diff --git a/Android.mk b/Android.mk
index 20f3944..4c67293 100644
--- a/Android.mk
+++ b/Android.mk
@@ -3,7 +3,7 @@
 
 LOCAL_MODULE_TAGS := optional
 
-incallui_dir := ../InCallUI
+incallui_dir := InCallUI
 contacts_common_dir := ../ContactsCommon
 phone_common_dir := ../PhoneCommon
 
diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 440c341..e7c17cb 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -17,8 +17,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.android.dialer"
     coreApp="true"
-    android:versionCode="20401"
-    android:versionName="2.04.01">
+    android:versionCode="20500"
+    android:versionName="2.05.00">
 
     <uses-sdk
         android:minSdkVersion="23"
@@ -67,7 +67,9 @@
         android:hardwareAccelerated="true"
         android:supportsRtl="true"
         android:backupAgent='com.android.dialer.DialerBackupAgent'
-        android:usesCleartextTraffic="false">
+        android:usesCleartextTraffic="false"
+        android:forceDeviceEncrypted="true"
+        android:encryptionAware="true">
 
         <meta-data android:name="com.google.android.backup.api_key"
             android:value="AEdPqrEAAAAIBXgtCEKQ6W0PXVnW-ZVia2KmlV2AxsTw3GjAeQ" />
@@ -81,7 +83,9 @@
             android:launchMode="singleTask"
             android:clearTaskOnLaunch="true"
             android:icon="@mipmap/ic_launcher_phone"
-            android:windowSoftInputMode="stateAlwaysHidden|adjustNothing">
+            android:windowSoftInputMode="stateAlwaysHidden|adjustNothing"
+            android:resizeableActivity="true"
+            >
             <intent-filter>
                 <action android:name="android.intent.action.DIAL" />
                 <category android:name="android.intent.category.DEFAULT" />
diff --git a/InCallUI/proguard.flags b/InCallUI/proguard.flags
new file mode 100644
index 0000000..4e8310c
--- /dev/null
+++ b/InCallUI/proguard.flags
@@ -0,0 +1,14 @@
+-keep class com.android.incallui.widget.multiwaveview.* {
+  *;
+}
+
+# Keep names that are used only by animation framework.
+-keepclasseswithmembers class com.android.incallui.AnimationUtils$CrossFadeDrawable {
+    *** setCrossFadeAlpha(...);
+}
+
+# Any class or method annotated with NeededForTesting or NeededForReflection.
+-keepclassmembers class * {
+@com.android.contacts.common.test.NeededForTesting *;
+@com.android.incallui.NeededForReflection *;
+}
diff --git a/InCallUI/res/anim/activity_open_enter.xml b/InCallUI/res/anim/activity_open_enter.xml
new file mode 100644
index 0000000..303b9dd
--- /dev/null
+++ b/InCallUI/res/anim/activity_open_enter.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+        android:shareInterpolator="false"
+        android:zAdjustment="top">
+    <alpha android:fromAlpha="0.0" android:toAlpha="1.0"
+            android:interpolator="@anim/decelerate_cubic"
+            android:fillEnabled="true"
+            android:fillBefore="false" android:fillAfter="true"
+            android:duration="300"/>
+    <scale android:fromXScale=".8" android:toXScale="1.0"
+            android:fromYScale=".8" android:toYScale="1.0"
+            android:pivotX="50%p" android:pivotY="50%p"
+            android:interpolator="@anim/decelerate_cubic"
+            android:fillEnabled="true"
+            android:fillBefore="false" android:fillAfter="true"
+            android:duration="300"/>
+</set>
\ No newline at end of file
diff --git a/InCallUI/res/anim/activity_open_exit.xml b/InCallUI/res/anim/activity_open_exit.xml
new file mode 100644
index 0000000..afa7c5e
--- /dev/null
+++ b/InCallUI/res/anim/activity_open_exit.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2009, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+        android:background="#ff000000" android:zAdjustment="normal">
+    <alpha android:fromAlpha="1.0" android:toAlpha="0.0"
+            android:fillEnabled="true" android:fillBefore="false" android:fillAfter="true"
+            android:interpolator="@anim/decelerate_quint"
+            android:duration="300"/>
+</set>
\ No newline at end of file
diff --git a/InCallUI/res/anim/call_status_pulse.xml b/InCallUI/res/anim/call_status_pulse.xml
new file mode 100644
index 0000000..abda25b
--- /dev/null
+++ b/InCallUI/res/anim/call_status_pulse.xml
@@ -0,0 +1,22 @@
+<?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
+  -->
+<alpha xmlns:android="http://schemas.android.com/apk/res/android"
+    android:fromAlpha="0.5"
+    android:toAlpha="1"
+    android:duration="600"
+    android:repeatCount="infinite"
+    android:repeatMode="reverse" />
diff --git a/InCallUI/res/anim/decelerate_cubic.xml b/InCallUI/res/anim/decelerate_cubic.xml
new file mode 100644
index 0000000..f988091
--- /dev/null
+++ b/InCallUI/res/anim/decelerate_cubic.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2010, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<decelerateInterpolator xmlns:android="http://schemas.android.com/apk/res/android"
+        android:factor="1.5" />
diff --git a/InCallUI/res/anim/decelerate_quint.xml b/InCallUI/res/anim/decelerate_quint.xml
new file mode 100644
index 0000000..ff2d5a9
--- /dev/null
+++ b/InCallUI/res/anim/decelerate_quint.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+** Copyright 2010, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<decelerateInterpolator xmlns:android="http://schemas.android.com/apk/res/android"
+        android:factor="2.5" />
diff --git a/InCallUI/res/color/ota_title_color.xml b/InCallUI/res/color/ota_title_color.xml
new file mode 100644
index 0000000..14a283a
--- /dev/null
+++ b/InCallUI/res/color/ota_title_color.xml
@@ -0,0 +1,21 @@
+<?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
+  -->
+
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:color="#FFA6C839"/>
+</selector>
+
diff --git a/InCallUI/res/color/selectable_icon_tint.xml b/InCallUI/res/color/selectable_icon_tint.xml
new file mode 100644
index 0000000..b8aad13
--- /dev/null
+++ b/InCallUI/res/color/selectable_icon_tint.xml
@@ -0,0 +1,24 @@
+<?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
+  -->
+
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:color="@color/button_disabled_color" android:state_enabled="false" />
+    <item android:color="@color/incall_accent_color" android:state_selected="true" />
+    <item android:color="@color/incall_accent_color" android:state_pressed="true" />
+    <item android:color="@color/button_default_color" />
+</selector>
+
diff --git a/InCallUI/res/drawable-hdpi/fab_blue.png b/InCallUI/res/drawable-hdpi/fab_blue.png
new file mode 100644
index 0000000..8ff3d29
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/fab_blue.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/fab_ic_call.png b/InCallUI/res/drawable-hdpi/fab_ic_call.png
new file mode 100644
index 0000000..548a391
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/fab_ic_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/fab_ic_end_call.png b/InCallUI/res/drawable-hdpi/fab_ic_end_call.png
new file mode 100644
index 0000000..b7f54d3
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/fab_ic_end_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/fab_ic_message.png b/InCallUI/res/drawable-hdpi/fab_ic_message.png
new file mode 100644
index 0000000..a1cf2ad
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/fab_ic_message.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/fab_red.png b/InCallUI/res/drawable-hdpi/fab_red.png
new file mode 100644
index 0000000..497cc79
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/fab_red.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_business_white_24dp.png b/InCallUI/res/drawable-hdpi/ic_business_white_24dp.png
new file mode 100644
index 0000000..d10ebb7
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_business_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_call_end_white_24dp.png b/InCallUI/res/drawable-hdpi/ic_call_end_white_24dp.png
new file mode 100644
index 0000000..757d339
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_call_end_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_call_split_white_24dp.png b/InCallUI/res/drawable-hdpi/ic_call_split_white_24dp.png
new file mode 100644
index 0000000..4e3dbf5
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_call_split_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_call_white_24dp.png b/InCallUI/res/drawable-hdpi/ic_call_white_24dp.png
new file mode 100644
index 0000000..1902e72
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_call_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_forward_white_24dp.png b/InCallUI/res/drawable-hdpi/ic_forward_white_24dp.png
new file mode 100644
index 0000000..a0711d3
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_forward_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_hd_24dp.png b/InCallUI/res/drawable-hdpi/ic_hd_24dp.png
new file mode 100644
index 0000000..35bf51a
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_hd_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_location_on_white_24dp.png b/InCallUI/res/drawable-hdpi/ic_location_on_white_24dp.png
new file mode 100644
index 0000000..7c281c3
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_location_on_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_lockscreen_glowdot.png b/InCallUI/res/drawable-hdpi/ic_lockscreen_glowdot.png
new file mode 100644
index 0000000..983c45e
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_lockscreen_glowdot.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_phone_paused_white_24dp.png b/InCallUI/res/drawable-hdpi/ic_phone_paused_white_24dp.png
new file mode 100644
index 0000000..a2177f5
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_phone_paused_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_schedule_white_24dp.png b/InCallUI/res/drawable-hdpi/ic_schedule_white_24dp.png
new file mode 100644
index 0000000..f3581d1
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_schedule_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_add_call.png b/InCallUI/res/drawable-hdpi/ic_toolbar_add_call.png
new file mode 100644
index 0000000..06603f2
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_add_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_arrow_whitespace.png b/InCallUI/res/drawable-hdpi/ic_toolbar_arrow_whitespace.png
new file mode 100644
index 0000000..ea02daa
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_arrow_whitespace.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_audio_bluetooth.png b/InCallUI/res/drawable-hdpi/ic_toolbar_audio_bluetooth.png
new file mode 100644
index 0000000..05e19bc
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_audio_bluetooth.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_audio_headphones.png b/InCallUI/res/drawable-hdpi/ic_toolbar_audio_headphones.png
new file mode 100644
index 0000000..413fdff
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_audio_headphones.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_audio_phone.png b/InCallUI/res/drawable-hdpi/ic_toolbar_audio_phone.png
new file mode 100644
index 0000000..90ee1fb
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_audio_phone.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_dialpad.png b/InCallUI/res/drawable-hdpi/ic_toolbar_dialpad.png
new file mode 100644
index 0000000..69ece11
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_dialpad.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_hold.png b/InCallUI/res/drawable-hdpi/ic_toolbar_hold.png
new file mode 100644
index 0000000..f32d6d5
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_hold.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_merge.png b/InCallUI/res/drawable-hdpi/ic_toolbar_merge.png
new file mode 100644
index 0000000..2871555
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_merge.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_mic_off.png b/InCallUI/res/drawable-hdpi/ic_toolbar_mic_off.png
new file mode 100644
index 0000000..b142ca8
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_mic_off.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_speaker_on.png b/InCallUI/res/drawable-hdpi/ic_toolbar_speaker_on.png
new file mode 100644
index 0000000..c934b13
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_speaker_on.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_swap.png b/InCallUI/res/drawable-hdpi/ic_toolbar_swap.png
new file mode 100644
index 0000000..e673f32
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_swap.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_video.png b/InCallUI/res/drawable-hdpi/ic_toolbar_video.png
new file mode 100644
index 0000000..cef47aa
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_video.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_video_off.png b/InCallUI/res/drawable-hdpi/ic_toolbar_video_off.png
new file mode 100644
index 0000000..968ded7
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_video_off.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/ic_toolbar_video_switch.png b/InCallUI/res/drawable-hdpi/ic_toolbar_video_switch.png
new file mode 100644
index 0000000..cdd623d
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/ic_toolbar_video_switch.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/img_business.png b/InCallUI/res/drawable-hdpi/img_business.png
new file mode 100644
index 0000000..f706342
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/img_business.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/img_conference.png b/InCallUI/res/drawable-hdpi/img_conference.png
new file mode 100644
index 0000000..3d9f683
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/img_conference.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/img_no_image.png b/InCallUI/res/drawable-hdpi/img_no_image.png
new file mode 100644
index 0000000..fd0ab32
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/img_no_image.png
Binary files differ
diff --git a/InCallUI/res/drawable-hdpi/img_phone.png b/InCallUI/res/drawable-hdpi/img_phone.png
new file mode 100644
index 0000000..748312e
--- /dev/null
+++ b/InCallUI/res/drawable-hdpi/img_phone.png
Binary files differ
diff --git a/InCallUI/res/drawable-land/rounded_call_card_background.xml b/InCallUI/res/drawable-land/rounded_call_card_background.xml
new file mode 100644
index 0000000..f41ecda
--- /dev/null
+++ b/InCallUI/res/drawable-land/rounded_call_card_background.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="@color/incall_call_banner_background_color" />
+    <corners
+        android:radius="4dp" />
+</shape>
\ No newline at end of file
diff --git a/InCallUI/res/drawable-mdpi/fab_blue.png b/InCallUI/res/drawable-mdpi/fab_blue.png
new file mode 100644
index 0000000..2ca6b4b
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/fab_blue.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/fab_ic_call.png b/InCallUI/res/drawable-mdpi/fab_ic_call.png
new file mode 100644
index 0000000..ff7b345
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/fab_ic_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/fab_ic_end_call.png b/InCallUI/res/drawable-mdpi/fab_ic_end_call.png
new file mode 100644
index 0000000..76ce397
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/fab_ic_end_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/fab_ic_message.png b/InCallUI/res/drawable-mdpi/fab_ic_message.png
new file mode 100644
index 0000000..74876fe
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/fab_ic_message.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/fab_red.png b/InCallUI/res/drawable-mdpi/fab_red.png
new file mode 100644
index 0000000..c9e76a0
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/fab_red.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_business_white_24dp.png b/InCallUI/res/drawable-mdpi/ic_business_white_24dp.png
new file mode 100644
index 0000000..7b9227c
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_business_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_call_end_white_24dp.png b/InCallUI/res/drawable-mdpi/ic_call_end_white_24dp.png
new file mode 100644
index 0000000..17eb482
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_call_end_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_call_split_white_24dp.png b/InCallUI/res/drawable-mdpi/ic_call_split_white_24dp.png
new file mode 100644
index 0000000..cb7ee1f
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_call_split_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_call_white_24dp.png b/InCallUI/res/drawable-mdpi/ic_call_white_24dp.png
new file mode 100644
index 0000000..d4e5f5d
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_call_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_forward_white_24dp.png b/InCallUI/res/drawable-mdpi/ic_forward_white_24dp.png
new file mode 100644
index 0000000..65f7329
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_forward_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_hd_24dp.png b/InCallUI/res/drawable-mdpi/ic_hd_24dp.png
new file mode 100644
index 0000000..30938fe
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_hd_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_location_on_white_24dp.png b/InCallUI/res/drawable-mdpi/ic_location_on_white_24dp.png
new file mode 100644
index 0000000..933eb51
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_location_on_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_lockscreen_glowdot.png b/InCallUI/res/drawable-mdpi/ic_lockscreen_glowdot.png
new file mode 100644
index 0000000..056c3f1
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_lockscreen_glowdot.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_phone_paused_white_24dp.png b/InCallUI/res/drawable-mdpi/ic_phone_paused_white_24dp.png
new file mode 100644
index 0000000..7dc920b
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_phone_paused_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_schedule_white_24dp.png b/InCallUI/res/drawable-mdpi/ic_schedule_white_24dp.png
new file mode 100644
index 0000000..501ee84
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_schedule_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_add_call.png b/InCallUI/res/drawable-mdpi/ic_toolbar_add_call.png
new file mode 100644
index 0000000..1ee2fb1
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_add_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_arrow_whitespace.png b/InCallUI/res/drawable-mdpi/ic_toolbar_arrow_whitespace.png
new file mode 100644
index 0000000..c39990d
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_arrow_whitespace.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_audio_bluetooth.png b/InCallUI/res/drawable-mdpi/ic_toolbar_audio_bluetooth.png
new file mode 100644
index 0000000..a6634ed
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_audio_bluetooth.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_audio_headphones.png b/InCallUI/res/drawable-mdpi/ic_toolbar_audio_headphones.png
new file mode 100644
index 0000000..b387e85
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_audio_headphones.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_audio_phone.png b/InCallUI/res/drawable-mdpi/ic_toolbar_audio_phone.png
new file mode 100644
index 0000000..b4d887c
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_audio_phone.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_dialpad.png b/InCallUI/res/drawable-mdpi/ic_toolbar_dialpad.png
new file mode 100644
index 0000000..9baa21b
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_dialpad.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_hold.png b/InCallUI/res/drawable-mdpi/ic_toolbar_hold.png
new file mode 100644
index 0000000..c837273
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_hold.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_merge.png b/InCallUI/res/drawable-mdpi/ic_toolbar_merge.png
new file mode 100644
index 0000000..2fba865
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_merge.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_mic_off.png b/InCallUI/res/drawable-mdpi/ic_toolbar_mic_off.png
new file mode 100644
index 0000000..c6b02b8
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_mic_off.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_speaker_on.png b/InCallUI/res/drawable-mdpi/ic_toolbar_speaker_on.png
new file mode 100644
index 0000000..008e245
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_speaker_on.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_swap.png b/InCallUI/res/drawable-mdpi/ic_toolbar_swap.png
new file mode 100644
index 0000000..acc9850
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_swap.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_video.png b/InCallUI/res/drawable-mdpi/ic_toolbar_video.png
new file mode 100644
index 0000000..3f13f9c
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_video.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_video_off.png b/InCallUI/res/drawable-mdpi/ic_toolbar_video_off.png
new file mode 100644
index 0000000..64a69f2
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_video_off.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/ic_toolbar_video_switch.png b/InCallUI/res/drawable-mdpi/ic_toolbar_video_switch.png
new file mode 100644
index 0000000..6d097c9
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/ic_toolbar_video_switch.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/img_business.png b/InCallUI/res/drawable-mdpi/img_business.png
new file mode 100644
index 0000000..90738a7
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/img_business.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/img_conference.png b/InCallUI/res/drawable-mdpi/img_conference.png
new file mode 100644
index 0000000..0694dbd
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/img_conference.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/img_no_image.png b/InCallUI/res/drawable-mdpi/img_no_image.png
new file mode 100644
index 0000000..014a1c4
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/img_no_image.png
Binary files differ
diff --git a/InCallUI/res/drawable-mdpi/img_phone.png b/InCallUI/res/drawable-mdpi/img_phone.png
new file mode 100644
index 0000000..41a1d33
--- /dev/null
+++ b/InCallUI/res/drawable-mdpi/img_phone.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/fab_blue.png b/InCallUI/res/drawable-xhdpi/fab_blue.png
new file mode 100644
index 0000000..300b07e
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/fab_blue.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/fab_ic_call.png b/InCallUI/res/drawable-xhdpi/fab_ic_call.png
new file mode 100644
index 0000000..2bff65e
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/fab_ic_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/fab_ic_end_call.png b/InCallUI/res/drawable-xhdpi/fab_ic_end_call.png
new file mode 100644
index 0000000..1c95e17
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/fab_ic_end_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/fab_ic_message.png b/InCallUI/res/drawable-xhdpi/fab_ic_message.png
new file mode 100644
index 0000000..5e3334a
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/fab_ic_message.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/fab_red.png b/InCallUI/res/drawable-xhdpi/fab_red.png
new file mode 100644
index 0000000..373e49e
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/fab_red.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_business_white_24dp.png b/InCallUI/res/drawable-xhdpi/ic_business_white_24dp.png
new file mode 100644
index 0000000..e563045
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_business_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_call_end_white_24dp.png b/InCallUI/res/drawable-xhdpi/ic_call_end_white_24dp.png
new file mode 100644
index 0000000..b00d82e
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_call_end_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_call_split_white_24dp.png b/InCallUI/res/drawable-xhdpi/ic_call_split_white_24dp.png
new file mode 100644
index 0000000..218cb12
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_call_split_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_call_white_24dp.png b/InCallUI/res/drawable-xhdpi/ic_call_white_24dp.png
new file mode 100644
index 0000000..cde9cea
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_call_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_forward_white_24dp.png b/InCallUI/res/drawable-xhdpi/ic_forward_white_24dp.png
new file mode 100644
index 0000000..7a5df52
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_forward_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_hd_24dp.png b/InCallUI/res/drawable-xhdpi/ic_hd_24dp.png
new file mode 100644
index 0000000..4c954d8
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_hd_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_location_on_white_24dp.png b/InCallUI/res/drawable-xhdpi/ic_location_on_white_24dp.png
new file mode 100644
index 0000000..814ca8d
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_location_on_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_lockscreen_glowdot.png b/InCallUI/res/drawable-xhdpi/ic_lockscreen_glowdot.png
new file mode 100644
index 0000000..cbd039a
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_lockscreen_glowdot.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_phone_paused_white_24dp.png b/InCallUI/res/drawable-xhdpi/ic_phone_paused_white_24dp.png
new file mode 100644
index 0000000..a8becf4
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_phone_paused_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_schedule_white_24dp.png b/InCallUI/res/drawable-xhdpi/ic_schedule_white_24dp.png
new file mode 100644
index 0000000..2e27936
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_schedule_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_add_call.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_add_call.png
new file mode 100644
index 0000000..b251d6b
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_add_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_arrow_whitespace.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_arrow_whitespace.png
new file mode 100644
index 0000000..cdaa79d
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_arrow_whitespace.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_audio_bluetooth.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_audio_bluetooth.png
new file mode 100644
index 0000000..88f6bb9
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_audio_bluetooth.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_audio_headphones.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_audio_headphones.png
new file mode 100644
index 0000000..1acfcaf
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_audio_headphones.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_audio_phone.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_audio_phone.png
new file mode 100644
index 0000000..0ba8f1e
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_audio_phone.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_dialpad.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_dialpad.png
new file mode 100644
index 0000000..cf803d1
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_dialpad.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_hold.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_hold.png
new file mode 100644
index 0000000..8fecf75
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_hold.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_merge.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_merge.png
new file mode 100644
index 0000000..777483e
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_merge.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_mic_off.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_mic_off.png
new file mode 100644
index 0000000..cf2041a
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_mic_off.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_speaker_on.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_speaker_on.png
new file mode 100644
index 0000000..5b5831c
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_speaker_on.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_swap.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_swap.png
new file mode 100644
index 0000000..38917cb
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_swap.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_video.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_video.png
new file mode 100644
index 0000000..b20f504
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_video.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_video_off.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_video_off.png
new file mode 100644
index 0000000..1b269a6
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_video_off.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/ic_toolbar_video_switch.png b/InCallUI/res/drawable-xhdpi/ic_toolbar_video_switch.png
new file mode 100644
index 0000000..fae6bfd
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/ic_toolbar_video_switch.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/img_business.png b/InCallUI/res/drawable-xhdpi/img_business.png
new file mode 100644
index 0000000..7b04d95
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/img_business.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/img_conference.png b/InCallUI/res/drawable-xhdpi/img_conference.png
new file mode 100644
index 0000000..b0dbcc2
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/img_conference.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/img_no_image.png b/InCallUI/res/drawable-xhdpi/img_no_image.png
new file mode 100644
index 0000000..4022207
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/img_no_image.png
Binary files differ
diff --git a/InCallUI/res/drawable-xhdpi/img_phone.png b/InCallUI/res/drawable-xhdpi/img_phone.png
new file mode 100644
index 0000000..2e0ceec
--- /dev/null
+++ b/InCallUI/res/drawable-xhdpi/img_phone.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/fab_blue.png b/InCallUI/res/drawable-xxhdpi/fab_blue.png
new file mode 100644
index 0000000..76d68ac
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/fab_blue.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/fab_ic_call.png b/InCallUI/res/drawable-xxhdpi/fab_ic_call.png
new file mode 100644
index 0000000..a756b95
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/fab_ic_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/fab_ic_end_call.png b/InCallUI/res/drawable-xxhdpi/fab_ic_end_call.png
new file mode 100644
index 0000000..37e8264
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/fab_ic_end_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/fab_ic_message.png b/InCallUI/res/drawable-xxhdpi/fab_ic_message.png
new file mode 100644
index 0000000..66984b1
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/fab_ic_message.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/fab_red.png b/InCallUI/res/drawable-xxhdpi/fab_red.png
new file mode 100644
index 0000000..92eb979
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/fab_red.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_business_white_24dp.png b/InCallUI/res/drawable-xxhdpi/ic_business_white_24dp.png
new file mode 100644
index 0000000..7dfc8dc
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_business_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_call_end_white_24dp.png b/InCallUI/res/drawable-xxhdpi/ic_call_end_white_24dp.png
new file mode 100644
index 0000000..aeabe4a
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_call_end_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_call_split_white_24dp.png b/InCallUI/res/drawable-xxhdpi/ic_call_split_white_24dp.png
new file mode 100644
index 0000000..5ea5777
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_call_split_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_call_white_24dp.png b/InCallUI/res/drawable-xxhdpi/ic_call_white_24dp.png
new file mode 100644
index 0000000..b761bc4
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_call_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_forward_white_24dp.png b/InCallUI/res/drawable-xxhdpi/ic_forward_white_24dp.png
new file mode 100644
index 0000000..7bd5b16
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_forward_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_hd_24dp.png b/InCallUI/res/drawable-xxhdpi/ic_hd_24dp.png
new file mode 100644
index 0000000..dd08bbb
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_hd_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_location_on_white_24dp.png b/InCallUI/res/drawable-xxhdpi/ic_location_on_white_24dp.png
new file mode 100644
index 0000000..078b10d
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_location_on_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_lockscreen_glowdot.png b/InCallUI/res/drawable-xxhdpi/ic_lockscreen_glowdot.png
new file mode 100644
index 0000000..c0edd91
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_lockscreen_glowdot.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_phone_paused_white_24dp.png b/InCallUI/res/drawable-xxhdpi/ic_phone_paused_white_24dp.png
new file mode 100644
index 0000000..baf0cf2
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_phone_paused_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_schedule_white_24dp.png b/InCallUI/res/drawable-xxhdpi/ic_schedule_white_24dp.png
new file mode 100644
index 0000000..bfc7273
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_schedule_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_add_call.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_add_call.png
new file mode 100644
index 0000000..6e343c7
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_add_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_arrow_whitespace.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_arrow_whitespace.png
new file mode 100644
index 0000000..7377040
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_arrow_whitespace.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_audio_bluetooth.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_audio_bluetooth.png
new file mode 100644
index 0000000..b8a385d
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_audio_bluetooth.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_audio_headphones.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_audio_headphones.png
new file mode 100644
index 0000000..62d0ae3
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_audio_headphones.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_audio_phone.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_audio_phone.png
new file mode 100644
index 0000000..0e88501
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_audio_phone.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_dialpad.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_dialpad.png
new file mode 100644
index 0000000..a754f68
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_dialpad.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_hold.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_hold.png
new file mode 100644
index 0000000..f3757a8
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_hold.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_merge.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_merge.png
new file mode 100644
index 0000000..5d04600
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_merge.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_mic_off.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_mic_off.png
new file mode 100644
index 0000000..ae41d5c
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_mic_off.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_speaker_on.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_speaker_on.png
new file mode 100644
index 0000000..d1bbb09
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_speaker_on.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_swap.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_swap.png
new file mode 100644
index 0000000..ea9127e
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_swap.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_video.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_video.png
new file mode 100644
index 0000000..5c52dd6
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_video.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_video_off.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_video_off.png
new file mode 100644
index 0000000..898b7c0
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_video_off.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/ic_toolbar_video_switch.png b/InCallUI/res/drawable-xxhdpi/ic_toolbar_video_switch.png
new file mode 100644
index 0000000..4380a47
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/ic_toolbar_video_switch.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/img_business.png b/InCallUI/res/drawable-xxhdpi/img_business.png
new file mode 100644
index 0000000..c17e4c9
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/img_business.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/img_conference.png b/InCallUI/res/drawable-xxhdpi/img_conference.png
new file mode 100644
index 0000000..a8dba5e
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/img_conference.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/img_no_image.png b/InCallUI/res/drawable-xxhdpi/img_no_image.png
new file mode 100644
index 0000000..2cf7f23
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/img_no_image.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxhdpi/img_phone.png b/InCallUI/res/drawable-xxhdpi/img_phone.png
new file mode 100644
index 0000000..4eaaba5
--- /dev/null
+++ b/InCallUI/res/drawable-xxhdpi/img_phone.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/fab_blue.png b/InCallUI/res/drawable-xxxhdpi/fab_blue.png
new file mode 100644
index 0000000..1dd8a92
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/fab_blue.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/fab_ic_call.png b/InCallUI/res/drawable-xxxhdpi/fab_ic_call.png
new file mode 100644
index 0000000..7af3396
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/fab_ic_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/fab_ic_end_call.png b/InCallUI/res/drawable-xxxhdpi/fab_ic_end_call.png
new file mode 100644
index 0000000..aabdade
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/fab_ic_end_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/fab_ic_message.png b/InCallUI/res/drawable-xxxhdpi/fab_ic_message.png
new file mode 100644
index 0000000..c5a108a
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/fab_ic_message.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/fab_red.png b/InCallUI/res/drawable-xxxhdpi/fab_red.png
new file mode 100644
index 0000000..f1b36f7
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/fab_red.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_business_white_24dp.png b/InCallUI/res/drawable-xxxhdpi/ic_business_white_24dp.png
new file mode 100644
index 0000000..c9aea72
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_business_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_call_end_white_24dp.png b/InCallUI/res/drawable-xxxhdpi/ic_call_end_white_24dp.png
new file mode 100644
index 0000000..a6e8a7b
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_call_end_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_call_split_white_24dp.png b/InCallUI/res/drawable-xxxhdpi/ic_call_split_white_24dp.png
new file mode 100644
index 0000000..600cec8
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_call_split_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_forward_white_24dp.png b/InCallUI/res/drawable-xxxhdpi/ic_forward_white_24dp.png
new file mode 100644
index 0000000..428009c
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_forward_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_hd_24dp.png b/InCallUI/res/drawable-xxxhdpi/ic_hd_24dp.png
new file mode 100644
index 0000000..3f87b88
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_hd_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_location_on_white_24dp.png b/InCallUI/res/drawable-xxxhdpi/ic_location_on_white_24dp.png
new file mode 100644
index 0000000..8bcb6f6
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_location_on_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_schedule_white_24dp.png b/InCallUI/res/drawable-xxxhdpi/ic_schedule_white_24dp.png
new file mode 100644
index 0000000..b94f4df
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_schedule_white_24dp.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_add_call.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_add_call.png
new file mode 100644
index 0000000..c97e4bb
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_add_call.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_arrow_whitespace.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_arrow_whitespace.png
new file mode 100644
index 0000000..1c11c5d
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_arrow_whitespace.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_audio_bluetooth.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_audio_bluetooth.png
new file mode 100644
index 0000000..f7fa12c
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_audio_bluetooth.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_audio_headphones.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_audio_headphones.png
new file mode 100644
index 0000000..8199701
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_audio_headphones.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_audio_phone.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_audio_phone.png
new file mode 100644
index 0000000..ee14ea6
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_audio_phone.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_dialpad.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_dialpad.png
new file mode 100644
index 0000000..e537112
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_dialpad.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_hold.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_hold.png
new file mode 100644
index 0000000..883d0d6
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_hold.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_merge.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_merge.png
new file mode 100644
index 0000000..4b64375
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_merge.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_mic_off.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_mic_off.png
new file mode 100644
index 0000000..2d8f279
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_mic_off.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_speaker_on.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_speaker_on.png
new file mode 100644
index 0000000..0560bb2
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_speaker_on.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_swap.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_swap.png
new file mode 100644
index 0000000..6f03b3f
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_swap.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_video.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_video.png
new file mode 100644
index 0000000..0797fd0
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_video.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_video_off.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_video_off.png
new file mode 100644
index 0000000..63f742b
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_video_off.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/ic_toolbar_video_switch.png b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_video_switch.png
new file mode 100644
index 0000000..77ff73c
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/ic_toolbar_video_switch.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/img_business.png b/InCallUI/res/drawable-xxxhdpi/img_business.png
new file mode 100644
index 0000000..88f14e9
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/img_business.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/img_conference.png b/InCallUI/res/drawable-xxxhdpi/img_conference.png
new file mode 100644
index 0000000..eb42b55
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/img_conference.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/img_no_image.png b/InCallUI/res/drawable-xxxhdpi/img_no_image.png
new file mode 100644
index 0000000..2165742
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/img_no_image.png
Binary files differ
diff --git a/InCallUI/res/drawable-xxxhdpi/img_phone.png b/InCallUI/res/drawable-xxxhdpi/img_phone.png
new file mode 100644
index 0000000..7cbfbd7
--- /dev/null
+++ b/InCallUI/res/drawable-xxxhdpi/img_phone.png
Binary files differ
diff --git a/InCallUI/res/drawable/btn_add.xml b/InCallUI/res/drawable/btn_add.xml
new file mode 100644
index 0000000..7d5e90f
--- /dev/null
+++ b/InCallUI/res/drawable/btn_add.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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <item android:id="@+id/backgroundItem"
+          android:drawable="@drawable/btn_background" />
+
+    <item>
+        <bitmap android:src="@drawable/ic_toolbar_add_call"
+            android:gravity="center"
+            android:tint="@color/selectable_icon_tint" />
+    </item>
+
+</layer-list>
\ No newline at end of file
diff --git a/InCallUI/res/drawable/btn_background.xml b/InCallUI/res/drawable/btn_background.xml
new file mode 100644
index 0000000..5978858
--- /dev/null
+++ b/InCallUI/res/drawable/btn_background.xml
@@ -0,0 +1,33 @@
+<?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
+  -->
+
+<!-- Background resource for "compound buttons" in the in-call UI.
+     These buttons have two states (checked and unchecked), and
+     show a blue bar along the bottom edge when checked. -->
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@color/incall_accent_color">
+    <item>
+        <selector>
+
+            <item android:state_focused="true"
+                  android:drawable="@drawable/btn_unselected_focused" />
+
+            <item android:drawable="@drawable/btn_unselected" />
+
+        </selector>
+    </item>
+</ripple>
diff --git a/InCallUI/res/drawable/btn_change_to_video.xml b/InCallUI/res/drawable/btn_change_to_video.xml
new file mode 100644
index 0000000..a26cee3
--- /dev/null
+++ b/InCallUI/res/drawable/btn_change_to_video.xml
@@ -0,0 +1,31 @@
+<?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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <item android:id="@+id/backgroundItem"
+          android:drawable="@drawable/btn_background" />
+
+    <item>
+        <bitmap android:src="@drawable/ic_toolbar_video"
+            android:gravity="center"
+            android:tint="@color/selectable_icon_tint"
+            android:autoMirrored="true" />
+    </item>
+
+</layer-list>
\ No newline at end of file
diff --git a/InCallUI/res/drawable/btn_change_to_voice.xml b/InCallUI/res/drawable/btn_change_to_voice.xml
new file mode 100644
index 0000000..86a7f21
--- /dev/null
+++ b/InCallUI/res/drawable/btn_change_to_voice.xml
@@ -0,0 +1,31 @@
+<?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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <item android:id="@+id/backgroundItem"
+          android:drawable="@drawable/btn_background" />
+
+    <item>
+        <bitmap android:src="@drawable/ic_toolbar_audio_phone"
+            android:gravity="center"
+            android:tint="@color/selectable_icon_tint"
+            android:autoMirrored="true" />
+    </item>
+
+</layer-list>
\ No newline at end of file
diff --git a/InCallUI/res/drawable/btn_compound_audio.xml b/InCallUI/res/drawable/btn_compound_audio.xml
new file mode 100644
index 0000000..25a64a6
--- /dev/null
+++ b/InCallUI/res/drawable/btn_compound_audio.xml
@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- Layers used to render the in-call "Audio mode" compound button.
+
+     This is a multi-mode button:
+
+     - If no bluetooth headset is connected, it behaves like a simple
+       "compound button" that switches the speaker on and off.  (This is why
+       the button itself is a ToggleButton instance.)
+
+     - But if a bluetooth headset is connected, this becomes a simple
+       action button (with no concept of a "checked" state) that brings
+       up a popup menu offering you a 3-way choice between earpiece /
+       speaker / bluetooth.
+
+     See InCallTouchUi.updateAudioButton() for the corresponding code. -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- The standard "compound button" background, used to distinguish
+         between the "checked" and "unchecked" states when this button is
+         simply an on/off toggle for the speaker.
+         (In states where the audio button *not* a toggle, we explicitly
+         hide this layer.) -->
+    <item android:id="@+id/compoundBackgroundItem"
+          android:drawable="@drawable/btn_compound_background" />
+
+    <!-- The little triangle that indicates that this isn't a plain
+         button, but will instead pop up a menu.  This layer is *not*
+         shown when the audio button is simply an on/off toggle. -->
+    <!-- Use an explicit <bitmap> to avoid scaling the icon up to the full
+         size of the button. -->
+    <item android:id="@+id/moreIndicatorItem">
+        <bitmap android:src="@drawable/ic_toolbar_arrow_whitespace"
+                android:gravity="center"
+                android:tint="@color/selectable_icon_tint" />
+    </item>
+
+    <!-- Finally, the button icon.
+
+         When the audio button is simply an on/off toggle for the speaker,
+         the icon is a "speakerphone" regardless of whether the speaker is
+         active.  (Instead, the "on/off" indication comes from the
+         btn_compound_background selector.)
+
+         But when the audio button is connected to the 3-way popup menu,
+         we use the button's icon to indicate the current audio mode
+         (i.e. one of { earpiece (or wired headset) , speaker , bluetooth }).
+
+         Here we have separate layers for each possible foreground icon,
+         and in InCallTouchUi.updateAudioButton() we hide them all
+         *except* the one needed for the current state. -->
+
+    <!-- These all use an explicit <bitmap> to avoid scaling the icon up
+         to the full size of the button. -->
+
+    <!-- Bluetooth is active -->
+    <item android:id="@+id/bluetoothItem">
+        <bitmap android:src="@drawable/ic_toolbar_audio_bluetooth"
+                android:gravity="center"
+                android:tint="@color/selectable_icon_tint" />
+    </item>
+
+
+    <!-- Handset earpiece is active -->
+    <item android:id="@+id/handsetItem">
+        <bitmap android:src="@drawable/ic_toolbar_audio_phone"
+                android:gravity="center"
+                android:tint="@color/selectable_icon_tint" />
+    </item>
+
+    <!-- Speakerphone icon showing 'speaker on' state -->
+    <item android:id="@+id/speakerphoneItem">
+        <bitmap android:src="@drawable/ic_toolbar_speaker_on"
+            android:gravity="center"
+            android:tint="@color/selectable_icon_tint" />
+    </item>
+
+</layer-list>
diff --git a/InCallUI/res/drawable/btn_compound_background.xml b/InCallUI/res/drawable/btn_compound_background.xml
new file mode 100644
index 0000000..20e2a30
--- /dev/null
+++ b/InCallUI/res/drawable/btn_compound_background.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- Background resource for "compound buttons" in the in-call UI.
+     These buttons have two states (selected and unselected). -->
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@color/incall_accent_color">
+    <item>
+        <selector>
+            <item android:state_selected="true" android:state_focused="true"
+                  android:drawable="@drawable/btn_selected_focused" />
+
+            <item android:state_focused="true"
+                  android:drawable="@drawable/btn_unselected_focused" />
+
+            <item android:state_selected="true"
+                android:drawable="@drawable/btn_selected" />
+
+            <item android:drawable="@drawable/btn_unselected" />
+        </selector>
+    </item>
+</ripple>
diff --git a/InCallUI/res/drawable/btn_compound_dialpad.xml b/InCallUI/res/drawable/btn_compound_dialpad.xml
new file mode 100644
index 0000000..1b78ead
--- /dev/null
+++ b/InCallUI/res/drawable/btn_compound_dialpad.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- Layers used to render the in-call "Dialpad" compound button. -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- The standard "compound button" background. -->
+    <item android:id="@+id/compoundBackgroundItem"
+          android:drawable="@drawable/btn_compound_background" />
+
+    <!-- ...and the actual icon on top.  Use an explicit <bitmap> to avoid scaling
+         the icon up to the full size of the button. -->
+    <item>
+        <bitmap android:src="@drawable/ic_toolbar_dialpad"
+                android:gravity="center"
+                android:tint="@color/selectable_icon_tint" />
+    </item>
+
+</layer-list>
diff --git a/InCallUI/res/drawable/btn_compound_hold.xml b/InCallUI/res/drawable/btn_compound_hold.xml
new file mode 100644
index 0000000..7974efa
--- /dev/null
+++ b/InCallUI/res/drawable/btn_compound_hold.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- Layers used to render the in-call "Hold" compound button. -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- The standard "compound button" background. -->
+    <item android:id="@+id/compoundBackgroundItem"
+          android:drawable="@drawable/btn_compound_background" />
+
+    <!-- ...and the actual icon on top.  Use an explicit <bitmap> to avoid scaling
+         the icon up to the full size of the button. -->
+    <item>
+        <bitmap android:src="@drawable/ic_toolbar_hold"
+                android:gravity="center"
+                android:tint="@color/selectable_icon_tint" />
+    </item>
+
+</layer-list>
diff --git a/InCallUI/res/drawable/btn_compound_mute.xml b/InCallUI/res/drawable/btn_compound_mute.xml
new file mode 100644
index 0000000..86708fb
--- /dev/null
+++ b/InCallUI/res/drawable/btn_compound_mute.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- Layers used to render the in-call "Mute" compound button. -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- The standard "compound button" background. -->
+    <item android:id="@+id/compoundBackgroundItem"
+          android:drawable="@drawable/btn_compound_background" />
+
+    <!-- Use an explicit <bitmap> to avoid scaling the icon up to the full size of the button. -->
+    <item>
+        <bitmap android:src="@drawable/ic_toolbar_mic_off"
+            android:gravity="center"
+            android:tint="@color/selectable_icon_tint" />
+    </item>
+
+</layer-list>
diff --git a/InCallUI/res/drawable/btn_compound_video_off.xml b/InCallUI/res/drawable/btn_compound_video_off.xml
new file mode 100644
index 0000000..b942cd0
--- /dev/null
+++ b/InCallUI/res/drawable/btn_compound_video_off.xml
@@ -0,0 +1,33 @@
+<?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
+  -->
+
+<!-- Layers used to render the in-call "Mute" compound button. -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- The standard "compound button" background. -->
+    <item android:id="@+id/compoundBackgroundItem"
+          android:drawable="@drawable/btn_compound_background" />
+
+    <!-- Use an explicit <bitmap> to avoid scaling the icon up to the full size of the button. -->
+    <item>
+        <bitmap android:src="@drawable/ic_toolbar_video_off"
+            android:gravity="center"
+            android:tint="@color/selectable_icon_tint"
+            android:autoMirrored="true" />
+    </item>
+
+</layer-list>
diff --git a/InCallUI/res/drawable/btn_compound_video_switch.xml b/InCallUI/res/drawable/btn_compound_video_switch.xml
new file mode 100644
index 0000000..f811186
--- /dev/null
+++ b/InCallUI/res/drawable/btn_compound_video_switch.xml
@@ -0,0 +1,33 @@
+<?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
+  -->
+
+<!-- Layers used to render the in-call "Mute" compound button. -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- The standard "compound button" background. -->
+    <item android:id="@+id/compoundBackgroundItem"
+          android:drawable="@drawable/btn_compound_background" />
+
+    <!-- Use an explicit <bitmap> to avoid scaling the icon up to the full size of the button. -->
+    <item>
+        <bitmap android:src="@drawable/ic_toolbar_video_switch"
+            android:gravity="center"
+            android:tint="@color/selectable_icon_tint"
+            android:autoMirrored="true" />
+    </item>
+
+</layer-list>
diff --git a/InCallUI/res/drawable/btn_merge.xml b/InCallUI/res/drawable/btn_merge.xml
new file mode 100644
index 0000000..2b4818a
--- /dev/null
+++ b/InCallUI/res/drawable/btn_merge.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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <item android:id="@+id/backgroundItem"
+          android:drawable="@drawable/btn_background" />
+
+    <item>
+        <bitmap android:src="@drawable/ic_toolbar_merge"
+            android:gravity="center"
+            android:tint="@color/selectable_icon_tint" />
+    </item>
+
+</layer-list>
\ No newline at end of file
diff --git a/InCallUI/res/drawable/btn_overflow.xml b/InCallUI/res/drawable/btn_overflow.xml
new file mode 100644
index 0000000..2eb26cc
--- /dev/null
+++ b/InCallUI/res/drawable/btn_overflow.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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <item android:id="@+id/backgroundItem"
+          android:drawable="@drawable/btn_background" />
+
+    <item>
+        <bitmap android:src="@drawable/ic_overflow_menu"
+            android:gravity="center"
+            android:tint="@color/selectable_icon_tint" />
+    </item>
+
+</layer-list>
\ No newline at end of file
diff --git a/InCallUI/res/drawable/btn_selected.xml b/InCallUI/res/drawable/btn_selected.xml
new file mode 100644
index 0000000..1446e41
--- /dev/null
+++ b/InCallUI/res/drawable/btn_selected.xml
@@ -0,0 +1,25 @@
+<?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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android" >
+    <item>
+        <shape android:shape="oval">
+            <solid android:color="@color/button_selected_color" />
+        </shape>
+    </item>
+</layer-list>
\ No newline at end of file
diff --git a/InCallUI/res/drawable/btn_selected_focused.xml b/InCallUI/res/drawable/btn_selected_focused.xml
new file mode 100644
index 0000000..2eda9bf
--- /dev/null
+++ b/InCallUI/res/drawable/btn_selected_focused.xml
@@ -0,0 +1,29 @@
+<?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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android" >
+    <item android:drawable="@drawable/btn_selected" />
+
+    <item>
+        <shape android:shape="oval" >
+            <stroke
+                android:width="4dp"
+                android:color="@color/focus_color" />
+        </shape>
+    </item>
+</layer-list>
\ No newline at end of file
diff --git a/InCallUI/res/drawable/btn_swap.xml b/InCallUI/res/drawable/btn_swap.xml
new file mode 100644
index 0000000..5d6c8ec
--- /dev/null
+++ b/InCallUI/res/drawable/btn_swap.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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <item android:id="@+id/backgroundItem"
+          android:drawable="@drawable/btn_background" />
+
+    <item>
+        <bitmap android:src="@drawable/ic_toolbar_swap"
+            android:gravity="center"
+            android:tint="@color/selectable_icon_tint" />
+    </item>
+
+</layer-list>
\ No newline at end of file
diff --git a/InCallUI/res/drawable/btn_unselected.xml b/InCallUI/res/drawable/btn_unselected.xml
new file mode 100644
index 0000000..aed995c
--- /dev/null
+++ b/InCallUI/res/drawable/btn_unselected.xml
@@ -0,0 +1,25 @@
+<?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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android" >
+    <item>
+        <shape android:shape="oval">
+            <solid android:color="@color/incall_background_color" />
+        </shape>
+    </item>
+</layer-list>
\ No newline at end of file
diff --git a/InCallUI/res/drawable/btn_unselected_focused.xml b/InCallUI/res/drawable/btn_unselected_focused.xml
new file mode 100644
index 0000000..66075d4
--- /dev/null
+++ b/InCallUI/res/drawable/btn_unselected_focused.xml
@@ -0,0 +1,28 @@
+<?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
+  -->
+
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android" >
+    <item android:drawable="@drawable/btn_unselected" />
+    <item>
+        <shape android:shape="oval" >
+            <stroke
+                android:width="4dp"
+                android:color="@color/focus_color" />
+        </shape>
+    </item>
+</layer-list>
\ No newline at end of file
diff --git a/InCallUI/res/drawable/conference_ripple.xml b/InCallUI/res/drawable/conference_ripple.xml
new file mode 100644
index 0000000..4e4a213
--- /dev/null
+++ b/InCallUI/res/drawable/conference_ripple.xml
@@ -0,0 +1,25 @@
+<!--
+  ~ 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/ripple_light">
+    <!-- Constrain the ripple to a rectangular area -->
+    <item>
+        <shape android:shape="rectangle">
+            <solid android:color="@color/background_dialer_white" />
+        </shape>
+    </item>
+</ripple>
\ No newline at end of file
diff --git a/InCallUI/res/drawable/end_call_background.xml b/InCallUI/res/drawable/end_call_background.xml
new file mode 100644
index 0000000..c43deac
--- /dev/null
+++ b/InCallUI/res/drawable/end_call_background.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- Background drawable used to render the "end call" button. -->
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@color/end_call_touch_feedback_tint">
+    <item android:id="@android:id/mask">
+        <shape android:shape="oval">
+            <solid android:color="@android:color/white" />
+        </shape>
+    </item>
+</ripple>
diff --git a/InCallUI/res/drawable/ic_incall_audio_handle.xml b/InCallUI/res/drawable/ic_incall_audio_handle.xml
new file mode 100644
index 0000000..2e71a5b
--- /dev/null
+++ b/InCallUI/res/drawable/ic_incall_audio_handle.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- Touch handle for the GlowPadView widget on the incoming call screen -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- Audio call icon on tinted floating action bar background. -->
+    <item
+        android:state_enabled="true"
+        android:state_active="false"
+        android:state_focused="false">
+        <layer-list>
+            <item>
+                <bitmap
+                    android:src="@drawable/fab_blue"
+                    android:tint="@color/glowpad_incoming_widget_background_tint" />
+            </item>
+            <item>
+                <bitmap
+                    android:gravity="center"
+                    android:src="@drawable/fab_ic_call"
+                    android:tint="@color/glowpad_incoming_widget_tint" />
+            </item>
+        </layer-list>
+    </item>
+
+</selector>
diff --git a/InCallUI/res/drawable/ic_incall_video_handle.xml b/InCallUI/res/drawable/ic_incall_video_handle.xml
new file mode 100644
index 0000000..a24e305
--- /dev/null
+++ b/InCallUI/res/drawable/ic_incall_video_handle.xml
@@ -0,0 +1,41 @@
+<?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
+  -->
+
+<!-- Touch handle for the GlowPadView widget on the incoming call screen -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- Video call icon on tinted floating action bar background. -->
+    <item
+        android:state_enabled="true"
+        android:state_active="false"
+        android:state_focused="false">
+        <layer-list>
+            <item>
+                <bitmap
+                    android:src="@drawable/fab_blue"
+                    android:tint="@color/glowpad_incoming_widget_background_tint" />
+            </item>
+            <item>
+                <bitmap
+                    android:gravity="center"
+                    android:src="@drawable/ic_videocam"
+                    android:tint="@color/glowpad_incoming_widget_tint" />
+            </item>
+        </layer-list>
+    </item>
+
+</selector>
diff --git a/InCallUI/res/drawable/ic_lockscreen_answer.xml b/InCallUI/res/drawable/ic_lockscreen_answer.xml
new file mode 100644
index 0000000..3184111
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_answer.xml
@@ -0,0 +1,27 @@
+<?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");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<!-- Used with incoming call wigdet. -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item
+        android:state_enabled="true" android:state_active="false" android:state_focused="false"
+        android:drawable="@drawable/ic_lockscreen_answer_normal_layer"/>
+    <item
+        android:state_enabled="true" android:state_active="true"  android:state_focused="false"
+        android:drawable="@drawable/ic_lockscreen_answer_activated_layer" />
+   <item
+        android:state_enabled="true" android:state_active="false"  android:state_focused="true"
+        android:drawable="@drawable/ic_lockscreen_answer_activated_layer" />
+</selector>
diff --git a/InCallUI/res/drawable/ic_lockscreen_answer_activated_layer.xml b/InCallUI/res/drawable/ic_lockscreen_answer_activated_layer.xml
new file mode 100644
index 0000000..f22b87e
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_answer_activated_layer.xml
@@ -0,0 +1,25 @@
+<?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");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="@drawable/fab_green"/>
+    <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@drawable/fab_ic_call"
+            android:tint="@color/glowpad_widget_active_color"
+            android:autoMirrored="true" />
+    </item>
+</layer-list>
diff --git a/InCallUI/res/drawable/ic_lockscreen_answer_normal_layer.xml b/InCallUI/res/drawable/ic_lockscreen_answer_normal_layer.xml
new file mode 100644
index 0000000..31b884f
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_answer_normal_layer.xml
@@ -0,0 +1,33 @@
+<?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");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- A fake circle to fix the size of this layer asset. -->
+    <item>
+        <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="oval">
+            <solid android:color="#00000000"/>
+            <size
+                android:width="@dimen/incoming_call_widget_circle_size"
+                android:height="@dimen/incoming_call_widget_circle_size" />
+        </shape>
+    </item>
+    <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@drawable/fab_ic_call"
+            android:tint="@color/glowpad_call_widget_normal_tint"
+            android:autoMirrored="true" />
+    </item>
+</layer-list>
diff --git a/InCallUI/res/drawable/ic_lockscreen_answer_video.xml b/InCallUI/res/drawable/ic_lockscreen_answer_video.xml
new file mode 100644
index 0000000..0557797
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_answer_video.xml
@@ -0,0 +1,28 @@
+<?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
+  -->
+<!-- Used with incoming call wigdet. -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item
+        android:state_enabled="true" android:state_active="false" android:state_focused="false"
+        android:drawable="@drawable/ic_lockscreen_answer_video_normal_layer"/>
+    <item
+        android:state_enabled="true" android:state_active="true"  android:state_focused="false"
+        android:drawable="@drawable/ic_lockscreen_answer_video_activated_layer" />
+   <item
+        android:state_enabled="true" android:state_active="false"  android:state_focused="true"
+        android:drawable="@drawable/ic_lockscreen_answer_video_activated_layer" />
+</selector>
diff --git a/InCallUI/res/drawable/ic_lockscreen_answer_video_activated_layer.xml b/InCallUI/res/drawable/ic_lockscreen_answer_video_activated_layer.xml
new file mode 100644
index 0000000..7895e1b
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_answer_video_activated_layer.xml
@@ -0,0 +1,26 @@
+<?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
+  -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="@drawable/fab_blue" />
+    <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@drawable/ic_videocam"
+            android:tint="@color/glowpad_widget_active_color"
+            android:autoMirrored="true" />
+    </item>
+</layer-list>
diff --git a/InCallUI/res/drawable/ic_lockscreen_answer_video_normal_layer.xml b/InCallUI/res/drawable/ic_lockscreen_answer_video_normal_layer.xml
new file mode 100644
index 0000000..793a36e
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_answer_video_normal_layer.xml
@@ -0,0 +1,34 @@
+<?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
+  -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- A fake circle to fix the size of this layer asset. -->
+    <item>
+        <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="oval">
+            <solid android:color="#00000000"/>
+            <size
+                android:width="@dimen/incoming_call_widget_circle_size"
+                android:height="@dimen/incoming_call_widget_circle_size" />
+        </shape>
+    </item>
+    <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@drawable/ic_videocam"
+            android:tint="@color/glowpad_call_widget_normal_tint"
+            android:autoMirrored="true" />
+    </item>
+</layer-list>
diff --git a/InCallUI/res/drawable/ic_lockscreen_decline.xml b/InCallUI/res/drawable/ic_lockscreen_decline.xml
new file mode 100644
index 0000000..6643816
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_decline.xml
@@ -0,0 +1,27 @@
+<?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");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<!-- Used with incoming call wigdet. -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item
+        android:state_enabled="true" android:state_active="false" android:state_focused="false"
+        android:drawable="@drawable/ic_lockscreen_decline_normal_layer" />
+    <item
+        android:state_enabled="true" android:state_active="true"  android:state_focused="false"
+        android:drawable="@drawable/ic_lockscreen_decline_activated_layer" />
+    <item
+        android:state_enabled="true" android:state_active="false"  android:state_focused="true"
+        android:drawable="@drawable/ic_lockscreen_decline_activated_layer" />
+</selector>
diff --git a/InCallUI/res/drawable/ic_lockscreen_decline_activated_layer.xml b/InCallUI/res/drawable/ic_lockscreen_decline_activated_layer.xml
new file mode 100644
index 0000000..096c32b
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_decline_activated_layer.xml
@@ -0,0 +1,24 @@
+<?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");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="@drawable/fab_red" />
+    <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@drawable/fab_ic_end_call"
+            android:tint="@color/glowpad_widget_active_color" />
+    </item>
+</layer-list>
diff --git a/InCallUI/res/drawable/ic_lockscreen_decline_normal_layer.xml b/InCallUI/res/drawable/ic_lockscreen_decline_normal_layer.xml
new file mode 100644
index 0000000..4da5f8d
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_decline_normal_layer.xml
@@ -0,0 +1,32 @@
+<?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");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- A fake circle to fix the size of this layer asset. -->
+    <item>
+        <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="oval">
+            <solid android:color="#00000000"/>
+            <size
+                android:width="@dimen/incoming_call_widget_circle_size"
+                android:height="@dimen/incoming_call_widget_circle_size" />
+        </shape>
+    </item>
+    <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@drawable/fab_ic_end_call"
+            android:tint="@color/glowpad_end_call_widget_normal_tint" />
+    </item>
+</layer-list>
diff --git a/InCallUI/res/drawable/ic_lockscreen_decline_video.xml b/InCallUI/res/drawable/ic_lockscreen_decline_video.xml
new file mode 100644
index 0000000..cedd497
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_decline_video.xml
@@ -0,0 +1,28 @@
+<?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
+  -->
+<!-- Used with incoming call wigdet. -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item
+        android:state_enabled="true" android:state_active="false" android:state_focused="false"
+        android:drawable="@drawable/ic_lockscreen_decline_video_normal_layer"/>
+    <item
+        android:state_enabled="true" android:state_active="true"  android:state_focused="false"
+        android:drawable="@drawable/ic_lockscreen_decline_video_activated_layer" />
+   <item
+        android:state_enabled="true" android:state_active="false"  android:state_focused="true"
+        android:drawable="@drawable/ic_lockscreen_decline_video_activated_layer" />
+</selector>
diff --git a/InCallUI/res/drawable/ic_lockscreen_decline_video_activated_layer.xml b/InCallUI/res/drawable/ic_lockscreen_decline_video_activated_layer.xml
new file mode 100644
index 0000000..0790aed
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_decline_video_activated_layer.xml
@@ -0,0 +1,26 @@
+<?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
+  -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="@drawable/fab_red" />
+    <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@drawable/ic_toolbar_video_off"
+            android:tint="@color/glowpad_widget_active_color"
+            android:autoMirrored="true" />
+    </item>
+</layer-list>
diff --git a/InCallUI/res/drawable/ic_lockscreen_decline_video_normal_layer.xml b/InCallUI/res/drawable/ic_lockscreen_decline_video_normal_layer.xml
new file mode 100644
index 0000000..e3b89b9
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_decline_video_normal_layer.xml
@@ -0,0 +1,34 @@
+<?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
+  -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- A fake circle to fix the size of this layer asset. -->
+    <item>
+        <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="oval">
+            <solid android:color="#00000000"/>
+            <size
+                android:width="@dimen/incoming_call_widget_circle_size"
+                android:height="@dimen/incoming_call_widget_circle_size" />
+        </shape>
+    </item>
+    <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@drawable/ic_toolbar_video_off"
+            android:tint="@color/glowpad_end_call_widget_normal_tint"
+            android:autoMirrored="true" />
+    </item>
+</layer-list>
diff --git a/InCallUI/res/drawable/ic_lockscreen_outerring.xml b/InCallUI/res/drawable/ic_lockscreen_outerring.xml
new file mode 100644
index 0000000..489515f
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_outerring.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="oval">
+    <size android:height="@dimen/glowpadview_outerring_diameter"
+          android:width="@dimen/glowpadview_outerring_diameter" />
+    <stroke android:color="@color/glowpad_outer_ring_color" android:width="1dp" />
+</shape>
diff --git a/InCallUI/res/drawable/ic_lockscreen_text.xml b/InCallUI/res/drawable/ic_lockscreen_text.xml
new file mode 100644
index 0000000..f9caac8
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_text.xml
@@ -0,0 +1,27 @@
+<?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");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<!-- Used with incoming call wigdet. -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item
+        android:state_enabled="true" android:state_active="false" android:state_focused="false"
+        android:drawable="@drawable/ic_lockscreen_text_normal_layer" />
+    <item
+        android:state_enabled="true" android:state_active="true"  android:state_focused="false"
+        android:drawable="@drawable/ic_lockscreen_text_activated_layer" />
+    <item
+        android:state_enabled="true" android:state_active="false"  android:state_focused="true"
+        android:drawable="@drawable/ic_lockscreen_text_activated_layer" />
+</selector>
diff --git a/InCallUI/res/drawable/ic_lockscreen_text_activated_layer.xml b/InCallUI/res/drawable/ic_lockscreen_text_activated_layer.xml
new file mode 100644
index 0000000..a74e36b
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_text_activated_layer.xml
@@ -0,0 +1,32 @@
+<?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");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item>
+        <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="oval">
+            <stroke android:color="@color/glowpad_text_widget_ring_color" android:width="1dp"/>
+            <size
+                android:width="@dimen/incoming_call_widget_circle_size"
+                android:height="@dimen/incoming_call_widget_circle_size" />
+        </shape>
+    </item>
+    <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@drawable/fab_ic_message"
+            android:tint="@color/glowpad_widget_active_color"
+            android:autoMirrored="true" />
+    </item>
+</layer-list>
diff --git a/InCallUI/res/drawable/ic_lockscreen_text_normal_layer.xml b/InCallUI/res/drawable/ic_lockscreen_text_normal_layer.xml
new file mode 100644
index 0000000..be32d0b
--- /dev/null
+++ b/InCallUI/res/drawable/ic_lockscreen_text_normal_layer.xml
@@ -0,0 +1,33 @@
+<?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");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- A fake circle to fix the size of this layer asset. -->
+    <item>
+        <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="oval">
+            <solid android:color="#00000000"/>
+            <size
+                android:width="@dimen/incoming_call_widget_circle_size"
+                android:height="@dimen/incoming_call_widget_circle_size" />
+        </shape>
+    </item>
+    <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@drawable/fab_ic_message"
+            android:tint="@color/glowpad_text_widget_normal_tint"
+            android:autoMirrored="true" />
+    </item>
+</layer-list>
diff --git a/InCallUI/res/drawable/img_conference_automirrored.xml b/InCallUI/res/drawable/img_conference_automirrored.xml
new file mode 100644
index 0000000..fa1fd49
--- /dev/null
+++ b/InCallUI/res/drawable/img_conference_automirrored.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  ~ Copyright (C) 2014 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<bitmap xmlns:android="http://schemas.android.com/apk/res/android"
+    android:src="@drawable/img_conference"
+    android:autoMirrored="true" />
\ No newline at end of file
diff --git a/InCallUI/res/drawable/img_no_image_automirrored.xml b/InCallUI/res/drawable/img_no_image_automirrored.xml
new file mode 100644
index 0000000..f0cf0db
--- /dev/null
+++ b/InCallUI/res/drawable/img_no_image_automirrored.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  ~ Copyright (C) 2014 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<bitmap xmlns:android="http://schemas.android.com/apk/res/android"
+    android:src="@drawable/img_no_image"
+    android:autoMirrored="true" />
\ No newline at end of file
diff --git a/InCallUI/res/drawable/incoming_sms_background.xml b/InCallUI/res/drawable/incoming_sms_background.xml
new file mode 100644
index 0000000..81ff21c
--- /dev/null
+++ b/InCallUI/res/drawable/incoming_sms_background.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<shape
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <corners
+        android:topLeftRadius="@dimen/person_contact_context_message_background_main_radius"
+        android:topRightRadius="@dimen/person_contact_context_message_background_main_radius"
+        android:bottomRightRadius="@dimen/person_contact_context_message_background_main_radius"
+        android:bottomLeftRadius="@dimen/person_contact_context_message_background_accent_radius"/>
+    <solid android:color="@color/person_contact_context_message_background_color" />
+</shape>
diff --git a/InCallUI/res/drawable/outgoing_sms_background.xml b/InCallUI/res/drawable/outgoing_sms_background.xml
new file mode 100644
index 0000000..e4f868f
--- /dev/null
+++ b/InCallUI/res/drawable/outgoing_sms_background.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<shape
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+    <corners
+        android:topLeftRadius="@dimen/person_contact_context_message_background_main_radius"
+        android:topRightRadius="@dimen/person_contact_context_message_background_main_radius"
+        android:bottomLeftRadius="@dimen/person_contact_context_message_background_main_radius"
+        android:bottomRightRadius="@dimen/person_contact_context_message_background_accent_radius"/>
+    <solid android:color="@color/person_contact_context_message_background_color" />
+</shape>
diff --git a/InCallUI/res/drawable/subject_bubble.xml b/InCallUI/res/drawable/subject_bubble.xml
new file mode 100644
index 0000000..adab678
--- /dev/null
+++ b/InCallUI/res/drawable/subject_bubble.xml
@@ -0,0 +1,22 @@
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="#ffffff" />
+    <padding android:left="10dp" android:top="10dp" android:right="10dp" android:bottom="10dp" />
+    <corners android:topLeftRadius="6dp" android:topRightRadius="6dp"
+             android:bottomLeftRadius="0dp" android:bottomRightRadius="6dp"/>
+</shape>
\ No newline at end of file
diff --git a/InCallUI/res/layout-h600dp/call_card_fragment.xml b/InCallUI/res/layout-h600dp/call_card_fragment.xml
new file mode 100644
index 0000000..c3ae877
--- /dev/null
+++ b/InCallUI/res/layout-h600dp/call_card_fragment.xml
@@ -0,0 +1,173 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  ~ Copyright (C) 2016 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:orientation="vertical">
+
+        <!-- Primary "call card" block, for the foreground call. -->
+        <LinearLayout
+            android:id="@+id/primary_call_info_container"
+            android:layout_width="match_parent"
+            android:layout_height="0dp"
+            android:layout_weight="1"
+            android:orientation="vertical"
+            android:elevation="@dimen/primary_call_elevation"
+            android:background="@color/incall_call_banner_background_color"
+            android:paddingTop="@dimen/call_banner_primary_call_container_top_padding"
+            android:clipChildren="false"
+            android:clipToPadding="false"
+            android:gravity="bottom">
+
+            <include layout="@layout/primary_call_info"
+                android:layout_width="match_parent"
+                android:layout_height="0dp"
+                android:layout_weight="1"
+                android:minHeight="@dimen/call_banner_height"
+                android:animateLayoutChanges="true"
+                android:gravity="center"
+                android:layout_centerHorizontal="true" />
+
+            <fragment android:name="com.android.incallui.CallButtonFragment"
+                android:id="@+id/callButtonFragment"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content" />
+
+            <TextView android:id="@+id/connectionServiceMessage"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:textAppearance="?android:attr/textAppearanceMedium"
+                android:visibility="gone"
+                android:padding="@dimen/call_banner_side_padding"
+                android:background="@android:color/white" />
+
+        </LinearLayout>
+
+        <RelativeLayout
+            android:layout_width="match_parent"
+            android:layout_height="0dp"
+            android:layout_weight="2">
+
+            <FrameLayout
+                android:layout_height="match_parent"
+                android:layout_width="match_parent"
+                android:id="@+id/call_card_content">
+
+                <!-- Contact photo for primary call info -->
+                <ImageView android:id="@+id/photoLarge"
+                    android:layout_width="match_parent"
+                    android:layout_height="match_parent"
+                    android:scaleType="centerCrop"
+                    android:importantForAccessibility="no"
+                    android:background="@color/incall_photo_background_color"
+                    android:src="@drawable/img_no_image_automirrored" />
+
+                <!-- Call context -->
+                <LinearLayout
+                    android:id="@+id/contact_context"
+                    android:layout_height="match_parent"
+                    android:layout_width="match_parent"
+                    android:orientation="vertical"
+                    android:background="@color/incall_background_color"
+                    android:visibility="gone">
+                    <TextView android:id="@+id/contactContextTitle"
+                        android:textSize="@dimen/contact_context_title_text_size"
+                        android:textColor="@color/contact_context_title_text_color"
+                        android:fontFamily="sans-serif-medium"
+                        android:layout_width="wrap_content"
+                        android:layout_height="wrap_content"
+                        android:layout_gravity="center_horizontal"
+                        android:layout_marginBottom="@dimen/contact_context_title_margin_bottom"/>
+                    <ListView android:id="@+id/contactContextInfo"
+                         android:layout_width="match_parent"
+                         android:layout_height="match_parent"
+                         android:divider="@null"
+                         android:dividerHeight="@dimen/contact_context_list_item_padding"/>
+                </LinearLayout>
+            </FrameLayout>
+
+            <fragment android:name="com.android.incallui.VideoCallFragment"
+                android:id="@+id/videoCallFragment"
+                android:layout_alignParentTop="true"
+                android:layout_gravity="top|center_horizontal"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent" />
+
+            <!-- Progress spinner, useful for indicating pending operations such as upgrade to video. -->
+            <FrameLayout
+                android:id="@+id/progressSpinner"
+                android:background="#63000000"
+                android:layout_width="fill_parent"
+                android:layout_height="fill_parent"
+                android:layout_centerHorizontal="true"
+                android:layout_centerVertical="true"
+                android:visibility="gone">
+
+                <ProgressBar
+                    android:id="@+id/progress_bar"
+                    style="@android:style/Widget.Material.ProgressBar"
+                    android:layout_gravity="center"
+                    android:layout_width="48dp"
+                    android:layout_height="48dp"
+                    android:indeterminate="true" />
+
+            </FrameLayout>
+
+
+            <include layout="@layout/manage_conference_call_button"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content" />
+
+            <!-- Placeholder for various fragments that are added dynamically underneath the caller info. -->
+            <FrameLayout
+                android:id="@+id/answer_and_dialpad_container"
+                android:layout_gravity="bottom|center_horizontal"
+                android:layout_alignParentBottom="true"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:elevation="@dimen/dialpad_elevation" />
+
+            <FrameLayout
+                android:id="@+id/floating_end_call_action_button_container"
+                android:layout_width="@dimen/end_call_floating_action_button_diameter"
+                android:layout_height="@dimen/end_call_floating_action_button_diameter"
+                android:background="@drawable/fab_red"
+                android:layout_alignParentBottom="true"
+                android:layout_centerHorizontal="true"
+                android:layout_marginBottom="@dimen/end_call_button_margin_bottom">
+
+                <ImageButton android:id="@+id/floating_end_call_action_button"
+                    android:layout_width="match_parent"
+                    android:layout_height="match_parent"
+                    android:background="@drawable/end_call_background"
+                    android:src="@drawable/fab_ic_end_call"
+                    android:scaleType="center"
+                    android:contentDescription="@string/onscreenEndCallText" />
+
+            </FrameLayout>
+
+        </RelativeLayout>
+
+    </LinearLayout>
+    <!-- Secondary "Call info" block, for the background ("on hold") call. -->
+    <include layout="@layout/secondary_call_info" />
+</RelativeLayout>
\ No newline at end of file
diff --git a/InCallUI/res/layout-w600dp-land/call_card_fragment.xml b/InCallUI/res/layout-w600dp-land/call_card_fragment.xml
new file mode 100644
index 0000000..c71cf07
--- /dev/null
+++ b/InCallUI/res/layout-w600dp-land/call_card_fragment.xml
@@ -0,0 +1,158 @@
+<?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
+  -->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="horizontal">
+
+    <LinearLayout
+        android:id="@+id/primary_call_info_container"
+        android:layout_centerVertical="true"
+        android:layout_width="0dp"
+        android:layout_height="match_parent"
+        android:layout_weight="1"
+        android:orientation="vertical"
+        android:elevation="@dimen/primary_call_elevation"
+        android:background="@drawable/rounded_call_card_background"
+        android:paddingTop="@dimen/call_banner_primary_call_container_top_padding"
+        android:clipChildren="false"
+        android:clipToPadding="false"
+        android:alpha="0.9"
+        android:layout_margin="10dp">
+
+        <include layout="@layout/primary_call_info" />
+
+        <fragment android:name="com.android.incallui.CallButtonFragment"
+            android:id="@+id/callButtonFragment"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="bottom|center_horizontal"
+            android:layout_marginBottom="@dimen/call_buttons_bottom_margin" />
+
+        <!-- Secondary "Call info" block, for the background ("on hold") call. -->
+        <include layout="@layout/secondary_call_info"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_gravity="bottom" />
+
+    </LinearLayout>
+
+    <FrameLayout
+        android:layout_height="match_parent"
+        android:layout_width="0dp"
+        android:layout_weight="1">
+
+        <FrameLayout
+            android:layout_height="match_parent"
+            android:layout_width="match_parent"
+            android:id="@+id/call_card_content">
+
+            <ImageView android:id="@+id/photoLarge"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:scaleType="centerCrop"
+                android:contentDescription="@string/contactPhoto"
+                android:background="@color/incall_photo_background_color"
+                android:src="@drawable/img_no_image_automirrored" />
+
+            <!-- Call context -->
+            <LinearLayout
+                android:id="@+id/contact_context"
+                android:layout_height="match_parent"
+                android:layout_width="match_parent"
+                android:orientation="vertical"
+                android:background="@color/incall_background_color"
+                android:visibility="gone">
+                <TextView android:id="@+id/contactContextTitle"
+                    android:textSize="@dimen/contact_context_title_text_size"
+                    android:textColor="@color/contact_context_title_text_color"
+                    android:fontFamily="sans-serif-medium"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_gravity="center_horizontal"
+                    android:layout_marginBottom="@dimen/contact_context_title_margin_bottom" />
+                <ListView android:id="@+id/contactContextInfo"
+                     android:layout_width="match_parent"
+                     android:layout_height="match_parent"
+                     android:divider="@null"
+                     android:dividerHeight="@dimen/contact_context_list_item_padding" />
+            </LinearLayout>
+
+        </FrameLayout>
+
+        <include layout="@layout/manage_conference_call_button"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_alignTop="@id/photoLarge" />
+
+        <!-- Progress spinner, useful for indicating pending operations such as upgrade to video. -->
+        <FrameLayout
+            android:id="@+id/progressSpinner"
+            android:background="#63000000"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:layout_centerHorizontal="true"
+            android:layout_centerVertical="true"
+            android:visibility="gone" >
+
+            <ProgressBar
+                android:id="@+id/progress_bar"
+                style="@android:style/Widget.Material.ProgressBar"
+                android:layout_gravity="center"
+                android:layout_width="48dp"
+                android:layout_height="48dp"
+                android:indeterminate="true" />
+
+        </FrameLayout>
+
+        <fragment android:name="com.android.incallui.VideoCallFragment"
+            android:layout_alignParentStart="true"
+            android:layout_gravity="start|center_vertical"
+            android:id="@+id/videoCallFragment"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent" />
+
+        <!-- Placeholder for the dialpad which is replaced with the dialpad fragment when shown. -->
+        <FrameLayout
+            android:id="@+id/answer_and_dialpad_container"
+            android:layout_gravity="bottom"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent" />
+
+        <FrameLayout
+            android:id="@+id/floating_end_call_action_button_container"
+            android:layout_width="@dimen/end_call_floating_action_button_diameter"
+            android:layout_height="@dimen/end_call_floating_action_button_diameter"
+            android:background="@drawable/fab_red"
+            android:layout_gravity="bottom|center_horizontal"
+            android:layout_marginBottom="@dimen/end_call_button_margin_bottom">
+
+            <ImageButton android:id="@+id/floating_end_call_action_button"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:background="@drawable/end_call_background"
+                android:src="@drawable/fab_ic_end_call"
+                android:scaleType="center"
+                android:contentDescription="@string/onscreenEndCallText" />
+
+        </FrameLayout>
+
+    </FrameLayout>
+
+</LinearLayout>
diff --git a/InCallUI/res/layout/accessible_answer_fragment.xml b/InCallUI/res/layout/accessible_answer_fragment.xml
new file mode 100644
index 0000000..90fe577
--- /dev/null
+++ b/InCallUI/res/layout/accessible_answer_fragment.xml
@@ -0,0 +1,104 @@
+<?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
+-->
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:gravity="center_horizontal"
+    android:background="@color/glowpad_background_color">
+    <RelativeLayout
+        android:id="@+id/accessible_answer_fragment_answer"
+        android:orientation="vertical"
+        android:layout_width="120dp"
+        android:layout_height="120dp"
+        android:focusable="true"
+        android:focusableInTouchMode="true"
+        android:clickable="true"
+        android:layout_alignParentRight="true"
+        android:layout_centerVertical="true"
+        android:layout_marginLeft="16dp"
+        android:layout_marginRight="16dp">
+        <ImageView
+            android:layout_width="64dp"
+            android:layout_height="64dp"
+            android:src="@drawable/ic_lockscreen_answer_activated_layer"
+            android:layout_centerInParent="true">
+        </ImageView>
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/description_target_answer"
+            android:textSize="12sp"
+            android:textColor="@color/accessible_answer_hint_text_color"
+            android:layout_alignParentBottom="true"
+            android:layout_centerHorizontal="true"
+            android:layout_marginBottom="8dp"/>
+    </RelativeLayout>
+    <RelativeLayout
+        android:id="@+id/accessible_answer_fragment_decline"
+        android:orientation="vertical"
+        android:layout_width="120dp"
+        android:layout_height="120dp"
+        android:focusable="true"
+        android:focusableInTouchMode="true"
+        android:clickable="true"
+        android:layout_alignParentLeft="true"
+        android:layout_centerVertical="true"
+        android:layout_marginLeft="16dp"
+        android:layout_marginRight="16dp">
+        <ImageView
+            android:layout_width="64dp"
+            android:layout_height="64dp"
+            android:src="@drawable/ic_lockscreen_decline_activated_layer"
+            android:layout_centerInParent="true">
+        </ImageView>
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/description_target_decline"
+            android:textSize="12sp"
+            android:textColor="@color/accessible_answer_hint_text_color"
+            android:layout_alignParentBottom="true"
+            android:layout_centerHorizontal="true"
+            android:layout_marginBottom="8dp"/>
+    </RelativeLayout>
+    <LinearLayout
+        android:id="@+id/accessible_answer_fragment_text"
+        android:orientation="vertical"
+        android:layout_width="92dp"
+        android:layout_height="92dp"
+        android:focusable="true"
+        android:focusableInTouchMode="true"
+        android:clickable="true"
+        android:layout_alignParentEnd="false"
+        android:layout_alignParentStart="false"
+        android:layout_above="@+id/accessible_answer_fragment_decline"
+        android:layout_alignWithParentIfMissing="false"
+        android:layout_alignParentTop="false"
+        android:layout_alignParentLeft="false"
+        android:layout_alignParentBottom="false"
+        android:layout_alignParentRight="false"
+        android:layout_centerHorizontal="true"
+        android:contentDescription="@string/description_target_send_sms"
+        android:gravity="center">
+        <ImageView
+            android:layout_width="64dp"
+            android:layout_height="64dp"
+            android:src="@drawable/ic_lockscreen_text">
+        </ImageView>
+    </LinearLayout>
+
+</RelativeLayout>
\ No newline at end of file
diff --git a/InCallUI/res/layout/answer_fragment.xml b/InCallUI/res/layout/answer_fragment.xml
new file mode 100644
index 0000000..ec6ef30
--- /dev/null
+++ b/InCallUI/res/layout/answer_fragment.xml
@@ -0,0 +1,42 @@
+<?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
+  -->
+
+<com.android.incallui.GlowPadWrapper
+        xmlns:android="http://schemas.android.com/apk/res/android"
+        xmlns:dc="http://schemas.android.com/apk/res-auto"
+        android:id="@+id/glow_pad_view"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:focusable="true"
+        android:layout_centerHorizontal="true"
+        android:gravity="center"
+        android:background="@color/glowpad_background_color"
+        android:layout_marginBottom="@dimen/glowpadview_margin_bottom"
+
+        dc:targetDrawables="@array/incoming_call_widget_audio_with_sms_targets"
+        dc:targetDescriptions="@array/incoming_call_widget_audio_with_sms_target_descriptions"
+        dc:directionDescriptions="@array/incoming_call_widget_audio_with_sms_direction_descriptions"
+        dc:handleDrawable="@drawable/ic_incall_audio_handle"
+        dc:outerRingDrawable="@drawable/ic_lockscreen_outerring"
+        dc:outerRadius="@dimen/glowpadview_target_placement_radius"
+        dc:innerRadius="@dimen/glowpadview_inner_radius"
+        dc:snapMargin="@dimen/glowpadview_snap_margin"
+        dc:feedbackCount="1"
+        dc:vibrationDuration="20"
+        dc:glowRadius="@dimen/glowpadview_glow_radius"
+        dc:pointDrawable="@drawable/ic_lockscreen_glowdot"
+        dc:allowScaling="true" />
diff --git a/InCallUI/res/layout/business_contact_context_list_header.xml b/InCallUI/res/layout/business_contact_context_list_header.xml
new file mode 100644
index 0000000..9052118
--- /dev/null
+++ b/InCallUI/res/layout/business_contact_context_list_header.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+     android:layout_width="match_parent"
+     android:layout_height="wrap_content"
+     android:orientation="horizontal"
+     android:paddingEnd="@dimen/business_contact_context_end_padding">
+     <ImageView android:id="@+id/icon"
+         android:layout_width="@dimen/contact_context_title_image_size"
+         android:layout_height="@dimen/contact_context_title_image_size"
+         android:layout_marginLeft="@dimen/contact_context_title_image_side_padding"
+         android:layout_marginRight="@dimen/contact_context_title_image_side_padding"
+         android:layout_gravity="center"
+         android:scaleType="center"
+         android:src="@drawable/ic_business_white_24dp"
+         android:tint="@color/business_contact_context_text_color"
+         android:alpha="0.8"
+         android:importantForAccessibility="no"/>
+     <TextView android:id="@+id/title"
+         android:layout_width="match_parent"
+         android:layout_height="wrap_content"
+         android:layout_gravity="center_vertical"
+         android:text="@string/business_contact_context_title"
+         android:textSize="@dimen/business_contact_context_detail_font_size"
+         android:textColor="@color/business_contact_context_text_color"
+         android:fontFamily="sans-serif-medium"/>
+ </LinearLayout>
\ No newline at end of file
diff --git a/InCallUI/res/layout/business_context_info_list_item.xml b/InCallUI/res/layout/business_context_info_list_item.xml
new file mode 100644
index 0000000..616d219
--- /dev/null
+++ b/InCallUI/res/layout/business_context_info_list_item.xml
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+     android:layout_width="match_parent"
+     android:layout_height="wrap_content"
+     android:orientation="horizontal"
+     android:paddingEnd="@dimen/business_contact_context_end_padding">
+     <ImageView android:id="@+id/icon"
+         android:layout_width="@dimen/business_contact_context_image_size"
+         android:layout_height="@dimen/business_contact_context_image_size"
+         android:layout_marginLeft="@dimen/business_contact_context_image_padding"
+         android:layout_marginRight="@dimen/business_contact_context_image_padding"
+         android:layout_gravity="center"
+         android:scaleType="centerCrop"
+         android:tint="@color/business_contact_context_text_color"
+         android:alpha="0.8"/>
+     <LinearLayout
+         android:layout_width="match_parent"
+         android:layout_height="wrap_content"
+         android:layout_gravity="center"
+         android:orientation="vertical">
+         <TextView android:id="@+id/heading"
+             android:layout_width="match_parent"
+             android:layout_height="wrap_content"
+             android:textSize="@dimen/business_contact_context_heading_font_size"
+             android:textColor="@color/business_contact_context_text_color"
+             android:fontFamily="sans-serif-medium"/>
+         <TextView android:id="@+id/detail"
+             android:layout_width="match_parent"
+             android:layout_height="wrap_content"
+             android:textSize="@dimen/business_contact_context_detail_font_size"
+             android:textColor="@color/business_contact_context_text_color"
+             android:fontFamily="sans-serif-medium"/>
+     </LinearLayout>
+ </LinearLayout>
\ No newline at end of file
diff --git a/InCallUI/res/layout/call_button_fragment.xml b/InCallUI/res/layout/call_button_fragment.xml
new file mode 100644
index 0000000..db75764
--- /dev/null
+++ b/InCallUI/res/layout/call_button_fragment.xml
@@ -0,0 +1,171 @@
+<?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
+  -->
+
+<!-- In-call onscreen touch UI elements, used on some platforms.
+
+     This layout is a fullscreen overlay, drawn on top of the
+     non-touch-sensitive parts of the in-call UI (i.e. the call card).
+
+     The top-level View here is a InCallTouchUi (FrameLayout) with 2 children:
+       (1) inCallControls: the widgets visible while a regular call (or calls) is in progress
+       (2) incomingCallWidget: the UI displayed while an incoming call is ringing
+     In usual cases, one of these is visible at any given moment.
+     One exception is when incomingCallWidget is fading-out. At that moment, we show
+     inCallControls beneath incomingCallWidget for smoother transition.
+     -->
+
+<!-- Main cluster of onscreen buttons on the lower part of the screen. -->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/bottomButtons"
+    android:orientation="vertical"
+    android:layout_width="match_parent"
+    android:layout_margin="0dp"
+    android:padding="0dp"
+    android:background="@color/button_background_color"
+    android:layout_height="wrap_content"
+    android:layout_alignParentBottom="true"
+    android:animateLayoutChanges="true" >
+
+    <LinearLayout
+        android:orientation="horizontal"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:gravity="bottom|center_horizontal"
+        android:baselineAligned="false">
+
+        <!-- This row only ever shows either 4 or 5 buttons. This may depend on whether the device
+             supports "Hold" (i.e. 4 buttons on CDMA devices, 5 buttons on GSM devices.) or whether
+             it is in a video call.
+
+             There are a couple of *pairs* of buttons that share a single "slot", namely Hold/Swap
+             and Add/Merge.  For these, the code in InCallTouchUi is responsible for making sure
+             that at any point exactly one of the pair is VISIBLE and the other is GONE.
+
+             If there are more than 5 buttons eligible to be shown, the presenter is responsible for
+             collapsing those options into an overflow menu, which appears as one of the buttons
+             in the row instead. -->
+
+        <!-- FAR LEFT SLOT ===================================================================== -->
+
+        <!-- "Audio mode". this is a multi-mode button that can behave either like a simple
+             "compound button" with two states *or* like an action button that brings up a popup
+             menu; see btn_compound_audio.xml and CallButtonFragment.updateAudioButtons(). -->
+        <ToggleButton android:id="@+id/audioButton"
+            style="@style/InCallCompoundButton"
+            android:background="@drawable/btn_compound_audio"
+            android:contentDescription="@string/audio_mode_speaker" />
+
+        <!-- MIDDLE LEFT SLOT ================================================================== -->
+
+        <!-- "Mute" -->
+        <ToggleButton android:id="@+id/muteButton"
+            style="@style/InCallCompoundButton"
+            android:background="@drawable/btn_compound_mute"
+            android:contentDescription="@string/onscreenMuteText" />
+
+        <!-- CENTER SLOT ======================================================================= -->
+
+        <!-- "Dialpad" -->
+        <ToggleButton android:id="@+id/dialpadButton"
+            style="@style/InCallCompoundButton"
+            android:background="@drawable/btn_compound_dialpad"
+            android:contentDescription="@string/onscreenShowDialpadText" />
+
+        <!-- MIDDLE RIGHT SLOT ================================================================= -->
+
+        <!-- This slot is either "Hold" or "Swap", depending on the state of the call. One or the
+             other of these must always be set to GONE. -->
+
+        <!-- "Hold" -->
+        <ToggleButton android:id="@+id/holdButton"
+            style="@style/InCallCompoundButton"
+            android:background="@drawable/btn_compound_hold"
+            android:contentDescription="@string/onscreenHoldText_unselected" />
+
+        <!-- "Swap" (or "Manage calls" in some CDMA states) -->
+        <ImageButton android:id="@+id/swapButton"
+            style="@style/InCallButton"
+            android:background="@drawable/btn_swap"
+            android:contentDescription="@string/onscreenSwapCallsText"
+            android:visibility="gone" />
+
+        <!-- "Change to video call" -->
+        <ImageButton android:id="@+id/changeToVideoButton"
+            style="@style/InCallButton"
+            android:background="@drawable/btn_change_to_video"
+            android:contentDescription="@string/onscreenVideoCallText"
+            android:visibility="gone" />
+
+        <!-- "Switch camera" for video calls. -->
+        <ToggleButton android:id="@+id/switchCameraButton"
+            style="@style/InCallCompoundButton"
+            android:background="@drawable/btn_compound_video_switch"
+            android:contentDescription="@string/onscreenSwitchCameraText"
+            android:visibility="gone" />
+
+        <!-- FAR RIGHT SLOT ==================================================================== -->
+
+        <!-- This slot is either "Add" or "Merge", depending on the state of the call.  One or the
+             other of these must always be set to GONE. -->
+
+        <!-- "Turn off camera" for video calls. -->
+        <ToggleButton android:id="@+id/pauseVideoButton"
+            style="@style/InCallCompoundButton"
+            android:background="@drawable/btn_compound_video_off"
+            android:contentDescription="@string/onscreenPauseVideoText"
+            android:visibility="gone" />
+
+        <!-- "Change to audio call" for video calls. -->
+        <ImageButton android:id="@+id/changeToVoiceButton"
+                     style="@style/InCallButton"
+                     android:background="@drawable/btn_change_to_voice"
+                     android:contentDescription="@string/onscreenChangeToVoiceText"
+                     android:visibility="gone" />
+
+        <!-- "Add Call" -->
+        <ImageButton android:id="@+id/addButton"
+            style="@style/InCallButton"
+            android:background="@drawable/btn_add"
+            android:contentDescription="@string/onscreenAddCallText"
+            android:visibility="gone" />
+
+        <!-- "Merge calls". This button is used only on GSM devices, where we know that "Add" and
+             "Merge" are never available at the same time. The "Merge" button for CDMA devices is
+             "cdmaMergeButton" above. -->
+        <ImageButton android:id="@+id/mergeButton"
+            style="@style/InCallButton"
+            android:background="@drawable/btn_merge"
+            android:contentDescription="@string/onscreenMergeCallsText"
+            android:visibility="gone" />
+
+        <!-- "Overflow" -->
+        <ImageButton android:id="@+id/overflowButton"
+            style="@style/InCallButton"
+            android:background="@drawable/btn_overflow"
+            android:contentDescription="@string/onscreenOverflowText"
+            android:visibility="gone" />
+
+        <!-- "Manage conference button (Video Call) " -->
+        <ImageButton android:id="@+id/manageVideoCallConferenceButton"
+            style="@style/InCallButton"
+            android:background="@drawable/ic_group_white_24dp"
+            android:contentDescription="@string/onscreenManageConferenceText"
+            android:visibility="gone" />
+
+    </LinearLayout>
+
+</LinearLayout>
diff --git a/InCallUI/res/layout/call_card_fragment.xml b/InCallUI/res/layout/call_card_fragment.xml
new file mode 100644
index 0000000..09e1485
--- /dev/null
+++ b/InCallUI/res/layout/call_card_fragment.xml
@@ -0,0 +1,157 @@
+<?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
+  -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent">
+
+    <LinearLayout
+        android:id="@+id/primary_call_info_container"
+        android:layout_centerVertical="true"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:orientation="vertical"
+        android:elevation="@dimen/primary_call_elevation"
+        android:background="@color/incall_call_banner_background_color"
+        android:clipChildren="false"
+        android:clipToPadding="false"
+        android:alpha="0.9">
+
+        <include layout="@layout/primary_call_info"
+                 android:layout_width="match_parent"
+                 android:layout_height="wrap_content"
+                 android:layout_marginTop="@dimen/call_banner_vertical_margin"
+                 android:layout_marginBottom="@dimen/call_banner_vertical_margin"/>
+
+        <fragment android:name="com.android.incallui.CallButtonFragment"
+                  android:id="@+id/callButtonFragment"
+                  android:layout_width="wrap_content"
+                  android:layout_height="wrap_content"
+                  android:layout_gravity="center_horizontal" />
+
+        <!-- Secondary "Call info" block, for the background ("on hold") call. -->
+        <include layout="@layout/secondary_call_info"
+                 android:layout_width="match_parent"
+                 android:layout_height="wrap_content"
+                 android:layout_gravity="bottom" />
+
+    </LinearLayout>
+
+    <!-- Placeholder for the dialpad which is replaced with the dialpad fragment when shown. -->
+    <FrameLayout
+        android:id="@+id/answer_and_dialpad_container"
+        android:layout_width="match_parent"
+        android:elevation="7dp"
+        android:layout_height="match_parent" />
+
+    <FrameLayout
+        android:id="@+id/floating_end_call_action_button_container"
+        android:layout_width="@dimen/end_call_floating_action_button_diameter"
+        android:layout_height="@dimen/end_call_floating_action_button_diameter"
+        android:background="@drawable/fab_red"
+        android:layout_alignParentBottom="true"
+        android:layout_centerHorizontal="true">
+
+        <ImageButton android:id="@+id/floating_end_call_action_button"
+                     android:layout_width="match_parent"
+                     android:layout_height="match_parent"
+                     android:background="@drawable/end_call_background"
+                     android:src="@drawable/fab_ic_end_call"
+                     android:scaleType="center"
+                     android:contentDescription="@string/onscreenEndCallText" />
+
+    </FrameLayout>
+
+    <FrameLayout
+        android:layout_height="match_parent"
+        android:layout_width="0dp"
+        android:layout_weight="1"
+        android:visibility="gone">
+
+        <FrameLayout
+            android:layout_height="match_parent"
+            android:layout_width="match_parent"
+            android:id="@+id/call_card_content">
+
+            <ImageView android:id="@+id/photoLarge"
+                       android:layout_width="match_parent"
+                       android:layout_height="match_parent"
+                       android:scaleType="centerCrop"
+                       android:contentDescription="@string/contactPhoto"
+                       android:background="@color/incall_photo_background_color"
+                       android:src="@drawable/img_no_image_automirrored" />
+
+            <!-- Call context -->
+            <LinearLayout
+                android:id="@+id/contact_context"
+                android:layout_height="match_parent"
+                android:layout_width="match_parent"
+                android:orientation="vertical"
+                android:background="@color/incall_background_color"
+                android:visibility="gone">
+                <TextView android:id="@+id/contactContextTitle"
+                          android:textSize="@dimen/contact_context_title_text_size"
+                          android:textColor="@color/glowpad_background_color"
+                          android:fontFamily="sans-serif-medium"
+                          android:layout_width="wrap_content"
+                          android:layout_height="wrap_content"
+                          android:layout_gravity="center_horizontal"
+                          android:layout_marginBottom="@dimen/contact_context_title_margin_bottom" />
+                <ListView android:id="@+id/contactContextInfo"
+                          android:layout_width="match_parent"
+                          android:layout_height="match_parent"
+                          android:divider="@null"
+                          android:dividerHeight="@dimen/contact_context_list_item_padding" />
+            </LinearLayout>
+        </FrameLayout>
+
+        <include layout="@layout/manage_conference_call_button"
+                 android:layout_width="match_parent"
+                 android:layout_height="wrap_content"
+                 android:layout_alignTop="@id/photoLarge" />
+
+        <!-- Progress spinner, useful for indicating pending operations such as upgrade to video. -->
+        <FrameLayout
+            android:id="@+id/progressSpinner"
+            android:background="#63000000"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:layout_centerHorizontal="true"
+            android:layout_centerVertical="true"
+            android:visibility="gone" >
+
+            <ProgressBar
+                android:id="@+id/progress_bar"
+                style="@android:style/Widget.Material.ProgressBar"
+                android:layout_gravity="center"
+                android:layout_width="48dp"
+                android:layout_height="48dp"
+                android:indeterminate="true" />
+
+        </FrameLayout>
+
+        <fragment android:name="com.android.incallui.VideoCallFragment"
+                  android:layout_alignParentStart="true"
+                  android:layout_gravity="start|center_vertical"
+                  android:id="@+id/videoCallFragment"
+                  android:layout_width="match_parent"
+                  android:layout_height="match_parent" />
+
+    </FrameLayout>
+
+</RelativeLayout>
diff --git a/InCallUI/res/layout/caller_in_conference.xml b/InCallUI/res/layout/caller_in_conference.xml
new file mode 100644
index 0000000..ac78096
--- /dev/null
+++ b/InCallUI/res/layout/caller_in_conference.xml
@@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2008 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="64dp"
+    android:orientation="horizontal"
+    android:gravity="center_vertical"
+    android:paddingStart="16dp"
+    android:paddingEnd="8dp">
+
+    <!-- Caller information -->
+    <LinearLayout
+        android:layout_width="0dp"
+        android:layout_weight="1"
+        android:layout_height="match_parent"
+        android:orientation="horizontal"
+        android:gravity="center_vertical">
+
+        <ImageView android:id="@+id/callerPhoto"
+            android:layout_width="@dimen/contact_browser_list_item_photo_size"
+            android:layout_height="@dimen/contact_browser_list_item_photo_size" />
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:gravity="center_vertical"
+            android:orientation="vertical"
+            android:layout_marginStart="16dp"
+            android:paddingBottom="2dp">
+
+            <!-- Name or number of this caller -->
+            <TextView android:id="@+id/conferenceCallerName"
+                android:textAppearance="?android:attr/textAppearanceLarge"
+                android:textSize="16sp"
+                android:textColor="@color/conference_call_manager_caller_name_text_color"
+                android:singleLine="true"
+                android:layout_width="wrap_content"
+                android:layout_height="match_parent"
+                android:layout_marginEnd="2dp" />
+
+            <!-- Number of this caller if name is supplied above -->
+            <LinearLayout
+                 android:layout_width="wrap_content"
+                 android:layout_height="match_parent"
+                 android:orientation="horizontal"
+                 android:gravity="bottom">
+
+                <!-- Number -->
+                <TextView
+                     android:id="@+id/conferenceCallerNumber"
+                     android:layout_width="wrap_content"
+                     android:layout_height="wrap_content"
+                     android:textSize="14sp"
+                     android:ellipsize="marquee"
+                     android:textColor="@color/conference_call_manager_secondary_text_color"
+                     android:singleLine="true"
+                     android:layout_marginEnd="8dp" />
+
+                <!-- Number type -->
+                <TextView
+                    android:id="@+id/conferenceCallerNumberType"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:textSize="12sp"
+                    android:textColor="@color/conference_call_manager_secondary_text_color"
+                    android:ellipsize="marquee"
+                    android:singleLine="true"
+                    android:textAllCaps="true"
+                    android:gravity="start" />
+
+            </LinearLayout>  <!-- End of caller number -->
+
+        </LinearLayout>  <!-- End of caller information -->
+
+    </LinearLayout>
+
+    <!-- "Separate" (i.e. "go private") button for this caller -->
+    <ImageView android:id="@+id/conferenceCallerSeparate"
+        android:src="@drawable/ic_call_split_white_24dp"
+        android:layout_width="@dimen/conference_call_manager_button_dimension"
+        android:layout_height="@dimen/conference_call_manager_button_dimension"
+        android:scaleType="center"
+        android:contentDescription="@string/goPrivate"
+        android:tint="@color/conference_call_manager_icon_color"
+        android:background="@drawable/conference_ripple"
+        android:clickable="true" />
+
+    <!-- "Disconnect" button which terminates the connection with this caller. -->
+    <ImageButton
+        android:id="@+id/conferenceCallerDisconnect"
+        android:layout_width="@dimen/conference_call_manager_button_dimension"
+        android:layout_height="@dimen/conference_call_manager_button_dimension"
+        android:layout_marginStart="8dp"
+        android:src="@drawable/ic_call_end_white_24dp"
+        android:scaleType="center"
+        android:contentDescription="@string/onscreenEndCallText"
+        android:tint="@color/conference_call_manager_icon_color"
+        android:background="@drawable/conference_ripple"
+        android:clickable="true" />
+
+</LinearLayout>  <!-- End of single list element -->
diff --git a/InCallUI/res/layout/conference_manager_fragment.xml b/InCallUI/res/layout/conference_manager_fragment.xml
new file mode 100644
index 0000000..7350bee
--- /dev/null
+++ b/InCallUI/res/layout/conference_manager_fragment.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2009 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- The "Manage conference" UI.  This panel is displayed (instead of
+     the inCallPanel) when the user clicks the "Manage conference"
+     button while on a conference call. -->
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/manageConferencePanel"
+    android:background="@color/conference_call_manager_background_color"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:paddingTop="@dimen/conference_call_manager_padding_top" >
+    <!-- List of conference participants. -->
+    <ListView
+        android:id="@+id/participantList"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:listSelector="@null"
+        android:background="@color/background_dialer_white"
+        android:divider="@null"
+        android:focusableInTouchMode="true"
+        android:focusable="true"/>
+</FrameLayout>
diff --git a/InCallUI/res/layout/incall_dialpad_fragment.xml b/InCallUI/res/layout/incall_dialpad_fragment.xml
new file mode 100644
index 0000000..b567dbb
--- /dev/null
+++ b/InCallUI/res/layout/incall_dialpad_fragment.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2006 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<view class="com.android.incallui.DialpadFragment$DialpadSlidingLinearLayout"
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/dtmf_twelve_key_dialer_view"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+    <include layout="@layout/dialpad_view"/>
+</view>
diff --git a/InCallUI/res/layout/incall_screen.xml b/InCallUI/res/layout/incall_screen.xml
new file mode 100644
index 0000000..3922ea0
--- /dev/null
+++ b/InCallUI/res/layout/incall_screen.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2007 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- In-call Phone UI; see InCallActivity.java. -->
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@android:color/black"
+    android:id="@+id/main" >
+</FrameLayout>
diff --git a/InCallUI/res/layout/manage_conference_call_button.xml b/InCallUI/res/layout/manage_conference_call_button.xml
new file mode 100644
index 0000000..3b5ef99
--- /dev/null
+++ b/InCallUI/res/layout/manage_conference_call_button.xml
@@ -0,0 +1,61 @@
+<?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
+  -->
+
+<!-- This button is used only on GSM and IMS devices, during a conference call. -->
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/manage_conference_call_button"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:background="@color/incall_banner_secondary_background_color"
+    android:focusable="true"
+    android:contentDescription="@string/onscreenManageConferenceText">
+
+    <Space android:layout_width="match_parent"
+        android:layout_height="1dp"
+        android:background="@color/secondary_call_info_divider_highlight_color" />
+
+    <!-- This LinearLayout nested immediately in a FrameLayout is necessary to apply both a
+         background color and ripple to the button. -->
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:paddingStart="@dimen/secondary_call_info_horizontal_padding"
+        android:paddingEnd="@dimen/secondary_call_info_horizontal_padding"
+        android:paddingTop="@dimen/secondary_call_info_vertical_padding"
+        android:paddingBottom="@dimen/secondary_call_info_vertical_padding"
+        android:background="?android:attr/selectableItemBackground">
+
+        <ImageView android:id="@+id/manageConferenceButtonImage"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:src="@drawable/ic_group_white_24dp"
+            android:tint="@color/incall_banner_secondary_text_color"
+            android:paddingEnd="16dp"
+            android:importantForAccessibility="no" />
+
+        <TextView android:id="@+id/manageConferenceButtonLabel"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:gravity="center_vertical"
+            android:textColor="@color/incall_banner_secondary_text_color"
+            android:textSize="@dimen/secondary_call_info_text_size"
+            android:text="@string/onscreenManageConferenceText"
+            android:importantForAccessibility="no" />
+
+    </LinearLayout>
+
+</FrameLayout>
diff --git a/InCallUI/res/layout/outgoing_call_animation.xml b/InCallUI/res/layout/outgoing_call_animation.xml
new file mode 100644
index 0000000..69ba3d3
--- /dev/null
+++ b/InCallUI/res/layout/outgoing_call_animation.xml
@@ -0,0 +1,22 @@
+<?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
+  -->
+<View xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/outgoing_call_animation_circle"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@color/incall_background_color" />
\ No newline at end of file
diff --git a/InCallUI/res/layout/person_context_info_list_item.xml b/InCallUI/res/layout/person_context_info_list_item.xml
new file mode 100644
index 0000000..4f973d5
--- /dev/null
+++ b/InCallUI/res/layout/person_context_info_list_item.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+     android:layout_width="match_parent"
+     android:layout_height="match_parent"
+     android:paddingRight="@dimen/person_contact_context_horizontal_padding"
+     android:paddingLeft="@dimen/person_contact_context_horizontal_padding">
+     <TextView android:id="@+id/message"
+         android:layout_width="wrap_content"
+         android:layout_height="wrap_content"
+         android:paddingLeft="@dimen/person_contact_context_message_horizontal_padding"
+         android:paddingRight="@dimen/person_contact_context_message_horizontal_padding"
+         android:paddingTop="@dimen/person_contact_context_message_vertical_padding"
+         android:paddingBottom="@dimen/person_contact_context_message_vertical_padding"
+         android:textSize="@dimen/person_contact_context_message_text_size"
+         android:textColor="@color/person_contact_context_message_text_color"
+         android:fontFamily="sans-serif-medium"
+         android:background="@drawable/incoming_sms_background"/>
+      <TextView android:id="@+id/detail"
+         android:layout_width="wrap_content"
+         android:layout_height="wrap_content"
+         android:paddingTop="@dimen/person_contact_context_detail_padding_top"
+         android:textSize="@dimen/person_contact_context_detail_text_size"
+         android:textColor="@color/person_contact_context_detail_text_color"
+         android:fontFamily="sans-serif-medium"
+         android:layout_below="@id/message"/>
+</RelativeLayout>
\ No newline at end of file
diff --git a/InCallUI/res/layout/primary_call_info.xml b/InCallUI/res/layout/primary_call_info.xml
new file mode 100644
index 0000000..2aa583c
--- /dev/null
+++ b/InCallUI/res/layout/primary_call_info.xml
@@ -0,0 +1,221 @@
+<?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
+  -->
+
+<!-- "Call Banner" for primary call, the foregound or ringing call. The "call banner" is a block
+    of info about a single call, including the contact name, phone number, call time counter, and
+    other status info.  This info is shown as a "banner" overlaid across the top of contact photo.
+    -->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+        android:id="@+id/primary_call_banner"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:orientation="vertical"
+        android:paddingStart="@dimen/call_banner_side_padding"
+        android:paddingEnd="@dimen/call_banner_side_padding"
+        android:clipChildren="false"
+        android:clipToPadding="false"
+        android:gravity="center">
+
+    <LinearLayout android:id="@+id/callSubjectLayout"
+                  android:layout_width="match_parent"
+                  android:layout_height="wrap_content"
+                  android:orientation="horizontal"
+                  android:clipChildren="false"
+                  android:clipToPadding="false">
+
+        <TextView android:id="@+id/callSubject"
+                  android:layout_width="wrap_content"
+                  android:layout_height="wrap_content"
+                  android:textAlignment="viewStart"
+                  android:textAppearance="?android:attr/textAppearanceSmall"
+                  android:textColor="@color/incall_call_banner_background_color"
+                  android:textSize="@dimen/call_label_text_size"
+                  android:background="@drawable/subject_bubble"
+                  android:maxLines="2"
+                  android:ellipsize="end"
+                  android:singleLine="false"
+                  android:visibility="gone" />
+    </LinearLayout>
+
+    <LinearLayout android:id="@+id/callStateButton"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:clipChildren="false"
+        android:clipToPadding="false">
+
+        <ImageView android:id="@+id/workProfileIcon"
+            android:src="@drawable/ic_work_profile"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="0"
+            android:layout_marginEnd="8dp"
+            android:baselineAlignBottom="true"
+            android:tint="@color/incall_accent_color"
+            android:scaleType="center"
+            android:visibility="gone" />
+
+        <!-- Subscription provider or WiFi calling icon displayed to the left of the label -->
+        <ImageView android:id="@+id/callStateIcon"
+            android:layout_width="24dp"
+            android:layout_height="match_parent"
+            android:layout_marginEnd="10dp"
+            android:tint="@color/incall_accent_color"
+            android:alpha="0.0"
+            android:scaleType="fitCenter"
+            android:visibility="gone" />
+
+        <ImageView android:id="@+id/videoCallIcon"
+            android:src="@drawable/ic_toolbar_video"
+            android:layout_width="16dp"
+            android:layout_height="match_parent"
+            android:layout_marginEnd="16dp"
+            android:baselineAlignBottom="true"
+            android:tint="@color/incall_accent_color"
+            android:scaleType="center"
+            android:visibility="gone" />
+
+        <com.android.phone.common.widget.ResizingTextTextView
+            xmlns:ex="http://schemas.android.com/apk/res-auto"
+            android:id="@+id/callStateLabel"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:textAlignment="viewStart"
+            android:textAppearance="?android:attr/textAppearanceLarge"
+            android:textColor="@color/incall_accent_color"
+            android:textSize="@dimen/call_status_text_size"
+            android:alpha="0.7"
+            android:singleLine="true"
+            android:gravity="start"
+            android:ellipsize="end"
+            ex:resizing_text_min_size="@dimen/call_status_text_min_size" />
+
+    </LinearLayout>
+
+    <RelativeLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content">
+
+        <!-- Name (or the phone number, if we don't have a name to display). -->
+        <com.android.phone.common.widget.ResizingTextTextView
+            xmlns:ex="http://schemas.android.com/apk/res-auto"
+            android:id="@+id/name"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="-5dp"
+            android:fontFamily="sans-serif-light"
+            android:textAlignment="viewStart"
+            android:textAppearance="?android:attr/textAppearanceLarge"
+            android:textSize="@dimen/call_name_text_size"
+            android:singleLine="true"
+            ex:resizing_text_min_size="@dimen/call_name_text_min_size" />
+
+        <!-- Contact photo for primary call info -->
+        <ImageView android:id="@+id/photoSmall"
+            android:layout_width="@dimen/contact_context_small_photo_size"
+            android:layout_height="@dimen/contact_context_small_photo_size"
+            android:layout_centerVertical="true"
+            android:layout_alignParentEnd="true"
+            android:scaleType="centerCrop"
+            android:importantForAccessibility="no"
+            android:src="@drawable/img_no_image_automirrored" />
+    </RelativeLayout>
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:clipChildren="false"
+        android:clipToPadding="false">
+
+        <ImageView android:id="@+id/hdAudioIcon"
+            android:src="@drawable/ic_hd_24dp"
+            android:layout_width="24dp"
+            android:layout_height="match_parent"
+            android:layout_marginEnd="8dp"
+            android:tint="@color/incall_call_banner_subtext_color"
+            android:scaleType="fitCenter"
+            android:visibility="gone" />
+
+        <ImageView android:id="@+id/forwardIcon"
+            android:src="@drawable/ic_forward_white_24dp"
+            android:layout_width="24dp"
+            android:layout_height="match_parent"
+            android:layout_marginEnd="8dp"
+            android:tint="@color/incall_call_banner_subtext_color"
+            android:scaleType="fitCenter"
+            android:visibility="gone" />
+
+        <!-- Label (like "Mobile" or "Work", if present) and phone number, side by side -->
+        <LinearLayout android:id="@+id/labelAndNumber"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:orientation="horizontal">
+
+            <TextView android:id="@+id/label"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_weight="0"
+                android:textAppearance="?android:attr/textAppearanceSmall"
+                android:textColor="@color/incall_call_banner_subtext_color"
+                android:textSize="@dimen/call_label_text_size"
+                android:singleLine="true"
+                android:textDirection="ltr"
+                android:visibility="gone" />
+
+            <TextView android:id="@+id/phoneNumber"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_weight="1"
+                android:layout_marginStart="6dp"
+                android:textAlignment="viewStart"
+                android:textAppearance="?android:attr/textAppearanceSmall"
+                android:textColor="@color/incall_call_banner_subtext_color"
+                android:textSize="@dimen/call_label_text_size"
+                android:singleLine="false"
+                android:visibility="gone" />
+
+        </LinearLayout>
+
+        <!-- Elapsed time indication for a call in progress. -->
+        <TextView android:id="@+id/elapsedTime"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_weight="0"
+            android:textAlignment="viewEnd"
+            android:textAppearance="?android:attr/textAppearanceSmall"
+            android:textColor="@color/incall_call_banner_subtext_color"
+            android:textSize="@dimen/call_label_text_size"
+            android:singleLine="true"
+            android:visibility="gone" />
+
+    </LinearLayout>
+
+    <!-- Call type indication: a special label and/or branding
+     for certain kinds of calls (like "SIP call" for a SIP call.) -->
+    <TextView android:id="@+id/callTypeLabel"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textAppearance="?android:attr/textAppearanceSmall"
+        android:textColor="@color/incall_call_banner_text_color"
+        android:maxLines="1"
+        android:ellipsize="end"
+        android:visibility="gone" />
+
+</LinearLayout> <!-- End of call_banner -->
diff --git a/InCallUI/res/layout/secondary_call_info.xml b/InCallUI/res/layout/secondary_call_info.xml
new file mode 100644
index 0000000..e866795
--- /dev/null
+++ b/InCallUI/res/layout/secondary_call_info.xml
@@ -0,0 +1,105 @@
+<?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.
+-->
+
+<!-- XML resource file for secondary call info, which will be used by CallCard. -->
+
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/secondary_call_info"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:layout_alignParentBottom="true"
+    android:background="@color/incall_banner_secondary_background_color"
+    android:visibility="gone">
+
+    <Space android:layout_width="match_parent"
+        android:layout_height="1dp"
+        android:background="@color/secondary_call_info_divider_highlight_color" />
+
+    <!-- This LinearLayout nested immediately in a FrameLayout is necessary to apply both a
+         background color and ripple to the button. -->
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:orientation="horizontal"
+        android:paddingStart="@dimen/secondary_call_info_horizontal_padding"
+        android:paddingEnd="@dimen/secondary_call_info_horizontal_padding"
+        android:paddingTop="@dimen/secondary_call_info_vertical_padding"
+        android:paddingBottom="@dimen/secondary_call_info_vertical_padding"
+        android:background="?android:attr/selectableItemBackground">
+
+        <ImageView android:id="@+id/secondaryCallVideoCallIcon"
+                   android:layout_width="wrap_content"
+                   android:layout_height="wrap_content"
+                   android:src="@drawable/ic_toolbar_video"
+                   android:tint="@color/incall_banner_secondary_text_color"
+                   android:paddingEnd="16dp"/>
+
+        <ImageView android:id="@+id/secondaryCallConferenceCallIcon"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:src="@drawable/ic_group_white_24dp"
+            android:tint="@color/incall_banner_secondary_text_color"
+            android:paddingEnd="16dp"/>
+
+        <LinearLayout
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:orientation="vertical">
+
+            <!-- Name (or the phone number, if we don't have a name to display). -->
+            <TextView android:id="@+id/secondaryCallName"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:textColor="@color/incall_banner_secondary_text_color"
+                android:textSize="@dimen/secondary_call_info_text_size"
+                android:textAlignment="viewStart"
+                android:ellipsize="marquee"
+                android:singleLine="true"/>
+
+            <!-- Provider, e.g. AT&T, that a call is associated with -->
+            <LinearLayout android:id="@+id/secondary_call_provider_info"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal"
+                android:visibility="gone" >
+
+                <TextView android:id="@+id/secondaryCallProviderLabel"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:textColor="@color/incall_banner_secondary_text_color"
+                    android:textSize="@dimen/secondary_call_info_text_size"
+                    android:textAlignment="viewStart"
+                    android:singleLine="true"/>
+
+            </LinearLayout>
+
+        </LinearLayout>
+
+        <!-- Call status of the background call, usually the string "On hold". -->
+        <TextView android:id="@+id/secondaryCallStatus"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="center_vertical"
+            android:paddingEnd="18dp"
+            android:text="@string/onHold"
+            android:textColor="@color/incall_banner_secondary_text_color"
+            android:textSize="@dimen/secondary_call_info_text_size"
+            android:singleLine="true" />
+
+    </LinearLayout>
+
+</FrameLayout>
diff --git a/InCallUI/res/layout/video_call_fragment.xml b/InCallUI/res/layout/video_call_fragment.xml
new file mode 100644
index 0000000..d5e11ef
--- /dev/null
+++ b/InCallUI/res/layout/video_call_fragment.xml
@@ -0,0 +1,28 @@
+<?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
+  -->
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <ViewStub
+        android:id="@+id/videoCallViewsStub"
+        android:inflatedId="@+id/videoCallViews"
+        android:layout="@layout/video_call_views"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+</FrameLayout>
\ No newline at end of file
diff --git a/InCallUI/res/layout/video_call_views.xml b/InCallUI/res/layout/video_call_views.xml
new file mode 100644
index 0000000..b0c6ce2
--- /dev/null
+++ b/InCallUI/res/layout/video_call_views.xml
@@ -0,0 +1,66 @@
+<?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
+  -->
+
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" >
+
+    <TextureView
+        android:id="@+id/incomingVideo"
+        android:layout_gravity="center"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+    <!-- The width and height are replaced at runtime based on the selected camera. -->
+    <FrameLayout
+        android:id="@+id/previewVideoContainer"
+        android:layout_width="70dp"
+        android:layout_height="120dp"
+        android:layout_gravity="bottom|right"
+        android:layout_margin="@dimen/video_preview_margin" >
+
+        <!-- The video preview surface, where the user's outgoing video is shown. -->
+        <TextureView
+            android:id="@+id/previewVideo"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent" />
+
+        <!-- The user's profile photo, shown when the user's camera is shut off. -->
+        <ImageView
+            android:id="@+id/previewProfilePhoto"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:scaleType="centerInside"
+            android:adjustViewBounds="false"
+            android:contentDescription="@string/profile_photo_description"
+            android:background="@android:color/black"
+            android:visibility="gone" />
+
+        <!-- The "camera off" icon, shown when the user's camera is shut off. -->
+        <ImageView
+            android:id="@+id/previewCameraOff"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="bottom|right"
+            android:layout_marginEnd="10dp"
+            android:layout_marginBottom="10dp"
+            android:scaleType="centerCrop"
+            android:contentDescription="@string/camera_off_description"
+            android:src="@drawable/ic_toolbar_video_off"
+            android:visibility="gone" />
+    </FrameLayout>
+</FrameLayout>
diff --git a/InCallUI/res/menu/incall_audio_mode_menu.xml b/InCallUI/res/menu/incall_audio_mode_menu.xml
new file mode 100644
index 0000000..070c181
--- /dev/null
+++ b/InCallUI/res/menu/incall_audio_mode_menu.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 Google Inc.
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- "Audio mode" popup menu for the in-call UI. -->
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- TODO: Need final icon assets.  Also, PopupMenu currently ignores the
+         android:icon attribute anyway(!) -->
+    <item android:id="@+id/audio_mode_speaker"
+          android:icon="@drawable/ic_toolbar_speaker_on"
+          android:title="@string/audio_mode_speaker" />
+
+    <!-- We display *either* "earpiece" or "wired headset", never both,
+         depending on whether a wired headset is physically plugged in
+         (see InCallTouchUi.showAudioModePopup().) -->
+    <item android:id="@+id/audio_mode_earpiece"
+          android:icon="@drawable/ic_toolbar_audio_phone"
+          android:title="@string/audio_mode_earpiece" />
+
+    <item android:id="@+id/audio_mode_wired_headset"
+          android:icon="@drawable/ic_toolbar_audio_headphones"
+          android:title="@string/audio_mode_wired_headset" />
+
+    <item android:id="@+id/audio_mode_bluetooth"
+          android:icon="@drawable/ic_toolbar_audio_bluetooth"
+          android:title="@string/audio_mode_bluetooth" />
+</menu>
diff --git a/InCallUI/res/values-af/strings.xml b/InCallUI/res/values-af/strings.xml
new file mode 100644
index 0000000..e99da46
--- /dev/null
+++ b/InCallUI/res/values-af/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Foon"</string>
+    <string name="onHold" msgid="527593602772521700">"Hou aan"</string>
+    <string name="unknown" msgid="3646075119047488748">"Onbekend"</string>
+    <string name="private_num" msgid="6081418498487514686">"Privaat nommer"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefoonhokkie"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferensie-oproep"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Oproep is ontkoppel"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Luidspreker"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Selfoonoorfoon"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Bedraade kopfoon"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Stuur die volgende luitone?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Stuur luitone\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Stuur"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ja"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Nee"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Vervang die plekhouerkarakter met"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferensie-oproep <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Stemboodskapnommer"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Bel"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Bel tans weer"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferensie-oproep"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Inkomende oproep"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Inkomende werkoproep"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Oproep beëindig"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Hou aan"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Lui af"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"In oproep"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"My nommer is <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Koppel tans video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Video-oproep"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Versoek tans video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Kan nie video-oproep koppel nie"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Videoversoek is verwerp"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Jou terugbelnommer\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Jou noodterugbelnommer\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Bel"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Gemiste oproep"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Gemiste oproepe"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> gemiste oproepe"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Gemiste oproep vanaf <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Voortdurende oproep"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Voortdurende werkoproep"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Voortdurende Wi-Fi-oproep"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Voortdurende Wi-Fi-werkoproep"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Hou aan"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Inkomende oproep"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Inkomende werkoproep"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Inkomende Wi-Fi-oproep"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Inkomende Wi-Fi-werkoproep"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Inkomende video-oproep"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Inkomende videoversoek"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nuwe stemboodskap"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nuwe stemboodskap (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Bel <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Stemboodskapnommer is onbekend"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Geen diens nie"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Gekose netwerk (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) is nie beskikbaar nie"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Antwoord"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Lui af"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Stem"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Aanvaar"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Maak toe"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Bel terug"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Boodskap"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Skakel vliegtuigmodus eers af om \'n oproep te maak."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Nie geregistreer op netwerk nie."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Sellulêre netwerk is nie beskikbaar nie."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Voer \'n geldige nommer in om \'n oproep te maak."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Kan nie bel nie."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Begin tans MMI-volgorde …"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Diens word nie gesteun nie."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Kan nie oproepe wissel nie."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Kan nie oproep skei nie."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Kan nie deurskakel nie."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Kan nie konferensie-oproep maak nie."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Kan nie oproep weier nie."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Kan nie oproep(e) vrystel nie."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP-oproep"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Noodoproep"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Skakel tans radio aan …"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Geen sein nie. Probeer tans weer …"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Kan nie bel nie. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> is nie \'n noodnommer nie."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Kan nie bel nie. Bel \'n noodnommer."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Gebruik sleutelbord om te bel"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Hou oproep"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Hervat oproep"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Beëindig oproep"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Belblad"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Demp"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Voeg oproep by"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Smelt oproepe saam"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Ruil"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Bestuur oproepe"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Bestuur konferensie-oproep"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Oudio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Video-oproep"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Verander na stemoproep"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Wissel kamera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Laat video wag"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Nog opsies"</string>
+    <string name="player_started" msgid="3478865572468310331">"Speler het begin"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Speler het gestop"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera is nie gereed nie"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera is gereed"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Onbekende oproepsessiegebeurtenis"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Diens"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Opstelling"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Nie gestel nie&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Ander oproepinstellings"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Bel via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Inkomend via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"kontakfoto"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"gaan privaat"</string>
+    <string name="selectContact" msgid="92191462970821951">"kies kontak"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Skryf jou eie …"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Kanselleer"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Stuur"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Antwoord"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Stuur SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Weier"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Antwoord as video-oproep"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Antwoord as oudio-oproep"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Aanvaar videoversoek"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Weier videoversoek"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Aanvaar videoversendversoek"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Weier videoversendversoek"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Aanvaar video-ontvangversoek"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Weier video-ontvangversoek"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Gly op vir <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Gly links vir <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Gly regs vir <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Gly af vir <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibreer"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibreer"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Klank"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Verstekklank (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Foon-luitoon"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibreer wanneer dit lui"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Luitoon en vibreer"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Bestuur konferensie-oproep"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Noodnommer"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekondes</item>
+      <item quantity="one">1 sekonde</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minute</item>
+      <item quantity="one">1 minuut</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> uur</item>
+      <item quantity="one">1 uur</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profielfoto"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera is af"</string>
+    <string name="child_number" msgid="4469090994612105532">"via <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Nota is gestuur"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Onlangse boodskappe"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Besigheidinligting"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> myl ver"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km ver"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Maak môre om <xliff:g id="OPEN_TIME">%s</xliff:g> oop"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Maak vandag om <xliff:g id="OPEN_TIME">%s</xliff:g> oop"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Maak om <xliff:g id="CLOSE_TIME">%s</xliff:g> toe"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Het vandag om <xliff:g id="CLOSE_TIME">%s</xliff:g> toegemaak"</string>
+    <string name="open_now" msgid="4615706338669555999">"Nou oop"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Nou gesluit"</string>
+</resources>
diff --git a/InCallUI/res/values-am/strings.xml b/InCallUI/res/values-am/strings.xml
new file mode 100644
index 0000000..ebfc0dd
--- /dev/null
+++ b/InCallUI/res/values-am/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"ስልክ"</string>
+    <string name="onHold" msgid="527593602772521700">"ያዝና ቆይ"</string>
+    <string name="unknown" msgid="3646075119047488748">"ያልታወቀ"</string>
+    <string name="private_num" msgid="6081418498487514686">"የግል ቁጥር"</string>
+    <string name="payphone" msgid="5743050584468748607">"የሕዝብ ስልክ"</string>
+    <string name="confCall" msgid="3181961445236675173">"የስብሰባ ጥሪ"</string>
+    <string name="call_lost" msgid="8208184291640961172">"ጥሪው ተቋርጧል"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"ድምፅ ማጉያ"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"የስልክ ጆሮ ማዳመጫ"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"ባለ ገመድ የጆሮ ማዳመጫ"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"ብሉቱዝ"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"የሚከተሉትን የጥሪ ድምፆች ላክ?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"የጥሪ ድምፆች በመላክ ላይ \n"</string>
+    <string name="send_button" msgid="4054398309483035794">"ላክ"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"አዎ"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"አይ"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"የልቅ ምልክት ተካ በ"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"የስብሰባ ጥሪ <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"የድምፅ መልእክት ቁጥር"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"በመደወል ላይ"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"ዳግም በመደወል ላይ"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"የስብሰባ ጥሪ"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"ገቢ ጥሪ"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"ገቢ የሥራ ጥሪ"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"ጥሪ አብቅቷል"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"ያዝና ቆይ"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"በመዝጋት ላይ"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"ጥሪ ላይ"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"ቁጥሬ <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g> ነው"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"ቪድዮ በማገናኘት ላይ"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"የቪዲዮ ጥሪ"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"ቪድዮ በመጠየቅ ላይ"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"የቪዲዮ ጥሪን ማገናኘት አይቻልም"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"የቪዲዮ ጥያቄ ውድቅ ተደርጓል"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"የእርስዎ የመልሶ መደወያ ቁጥር\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"የእርስዎ የድንገተኛ አደጋ መልሶ መደወያ ቁጥር\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"በመደወል ላይ"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"ያመለጠ ጥሪ"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"ያመለጡ ጥሪዎች"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ያመለጡ ጥሪዎች"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"ያልተመለሰ ጥሪ ከ<xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"በሂደት ላይ ያለ ጥሪ"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"በሂደት ላይ ያለ የሥራ ጥሪ"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"በሂደት ላይ ያለ የWi-Fi ጥሪ"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"በሂደት ላይ ያለ የWi-Fi የሥራ ጥሪ"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"ያዝና ቆይ"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"ገቢ ጥሪ"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"ገቢ የሥራ ጥሪ"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"ገቢ የWi-Fi ጥሪ"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"ገቢ የWi-Fi የሥራ ጥሪ"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"ገቢ የቪዲዮ ጥሪ"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"ገቢ የቪዲዮ ጥያቄ"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"አዲስ የድምፅ መልእክት"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"አዲስ የድምፅ መልእክት (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"ደውል <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"የማይታወቅ የድምፅ መልእክት ቁጥር"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"ምንም አገልግሎት የለም"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"የተመረጠ አውታረመረብ (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) አይገኝም"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"መልስ"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"ዝጋ"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"ቪዲዮ"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"ድምፅ"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"ተቀበል"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"አስወግድ"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"መልሰህ ደውል"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"መልእክት"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"ለመደወል፣ መጀመሪያ የአውሮፕላኑን ሁኔታ ያጥፉ።"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"በአውታረ መረቡ ላይ አልተመዘገበም።"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"የተንቀሳቃሽ ስልክ አውታረ መረብ አይገኝም።"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"አንድ ጥሪ ለማድረግ የሚሠራ ቁጥር ያስገቡ።"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"መደወል አይቻልም።"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"የMMI ቅደመ ተከተል በማስጀመር ላይ…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"አገልግሎት አይደገፍም።"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"ጥሪዎችን መቀያየር አይቻልም።"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"ጥሪን መለየት አይቻልም።"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"ማስተላለፍ አይቻልም።"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"የጉባዔ ጥሪ ማድረግ አይቻልም።"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"ጥሪውን መዝጋት አይቻልም።"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"ጥሪ(ዎች)ን መልቀቅ አይቻልም።"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"የSIP ጥሪ"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"የአስቸኳይ ጊዜ ጥሪ"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"ሬዲዮ በማብራት ላይ…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"ምንም አገልግሎት የለም። ዳግም በመሞከር ላይ…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"መደወል አይቻልም። <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> የአስቸኳይ አደጋ ቁጥር አይደለም።"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"መደወል አይቻልም። ወደ የአስቸኳይ አደጋ ቁጥር ይደውሉ።"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ለመደወል የሰሌዳ ቁልፍ ተጠቀም"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"ጥሪ አቆይ"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"ጥሪ ቀጥል"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"ጥሪ ጨርስ"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"መደወያ ሰሌዳ"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"ድምፅ-ከል አድርግ"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"ጥሪ ያክሉ"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"ጥሪዎችን አዋህድ"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"በውዝ"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"ጥሪዎችን አደራጅ"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"የስብሰባ ስልክ ጥሪ አደራጅ"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"ኦዲዮ"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"የቪዲዮ ጥሪ"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"ወደ ድምፅ ጥሪ ይለውጡ"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"ካሜራ ቀይር"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"ቪድዮ ለአፍታ አቁም"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"ተጨማሪ አማራጮች"</string>
+    <string name="player_started" msgid="3478865572468310331">"አጫዋች ጀምሯል"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"አጫዋች ቆሟል"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"ካሜራ ዝግጁ አይደለም"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"ካሜራ ዝግጁ ነው"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"ያልታወቀ የጥሪ ክፍለጊዜ ክስተት"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"አገልግሎት"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"አዋቅር"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;አልተዘጋጀም&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"ሌሎች የጥሪ ቅንብሮች"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"በ<xliff:g id="PROVIDER_NAME">%s</xliff:g> በኩል በመደወል ላይ"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"በ<xliff:g id="PROVIDER_NAME">%s</xliff:g> በኩል የመጣ"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"የዕውቂያ ፎቶ"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"ወደ ግላዊነት ሂድ"</string>
+    <string name="selectContact" msgid="92191462970821951">"ዕውቂያ ይምረጡ"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"የእራስዎን ይጻፉ..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"ተወው"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"ላክ"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"መልስ"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"ኤስኤምኤስ ላክ"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"ውድቅ አድርግ"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"እንደ ቪድዮ ጥሪ ይመልሱ"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"እንደ ድምፅ ጥሪ ይመልሱ"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"የቪዲዮ ጥያቄ ተቀበል"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"የቪዲዮ ጥያቄ ውድቅ አድርግ"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"የቪዲዮ አስተላልፍ ጥያቄን ተቀበል"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"የቪዲዮ አስተላልፍ ጥያቄን ውድቅ አድርግ"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"የቪዲዮ ተቀበል ጥያቄን ተቀበል"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"የቪዲዮ ተቀበል ጥያቄን ውድቅ አድርግ"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"ለ<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ወደ ላይ ያንሸራትቱ።"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"ለ<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ወደ ግራ ያንሸራትቱ።"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"ለ<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ወደ ቀኝ ያንሸራትቱ።"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"ለ<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ወደ ታች ያንሸራትቱ።"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"ንዘር"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"ንዘር"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"ድምፅ"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"ነባሪ ድምፅ (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"የስልክ ጥሪ ቅላጼ"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"በሚደወልበት ጊዜ ንዘር"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"የጥሪ ቅላጼ እና ንዘረት"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"የስብሰባ ስልክ ጥሪ አደራጅ"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"የአደጋ ጊዜ ቁጥር"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ሰከንዶች</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ሰከንዶች</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ደቂቃዎች</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ደቂቃዎች</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ሰዓቶች</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ሰዓቶች</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"የመገለጫ ፎቶ"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"ካሜራ ጠፍቷል"</string>
+    <string name="child_number" msgid="4469090994612105532">"በ<xliff:g id="CHILD_NUMBER">%s</xliff:g> በኩል"</string>
+    <string name="note_sent" msgid="7623014827902758398">"ማስታወሻ ተልኳል"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"የቅርብ ጊዜ መልእክቶች"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"የንግድ መረጃ"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> ማይል ርቀት ላይ"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> ኪሜ ርቀት ላይ"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>፣ <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>፣ <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"ነገ <xliff:g id="OPEN_TIME">%s</xliff:g> ላይ ይከፈታል"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"ዛሬ <xliff:g id="OPEN_TIME">%s</xliff:g> ላይ ይከፈታል"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g> ላይ ይዘጋል"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"ዛሬ <xliff:g id="CLOSE_TIME">%s</xliff:g> ላይ ተዘግቷል"</string>
+    <string name="open_now" msgid="4615706338669555999">"አሁን ክፍት ነው"</string>
+    <string name="closed_now" msgid="2635314668145282080">"አሁን ዝግ ነው"</string>
+</resources>
diff --git a/InCallUI/res/values-ar/strings.xml b/InCallUI/res/values-ar/strings.xml
new file mode 100644
index 0000000..f988032
--- /dev/null
+++ b/InCallUI/res/values-ar/strings.xml
@@ -0,0 +1,204 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"الهاتف"</string>
+    <string name="onHold" msgid="527593602772521700">"معلقة"</string>
+    <string name="unknown" msgid="3646075119047488748">"غير معروف"</string>
+    <string name="private_num" msgid="6081418498487514686">"رقم خاص"</string>
+    <string name="payphone" msgid="5743050584468748607">"هاتف بالعملة"</string>
+    <string name="confCall" msgid="3181961445236675173">"مكالمة جماعية"</string>
+    <string name="call_lost" msgid="8208184291640961172">"تم قطع المكالمة"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"السماعة"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"سماعة الأذن للهاتف"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"سماعة رأس سلكية"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"بلوتوث"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"هل تريد إرسال النغمات التالية؟\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"إرسال النغمات\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"إرسال"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"نعم"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"لا"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"استبدال حرف البدل بـ"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"مكالمة جماعية <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"رقم البريد الصوتي"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"جارٍ الطلب"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"جارٍ إعادة الطلب"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"مكالمة جماعية"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"مكالمة واردة"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"مكالمة عمل واردة"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"تم إنهاء الاتصال"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"معلقة"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"جارٍ وقف المكالمة"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"بصدد مكالمة"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"رقمي <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"جارٍ الاتصال بالفيديو"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"مكالمة فيديو"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"جارٍ طلب الفيديو"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"يتعذر الاتصال بمكالمة فيديو"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"تم رفض طلب الفيديو"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"رقم معاودة الاتصال\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"رقم معاودة اتصال الطوارئ\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"جارٍ الطلب"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"مكالمة فائتة"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"المكالمات الفائتة"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> من المكالمات الفائتة"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"مكالمة فائتة من <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"مكالمة حالية"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"مكالمة عمل جارية"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"‏مكالمة جارية عبر Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"‏مكالمة عمل جارية عبر Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"معلقة"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"مكالمة واردة"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"مكالمة عمل واردة"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"‏مكالمة واردة عبر Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"‏مكالمة عمل واردة عبر اتصال Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"مكالمة فيديو واردة"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"طلب فيديو وارد"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"بريد صوتي جديد"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"بريد صوتي جديد (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"طلب <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"رقم البريد الصوتي غير معروف"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"لا تتوفر خدمة"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"الشبكة المحددة (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) غير متاحة"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"رد"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"قطع الاتصال"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"فيديو"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"صوت"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"قبول"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"تجاهل"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"معاودة الاتصال"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"رسالة"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"لإجراء مكالمة، أوقف تشغيل وضع الطائرة أولاً."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"غير مسجل على الشبكة."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"شبكة الجوّال غير متاحة."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"لإجراء مكالمة، أدخل رقمًا صالحًا."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"يتعذر الاتصال."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"‏جارٍ بدء تسلسل MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"الخدمة ليست متوفرة."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"يتعذر تبديل المكالمات."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"يتعذر فصل المكالمة."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"يتعذر النقل."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"يتعذر إجراء مكالمة جماعية."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"يتعذر رفض المكالمة."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"يتعذر تحرير المكالمات."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"‏مكالمة SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"مكالمة طوارئ"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"جارٍ تشغيل اللاسلكي..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"لا تتوفر خدمة. جارٍ إعادة المحاولة…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"يتعذر الاتصال. لا يعد <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> رقم طوارئ."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"يتعذر الاتصال. يمكنك طلب رقم طوارئ"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"استخدام لوحة المفاتيح للطلب"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"تعليق المكالمة"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"استئناف المكالمة"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"إنهاء المكالمة"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"لوحة الاتصال"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"تجاهل"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"إضافة مكالمة"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"دمج المكالمات"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"تبديل"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"إدارة المكالمات"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"إدارة مكالمة جماعية"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"صوت"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"مكالمة فيديو"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"التغيير إلى مكالمة صوتية"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"تبديل الكاميرا"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"إيقاف الفيديو مؤقتًا"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"خيارات أخرى"</string>
+    <string name="player_started" msgid="3478865572468310331">"تم بدء المشغّل"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"تم إيقاف المشغّل"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"الكاميرا غير جاهزة"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"الكاميرا جاهزة"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"حدث جلسة اتصال غير معروف"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"الخدمة"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"الإعداد"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"‏&lt;لم يتم التعيين&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"إعدادات الاتصال الأخرى"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"الاتصال عبر <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"واردة عبر <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"صورة جهة الاتصال"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"انتقال إلى مكالمة خاصة"</string>
+    <string name="selectContact" msgid="92191462970821951">"تحديد جهة اتصال"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"اكتب ردك…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"إلغاء"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"إرسال"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"الرد"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"‏إرسال رسالة قصيرة SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"الرفض"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"الرد بمكالمة فيديو"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"الرد بمكالمة صوتية"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"قبول طلب الفيديو"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"رفض طلب الفيديو"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"قبول طلب بث الفيديو"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"رفض طلب بث الفيديو"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"قبول طلب استلام مكالمة الفيديو"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"رفض طلب استلام مكالمة الفيديو"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"تمرير لأعلى لـ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"تمرير لليسار لـ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"تمرير لليمين لـ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"تمرير لأسفل لـ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"اهتزاز"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"اهتزاز"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"الصوت"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"الصوت الافتراضي (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"نغمة رنين الهاتف"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"اهتزاز عند الرنين"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"نغمة الرنين والاهتزاز"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"إدارة مكالمة جماعية"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"رقم الطوارئ"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="zero"><xliff:g id="COUNT">%d</xliff:g> ثانية</item>
+      <item quantity="two">ثانيتان (<xliff:g id="COUNT">%d</xliff:g>)</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> ثوانٍ</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> ثانية</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ثانية</item>
+      <item quantity="one">ثانية واحدة</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="zero"><xliff:g id="COUNT">%d</xliff:g> دقيقة</item>
+      <item quantity="two">دقيقتان (<xliff:g id="COUNT">%d</xliff:g>)</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> دقائق</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> دقيقة</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> دقيقة</item>
+      <item quantity="one">دقيقة واحدة</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="zero"><xliff:g id="COUNT">%d</xliff:g> ساعة</item>
+      <item quantity="two">ساعتان (<xliff:g id="COUNT">%d</xliff:g>)</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> ساعات</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> ساعة</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ساعة</item>
+      <item quantity="one">ساعة واحدة</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"صورة الملف الشخصي"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"تم إيقاف الكاميرا"</string>
+    <string name="child_number" msgid="4469090994612105532">"عبر <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"تم إرسال الملاحظة"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"الرسائل الأخيرة"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"معلومات النشاط التجاري"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"على بُعد <xliff:g id="DISTANCE">%.1f</xliff:g> ميل"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"على بُعد <xliff:g id="DISTANCE">%.1f</xliff:g> كم"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>، <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>، <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"مفتوح غدًا في <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"مفتوح اليوم في <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"مغلق في <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"مغلق اليوم في <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"مفتوح الآن"</string>
+    <string name="closed_now" msgid="2635314668145282080">"مغلق الآن"</string>
+</resources>
diff --git a/InCallUI/res/values-az-rAZ/strings.xml b/InCallUI/res/values-az-rAZ/strings.xml
new file mode 100644
index 0000000..437f558
--- /dev/null
+++ b/InCallUI/res/values-az-rAZ/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Gözləmə mövqeyində"</string>
+    <string name="unknown" msgid="3646075119047488748">"Naməlum"</string>
+    <string name="private_num" msgid="6081418498487514686">"Şəxsi nömrə"</string>
+    <string name="payphone" msgid="5743050584468748607">"Taksofon"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konfrans zəngi"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Zəng bitdi"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Dinamik"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Dəstək qulaqlığı"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Simli qulaqlıq"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Aşağıdakı tonlar göndərilsin?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Tonlar göndərilir\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Göndər"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Bəli"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Xeyr"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Joker simvolları əvəz edin"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konfrans zəngi <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Səsli poçt nömrəsi"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Nömrə yığılır"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Yenidən yığır"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konfrans zəngi"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Gələn zəng"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Daxil olan iş çağrısı"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Zəng sona çatdı"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Gözləmə mövqeyində"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Dəstək asılır"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Çağrıda"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mənim nömrəm <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Video qoşulur"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Video zəng"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Video sorğusu göndərilir"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Video zəngə qoşulmaq mümkün deyil"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Video sorğusu rədd edildi"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Cavab zəngi nömrəniz\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Təcili cavab zəngi nömrəniz\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Nömrə yığılır"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Buraxılmış zəng"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Buraxılmış zənglər"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> buraxılmış zənglər"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> tərəfindən zəng buraxılıb"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Davam edən çağrı"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Davam edən iş çağrısı"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Davam edən Wi-Fi zəngi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Davam edən Wi-Fi iş çağrısı"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Gözləmə mövqeyində"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Gələn zəng"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Daxil olan iş çağrısı"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Gələn Wi-Fi zəngi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Daxil olan Wi-Fi iş çağrısı"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Gələn video zəng"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Gələn video çağrı"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Yeni səsli poçt"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Yeni səsli poçt (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Yığın <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Səsli poçt nömrəsi naməlumdur"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Xidmət yoxdur"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Seçilmiş (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) şəbəkə əlçatmazdır"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Cavab"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Dəstəyi qoyun"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Videolar"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Səs"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Qəbul edin"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Rədd edin"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Geriyə zəng"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Mesaj"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Zəng etmək üçün ilk olaraq Uçuş Rejimini söndürün."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Şəbəkədə qeydə alınmayıb."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobil şəbəkə əlçatan deyil"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Zəngi yerləşdirmək üçün düzgün nömrə daxil edin."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Zəng etmək mümkün deyil."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI başlanma ardıcıllığı…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Xidmət dəstəklənmir."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Zəngləri keçirmək mümkün deyil."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Zəngi ayırmaq mümkün deyil."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Ötürmək mümkün deyil."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Konfrans keçirmək mümkün deyil."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Zəngi rədd etmək mümkün deyil."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Zəngləri buraxmaq mümkün deyil."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP çağrısıs"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Təcili zəng"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Radio yandırılır ..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Xidmət yoxdur. Yenidən cəhd edilir…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Zəng etmək mümkün deyil. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> fövqəladə nömrə deyil."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Zəng etmək mümkün deyil. Fövqəladə nömrəni yı"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Nömrə yığmaq üçün klaviaturadan istifadə ediin"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Zəngi gözlədin"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Zəngə davam edin"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Zəngi bitirin"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Yığım paneli"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Susdurun"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Zəng əlavə edin"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Zəngləri birləşdirin"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Dəyişdirin"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Zəngləri idarə edin"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Konfrans çağrısını idarə edin"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Video zəng"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Səsli çağrıya dəyişin"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Kameraya keçin"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Videonu durdurun"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Daha çox seçim"</string>
+    <string name="player_started" msgid="3478865572468310331">"Pleyer Başladıldı"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Pleyer Dayandırıldı"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera hazır deyil"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera hazırdır"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Naməlum zəng sessiyası"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Xidmət"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Quraşdırma"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Təyin edilməyib&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Digər zəng parametrləri"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> vasitəsi ilə zəng edilir"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> vasitəsilə gələn"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"kontakt fotosu"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"şəxsi rejimə keçin"</string>
+    <string name="selectContact" msgid="92191462970821951">"kontakt seçin"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Özünüzünkünü yazın"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Ləğv edin"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Göndər"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Cavab"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS göndərin"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"İmtina edin"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Video çağrı olaraq cavab verin"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Audio çağrı olaraq cavab verin"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Video sorğusunu qəbul edin"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Video sorğusunu ləğv edin"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Video ötürmə sorğusunu qəbul edin"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Video ötürmə sorğusunu ləğv edin"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Video qəbuletmə sorğusunu qəbul edin"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Video qəbuletmə sorğusunu ləğv edin"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> üçün yuxarı sürüşdürün."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> üçün sola sürüşdürün."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> üçün sağa sürüşdürün."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> üçün aşağı sürüşdürün."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrasiya"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrasiya"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Səs"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Defolt səs (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Telefon zəng səsi"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Zəng çalanda vibrasiya olsun"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Zəng səsi &amp; Vibrasiya"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Konfrans çağrısını idarə edin"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Təcili nömrə"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> saniyə</item>
+      <item quantity="one">1 saniyə</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> dəqiqə</item>
+      <item quantity="one">1 dəqiqə</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> saat</item>
+      <item quantity="one">1 saat</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profil fotosu"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera deaktivdir"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> vasitəsilə"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Qeyd göndərildi"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Son mesajlar"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Biznes məlumatı"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mil uzaqlıqda"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km uzaqlıqda"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Sabah saat <xliff:g id="OPEN_TIME">%s</xliff:g> açılır"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Bu gün saat <xliff:g id="OPEN_TIME">%s</xliff:g> açılır"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Saat <xliff:g id="CLOSE_TIME">%s</xliff:g> bağlanır"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Bu gün saat <xliff:g id="CLOSE_TIME">%s</xliff:g> bağlanıb"</string>
+    <string name="open_now" msgid="4615706338669555999">"İndi açın"</string>
+    <string name="closed_now" msgid="2635314668145282080">"İndi bağlandı"</string>
+</resources>
diff --git a/InCallUI/res/values-b+sr+Latn/strings.xml b/InCallUI/res/values-b+sr+Latn/strings.xml
new file mode 100644
index 0000000..deea4aa
--- /dev/null
+++ b/InCallUI/res/values-b+sr+Latn/strings.xml
@@ -0,0 +1,195 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Na čekanju"</string>
+    <string name="unknown" msgid="3646075119047488748">"Nepoznat"</string>
+    <string name="private_num" msgid="6081418498487514686">"Privatan broj"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefonska govornica"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferencijski poziv"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Poziv je prekinut"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Zvučnik"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Slušalica telefona"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Žičane naglavne slušalice"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Želite li da pošaljete sledeće tonove?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Tonovi se šalju\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Pošalji"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Da"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Ne"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Zamenite džoker znak sa"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferencijski poziv <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Broj govorne pošte"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Poziva se"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Ponovo se bira"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferencijski poziv"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Dolazni poziv"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Dolazni poziv za Work"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Poziv je završen"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Na čekanju"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Veza se prekida"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Poziv je u toku"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Moj broj je <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Povezuje se video poziv"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Video poziv"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Zahteva se video poziv"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Povezivanje video poziva nije uspelo"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Zahtev za video poziv je odbijen"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Broj za povratni poziv\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Broj za hitan povratni poziv\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Poziva se"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Propušten poziv"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Propušteni pozivi"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"Broj propuštenih poziva: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Propušten poziv od: <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Tekući poziv"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Tekući poziv za Work"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Tekući Wi-Fi poziv"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Tekući poziv za Work preko Wi-Fi-ja"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Na čekanju"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Dolazni poziv"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Dolazni poziv za Work"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Dolazni Wi-Fi poziv"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Dolazni poziv za Work preko Wi-Fi-ja"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Dolazni video poziv"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Zahtev za dolazni video poziv"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nova poruka govorne pošte"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nova poruka govorne pošte (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Pozovi <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Nepoznat broj govorne pošte"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Mobilna mreža nije dostupna"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Izabrana mreža (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) nije dostupna"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Odgovori"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Prekini vezu"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Glasovni"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Prihvatam"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Odbaci"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Uzvrati poziv"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Pošalji SMS"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Da biste uputili poziv, prvo isključite režim rada u avionu."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Nije registrovano na mreži."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobilna mreža nije dostupna."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Da biste uputili poziv, unesite važeći broj."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Poziv nije uspeo."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Pokreće se MMI sekvenca..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Usluga nije podržana."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Zamena poziva nije uspela."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Razdvajanje poziva nije uspelo."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Prebacivanje nije uspelo."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Konferencijski poziv nije uspeo."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Odbijanje poziva nije uspelo."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Uspostavljanje poziva nije uspelo."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP poziv"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Hitni poziv"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Uključuje se radio…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Mobilna mreža nije dostupna. Pokušavamo ponovo…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Poziv nije uspeo. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> nije broj za hitne slučajeve."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Poziv nije uspeo. Pozovite broj za hitne slučajeve."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Koristite tastaturu za pozivanje"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Stavi poziv na čekanje"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Nastavi poziv"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Završi poziv"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Numerička tastatura"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Ignoriši"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Dodaj poziv"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Objedini pozive"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Zameni"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Upravljaj pozivima"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Upravljaj konferencijskim pozivom"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Video poziv"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Promeni u glasovni poziv"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Promeni kameru"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pauziraj video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Još opcija"</string>
+    <string name="player_started" msgid="3478865572468310331">"Plejer je pokrenut"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Plejer je zaustavljen"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera nije spremna"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera je spremna"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Nepoznat događaj sesije poziva"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Usluga"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Podešavanje"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Nije podešeno&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Druga podešavanja poziva"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Poziva se preko dobavljača <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Dolazni poziv preko <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"slika kontakta"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"idi na privatno"</string>
+    <string name="selectContact" msgid="92191462970821951">"izaberite kontakt"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Napišite sami…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Otkaži"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Pošalji"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Odgovori"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Pošalji SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Odbij"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Odgovori video pozivom"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Odgovori audio-pozivom"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Prihvati zahtev za video"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Odbij zahtev za video"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Prihvati zahtev za odlazni video poziv"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Odbij zahtev za odlazni video poziv"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Prihvati zahtev za dolazni video poziv"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Odbij zahtev za dolazni video poziv"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Prevucite nagore za <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Prevucite ulevo za <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Prevucite udesno za <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Prevucite nadole za <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibracija"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibracija"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Zvuk"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Podrazumevani zvuk (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Melodija zvona telefona"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibriraj kada zvoni"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Melodija zvona i vibracija"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Upravljaj konferencijskim pozivom"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Broj za hitne slučajeve"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> sekunda</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> sekunde</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekundi</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> minut</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> minuta</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minuta</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> sat</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> sata</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sati</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Slika profila"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera je isključena"</string>
+    <string name="child_number" msgid="4469090994612105532">"na <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Beleška je poslata"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Nedavne poruke"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informacije o preduzeću"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"Udaljenost je <xliff:g id="DISTANCE">%.1f</xliff:g> mi"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"Udaljenost je <xliff:g id="DISTANCE">%.1f</xliff:g> km"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>–<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Otvara se sutra u <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Otvara se danas u <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Zatvara se u <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Zatvorilo se danas u <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Trenutno otvoreno"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Trenutno zatvoreno"</string>
+</resources>
diff --git a/InCallUI/res/values-bg/strings.xml b/InCallUI/res/values-bg/strings.xml
new file mode 100644
index 0000000..4c2d709
--- /dev/null
+++ b/InCallUI/res/values-bg/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Телефон"</string>
+    <string name="onHold" msgid="527593602772521700">"Задържано"</string>
+    <string name="unknown" msgid="3646075119047488748">"Неизвестно лице"</string>
+    <string name="private_num" msgid="6081418498487514686">"Частен номер"</string>
+    <string name="payphone" msgid="5743050584468748607">"Обществен телефон"</string>
+    <string name="confCall" msgid="3181961445236675173">"Конферентно обаждане"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Обаждането бе прекъснато"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Високоговорител"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Телефонна слушалка"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Слушалки с кабел"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Да се изпратят ли следните мелодии? \n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Мелодиите се изпращат\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Изпращане"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Да"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Не"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Замяна на заместващия символ със:"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Конферентно обаждане – <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Номер за гласова поща"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Набира се"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Набира се отново"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Конферентно обаждане"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Входящо обаждане"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Входящо служебно обаждане"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Обаждането завърши"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Задържано"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Разговорът се приключва"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Извършва се обаждане"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Номерът ми е <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Установява се видеовръзка"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Видеообаждане"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Заявява се видеовръзка"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Видеообаждането не може да се осъществи"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Заявката за видеовръзка е отхвърлена"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Номерът ви за обратно обаждане\n– <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Номерът ви за спешно обратно обаждане\n– <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Набиране"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Пропуснато обаждане"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Пропуснати обаждания"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> пропуснати обаждания"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Пропуснато обаждане от <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Текущо обаждане"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Текущо служебно обаждане"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Текущо обаждане през Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Текущо служебно обаждане през Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Задържано"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Входящо обаждане"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Входящо служебно обаждане"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Входящо обаждане през Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Входящо служебно обаждане през Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Входящо видеообаждане"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Заявка за входящо видеообаждане"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Нова гласова поща"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Нова гласова поща (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Набиране на <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Неизвестен номер за гласова поща"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Няма покритие"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Избраната мрежа (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) не е налице"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Приемане"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Затваряне"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Видеообажд."</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Гл. обаждане"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Приемане"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Отхвърляне"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Обр. обажд."</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Съобщение"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"За да осъществите обаждане, първо изключете самолетния режим."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Няма регистрация в мрежата."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Няма достъп до клетъчната мрежа."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"За да извършите обаждане, въведете валиден номер."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Не може да се извърши обаждане."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Стартира се последователността MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Услугата не се поддържа."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Обажданията не могат да се превключат."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Обаждането не може да се отдели."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Не може да се прехвърли."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Не може да се извърши конферентно обаждане."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Обаждането не може да се отхвърли."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Обаждането или съответно обажданията не могат да се освободят."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Обаждане чрез SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Спешно обаждане"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Радиомодулът се включва…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Няма услуга. Извършва се нов опит…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Не може да се извърши обаждане. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> не е номер за спешни случаи."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Не може да се извърши обаждане. Наберете номер за спешни случаи."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Използвайте клавиатурата за набиране"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Задържане на обаждането"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Възобновяване на обаждането"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Край на обаждането"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Клавиатура за набиране"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Спиране на звука"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Добавяне на обаждане"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Обединяване на обаждания"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Размяна"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Управление на обажданията"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Управление на конф. обаждане"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Аудио"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Видеообажд."</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Преминаване към гласово обаждане"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Превключване на камерата"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Поставяне на видеовръзката на пауза"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Още опции"</string>
+    <string name="player_started" msgid="3478865572468310331">"Плейърът е стартиран"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Плейърът е спрян"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Камерата не е в готовност"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Камерата е в готовност"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Неизвестно събитие в сесията на обаждане"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Услуга"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Настройване"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Не е зададено&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Други настройки за обаждане"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Обаждане чрез <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Входящо обаждане чрез <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"снимка на контакта"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"превключване към частно обаждане"</string>
+    <string name="selectContact" msgid="92191462970821951">"избиране на контакта"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Напишете свой собствен..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Отказ"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Изпращане"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Приемане"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Изпращане на SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Отхвърляне"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Приемане като видеообаждане"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Приемане като аудиообаждане"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Приемане на заявката за видеовръзка"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Отхвърляне на заявката за видеовръзка"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Приемане на заявката за предаване на видео"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Отхвърляне на заявката за предаване на видео"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Приемане на заявката за получаване на видеообаждане"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Отхвърляне на заявката за получаване на видео"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Плъзнете нагоре за <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Плъзнете наляво за <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Плъзнете надясно за <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Плъзнете надолу за <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Вибриране"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Вибриране"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Звук"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Стандартен звук (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Мелодия на телефона"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Вибриране при звънене"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Мелодия и вибриране"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Управление на конферентното обаждане"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Спешен номер"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> секунди</item>
+      <item quantity="one">1 секунда</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> минути</item>
+      <item quantity="one">1 минута</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> часа</item>
+      <item quantity="one">1 час</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Снимка на потребителския профил"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Камерата е изключена"</string>
+    <string name="child_number" msgid="4469090994612105532">"чрез <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Бележката е изпратена"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Скорошни съобщения"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Бизнес информация"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"На <xliff:g id="DISTANCE">%.1f</xliff:g> мили"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"На <xliff:g id="DISTANCE">%.1f</xliff:g> км"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>; <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Отваря утре в <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Отваря днес в <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Затваря в <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Затворено днес в <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"В момента работи"</string>
+    <string name="closed_now" msgid="2635314668145282080">"В момента не работи"</string>
+</resources>
diff --git a/InCallUI/res/values-bn-rBD/strings.xml b/InCallUI/res/values-bn-rBD/strings.xml
new file mode 100644
index 0000000..89fae85
--- /dev/null
+++ b/InCallUI/res/values-bn-rBD/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"ফোন"</string>
+    <string name="onHold" msgid="527593602772521700">"হোল্ডে রয়েছে"</string>
+    <string name="unknown" msgid="3646075119047488748">"অজানা"</string>
+    <string name="private_num" msgid="6081418498487514686">"ব্যক্তিগত নম্বর"</string>
+    <string name="payphone" msgid="5743050584468748607">"অর্থের বিনিময়ে কল করার ফোন"</string>
+    <string name="confCall" msgid="3181961445236675173">"কনফারেন্স কল"</string>
+    <string name="call_lost" msgid="8208184291640961172">"কল সমাপ্ত হয়েছে"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"স্পিকার"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"হ্যান্ডসেট ইয়ারপিস"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"তারযুক্ত হেডসেট"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"নিম্নলিখিত টোনগুলি পাঠাবেন?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"টোনগুলি পাঠানো হচ্ছে\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"পাঠান"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"হ্যাঁ"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"না"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"ওয়াইল্ড অক্ষরগুলিকে এর মাধ্যমে প্রতিস্থাপিত করুন"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"কনফারেন্স কল <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"ভয়েসমেল নম্বর"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"ডায়াল করা হচ্ছে"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"পুনরায় ডায়াল করা হচ্ছে"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"কনফারেন্স কল"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"আগত কল"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"আগত কাজের কল"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"কল সমাপ্ত হয়েছে"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"হোল্ডে রয়েছে"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"কল নামিয়ে রাখা হচ্ছে"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"কলের সময়ে"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"আমার নম্বর হল <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"ভিডিও সংযুক্ত করছে"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"ভিডিও কল"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"ভিডিওর অনুরোধ করছে"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"ভিডিও কলে সংযোগ করা যাচ্ছে না"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"ভিডিওর অনুরোধ প্রত্যাখ্যান করা হয়েছে"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"আপনার কলব্যাক নম্বর\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"আপনার জরুরী কলব্যাক নম্বর\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"ডায়াল করা হচ্ছে"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"মিসড কল"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"মিসড কলগুলি"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>টি মিসড কল"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> এর থেকে মিসড কল"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"চলমান কল"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"চলমান কাজের কল"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"চলমান Wi-Fi কল"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"চলমান Wi-Fi কাজের কল"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"হোল্ডে রয়েছে"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"আগত কল"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"আগত কাজের কল"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"আগত Wi-Fi কল"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"আগত Wi-Fi কাজের কল"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"আগত ভিডিও কল"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"আগত ভিডিও অনুরোধ"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"নতুন ভয়েসমেল"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"নতুন ভয়েসমেল (<xliff:g id="COUNT">%d</xliff:g>টি)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> ডায়াল করুন"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"ভয়েসমেল নম্বর অজানা"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"কোনো পরিষেবা নেই"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"নির্বাচিত নেটওয়ার্ক (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) অনুপলব্ধ"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"উত্তর"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"কল নামিয়ে রাখুন"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"ভিডিও"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"ভয়েস"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"স্বীকার করুন"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"খারিজ করুন"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"ঘুরিয়ে কল করুন"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"বার্তা"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"একটি কল করতে, প্রথমে বিমানমোড বন্ধ করুন৷"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"নেটওয়ার্কে নিবন্ধিত নয়৷"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"সেলুলার নেটওয়ার্ক উপলব্ধ নয়।"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"কোনো কল স্থাপন করতে, একটি বৈধ নম্বর লিখুন৷"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"কল করা যাবে না৷"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI ক্রম চালু হচ্ছে…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"পরিষেবা সমর্থিত নয়৷"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"কলগুলি স্যুইচ করা যাবে না৷"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"কল আলাদা করা যাবে না৷"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"হস্তান্তর করা যাবে না৷"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"কনফারেন্স করা যাবে না৷"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"কল প্রত্যাখ্যান কলা যাবে না৷"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"কল(গুলি) কাটা যাবে না৷"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP কল"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"জরুরি কল"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"রেডিও চালু করা হচ্ছে…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"কোন পরিষেবা নেই৷ আবার চেষ্টা করা হচ্ছে..."</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"কল করা যাবে না৷ <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> কোনো জরুরী নম্বর নয়৷"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"কল করা যাবে না৷ কোনো জরুরী নম্বর ডায়াল করুন৷"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ডায়াল করতে কীবোর্ড ব্যবহার করুন"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"কল হোল্ডে রাখুন"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"কল পুনরায় শুরু করুন"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"কল শেষ করুন"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"ডায়ালপ্যাড"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"নিঃশব্দ করুন"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"কল যোগ করুন"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"কলগুলি মার্জ করুন"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"সোয়াপ করুন"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"কলগুলি পরিচালনা করুন"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"কনফারেন্স কল পরিচালনা করুন"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"অডিও"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"ভিডিও কল"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"ভয়েস কলে পরিবর্তন করুন"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"ক্যামেরা স্যুইচ করুন"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"ভিডিও বিরাম দিন"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"আরো বিকল্প"</string>
+    <string name="player_started" msgid="3478865572468310331">"প্লেয়ার শুরু হয়েছে"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"প্লেয়ার বন্ধ হয়ে গেছে"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"ক্যামেরা প্রস্তুত নেই"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"ক্যামেরা প্রস্তুত"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"অজানা কল অধিবেশনের ইভেন্ট"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"পরিষেবা"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"সেটআপ"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;সেট করা নেই&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"অন্যান্য কল সেটিংস"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> এর মাধ্যমে কল করা হচ্ছে"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> এর মাধ্যমে ইনকামিং কল"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"পরিচিতির ফটো"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"ব্যক্তিগতভাবে কাজ করুন"</string>
+    <string name="selectContact" msgid="92191462970821951">"পরিচিতি নির্বাচন করুন"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"আপনার নিজের পছন্দ মতো লিখুন…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"বাতিল করুন"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"পাঠান"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"উত্তর"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS পাঠান"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"অস্বীকার করুন"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"ভিডিও কল হিসেবে উত্তর দিন"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"অডিও কল হিসেবে উত্তর দিন"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"ভিডিওর অনুরোধ গ্রহণ করুন"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"ভিডিওর অনুরোধ প্রত্যাখ্যান করুন"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"ভিডিও প্রেরণ করার অনুরোধ স্বীকার করুন"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"ভিডিও প্রেরণ করার অনুরোধ প্রত্যাখ্যান করুন"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"ভিডিও গ্রহণ করার অনুরোধ স্বীকার করুন"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"ভিডিও গ্রহণ করার অনুরোধ প্রত্যাখ্যান করুন"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> এর জন্য উপরের দিকে স্লাইড করুন৷"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> এর জন্য বাম দিকে স্লাইড করুন৷"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> এর জন্য ডান দিকে স্লাইড করুন৷"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> এর জন্য নীচের দিকে স্লাইড করুন৷"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"কম্পন"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"কম্পন"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"শব্দ"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"ডিফল্ট শব্দ (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"ফোন রিংটোন"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"রিং হওয়ার সময় কম্পন হবে"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"রিংটোন ও কম্পন"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"কনফারেন্স কল পরিচালনা করুন"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"জরুরি নম্বর"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> সেকেন্ড</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> সেকেন্ড</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> মিনিট</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> মিনিট</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ঘণ্টা</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ঘণ্টা</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"প্রোফাইল ফটো"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"ক্যামেরা বন্ধ"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> এর মাধ্যমে"</string>
+    <string name="note_sent" msgid="7623014827902758398">"নোট পাঠানো হয়েছে"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"সাম্প্রতিক বার্তাগুলি"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"ব্যবসার তথ্য"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> মাইল দূরে"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> কিলোমিটার দূরে"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"আগামীকাল <xliff:g id="OPEN_TIME">%s</xliff:g>\'টায় খুলবে"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"আজ <xliff:g id="OPEN_TIME">%s</xliff:g>\'টায় খুলবে"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g>\'টায় বন্ধ হয়"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"আজ <xliff:g id="CLOSE_TIME">%s</xliff:g>\'টায় বন্ধ হয়েছে"</string>
+    <string name="open_now" msgid="4615706338669555999">"এখন খোলা রয়েছে"</string>
+    <string name="closed_now" msgid="2635314668145282080">"এখন বন্ধ রয়েছে"</string>
+</resources>
diff --git a/InCallUI/res/values-ca/strings.xml b/InCallUI/res/values-ca/strings.xml
new file mode 100644
index 0000000..ffae86d
--- /dev/null
+++ b/InCallUI/res/values-ca/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telèfon"</string>
+    <string name="onHold" msgid="527593602772521700">"En espera"</string>
+    <string name="unknown" msgid="3646075119047488748">"Desconegut"</string>
+    <string name="private_num" msgid="6081418498487514686">"Número privat"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telèfon públic"</string>
+    <string name="confCall" msgid="3181961445236675173">"Conferència"</string>
+    <string name="call_lost" msgid="8208184291640961172">"La trucada s\'ha interromput"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Altaveu"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Auricular"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Auricular amb cable"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Vols enviar els tons següents?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"S\'estan enviant els tons\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Envia"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Sí"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"No"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Substitueix el caràcter comodí per"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Conferència, <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Número del missatge de veu"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"S\'està marcant"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"S\'està tornant a marcar"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Conferència"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Trucada entrant"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Trucada de feina entrant"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Ha finalitzat la trucada"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"En espera"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"S\'està penjant"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"En una trucada"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"El meu número és <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"S\'està connectant el vídeo"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videotrucada"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"S\'està sol·licitant el vídeo"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"No es pot connectar la videotrucada"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"S\'ha rebutjat la sol·licitud de vídeo"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Número de devolució de trucada\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Número de devolució de trucada d\'emergència\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"S\'està marcant"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Trucada perduda"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Trucades perdudes"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> trucades perdudes"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Trucada perduda de <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Trucada en curs"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Trucada de feina en curs"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Trucada per Wi-Fi en curs"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Trucada de feina per Wi-Fi en curs"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"En espera"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Trucada entrant"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Trucada de feina entrant"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Trucada per Wi-Fi entrant"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Trucada de feina per Wi-Fi entrant"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Videotrucada entrant"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Sol·licitud de vídeo entrant"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Missatge de veu nou"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Missatges de veu nous (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Marca <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Número del missatge de veu desconegut"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Sense servei"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"La xarxa seleccionada (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) no està disponible"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Respon"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Penja"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Vídeo"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Veu"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Accepta"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Ignora"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Torna truc."</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Missatge"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Per fer una trucada, primer desactiva el mode d\'avió."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"No s\'ha registrat a la xarxa."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"La xarxa mòbil no està disponible."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Introdueix un número vàlid per fer una trucada."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"No es pot trucar."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"S\'està iniciant la seqüència MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"El servei no és compatible."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"No es pot canviar de trucada."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"No es pot separar la trucada."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"No es poden transferir trucades."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"No es pot establir la conferència."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"No es pot rebutjar la trucada."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"No es poden alliberar trucades."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Trucada de SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Trucada d\'emergència"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"S\'està activant el senyal mòbil…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"No hi ha servei. S\'està tornant a provar…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"No es pot trucar. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> no és un número d\'emergència."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"No es pot trucar. Marca un número d\'emergència."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Utilitza el teclat per marcar"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Posa la trucada en espera"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Reprèn la trucada"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Finalitza la trucada"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Teclat de marcatge"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Silencia"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Afegeix una trucada"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Combina les trucades"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Canvia"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Gestiona les trucades"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Gestiona la conferència"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Àudio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videotruc."</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Canvia a trucada"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Canvia la càmera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Posa en pausa el vídeo"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Més opcions"</string>
+    <string name="player_started" msgid="3478865572468310331">"S\'ha iniciat el reproductor"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"S\'ha aturat el reproductor"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"La càmera no està preparada"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"La càmera està preparada"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Esdeveniment de sessió de trucada desconeguda"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Servei"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Configura"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;No definit&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Altres opcions de configuració de les trucades"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"S\'està trucant amb <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Trucada entrant mitjançant <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"foto de contacte"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"conferència privada"</string>
+    <string name="selectContact" msgid="92191462970821951">"selecciona el contacte"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Escriu la teva…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Cancel·la"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Envia"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Respon"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Envia SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Rebutja"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Respon amb una videotrucada"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Respon amb una trucada d\'àudio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Accepta la sol·licitud de vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Rebutja la sol·licitud de vídeo"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Accepta la sol·licitud per transmetre vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Rebutja la sol·licitud per transmetre vídeo"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Accepta la sol·licitud per rebre vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Rebutja la sol·licitud per rebre vídeo"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Fes lliscar el dit cap amunt per <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Fes lliscar el dit cap a l\'esquerra per <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Fes lliscar el dit cap a la dreta per <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Fes lliscar el dit cap avall per <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibració"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibració"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"So"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"So predeterminat (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"So de trucada"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrar en sonar"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"So de trucada i vibració"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Gestiona la conferència"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Número d\'emergència"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> segons</item>
+      <item quantity="one">1 segon</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minuts</item>
+      <item quantity="one">1 minut</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> hores</item>
+      <item quantity="one">1 hora</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Foto de perfil"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"La càmera està desactivada"</string>
+    <string name="child_number" msgid="4469090994612105532">"mitjançant <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"S\'ha enviat la nota"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Missatges recents"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informació de l\'empresa"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"A <xliff:g id="DISTANCE">%.1f</xliff:g> mi de distància"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"A <xliff:g id="DISTANCE">%.1f</xliff:g> km de distància"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Obre demà a les <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Obre avui a les <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Tanca a les <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Avui ha tancat a les <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Ara és obert"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Ara és tancat"</string>
+</resources>
diff --git a/InCallUI/res/values-cs/strings.xml b/InCallUI/res/values-cs/strings.xml
new file mode 100644
index 0000000..050da28
--- /dev/null
+++ b/InCallUI/res/values-cs/strings.xml
@@ -0,0 +1,198 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Přidržený hovor"</string>
+    <string name="unknown" msgid="3646075119047488748">"Neznámý volající"</string>
+    <string name="private_num" msgid="6081418498487514686">"Soukromé číslo"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefonní automat"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferenční hovor"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Volání zrušeno"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Reproduktor"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Sluchátko telefonu"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Kabelová náhlavní soupr."</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Odeslat následující tóny?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Odesílání tónů\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Odeslat"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ano"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Ne"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Nahradit zástupné znaky jinými znaky"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferenční hovor <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Číslo hlasové schránky"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Vytáčení"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Opakované vytáčení"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferenční hovor"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Příchozí hovor"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Příchozí pracovní hovor"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Hovor ukončen"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Přidržený hovor"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Ukončování hovoru"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Probíhá hovor"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Moje číslo je <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Navazování spojení pro video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videohovor"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Požadování videa"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Videohovor nelze zahájit"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Žádost o video byla zamítnuta"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Vaše číslo pro zpětné volání\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Vaše číslo pro tísňové zpětné volání\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Vytáčení"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Zmeškaný hovor"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Zmeškané hovory"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"Zmeškané hovory: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Zmeškaný hovor od volajícího <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Probíhající hovor"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Probíhající pracovní hovor"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Probíhající hovor přes Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Probíhající pracovní hovor přes Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Přidržený hovor"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Příchozí hovor"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Příchozí pracovní hovor"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Příchozí hovor přes Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Příchozí pracovní hovor přes Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Příchozí videohovor"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Příchozí žádost o videohovor"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nová hlasová zpráva"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nové hlasové zprávy (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Volat hlasovou schránku <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Číslo hlasové schránky není známé"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Žádný signál"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Vybraná síť (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) není k dispozici"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Přijmout"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Zavěsit"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Videohovor"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Hlas. hovor"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Přijmout"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Odmítnout"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Zavolat zpět"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Posl. zprávu"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Chcete-li telefonovat, nejprve vypněte režim Letadlo."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Přihlášení k síti nebylo úspěšné."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobilní síť je nedostupná."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Chcete-li uskutečnit hovor, zadejte platné telefonní číslo."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Hovor nelze uskutečnit."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Spouštění sekvence MMI..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Služba není podporována."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Hovory nelze přepnout."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Hovor nelze rozdělit."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Hovor nelze předat."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Konferenční hovor nelze uskutečnit."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Hovor nelze odmítnout."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Hovor nelze ukončit."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Volání SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Tísňové volání"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Zapínání bezdrátového modulu..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Žádný signál. Probíhá další pokus…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Hovor nelze uskutečnit. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> není číslo tísňového volání."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Hovor nelze uskutečnit. Vytočte číslo tísňového volání."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Vytočte číslo pomocí klávesnice"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Podržet hovor"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Obnovit hovor"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Ukončit hovor"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Číselník"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Ignorovat"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Přidat hovor"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Spojit hovory"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Zaměnit"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Spravovat hovory"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Spravovat konferenční hovor"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Zvuk"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videohovor"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Změnit na hlasové volání"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Přepnout kameru"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pozastavit video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Další možnosti"</string>
+    <string name="player_started" msgid="3478865572468310331">"Přehrávač spuštěn"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Přehrávač zastaven"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Fotoaparát není připraven"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Fotoaparát je připraven"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Neznámá událost relace volání"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Služba"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Nastavení"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Nenastaveno&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Další nastavení hovorů"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Volání prostřednictvím poskytovatele <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Příchozí hovor přes poskytovatele <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"fotografie kontaktu"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"přepnout na soukromé"</string>
+    <string name="selectContact" msgid="92191462970821951">"vybrat kontakt"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Napsat vlastní odpověď..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Zrušit"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Odeslat"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Přijmout"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Odeslat SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Odmítnout"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Přijmout jako videohovor"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Přijmout jako hlasový hovor"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Přijmout žádost o videhovor"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Odmítnout žádost o videohovor"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Přijmout žádost o odesílání videa"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Odmítnout žádost o odesílání videa"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Přijmout žádost o příjem videa"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Odmítnout žádost o příjem videa"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> – přejeďte prstem nahoru"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> – přejeďte prstem doleva"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> – přejeďte prstem doprava"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> – přejeďte prstem dolů"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrace"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrace"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Zvuk"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Výchozí zvuk (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Vyzváněcí tón telefonu"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrace při vyzvánění"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Vyzvánění a vibrace"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Správa konferenčního hovoru"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Číslo tísňové linky"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> sekundy</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> sekundy</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekund</item>
+      <item quantity="one">1 sekunda</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> minuty</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> minuty</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minut</item>
+      <item quantity="one">1 minuta</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> hodiny</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> hodiny</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> hodin</item>
+      <item quantity="one">1 hodina</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profilová fotka"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Fotoaparát je vypnutý"</string>
+    <string name="child_number" msgid="4469090994612105532">"pomocí čísla <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Poznámka byla odeslána"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Nejnovější zprávy"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informace o firmě"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"Vzdálenost: <xliff:g id="DISTANCE">%.1f</xliff:g> mi"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"Vzdálenost: <xliff:g id="DISTANCE">%.1f</xliff:g> km"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>–<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Zítra otevírá v <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Dnes otevírá v <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Zavírá v <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Dnes zavřeno od <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Otevřeno"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Nyní zavřeno"</string>
+</resources>
diff --git a/InCallUI/res/values-da/strings.xml b/InCallUI/res/values-da/strings.xml
new file mode 100644
index 0000000..8515e58
--- /dev/null
+++ b/InCallUI/res/values-da/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Afventer"</string>
+    <string name="unknown" msgid="3646075119047488748">"Ukendt"</string>
+    <string name="private_num" msgid="6081418498487514686">"Privat nummer"</string>
+    <string name="payphone" msgid="5743050584468748607">"Mønttelefon"</string>
+    <string name="confCall" msgid="3181961445236675173">"Telefonmøde"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Opkaldet blev afbrudt."</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Højttaler"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Ørestykke til håndsæt"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Headset med ledning"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Vil du sende følgende toner?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Sender toner\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Send"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ja"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Nej"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Erstat jokertegnet med"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Telefonmøde <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Telefonsvarernummer"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Ringer op"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Ringer op igen"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Telefonmøde"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Indgående opkald"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Indgående arbejdsopkald"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Opkaldet er afsluttet"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Afventer"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Lægger på"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Opkald i gang"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mit nummer er <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Opretter videoforbindelse"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videoopkald"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Anmoder om video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Kan ikke forbinde videoopkald"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Videoanmodningen blev afvist"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Dit tilbagekaldsnummer\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Dit tilbagekaldsnummer til nødopkald\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Ringer op"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Ubesvaret opkald"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Ubesvarede opkald"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ubesvarede opkald"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Ubesvaret opkald fra <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Igangværende opkald"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Igangværende opkald i forbindelse med arbejde"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Igangværende opkald via Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Igangværende Wi-Fi-opkald i forbindelse med arbejde"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Afventer"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Indgående opkald"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Indgående arbejdsopkald"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Indgående Wi-Fi-opkald"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Indgående Wi-Fi-opkald i forbindelse med arbejde"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Indgående videoopkald"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Indgående videoanmodning"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Ny telefonsvarerbesked"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nye telefonsvarerbeskeder (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Ring til <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Telefonsvarernummeret er ukendt"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Ingen dækning"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Det valgte netværk (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) er ikke tilgængeligt"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Svar"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Læg på"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Tale"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Acceptér"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Afvis"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Ring tilbage"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Besked"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Slå Flytilstand fra først for at foretage et opkald."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Ikke registreret på netværket."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobilnetværket er ikke tilgængeligt."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Indtast et gyldigt nummer for at foretage et opkald."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Der kan ikke ringes op."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Starter MMI-sekvens…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Tjenesten er ikke understøttet."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Der kan ikke skiftes opkald."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Opkaldet kan ikke adskilles."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Der kan ikke viderestilles."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Der kan ikke oprettes telefonmøde."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Opkaldet kan ikke afvises."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Et eller flere opkald kan ikke frigives."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP-opkald"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Nødopkald"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Tænder for radio…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Ingen tjeneste. Prøver igen…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Der kan ikke ringes op. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> er ikke et alarmnummer."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Der kan ikke ringes op. Ring til et alarmnummer."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Brug tastaturet til at ringe op"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Sæt opkald i venteposition"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Genoptag opkald"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Afslut opkald"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Tastatur"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Slå lyden fra"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Tilføj opkald"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Slå opkald sammen"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Skift"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Administrer opkald"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Administrer telefonmøde"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Lyd"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videoopkald"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Skift til taleopkald"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Skift kamera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Sæt video på pause"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Flere valgmuligheder"</string>
+    <string name="player_started" msgid="3478865572468310331">"Afspilleren er startet"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Afspilleren er stoppet"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kameraet er ikke klar"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kameraet er klar"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Ukendt opkaldsbegivenhed"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Tjeneste"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Konfiguration"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Ikke angivet&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Andre indstillinger for opkald"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Opkald via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Indgående opkald via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"billede af kontaktperson"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"gør privat"</string>
+    <string name="selectContact" msgid="92191462970821951">"vælg kontaktperson"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Skriv dit eget svar…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Annuller"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Send"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Svar"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Send sms"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Afvis"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Besvar som videoopkald"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Besvar som lydopkald"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Acceptér anmodning om video"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Afvis videoanmodning"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Acceptér anmodning om udgående video"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Afvis anmodning om udgående video"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Acceptér anmodning om indgående video"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Afvis anmodning om indgående video"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Skub op for at <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Skub til venstre for at <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Skub til højre for at <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Skub ned for at <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibration"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibration"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Lyd"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Standardlyd (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Ringetone ved opkald"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrer ved opringning"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Ringetone og vibration"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Administrer telefonmøde"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Alarmnummer"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> sekund</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekunder</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> minut</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutter</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> time</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> timer</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profilbillede"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kameraet er slukket"</string>
+    <string name="child_number" msgid="4469090994612105532">"via <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Noten er sendt"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Seneste beskeder"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Virksomhedsoplysninger"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mil væk"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km væk"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>-<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Åbner i morgen kl. <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Åbner i dag kl. <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Lukker kl. <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Lukkede i dag kl. <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Åbent nu"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Lukket for i dag"</string>
+</resources>
diff --git a/InCallUI/res/values-de/strings.xml b/InCallUI/res/values-de/strings.xml
new file mode 100644
index 0000000..7bf6e3b
--- /dev/null
+++ b/InCallUI/res/values-de/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Gehaltener Anruf"</string>
+    <string name="unknown" msgid="3646075119047488748">"Unbekannt"</string>
+    <string name="private_num" msgid="6081418498487514686">"Private Nummer"</string>
+    <string name="payphone" msgid="5743050584468748607">"Münztelefon"</string>
+    <string name="confCall" msgid="3181961445236675173">"Telefonkonferenz"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Verbindung unterbrochen"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Lautsprecher"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Mobilgerät-Kopfhörer"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Kabelgebundenes Headset"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Folgende Töne senden?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Töne werden gesendet\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Senden"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ja"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Nein"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Platzhalter ersetzen durch"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Telefonkonferenz <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Mailboxnummer"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Rufaufbau"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Wahlwiederholung"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Telefonkonferenz"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Eingehender Anruf"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Eingeh. geschäftl. Anruf"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Anruf beendet"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Gehaltener Anruf"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Auflegen"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Im Gespräch"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Meine Nummer lautet <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Videoverbindung wird hergestellt"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videoanruf"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Videoanfrage wird gesendet"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Videoanruf kann nicht verbunden werden"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Videoanfrage abgelehnt"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Deine Rückrufnummer lautet:\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Deine Notrufnummer lautet:\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Rufaufbau"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Verpasster Anruf"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Verpasste Anrufe"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> verpasste Anrufe"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Verpasster Anruf von <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Aktiver Anruf"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Aktiver geschäftlicher Anruf"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Aktiver WLAN-Anruf"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Aktiver geschäftlicher WLAN-Anruf"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Gehaltener Anruf"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Eingehender Anruf"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Eingehender geschäftlicher Anruf"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Eingehender WLAN-Anruf"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Eingehender geschäftlicher WLAN-Anruf"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Eingehender Videoanruf"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Eingehende Videoanfrage"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Neue Mailbox-Nachricht"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Neue Mailbox-Nachricht (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> wählen"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Mailboxnummer unbekannt"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Kein Service"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Ausgewähltes Netzwerk (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) nicht verfügbar"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Annehmen"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Beenden"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Videoanruf"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Sprachanruf"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Akzeptieren"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Ablehnen"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Zurückrufen"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Nachricht"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Deaktiviere zunächst den Flugmodus, um einen Anruf zu tätigen."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Nicht in Netzwerk registriert."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobilfunknetz nicht verfügbar."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Gib eine gültige Nummer ein, um einen Anruf zu tätigen."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Anruf nicht möglich."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI-Sequenz wird gestartet…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Dienst wird nicht unterstützt."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Anruf kann nicht gewechselt werden."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Anruf kann nicht getrennt werden."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Anruf kann nicht übergeben werden."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Konferenzschaltung nicht möglich."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Anruf kann nicht abgelehnt werden."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Anrufe können nicht freigegeben werden."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP-Anruf"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Notruf"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Mobilfunkverbindung wird aktiviert…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Kein Service. Neuer Versuch…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Anruf nicht möglich. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> ist keine Notrufnummer."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Anruf nicht möglich. Wähle eine Notrufnummer."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Zum Wählen Tastatur verwenden"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Anruf halten"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Anruf fortsetzen"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Anruf beenden"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Wähltasten"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Stummschalten"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Anruf hinzufügen"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Anrufe verbinden"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Wechseln"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Anrufe verwalten"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Telefonkonferenz verwalten"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videoanruf"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Zu Sprachanruf wechseln"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Kamera wechseln"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Video pausieren"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Weitere Optionen"</string>
+    <string name="player_started" msgid="3478865572468310331">"Videoübertragung gestartet"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Videoübertragung gestoppt"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera nicht bereit"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera bereit"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Unbekanntes Ereignis während eines Anrufs"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Dienst"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Einrichtung"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Nicht festgelegt&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Sonstige Anrufeinstellungen"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Anruf über <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Eingehender Anruf über <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"Kontaktbild"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"privat sprechen"</string>
+    <string name="selectContact" msgid="92191462970821951">"Kontakt auswählen"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Eigene Antwort schreiben…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Abbrechen"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Senden"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Annehmen"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS senden"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Ablehnen"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Als Videoanruf annehmen"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Als normalen Anruf annehmen"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Videoanfrage akzeptieren"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Videoanfrage ablehnen"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Anfrage für ausgehenden Videoanruf akzeptieren"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Anfrage für ausgehenden Videoanruf ablehnen"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Anfrage für eingehenden Videoanruf akzeptieren"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Anfrage für eingehenden Videoanruf ablehnen"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Zum <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> nach oben schieben."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Zum <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> nach links schieben."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Zum <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> nach rechts schieben."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Zum <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> nach unten schieben."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrieren"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrieren"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Ton"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Standardklingelton (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Klingelton"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Beim Klingeln vibrieren"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Klingelton &amp; Vibration"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Telefonkonferenz verwalten"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Notrufnummer"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> Sekunden</item>
+      <item quantity="one">1 Sekunde</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> Minuten</item>
+      <item quantity="one">1 Minute</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> Stunden</item>
+      <item quantity="one">1 Stunde</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profilbild"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera aus"</string>
+    <string name="child_number" msgid="4469090994612105532">"über <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Notiz gesendet"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Zuletzt eingegangene Nachrichten"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Geschäftsinformationen"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> Meilen entfernt"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> Kilometer entfernt"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> bis <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Öffnet morgen um <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Öffnet heute um <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Schließt um <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Hat heute um <xliff:g id="CLOSE_TIME">%s</xliff:g> geschlossen"</string>
+    <string name="open_now" msgid="4615706338669555999">"Jetzt geöffnet"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Jetzt geschlossen"</string>
+</resources>
diff --git a/InCallUI/res/values-el/strings.xml b/InCallUI/res/values-el/strings.xml
new file mode 100644
index 0000000..eeab793
--- /dev/null
+++ b/InCallUI/res/values-el/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Τηλέφωνο"</string>
+    <string name="onHold" msgid="527593602772521700">"Σε αναμονή"</string>
+    <string name="unknown" msgid="3646075119047488748">"Άγνωστος"</string>
+    <string name="private_num" msgid="6081418498487514686">"Απόκρυψη αριθμού"</string>
+    <string name="payphone" msgid="5743050584468748607">"Τηλέφωνο με χρέωση"</string>
+    <string name="confCall" msgid="3181961445236675173">"Κλήση συνδιάσκεψης"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Η κλήση απορρίφθηκε"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Ηχείο"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Ακουστικό"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Ενσύρματο ακουστικό"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Αποστολή των παρακάτω ήχων;\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Ήχοι αποστολής\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Αποστολή"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ναι"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Όχι"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Αντικατάσταση του χαρακτήρα μπαλαντέρ με"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Κλήση συνδιάσκεψης <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Αριθμός αυτόματου τηλεφωνητή"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Κλήση"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Επανάκληση"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Κλήση συνδιάσκεψης"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Εισερχόμενη κλήση"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Εισερχόμ. κλήση εργασίας"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Η κλήση τερματίστηκε"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Σε αναμονή"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Κλείσιμο γραμμής"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Σε κλήση"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Ο αριθμός μου είναι <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Σύνδεση βίντεο"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Βιντεοκλήση"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Αίτημα βίντεο"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Δεν είναι δυνατή η σύνδεση βιντεοκλήσης"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Το αίτημα βίντεο απορρίφθηκε"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Αριθμός επανάκλησης\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Αριθμός επανάκλησης έκτακτης ανάγκης\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Κλήση"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Αναπάντητη κλήση"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Αναπάντητες κλήσεις"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> αναπάντητες κλήσεις"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Αναπάντητη κλήση από <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Κλήση σε εξέλιξη"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Κλήση εργασίας σε εξέλιξη"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Κλήση Wi-Fi σε εξέλιξη"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Κλήση εργασίας μέσω Wi-Fi σε εξέλιξη"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Σε αναμονή"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Εισερχόμενη κλήση"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Εισερχόμενη κλήση εργασίας"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Εισερχόμενη κλήση μέσω Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Εισερχόμενη κλήση εργασίας μέσω Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Εισερχόμενη βιντεοκλήση"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Αίτημα εισερχόμενου βίντεο"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Νέο μήνυμα στον αυτόματο τηλεφωνητή"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Νέο μήνυμα στον αυτόματο τηλεφωνητή (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Καλέστε στο <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Άγνωστος αριθμός αυτόματου τηλεφωνητή"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Δίκτυο μη διαθέσιμο"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Το επιλεγμένο δίκτυο (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) δεν είναι διαθέσιμο"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Απάντηση"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Τερμ. κλήσης"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Βίντεο"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Φωνή"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Αποδοχή"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Παράβλεψη"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Επανάκληση"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Μήνυμα"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Για να πραγματοποιήσετε μια κλήση, απενεργοποιήστε πρώτα τη λειτουργία πτήσης."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Δεν έχετε εγγραφεί στο δίκτυο."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Το δίκτυο κινητής τηλεφωνίας δεν είναι διαθέσιμο."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Για να πραγματοποιήσετε κλήση, εισαγάγετε έναν έγκυρο αριθμό."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Δεν είναι δυνατή η κλήση."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Έναρξη ακολουθίας MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Η υπηρεσία δεν υποστηρίζεται."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Δεν είναι δυνατή η εναλλαγή κλήσεων."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Δεν είναι δυνατός ο διαχωρισμός της κλήσης."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Δεν είναι δυνατή η μεταφορά."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Δεν είναι δυνατή η συνδιάσκεψη."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Δεν είναι δυνατή η απόρριψη της κλήσης."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Δεν είναι δυνατή η πραγματοποίηση κλήσεων."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Κλήση SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Κλήση έκτακτης ανάγκης"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Ενεργοποίηση πομπού…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Δεν υπάρχει υπηρεσία. Νέα προσπάθεια…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Δεν είναι δυνατή η κλήση. Το <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> δεν είναι αριθμός έκτακτης ανάγκης."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Δεν είναι δυνατή η κλήση. Πληκτρολογήστε έναν αριθμό έκτακτης ανάγκης."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Χρησιμοποιήστε το πληκτρολόγιο για να πραγματοποιήσετε μια κλήση"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Αναμονή κλήσης"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Συνέχιση κλήσης"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Τερματισμός κλήσης"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Πληκτρολόγιο κλήσης"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Σίγαση"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Προσθήκη κλήσης"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Συγχώνευση κλήσεων"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Ανταλλαγή"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Διαχείριση κλήσεων"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Διαχείριση κλήσης συνδιάσκεψης"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Ήχος"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Βιντεοκλ."</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Αλλαγή σε φωνητική κλήση"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Αλλαγή κάμερας"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Παύση βίντεο"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Περισσότερες επιλογές"</string>
+    <string name="player_started" msgid="3478865572468310331">"Το πρόγραμμα αναπαραγωγής βίντεο ξεκίνησε"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Το πρόγραμμα αναπαραγωγής βίντεο διακόπηκε"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Η κάμερα δεν είναι έτοιμη"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Η κάμερα είναι έτοιμη"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Άγνωστο συμβάν περιόδου σύνδεσης κλήσης"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Υπηρεσία"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Ρύθμιση"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Δεν έχει οριστεί&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Άλλες ρυθμίσεις κλήσης"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Κλήση μέσω <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Εισερχόμενη κλήση μέσω <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"φωτογραφία επαφής"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"ιδιωτική χρήση"</string>
+    <string name="selectContact" msgid="92191462970821951">"επιλογή επαφής"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Συντάξτε τη δική σας…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Ακύρωση"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Αποστολή"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Απάντηση"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Αποστολή SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Απόρριψη"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Απάντηση ως βιντεοκλήση"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Απάντηση ως κλήση ήχου"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Αποδοχή αιτήματος βίντεο"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Απόρριψη αιτήματος βίντεο"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Αποδοχή αιτήματος μετάδοσης βίντεο"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Απόρριψη αιτήματος μετάδοσης βίντεο"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Αποδοχή αιτήματος λήψης βίντεο"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Απόρριψη αιτήματος λήψης βίντεο"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Κύλιση προς τα επάνω για <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Κύλιση προς τα αριστερά για <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Κύλιση προς τα δεξιά για <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Κύλιση προς τα κάτω για <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Δόνηση"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Δόνηση"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Ήχος"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Προεπιλεγμένος ήχος (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Ήχος κλήσης τηλεφώνου"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Δόνηση κατά το κουδούνισμα"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Ήχος κλήσης και δόνηση"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Διαχείριση κλήσης συνδιάσκεψης"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Αριθμός έκτακτης ανάγκης"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> δευτερόλεπτα</item>
+      <item quantity="one">1 δευτερόλεπτο</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> λεπτά</item>
+      <item quantity="one">1 λεπτό</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ώρες</item>
+      <item quantity="one">1 ώρα</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Φωτογραφία προφίλ"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Απενεργοποίηση κάμερας"</string>
+    <string name="child_number" msgid="4469090994612105532">"μέσω <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Η σημείωση εστάλη"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Πρόσφατα μηνύματα"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Πληροφορίες επιχείρησης"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> μίλια μακριά"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> χιλιόμετρα μακριά"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Ανοίγει αύριο στις <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Ανοίγει σήμερα στις <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Κλείνει στις <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Έκλεισε σήμερα στις <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Ανοιχτό τώρα"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Κλειστό τώρα"</string>
+</resources>
diff --git a/InCallUI/res/values-en-rAU/strings.xml b/InCallUI/res/values-en-rAU/strings.xml
new file mode 100644
index 0000000..29fd2d9
--- /dev/null
+++ b/InCallUI/res/values-en-rAU/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telephone"</string>
+    <string name="onHold" msgid="527593602772521700">"On hold"</string>
+    <string name="unknown" msgid="3646075119047488748">"unknown"</string>
+    <string name="private_num" msgid="6081418498487514686">"Private number"</string>
+    <string name="payphone" msgid="5743050584468748607">"Payphone"</string>
+    <string name="confCall" msgid="3181961445236675173">"Conference call"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Call cut off"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Speaker"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Handset earpiece"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Wired headset"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Send the following tones?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Sending tones\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Send"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"yes"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"no"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Replace wild character with"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Conference call <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Voicemail number"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Dialling"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Redialling"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Conference call"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Incoming call"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Incoming work call"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Call ended"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"On hold"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Hanging up"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"In call"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"My number is <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Connecting video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Video call"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Requesting video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Can\'t connect video call"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Video request rejected"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Your callback number\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Your emergency callback number\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Dialling"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Missed call"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Missed calls"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> missed calls"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Missed call from <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"On-going call"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Ongoing work call"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Ongoing Wi-Fi call"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Ongoing Wi-Fi work call"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"On hold"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Incoming call"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Incoming work call"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Incoming Wi-Fi call"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Incoming Wi-Fi work call"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Incoming video call"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Incoming video request"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"New voicemail"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"New voicemail (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Dial <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Voicemail number unknown"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"No service"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Selected network (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) unavailable"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Answer"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Hang up"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"In-stream video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Voice"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Accept"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Dismiss"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Call back"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Message"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"To place a call, first turn off Aeroplane mode."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Not registered on network."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobile network not available."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"To place a call, enter a valid number."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Can\'t call."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Starting MMI sequence…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Service not supported."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Can\'t switch calls."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Can\'t separate call."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Can\'t transfer."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Can\'t conference."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Can\'t reject call."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Can\'t release call(s)."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP call"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Emergency call"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Turning on radio…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"No network. Trying again…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Can\'t call. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> is not an emergency number."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Can\'t call. Dial an emergency number."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Use keyboard to dial"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Hold Call"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Resume Call"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"End Call"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Dial pad"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Mute"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Add call"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Merge calls"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Swap"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Manage calls"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Manage conference call"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Video call"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Change to voice call"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Switch camera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pause video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"More options"</string>
+    <string name="player_started" msgid="3478865572468310331">"Player Started"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Player Stopped"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Camera not ready"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Camera ready"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Unknown call session event"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Service"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Set up"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Not set&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Other call settings"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Calling via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Incoming via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"contact photo"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"go private"</string>
+    <string name="selectContact" msgid="92191462970821951">"select contact"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Write your own..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"cancel"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Send"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Answer"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Send SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Decline"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Answer as video call"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Answer as audio call"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Accept video request"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Decline video request"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Accept video transmit request"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Decline video transmit request"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Accept video receive request"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Decline video receive request"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Slide up for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Slide left for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Slide right for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Slide down for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrate"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrate"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Sound"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Default sound (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Phone ringtone"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrate when ringing"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Ringtone &amp; Vibrate"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Manage conference call"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Emergency number"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> seconds</item>
+      <item quantity="one">1 second</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutes</item>
+      <item quantity="one">1 minute</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> hours</item>
+      <item quantity="one">1 hour</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profile photo"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Camera off"</string>
+    <string name="child_number" msgid="4469090994612105532">"via <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Note sent"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Recent messages"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Business info"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mi away"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km away"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Opens tomorrow at <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Opens today at <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Closes at <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Closed today at <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Open now"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Closed now"</string>
+</resources>
diff --git a/InCallUI/res/values-en-rGB/strings.xml b/InCallUI/res/values-en-rGB/strings.xml
new file mode 100644
index 0000000..29fd2d9
--- /dev/null
+++ b/InCallUI/res/values-en-rGB/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telephone"</string>
+    <string name="onHold" msgid="527593602772521700">"On hold"</string>
+    <string name="unknown" msgid="3646075119047488748">"unknown"</string>
+    <string name="private_num" msgid="6081418498487514686">"Private number"</string>
+    <string name="payphone" msgid="5743050584468748607">"Payphone"</string>
+    <string name="confCall" msgid="3181961445236675173">"Conference call"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Call cut off"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Speaker"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Handset earpiece"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Wired headset"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Send the following tones?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Sending tones\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Send"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"yes"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"no"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Replace wild character with"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Conference call <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Voicemail number"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Dialling"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Redialling"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Conference call"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Incoming call"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Incoming work call"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Call ended"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"On hold"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Hanging up"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"In call"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"My number is <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Connecting video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Video call"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Requesting video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Can\'t connect video call"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Video request rejected"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Your callback number\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Your emergency callback number\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Dialling"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Missed call"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Missed calls"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> missed calls"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Missed call from <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"On-going call"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Ongoing work call"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Ongoing Wi-Fi call"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Ongoing Wi-Fi work call"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"On hold"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Incoming call"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Incoming work call"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Incoming Wi-Fi call"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Incoming Wi-Fi work call"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Incoming video call"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Incoming video request"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"New voicemail"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"New voicemail (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Dial <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Voicemail number unknown"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"No service"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Selected network (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) unavailable"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Answer"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Hang up"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"In-stream video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Voice"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Accept"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Dismiss"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Call back"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Message"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"To place a call, first turn off Aeroplane mode."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Not registered on network."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobile network not available."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"To place a call, enter a valid number."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Can\'t call."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Starting MMI sequence…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Service not supported."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Can\'t switch calls."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Can\'t separate call."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Can\'t transfer."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Can\'t conference."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Can\'t reject call."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Can\'t release call(s)."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP call"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Emergency call"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Turning on radio…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"No network. Trying again…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Can\'t call. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> is not an emergency number."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Can\'t call. Dial an emergency number."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Use keyboard to dial"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Hold Call"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Resume Call"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"End Call"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Dial pad"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Mute"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Add call"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Merge calls"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Swap"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Manage calls"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Manage conference call"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Video call"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Change to voice call"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Switch camera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pause video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"More options"</string>
+    <string name="player_started" msgid="3478865572468310331">"Player Started"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Player Stopped"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Camera not ready"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Camera ready"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Unknown call session event"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Service"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Set up"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Not set&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Other call settings"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Calling via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Incoming via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"contact photo"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"go private"</string>
+    <string name="selectContact" msgid="92191462970821951">"select contact"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Write your own..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"cancel"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Send"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Answer"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Send SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Decline"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Answer as video call"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Answer as audio call"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Accept video request"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Decline video request"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Accept video transmit request"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Decline video transmit request"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Accept video receive request"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Decline video receive request"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Slide up for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Slide left for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Slide right for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Slide down for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrate"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrate"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Sound"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Default sound (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Phone ringtone"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrate when ringing"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Ringtone &amp; Vibrate"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Manage conference call"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Emergency number"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> seconds</item>
+      <item quantity="one">1 second</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutes</item>
+      <item quantity="one">1 minute</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> hours</item>
+      <item quantity="one">1 hour</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profile photo"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Camera off"</string>
+    <string name="child_number" msgid="4469090994612105532">"via <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Note sent"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Recent messages"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Business info"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mi away"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km away"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Opens tomorrow at <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Opens today at <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Closes at <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Closed today at <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Open now"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Closed now"</string>
+</resources>
diff --git a/InCallUI/res/values-en-rIN/strings.xml b/InCallUI/res/values-en-rIN/strings.xml
new file mode 100644
index 0000000..29fd2d9
--- /dev/null
+++ b/InCallUI/res/values-en-rIN/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telephone"</string>
+    <string name="onHold" msgid="527593602772521700">"On hold"</string>
+    <string name="unknown" msgid="3646075119047488748">"unknown"</string>
+    <string name="private_num" msgid="6081418498487514686">"Private number"</string>
+    <string name="payphone" msgid="5743050584468748607">"Payphone"</string>
+    <string name="confCall" msgid="3181961445236675173">"Conference call"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Call cut off"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Speaker"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Handset earpiece"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Wired headset"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Send the following tones?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Sending tones\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Send"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"yes"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"no"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Replace wild character with"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Conference call <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Voicemail number"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Dialling"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Redialling"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Conference call"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Incoming call"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Incoming work call"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Call ended"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"On hold"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Hanging up"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"In call"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"My number is <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Connecting video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Video call"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Requesting video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Can\'t connect video call"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Video request rejected"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Your callback number\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Your emergency callback number\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Dialling"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Missed call"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Missed calls"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> missed calls"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Missed call from <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"On-going call"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Ongoing work call"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Ongoing Wi-Fi call"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Ongoing Wi-Fi work call"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"On hold"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Incoming call"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Incoming work call"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Incoming Wi-Fi call"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Incoming Wi-Fi work call"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Incoming video call"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Incoming video request"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"New voicemail"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"New voicemail (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Dial <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Voicemail number unknown"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"No service"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Selected network (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) unavailable"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Answer"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Hang up"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"In-stream video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Voice"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Accept"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Dismiss"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Call back"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Message"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"To place a call, first turn off Aeroplane mode."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Not registered on network."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobile network not available."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"To place a call, enter a valid number."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Can\'t call."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Starting MMI sequence…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Service not supported."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Can\'t switch calls."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Can\'t separate call."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Can\'t transfer."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Can\'t conference."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Can\'t reject call."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Can\'t release call(s)."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP call"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Emergency call"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Turning on radio…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"No network. Trying again…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Can\'t call. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> is not an emergency number."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Can\'t call. Dial an emergency number."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Use keyboard to dial"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Hold Call"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Resume Call"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"End Call"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Dial pad"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Mute"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Add call"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Merge calls"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Swap"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Manage calls"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Manage conference call"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Video call"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Change to voice call"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Switch camera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pause video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"More options"</string>
+    <string name="player_started" msgid="3478865572468310331">"Player Started"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Player Stopped"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Camera not ready"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Camera ready"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Unknown call session event"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Service"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Set up"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Not set&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Other call settings"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Calling via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Incoming via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"contact photo"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"go private"</string>
+    <string name="selectContact" msgid="92191462970821951">"select contact"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Write your own..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"cancel"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Send"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Answer"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Send SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Decline"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Answer as video call"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Answer as audio call"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Accept video request"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Decline video request"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Accept video transmit request"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Decline video transmit request"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Accept video receive request"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Decline video receive request"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Slide up for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Slide left for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Slide right for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Slide down for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrate"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrate"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Sound"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Default sound (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Phone ringtone"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrate when ringing"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Ringtone &amp; Vibrate"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Manage conference call"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Emergency number"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> seconds</item>
+      <item quantity="one">1 second</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutes</item>
+      <item quantity="one">1 minute</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> hours</item>
+      <item quantity="one">1 hour</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profile photo"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Camera off"</string>
+    <string name="child_number" msgid="4469090994612105532">"via <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Note sent"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Recent messages"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Business info"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mi away"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km away"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Opens tomorrow at <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Opens today at <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Closes at <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Closed today at <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Open now"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Closed now"</string>
+</resources>
diff --git a/InCallUI/res/values-es-rUS/strings.xml b/InCallUI/res/values-es-rUS/strings.xml
new file mode 100644
index 0000000..06fe93f
--- /dev/null
+++ b/InCallUI/res/values-es-rUS/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Teléfono"</string>
+    <string name="onHold" msgid="527593602772521700">"En espera"</string>
+    <string name="unknown" msgid="3646075119047488748">"Desconocido"</string>
+    <string name="private_num" msgid="6081418498487514686">"Número privado"</string>
+    <string name="payphone" msgid="5743050584468748607">"Teléfono pago"</string>
+    <string name="confCall" msgid="3181961445236675173">"Llamada en conferencia"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Se interrumpió la llamada"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Altavoz"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Auricular del dispositivo"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Auriculares con cable"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"¿Deseas enviar los siguientes tonos?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Enviando tonos\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Enviar"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Sí"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"No"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Reemplazar el carácter comodín con"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Llamada en conferencia: <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Número de buzón de voz"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Marcando"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Volviendo a marcar"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Llamada en conferencia"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Llamada entrante"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Llamada entrante: trabajo"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Llamada finalizada"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"En espera"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Colgando"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"En llamada"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mi número es <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Conectando video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videollamada"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Solicitando video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"No se puede conectar la videollamada"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Se rechazó la solicitud de videollamada"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Número de devolución de llamada\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Número de devolución de llamada de emergencia\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Marcando"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Llamada perdida"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Llamadas perdidas"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> llamadas perdidas"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Llamada perdida de <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Llamada en curso"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Llamada en curso: trabajo"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Llamada Wi-Fi en curso"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Llamada Wi-Fi en curso: trabajo"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"En espera"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Llamada entrante"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Llamada entrante: trabajo"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Llamada Wi-Fi entrante"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Llamada Wi-Fi entrante: trabajo"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Videollamada entrante"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Solicitud de videollamada entrante"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nuevo mensaje de buzón de voz"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Buzón de voz nuevo (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Marcar <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Número de buzón de voz desconocido"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Sin servicio"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"La red seleccionada (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) no está disponible"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Responder"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Colgar"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Voz"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Aceptar"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Descartar"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Llamar"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Mensaje"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Para realizar una llamada, primero debes desactivar el modo de avión."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"No está registrado en la red."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"La red móvil no está disponible."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Para realizar una llamada, ingresa un número válido."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"No se puede realizar la llamada."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Iniciando la secuencia de MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"El servicio no es compatible."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"No se pueden cambiar las llamadas."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"No se puede desviar la llamada."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"No se puede transferir."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"No se puede realizar la conferencia."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"No se puede rechazar la llamada."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"No se pueden liberar las llamadas."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Llamada SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Llamada de emergencia"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Encendiendo radio…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"No hay servicio. Vuelve a intentarlo…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"No se puede realizar la llamada. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> no es un número de emergencia."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"No se puede realizar la llamada. Marca un número de emergencia."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Usar teclado para marcar"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Retener llamada"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Reanudar llamada"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Finalizar llamada"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Teclado"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Silenciar"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Agregar llamada"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Combinar llamadas"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Cambiar"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Administrar llamadas"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Administrar conferencia"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Video"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Cambiar a llamada de voz"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Cambiar cámara"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pausar video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Más opciones"</string>
+    <string name="player_started" msgid="3478865572468310331">"Se inició el reproductor"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Se detuvo el reproductor"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"La cámara no está lista"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Cámara lista"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Evento de sesión de llamada desconocido"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Servicio"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Configuración"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Sin configurar&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Otras opciones de llamada"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Llamada por medio de <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Entrantes por medio de <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"foto de contacto"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"pasar a modo privado"</string>
+    <string name="selectContact" msgid="92191462970821951">"seleccionar contacto"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Escribe tu propia respuesta…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Cancelar"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Enviar"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Responder"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Enviar SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Rechazar"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Responder como videollamada"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Responder como llamada de audio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Aceptar solicitud de videollamada"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Rechazar solicitud de videollamada"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Aceptar solicitud de transmisión de videollamada"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Rechazar solicitud de transmisión de videollamada"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Aceptar solicitud de recepción de videollamada"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Rechazar solicitud de recepción de videollamada"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Desliza el dedo hacia arriba para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Desliza el dedo hacia la izquierda para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Desliza el dedo hacia la derecha para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Desliza el dedo hacia abajo para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrar"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrar"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Sonido"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Sonido predeterminado (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Tono del teléfono"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrar al sonar"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Tono y vibración"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Administrar llamada en conferencia"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Número de emergencia"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> segundos</item>
+      <item quantity="one">1 segundo</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutos</item>
+      <item quantity="one">1 minuto</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> horas</item>
+      <item quantity="one">1 hora</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Foto de perfil"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Cámara desactivada"</string>
+    <string name="child_number" msgid="4469090994612105532">"del <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Se envió la nota"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Mensajes recientes"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Información de la empresa"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"A <xliff:g id="DISTANCE">%.1f</xliff:g> mi"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"A <xliff:g id="DISTANCE">%.1f</xliff:g> km"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"De <xliff:g id="OPEN_TIME">%1$s</xliff:g> a <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g> y <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Abre mañana a la hora <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Abre hoy a la hora <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Cierra a la hora <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Cerró hoy a la hora <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Abierto ahora"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Cerrado ahora"</string>
+</resources>
diff --git a/InCallUI/res/values-es/strings.xml b/InCallUI/res/values-es/strings.xml
new file mode 100644
index 0000000..7cc8629
--- /dev/null
+++ b/InCallUI/res/values-es/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Teléfono"</string>
+    <string name="onHold" msgid="527593602772521700">"En espera"</string>
+    <string name="unknown" msgid="3646075119047488748">"Desconocida"</string>
+    <string name="private_num" msgid="6081418498487514686">"Número privado"</string>
+    <string name="payphone" msgid="5743050584468748607">"Teléfono público"</string>
+    <string name="confCall" msgid="3181961445236675173">"Conferencia"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Llamada perdida"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Altavoz"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Auricular"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Auriculares con cable"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"¿Quieres enviar los siguientes tonos?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Enviando tonos\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Enviar"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Sí"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"No"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Sustituir el carácter comodín por"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Conferencia <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Número del mensaje de voz"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Llamando"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Llamando otra vez"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Conferencia"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Llamada entrante"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Llamada trabajo entrante"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Llamada finalizada"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"En espera"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Colgando"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Llamada entrante"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mi número es el <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Conectando videollamada"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videollamada"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Solicitando videollamada"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"No se puede establecer la videollamada"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Solicitud de videollamada rechazada"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Tu número de devolución de llamada\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Tu número de devolución de llamada de emergencia\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Llamando"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Llamada perdida"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Llamadas perdidas"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> llamadas perdidas"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Llamada perdida de <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Llamada en curso"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Llamada de trabajo en curso"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Llamada Wi-Fi en curso"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Llamada Wi-Fi de trabajo en curso"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"En espera"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Llamada entrante"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Llamada de trabajo entrante"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Llamada Wi-Fi entrante"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Llamada Wi-Fi de trabajo entrante"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Videollamada entrante"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Solicitud de videollamada entrante"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nuevo mensaje de voz"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nuevo mensaje de voz (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Marcar <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Número del mensaje de voz desconocido"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Sin servicio"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"La red seleccionada (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) no está disponible"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Responder"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Colgar"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Videollamada"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Voz"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Aceptar"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Rechazar"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Llamar"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Mensaje"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Para realizar una llamada, primero debes desactivar el modo avión."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"No registrado en la red"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"La red móvil no está disponible."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Para realizar una llamada, introduce un número válido."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"No se puede establecer la llamada."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Iniciando secuencia MMI..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Servicio no admitido."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"No se pueden intercambiar llamadas."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"No se pueden separar llamadas."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"No se puede transferir."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"No se puede establecer la conferencia."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"No se puede rechazar la llamada."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"No se pueden hacer llamadas."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Llamada SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Llamada de emergencia"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Activando señal móvil…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Sin servicio. Reintentado…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"No se puede establecer la llamada. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> no es un número de emergencia."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"No se puede establecer la llamada. Marcar un número de emergencia."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Utilizar teclado para marcar"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Retener llamada"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Seguir con la llamada"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Finalizar llamada"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Teclado"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Silenciar"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Añadir llamada"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Llamada a tres"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Cambiar"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Administrar llamadas"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Administrar conferencia"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videollamada"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Cambiar a llamada de voz"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Cambiar cámara"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pausar vídeo"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Más opciones"</string>
+    <string name="player_started" msgid="3478865572468310331">"Reproductor iniciado"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Reproductor detenido"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Cámara no preparada"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Cámara preparada"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Evento de sesión de llamada desconocido"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Servicio"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Configuración"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;No definido&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Otra configuración de llamada"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Llamada a través de <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Recibidas a través de <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"foto de contacto"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"llamada privada"</string>
+    <string name="selectContact" msgid="92191462970821951">"seleccionar contacto"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Escribe tu propia respuesta..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Cancelar"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Enviar"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Responder"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Enviar SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Rechazar"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Responder como videollamada"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Responder como llamada de audio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Aceptar solicitud de videollamada"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Rechazar solicitud de videollamada"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Aceptar solicitud de transmisión de videollamada"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Rechazar solicitud de transmisión de videollamada"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Aceptar solicitud de recepción de videollamada"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Rechazar solicitud de recepción de videollamada"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Desliza el dedo hacia arriba para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Desliza el dedo hacia la izquierda para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Desliza el dedo hacia la derecha para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Desliza el dedo hacia abajo para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrar"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrar"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Sonido"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Sonido predeterminado (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Tono de llamada del teléfono"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrar al sonar"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Tono de llamada y vibración"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Administrar videollamada"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Número de emergencia"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> segundos</item>
+      <item quantity="one">1 segundo</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutos</item>
+      <item quantity="one">1 minuto</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> horas</item>
+      <item quantity="one">1 hora</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Foto de perfil"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Cámara apagada"</string>
+    <string name="child_number" msgid="4469090994612105532">"a través de <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Nota enviada"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Mensajes recientes"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Información de la empresa"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"A <xliff:g id="DISTANCE">%.1f</xliff:g> mi"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"A <xliff:g id="DISTANCE">%.1f</xliff:g> km"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Abre mañana a las <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Abre hoy a las <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Cierra a las <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Cerrado hoy a las <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Abierto ahora"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Cerrado ahora"</string>
+</resources>
diff --git a/InCallUI/res/values-et-rEE/strings.xml b/InCallUI/res/values-et-rEE/strings.xml
new file mode 100644
index 0000000..b713672
--- /dev/null
+++ b/InCallUI/res/values-et-rEE/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Ootel"</string>
+    <string name="unknown" msgid="3646075119047488748">"Tundmatu"</string>
+    <string name="private_num" msgid="6081418498487514686">"Eranumber"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefoniautomaat"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konverentskõne"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Kõne katkes"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Kõlar"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Käsitelefoni kuular"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Juhtmega peakomplekt"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Kas saata järgmised toonid?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Toonide saatmine\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Saada"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Jah"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Ei"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Asenda metamärk üksusega"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konverentskõne <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Kõnepostinumber"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Valimine"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Uuesti valimine"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konverentskõne"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Sissetulev kõne"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Sissetulev töökõne"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Kõne lõpetati"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Ootel"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Lõpetamine"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Kõne on pooleli"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Minu number on <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Video ühendamine"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videokõne"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Video taotlemine"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Videokõnet ei õnnestu ühendada"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Videokõne taotlus lükati tagasi"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Teie tagasihelistamise number\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Teie hädaabikõne tagasihelistamise number\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Valimine"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Vastamata kõne"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Vastamata kõned"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> vastamata kõnet"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Vastamata kõne helistajalt <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Käimasolev kõne"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Käimasolev töökõne"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Käimasolev WiFi-kõne"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Käimasolev töökõne WiFi kaudu"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Ootel"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Sissetulev kõne"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Sissetulev töökõne"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Sissetulev WiFi-kõne"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Sissetulev töökõne WiFi kaudu"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Sissetulev videokõne"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Sissetulev videokõne taotlus"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Uus kõnepostisõnum"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Uus kõnepostisõnum (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Valige <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Kõnepostinumber on tundmatu"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Levi puudub"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Valitud võrk (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) pole saadaval"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Vasta"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Lõpeta kõne"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Videokõne"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Häälkõne"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Nõustu"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Loobu"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Helista tagasi"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Saada sõnum"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Helistamiseks lülitage esmalt lennukirežiim välja."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Ei ole võrgus registreeritud."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobiilsidevõrk pole saadaval."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Helistamiseks sisestage kehtiv number."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Ei saa helistada."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI-jada alustamine …"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Teenust ei toetata."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Kõnesid ei saa vahetada."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Kõnet ei saa eraldada."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Ei saa üle kanda."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Konverentskõnet ei saa pidada."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Kõnet ei saa tagasi lükata."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Kõnesid ei saa vabastada."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP-kõne"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Hädaabikõne"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Raadioside sisselülitamine …"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Levi puudub. Uuesti proovimine …"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Ei saa helistada. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> ei ole hädaabinumber."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Ei saa helistada. Valige hädaabinumber."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Kasutage valimiseks klaviatuuri"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Kõne ootele"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Jätka kõnet"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Lõpeta kõne"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Valimisklahvistik"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Vaigista"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Lisa kõne"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Ühenda kõned"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Vaheta"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Halda kõnesid"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Halda konverentskõnet"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Heli"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videokõne"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Mine üle häälkõnele"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Vaheta kaamerat"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Peata video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Rohkem valikuid"</string>
+    <string name="player_started" msgid="3478865572468310331">"Pleier käivitati"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Pleier peatati"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kaamera pole valmis"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kaamera on valmis"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Tundmatu kõneseansisündmus"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Teenus"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Seadistamine"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Määramata&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Muud kõneseaded"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Kõne edastab <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Sissetulev kõne teenusepakkuja <xliff:g id="PROVIDER_NAME">%s</xliff:g> kaudu"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"kontakti foto"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"aktiveeri privaatne kõne"</string>
+    <string name="selectContact" msgid="92191462970821951">"vali kontakt"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Kirjutage ise …"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Tühista"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Saada"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Vastamine"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS-i saatmine"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Tagasilükkamine"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Vastamine videokõnena"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Vastamine helikõnena"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Video taotluse aktsepteerimine"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Video taotluse tagasilükkamine"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Video edastamise taotluse aktsepteerimine"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Video edastamise taotluse tagasilükkamine"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Video vastuvõtmise taotluse aktsepteerimine"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Video vastuvõtmise taotluse tagasilükkamine"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Lohistage üles: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Lohistage vasakule: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Lohistage paremale: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Lohistage alla: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibreerimine"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibreerimine"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Heli"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Vaikeheli (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Telefonihelin"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibreerimine helina ajal"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Helin ja vibratsioon"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Konverentskõne haldamine"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Hädaabinumber"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekundit</item>
+      <item quantity="one">1 sekund</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutit</item>
+      <item quantity="one">1 minut</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> tundi</item>
+      <item quantity="one">1 tund</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profiilifoto"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kaamera on välja lülitatud"</string>
+    <string name="child_number" msgid="4469090994612105532">"numbri <xliff:g id="CHILD_NUMBER">%s</xliff:g> kaudu"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Märkus on saadetud"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Hiljutised sõnumid"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Ettevõtte teave"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> miili kaugusel"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km kaugusel"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> kuni <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Avatakse homme kell <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Avatakse täna kell <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Suletakse kell <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Suleti täna kell <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Praegu avatud"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Praegu suletud"</string>
+</resources>
diff --git a/InCallUI/res/values-eu-rES/strings.xml b/InCallUI/res/values-eu-rES/strings.xml
new file mode 100644
index 0000000..3c83a74
--- /dev/null
+++ b/InCallUI/res/values-eu-rES/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefonoa"</string>
+    <string name="onHold" msgid="527593602772521700">"Zain"</string>
+    <string name="unknown" msgid="3646075119047488748">"Ezezaguna"</string>
+    <string name="private_num" msgid="6081418498487514686">"Zenbaki pribatua"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefono publikoa"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferentzia-deia"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Eten egin da deia"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Bozgorailua"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Aurikularrak"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Kabledun entzungailua"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth konexioa"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Tonu hauek bidali nahi dituzu?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Tonuak bidaltzen\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Bidali"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Bai"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Ez"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Ordeztu komodina honekin:"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferentzia-deiaren ordua: <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Erantzungailuaren zenbakia"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Deitzen"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Berriro markatzen"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferentzia-deia"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Dei bat jaso duzu"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Laneko dei bat jaso duzu"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Amaitu da deia"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Zain"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Deia amaitzen"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Deia abian"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Nire zenbakia <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g> da"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Bideoa konektatzen"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Bideo-deia"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Bideo-deia eskatzen"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Ezin da konektatu bideo-deia"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Baztertu egin da bideo-deia egiteko eskaera"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Deiak itzultzeko zenbakia:\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Larrialdi-deiak itzultzeko zenbakia:\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Deitzen"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Dei bat galdu duzu"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Dei batzuk galdu dituzu"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> dei galdu dituzu"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Deitzaile honen dei bat galdu duzu: <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Deia abian da"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Laneko dei bat abian da"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Wi-Fi bidezko deia abian da"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Wi-Fi bidezko laneko dei bat abian da"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Zain"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Dei bat jaso duzu"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Laneko dei bat jaso duzu"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Wi-Fi bidezko dei bat jaso duzu"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Wi-Fi bidezko laneko dei bat jaso duzu"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Bideo-dei bat jaso duzu"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Bideo-dei bat egiteko eskaera bat jaso duzu"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Ahots-mezu berria"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Ahots-mezu berriak (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Markatu <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Erantzungailuaren zenbakia ezezaguna da"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Ez dago zerbitzurik"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Hautatutako sarea (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) ez dago erabilgarri"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Erantzun"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Amaitu deia"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Bideo-deia"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Ahots-deia"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Onartu"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Baztertu"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Itzuli deia"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Mezua"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Deitzeko, desaktibatu hegaldi modua."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Ez dago sarean erregistratuta."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Sare mugikorra ez dago erabilgarri."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Deitzeko, idatzi balio duen zenbaki bat."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Ezin da deitu."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI sekuentzia hasten…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Ez da onartzen zerbitzua."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Ezin aldatu beste dei batera."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Ezin da bereizi deia."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Ezin da transferitu."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Ezin da egin konferentzia-deia."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Ezin da baztertu deia."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Ezin dira amaitu deiak."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP deia"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Larrialdi-deia"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Irratia pizten…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Ez dago zerbitzurik. Berriro saiatzen…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Ezin da deitu. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> ez da larrialdietarako zenbakia."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Ezin da deitu. Markatu larrialdietarako zenbakia."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Erabili teklatua markatzeko"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Utzi deia zain"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Berrekin deiari"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Amaitu deia"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Markagailua"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Desaktibatu audioa"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Gehitu deia"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Bateratu deiak"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Aldatu"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Kudeatu deiak"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Kudeatu konferentzia-deia"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audioa"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Bideo-deia"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Aldatu ahots-deira"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Aldatu kamera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pausatu bideoa"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Aukera gehiago"</string>
+    <string name="player_started" msgid="3478865572468310331">"Abian da erreproduzigailua"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Gelditu da erreproduzigailua"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Ez dago prest kamera"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Prest dago kamera"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Dei-saioko gertaera ezezaguna"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Zerbitzua"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Konfigurazioa"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Ezarri gabe&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Deien beste ezarpen batzuk"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> bidez deitzen"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> bidez jasotzen"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"kontaktuaren argazkia"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"bihurtu pribatu"</string>
+    <string name="selectContact" msgid="92191462970821951">"hautatu kontaktua"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Idatzi zeure erantzuna…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Utzi"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Bidali"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Erantzun"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Bidali SMS mezua"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Baztertu"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Erantzun bideo-dei moduan"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Erantzun audio-dei moduan"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Onartu bideo-deia egiteko eskaera"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Baztertu bideo-deia egiteko eskaera"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Onartu bideoa transmititzeko eskaera"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Baztertu bideoa transmititzeko eskaera"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Onartu bideo-deia jasotzeko eskaera"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Baztertu bideo-deia jasotzeko eskaera"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Lerratu gora hau egiteko: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Lerratu ezkerrera hau egiteko: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Lerratu eskuinera hau egiteko: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Lerratu behera hau egiteko: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Dardara"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Dardara"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Soinua"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Soinu lehenetsia (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Telefonoaren tonua"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Egin dar-dar tonuak jotzean"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Tonua eta dardara"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Kudeatu konferentzia-deia"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Larrialdietarako zenbakia"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> segundo</item>
+      <item quantity="one">Segundo bat</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutu</item>
+      <item quantity="one">Minutu bat</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ordu</item>
+      <item quantity="one">Ordubete</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profileko argazkia"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Desaktibatuta dago kamera"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> zenbakitik"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Bidali da oharra"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Azken mezuak"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Enpresaren informazioa"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"Hemendik <xliff:g id="DISTANCE">%.1f</xliff:g> miliara"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"Hemendik <xliff:g id="DISTANCE">%.1f</xliff:g> km-ra"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"<xliff:g id="OPEN_TIME">%s</xliff:g> da biharko irekitze-ordua"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"<xliff:g id="OPEN_TIME">%s</xliff:g> da gaurko irekitze-ordua"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g> da itxiera-ordua"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"<xliff:g id="CLOSE_TIME">%s</xliff:g> da gaurko itxiera-ordua"</string>
+    <string name="open_now" msgid="4615706338669555999">"Irekita dago"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Itxita dago"</string>
+</resources>
diff --git a/InCallUI/res/values-fa/strings.xml b/InCallUI/res/values-fa/strings.xml
new file mode 100644
index 0000000..add4d0f
--- /dev/null
+++ b/InCallUI/res/values-fa/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"تلفن"</string>
+    <string name="onHold" msgid="527593602772521700">"در انتظار"</string>
+    <string name="unknown" msgid="3646075119047488748">"نامشخص"</string>
+    <string name="private_num" msgid="6081418498487514686">"شماره خصوصی"</string>
+    <string name="payphone" msgid="5743050584468748607">"تلفن عمومی"</string>
+    <string name="confCall" msgid="3181961445236675173">"تماس کنفرانسی"</string>
+    <string name="call_lost" msgid="8208184291640961172">"تماس قطع شد"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"بلندگو"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"گوشی"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"هدست سیمی"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"بلوتوث"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"شماره‌های بعدی ارسال شود؟\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"تون‌های ارسالی\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"ارسال"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"بله"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"نه"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"جایگزینی نویسه عمومی با"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"تماس کنفرانسی <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"شماره پست صوتی"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"شماره‌گیری"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"درحال شماره‌گیری مجدد"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"تماس کنفرانسی"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"تماس ورودی"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"تماس کاری ورودی"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"تماس پایان یافت"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"در انتظار"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"قطع تماس"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"درحال تماس"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"شماره من <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g> است"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"درحال برقراری تماس ویدیویی"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"تماس ویدیویی"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"درحال درخواست تماس ویدیویی"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"برقراری تماس ویدیویی ممکن نیست"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"درخواست تماس ویدیویی رد شد"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"شماره پاسخ تماس شما\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"شماره پاسخ تماس اضطراری شما\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"شماره‌گیری"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"تماس بی‌پاسخ"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"تماس بی‌پاسخ"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> تماس بی‌پاسخ"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"تماس بی‌پاسخ از <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"تماس درحال انجام"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"تماس کاری درحال انجام"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"‏تماس درحال انجام ازطریق Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"‏تماس کاری Wi-Fi درحال انجام"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"در انتظار"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"تماس ورودی"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"تماس کاری ورودی"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"‏تماس Wi-Fi ورودی"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"‏تماس کاری Wi-Fi ورودی"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"تماس ویدیویی ورودی"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"درخواست تماس ویدیویی ورودی"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"پست صوتی جدید"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"پست صوتی جدید (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"شماره‌گیری <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"شماره پست صوتی ناشناس"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"بدون سرویس"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"شبکه انتخابی (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) قابل دسترس نیست"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"پاسخ"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"پایان تماس"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"ویدیو"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"صدا"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"پذیرفتن"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"نپذیرفتن"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"پاسخ تماس"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"پیام"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"برای برقراری تماس، ابتدا حالت هواپیما را خاموش کنید."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"در شبکه ثبت نشده است."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"شبکه تلفن همراه در دسترس نیست."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"برای برقراری تماس، شماره معتبری وارد کنید."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"تماس ممکن نیست."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"‏شروع ترتیب MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"سرویس پشتیبانی نمی‌شود."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"جابه‌جایی بین تماس‌ها ممکن نیست."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"جدا کردن تماس ممکن نیست."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"انتقال ممکن نیست."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"تماس کنفرانسی ممکن نیست."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"رد کردن تماس ممکن نیست."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"آزاد کردن تماس(ها) ممکن نیست."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"‏تماس SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"تماس اضطراری"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"درحال روشن کردن رادیو…‏"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"سرویسی دردسترس نیست. درحال تلاش مجدد…‏"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"تماس ممکن نیست. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> شماره اضطراری نیست."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"تماس ممکن نیست. فقط شماره اضطراری."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"استفاده از صفحه‌کلید برای شماره‌گیری"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"در انتظار گذاشتن تماس"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"ازسرگیری تماس"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"پایان تماس"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"صفحه شماره‌گیری"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"بی‌صدا کردن"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"افزودن تماس"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"ادغام تماس‌ها"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"تعویض"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"مدیریت تماس‌ها"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"مدیریت تماس کنفرانسی"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"صوتی"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"تماس ویدیویی"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"تغییر به تماس صوتی"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"تعویض دوربین"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"توقف موقت ویدیو"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"گزینه‌های بیشتر"</string>
+    <string name="player_started" msgid="3478865572468310331">"پخش‌کننده راه‌اندازی شد"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"پخش‌کننده متوقف شد"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"دوربین آماده نیست"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"دوربین آماده است"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"رویداد جلسه تماس ناشناس"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"سرویس"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"راه‌اندازی"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"‏&lt;تنظیم نشده&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"سایر تنظیمات تماس"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"تماس با <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"تماس‌های ورودی ازطریق <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"عکس مخاطب"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"رفتن به حالت خصوصی"</string>
+    <string name="selectContact" msgid="92191462970821951">"انتخاب مخاطب"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"پیام خودتان را بنویسید..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"لغو"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"ارسال"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"پاسخ"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"ارسال پیامک"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"رد کردن"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"پاسخ به‌صورت تماس ویدیویی"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"پاسخ به‌صورت تماس صوتی"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"پذیرفتن درخواست تماس ویدیویی"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"نپذیرفتن درخواست تماس ویدیویی"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"پذیرفتن درخواست مخابره ویدیویی"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"نپذیرفتن درخواست مخابره ویدیویی"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"پذیرفتن درخواست دریافت ویدیویی"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"نپذیرفتن درخواست دریافت ویدیویی"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"برای <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> به بالا بلغزانید."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"برای <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> به چپ بلغزانید."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"برای <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> به راست بلغزانید."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"برای <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> به پایین بلغزانید."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"لرزش"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"لرزش"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"صدا"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"صدای پیش‌فرض (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"آهنگ زنگ تلفن"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"لرزش هنگام زنگ زدن"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"آهنگ‌ زنگ و لرزش"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"مدیریت تماس کنفرانسی"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"شماره اضطراری"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ثانیه</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ثانیه</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> دقیقه</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> دقیقه</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one">‏<xliff:g id="COUNT">%d</xliff:g> ساعت</item>
+      <item quantity="other">‏<xliff:g id="COUNT">%d</xliff:g> ساعت</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"عکس نمایه"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"دوربین خاموش"</string>
+    <string name="child_number" msgid="4469090994612105532">"ازطریق <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"یادداشت ارسال شد"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"پیام‌های جدید"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"اطلاعات کسب و کار"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> مایل فاصله"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> کیلومتر فاصله"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>،‏ <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> تا <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>،‏ <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"فردا ساعت <xliff:g id="OPEN_TIME">%s</xliff:g> باز می‌شود"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"امروز ساعت <xliff:g id="OPEN_TIME">%s</xliff:g> باز می‌شود"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"ساعت <xliff:g id="CLOSE_TIME">%s</xliff:g> بسته می‌شود"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"امروز ساعت <xliff:g id="CLOSE_TIME">%s</xliff:g> بسته شد"</string>
+    <string name="open_now" msgid="4615706338669555999">"اکنون باز است"</string>
+    <string name="closed_now" msgid="2635314668145282080">"اکنون بسته است"</string>
+</resources>
diff --git a/InCallUI/res/values-fi/strings.xml b/InCallUI/res/values-fi/strings.xml
new file mode 100644
index 0000000..b0d8ee5
--- /dev/null
+++ b/InCallUI/res/values-fi/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Puhelin"</string>
+    <string name="onHold" msgid="527593602772521700">"Pidossa"</string>
+    <string name="unknown" msgid="3646075119047488748">"Tuntematon"</string>
+    <string name="private_num" msgid="6081418498487514686">"Yksityinen numero"</string>
+    <string name="payphone" msgid="5743050584468748607">"Maksupuhelin"</string>
+    <string name="confCall" msgid="3181961445236675173">"Puhelinneuvottelu"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Puhelu katkaistiin."</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Kaiutin"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Puhelimen kaiutin"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Kuulokemikrofoni"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Lähetetäänkö seuraavat äänet?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Lähetetään ääniä\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Lähetä"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Kyllä"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Ei"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Muuta jokerimerkiksi"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Puhelinneuvottelu <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Puhelinvastaajan numero"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Soitetaan"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Soitetaan uudelleen"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Puhelinneuvottelu"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Saapuva puhelu"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Saapuva työpuhelu"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Puhelu päättyi"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Pidossa"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Katkaistaan"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Puhelu käynnissä"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Numeroni on <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Avataan videoyhteys"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videopuhelu"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Videota pyydetään"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Videopuhelua ei voi soittaa"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Videopyyntö hylättiin"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Takaisinsoittonumero:\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Hätäpuhelujen takaisinsoittonumero:\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Soitetaan"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Vastaamaton puhelu"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Vastaamattomia puheluita"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> vastaamatonta puhelua"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Vastaamaton puhelu: <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Käynnissä oleva puhelu"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Käynnissä oleva työpuhelu"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Käynnissä oleva Wi-Fi-puhelu"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Käynnissä oleva Wi-Fi-työpuhelu"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Pidossa"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Saapuva puhelu"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Saapuva työpuhelu"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Saapuva Wi-Fi-puhelu"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Saapuva Wi-Fi-työpuhelu"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Saapuva videopuhelu"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Saapuva videopyyntö"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Uusi vastaajaviesti"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Uusia vastaajaviestejä (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Soita: <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Puhelinvastaajan numero on tuntematon."</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Ei yhteyttä"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Valittu verkko (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) ei ole käytettävissä."</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Vastaa"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Katkaise"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Videopuhelu"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Äänipuhelu"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Hyväksy"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Hylkää"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Soita"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Viesti"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Poista lentokonetila käytöstä ennen puhelun soittamista."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Ei rekisteröity verkkoon"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Matkapuhelinverkko ei ole käytettävissä."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Soita antamalla kelvollinen numero."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Puhelua ei voi soittaa."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Aloitetaan MMI-koodisekvenssiä…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Yhteyttä ei tueta."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Puhelua ei voi vaihtaa."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Puhelua ei voi erottaa."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Puhelua ei voi siirtää."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Puheluja ei voi yhdistää."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Puhelua ei voi hylätä."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Puheluja ei voi katkaista."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP-puhelu"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Hätäpuhelu"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Käynnistetään radiota…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Ei yhteyttä. Yritetään uudelleen…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Puhelua ei voi soittaa. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> ei ole hätänumero."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Puhelua ei voi soittaa. Valitse hätänumero."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Valitse numero näppäimistöllä."</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Aseta puhelu pitoon"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Jatka puhelua"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Lopeta puhelu"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Näppäimistö"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Mykistä"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Lisää puhelu"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Yhdistä puhelut"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Vaihda"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Hallinnoi puheluja"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Hallinnoi puhelinneuvottelua"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Ääni"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Video"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Muuta äänipuheluksi"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Vaihda kameraa"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Keskeytä video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Lisäasetukset"</string>
+    <string name="player_started" msgid="3478865572468310331">"Soitin käynnistettiin."</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Soitin pysäytettiin."</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera ei ole valmis."</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera on valmis."</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Tuntematon puheluistunnon tapahtuma"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Palveluntarjoaja"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Määritys"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Ei määritetty&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Muut puheluasetukset"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Käytetään operaattoria <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Saapuva puhelu (<xliff:g id="PROVIDER_NAME">%s</xliff:g>)"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"Yhteystiedon kuva"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"Muuta yksityiseksi."</string>
+    <string name="selectContact" msgid="92191462970821951">"Valitse yhteystieto."</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Kirjoita oma…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Peruuta"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Lähetä"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Vastaa."</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Lähetä tekstiviesti."</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Hylkää."</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Vastaa ja aloita videopuhelu."</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Vastaa ja aloita äänipuhelu."</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Hyväksy videopyyntö."</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Hylkää videopyyntö."</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Hyväksy videon lähetyspyyntö."</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Hylkää videon lähetyspyyntö."</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Hyväksy videon vastaanottopyyntö."</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Hylkää videon vastaanottopyyntö."</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Valitse <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> liu\'uttamalla ylös."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Valitse <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> liu\'uttamalla vasemmalle."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Valitse <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> liu\'uttamalla oikealle."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Valitse <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> liu\'uttamalla alas."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Värinä"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Värinä"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Ääni"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Oletusääni (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Puhelimen soittoääni"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Käytä värinää, kun puhelin soi"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Soittoääni ja värinä"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Hallinnoi puhelinneuvottelua"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Hätänumero"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekuntia</item>
+      <item quantity="one">1 sekunti</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minuuttia</item>
+      <item quantity="one">1 minuutti</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> tuntia</item>
+      <item quantity="one">1 tunti</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profiilikuva"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera on pois käytöstä."</string>
+    <string name="child_number" msgid="4469090994612105532">"nron <xliff:g id="CHILD_NUMBER">%s</xliff:g> kautta"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Muistiinpano lähetettiin."</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Viimeisimmät viestit"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Yrityksen tiedot"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"Etäisyys: <xliff:g id="DISTANCE">%.1f</xliff:g> mailia"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"Etäisyys: <xliff:g id="DISTANCE">%.1f</xliff:g> kilometriä"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>–<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Avataan huomenna kello <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Avataan tänään kello <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Suljetaan tänään kello <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Suljettiin tänään kello <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Avoinna nyt"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Suljettu nyt"</string>
+</resources>
diff --git a/InCallUI/res/values-fr-rCA/strings.xml b/InCallUI/res/values-fr-rCA/strings.xml
new file mode 100644
index 0000000..9424398
--- /dev/null
+++ b/InCallUI/res/values-fr-rCA/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Téléphone"</string>
+    <string name="onHold" msgid="527593602772521700">"En attente"</string>
+    <string name="unknown" msgid="3646075119047488748">"Inconnue"</string>
+    <string name="private_num" msgid="6081418498487514686">"Numéro privé"</string>
+    <string name="payphone" msgid="5743050584468748607">"Cabine téléphonique"</string>
+    <string name="confCall" msgid="3181961445236675173">"Conférence téléphonique"</string>
+    <string name="call_lost" msgid="8208184291640961172">"L\'appel a été interrompu"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Haut-parleur"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Écouteur du combiné"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Écouteurs à fil"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Envoyer les tonalités suivantes?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Envoi des tonalités\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Envoyer"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Oui"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Non"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Remplacer le caractère générique par"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Conférence téléphonique <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Numéro de messagerie vocale"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Composition..."</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Recomposition en cours..."</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Conférence téléphonique"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Appel entrant"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Appel entrant - travail"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Appel terminé"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"En attente"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Fin de l\'appel"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"En cours d\'appel"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mon numéro est le <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Connexion de la vidéo en cours…"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Appel vidéo"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Demande de vidéo en cours"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Impossible de connecter l\'appel vidéo"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Demande vidéo refusée"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Votre numéro de rappel :\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Votre numéro de rappel d\'urgence :\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Composition en cours..."</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Appel manqué"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Appels manqués"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> appels manqués"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Appel manqué de <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Appel en cours"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Appel en cours - travail"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Appel Wi-Fi en cours"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Appel Wi-Fi en cours - travail"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"En attente"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Appel entrant"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Appel entrant - travail"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Appel Wi-Fi entrant"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Appel Wi-Fi entrant - travail"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Appel vidéo entrant"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Demande de vidéo reçue"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nouveau message vocal"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nouveaux messages vocaux (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Composer le <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Numéro de messagerie vocale inconnu"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Aucun service"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Réseau sélectionné (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) non disponible"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Répondre"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Raccrocher"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Vidéo"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Voix"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Accepter"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Fermer"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Rappeler"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Message"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Pour faire un appel, d\'abord désactiver le mode Avion."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Non enregistré sur le réseau."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Réseau cellulaire non disponible."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Pour faire un appel, entrez un numéro valide."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Impossible d\'appeler."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Lancement de la séquence IHM en cours…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Service non pris en charge."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Impossible de faire des appels."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Impossible de séparer les appels."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Impossible de transférer."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Impossible de créer la conférence."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Impossible de refuser l\'appel."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Impossible de libérer l\'appel ou les appels."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Appel SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Appel d\'urgence"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Activation du signal radio…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Aucun service. Nouvel essai en cours..."</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Appel impossible. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> n\'est pas un numéro d\'urgence."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Appel impossible. Composez un numéro d\'urgence."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Utilisez le clavier pour composer un numéro"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Mettre l\'appel en attente"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Reprendre l\'appel"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Mettre fin à l\'appel"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Clavier numérique"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Désactiver le son"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Ajouter un appel"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Fusionner les appels"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Permuter"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Gérer les appels"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Gérer la conférence"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Appel vidéo"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Passer à un appel vocal"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Changer d\'appareil photo"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Interrompre la vidéo"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Plus d\'options"</string>
+    <string name="player_started" msgid="3478865572468310331">"Le lecteur a démarré"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Le lecteur a arrêté"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"L\'appareil photo n\'est pas prêt"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"L\'appareil photo est prêt"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Événement inconnu de séance d\'appel"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Service"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Configuration"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Non défini&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Autres paramètres d\'appel"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Appel par <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Appel entrant par <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"photo du contact"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"mode privé"</string>
+    <string name="selectContact" msgid="92191462970821951">"sélectionner un contact"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Réponse personnalisée..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Annuler"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Envoyer"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Répondre"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Envoyer un texto"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Refuser"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Répondre comme appel vidéo"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Répondre comme appel audio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Accepter la demande vidéo"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Refuser la demande vidéo"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Accepter la demande de transmission vidéo"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Refuser la demande de transmission vidéo"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Accepter la demande de réception vidéo"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Refuser la demande de réception vidéo"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Faites glisser votre doigt vers le haut pour <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Faites glisser votre doigt vers la gauche pour <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Faites glisser votre doigt vers la droite pour <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Faire glisser le doigt vers le bas : <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibration"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibration"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Son"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Son par défaut (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Sonnerie du téléphone"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrer lorsque téléphone sonne"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Sonnerie et vibreur"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Gérer la conférence"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Numéro d\'urgence"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> seconde</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> secondes</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> minute</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutes</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> heure</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> heures</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Photo de profil"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Appareil photo désactivé"</string>
+    <string name="child_number" msgid="4469090994612105532">"au moyen du <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Note envoyée"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Messages récents"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Renseignements sur l\'entreprise"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"À <xliff:g id="DISTANCE">%.1f</xliff:g> mi"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"À <xliff:g id="DISTANCE">%.1f</xliff:g> km"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"De <xliff:g id="OPEN_TIME">%1$s</xliff:g> à <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Ouvre demain à <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Ouvre aujourd\'hui à <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Ferme à <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"A fermé aujourd\'hui à <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Ouvert"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Fermé"</string>
+</resources>
diff --git a/InCallUI/res/values-fr/strings.xml b/InCallUI/res/values-fr/strings.xml
new file mode 100644
index 0000000..fe70f8c
--- /dev/null
+++ b/InCallUI/res/values-fr/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Téléphone"</string>
+    <string name="onHold" msgid="527593602772521700">"En attente"</string>
+    <string name="unknown" msgid="3646075119047488748">"Inconnu"</string>
+    <string name="private_num" msgid="6081418498487514686">"Numéro privé"</string>
+    <string name="payphone" msgid="5743050584468748607">"Cabine téléphonique"</string>
+    <string name="confCall" msgid="3181961445236675173">"Conférence téléphonique"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Appel interrompu"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Haut-parleur"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Écouteur du combiné"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Casque filaire"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Envoyer les tonalités suivantes ?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Envoi des tonalités…\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Envoyer"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Oui"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Non"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Remplacer le caractère générique par"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Conférence téléphonique à <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"N° de la messagerie vocale"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Appel…"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Rappel…"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Conférence téléphonique"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Appel entrant"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Appel profession. entrant"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Appel terminé"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"En attente"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Fin de l\'appel…"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Appel en cours"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mon numéro est le <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Connexion de la vidéo…"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Appel vidéo"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Demande de vidéo…"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Impossible d\'établir la connexion de l\'appel vidéo."</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Demande d\'appel vidéo refusée"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Votre numéro de rappel\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Votre numéro de rappel d\'urgence\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Appel…"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Appel manqué"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Appels manqués"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> appels manqués"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Appel manqué de <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Appel en cours"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Appel professionnel en cours"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Appel Wi-Fi en cours"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Appel Wi-Fi professionnel en cours"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"En attente"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Appel entrant"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Appel professionnel entrant"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Appel Wi-Fi entrant"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Appel Wi-Fi professionnel entrant"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Appel vidéo entrant"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Demande de vidéo reçue"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nouveau message vocal"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nouveaux messages vocaux (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Composer le <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Numéro de messagerie vocale inconnu"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Aucun service"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Réseau sélectionné (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) non disponible"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Répondre"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Raccrocher"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Vidéo"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Appel vocal"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Accepter"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Fermer"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Rappeler"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Envoyer SMS"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Veuillez désactiver le mode Avion avant de passer un appel."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Non enregistré sur le réseau."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Réseau mobile indisponible."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Pour émettre un appel, veuillez saisir un numéro valide."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Impossible d\'émettre l\'appel."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Lancement de la séquence IHM…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Service non compatible."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Impossible de changer d\'appel."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Impossible d\'isoler l\'appel."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Transfert impossible."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Impossible de lancer une conférence téléphonique."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Impossible de refuser l\'appel."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Impossible de lancer les appels."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Appel SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Appel d\'urgence"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Activation du signal radio…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Aucun service disponible. Nouvelle tentative…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Impossible d\'émettre l\'appel. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> n\'est pas un numéro d\'urgence."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Impossible d\'émettre l\'appel. Veuillez composer un numéro d\'urgence."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Utilisez le clavier pour composer un numéro."</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Mettre l\'appel en attente"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Reprendre l\'appel"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Mettre fin à l\'appel"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Clavier"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Couper le son"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Ajouter un appel"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Fusionner les appels"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Permuter"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Gérer les appels"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Gérer conférence téléphonique"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Appel vidéo"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Passer à un appel vocal"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Changer de caméra"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Suspendre la vidéo"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Plus d\'options"</string>
+    <string name="player_started" msgid="3478865572468310331">"Le lecteur a démarré."</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Le lecteur s\'est arrêté."</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"La caméra n\'est pas prête"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"La caméra est prête"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Événement de session d\'appel inconnu"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Service"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Configuration"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Non défini&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Autres paramètres d\'appel"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Appel via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Appel entrant via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"photo du contact"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"mode privé"</string>
+    <string name="selectContact" msgid="92191462970821951">"sélectionner un contact"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Réponse personnalisée…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Annuler"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Envoyer"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Répondre"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Envoyer un SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Refuser"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Répondre via un appel vidéo"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Répondre via un appel audio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Accepter la demande d\'appel vidéo"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Refuser la demande d\'appel vidéo"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Accepter la demande de transmission d\'appel vidéo"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Refuser la demande de transmission d\'appel vidéo"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Accepter la demande de réception d\'appel vidéo"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Refuser la demande de réception d\'appel vidéo"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Faites glisser vers le haut pour <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Faites glisser vers la gauche pour <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Faites glisser vers la droite pour <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Faites glisser vers le bas pour <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibreur"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibreur"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Sonnerie"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Sonnerie par défaut (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Sonnerie du téléphone"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibreur lorsque le tél. sonne"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Sonnerie et vibreur"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Gérer la conférence téléphonique"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Numéro d\'urgence"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> seconde</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> secondes</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> minute</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutes</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> heure</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> heures</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Photo du profil"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Caméra désactivée"</string>
+    <string name="child_number" msgid="4469090994612105532">"via le <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"La note a bien été envoyée."</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Messages récents"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informations sur l\'établissement"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"À <xliff:g id="DISTANCE">%.1f</xliff:g> mi"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"À <xliff:g id="DISTANCE">%.1f</xliff:g> km"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Ouvre demain à <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Ouvre aujourd\'hui à <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Ferme à <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Fermé aujourd\'hui à <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Ouvert"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Fermé"</string>
+</resources>
diff --git a/InCallUI/res/values-gl-rES/strings.xml b/InCallUI/res/values-gl-rES/strings.xml
new file mode 100644
index 0000000..0b95b42
--- /dev/null
+++ b/InCallUI/res/values-gl-rES/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Teléfono"</string>
+    <string name="onHold" msgid="527593602772521700">"En espera"</string>
+    <string name="unknown" msgid="3646075119047488748">"Descoñecido"</string>
+    <string name="private_num" msgid="6081418498487514686">"Número privado"</string>
+    <string name="payphone" msgid="5743050584468748607">"Teléfono público"</string>
+    <string name="confCall" msgid="3181961445236675173">"Conferencia telefónica"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Chamada interrompida"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Altofalante"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Auricular do teléfono"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Auriculares con cable"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Queres enviar os seguintes tons?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Enviando tons\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Enviar"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Si"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Non"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Substituír carácter comodín por"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Conferencia telefónica ás <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Número de correo de voz"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Marcando"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Marcando de novo"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Conferencia telefónica"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Chamada entrante"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Chamada traballo entrante"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Chamada finalizada"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"En espera"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Desconectando"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Chamada entrante"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"O meu número é o <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Conectando vídeo"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videochamada"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Solicitando vídeo"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Non se pode conectar a videochamada"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Rexeitouse a solicitude de vídeo"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"O teu número de devolución de chamada\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"O teu número de devolución de chamada de emerxencia\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Marcando"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Chamada perdida"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Chamadas perdidas"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> chamadas perdidas"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Chamada perdida de <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Chamada en curso"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Chamada de traballo saínte"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Chamada por wifi saínte"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Chamada por wifi de traballo saínte"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"En espera"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Chamada entrante"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Chamada de traballo entrante"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Chamada por wifi entrante"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Chamada wifi de traballo entrante"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Videochamada entrante"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Solicitude de vídeo entrante"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Correo de voz novo"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Correo de voz novo (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Marcar o <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Número de correo de voz descoñecido"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Sen servizo"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"A rede seleccionada (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) non está dispoñible"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Responder"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Colgar"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Vídeo"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Voz"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Aceptar"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Ignorar"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Dev. chamada"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Mensaxe"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Para realizar unha chamada, primeiro desactiva o modo avión."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Sen rexistro na rede."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Rede móbil non dispoñible."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Para realizar unha chamada, introduce un número válido."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Non se pode realizar a chamada."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Iniciando secuencia MMI..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Servizo non compatible."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Non se poden cambiar as chamadas."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Non se pode separar a chamada."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Non se pode transferir."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Non se pode realizar a conferencia."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Non se pode rexeitar a chamada."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Non se poden desconectar as chamadas."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Chamada SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Chamada de emerxencia"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Activando radio..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Sen servizo. Tentándoo de novo…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Non se pode realizar a chamada. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> non é un número de emerxencia."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Non se pode realizar a chamada. Marca un número de emerxencia."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Utiliza o teclado para marcar"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Poñer a chamada en espera"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Retomar chamada"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Finalizar chamada"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Teclado de marcación"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Silenciar"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Engadir chamada"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Combinar chamadas"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Cambiar"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Xestionar chamadas"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Xestionar confer. telefónica"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videocham."</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Cambiar para chamada de voz"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Cambiar cámara"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pausar vídeo"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Máis opcións"</string>
+    <string name="player_started" msgid="3478865572468310331">"Iniciouse o reprodutor"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Detívose o reprodutor"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"A cámara non está preparada"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"A cámara está preparada"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Evento de sesión de chamada descoñecido"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Servizo"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Configuración"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Sen configurar&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Outras configuracións de chamada"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Chamando a través de <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Chamadas entrantes a través de <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"foto do contacto"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"activar o modo privado"</string>
+    <string name="selectContact" msgid="92191462970821951">"seleccionar contacto"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Escribe a túa propia..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Cancelar"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Enviar"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Responder"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Enviar SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Rexeitar"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Responde como videochamada"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Responde como chamada de audio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Acepta a solicitude de vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Rexeita a solicitude de vídeo"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Acepta a solicitude de transmisión de vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Rexeita a solicitude de transmisión de vídeo"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Acepta a solicitude de recepción de vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Rexeita a solicitude de recepción de vídeo"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Pasa o dedo cara a arriba para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Pasa o dedo cara a esquerda para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Pasa o dedo cara a dereita para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Pasa o dedo cara a abaixo para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrar"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrar"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Son"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Son predeterminado (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Ton de chamada do teléfono"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrar ao soar"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Ton de chamada e vibración"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Xestionar conferencia telefónica"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Número de emerxencia"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> segundos</item>
+      <item quantity="one">1 segundo</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutos</item>
+      <item quantity="one">1 minuto</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> horas</item>
+      <item quantity="one">1 hora</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Foto do perfil"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"A cámara está desactivada"</string>
+    <string name="child_number" msgid="4469090994612105532">"a través do <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Enviouse a nota"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Mensaxes recentes"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Información da empresa"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"A <xliff:g id="DISTANCE">%.1f</xliff:g> mi de distancia"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"A <xliff:g id="DISTANCE">%.1f</xliff:g> km de distancia"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Abre mañá ás <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Abre hoxe ás <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Pecha ás <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Pechou hoxe ás <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Aberto agora"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Pechado agora"</string>
+</resources>
diff --git a/InCallUI/res/values-gu-rIN/strings.xml b/InCallUI/res/values-gu-rIN/strings.xml
new file mode 100644
index 0000000..f97ed00
--- /dev/null
+++ b/InCallUI/res/values-gu-rIN/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"ફોન"</string>
+    <string name="onHold" msgid="527593602772521700">"હોલ્ડ પર"</string>
+    <string name="unknown" msgid="3646075119047488748">"અજાણ્યો"</string>
+    <string name="private_num" msgid="6081418498487514686">"ખાનગી નંબર"</string>
+    <string name="payphone" msgid="5743050584468748607">"પેફોન"</string>
+    <string name="confCall" msgid="3181961445236675173">"કોન્ફરન્સ કૉલ"</string>
+    <string name="call_lost" msgid="8208184291640961172">"કૉલ કપાઇ ગયો"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"સ્પીકર"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"હેન્ડસેટ ઇયરપીસ"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"વાયર્ડ હેડસેટ"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"નીચે આપેલ ટોન્સ મોકલીએ?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"ટોન્સ મોકલી રહ્યાં છે\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"મોકલો"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"હા"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"નહીં"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"વાઇલ્ડ અક્ષરને આની સાથે બદલો"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"કોન્ફરન્સ કૉલ <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"વૉઇસમેઇલ નંબર"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"ડાયલ કરી રહ્યાં છે"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"ફરી ડાયલ કરી રહ્યાં છે"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"કોન્ફરન્સ કૉલ"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"ઇનકમિંગ કૉલ"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"ઇનકમિંગ કાર્ય કૉલ"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"કૉલ સમાપ્ત થયો"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"હોલ્ડ પર"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"સમાપ્ત કરી રહ્યાં છે"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"કૉલમાં"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"મારો નંબર <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g> છે"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"વિડિઓ કનેક્ટ કરી રહ્યાં છે"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"વિડિઓ કૉલ"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"વિડિઓની વિનંતી કરી રહ્યાં છે"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"વિડિઓ કૉલ કનેક્ટ કરી શકાતો નથી"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"વિડિઓ વિનંતી નકારી"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"તમારો કૉલબેક નંબર\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"તમારો કટોકટીનો કૉલબેક નંબર\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"ડાયલ કરી રહ્યાં છે"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"છૂટેલો કૉલ"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"છૂટેલા કૉલ્સ"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> છૂટેલા કૉલ"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> નો કૉલ ચૂકી ગયાં"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"ચાલી રહેલ કૉલ"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"ચાલી રહેલ કાર્ય કૉલ"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"ચાલી રહેલ Wi-Fi કૉલ"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"ચાલી રહેલ Wi-Fi કાર્ય કૉલ"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"હોલ્ડ પર"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"ઇનકમિંગ કૉલ"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"ઇનકમિંગ કાર્ય કૉલ"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"ઇનકમિંગ Wi-Fi કૉલ"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"ઇનકમિંગ Wi-Fi કાર્ય કૉલ"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"ઇનકમિંગ વિડિઓ કૉલ"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"ઇનકમિંગ વિડિઓ વિનંતી"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"નવો વૉઇસમેઇલ"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"નવો વૉઇસમેઇલ (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> ડાયલ કરો"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"વૉઇસમેઇલ નંબર અજાણ"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"કોઈ સેવા નથી"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"પસંદ કરેલ નેટવર્ક (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) અનુપલબ્ધ"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"જવાબ"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"સમાપ્ત કરો"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"વિડિઓ"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"વૉઇસ"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"સ્વીકારો"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"છોડી દો"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"કૉલ બૅક કરો"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"સંદેશ"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"કૉલ કરવા માટે, પહેલા એરપ્લેન મોડને બંધ કરો."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"નેટવર્ક પર નોંધણી કરાયેલ નથી."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"સેલ્યુલર નેટવર્ક ઉપલબ્ધ નથી."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"કૉલ કરવા માટે, માન્ય નંબર દાખલ કરો."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"કૉલ કરી શકાતો નથી."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI અનુક્રમ પ્રારંભ કરી રહ્યાં છે…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"સેવા સમર્થિત નથી."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"કૉલ્સ સ્વિચ કરી શકાતાં નથી."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"અલગ કૉલ કરી શકાતો નથી."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"ટ્રાંસ્ફર કરી શકાતો નથી."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"કોન્ફરન્સ કરી શકાતી નથી."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"કૉલ નકારી શકાતો નથી."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"કૉલ(કૉલ્સ) રિલીઝ કરી શકતાં નથી."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP કૉલ"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"કટોકટીનો કૉલ"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"રેડિઓ ચાલુ કરી રહ્યાં છે…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"કોઈ સેવા નથી. ફરી પ્રયાસ કરી રહ્યાં છે…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"કૉલ કરી શકાતો નથી. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> એ કટોકટીનો નંબર નથી."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"કૉલ કરી શકાતો નથી. કટોકટીનો નંબર ડાયલ કરો."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ડાયલ કરવા માટે કીબોર્ડનો ઉપયોગ કરો"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"કૉલ હોલ્ડ કરો"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"કૉલ ફરી શરૂ કરો"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"કૉલ સમાપ્ત કરો"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"ડાયલપેડ"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"મ્યૂટ કરો"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"કૉલ ઉમેરો"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"કૉલ્સ મર્જ કરો"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"સ્વેપ કરો"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"કૉલ્સ સંચાલિત કરો"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"કોન્ફરન્સ કૉલ સંચાલિત કરો"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"ઑડિઓ"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"વિડિઓ કૉલ"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"વૉઇસ કૉલ પર બદલો"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"કૅમેરા પર સ્વિચ કરો"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"વિડિઓ થોભાવો"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"વધુ વિકલ્પો"</string>
+    <string name="player_started" msgid="3478865572468310331">"પ્લેયર પ્રારંભ કર્યું"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"પ્લેયર બંધ કર્યું"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"કૅમેરો તૈયાર નથી"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"કૅમેરો તૈયાર"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"અજાણી કૉલ સત્ર ઇવેન્ટ"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"સેવા"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"સેટઅપ"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;સેટ કરેલ નથી&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"અન્ય કૉલ સેટિંગ્સ"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> મારફતે કૉલ કરે છે"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> મારફતે ઇનકમિંગ"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"સંપર્ક ફોટો"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"ખાનગી થાઓ"</string>
+    <string name="selectContact" msgid="92191462970821951">"સંપર્ક પસંદ કરો"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"તમારો પોતાનો લખો…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"રદ કરો"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"મોકલો"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"જવાબ"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS મોકલો"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"નકારો"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"વિડિઓ કૉલ તરીકે જવાબ આપો"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"ઑડિઓ કૉલ તરીકે જવાબ આપો"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"વિડિઓ વિનંતી સ્વીકારો"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"વિડિઓ વિનંતી નકારો"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"વિડિઓ ટ્રાંસ્મિટ વિનંતી સ્વીકારો"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"વિડિઓ ટ્રાંસ્મિટ વિનંતી નકારો"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"વિડિઓ પ્રાપ્તિ વિનંતી સ્વીકારો"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"વિડિઓ પ્રાપ્તિ વિનંતી નકારો"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> માટે ઉપર સ્લાઇડ કરો."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> માટે ડાબે સ્લાઇડ કરો."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> માટે જમણે સ્લાઇડ કરો."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> માટે નીચે સ્લાઇડ કરો."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"વાઇબ્રેટ"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"વાઇબ્રેટ"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"ધ્વનિ"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"ડિફોલ્ટ ધ્વનિ (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"ફોન રિંગટોન"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"જ્યારે રિંગ કરે ત્યારે વાઇબ્રેટ કરો"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"રિંગટોન અને વાઇબ્રેટ"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"કોન્ફરન્સ કૉલ સંચાલિત કરો"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"કટોકટીનો નંબર"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> સેકંડ</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> સેકંડ</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> મિનિટ</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> મિનિટ</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> કલાક</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> કલાક</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"પ્રોફાઇલ ફોટો"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"કૅમેરો બંધ"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> મારફતે"</string>
+    <string name="note_sent" msgid="7623014827902758398">"નોંધ મોકલી"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"તાજેતરનાં સંદેશા"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"વ્યવસાયની માહિતી"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> માઇલ દૂર"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> કિમી દૂર"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"આવતીકાલે <xliff:g id="OPEN_TIME">%s</xliff:g> વાગ્યે ખુલશે"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"આજે <xliff:g id="OPEN_TIME">%s</xliff:g> વાગ્યે ખુલશે"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g> વાગ્યે બંધ થશે"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"આજે <xliff:g id="CLOSE_TIME">%s</xliff:g> વાગ્યે બંધ થયેલું"</string>
+    <string name="open_now" msgid="4615706338669555999">"હમણાં ખુલ્લું"</string>
+    <string name="closed_now" msgid="2635314668145282080">"હમણાં બંધ છે"</string>
+</resources>
diff --git a/InCallUI/res/values-h600dp/dimens.xml b/InCallUI/res/values-h600dp/dimens.xml
new file mode 100644
index 0000000..12f48d9
--- /dev/null
+++ b/InCallUI/res/values-h600dp/dimens.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<resources>
+    <dimen name="call_banner_height">90dp</dimen>
+
+    <dimen name="end_call_button_margin_bottom">15dp</dimen>
+
+    <dimen name="floating_action_button_vertical_offset">-24dp</dimen>
+</resources>
diff --git a/InCallUI/res/values-hi/strings.xml b/InCallUI/res/values-hi/strings.xml
new file mode 100644
index 0000000..415fb21
--- /dev/null
+++ b/InCallUI/res/values-hi/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"फ़ोन"</string>
+    <string name="onHold" msgid="527593602772521700">"होल्ड पर"</string>
+    <string name="unknown" msgid="3646075119047488748">"अज्ञात"</string>
+    <string name="private_num" msgid="6081418498487514686">"निजी नंबर"</string>
+    <string name="payphone" msgid="5743050584468748607">"पे-फ़ोन"</string>
+    <string name="confCall" msgid="3181961445236675173">"कॉन्फ़्रेंस कॉल"</string>
+    <string name="call_lost" msgid="8208184291640961172">"कॉल कट गया"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"स्पीकर"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"हैंडसेट इयरपीस"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"वायर वाला हैडसेट"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"ब्लूटूथ"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"निम्न टोन भेजें?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"भेजने वाली टोन\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"भेजें"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"हां"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"नहीं"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"वाइल्ड वर्ण को इससे बदलें:"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"कॉन्फ़्रेंस कॉल <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"वॉइसमेल नबंर"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"डायल किया जा रहा है"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"पुन: डायल हो रहा है"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"कॉन्फ़्रेंस कॉल"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"इनकमिंग कॉल"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"कार्यस्थल का इनकमिंग कॉल"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"कॉल समाप्त"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"होल्ड पर"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"कॉल समाप्त हो रहा है"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"कॉल में"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"मेरा नंबर <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g> है"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"वीडियो कनेक्ट हो रहा है"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"वीडियो कॉल"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"वीडियो का अनुरोध किया जा रहा है"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"वीडियो कॉल कनेक्ट नहीं किया जा सकता"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"वीडियो अनुरोध अस्वीकार किया गया"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"आपका कॉलबैक नंबर\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"आपका आपातकालीन कॉलबैक नंबर\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"डायल किया जा रहा है"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"छूटा कॉल"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"छूटे कॉल"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> छूटे कॉल"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> के छूटे कॉल"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"चल रहा कॉल"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"कार्यस्थल का जारी कॉल"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"चल रहा वाई-फ़ाई कॉल"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"कार्यस्थल का जारी वाई-फ़ाई कॉल"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"होल्ड पर"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"इनकमिंग कॉल"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"कार्यस्थल का इनकमिंग कॉल"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"इनकमिंग वाई-फ़ाई कॉल"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"कार्यस्थल का वाई-फ़ाई इनकमिंग कॉल"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"इनकमिंग वीडियो कॉल"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"इनकमिंग वीडियो अनुरोध"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"नया वॉइसमेल"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"नया वॉइसमेल (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> डायल करें"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"वॉइसमेल नंबर अज्ञात"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"कोई सेवा नहीं"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"चयनित नेटवर्क (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) अनुपलब्ध"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"उत्तर दें"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"समाप्त करें"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"वीडियो"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"ध्वनि"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"स्वीकार करें"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"ख़ारिज करें"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"कॉल बैक करें"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"संदेश"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"कॉल करने के लिए, पहले हवाई जहाज़ मोड बंद करें."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"नेटवर्क पर पंजीकृत नहीं."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"सेल्युलर नेटवर्क उपलब्ध नहीं."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"कॉल करने के लिए, मान्य नंबर डालें."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"कॉल नहीं किया जा सकता."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI अनुक्रम प्रारंभ हो रहा है…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"सेवा समर्थित नहीं है."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"कॉल स्विच नहीं किए जा सकते."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"कॉल अलग नहीं किया जा सकता."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"स्थानान्तरित नहीं किया जा सकता."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"कॉन्फ़्रेंस नहीं की जा सकती."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"कॉल अस्वीकार नहीं किया जा सकता."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"कॉल रिलीज़ नहीं किया जा सकता (किए जा सकते)."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP कॉल"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"आपातकालीन कॉल"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"रेडियो चालू कर रहा है..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"कोई सेवा नहीं. पुन: प्रयास किया जा रहा है…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"कॉल नहीं किया जा सकता. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> एक आपातकालीन नंबर नहीं है."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"कॉल नहीं किया जा सकता. आपातकालीन नबर डायल करें."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"डायल करने के लिए कीबोर्ड का उपयोग करें"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"कॉल होल्ड करें"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"कॉल फिर से शुरू करें"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"कॉल समाप्त करें"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"डायलपैड"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"म्यूट करें"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"कॉल जोड़ें"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"कॉल मर्ज करें"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"स्वैप करें"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"कॉल प्रबंधित करें"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"कॉन्फ़्रेंस कॉल प्रबंधित करें"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"ऑडियो"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"वीडियो कॉल"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"वॉइस कॉल में बदलें"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"कैमरा स्विच करें"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"वीडियो रोकें"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"अधिक विकल्प"</string>
+    <string name="player_started" msgid="3478865572468310331">"प्लेयर प्रारंभ हो गया"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"प्लेयर रुक गया"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"कैमरा तैयार नहीं है"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"कैमरा तैयार है"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"अज्ञात कॉल सत्र ईवेंट"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"सेवा"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"सेटअप"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;सेट नहीं है&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"अन्य कॉल सेटिंग"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> के माध्यम से कॉल किया जा रहा है"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> की ओर से इनकमिंग"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"संपर्क का फ़ोटो"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"निजी हो जाएं"</string>
+    <string name="selectContact" msgid="92191462970821951">"संपर्क को चुनें"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"अपना स्वयं का लिखें..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"अभी नहीं"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"भेजें"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"उत्तर दें"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS भेजें"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"अस्वीकार करें"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"वीडियो कॉल के रूप में उत्तर दें"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"ऑडियो कॉल के रूप में उत्तर दें"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"वीडियो अनुरोध स्वीकार करें"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"वीडियो अनुरोध अस्वीकार करें"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"वीडियो प्रसारण अनुरोध स्वीकार करें"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"वीडियो प्रसारण अनुरोध अस्वीकार करें"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"वीडियो प्राप्ति अनुरोध स्वीकार करें"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"वीडियो प्राप्ति अनुरोध अस्वीकार करें"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> करने के लिए ऊपर स्लाइड करें."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> करने के लिए बाएं स्लाइड करें."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> करने के लिए दाएं स्लाइड करें."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> करने के लिए नीचे स्लाइड करें."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"कंपन"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"कंपन"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"ध्वनि"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"डिफ़ॉल्ट ध्वनि (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"फ़ोन रिंगटोन"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"रिंग आने पर कंपन करें"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"रिंगटोन और कंपन"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"कॉन्फ़्रेंस कॉल प्रबंधित करें"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"आपातकालीन नंबर"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> सेकंड</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> सेकंड</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> मिनट</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> मिनट</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> घंटे</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> घंटे</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"प्रोफ़ाइल फ़ोटो"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"कैमरा बंद है"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> के द्वारा"</string>
+    <string name="note_sent" msgid="7623014827902758398">"नोट भेज दिया गया है"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"हाल ही के संदेश"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"व्यवसाय जानकारी"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> मील दूर"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> किमी दूर"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"कल <xliff:g id="OPEN_TIME">%s</xliff:g> बजे खुलेगा"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"आज <xliff:g id="OPEN_TIME">%s</xliff:g> बजे खुलता है"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g> बजे बंद होता है"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"आज <xliff:g id="CLOSE_TIME">%s</xliff:g> बजे बंद हो गया"</string>
+    <string name="open_now" msgid="4615706338669555999">"अभी खुला है"</string>
+    <string name="closed_now" msgid="2635314668145282080">"अभी बंद है"</string>
+</resources>
diff --git a/InCallUI/res/values-hr/strings.xml b/InCallUI/res/values-hr/strings.xml
new file mode 100644
index 0000000..08e30ae
--- /dev/null
+++ b/InCallUI/res/values-hr/strings.xml
@@ -0,0 +1,195 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Na čekanju"</string>
+    <string name="unknown" msgid="3646075119047488748">"Nepoznato"</string>
+    <string name="private_num" msgid="6081418498487514686">"Privatni broj"</string>
+    <string name="payphone" msgid="5743050584468748607">"Javna telefonska govornica"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferencijski poziv"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Poziv je prekinut"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Zvučnik"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Slušalice"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Žičane slušalice"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Poslati sljedeće tonove?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Slanje tonova\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Pošalji"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Da"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Ne"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Zamijeni zamjenski znak znakom"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferencijski poziv <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Broj govorne pošte"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Biranje broja"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Ponovno biranje"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferencijski poziv"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Dolazni poziv"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Dolazni poslovni poziv"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Poziv je završio"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Na čekanju"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Prekidanje veze"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Poziv u tijeku"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Moj je broj <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Povezivanje videopoziva"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videopoziv"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Zahtijevanje videopoziva"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Videopoziv nije uspostavljen"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Zahtjev za videopoziv odbijen"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Vaš broj za povratni poziv\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Vaš broj za povratni poziv za hitne službe\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Biranje broja"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Propušteni poziv"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Propušteni pozivi"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"Propušteni pozivi (<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>)"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Propušten poziv kontakta <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Poziv u tijeku"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Poslovni poziv u tijeku"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Wi-Fi poziv u tijeku"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Poslovni Wi-Fi poziv u tijeku"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Na čekanju"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Dolazni poziv"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Dolazni poslovni poziv"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Dolazni Wi-Fi poziv"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Dolazni poslovni Wi-Fi poziv"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Dolazni videopoziv"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Dolazni zahtjev za videopoziv"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nova govorna pošta"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nova govorna pošta (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Biraj <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Nepoznat broj govorne pošte"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Nema usluge"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Odabrana mreža (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) nije dostupna"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Odgovori"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Prekini vezu"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Videopoziv"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Glasovni poziv"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Prihvati"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Odbaci"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Uzvrati"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Poruka"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Da biste uspostavili poziv, isključite način rada u zrakoplovu."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Nije registrirano na mreži."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobilna mreža nije dostupna."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Unesite važeći broj da biste uspostavili poziv."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Pozivanje nije moguće."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Pokretanje MMI sekvence…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Usluga nije podržana."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Prebacivanje poziva nije moguće."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Odvajanje poziva nije moguće."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Prijenos nije moguć."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Konferencijski poziv nije moguć."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Odbijanje poziva nije moguće."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Prekidanje poziva nije moguće."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP poziv"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Hitni poziv"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Uključivanje radija…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Nema usluge. Pokušavamo ponovo…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Pozivanje nije moguće. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> nije broj hitne službe."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Pozivanje nije moguće. Nazovite broj hitne službe."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Upotrijebite tipkovnicu"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Stavi poziv na čekanje"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Nastavi poziv"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Završi poziv"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Površina za biranje brojeva"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Zanemari"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Dodaj poziv"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Spoji pozive"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Zamijeni"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Upravljaj pozivima"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Upravljaj konf. pozivom"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videopoziv"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Prijeđi na glasovni poziv"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Promijeni kameru"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pauziraj videopoziv"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Više opcija"</string>
+    <string name="player_started" msgid="3478865572468310331">"Player je pokrenut"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Player je prekinut"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Fotoaparat nije spreman"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Fotoaparat je spreman"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Nepoznati događaj sesije poziva"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Usluga"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Postavljanje"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Nije postavljeno&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Ostale postavke poziva"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Pozivanje putem operatera <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Dolazni pozivi putem usluge <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"fotografija kontakta"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"uputi na privatno"</string>
+    <string name="selectContact" msgid="92191462970821951">"odabir kontakta"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Napišite odgovor..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Odustani"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Pošalji"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Odgovori"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Pošalji SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Odbij"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Prihvati kao videopoziv"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Prihvati kao audiopoziv"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Prihvati zahtjev za videopoziv"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Odbij zahtjev za videopoziv"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Prihvati zahtjev za slanje videopoziva"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Odbij zahtjev za slanje videopoziva"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Prihvati zahtjev za primanje videopoziva"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Odbij zahtjev za primanje videopoziva"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Kliznite prema gore za <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Kliznite lijevo za <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Kliznite desno za <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Kliznite prema dolje za <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibriranje"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibriranje"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Zvuk"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Zadani zvuk (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Melodija zvona telefona"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibracija tijekom zvonjenja"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Melodija zvona i vibracija"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Upravljaj konferencijskim pozivom"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Broj hitne službe"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> sekunda</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> sekunde</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekundi</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> minuta</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> minute</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minuta</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> sat</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> sata</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sati</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Fotografija profila"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Fotoaparat je isključen"</string>
+    <string name="child_number" msgid="4469090994612105532">"putem broja <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Bilješka je poslana"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Nedavne poruke"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informacije o tvrtki"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mi udaljenosti"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km udaljenosti"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Otvara se sutra u <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Otvara se danas u <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Zatvara se u <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Zatvoreno danas u <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Trenutačno otvoreno"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Trenutačno zatvoreno"</string>
+</resources>
diff --git a/InCallUI/res/values-hu/strings.xml b/InCallUI/res/values-hu/strings.xml
new file mode 100644
index 0000000..9a4afe5
--- /dev/null
+++ b/InCallUI/res/values-hu/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Tartásban"</string>
+    <string name="unknown" msgid="3646075119047488748">"Ismeretlen"</string>
+    <string name="private_num" msgid="6081418498487514686">"Magántelefonszám"</string>
+    <string name="payphone" msgid="5743050584468748607">"Nyilvános telefon"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferenciahívás"</string>
+    <string name="call_lost" msgid="8208184291640961172">"A hívás megszakadt"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Hangszóró"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Kézibeszélő fülhallgatója"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Vezetékes fülhallgató"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Elküldi a következő hangjelzéseket?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Hangjelzések küldése\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Küldés"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Igen"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Nem"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Helyettesítő karakter lecserélése a következőre:"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferenciahívás – <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Hangposta száma"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Tárcsázás"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Újratárcsázás"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferenciahívás"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Bejövő hívás"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Bejövő munkahelyi hívás"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"A hívás befejeződött"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Tartásban"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Megszakítás"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Hívásban"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"A számom: <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Videókapcsolat létrehozása"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videóhívás"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Videóhívást kér"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"A videóhívás létesítése sikertelen"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Videókérelem elutasítva"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Visszahívható telefonszáma:\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Vészhelyzet esetén visszahívható telefonszáma:\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Tárcsázás"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Nem fogadott hívás"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Nem fogadott hívások"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> nem fogadott hívás"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Nem fogadott hívás: <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Hívás folyamatban"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Folyamatban lévő munkahelyi hívás"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Folyamatban lévő Wi-Fi-hívás"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Folyamatban lévő munkahelyi hívás Wi-Fi-hálózaton keresztül"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Tartásban"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Bejövő hívás"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Bejövő munkahelyi hívás"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Bejövő Wi-Fi-hívás"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Bejövő munkahelyi hívás Wi-Fi-hálózaton keresztül"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Bejövő videóhívás"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Bejövő videókérés"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Új hangpostaüzenet"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Új hangpostaüzenet (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> tárcsázása"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"A hangposta száma ismeretlen"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Nincs szolgáltatás"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"A kiválasztott hálózat (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) nem áll rendelkezésre"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Fogadás"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Hívás bontása"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Videó"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Hang"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Elfogadás"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Elvetés"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Visszahívás"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Üzenet"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Hívásindításhoz kapcsolja ki a Repülős üzemmódot."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Nincs regisztrálva a hálózaton."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"A mobilhálózat nem áll rendelkezésre."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Hívásindításhoz adjon meg egy érvényes számot."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"A hívás sikertelen."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI-sorozat indítása…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"A szolgáltatás nem támogatott."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"A hívások közötti váltás sikertelen."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"A híváselkülönítés sikertelen."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Az átirányítás sikertelen."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"A konferenciahívás sikertelen."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"A híváselutasítás sikertelen."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"A tartásban lévő hívás(ok) folytatása sikertelen."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP-hívás"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Segélyhívás"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Rádió bekapcsolása…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Nincs szolgáltatás. Újrapróbálkozás folyamatban…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"A hívás sikertelen. A(z) <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> szám nem segélyhívószám."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"A hívás sikertelen. Tárcsázzon segélyhívószámot."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"A tárcsázáshoz használja a billentyűzetet"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Hívás tartása"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Hívás folytatása"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Hívás befejezése"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Tárcsázó"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Némítás"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Hívás hozzáadása"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Hívások egyesítése"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Csere"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Hívások kezelése"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Konferenciahívás kezelése"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Hang"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videóhívás"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Váltás hanghívásra"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Váltás a kamerák között"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Videó szüneteltetése"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"További lehetőségek"</string>
+    <string name="player_started" msgid="3478865572468310331">"A lejátszó elindult"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"A lejátszó leállt"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"A kamera nem áll készen"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"A kamera készen áll"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Ismeretlen hívási esemény"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Szolgáltatás"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Beállítás"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Nincs megadva&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Egyéb hívásbeállítások"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Hívás a(z) <xliff:g id="PROVIDER_NAME">%s</xliff:g> szolgáltatón keresztül"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Bejövő hívás a következőn keresztül: <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"fotó a névjegyhez"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"magánbeszélgetés"</string>
+    <string name="selectContact" msgid="92191462970821951">"névjegy kiválasztása"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Saját válasz írása…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Mégse"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Küldés"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Fogadás"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS küldése"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Elutasítás"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Fogadás videóhívásként"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Fogadás hanghívásként"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Videó kérésének elfogadása"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Videó kérésének elutasítása"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Videóküldési kérés elfogadása"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Videóküldési kérés elutasítása"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Videófogadási kérés elfogadása"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Videófogadási kérés elutasítása"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"A(z) <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> művelethez csúsztassa felfelé."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"A(z) <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> művelethez csúsztassa balra."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"A(z) <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> művelethez csúsztassa jobbra."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"A(z) <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> művelethez csúsztassa lefelé."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Rezgés"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Rezgés"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Hang"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Alapértelmezett hang (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Telefon csengőhangja"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Csörgéskor rezegjen"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Csengőhang és rezgés"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Konferenciahívás kezelése"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Segélyhívó szám"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> másodperc</item>
+      <item quantity="one">1 másodperc</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> perc</item>
+      <item quantity="one">1 perc</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> óra</item>
+      <item quantity="one">1 óra</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profilfotó"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera ki"</string>
+    <string name="child_number" msgid="4469090994612105532">"a következő számon keresztül: <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Üzenet elküldve"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Legutóbbi üzenetek"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Cég adatai"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mérföldre"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> kilométerre"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="LOCALITY">%2$s</xliff:g>, <xliff:g id="STREET_ADDRESS">%1$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Holnap ekkor nyit: <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Ma ekkor nyit: <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Ekkor zár: <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Ma ekkor zárt: <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Jelenleg nyitva van"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Jelenleg zárva van"</string>
+</resources>
diff --git a/InCallUI/res/values-hy-rAM/strings.xml b/InCallUI/res/values-hy-rAM/strings.xml
new file mode 100644
index 0000000..cfa3986
--- /dev/null
+++ b/InCallUI/res/values-hy-rAM/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Հեռախոս"</string>
+    <string name="onHold" msgid="527593602772521700">"Սպասում"</string>
+    <string name="unknown" msgid="3646075119047488748">"Անհայտ"</string>
+    <string name="private_num" msgid="6081418498487514686">"Գաղտնի համար"</string>
+    <string name="payphone" msgid="5743050584468748607">"Հանրային հեռախոս"</string>
+    <string name="confCall" msgid="3181961445236675173">"Կոնֆերանս զանգ"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Զանգն ընդհատվեց"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Բարձրախոս"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Հեռախոսի ականջակալ"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Լարային ականջակալ"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Ուղարկե՞լ հետևյալ ձայներանգները:\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Ձայներանգների ուղարկում\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Ուղարկել"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Այո"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Ոչ"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Փոխարինել կոպիտ գրանշանը"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Կոնֆերանս զանգ <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Ձայնային փոստի համարը"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Համարարկում"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Վերահամարարկում"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Կոնֆերանս զանգ"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Մուտքային զանգ"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Մուտքային աշխատանքային զանգ"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Զանգն ավարտվեց"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Սպասում"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Անջատում"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Զանգը միացված է"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Իմ համարը՝ <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Տեսակապը միանում է"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Տեսազանգ"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Տեսակապի հայցում"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Հնարավոր չէ միացնել տեսազանգը"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Տեսազանգի հարցումը մերժվել է"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Հետադարձ զանգի համարը՝\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Արտակարգ իրավիճակների հետադարձ զանգի համարը՝\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Համարարկում է"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Բաց թողնված զանգ"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Բաց թողնված զանգեր"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> բաց թողնված զանգ"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Բաց թողնված զանգ <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>-ից"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Ընթացիկ զանգ"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Ընթացիկ աշխատանքային զանգ"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Ընթացիկ Wi-Fi զանգ"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Ընթացիկ աշխատանքային Wi-Fi զանգ"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Սպասում"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Մուտքային զանգ"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Մուտքային աշխատանքային զանգ"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Մուտքային Wi-Fi զանգ"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Մուտքային աշխատանքային Wi-Fi զանգ"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Մուտքային տեսազանգ"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Մուտքային տեսազանգի հայցում"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Նոր ձայնային հաղորդագրություն"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Նոր ձայնային հաղորդագրություն (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Զանգել <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> համարին"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Ձայնային փոստի համարն անհայտ է"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Ծառայություն չկա"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Ընտրված ցանցը (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) անհասանելի է"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Պատասխանել"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Անջատել"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Տեսազանգ"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Ձայնային"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Ընդունել"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Փակել"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Հետ զանգել"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Հաղորդագրություն"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Զանգ կատարելու համար նախ անջատեք թռիչքային ռեժիմը:"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Ցանցում գրանցված չէ:"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Բջջային ցանցն անհասանելի է:"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Զանգ կատարելու համար մուտքագրեք ճիշտ համար:"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Հնարավոր չէ զանգել:"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Մեկնարկում է MMI հաջորդականությունը…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Ծառայությունը չի աջակցվում:"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Հնարավոր չէ փոխարկել զանգերը:"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Հնարավոր չէ առանձնացնել զանգը:"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Հնարավոր չէ փոխանցել:"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Հնարավոր չէ կոնֆերանս զանգ կատարել:"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Հնարավոր չէ մերժել զանգը:"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Հնարավոր չէ անջատել զանգ(եր)ը:"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP զանգ"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Արտակարգ իրավիճակի զանգ"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Ռադիոն միացվում է…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Ծառայությունը մատչելի չէ: Փորձը կրկնվում է…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Հնարավոր չէ զանգել: <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> համարը արտակարգ իրավիճակի համար չէ:"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Հնարավոր չէ զանգել: Հավաքեք արտակարգ իրավիճակի որևէ համար:"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Օգտագործել ստեղնաշարը համար հավաքելու համար"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Հետաձգել զանգը"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Վերսկսել զանգը"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Ավարտել զանգը"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Թվաշար"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Անջատել ձայնը"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Ավելացնել զանգ"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Միացնել զանգերը"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Փոխանակել"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Կառավարել զանգերը"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Կառավարել կոնֆերանս զանգը"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Ձայնային"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Տեսազանգ"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Փոխարկել ձայնային կանչի"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Փոխել տեսախցիկը"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Դադարեցնել տեսազանգը"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Այլ ընտրանքներ"</string>
+    <string name="player_started" msgid="3478865572468310331">"Նվագարկիչը մեկնարկել է"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Նվագարկիչը դադարեցվել է"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Տեսախցիկը պատրաստ չէ"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Տեսախցիկը պատրաստ է"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Զանգի աշխատաշրջանի անհայտ իրադարձություն"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Ծառայություն"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Կարգավորում"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Կարգավորված չէ&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Զանգերի այլ կարգավորումներ"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Զանգում է <xliff:g id="PROVIDER_NAME">%s</xliff:g>-ի միջոցով"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Մուտքային զանգ <xliff:g id="PROVIDER_NAME">%s</xliff:g>-ի միջոցով"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"կոնտակտի լուսանկարը"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"անցնել անձնականի"</string>
+    <string name="selectContact" msgid="92191462970821951">"ընտրել կոնտակտ"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Գրեք ձեր սեփականը…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Չեղարկել"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Ուղարկել"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Պատասխանել"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Ուղարկել SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Մերժել"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Պատասխանել տեսազանգով"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Պատասխանել ձայնային զանգով"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Ընդունել տեսազանգի հարցումը"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Մերժել տեսազանգի հարցումը"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Ընդունել տեսափոխանցման հարցումը"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Մերժել տեսափոխանցման հարցումը"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Ընդունել տեսազանգ ստանալու հարցումը"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Մերժել տեսազանգ ստանալու հարցումը"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Սահեցրեք վերև` <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>-ի համար:"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Սահեցրեք ձախ` <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>-ի համար:"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Սահեցրեք աջ` <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>-ի համար:"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Սահեցրեք ցած՝ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>-ի համար:"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Թրթռոց"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Թրթռոց"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Ձայն"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Կանխադրված ձայնը (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Հեռախոսի զանգերանգ"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Թրթռալ զանգի ժամանակ"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Ձայներանգ և թրթռոց"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Կառավարել կոնֆերանս զանգը"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Արտակարգ իրավիճակի համար"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> վայրկյան</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> վայրկյան</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> րոպե</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> րոպե</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ժամ</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ժամ</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Պրոֆիլի լուսանկար"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Տեսախցիկն անջատված"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g>-ի միջոցով"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Գրառումն ուղարկվեց"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Վերջին հաղորդագրությունները"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Բիզնես տեղեկատվություն"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> մղոն հեռու"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> կմ հեռու"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Բացվում է վաղը ժամը <xliff:g id="OPEN_TIME">%s</xliff:g>-ին"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Բացվում է այսօր ժամը <xliff:g id="OPEN_TIME">%s</xliff:g>-ին"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Փակվում է ժամը <xliff:g id="CLOSE_TIME">%s</xliff:g>-ին"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Փակվել է այսօր ժամը <xliff:g id="CLOSE_TIME">%s</xliff:g>-ին"</string>
+    <string name="open_now" msgid="4615706338669555999">"Հիմա բաց է"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Հիմա փակ է"</string>
+</resources>
diff --git a/InCallUI/res/values-in/strings.xml b/InCallUI/res/values-in/strings.xml
new file mode 100644
index 0000000..3cb6196
--- /dev/null
+++ b/InCallUI/res/values-in/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telepon"</string>
+    <string name="onHold" msgid="527593602772521700">"Ditahan"</string>
+    <string name="unknown" msgid="3646075119047488748">"Tidak dikenal"</string>
+    <string name="private_num" msgid="6081418498487514686">"Nomor pribadi"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telepon Umum"</string>
+    <string name="confCall" msgid="3181961445236675173">"Telewicara"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Panggilan terputus"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Pengeras suara"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Earpiece handset"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Headset berkabel"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Kirim nada berikut?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Mengirim nada\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Kirim"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ya"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Tidak"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Ganti karakter acak dengan"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Telewicara <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Nomor pesan suara"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Memanggil"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Memanggil ulang"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Telewicara"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Panggilan masuk"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Panggilan masuk di telepon kerja"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Panggilan diakhiri"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Ditahan"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Menutup panggilan"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Sedang dalam panggilan"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Nomor saya <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Menyambungkan video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Video call"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Meminta video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Tidak dapat menyambungkan video call"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Permintaan video ditolak"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Nomor panggilan balik Anda\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Nomor panggilan balik darurat Anda\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Memanggil"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Panggilan tak terjawab"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Panggilan tak terjawab"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> panggilan tak terjawab"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Panggilan tak terjawab dari <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Panggilan yang berlangsung"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Panggilan telepon kerja yang sedang berlangsung"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Panggilan Wi-Fi keluar"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Panggilan Wi-Fi kerja yang sedang berlangsung"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Ditahan"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Panggilan masuk"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Panggilan masuk di telepon kerja"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Panggilan Wi-Fi masuk"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Panggilan Wi-Fi masuk di telepon kerja"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Video call masuk"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Permintaan video masuk"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Pesan suara baru"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Pesan suara baru (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Telepon <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Nomor pesan suara tidak dikenal"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Tidak ada layanan"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Jaringan yang dipilih (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) tidak tersedia"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Jawab"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Akhiri"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Suara"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Terima"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Tutup"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Telepon balik"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Pesan"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Untuk melakukan panggilan, terlebih dahulu nonaktifkan mode Pesawat."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Tidak terdaftar pada jaringan."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Jaringan seluler tidak tersedia."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Untuk melakukan panggilan telepon, masukkan nomor yang valid."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Tidak dapat menelepon."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Memulai urutan MMI..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Layanan tidak didukung."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Tidak dapat beralih panggilan."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Tidak dapat memisahkan panggilan."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Tidak dapat mentransfer."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Tidak dapat melakukan telewicara."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Tidak dapat menolak panggilan."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Tidak dapat melepas panggilan."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Panggilan SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Panggilan darurat"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Menghidupkan radio..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Tidak ada layanan. Mencoba lagi…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Tidak dapat menelepon. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> bukan nomor darurat."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Tidak dapat menelepon. Panggil nomor darurat."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Gunakan keyboard untuk memanggil"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Tahan Panggilan"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Mulai Kembali Panggilan"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Akhiri Panggilan"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Papan tombol"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Bisukan"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Tambahkan panggilan"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Gabungkan panggilan"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Tukar"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Kelola panggilan"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Kelola telewicara"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Video call"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Ubah ke panggilan suara"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Beralih kamera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Jeda video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Opsi lainnya"</string>
+    <string name="player_started" msgid="3478865572468310331">"Pemutar Dimulai"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Pemutar Dihentikan"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera tidak siap"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera siap"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Sesi panggilan tidak dikenal"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Layanan"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Siapkan"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Tidak disetel&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Setelan panggilan lainnya"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Memanggil via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Masuk melalui <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"foto kontak"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"aktifkan pribadi"</string>
+    <string name="selectContact" msgid="92191462970821951">"pilih kontak"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Tulis respons Anda sendiri…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Batal"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Kirim"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Jawab"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Kirim SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Tolak"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Jawab sebagai video call"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Jawab sebagai panggilan audio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Terima permintaan video"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Tolak permintaan video"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Terima permintaan transmisi video"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Tolak permintaan transmisi video"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Terima permintaan menerima video"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Tolak permintaan menerima video"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Geser ke atas untuk <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Geser ke kiri untuk <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Geser ke kanan untuk <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Geser ke bawah untuk <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Getar"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Getar"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Suara"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Suara default (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Nada dering ponsel"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Bergetar saat berdering"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Nada dering &amp; Getar"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Kelola telewicara"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Nomor darurat"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> detik</item>
+      <item quantity="one">1 detik</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> menit</item>
+      <item quantity="one">1 menit</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> jam</item>
+      <item quantity="one">1 jam</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Foto profil"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera tidak aktif"</string>
+    <string name="child_number" msgid="4469090994612105532">"melalui <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Catatan telah dikirim"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Pesan terbaru"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Info bisnis"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mil"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Buka pukul <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Hari ini buka pukul <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Tutup pukul <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Hari ini tutup pukul <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Buka sekarang"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Sekarang tutup"</string>
+</resources>
diff --git a/InCallUI/res/values-is-rIS/strings.xml b/InCallUI/res/values-is-rIS/strings.xml
new file mode 100644
index 0000000..4f63b8b
--- /dev/null
+++ b/InCallUI/res/values-is-rIS/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Sími"</string>
+    <string name="onHold" msgid="527593602772521700">"Í bið"</string>
+    <string name="unknown" msgid="3646075119047488748">"Óþekkt"</string>
+    <string name="private_num" msgid="6081418498487514686">"Óþekkt númer"</string>
+    <string name="payphone" msgid="5743050584468748607">"Símasjálfsali"</string>
+    <string name="confCall" msgid="3181961445236675173">"Símafundur"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Símtali slitið"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Hátalari"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Símahátalari"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Höfuðtól með snúru"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Senda eftirfarandi tóna?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Sendir tóna\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Senda"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Já"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Nei"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Skipta algildisstaf út fyrir"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Símafundur <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Talhólfsnúmer"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Hringir"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Hringir aftur"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Símafundur"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Móttekið símtal"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Vinnusímtal berst"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Lagt á"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Í bið"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Leggur"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Í símtali"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Númerið mitt er <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Tengir myndskeið"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Myndsímtal"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Biður um myndskeið"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Ekki tókst að tengja myndsímtal"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Myndsímtalsbeiðni hafnað"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Svarhringingarnúmer þitt\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Svarhringingarnúmer þitt í neyðartilvikum\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Hringir"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Ósvarað símtal"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Ósvöruð símtöl"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ósvöruð símtöl"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Ósvarað símtal frá <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Samtal í gangi"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Vinnusímtal í gangi"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Wi-Fi símtal stendur yfir"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Vinnusímtal í gangi um Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Í bið"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Móttekið símtal"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Vinnusímtal berst"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Wi-Fi símtal berst"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Vinnusímtal berst um Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Myndsímtal berst"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Myndbeiðni berst"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Ný skilaboð í talhólfinu"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Ný skilaboð í talhólfinu (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Hringja í <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Talhólfsnúmer ekki þekkt"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Ekkert símasamband"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Valið símkerfi (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) er ekki tiltækt"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Svara"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Leggja á"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Myndskeið"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Tal"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Samþykkja"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Hunsa"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Hringja til baka"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Skilaboð"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Til að hringja símtal þarftu fyrst að slökkva á flugstillingu."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Ekki skráð á símkerfi."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Farsímakerfi ekki til staðar."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Sláðu inn gilt númer til að hringja símtal."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Ekki hægt að hringja."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Ræsir MMI-runu…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Þjónustan er ekki studd."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Ekki hægt að skipta milli símtala."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Ekki hægt að aðskilja símtal."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Ekki hægt að flytja."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Ekki hægt að halda símafund."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Ekki hægt að hafna símtali."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Ekki hægt að leggja á."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP-símtal"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Neyðarsímtal"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Kveikir á loftneti…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Ekkert samband. Reynir aftur…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Getur ekki hringt. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> er ekki neyðarsímanúmer."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Ekki hægt að hringja. Hringdu í neyðarnúmer"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Notaðu lyklaborðið til að hringja"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Setja símtal í bið"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Halda símtali áfram"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Leggja á"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Símatakkaborð"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Þagga"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Bæta við símtali"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Sameina símtöl"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Skipta milli"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Stjórna símtölum"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Stjórna símafundi"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Hljóð"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Myndsímtal"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Breyta í símtal"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Skipta um myndavél"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Gera hlé á myndskeiði"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Fleiri valkostir"</string>
+    <string name="player_started" msgid="3478865572468310331">"Spilari ræstur"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Spilari stöðvaður"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Myndavél ekki tilbúin"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Myndavél tilbúin"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Óþekkt atvik símtalslotu"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Þjónusta"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Uppsetning"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Ekki valið&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Aðrar símtalsstillingar"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Hringt í gegnum <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Berst í gegnum <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"mynd tengiliðar"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"tala í einrúmi"</string>
+    <string name="selectContact" msgid="92191462970821951">"velja tengilið"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Skrifaðu eigið svar…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Hætta við"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Senda"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Svara"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Senda SMS-skilaboð"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Hafna"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Svara sem myndsímtali"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Svara sem símtali"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Samþykkja beiðni um myndsímtal"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Hafna beiðni um myndsímtal"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Samþykkja beiðni um sendingu myndsímtals"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Hafna beiðni um sendingu myndsímtals"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Samþykkja beiðni um móttöku myndsímtals"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Hafna beiðni um móttöku myndsímtals"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Strjúktu upp til að <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Strjúktu til vinstri til að <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Strjúktu til hægri til að <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Strjúktu niður til að <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Titra"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Titra"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Hljóð"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Sjálfgefið hljóð (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Hringitónn síma"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Titra við hringingu"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Hringitónn og titringur"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Stjórna símafundi"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Neyðarnúmer"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> sekúnda</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekúndur</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> mínúta</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> mínútur</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> klukkustund</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> klukkustundir</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Prófílmynd"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Slökkt á myndavél"</string>
+    <string name="child_number" msgid="4469090994612105532">"úr <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Glósa send"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Nýleg skilaboð"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Fyrirtækjaupplýsingar"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"í <xliff:g id="DISTANCE">%.1f</xliff:g> míl. fjarlægð"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"í <xliff:g id="DISTANCE">%.1f</xliff:g> km fjarlægð"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>–<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Opið á morgun frá kl. <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Opið í dag frá kl. <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Lokað kl. <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Var lokað í dag kl. <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Opið núna"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Lokað núna"</string>
+</resources>
diff --git a/InCallUI/res/values-it/strings.xml b/InCallUI/res/values-it/strings.xml
new file mode 100644
index 0000000..af47766
--- /dev/null
+++ b/InCallUI/res/values-it/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefono"</string>
+    <string name="onHold" msgid="527593602772521700">"In attesa"</string>
+    <string name="unknown" msgid="3646075119047488748">"Sconosciuto"</string>
+    <string name="private_num" msgid="6081418498487514686">"Numero privato"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefono pubblico"</string>
+    <string name="confCall" msgid="3181961445236675173">"Audioconferenza"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Chiamata persa"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Altoparlante"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Auricolare telefono"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Auricolare con cavo"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Inviare i numeri successivi?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Invio toni\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Invia"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Sì"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"No"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Sostituisci carattere jolly con"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Audioconferenza: <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Numero segreteria"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Chiamata in corso"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Ricomposizione"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Audioconferenza"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Chiamata in arrivo"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Chiamata lavoro in arrivo"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Chiamata terminata"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"In attesa"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"In fase di chiusura"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Chiamata in corso"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Il mio numero è: <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Collegamento video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videochiamata"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Richiesta video in corso"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Impossibile effettuare una videochiamata"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Richiesta video rifiutata"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Numero da richiamare:\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Numero da richiamare in caso di emergenza:\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Composizione in corso"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Chiamata senza risposta"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Chiamate senza risposta"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> chiamate senza risposta"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Chiamata senza risposta da <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Chiamata in corso"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Chiamata di lavoro in corso"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Chiamata Wi-Fi in corso"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Chiamata di lavoro tramite Wi-Fi in corso"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"In attesa"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Chiamata in arrivo"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Chiamata di lavoro in arrivo"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Chiamata Wi-Fi in arrivo"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Chiamata di lavoro in arrivo tramite Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Videochiamata in arrivo"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Richiesta video in arrivo"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nuovo messaggio vocale"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nuovo messaggio vocale (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Componi <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Numero segreteria sconosciuto"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Nessun servizio"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Rete selezionata (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) non disponibile"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Rispondi"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Riaggancia"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Voce"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Accetta"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Ignora"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Richiama"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Messaggio"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Per fare una chiamata, disattiva la modalità aereo."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Non registrato sulla rete."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Rete dati non disponibile."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Per fare una chiamata, inserisci un numero valido."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Impossibile chiamare."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Avvio sequenza MMI..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Servizio non supportato."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Impossibile cambiare chiamata."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Impossibile separare la chiamata."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Impossibile trasferire."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Impossibile fare una chiamata in conferenza."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Impossibile rifiutare la chiamata."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Impossibile riagganciare."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Chiamata SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Chiamata di emergenza"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Attivazione segnale cellulare..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Nessun servizio. Nuovo tentativo…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Impossibile chiamare. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> non è un numero di emergenza."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Impossibile chiamare. Componi un numero di emergenza."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Usa tastiera"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Metti in attesa la chiamata"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Riprendi chiamata"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Termina chiamata"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Tastierino"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Disattiva audio"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Aggiungi chiamata"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Unisci chiamate"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Scambia"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Gestisci chiamate"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Gestisci audioconferenza"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videochiam"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Passa a chiamata vocale"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Cambia fotocamera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Metti in pausa video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Altre opzioni"</string>
+    <string name="player_started" msgid="3478865572468310331">"Player avviato"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Player interrotto"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"La fotocamera non è pronta"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Fotocamera pronta"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Evento sessione chiamata sconosciuto"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Servizio"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Configura"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Non impostato&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Altre impostazioni di chiamata"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Chiamate tramite <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"In arrivo tramite <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"foto contatto"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"Privato"</string>
+    <string name="selectContact" msgid="92191462970821951">"seleziona contatto"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Scrivi risposta personale..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Annulla"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Invia"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Rispondi"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Invia SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Rifiuta"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Rispondi con videochiamata"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Rispondi con chiamata audio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Accetta richiesta video"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Rifiuta richiesta video"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Accetta richiesta di trasmissione video"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Rifiuta richiesta di trasmissione video"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Accetta richiesta di ricevimento video"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Rifiuta richiesta di ricevimento video"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Scorri verso l\'alto per <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Scorri verso sinistra per <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Scorri verso destra per <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Scorri verso il basso per <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrazione"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrazione"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Suono"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Suono predefinito (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Suoneria telefono"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrazione quando squilla"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Suoneria e vibrazione"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Gestisci audioconferenza"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Numero di emergenza"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> secondi</item>
+      <item quantity="one">1 secondo</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minuti</item>
+      <item quantity="one">1 minuto</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ore</item>
+      <item quantity="one">1 ora</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Foto del profilo"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Fotocamera disattivata"</string>
+    <string name="child_number" msgid="4469090994612105532">"tramite <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Nota inviata"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Messaggi recenti"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informazioni sull\'attività"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"Distante <xliff:g id="DISTANCE">%.1f</xliff:g> mi"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"Distante <xliff:g id="DISTANCE">%.1f</xliff:g> km"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Apre domani alle ore <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Apre oggi alle ore <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Chiude alle ore <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Ha chiuso oggi alle ore <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Aperto ora"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Ora chiuso"</string>
+</resources>
diff --git a/InCallUI/res/values-iw/strings.xml b/InCallUI/res/values-iw/strings.xml
new file mode 100644
index 0000000..232be4c
--- /dev/null
+++ b/InCallUI/res/values-iw/strings.xml
@@ -0,0 +1,198 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"טלפון"</string>
+    <string name="onHold" msgid="527593602772521700">"בהמתנה"</string>
+    <string name="unknown" msgid="3646075119047488748">"לא ידוע"</string>
+    <string name="private_num" msgid="6081418498487514686">"מספר פרטי"</string>
+    <string name="payphone" msgid="5743050584468748607">"טלפון ציבורי"</string>
+    <string name="confCall" msgid="3181961445236675173">"שיחת ועידה"</string>
+    <string name="call_lost" msgid="8208184291640961172">"השיחה נותקה"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"רמקול"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"אוזנייה"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"אוזניות עם חיבור חוטי"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"האם לשלוח את הצלילים הבאים?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"שולח צלילים\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"שלח"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"כן"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"לא"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"החלף את התו הכללי ב"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"שיחת ועידה <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"המספר של הדואר הקולי"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"מחייג"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"מחייג שוב"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"שיחת ועידה"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"שיחה נכנסת"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"שיחת עבודה נכנסת"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"השיחה הסתיימה"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"בהמתנה"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"מנתק"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"בשיחה"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"המספר שלי הוא <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"מחבר וידאו"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"שיחת וידאו"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"מבקש וידאו"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"לא ניתן לחבר שיחת וידאו"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"בקשת וידאו נדחתה"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"המספר שלך להתקשרות חזרה\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"המספר שלך להתקשרות חזרה במצב חירום\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"מחייג"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"שיחה שלא נענתה"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"שיחות שלא נענו"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> שיחות שלא נענו"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"שיחה שלא נענתה מאת <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"שיחה פעילה"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"שיחת עבודה פעילה"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"‏שיחת Wi-Fi פעילה"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"‏שיחת עבודה פעילה ברשת WiFi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"בהמתנה"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"שיחה נכנסת"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"שיחת עבודה נכנסת"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"‏שיחת Wi-Fi נכנסת"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"‏שיחת עבודה נכנסת ברשת WiFi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"שיחת וידאו נכנסת"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"בקשת וידאו נכנסת"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"דואר קולי חדש"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"דואר קולי חדש (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"‏חייג ‎<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>‎"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"המספר של הדואר הקולי אינו ידוע"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"אין שירות"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"הרשת שנבחרה (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) לא זמינה"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"ענה"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"נתק"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"וידאו"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"קול"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"אשר"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"בטל"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"התקשר חזרה"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"שלח הודעה"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"כדי להתקשר, כבה תחילה את מצב טיסה."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"לא רשום ברשת."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"רשת סלולרית אינה זמינה."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"כדי להתקשר, הזן מספר טלפון חוקי."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"לא ניתן להתקשר."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"‏מתחיל רצף MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"שירות לא נתמך."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"לא ניתן לעבור בין שיחות."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"לא ניתן להפריד שיחה."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"לא ניתן להעביר."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"לא ניתן לבצע שיחת ועידה."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"לא ניתן לדחות שיחה."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"לא ניתן להתקשר."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"‏שיחת SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"שיחת חירום"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"מפעיל את הרדיו…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"אין שירות. מנסה שוב..."</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"לא ניתן להתקשר. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> אינו מספר חירום."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"לא ניתן להתקשר. חייג למספר חירום."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"השתמש במקלדת כדי לחייג"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"החזק שיחה"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"המשך בשיחה"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"סיים שיחה"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"לוח חיוג"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"השתק"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"הוסף שיחה"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"מזג שיחות"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"החלף"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"נהל שיחות"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"נהל שיחת ועידה"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"אודיו"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"שיחת וידאו"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"שנה לשיחה קולית"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"החלף מצלמה"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"השהה וידאו"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"אפשרויות נוספות"</string>
+    <string name="player_started" msgid="3478865572468310331">"הנגן הופעל"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"הנגן הפסיק"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"המצלמה לא מוכנה"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"המצלמה מוכנה"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"אירוע הפעלת שיחה לא ידוע"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"שירות"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"הגדרות"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;לא הוגדר&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"הגדרות אחרות של שיחה"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"שיחה באמצעות <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"שיחה נכנסת באמצעות <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"תמונה של איש קשר"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"עבור לשיחה פרטית"</string>
+    <string name="selectContact" msgid="92191462970821951">"בחר איש קשר"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"כתוב תגובה משלך..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"בטל"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"שלח"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"ענה"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"‏שלח SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"דחה"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"ענה כשיחת וידאו"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"ענה כשיחת אודיו"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"קבל בקשת וידאו"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"דחה בקשת וידאו"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"אשר את הבקשה לשידור וידאו"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"דחה את הבקשה לשידור וידאו"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"אשר את הבקשה לקבלת וידאו"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"דחה את הבקשה לקבלת וידאו"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"הסט למעלה כדי <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"הסט שמאלה כדי <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"הסט ימינה כדי <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"הסט למטה כדי <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"רטט"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"רטט"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"צליל"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"צליל ברירת מחדל (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"רינגטון של טלפון"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"רטט בעת צלצול"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"רינגטון ורטט"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"נהל שיחת ועידה"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"מספר חירום"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="two"><xliff:g id="COUNT">%d</xliff:g> שניות</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> שניות</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> שניות</item>
+      <item quantity="one">שנייה אחת</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="two"><xliff:g id="COUNT">%d</xliff:g> דקות</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> דקות</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> דקות</item>
+      <item quantity="one">דקה אחת</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="two"><xliff:g id="COUNT">%d</xliff:g> שעות</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> שעות</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> שעות</item>
+      <item quantity="one">שעה אחת</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"תמונת פרופיל"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"המצלמה כבויה"</string>
+    <string name="child_number" msgid="4469090994612105532">"באמצעות <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"ההערה נשלחה"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"הודעות אחרונות"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"פרטי עסק"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"במרחק <xliff:g id="DISTANCE">%.1f</xliff:g> מייל"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"במרחק <xliff:g id="DISTANCE">%.1f</xliff:g> ק\"מ"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"ייפתח מחר ב-<xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"נפתח היום ב-<xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"נסגר ב-<xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"נסגר היום ב-<xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"פתוח עכשיו"</string>
+    <string name="closed_now" msgid="2635314668145282080">"סגור עכשיו"</string>
+</resources>
diff --git a/InCallUI/res/values-ja/strings.xml b/InCallUI/res/values-ja/strings.xml
new file mode 100644
index 0000000..d629a2e
--- /dev/null
+++ b/InCallUI/res/values-ja/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"電話"</string>
+    <string name="onHold" msgid="527593602772521700">"保留中"</string>
+    <string name="unknown" msgid="3646075119047488748">"不明"</string>
+    <string name="private_num" msgid="6081418498487514686">"非通知"</string>
+    <string name="payphone" msgid="5743050584468748607">"公衆電話"</string>
+    <string name="confCall" msgid="3181961445236675173">"グループ通話"</string>
+    <string name="call_lost" msgid="8208184291640961172">"通話が遮断されました"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"スピーカー"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"携帯端末のイヤホン"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"有線ヘッドセット"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"次の番号を送信しますか？\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"番号を送信中\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"送信"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"はい"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"いいえ"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"ワイルド文字を置換:"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"グループ通話 <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"ボイスメールの番号"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"発信中"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"リダイヤル中"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"グループ通話"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"着信中"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"仕事の通話が着信中"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"通話終了"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"保留中"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"通話終了"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"通話中"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"この電話の番号: <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"ビデオハングアウトに接続中"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"ビデオハングアウト"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"ビデオハングアウトをリクエスト中"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"ビデオハングアウトの接続エラー"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"ビデオハングアウトのリクエスト不承認"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"コールバック先\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"緊急通報コールバック先\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"発信中"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"不在着信"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"不在着信"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"不在着信 <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> 件"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> さんからの不在着信"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"通話中"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"仕事の通話中"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Wi-Fi 通話中"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"仕事の Wi-Fi 通話中"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"保留中"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"着信中"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"仕事の通話が着信中"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Wi-Fi 通話が着信中"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"仕事の Wi-Fi 通話が着信中"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"ビデオハングアウトが着信中"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"ビデオハングアウト リクエストが着信中"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"新着のボイスメール"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"新着のボイスメール（<xliff:g id="COUNT">%d</xliff:g> 件）"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> に発信"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"ボイスメールの番号が不明です"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"通信サービスはありません"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"選択したネットワーク（<xliff:g id="OPERATOR_NAME">%s</xliff:g>）が利用できません"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"電話に出る"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"通話終了"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"ビデオ"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"音声"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"受ける"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"拒否する"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"コールバック"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"メッセージ"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"機内モードを OFF にしてから発信してください。"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"ご加入の通信サービスがありません。"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"モバイル ネットワークが利用できません。"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"発信するには、有効な番号を入力してください。"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"発信できません。"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI シーケンスを開始しています..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"サービスはサポートされていません。"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"通話を切り替えられません。"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"通話を分割できません。"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"転送できません。"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"グループ通話できません。"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"着信を拒否できません。"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"通話を解放できません。"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP 通話"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"緊急通報"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"無線通信を ON にしています..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"通信サービスはありません。もう一度お試しください…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"発信できません。<xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> は緊急通報番号ではありません。"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"発信できません。緊急通報番号におかけください。"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"キーボードで番号を入力してください"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"通話を保留"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"通話を再開"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"通話を終了"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"ダイヤルパッド"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"ミュート"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"通話を追加"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"グループ通話"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"切り替え"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"通話を管理"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"グループ通話オプション"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"音声"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"ビデオ"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"音声通話に変更"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"カメラを切り替え"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"ビデオハングアウトを一時停止"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"その他のオプション"</string>
+    <string name="player_started" msgid="3478865572468310331">"プレーヤーを開始しました"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"プレーヤーを停止しました"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"カメラが準備できていません"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"カメラが準備できました"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"不明な通話セッション イベントです"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"サービス"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"セットアップ"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;未設定&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"その他の通話設定"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> で発信中"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> で着信中"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"連絡先の写真"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"個別通話に切り替え"</string>
+    <string name="selectContact" msgid="92191462970821951">"連絡先を選択"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"カスタム返信を作成..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"キャンセル"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"送信"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"電話に出る"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS を送信する"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"拒否"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"ビデオハングアウトで電話に出る"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"音声通話で電話に出る"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"ビデオハングアウト リクエストを承認する"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"ビデオハングアウト リクエストを拒否する"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"ビデオハングアウト送信リクエストを承認する"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"ビデオハングアウト送信リクエストを拒否する"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"ビデオハングアウト受信リクエストを承認する"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"ビデオハングアウト受信リクエストを拒否する"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"上にスライドして<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>を行います。"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"左にスライドして<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>を行います。"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"右にスライドして<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>を行います。"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"下にスライドして<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>を行います。"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"バイブレーション"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"バイブレーション"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"着信音"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"デフォルトの通知音（<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>）"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"着信音"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"着信時のバイブレーション"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"着信音とバイブレーション"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"グループ通話オプション"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"緊急通報番号"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g>秒</item>
+      <item quantity="one">1秒</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g>分</item>
+      <item quantity="one">1分</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g>時間</item>
+      <item quantity="one">1時間</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"プロフィール写真"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"カメラ OFF"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> に着信"</string>
+    <string name="note_sent" msgid="7623014827902758398">"メモを送信しました"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"最近のメッセージ"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"ビジネス情報"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> マイル内"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km 内"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>、<xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>～<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>、<xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"明日 <xliff:g id="OPEN_TIME">%s</xliff:g>に営業開始"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"本日 <xliff:g id="OPEN_TIME">%s</xliff:g>に営業開始"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g>に営業終了"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"本日 <xliff:g id="CLOSE_TIME">%s</xliff:g>に営業終了"</string>
+    <string name="open_now" msgid="4615706338669555999">"現在営業中"</string>
+    <string name="closed_now" msgid="2635314668145282080">"営業終了"</string>
+</resources>
diff --git a/InCallUI/res/values-ka-rGE/strings.xml b/InCallUI/res/values-ka-rGE/strings.xml
new file mode 100644
index 0000000..80c56e0
--- /dev/null
+++ b/InCallUI/res/values-ka-rGE/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"ტელეფონი"</string>
+    <string name="onHold" msgid="527593602772521700">"მოცდის რეჟიმში"</string>
+    <string name="unknown" msgid="3646075119047488748">"უცნობი"</string>
+    <string name="private_num" msgid="6081418498487514686">"დაფარული ნომერი"</string>
+    <string name="payphone" msgid="5743050584468748607">"ტელეფონ-ავტომატი"</string>
+    <string name="confCall" msgid="3181961445236675173">"საკონფერენციო ზარი"</string>
+    <string name="call_lost" msgid="8208184291640961172">"ზარი შეწყდა"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"დინამიკი"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"ყურსაცვამის საყურისი"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"სადენიანი ყურსაცვამი"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"გსურთ შემდეგი ტონების გაგზავნა?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"ტონების გაგზავნა\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"გაგზავნა"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"დიახ"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"არა"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"ჩანაცვლების სიმბოლო ჩანაცვლდეს შემდეგით:"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"საკონფერენციო ზარი: <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"ხმოვანი ფოსტის ნომერი"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"მიმდინარეობს აკრეფა"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"იკრიფება ხელახლა"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"საკონფერენციო ზარი"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"შემომავალი ზარი"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"შემომავალი ზარი (სამსახური)"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"ზარი დასრულდა"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"მოცდის რეჟიმში"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"მიმდინარეობს გათიშვა"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"საუბრის რეჟიმში"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"ჩემი ნომერია <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"მიმდინარეობს ვიდეოს დაკავშირება"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"ვიდეო ზარი"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"მიმდინარეობს ვიდეოს მოთხოვნა"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"ვიდეო ზარის დაკავშირება ვერ მოხერხდა"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"ვიდეოს მოთხოვნა უარყოფილია"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"თქვენი ნომერი გადმორეკვისთვის\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"თქვენი ნომერი გადაუდებელი გადმორეკვისთვის\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"მიმდინარეობს აკრეფა"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"გამოტოვებული ზარი"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"გამოტოვებული ზარები"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> გამოტოვებული ზარი"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"გამოტოვებული ზარი <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>-ისგან"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"მიმდინარე ზარი"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"მიმდინარე ზარი (სამსახური)"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"მიმდინარე Wi-Fi ზარი"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"მიმდინარე Wi-Fi ზარი (სამსახური)"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"მოცდის რეჟიმში"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"შემომავალი ზარი"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"შემომავალი ზარი (სამსახური)"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"შემომავალი Wi-Fi ზარი"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"შემომავალი Wi-Fi ზარი (სამსახური)"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"შემომავალი ვიდეო ზარი"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"შემომავალი ვიდეოს მოთხოვნა"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"ახალი ხმოვანი შეტყობინება"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"ახალი ხმოვანი შეტყობინება (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>-ზე დარეკვა"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"ხმოვანი ფოსტის ნომერი უცნობია"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"სერვისი არ არის"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"არჩეული ქსელი (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) მიუწვდომელია"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"პასუხი"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"გათიშვა"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"ვიდეო"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"ხმოვანი"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"მიღება"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"დახურვა"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"გადარეკვა"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"შეტყობინება"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"ზარის განსახორციელებლად, ჯერ გამორთეთ თვითმფრინავის რეჟიმი."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"არ არის რეგისტრირებული ქსელში."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"ფიჭური ქსელი მიუწვდომელია."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"ზარის განსახორციელებლად, შეიყვანეთ სწორი ნომერი."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"დარეკვა ვერ ხერხდება."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI თანმიმდევრობის დაწყება…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"სერვისი არ არის მხარდაჭერილი."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"ზარების გადართვა ვერ ხერხდება."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"ზარის განცალკევება ვერ ხერხდება."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"გადამისამართება ვერ ხერხდება."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"საკონფერენციო ზარის განხორციელება ვერ ხერხდება."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"ზარის უარყოფა ვერ ხერხდება."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"ზარ(ებ)ის გათიშვა ვერ ხერხდება."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP ზარი"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"გადაუდებელი ზარი"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"მიმდინარეობს რადიოს ჩართვა…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"სერვისი არ არის. მიმდინარეობს ხელახლა ცდა…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"დარეკვა ვერ ხერხდება. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> არ არის გადაუდებელი დახმარების ნომერი."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"დარეკვა ვერ ხერხდება. აკრიფეთ გადაუდებელი დახმარების ნომერი."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ნომრის ასაკრეფად გამოიყენეთ კლავიატურა"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"მოცდის რეჟიმზე გადაყვანა"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"ზარის განახლება"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"ზარის დასრულება"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"ციფერბლატი"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"დადუმება"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"ზარის დამატება"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"ზარების გაერთიანება"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"ჩანაცვლება"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"ზარების მართვა"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"საკონფერენციო ზარის მართვა"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"აუდიო"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"ვიდეო ზარი"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"ხმოვან ზარზე გადართვა"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"კამერის გადართვა"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"ვიდეოს დაპაუზება"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"სხვა ვარიანტები"</string>
+    <string name="player_started" msgid="3478865572468310331">"დამკვრელი ჩაირთო"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"დამკვრელი გამოირთო"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"კამერა არ არის მზად"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"კამერა მზადაა"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"ზარის სესიის უცნობი მოვლენა"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"სერვისი"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"დაყენება"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;არ არის დაყენებული&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"ზარის სხვა პარამეტრები"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"მიმდინარეობს დარეკვა <xliff:g id="PROVIDER_NAME">%s</xliff:g>-ის მეშვეობით"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"შემომავალი ზარი <xliff:g id="PROVIDER_NAME">%s</xliff:g>-დან"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"კონტაქტის ფოტო"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"პირადი რეჟიმი"</string>
+    <string name="selectContact" msgid="92191462970821951">"კონტაქტის არჩევა"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"საკუთარის შექმნა..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"გაუქმება"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"გაგზავნა"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"პასუხი"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS-ის გაგზავნა"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"უარყოფა"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"პასუხი ვიდეო ზარის სახით"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"პასუხი ხმოვანი ზარის სახით"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"ვიდეოს მოთხოვნის მიღება"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"ვიდეოს მოთხოვნის უარყოფა"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"ვიდეოს გადაცემის მოთხოვნის მიღება"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"ვიდეოს გადაცემის მოთხოვნის უარყოფა"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"ვიდეოს მიღების მოთხოვნაზე დათანხმება"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"ვიდეოს მიღების მოთხოვნის უარყოფა"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"გაასრიალეთ ზემოთ, რათა შესრულდეს <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"გაასრიალეთ მარცხნივ, რათა შესრულდეს <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"გაასრიალეთ მარჯვნივ, რათა შესრულდეს <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"გაასრიალეთ ქვემოთ, რათა შესრულდეს <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"ვიბრაცია"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"ვიბრაცია"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"ხმა"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"ნაგულისხმები ხმა (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"ტელეფონის ზარი"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"ვიბრაცია დარეკვისას"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"ზარის მელოდია და ვიბრაცია"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"საკონფერენციო ზარის მართვა"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"გადაუდებელი დახმარების ნომერი"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> წამი</item>
+      <item quantity="one">1 წამი</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> წუთი</item>
+      <item quantity="one">1 წუთი</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> საათი</item>
+      <item quantity="one">1 საათი</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"პროფილის ფოტო"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"კამერა გამორთულია"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g>-დან"</string>
+    <string name="note_sent" msgid="7623014827902758398">"შენიშვნა გაიგზავნა"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"ბოლო შეტყობინებები"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"ბიზნეს-ინფორმაცია"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> მილში"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> კმ-ში"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> — <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"იხსნება ხვალ <xliff:g id="OPEN_TIME">%s</xliff:g>-ზე"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"იხსნება დღეს <xliff:g id="OPEN_TIME">%s</xliff:g>-ზე"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"იკეტება <xliff:g id="CLOSE_TIME">%s</xliff:g>-ზე"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"დაიკეტა დღეს <xliff:g id="CLOSE_TIME">%s</xliff:g>-ზე"</string>
+    <string name="open_now" msgid="4615706338669555999">"ახლა ღიაა"</string>
+    <string name="closed_now" msgid="2635314668145282080">"ახლა დაკეტილია"</string>
+</resources>
diff --git a/InCallUI/res/values-kk-rKZ/strings.xml b/InCallUI/res/values-kk-rKZ/strings.xml
new file mode 100644
index 0000000..149afd1
--- /dev/null
+++ b/InCallUI/res/values-kk-rKZ/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Телефон"</string>
+    <string name="onHold" msgid="527593602772521700">"Күтуде"</string>
+    <string name="unknown" msgid="3646075119047488748">"Белгісіз"</string>
+    <string name="private_num" msgid="6081418498487514686">"Жеке нөмір"</string>
+    <string name="payphone" msgid="5743050584468748607">"Автомат-телефон"</string>
+    <string name="confCall" msgid="3181961445236675173">"Конференциялық қоңырау"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Қоңырау үзілді"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Динамик"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Телефон құлаққабы"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Сымды құлақаспап жинағы"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Келесі әуендер жіберілсін бе?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Жіберу әуендері\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Жіберу"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Иә"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Жоқ"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Қойылмалы таңбаны келесі таңбамен алмастыру"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"<xliff:g id="CONF_CALL_TIME">%s</xliff:g> конференциялық қоңырауы"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Дауыстық пошта нөмірі"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Терілуде"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Қайта терілуде"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Конференциялық қоңырау"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Кіріс қоңырау"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Кіріс жұмыс қоңырауы"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Қоңырау аяқталды"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Күтуде"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Қоңырау аяқталуда"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Қоңырауда"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mенің нөмірім — <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Бейне қосылуда"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Бейне қоңырау"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Бейне сұралуда"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Бейне қоңырауға қосылу мүмкін емес"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Бейне сұрауы қабылданбады"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Кері қоңырау шалу нөміріңіз\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Төтенше кері қоңырау шалу нөміріңіз\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Терілуде"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Өткізіп алған қоңырау"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Өткізіп алған қоңыраулар"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> өткізіп алған қоңырау"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> қоңырауы өткізіп алынған"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Ағымдағы қоңырау"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Ағымдағы жұмыс қоңырауы"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Ағымдағы Wi-Fi қоңырауы"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Ағымдағы Wi-Fi жұмыс қоңырауы"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Күтуде"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Кіріс қоңырау"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Кіріс жұмыс қоңырауы"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Кіріс Wi-Fi қоңырауы"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Кіріс Wi-Fi жұмыс қоңырауы"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Кіріс бейне қоңырау"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Кіріс бейне сұрау"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Жаңа дауыстық хабар"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Жаңа дауыстық хабар (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> нөмірін теру"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Дауыстық пошта нөмірі белгісіз"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Қызмет жоқ"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Таңдалған (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) желісі қол жетімді емес"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Жауап"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Қоңырауды аяқтау"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Бейне"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Дауыс"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Қабылдау"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Қабылдамау"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Кері қоңырау шалу"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Хабар"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Қоңырау шалу үшін алдымен ұшақ режимін өшіріңіз."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Желіде тіркелмеген."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Ұялы желі қол жетімді емес."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Қоңырау шалу үшін жарамды нөмірді енгізіңіз."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Қоңырау шалу мүмкін емес."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI қатарын бастау…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Қызметке қолдау көрсетілмейді."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Қоңырауларды ауыстыру мүмкін емес."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Қоңырауды бөлу мүмкін емес."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Тасымалдау мүмкін емес."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Конференция мүмкін емес."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Қоңырауды қабылдамау мүмкін емес."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Қоңырау(лар)ды босату мүмкін емес."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP қоңырауы"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Төтенше қоңырау"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Радио қосылуда…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Қызмет жоқ. Әрекет қайталануда…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Қоңырау шалу мүмкін емес. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> төтенше нөмір емес."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Қоңырау шалу мүмкін емес. Төтенше нөмірді теріңіз."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Теру үшін пернетақтаны пайдалану"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Қоңырауды ұстап тұру"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Қоңырауды жалғастыру"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Қоңырауды аяқтау"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Теру тақтасы"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Дыбысты өшіру"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Қоңырау қосу"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Қоңырауларды біріктіру"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Алмастыру"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Қоңырауларды басқару"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Конференциялық қоңырауды басқару"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Aудио"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Бейне қоңырау"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Дауыстық қоңырауға өзгерту"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Камераны ауыстыру"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Бейнені кідірту"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Қосымша опциялар"</string>
+    <string name="player_started" msgid="3478865572468310331">"Ойнатқыш іске қосылды"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Ойнатқыш тоқтатылды"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Камера дайын емес"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Камера дайын"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Белгісіз қоңырау сеансы оқиғасы"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Қызмет"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Реттеу"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Орнатылмаған&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Басқа қоңырау параметрлері"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> арқылы қоңырау шалу"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> арқылы кіріс"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"контакт фотосуреті"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"жеке қоңырауға ауысу"</string>
+    <string name="selectContact" msgid="92191462970821951">"контакт таңдау"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Өзіңіздікін жазыңыз..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Бас тарту"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Жіберу"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Жауап"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS жіберу"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Қабылдамау"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Бейне қоңырауға жауап беру"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Аудио қоңырауға жауап беру"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Бейне сұрауды қабылдау"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Бейне сұрауды қабылдамау"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Бейне тасымалдау сұрауын қабылдау"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Бейне тасымалдау сұрауын қабылдамау"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Бейне алу сұрауын қабылдау"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Бейне алу сұрауын қабылдамау"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> үшін жоғары сырғытыңыз."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> үшін сол жаққа сырғытыңыз."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> үшін оң жаққа сырғытыңыз."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> үшін төмен сырғытыңыз."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Діріл"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Діріл"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Дыбыс"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Әдепкі дыбыс (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Телефонның қоңырау әуені"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Шылдырлағанда дірілдеу"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Қоңырау әуені және діріл"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Конференциялық қоңырауды басқару"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Төтенше нөмір"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> секунд</item>
+      <item quantity="one">1 секунд</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> минут</item>
+      <item quantity="one">1 минут</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> сағат</item>
+      <item quantity="one">1 сағат</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Профиль фотосуреті"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Камераны өшіру"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> арқылы"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Ескертпе жіберілді"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Жақындағы хабарлар"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Іскери ақпарат"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> миля қашықтықта"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> км қашықтықта"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Ертең <xliff:g id="OPEN_TIME">%s</xliff:g> уақытында ашылады"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Бүгін <xliff:g id="OPEN_TIME">%s</xliff:g> уақытында ашылады"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g> уақытында жабылады"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Бүгін <xliff:g id="CLOSE_TIME">%s</xliff:g> уақытында жабық"</string>
+    <string name="open_now" msgid="4615706338669555999">"Қазір ашық"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Қазір жабық"</string>
+</resources>
diff --git a/InCallUI/res/values-km-rKH/strings.xml b/InCallUI/res/values-km-rKH/strings.xml
new file mode 100644
index 0000000..69feae0
--- /dev/null
+++ b/InCallUI/res/values-km-rKH/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"ទូរស័ព្ទ"</string>
+    <string name="onHold" msgid="527593602772521700">"រង់ចាំ"</string>
+    <string name="unknown" msgid="3646075119047488748">"មិនស្គាល់"</string>
+    <string name="private_num" msgid="6081418498487514686">"លេខ​ឯកជន"</string>
+    <string name="payphone" msgid="5743050584468748607">"ទូរស័ព្ទសាធារណៈ"</string>
+    <string name="confCall" msgid="3181961445236675173">"ការហៅជាក្រុម"</string>
+    <string name="call_lost" msgid="8208184291640961172">"ការហៅទូរស័ព្ទបានដាក់ចុះ"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"ឧបករណ៍បំពងសម្លេង"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"អូប៉ាល័រសំឡេងទូរស័ព្ទ"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"កាសមានខ្សែ"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"ប៊្លូធូស"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"ផ្ញើសំឡេងដូចខាងក្រោមឬ?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"ផ្ញើ​សំឡេង \n"</string>
+    <string name="send_button" msgid="4054398309483035794">"ផ្ញើ"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"បាទ/ចាស"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"ទេ"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"ជំនួស​តួ​អក្សរ​ជំនួស​ដោយ"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"ការហៅជាក្រុម <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"លេខ​សារ​ជា​សំឡេង"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"កំពុងហៅ"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"ការចុចហៅឡើងវិញ"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"ការហៅជាក្រុម"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"ការហៅចូល"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"កំពុងហៅចូលពីកន្លែងការងារ"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"បាន​បញ្ចប់​ការ​ហៅ"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"រង់ចាំ"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"បញ្ចប់​ការ​សន្ទនា"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"កំពុង​ហៅ"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"លេខ​របស់​ខ្ញុំ​គឺ <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"ភ្ជាប់​វីដេអូ"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"ហៅជាវីដេអូ"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"ស្នើ​វីដេអូ"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"មិនអាចភ្ជាប់ការហៅជាវីដេអូបានទេ"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"បានបដិសេធសំណើហៅជាវីដេអូ"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"លេខហៅទៅវិញរបស់អ្នក\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"លេខហៅទៅវិញពេលអាសន្នរបស់អ្នក\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"កំពុង​ហៅ"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"ខកខាន​ទទួល"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"ខកខាន​ទទួល"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"ខកខានទទួល <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ដង"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"ខកខាន​ទទួល​ពី <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"កំពុង​បន្ត​ការ​ហៅ"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"ការហៅពីកន្លែងការងារកំពុងដំណើរការ"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"ការហៅតាម Wi-Fi កំពុងបន្ត"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"ការហៅតាម Wi-Fi ពីកន្លែងការងារកំពុងដំណើរការ"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"រង់ចាំ"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"ការហៅចូល"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"កំពុងហៅចូលពីកន្លែងការងារ"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"មានការហៅចូលតាម Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"កំពុងហៅចូលពីកន្លែងការងារតាម Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"ការ​ហៅចូលជា​វីដេអូ​"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"សំណើ​ការ​ហៅ​ជា​វីដេអូ​ចូល"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"សារ​ជា​សំឡេង​ថ្មី"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"សារ​ជា​សំឡេង​ថ្មី (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"ហៅ <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"លេខសារជាសំឡេងមិនស្គាល់"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"គ្មានសេវាទេ"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"បណ្ដាញ​ដែល​បាន​ជ្រើស ( <xliff:g id="OPERATOR_NAME">%s</xliff:g> ) មិន​អាច​ប្រើ​បាន​ទេ"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"ឆ្លើយតប"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"បញ្ចប់​ការ​សន្ទនា"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"វីដេអូ"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"សំឡេង"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"ព្រម​ទទួល"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"បដិសេធ"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"ហៅ​ទៅ​វិញ"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"សារ"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"ដើម្បីកំណត់ការហៅ សូមបិទរបៀបពេលជិះយន្តហោះជាមុនសិន"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"មិនបានចុះឈ្មោះនៅលើបណ្ដាញទេ"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"បណ្ដាញចល័តមិនអាចប្រើបានទេ"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"ដើម្បីធ្វើការហៅ សូមបញ្ចូលលេខដែលត្រឹមត្រូវ"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"មិនអាចហៅបានទេ"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"កំពុងចាប់ផ្តើមលំដាប់ MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"សេវាកម្មមិនត្រូវបានគាំទ្រទេ"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"មិនអាចប្តូរការហៅបានទេ"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"មិនអាចបំបែកការហៅបានទេ"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"មិនអាចផ្ទេរបានទេ"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"មិនអាចធ្វើការហៅជាក្រុមបានទេ"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"មិនអាចបដិសេធការហៅបានទេ"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"មិនអាចធ្វើការហៅបានទេ"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"ការ​ហៅ SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"ការ​ហៅ​ពេល​អាសន្ន"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"កំពុងបើកវិទ្យុ…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"គ្មានសេវាទេ សូមព្យាយាមម្តង…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"មិនអាចហៅបានទេ។ <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> មិនមែនជាលេខអាសន្នទេ"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"មិនអាចហៅបានទេ សូមចុចហៅលេខអាសន្ន"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ប្រើ​ក្ដារ​ចុច ​ដើម្បី​ចុច​លេខ"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"រង់ចាំការហៅ"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"បន្តការហៅ"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"បញ្ចប់ការហៅ"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"បន្ទះ​លេខ"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"បិទ"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"បន្ថែម​ការ​ហៅ"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"បញ្ចូល​ការ​ហៅ​ចូល​គ្នា"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"ប្ដូរ"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"គ្រប់គ្រង​ការ​ហៅ"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"គ្រប់គ្រងការហៅជាក្រុម"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"សំឡេង"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"ហៅជាវីដេអូ"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"ប្ដូរ​ទៅ​ការ​ហៅ​ជា​សំឡេង"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"ប្ដូរកាមេរ៉ា"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"ផ្អាក​វីដេអូ"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"ជម្រើសច្រើនទៀត"</string>
+    <string name="player_started" msgid="3478865572468310331">"អ្នកលេងបានចាប់ផ្តើម"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"អ្នកលេងបានឈប់"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"កាមេរ៉ាមិនទាន់ត្រៀមរួចរាល់ទេ"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"កាមេរ៉ាត្រៀមរួចរាល់ហើយ"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"ព្រឹត្តិការណ៍វេននៃការហៅមិនស្គាល់"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"សេវាកម្ម"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"ដំឡើង"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;មិន​បាន​កំណត់&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"​កំណត់​ការ​​ហៅ​ផ្សេងទៀត"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"ហៅតាមរយៈ <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"ចូល​តាមរយៈ <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"រូបថត​ទំនាក់ទំនង"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"ចូលជាលក្ខណៈឯកជន"</string>
+    <string name="selectContact" msgid="92191462970821951">"ជ្រើសទំនាក់ទំនង"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"សរសេរដោយខ្លួនអ្នកផ្ទាល់..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"បោះបង់"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"ផ្ញើ"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"ឆ្លើយតប"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"ផ្ញើសារ SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"បដិសេធ"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"ឆ្លើយតប​ជា​ការ​ហៅ​ជា​​វីដេអូ"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"ឆ្លើយតប​ជា​ការ​ហៅ​ជា​សំឡេង"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"ទទួលយក​សំណើ​វីដេអូ"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"ទទួលយក​សំណើ​វីដេអូ"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"ទទួលយកសំណើបញ្ជូនជាវីដេអូ"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"បដិសេធសំណើបញ្ជូនជាវីដេអូ"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"ទទួលយកសំណើទទួលជាវីដេអូ"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"បដិសេធសំណើទទួលជាវីដេអូ"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"រុញឡើងលើដើម្បី <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"រុញទៅឆ្វេងដើម្បី <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"រុញទៅស្ដាំដើម្បី <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"រុញចុះក្រោមដើម្បី <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"ញ័រ"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"ញ័រ"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"សំឡេង"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"សំឡេង​លំនាំដើម (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"សំឡេងរោទ៍ទូរស័ព្ទ"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"ញ័រពេលរោទ៍"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"សំឡេងរោទ៍ និងញ័រ"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"គ្រប់គ្រងការហៅជាក្រុម"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"លេខអាសន្ន"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> វិនាទី</item>
+      <item quantity="one">1 វិនាទី</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> នាទី</item>
+      <item quantity="one">1 នាទី</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ម៉ោង</item>
+      <item quantity="one">1 ម៉ោង</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"រូបថត​ប្រវត្តិរូប"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"បិទកាមេរ៉ា"</string>
+    <string name="child_number" msgid="4469090994612105532">"តាមរយៈ <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"បានផ្ញើចំណាំ"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"សារថ្មីៗ"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"ព័ត៌មានធុរកិច្ច"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"ចម្ងាយ <xliff:g id="DISTANCE">%.1f</xliff:g> ម៉ាយល៍"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"ចម្ងាយ <xliff:g id="DISTANCE">%.1f</xliff:g> គម"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"បើកថ្ងៃស្អែកនៅម៉ោង <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"បើកថ្ងៃនេះនៅម៉ោង <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"បិទនៅម៉ោង <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"បានបិទថ្ងៃនេះនៅម៉ោង <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"បើកឥឡូវនេះ"</string>
+    <string name="closed_now" msgid="2635314668145282080">"បិទឥឡូវនេះ"</string>
+</resources>
diff --git a/InCallUI/res/values-kn-rIN/strings.xml b/InCallUI/res/values-kn-rIN/strings.xml
new file mode 100644
index 0000000..c198663
--- /dev/null
+++ b/InCallUI/res/values-kn-rIN/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"ಫೋನ್"</string>
+    <string name="onHold" msgid="527593602772521700">"ತಡೆಹಿಡಿಯಲಾಗಿದೆ"</string>
+    <string name="unknown" msgid="3646075119047488748">"ಅಪರಿಚಿತ"</string>
+    <string name="private_num" msgid="6081418498487514686">"ಖಾಸಗಿ ಸಂಖ್ಯೆ"</string>
+    <string name="payphone" msgid="5743050584468748607">"ಪೇಫೋನ್"</string>
+    <string name="confCall" msgid="3181961445236675173">"ಕಾನ್ಫರೆನ್ಸ್ ಕರೆ"</string>
+    <string name="call_lost" msgid="8208184291640961172">"ಕರೆಯನ್ನು ಬಿಡಲಾಗಿದೆ"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"ಸ್ಪೀಕರ್‌"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"ಹ್ಯಾಂಡ್‌ಸೆಟ್ ಇಯರ್‌ಪೀಸ್"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"ವೈರ್ಡ್ ಹೆಡ್‌ಸೆಟ್‌"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"ಬ್ಲೂಟೂತ್"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"ಕೆಳಗಿನ ಟೋನ್‌ಗಳನ್ನು ಕಳುಹಿಸುವುದೇ?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"ಟೋನ್‌ಗಳನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತಿದೆ\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"ಕಳುಹಿಸು"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"ಹೌದು"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"ಇಲ್ಲ"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"ಇದರೊಂದಿಗೆ ವಿಶೇಷ ಅಕ್ಷರಗಳನ್ನು ಸ್ಥಳಾಂತರಿಸು"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"ಕಾನ್ಫರೆನ್ಸ್ ಕರೆ <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"ಧ್ವನಿಮೇಲ್‌ ಸಂಖ್ಯೆ"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"ಡಯಲ್‌ ಮಾಡಲಾಗುತ್ತಿದೆ"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"ಮರು ಡಯಲ್ ಮಾಡಲಾಗುತ್ತಿದೆ"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"ಕಾನ್ಫರೆನ್ಸ್ ಕರೆ"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"ಒಳಬರುವ ಕರೆ"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"ಒಳಬರುವ ಕೆಲಸದ ಕರೆ"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"ಕರೆ ಅಂತ್ಯಗೊಂಡಿದೆ"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"ತಡೆಹಿಡಿಯಲಾಗಿದೆ"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"ಹ್ಯಾಂಗ್ ಮಾಡಲಾಗುತ್ತಿದೆ"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"ಕರೆಯಲ್ಲಿ"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"ನನ್ನ ಸಂಖ್ಯೆ <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"ವೀಡಿಯೊ ಸಂಪರ್ಕಪಡಿಸಲಾಗುತ್ತಿದೆ"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"ವೀಡಿಯೊ ಕರೆ"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"ವೀಡಿಯೊ ವಿನಂತಿಸಲಾಗುತ್ತಿದೆ"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"ವೀಡಿಯೊ ಕರೆಯನ್ನು ಸಂಪರ್ಕಪಡಿಸಲಾಗುವುದಿಲ್ಲ"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"ವೀಡಿಯೊ ವಿನಂತಿಯನ್ನು ತಿರಸ್ಕರಿಸಲಾಗಿದೆ"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"ನಿಮ್ಮ ಮರಳಿಕರೆ ಮಾಡುವ ಸಂಖ್ಯೆ\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"ನಿಮ್ಮ ತುರ್ತು ಮರಳಿಕರೆ ಮಾಡುವ ಸಂಖ್ಯೆ\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"ಡಯಲ್‌ ಮಾಡಲಾಗುತ್ತಿದೆ"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"ಮಿಸ್ಡ್‌ ಕಾಲ್‌"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"ಮಿಸ್ಡ್ ಕಾಲ್‌ಗಳು"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ಮಿಸ್ಡ್ ಕಾಲ್‌ಗಳು"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> ಅವರಿಂದ ಮಿಸ್ಡ್ ಕಾಲ್"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"ಚಾಲ್ತಿಯಲ್ಲಿರುವ ಕರೆ"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"ಚಾಲ್ತಿಯಲ್ಲಿರುವ ಕೆಲಸದ ಕರೆ"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"ಚಾಲ್ತಿಯಲ್ಲಿರುವ ವೈ-ಫೈ ಕರೆ"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"ಚಾಲ್ತಿಯಲ್ಲಿರುವ ವೈ-ಫೈ ಕೆಲಸದ ಕರೆ"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"ತಡೆಹಿಡಿಯಲಾಗಿದೆ"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"ಒಳಬರುವ ಕರೆ"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"ಒಳಬರುವ ಕೆಲಸದ ಕರೆ"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"ಒಳಬರುವ ವೈ-ಫೈ ಕರೆ"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"ಒಳಬರುವ ವೈ-ಫೈ ಕೆಲಸದ ಕರೆ"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"ಒಳಬರುವ ವೀಡಿಯೊ ಕರೆ"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"ಒಳಬರುವ ವೀಡಿಯೊ ವಿನಂತಿ"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"ಹೊಸ ಧ್ವನಿಮೇಲ್‌"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"ಹೊಸ ಧ್ವನಿಮೇಲ್‌‌ (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> ಗೆ ಡಯಲ್‌‌ ಮಾಡು"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"ಅಪರಿಚಿತ ಧ್ವನಿಮೇಲ್‌ ಸಂಖ್ಯೆ"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"ಸೇವೆ ಇಲ್ಲ"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"ಆಯ್ಕೆಮಾಡಿದ (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) ನೆಟ್‌ವರ್ಕ್‌ ಲಭ್ಯವಿಲ್ಲ"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"ಉತ್ತರ"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"ಹ್ಯಾಂಗ್ ಅಪ್"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"ವೀಡಿಯೊ"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"ಧ್ವನಿ"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"ಸಮ್ಮತಿಸು"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"ವಜಾಗೊಳಿಸಿ"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"ಮರಳಿ ಕರೆ"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"ಸಂದೇಶ"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"ಕರೆ ಮಾಡಲು, ಮೊದಲು ಏರ್‌ಪ್ಲೇನ್‌‌ ಮೋಡ್‌‌ ಆಫ್‌ ಮಾಡಿ."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಇನ್ನೂ ನೋಂದಣಿಯಾಗಿಲ್ಲ."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"ಸೆಲ್ಯುಲಾರ್ ನೆಟ್‌ವರ್ಕ್‌ ಲಭ್ಯವಿಲ್ಲ."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"ಕರೆಯನ್ನು ಮಾಡಲು, ಮಾನ್ಯವಾದ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"ಕರೆ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI ಅನುಕ್ರಮ ಪ್ರಾರಂಭವಾಗುತ್ತಿದೆ…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"ಸೇವೆ ಬೆಂಬಲಿತವಾಗಿಲ್ಲ."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"ಕರೆಗಳನ್ನು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"ಕರೆಯನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"ವರ್ಗಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"ಕಾನ್ಫರೆನ್ಸ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"ಕರೆ ತಿರಸ್ಕರಿಸಲಾಗುವುದಿಲ್ಲ."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"ಕರೆ(ಗಳು) ಬಿಡುಗಡೆ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP ಕರೆ"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"ತುರ್ತು ಕರೆ"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"ರೇಡಿಯೋ ಆನ್‌ ಮಾಡಲಾಗುತ್ತಿದೆ…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"ಯಾವುದೇ ಸೇವೆ ಇಲ್ಲ. ಮತ್ತೆ ಪ್ರಯತ್ನಿಸಲಾಗುತ್ತಿದೆ..."</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"ಕರೆ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> ತುರ್ತು ಸಂಖ್ಯೆಯಲ್ಲ."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"ಕರೆ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ತುರ್ತು ಸಂಖ್ಯೆಯನ್ನು ಡಯಲ್ ಮಾಡಿ."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ಡಯಲ್‌ ಮಾಡಲು ಕೀಬೋರ್ಡ್‌ ಬಳಸಿ"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"ಕರೆಯನ್ನು ಹೋಲ್ಡ್‌‌ ಮಾಡು"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"ಕರೆಯನ್ನು ಮುಂದುವರಿಸಿ"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"ಕರೆ ಅಂತ್ಯಗೊಳಿಸಿ"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"ಡಯಲ್‌ಪ್ಯಾಡ್"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"ಮ್ಯೂಟ್"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"ಕರೆಯನ್ನು ಸೇರಿಸು"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"ಕರೆಗಳನ್ನು ವಿಲೀನಗೊಳಿಸು"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"ಸ್ವ್ಯಾಪ್‌ ಮಾಡು"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"ಕರೆಗಳನ್ನು ನಿರ್ವಹಿಸಿ"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"ಕಾನ್ಫರೆನ್ಸ್ ಕರೆಯನ್ನು ನಿರ್ವಹಿಸಿ"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"ಆಡಿಯೊ"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"ವೀಡಿಯೊ ಕರೆ"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"ಧ್ವನಿ ಕರೆಗೆ ಬದಲಾಯಿಸಿ"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"ಕ್ಯಾಮರಾ ಬದಲಿಸಿ"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"ವೀಡಿಯೊ ವಿರಾಮಗೊಳಿಸು"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"ಇನ್ನಷ್ಟು ಆಯ್ಕೆಗಳು"</string>
+    <string name="player_started" msgid="3478865572468310331">"ಪ್ಲೇಯರ್‌ ಪ್ರಾರಂಭವಾಗಿದೆ"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"ಪ್ಲೇಯರ್‌ ನಿಲ್ಲಿಸಲಾಗಿದೆ"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"ಕ್ಯಾಮರಾ ಸಿದ್ಧವಾಗಿಲ್ಲ"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"ಕ್ಯಾಮರಾ ಸಿದ್ಧವಾಗಿದೆ"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"ಅಜ್ಞಾತ ಕರೆಯ ಸೆಶನ್‌ ಈವೆಂಟ್‌"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"ಸೇವೆ"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"ಸೆಟಪ್"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;ಹೊಂದಿಸಿಲ್ಲ&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"ಇತರ ಕರೆ ಸೆಟ್ಟಿಂಗ್‌ಗಳು"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> ಮೂಲಕ ಕರೆ ಮಾಡಲಾಗುತ್ತಿದೆ"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> ಮೂಲಕ ಒಳಬರುತ್ತಿರುವ ಕರೆ"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"ಸಂಪರ್ಕ ಫೋಟೋ"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"ಖಾಸಗಿಯಾಗಿ ಹೋಗಿ"</string>
+    <string name="selectContact" msgid="92191462970821951">"ಸಂಪರ್ಕವನ್ನು ಆಯ್ಕೆಮಾಡಿ"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"ನಿಮ್ಮ ಸ್ವಂತದ್ದನ್ನು ಬರೆಯಿರಿ..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"ರದ್ದುಮಾಡು"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"ಕಳುಹಿಸು"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"ಉತ್ತರ"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS ಕಳುಹಿಸಿ"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"ನಿರಾಕರಿಸು"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"ವೀಡಿಯೊ ಕರೆ ರೂಪದಲ್ಲಿ ಉತ್ತರಿಸಿ"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"ಆಡಿಯೊ ಕರೆಯಂತೆ ಉತ್ತರಿಸಿ"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"ವೀಡಿಯೊ ವಿನಂತಿ ಒಪ್ಪಿಕೊಳ್ಳು"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"ವೀಡಿಯೊ ವಿನಂತಿ ತಿರಸ್ಕರಿಸು"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"ವೀಡಿಯೊ ಪ್ರಸಾರ ವಿನಂತಿ ಸಮ್ಮತಿಸಿ"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"ವೀಡಿಯೊ ಪ್ರಸಾರ ವಿನಂತಿ ತಿರಸ್ಕರಿಸಿ"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"ವೀಡಿಯೊ ಸ್ವೀಕರಿಸುವಿಕೆ ವಿನಂತಿ ಸಮ್ಮತಿಸಿ"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"ವೀಡಿಯೊ ಸ್ವೀಕರಿಸುವಿಕೆ ವಿನಂತಿ ತಿರಸ್ಕರಿಸಿ"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ಗೆ ಮೇಲಕ್ಕೆ ಸ್ಲೈಡ್ ಮಾಡಿ."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ಗೆ ಎಡಕ್ಕೆ ಸ್ಲೈಡ್ ಮಾಡಿ."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ಗೆ ಬಲಕ್ಕೆ ಸ್ಲೈಡ್ ಮಾಡಿ."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ಗೆ ಕೆಳಕ್ಕೆ ಸ್ಲೈಡ್ ಮಾಡಿ."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"ವೈಬ್ರೇಟ್‌"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"ವೈಬ್ರೇಟ್‌"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"ಶಬ್ದ"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"ಡೀಫಾಲ್ಟ್‌ ಧ್ವನಿ (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"ಫೋನ್ ರಿಂಗ್‌ಟೋನ್"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"ರಿಂಗ್ ಆಗುವಾಗ ವೈಬ್ರೇಟ್‌ ಆಗು"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"ರಿಂಗ್‌ಟೋನ್‌‌ ಮತ್ತು ವೈಬ್ರೇಟ್‌"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"ಕಾನ್ಫರೆನ್ಸ್ ಕರೆಯನ್ನು ನಿರ್ವಹಿಸಿ"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"ತುರ್ತು ಸಂಖ್ಯೆ"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ಸೆಕೆಂಡುಗಳು</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ಸೆಕೆಂಡುಗಳು</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ನಿಮಿಷಗಳು</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ನಿಮಿಷಗಳು</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ಗಂಟೆಗಳು</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ಗಂಟೆಗಳು</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"ಪ್ರೊಫೈಲ್ ಫೋಟೋ"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"ಕ್ಯಾಮರಾ ಆಫ್‌"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> ಮೂಲಕ"</string>
+    <string name="note_sent" msgid="7623014827902758398">"ಟಿಪ್ಪಣಿ ಕಳುಹಿಸಲಾಗಿದೆ"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"ಇತ್ತೀಚಿನ ಸಂದೇಶಗಳು"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"ವ್ಯಾಪಾರ ಮಾಹಿತಿ"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> ಮೈಲು ದೂರ"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> ಕಿಮೀ ದೂರ"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"ನಾಳೆ <xliff:g id="OPEN_TIME">%s</xliff:g> ಗಂಟೆಗೆ ತೆರೆಯುತ್ತದೆ"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"ಇಂದು <xliff:g id="OPEN_TIME">%s</xliff:g> ಗಂಟೆಗೆ ತೆರೆಯುತ್ತದೆ"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g> ಗಂಟೆಗೆ ಮುಚ್ಚಲಾಗಿದೆ"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"ಇಂದು <xliff:g id="CLOSE_TIME">%s</xliff:g> ಗಂಟೆಗೆ ಮುಚ್ಚಲಾಗಿದೆ"</string>
+    <string name="open_now" msgid="4615706338669555999">"ಇದೀಗ ತೆರೆಯಲಾಗಿದೆ"</string>
+    <string name="closed_now" msgid="2635314668145282080">"ಇದೀಗ ಮುಚ್ಚಲಾಗಿದೆ"</string>
+</resources>
diff --git a/InCallUI/res/values-ko/strings.xml b/InCallUI/res/values-ko/strings.xml
new file mode 100644
index 0000000..639e578
--- /dev/null
+++ b/InCallUI/res/values-ko/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"전화"</string>
+    <string name="onHold" msgid="527593602772521700">"대기 중"</string>
+    <string name="unknown" msgid="3646075119047488748">"알 수 없음"</string>
+    <string name="private_num" msgid="6081418498487514686">"비공개 번호"</string>
+    <string name="payphone" msgid="5743050584468748607">"공중전화"</string>
+    <string name="confCall" msgid="3181961445236675173">"다자간 통화"</string>
+    <string name="call_lost" msgid="8208184291640961172">"연락되지 않음"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"스피커"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"핸드셋 수화부"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"유선 헤드셋"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"블루투스"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"다음 톤을 보내시겠습니까?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"신호음 보내기\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"전송"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"예"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"아니요"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"와일드 문자를 다음으로 바꿈:"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"다자간 통화 <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"음성사서함 번호"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"전화 거는 중"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"재다이얼 중"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"다자간 통화"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"수신 전화"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"수신 업무 전화"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"통화 종료됨"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"대기 중"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"전화 끊는 중"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"통화 중"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"내 전화번호는 <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>입니다."</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"화상 통화 연결 중"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"화상 통화"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"화상 통화 요청 중"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"화상 통화를 연결할 수 없습니다."</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"화상 통화 요청이 거부되었습니다."</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"콜백 번호\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"긴급 콜백 번호\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"전화 거는 중"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"부재중 전화"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"부재중 전화"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"부재중 전화 <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>통"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g>의 부재중 전화"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"발신 전화"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"발신 업무 전화"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"발신 Wi-Fi 전화"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"발신 Wi-Fi 업무 전화"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"대기 중"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"수신 전화"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"수신 업무 전화"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Wi-Fi 수신 전화"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"수신 Wi-Fi 업무 전화"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"수신 화상 통화"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"수신 화상 통화 요청"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"새로운 음성사서함"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"새 음성사서함(<xliff:g id="COUNT">%d</xliff:g>개)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>(으)로 전화 걸기"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"알 수 없는 음성사서함 번호"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"서비스 불가"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"선택한 네트워크(<xliff:g id="OPERATOR_NAME">%s</xliff:g>)를 사용할 수 없음"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"전화 받기"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"전화 끊기"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"화상"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"음성"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"수락"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"해제"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"전화 걸기"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"메시지"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"전화를 걸려면 먼저 비행기 모드를 해제하세요."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"네트워크에서 등록되지 않았습니다."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"사용 가능한 이동통신망이 없습니다."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"전화를 걸려면 올바른 번호를 입력하세요."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"전화를 걸 수 없습니다."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI 시퀀스 시작 중..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"서비스가 지원되지 않습니다."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"통화를 전환할 수 없습니다."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"통화를 분리할 수 없습니다."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"통화를 전환할 수 없습니다."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"다자간 통화를 이용할 수 없습니다."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"통화를 거부할 수 없습니다."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"통화를 끊을 수 없습니다."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP 통화"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"긴급 전화"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"무선을 켜는 중..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"서비스를 사용할 수 없습니다. 다시 시도 중..."</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"전화를 걸 수 없습니다. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g>은(는) 긴급 번호가 아닙니다."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"전화를 걸 수 없습니다. 긴급 번호를 사용하세요."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"키보드를 사용하여 전화 걸기"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"통화 대기"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"통화 재개"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"통화 종료"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"다이얼패드"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"숨기기"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"통화 추가"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"통화 병합"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"전환"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"통화 관리"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"다자간 통화 관리"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"오디오"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"화상 통화"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"음성 통화로 변경"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"카메라 전환"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"동영상 일지중지"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"옵션 더보기"</string>
+    <string name="player_started" msgid="3478865572468310331">"플레이어가 시작되었습니다."</string>
+    <string name="player_stopped" msgid="1278611664986561535">"플레이어가 중지되었습니다."</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"카메라가 준비되지 않았습니다."</string>
+    <string name="camera_ready" msgid="2614541247814590887">"카메라가 준비되었습니다."</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"알 수 없는 통화 세션 이벤트"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"서비스"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"설정"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;설정 안됨&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"기타 통화 설정"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g>을(를) 통해 걸려온 전화"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g>을(를) 통해 걸려온 전화"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"연락처 사진"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"비공개로 실행"</string>
+    <string name="selectContact" msgid="92191462970821951">"연락처 선택"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"나만의 응답 작성…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"취소"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"전송"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"전화 받기"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS 보내기"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"거부"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"화상 통화로 받기"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"음성 통화로 받기"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"화상 통화 요청 수락"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"화상 통화 요청 거부"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"화상 통화 전송 요청 허용"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"화상 통화 전송 요청 거부"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"화상 통화 수신 요청 허용"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"화상 통화 수신 요청 거부"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>하려면 위로 슬라이드합니다."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>하려면 왼쪽으로 슬라이드합니다."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>하려면 오른쪽으로 슬라이드합니다."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>하려면 아래로 슬라이드합니다."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"진동"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"진동"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"소리"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"기본 알림음(<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"전화 벨소리"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"전화 수신 시 진동"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"벨소리 및 진동"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"다자간 통화 관리"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"비상 전화번호"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g>초</item>
+      <item quantity="one">1초</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g>분</item>
+      <item quantity="one">1분</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g>시간</item>
+      <item quantity="one">1시간</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"프로필 사진"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"카메라 꺼짐"</string>
+    <string name="child_number" msgid="4469090994612105532">"수신 번호: <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"메모가 전송되었습니다."</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"최근 메시지"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"비즈니스 정보"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g>mi 거리"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g>km 거리"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>~<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"내일 <xliff:g id="OPEN_TIME">%s</xliff:g>에 영업 시작"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"오늘 <xliff:g id="OPEN_TIME">%s</xliff:g>에 영업 시작"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g>에 영업 종료"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"오늘 <xliff:g id="CLOSE_TIME">%s</xliff:g>에 영업 종료됨"</string>
+    <string name="open_now" msgid="4615706338669555999">"영업 중"</string>
+    <string name="closed_now" msgid="2635314668145282080">"영업 종료"</string>
+</resources>
diff --git a/InCallUI/res/values-ky-rKG/strings.xml b/InCallUI/res/values-ky-rKG/strings.xml
new file mode 100644
index 0000000..7fec9f7
--- /dev/null
+++ b/InCallUI/res/values-ky-rKG/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Телефон"</string>
+    <string name="onHold" msgid="527593602772521700">"Күтүлүүдө"</string>
+    <string name="unknown" msgid="3646075119047488748">"Белгисиз"</string>
+    <string name="private_num" msgid="6081418498487514686">"Купуя номер"</string>
+    <string name="payphone" msgid="5743050584468748607">"Таксофон"</string>
+    <string name="confCall" msgid="3181961445236675173">"Конференц-чалуу"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Чалуу үзүлдү"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Катуу сүйлөткүч"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Гарнитура"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Зымдуу гарнитура"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Төмөнкү номер жөнөтүлсүнбү?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Обондор жөнөтүлүүдө\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Жөнөтүү"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ооба"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Жок"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Атайын белгини төмөнкүгө алмаштыруу"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Конференц-чалуу <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Үн почтасынын номери"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Терилүүдө"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Кайра терилүүдө"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Конференц-чалуу"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Кирүүчү чалуу"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Жумуш боюнча чалуу"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Чалуу аяктады"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Күтүлүүдө"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Чалуу аяктоодо"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Чалууда"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Менин номерим <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Видео туташтырылууда"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Видео чалуу"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Видео суралууда"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Видео чалууга туташуу мүмкүн болбой жатат"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Видео сурам четке кагылды"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Кайра чалына турган номер\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Өзгөчө кырдаалда кайра чалына турган номер\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Терилүүдө"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Кабыл алынбаган чалуу"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Кабыл алынбаган чалуулар"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> кабыл алынбаган чалуу"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> дегенден кабыл алынбаган чалуу"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Учурдагы чалуу"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Учурдагы чалуу (жумуш боюнча)"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Учурдагы Wi-Fi чалуу"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Учурдагы Wi-Fi чалуу (жумуш боюнча)"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Күтүлүүдө"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Кирүүчү чалуу"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Жумуш боюнча чалуу"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Кирүүчү Wi-Fi чалуу"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Жумуш боюнча келип жаткан Wi-Fi чалуу"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Кирүүчү видео чалуу"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Кирүүчү видео сурамы"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Жаңы үн почтасы"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Жаңы үн почтасы (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> номерин терүү"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Үн почтасынын номери белгисиз"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Байланыш жок"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Тандалган тармак (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) жеткиликсиз"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Жооп берүү"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Чалууну бүтүрүү"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Видео"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Үн"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Кабыл алуу"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Этибарга албоо"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Кайра чалуу"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Билдирүү"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Учак режимин өчүрүп туруп чалыңыз."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Тармакта катталган эмес."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Мобилдик тармак жеткиликтүү эмес."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Чалуу үчүн, жарактуу номер киргизиңиз."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Чалынбай жатат."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI кезеги башталууда…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Кызмат колдоого алынбайт."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Чалуулар которуштурулбай жатат."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Чалуу бөлүнбөй жатат."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Өткөрүлбөй жатат."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Конференц-чалуу түзүлбөй жатат."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Чалуу четке кагылбай жатат."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Чалуу (-лар) ажыратылбай жатат."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP чалуу"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Өзгөчө кырдаалда чалуу"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Радио күйгүзүлүүдө…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Кызмат жок. Кайра аракет кылууда…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Чалынбай жатат. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> өзгөчө кырдаал номери эмес."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Чалынбай жатат. Өзгөчө кырдаал номерин териңиз."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Баскычтоп менен териңиз"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Чалууну кармап туруу"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Чалууну улантуу"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Чалууну бүтүрүү"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Тергич"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Үнсүз"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Чалуу кошуу"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Чалууларды бириктирүү"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Алмаштыруу"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Чалууларды башкаруу"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Конференц-чалууну башкаруу"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Аудио"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Видео чалуу"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Үн чалууга өзгөртүү"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Камераны которуштуруу"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Видеону тындыруу"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Дагы параметрлер"</string>
+    <string name="player_started" msgid="3478865572468310331">"Ойноткуч башталды"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Ойноткуч токтотулду"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Камера даяр эмес"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Камера даяр"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Чалуу сеансынын окуясы белгисиз"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Кызмат"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Орнотуу"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Коюлган эмес&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Башка чалуу жөндөөлөрү"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> аркылуу чалуу"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> аркылуу келүүдө"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"байланыштын сүрөтү"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"купуя режимине өтүү"</string>
+    <string name="selectContact" msgid="92191462970821951">"байланыш тандоо"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Сиздин жообуңуз…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Жокко чыгаруу"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Жөнөтүү"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Жооп берүү"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS жөнөтүү"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Четке кагуу"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Видео чалуу түрүндө жооп берүү"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Аудио чалуу түрүндө жооп берүү"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Видео сурамын кабыл алуу"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Видео сурамын четке кагуу"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Видео өткөрүү сурамын кабыл алуу"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Видео өткөрүү сурамын четке кагуу"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Видео алуу сурамын кабыл алуу"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Видео алуу сурамын четке кагуу"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> үчүн жогору жылмыштырыңыз."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> үчүн солго жылмыштырыңыз."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> үчүн оңго жылмыштырыңыз."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> үчүн төмөн жылмыштырыңыз."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Дирилдөө"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Дирилдөө"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Үн"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Демейки үнү (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Телефондун рингтону"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Дирилдеп шыңгырасын"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Рингтон жана дирилдөө"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Конференц-чалууну башкаруу"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Өзгөчө кырдаал номери"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> секунд</item>
+      <item quantity="one">1 секунд</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> мүнөт</item>
+      <item quantity="one">1 мүнөт</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> саат</item>
+      <item quantity="one">1 саат</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Профилдин сүрөтү"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Камера өчүк"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> аркылуу"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Билдирүү жөнөтүлдү"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Акыркы билдирүүлөр"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Компания тууралуу маалымат"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> миля алыста"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> км алыста"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Эртең саат <xliff:g id="OPEN_TIME">%s</xliff:g> ачылат"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Бүгүн саат <xliff:g id="OPEN_TIME">%s</xliff:g> ачылат"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Саат <xliff:g id="CLOSE_TIME">%s</xliff:g> жабылат"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Бүгүн саат <xliff:g id="CLOSE_TIME">%s</xliff:g> жабылды"</string>
+    <string name="open_now" msgid="4615706338669555999">"Азыр ачык"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Эми жабылды"</string>
+</resources>
diff --git a/InCallUI/res/values-lo-rLA/strings.xml b/InCallUI/res/values-lo-rLA/strings.xml
new file mode 100644
index 0000000..eca3f52
--- /dev/null
+++ b/InCallUI/res/values-lo-rLA/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"ໂທລະສັບ"</string>
+    <string name="onHold" msgid="527593602772521700">"ຖືສາຍລໍຖ້າ"</string>
+    <string name="unknown" msgid="3646075119047488748">"ບໍ່ຮູ້ຈັກ"</string>
+    <string name="private_num" msgid="6081418498487514686">"ເບີສ່ວນຕົວ"</string>
+    <string name="payphone" msgid="5743050584468748607">"ຕູ້​ໂທ​ລະ​ສັບ​ສາ​ທາ​ລະ​ນະ"</string>
+    <string name="confCall" msgid="3181961445236675173">"ການປະຊຸມທາງໂທລະສັບ"</string>
+    <string name="call_lost" msgid="8208184291640961172">"ສາຍ​ຫຼຸດ​ແລ້ວ"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"ລຳໂພງ"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"ຊຸດຫູຟັງ"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"ຊຸດຫູຟັງແບບມີສາຍ"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"ສົ່ງໂທນສຽງຕໍ່ໄປນີ້ບໍ?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"ກຳລັງສົ່ງໂທນສຽງ\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"ສົ່ງ"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"ແມ່ນ"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"ບໍ່"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"ປ່ຽນແທນ \"ອັກຂະລະຕົວແທນ\" ດ້ວຍ"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"ການປະຊຸມທາງໂທລະສັບ <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"ເບີຂໍ້ຄວາມສຽງ"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"ກຳລັງໂທ"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"ກຳ​ລັງ​ໂທ​ຄືນ"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"ການປະຊຸມທາງໂທລະສັບ"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"​ສາຍ​ໂທ​ເຂົ້າ"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"ສາຍໂທເຂົ້າຈາກບ່ອນເຮັດວຽກ"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"ວາງສາຍແລ້ວ"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"ຖືສາຍລໍຖ້າ"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"ກຳລັງວາງສາຍ"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"ຢູ່ໃນສາຍ"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"ເບີໂທຂອງຂ້ອຍແມ່ນ <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"​ກຳ​ລັງ​ເຊື່ອມ​ຕໍ່​ວິ​ດີ​ໂອ"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"​ການໂທ​​ວິ​ດີ​ໂອ"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"​ກຳ​ລັງ​ຮ້ອງ​ຂໍການໂທ​ວິ​ດີ​ໂອ"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"ບໍ່​ສາ​ມາດ​ເຊື່ອມ​ຕໍ່​ການ​ໂທວິດີໂອ​ໄດ້"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"ປະ​ຕິ​ເສດ​ການຮ້ອງ​ຂໍການ​ໂທວິ​ດີ​ໂອ​ແລ້ວ"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"ເບີໂທກັບຂອງທ່ານ\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"ເບີ​ໂທ​ກັບ​ສຸກ​ເສີນ​ຂອງ​ທ່ານ\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"ກຳລັງໂທ"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"ສາຍບໍ່ໄດ້ຮັບ"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"ສາຍບໍ່ໄດ້ຮັບ"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ສາຍບໍ່ໄດ້ຮັບ"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"ສາຍບໍ່ໄດ້ຮັບຈາກ <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"ສາຍກຳລັງໂທ"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"ສາຍກຳລັງໂທຈາກບ່ອນເຮັດວຽກ"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"ສາຍກຳລັງໂທຜ່ານ Wi​-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"ສາຍກຳລັງໂທຜ່ານ Wi-Fi ຈາກບ່ອນເຮັດວຽກ"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"ຖືສາຍລໍຖ້າ"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"​ສາຍ​ໂທ​ເຂົ້າ"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"ສາຍໂທເຂົ້າຈາກບ່ອນເຮັດວຽກ"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"ສາຍໂທເຂົ້າຜ່ານ Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"ສາຍໂທເຂົ້າຜ່ານ Wi-Fi ຈາກບ່ອນເຮັດວຽກ"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"ສາຍໂທ​ວິດີໂອ​ເຂົ້າ"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"​ຄຳ​ຮ້ອງ​ຂໍ​ວິ​ດີ​ໂອທີ່​ເຂົ້າ​ມາ"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"ຂໍ້ຄວາມສຽງໃໝ່"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"ຂໍ້ຄວາມສຽງໃໝ່ (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"ໂທຫາ <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"ເບີຂໍ້ຄວາມສຽງບໍ່ຮູ້ຈັກ"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"ບໍ່ມີການບໍລິການ"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"ເຄືອຂ່າຍທີ່ເລືອກ (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) ບໍ່ສາມາດໃຊ້ໄດ້"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"ຮັບສາຍ"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"ວາງສາຍ"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"ວິດີໂອ"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"ສຽງ"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"ຍອມຮັບ"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"ປິດໄວ້"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"ໂທກັບ"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"ຂໍ້ຄວາມ"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"ເພື່ອເຮັດການໂທ, ໃຫ້ປິດໂໝດເຮືອບິນກ່ອນ"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"ບໍ່ໄດ້ລົງທະບຽນໃນເຄືອຂ່າຍ."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"ບໍ່​ມີ​ເຄືອ​ຂ່າຍ​ມື​ຖື​ທີ່​​ໃຊ້​ໄດ້."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"ເພື່ອເຮັດການ​ໂທ, ປ້ອນ​ເບີ​ໂທ​ທີ່​ໃຊ້​ໄດ້​."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"ບໍ່​ສາ​ມາດ​ໂທ​ໄດ້."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"ກຳລັງເລີ່ມຕົ້ນລຳດັບ MMI..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"ບໍ່ຮອງຮັບການ​ບໍ​ລິ​ການ."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"ບໍ່​ສາ​ມາດ​ສະ​ຫຼັບ​ສາ​ຍ​ໂທ​ໄດ້."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"ບໍ່​ສາ​ມາດ​ແຍກ​ສາຍ​ໂທ​ໄດ້."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"ບໍ່​ສາ​ມາດ​ໂອນສາຍ​ໄດ້."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"ບໍ່​ສາ​ມາດ​ປະ​ຊຸມ​ໄດ້."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"ບໍ່​ສາ​ມາດ​ປະ​ຕິ​ເສດ​ສາຍ​ໂທ​ໄດ້."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"ບໍ່​ສາ​ມາດ​ປ່ອຍ​ສາຍ​ໂທ​ໄດ້."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"ການໂທ SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"ການໂທສຸກເສີນ"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"ກຳລັງເປີດວິທະຍຸ"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"ບໍ່​ມີ​ການ​ບໍ​ລິ​ການ. ກຳ​ລັງ​ລອງ​ໃໝ່​ອີກ…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"ບໍ່ສາມາດໂທໄດ້. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> ບໍ່ແມ່ນເບີໂທສຸກເສີນ."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"ບໍ່​ສາ​ມາດ​ໂທ​ໄດ້. ກົດ​ເບີ​ໂທ​ສຸກ​ເສີນ."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ໃຊ້ແປ້ນພິມເພື່ອກົດໂທ"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"ຖືສາຍ"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"​ສືບ​ຕໍ່​ສາຍ"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"ວາງສາຍ"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"ແປ້ນກົດ"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"ປິດສຽງ"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"ເພີ່ມການໂທ"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"ລວມສາຍ"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"ສະຫຼັບ"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"ຈັດການການໂທ"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"ຈັດ​ການ​ການ​ປະ​ຊຸມ​ທາງໂທລະສັບ"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"ສຽງ"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"​ການໂທ​​ວິ​ດີ​ໂອ"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"ປ່ຽນ​ເປັນ​ການ​ໂທ​ດ້ວຍ​ສຽງ"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"ສັບປ່ຽນກ້ອງ"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"ຢຸດວິດີໂອຊົ່ວຄາວ"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"ຕົວເລືອກ​ເພີ່ມ​ເຕີມ"</string>
+    <string name="player_started" msgid="3478865572468310331">"ເຄື່ອງ​ຫຼິ້ນ​ເລີ່ມ​ຕົ້ນ​ແລ້ວ"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"ເຄື່ອງ​ຫຼິ້ນ​ຢຸດ​ແລ້ວ"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"ກ້ອງ​ຖ່າຍ​ຮູບ​ບໍ່​ພ້ອມ"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"ກ້ອງ​ຖ່າຍ​ຮູບ​ພ້ອມ​ແລ້ວ"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"ເຫດ​ການ​ເຊ​ສ​ຊັນ​ການ​ໂທ​ບໍ່​ຮູ້​ຈັກ"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"ການບໍລິການ"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"ຕັ້ງຄ່າ"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;ບໍ່ໄດ້ຕັ້ງ&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"ການຕັ້ງຄ່າການໂທອື່ນ"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"ກຳລັງໂທຜ່ານ <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"ສາຍໂທເຂົ້າ​ຈາກ <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"ຮູບລາຍຊື່ຜູ້ຕິດຕໍ່"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"ໃຊ້ແບບສ່ວນຕົວ"</string>
+    <string name="selectContact" msgid="92191462970821951">"ເລືອກລາຍຊື່ຜູ້ຕິດຕໍ່"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"ຂຽນ...ຂອງທ່ານເອງ"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"ຍົກເລີກ"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"ສົ່ງ"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"ຮັບສາຍ"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"ສົ່ງ SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"ປະຕິເສດ"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"ຮັບສາຍໂທວິດີໂອ"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"ຮັບສາຍໂທແບບສຽງ"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"ຍອມຮັບການຂໍວິດີໂອ"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"ປະຕິເສດການຂໍວິດີໂອ"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"ຍອມ​ຮັບ​ການ​ຂໍ​ສົ່ງ​ວິ​ດີ​ໂອ"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"ປະ​ຕິ​ເສດ​ການ​ຂໍ​ສົ່ງ​ວິ​ດີ​ໂອ"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"ຍອມ​ຮັບ​ການ​ຂໍ​ຮັບ​ວິ​ດີ​ໂອ"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"ປະ​ຕິ​ເສດ​ການ​ຂໍ​ຮັບ​ວິ​ດີ​ໂອ"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"ເລື່ອນຂຶ້ນເພື່ອ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"ເລື່ອນໄປຊ້າຍເພື່ອ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"ເລື່ອນໄປຂວາເພື່ອ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"ເລື່ອນລົງເພື່ອ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"ສັ່ນເຕືອນ"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"ສັ່ນເຕືອນ"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"ສຽງ"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"ສຽງເລີ່ມຕົ້ນ (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"ຣິງໂທນໂທລະສັບ"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"ສັ່ນເຕືອນເມື່ອດັງ"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"ຣິງໂທນ ແລະ ການສັ່ນເຕືອນ"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"ຈັດ​ການ​ການ​ປະ​ຊຸມ​ທາງໂທລະສັບ"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"ເບີໂທສຸກເສີນ"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ວິນາທີ</item>
+      <item quantity="one">1 ວິນາທີ</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ນາທີ</item>
+      <item quantity="one">1 ນາທີ</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ຊົ່ວໂມງ</item>
+      <item quantity="one">1 ຊົ່ວໂມງ</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"ຮູບໂປຣໄຟລ໌"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"ກ້ອງ​ຖ່າຍ​ຮູບ​ປິດຢູ່"</string>
+    <string name="child_number" msgid="4469090994612105532">"ຜ່ານ <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"ສົ່ງ​ບັນ​ທຶກ​ແລ້ວ"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"ຂໍ້​ຄວາມ​ບໍ່​ດົນ​ມາ​ນີ້"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"ຂໍ້​ມູນ​ທຸ​ລະ​ກິດ"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"ຫ່າງອອກໄປ <xliff:g id="DISTANCE">%.1f</xliff:g> ໄມ​ລ໌​"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"ຫ່າງອອກໄປ <xliff:g id="DISTANCE">%.1f</xliff:g> ກມ"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"ເປີດມື້ອື່ນເວລາ <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"ເປີດມື້ນີ້ເວລາ <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"ປິດເວລາ <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"ປິດແລ້ວມື້ນີ້ເວລາ <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"ດຽວ​ນີ້​ເປີດ"</string>
+    <string name="closed_now" msgid="2635314668145282080">"​ປິດ​ແລ້ວດຽວນີ້"</string>
+</resources>
diff --git a/InCallUI/res/values-lt/strings.xml b/InCallUI/res/values-lt/strings.xml
new file mode 100644
index 0000000..9c27a37
--- /dev/null
+++ b/InCallUI/res/values-lt/strings.xml
@@ -0,0 +1,198 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefonas"</string>
+    <string name="onHold" msgid="527593602772521700">"Sulaikyta"</string>
+    <string name="unknown" msgid="3646075119047488748">"Nežinoma"</string>
+    <string name="private_num" msgid="6081418498487514686">"Privatus numeris"</string>
+    <string name="payphone" msgid="5743050584468748607">"Taksofonas"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferencinis skambutis"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Skambutis atmestas"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Garsiakalbis"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Tel. su gars. prie ausies"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Laidinės ausinės"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Siųsti šiuo tonus?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Siunčiami tonai\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Siųsti"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Taip"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Ne"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Pakaitos simbolį pakeisti"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferencinis skambutis <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Balso pašto numeris"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Renkamas numeris"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Numeris renkamas pakartotinai"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferencinis skambutis"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Gaunamasis skambutis"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Gaunamasis darbo skambutis"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Skambutis baigtas"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Sulaikyta"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Baigiamas pokalbis"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Dalyvauju skambutyje"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mano numeris: <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Prisijungiama prie vaizdo skambučio"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Vaizdo skambutis"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Pateikiama vaizdo skambučio užklausa"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Nepavyko prijungti vaizdo įrašo skambučio"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Vaizdo įrašo užklausa atmesta"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Atskambinimo numeris\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Atskambinimo numeris, kuriuos skambina pagalbos tarnyba\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Renkamas numeris"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Praleistas skambutis"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Praleisti skambučiai"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"Praleistų skambučių: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Praleistas skambutis nuo <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Vykstantis pokalbis"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Vykstantis darbo skambutis"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Vykstantis „Wi-Fi“ skambutis"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Vykstantis „Wi-Fi“ darbo skambutis"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Sulaikyta"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Gaunamasis skambutis"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Gaunamasis darbo skambutis"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Gaunamasis „Wi-Fi“ skambutis"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Gaunamasis „Wi-Fi“ darbo skambutis"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Gaunamas vaizdo skambutis"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Gaunama vaizdo skambučio užklausa"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Naujas balso pašto pranešimas"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Naujas balso pašto pranešimas (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Rinkti <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Nežinomas balso pašto numeris"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Nėra paslaugos"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Pasirinktas tinklas (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) negalimas"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Atsiliepti"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Padėti ragelį"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Vaizdo įrašas"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Balsas"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Priimti"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Atsisakyti"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Perskambinti"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Siųsti pranešimą"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Jei norite skambinti, išjunkite lėktuvo režimą."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Neregistruota tinkle."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Korinis tinklas nepasiekiamas"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Kad galėtumėte paskambinti, įveskite tinkamą numerį."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Nepavyko paskambinti."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Paleidžiama MMI seka..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Paslauga nepalaikoma."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Nepavyko perjungti skambučių."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Nepavyko atskirti skambučio."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Nepavyko peradresuoti."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Nepavyko sukurti konferencijos."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Nepavyko atmesti skambučio."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Nepavyko atjungti skamb."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP skambutis"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Skambutis pagalbos numeriu"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Įjungiamas radijas…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Nėra ryšio. Bandoma dar kartą…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Nepavyko paskambinti. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> nėra pagalbos numeris."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Nepavyko paskambinti. Surinkite pagalbos tarnybos numerį."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Naudokite klaviatūrą ir rinkite numerius"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Sulaikyti skambutį"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Tęsti skambutį"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Baigti skambutį"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Numerio rinkimo klaviatūra"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Paslėpti"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Pridėti skambutį"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Sujungti skambučius"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Apkeisti"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Valdyti skambučius"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Tvarkyti konferencinį skambutį"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Garsas"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Vaizdo skambutis"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Pakeisti į balso skambutį"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Perjungti fotoaparatą"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pristabdyti vaizdo įrašą"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Daugiau parinkčių"</string>
+    <string name="player_started" msgid="3478865572468310331">"Leistuvė paleista"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Leistuvė sustabdyta"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Fotoaparatas neparuoštas"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Fotoaparatas paruoštas"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Nežinomas skambučio sesijos įvykis"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Paslauga"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Sąranka"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Nenustatyta&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Kiti skambučio nustatymai"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Skambinama naudojantis „<xliff:g id="PROVIDER_NAME">%s</xliff:g>“ paslaugomis"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Gaunama per „<xliff:g id="PROVIDER_NAME">%s</xliff:g>“"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"kontakto nuotrauka"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"naudoti privatų režimą"</string>
+    <string name="selectContact" msgid="92191462970821951">"pasirinkti kontaktą"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Sukurkite patys..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Atšaukti"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Siųsti"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Atsiliepti"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Siųsti SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Atmesti"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Atsiliepti kaip į vaizdo skambutį"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Atsiliepti kaip į garso skambutį"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Priimti vaizdo įrašo užkl"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Atmesti vaizdo įrašo užklausą"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Priimti vaizdo įrašo perdavimo užklausą"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Atmesti vaizdo įrašo perdavimo užklausą"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Priimti vaizdo įrašo gavimo užklausą"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Atmesti vaizdo įrašo gavimo užklausą"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Slyskite aukštyn link parinkties „<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>“."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Slyskite į kairę link parinkties „<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>“."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Slyskite į dešinę link parinkties „<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>“."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Slyskite žemyn link <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibruoti"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibruoti"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Garsas"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Numatytasis garsas (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Telefono skambėjimo tonas"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibruoti, kai skambina"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Skambėjimo tonas ir vibracija"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Tvarkyti konferencinį skambutį"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Pagalbos numeris"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> sekundė</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> sekundės</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> sekundės</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekundžių</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> minutė</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> minutės</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> minutės</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minučių</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> valanda</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> valandos</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> valandos</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> valandų</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profilio nuotrauka"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Fotoaparatas išjungtas"</string>
+    <string name="child_number" msgid="4469090994612105532">"naudojant <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Užrašas išsiųstas"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Naujausi pranešimai"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Įmonės informacija"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"Už <xliff:g id="DISTANCE">%.1f</xliff:g> myl."</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"Už <xliff:g id="DISTANCE">%.1f</xliff:g> km"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>–<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Rytoj atidaroma <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Šiandien atidaroma <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Uždaroma <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Šiandien uždaryta <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Dabar atidaryta"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Dabar uždaryta"</string>
+</resources>
diff --git a/InCallUI/res/values-lv/strings.xml b/InCallUI/res/values-lv/strings.xml
new file mode 100644
index 0000000..f2f6d99
--- /dev/null
+++ b/InCallUI/res/values-lv/strings.xml
@@ -0,0 +1,195 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Tālrunis"</string>
+    <string name="onHold" msgid="527593602772521700">"Aizturēts"</string>
+    <string name="unknown" msgid="3646075119047488748">"Nezināms"</string>
+    <string name="private_num" msgid="6081418498487514686">"Privāts numurs"</string>
+    <string name="payphone" msgid="5743050584468748607">"Maksas tālrunis"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferences zvans"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Zvans tika pārtraukts."</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Skaļrunis"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Auss skaļrunis"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Austiņas ar vadu"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Vai sūtīt tālāk norādītos signālus?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Sūtīšanas signāli\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Sūtīt"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Jā"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Nē"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Aizstāt aizstājējzīmi ar:"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferences zvans: <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Balss pasta numurs"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Notiek numura sastādīšana"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Notiek atkārtota zvanīšana"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferences zvans"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Ienākošs zvans"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Ienākošs darba zvans"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Zvans ir pabeigts"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Aizturēts"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Notiek klausules nolikšana"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Notiek zvans"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mans tālruņa numurs: <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Notiek video savienojuma izveide"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videozvans"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Notiek video pieprasīšana"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Nevar veikt videozvanu"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Video pieprasījums noraidīts"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Jūsu atzvana numurs\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Jūsu ārkārtas atzvana numurs\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Notiek numura sastādīšana"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Neatbildēts zvans"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Neatbildēti zvani"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> neatbildēti zvani"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Neatbildēts zvans no: <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Notiekošs zvans"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Notiekošs darba zvans"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Notiekošs Wi-Fi zvans"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Notiekošs darba Wi-Fi zvans"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Aizturēts"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Ienākošs zvans"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Ienākošs darba zvans"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Ienākošs Wi-Fi zvans"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Ienākošs darba Wi-Fi zvans"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Ienākošs videozvans"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Ienākošs video pieprasījums"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Jauns balss pasta ziņojums"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Jauns balss pasts (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Sastādiet šādu numuru: <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Balss pasta numurs nav zināms."</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Nav pakalpojuma"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Atlasītais tīkls (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) nav pieejams."</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Atbildēt"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Beigt zvanu"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Balss"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Pieņemt"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Noraidīt"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Atzvanīt"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Sūtīt īsziņu"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Lai veiktu zvanu, vispirms izslēdziet lidojuma režīmu."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Nav reģistrēts tīklā."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobilais tīkls nav pieejams."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Lai veiktu zvanu, ievadiet derīgu numuru."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Nevar veikt zvanu."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Notiek MMI secības startēšana…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Pakalpojums netiek atbalstīts."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Nevar pārslēgt zvanus."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Nevar nošķirt zvanu."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Nevar pārsūtīt."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Nevar veikt konferences zvanu."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Nevar noraidīt zvanu."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Nevar pārtraukt zvanu(-us)."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP zvans"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Ārkārtas izsaukums"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Notiek radio ieslēgšana…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Nav pakalpojuma. Notiek atkārtots mēģinājums…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Nevar veikt zvanu. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> nav ārkārtas numurs."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Nevar veikt zvanu. Zvaniet ārkārtas numuram."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Izmantojiet tastatūru, lai sastādītu numuru"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Aizturēt zvanu"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Atsākt zvanu"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Beigt zvanu"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Numura sastādīšanas tastatūra"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Izslēgt skaņu"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Pievienot zvanu"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Apvienot zvanus"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Mainīt"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Pārvaldīt zvanus"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Pārvaldīt konferences zvanu"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videozvans"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Mainīt uz balss zvanu"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Pārslēgt kameru"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pārtraukt video plūsmu"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Citas iespējas"</string>
+    <string name="player_started" msgid="3478865572468310331">"Atskaņošana sākta"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Atskaņošana apturēta"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera nav gatava"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera ir gatava"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Nezināms zvana sesijas notikums"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Pakalpojums"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Iestatīšana"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Nav iestatīts&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Citi zvanu iestatījumi"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Zvans, ko nodrošina <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Ienākošie zvani, ko nodrošina <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"kontaktpersonas fotoattēls"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"pārslēgt uz privāto režīmu"</string>
+    <string name="selectContact" msgid="92191462970821951">"atlasīt kontaktpersonu"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Rakstīt savu…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Atcelt"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Sūtīt"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Atbildēt"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Sūtīt īsziņu"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Noraidīt"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Atbildēt videozvanā"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Atbildēt audiozvanā"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Apstiprināt video pieprasījumu"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Noraidīt video pieprasījumu"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Apstiprināt video pārsūtīšanas pieprasījumu"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Noraidīt video pārsūtīšanas pieprasījumu"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Apstiprināt video saņemšanas pieprasījumu"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Noraidīt video saņemšanas pieprasījumu"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Velciet uz augšu, lai veiktu šādu darbību: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Velciet pa kreisi, lai veiktu šādu darbību: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Velciet pa labi, lai veiktu šādu darbību: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Velciet uz leju, lai veiktu šādu darbību: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrācija"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrācija"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Signāls"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Noklusējuma signāls (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Tālruņa zvana signāls"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrācija zvana laikā"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Zvana signāls un vibrācija"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Konferences zvana pārvaldība"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Ārkārtas numurs"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="zero"><xliff:g id="COUNT">%d</xliff:g> sekunžu</item>
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> sekunde</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekundes</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="zero"><xliff:g id="COUNT">%d</xliff:g> minūšu</item>
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> minūte</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minūtes</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="zero"><xliff:g id="COUNT">%d</xliff:g> stundu</item>
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> stunda</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> stundas</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profila fotoattēls"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera ir izslēgta"</string>
+    <string name="child_number" msgid="4469090994612105532">"no numura <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Piezīme nosūtīta"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Pēdējie ziņojumi"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informācija par uzņēmumu"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> jūdzes(-džu) attālumā"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km attālumā"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>–<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Tiks atvērts rīt plkst. <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Tiks atvērts šodien plkst. <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Tiks slēgts plkst. <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Tika slēgts šodien plkst. <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Atvērts"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Slēgts"</string>
+</resources>
diff --git a/InCallUI/res/values-mk-rMK/strings.xml b/InCallUI/res/values-mk-rMK/strings.xml
new file mode 100644
index 0000000..59f25b5
--- /dev/null
+++ b/InCallUI/res/values-mk-rMK/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Телефон"</string>
+    <string name="onHold" msgid="527593602772521700">"На чекање"</string>
+    <string name="unknown" msgid="3646075119047488748">"Непознат"</string>
+    <string name="private_num" msgid="6081418498487514686">"Приватен број"</string>
+    <string name="payphone" msgid="5743050584468748607">"Говорница"</string>
+    <string name="confCall" msgid="3181961445236675173">"Конференциски повик"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Повикот е прекинат"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Звучник"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Слушалка"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Жичени слушалки"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Испратете ги следниве тонови?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Се испраќаат тонови\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Испрати"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Да"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Не"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Заменете го резервниот знак со"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Конференциски повик <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Број на говорна пошта"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Бирање"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Повторно бирање"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Конференциски повик"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Дојдовен повик"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Дојдовен работен повик"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Повикот заврши"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"На чекање"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Повикот се прекинува"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Повик во тек"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Мојот број е <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Се поврзува видео"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Видеоповик"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Се бара видео"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Не може да се поврзе видеоповик"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Барањето за видео е одбиено"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Вашиот број за повратен повик\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Вашиот број за итен повик\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Бирање"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Пропуштен повик"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Пропуштени повици"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> пропуштени повици"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Пропуштен повик од <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Тековен повик"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Тековен работен повик"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Појдовен повик преку Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Тековен работен повик преку Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"На чекање"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Дојдовен повик"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Дојдовен работен повик"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Дојдовен повик преку Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Дојдовен работен повик преку Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Дојдовен видеоповик"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Дојдовно барање за видео"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Нова говорна пошта"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Нова говорна пошта (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Бирај <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Непознат број на говорна пошта"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Нема услуга"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Избраната мрежа (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) е недостапна"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Одговори"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Спушти"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Видео"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Гласовен"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Прифати"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Отфрли"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Врати повик"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Порака"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"За да остварите повик, прво исклучете го авионскиот режим."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Не е регистриран на мрежа."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Не е достапна мобилна мрежа."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"За да остварите повик, внесете важечки број."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Не може да се повика."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Започнува ММИ низа..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Услугата не е поддржана."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Не може да се префрлат повици."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Не може да се оддели повик."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Не може да се пренесе."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Не може да се оствари конференциски повик."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Не може да се отфрли повик."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Не може да се оствари повик."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Повик преку СИП"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Повик за итни случаи"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Се вклучува радиото..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Нема услуга. Се обидува повторно…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Не може да се повика. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> не е број за итни повици."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Не може да се повика. Бирајте го бројот за итни повици."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Користете ја тастатурата за бирање"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Стави на чекање"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Продолжи го повикот"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Заврши го повикот"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Тастатура за бирање"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Исклучи звук"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Додај повик"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Спои повици"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Замени"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Управувај со повици"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Управувај со конференциски повик"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Аудио"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Видеоповик"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Промени во гласовен повик"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Промени ја камерата"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Паузирај видео"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Повеќе опции"</string>
+    <string name="player_started" msgid="3478865572468310331">"Плеерот се вклучи"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Плеерот запре"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Камерата не е подготвена"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Камерата е подготвена"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Непознат настан при сесија повици"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Услуга"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Поставување"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Не е поставен&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Други поставки за повик"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Повикување преку <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Дојдовни повици преку <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"фотографија на контакт"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"префли на приватно"</string>
+    <string name="selectContact" msgid="92191462970821951">"избери контакт"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Напиши сопствена..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Откажи"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Испрати"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Одговори"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Испрати СМС"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Одбиј"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Одговори со видеоповик"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Одговори со аудиоповик"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Прифати барање за видео"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Одбиј барање за видео"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Прифати барање за пренос на видео"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Одбиј барање за пренос на видео"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Прифати барање за прием на видео"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Одбиј барање за прием на видео"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Лизгај нагоре за <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Лизгај налево за <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Лизгај надесно за <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Лизгај надолу за <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Вибрации"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Вибрации"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Звук"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Стандарден звук (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Мелодија на телефонот"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Вибрации при ѕвонење"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Мелодија и вибрации"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Управувај со конференциски повик"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Број за итни случаи"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> секунда</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> секунди</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> минута</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> минути</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> час</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> часа</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Фотографија на профилот"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Камерата е исклучена"</string>
+    <string name="child_number" msgid="4469090994612105532">"преку <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Испратена е белешка"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Неодамнешни пораки"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Деловни информации"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"Оддалечено <xliff:g id="DISTANCE">%.1f</xliff:g> милји"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"Оддалечено <xliff:g id="DISTANCE">%.1f</xliff:g> км"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Отвора утре во <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Отвора денес во <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Затвора во <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Денес затвори во <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Сега е отворено"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Сега е затворено"</string>
+</resources>
diff --git a/InCallUI/res/values-ml-rIN/strings.xml b/InCallUI/res/values-ml-rIN/strings.xml
new file mode 100644
index 0000000..e3b59e7
--- /dev/null
+++ b/InCallUI/res/values-ml-rIN/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"ഫോൺ"</string>
+    <string name="onHold" msgid="527593602772521700">"ഹോൾഡിലാണ്"</string>
+    <string name="unknown" msgid="3646075119047488748">"അജ്ഞാതം"</string>
+    <string name="private_num" msgid="6081418498487514686">"സ്വകാര്യ നമ്പർ"</string>
+    <string name="payphone" msgid="5743050584468748607">"പണം നൽകി ഉപയോഗിക്കുന്ന ഫോൺ"</string>
+    <string name="confCall" msgid="3181961445236675173">"കോൺഫറൻസ് കോൾ"</string>
+    <string name="call_lost" msgid="8208184291640961172">"കോൾ വിട്ടു"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"സ്പീക്കർ"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"ഹാൻഡ്‌സെറ്റ് ഇയർപീസ്"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"വയേർഡ് ഹെഡ്സെറ്റ്"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"ഇനിപ്പറയുന്ന ടോണുകൾ അയയ്‌ക്കണോ?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"ടോണുകൾ അയയ്‌ക്കുന്നു\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"അയയ്‌ക്കുക"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"ഉവ്വ്"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"ഇല്ല"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"വൈൽഡ് പ്രതീകം ഇതുപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"കോൺഫറൻസ് കോൾ <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"വോയ്‌സ്‌മെയിൽ നമ്പർ"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"ഡയൽ ചെയ്യുന്നു"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"വീണ്ടും ഡയൽചെയ്യുന്നു"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"കോൺഫറൻസ് കോൾ"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"ഇൻകമിംഗ് കോൾ"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"ഇൻകമിംഗ് ഔദ്യോഗിക കോൾ"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"കോൾ അവസാനിച്ചു"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"ഹോൾഡിലാണ്"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"ഹാംഗ് അപ്പ് ചെയ്യുന്നു"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"കോളിലാണ്"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"എന്റെ നമ്പർ <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g> ആണ്"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"വീഡിയോ കണക്‌റ്റുചെയ്യുന്നു"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"വീഡിയോ കോൾ"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"വീഡിയോ അഭ്യർത്ഥിക്കുന്നു"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"വീഡിയോ കോളുമായി കണക്‌റ്റുചെയ്യാനാവില്ല"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"വീഡിയോ അഭ്യർത്ഥന നിരസിച്ചു"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"നിങ്ങൾ തിരിച്ചുവിളിക്കേണ്ട നമ്പർ\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"അടിയന്തിരമായി നിങ്ങൾ തിരിച്ചുവിളിക്കേണ്ട നമ്പർ\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"ഡയൽ ചെയ്യുന്നു"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"മിസ്‌ഡ് കോൾ"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"മിസ്‌ഡ് കോളുകൾ"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> മിസ്‌ഡ് കോളുകൾ"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> എന്നതിൽ നിന്നുള്ള മിസ്‌ഡ് കോൾ"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"കോൾ സജീവമാണ്"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"ഓൺഗോയിംഗ് ഔദ്യോഗിക കോൾ"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"ഓൺഗോയിംഗ് വൈഫൈ കോൾ"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"ഓൺഗോയിംഗ് വൈഫൈ ഔദ്യോഗിക കോൾ"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"ഹോൾഡിലാണ്"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"ഇൻകമിംഗ് കോൾ"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"ഇൻകമിംഗ് ഔദ്യോഗിക കോൾ"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"ഇൻകമിംഗ് വൈഫൈ കോൾ"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"ഇൻകമിംഗ് വൈഫൈ ഔദ്യോഗിക കോൾ"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"ഇൻകമിംഗ് വീഡിയോ കോൾ"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"ഇൻകമിംഗ് വീഡിയോ അഭ്യർത്ഥന"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"പുതിയ വോയ്‌സ്‌മെയിൽ"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"പുതിയ വോയ്‌സ്‌മെയിൽ (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> ഡയൽ ചെയ്യുക"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"വോയ്‌സ്‌മെയിൽ നമ്പർ അജ്ഞാതമാണ്"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"സേവനമില്ല"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"തിരഞ്ഞെടുത്ത നെറ്റ്‌വർക്ക് (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) ലഭ്യമല്ല"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"മറുപടി"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"ഹാംഗ് അപ്പുചെയ്യുക"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"വീഡിയോ"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"വോയ്‌സ്"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"അംഗീകരിക്കുക"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"ഡിസ്മിസ്"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"തിരിച്ചുവിളിക്കുക"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"സന്ദേശം"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"ഒരു കോൾ ചെയ്യാൻ, ആദ്യം ഫ്ലൈറ്റ് മോഡ് ഓഫുചെയ്യുക."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"നെറ്റ്‌വർക്കിൽ രജിസ്റ്റർ ചെയ്‌തിട്ടില്ല."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"സെല്ലുലാർ നെറ്റ്‌വർക്ക് ലഭ്യമല്ല."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"ഒരു കോൾ ചെയ്യുന്നതിന്, സാധുതയുള്ള നമ്പർ നൽകുക."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"കോൾ ചെയ്യാനായില്ല."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI സീക്വൻസ് ആരംഭിക്കുന്നു…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"സേവനം പിന്തുണയ്‌ക്കുന്നില്ല."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"കോളുകൾ മാറാനാവില്ല."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"കോൾ വേർതിരിക്കാനാവില്ല."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"കൈമാറ്റം ചെയ്യാനാവില്ല."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"കോൺഫറൻസ് കോൾ ചെയ്യാനാവില്ല."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"കോൾ നിരസിക്കാനാവില്ല."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"കോൾ (കോളുകൾ) വിളിക്കാനാവില്ല."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP കോൾ"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"എമർജൻസി കോൾ"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"റേഡിയോ ഓൺ ചെയ്യുന്നു…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"സേവനമൊന്നുമില്ല. വീണ്ടും ശ്രമിക്കുന്നു…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"കോൾ ചെയ്യാനാവില്ല. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> എന്നത് ഒരു അടിയന്തിര നമ്പറല്ല."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"കോൾ ചെയ്യാനാവില്ല. ഒരു അടിയന്തിര കോൾ നമ്പർ ഡയൽചെയ്യുക."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ഡയൽ ചെയ്യാൻ കീബോർഡ് ഉപയോഗിക്കുക"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"കോൾ ഹോൾഡുചെയ്യുക"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"കോൾ പുനരാരംഭിക്കുക"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"കോൾ അവസാനിപ്പിക്കുക"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"ഡയൽപാഡ്"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"മ്യൂട്ടുചെയ്യുക"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"കോൾ ചേർക്കുക"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"കോളുകൾ ലയിപ്പിക്കുക"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"സ്വാപ്പുചെയ്യുക"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"കോളുകൾ നിയന്ത്രിക്കുക"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"കോൺഫറൻസ് കോൾ നിയന്ത്രിക്കുക"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"ഓഡിയോ"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"വീഡിയോ കോൾ"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"വോയ്‌സ്‌ കോളിലേക്ക് മാറ്റുക"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"ക്യാമറ സ്വിച്ചുചെയ്യുക"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"വീഡിയോ താൽക്കാലികമായി നിർത്തുക"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"കൂടുതൽ ഓ‌പ്‌ഷനുകൾ"</string>
+    <string name="player_started" msgid="3478865572468310331">"പ്ലെയർ ആരംഭിച്ചു"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"പ്ലേയർ നിർത്തി"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"ക്യാമറ തയ്യാറായില്ല"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"ക്യാമറ തയ്യാറായി"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"അജ്ഞാത കോൾ സെഷൻ ഇവന്റ്"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"സേവനം"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"സജ്ജമാക്കുക"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;ക്രമീകരിച്ചിട്ടില്ല&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"മറ്റ് കോൾ ക്രമീകരണം"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> മുഖേന വിളിക്കുന്നു"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> മുഖേനയുള്ള ഇൻകമിംഗ്"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"കോൺടാക്റ്റ് ഫോട്ടോ"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"സ്വകാര്യം എന്നതിലേക്ക് പോകുക"</string>
+    <string name="selectContact" msgid="92191462970821951">"കോൺടാക്റ്റ് തിരഞ്ഞെടുക്കുക"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"നിങ്ങളുടെ സ്വന്തം സന്ദേശമെഴുതുക..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"റദ്ദാക്കുക"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"അയയ്‌ക്കുക"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"മറുപടി"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS അയയ്ക്കുക"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"നിരസിക്കുക"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"വീഡിയോ കോളായി മറുപടി നൽകുക"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"ഓഡിയോ കോളായി മറുപടി നൽകുക"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"വീഡിയോ കോളിനുള്ള അഭ്യർത്ഥന അംഗീകരിക്കുക"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"വീഡിയോ കോൾ അഭ്യർത്ഥന നിരസിക്കുക"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"വീഡിയോ പ്രക്ഷേപണ അഭ്യർത്ഥന അംഗീകരിക്കുക"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"വീഡിയോ പ്രക്ഷേപണ അഭ്യർത്ഥന നിരസിക്കുക"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"വീഡിയോ കോൾ സ്വീകരിക്കാനുള്ള അഭ്യർത്ഥന അംഗീകരിക്കുക"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"വീഡിയോ കോൾ സ്വീകരിക്കാനുള്ള അഭ്യർത്ഥന നിരസിക്കുക"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> എന്നതിനായി മുകളിലേയ്‌ക്ക് സ്ലൈഡുചെയ്യുക."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> എന്നതിനായി ഇടത്തേയ്‌ക്ക് സ്ലൈഡുചെയ്യുക."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> എന്നതിനായി വലത്തേയ്‌ക്ക് സ്ലൈഡുചെയ്യുക."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> എന്നതിനായി താഴേക്ക് സ്ലൈഡുചെയ്യുക."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"വൈബ്രേറ്റുചെയ്യുക"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"വൈബ്രേറ്റുചെയ്യുക"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"ശബ്‌ദം"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"സ്ഥിര ശബ്‌ദം (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"ഫോൺ റിംഗ്ടോൺ"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"റിംഗുചെയ്യുമ്പോൾ വൈബ്രേറ്റുചെയ്യുക"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"റിംഗ്ടോണും വൈബ്രേറ്റുചെയ്യലും"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"കോൺഫറൻസ് കോൾ നിയന്ത്രിക്കുക"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"അടിയന്തര നമ്പർ"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> സെക്കൻഡ്</item>
+      <item quantity="one">ഒരു സെക്കൻഡ്</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> മിനിറ്റ്</item>
+      <item quantity="one">ഒരു മിനിറ്റ്</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> മണിക്കൂർ</item>
+      <item quantity="one">ഒരു മണിക്കൂർ</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"പ്രൊഫൈൽ ഫോട്ടോ"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"ക്യാമറ ഓഫാക്കുക"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> വഴി"</string>
+    <string name="note_sent" msgid="7623014827902758398">"കുറിപ്പ് അയച്ചു"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"ഏറ്റവും പുതിയ സന്ദേശങ്ങൾ"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"ബിസിനസ്സ് വിവരം"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> മൈൽ അകലെ"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> കിലോമീറ്റർ അകലെ"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"നാളെ <xliff:g id="OPEN_TIME">%s</xliff:g>-ന് തുറക്കുന്നു"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"ഇന്ന് <xliff:g id="OPEN_TIME">%s</xliff:g>-ന് തുറക്കുന്നു"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g>-ന് അടയ്ക്കുന്നു"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"ഇന്ന് <xliff:g id="CLOSE_TIME">%s</xliff:g>-ന് അടച്ചു"</string>
+    <string name="open_now" msgid="4615706338669555999">"ഇപ്പോൾ തുറന്നിരിക്കുന്നു"</string>
+    <string name="closed_now" msgid="2635314668145282080">"ഇപ്പോൾ അടച്ചിരിക്കുന്നു"</string>
+</resources>
diff --git a/InCallUI/res/values-mn-rMN/strings.xml b/InCallUI/res/values-mn-rMN/strings.xml
new file mode 100644
index 0000000..9f78ac6
--- /dev/null
+++ b/InCallUI/res/values-mn-rMN/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Утас"</string>
+    <string name="onHold" msgid="527593602772521700">"Хүлээлгэнд байгаа"</string>
+    <string name="unknown" msgid="3646075119047488748">"Тодорхойгүй"</string>
+    <string name="private_num" msgid="6081418498487514686">"Нууцалсан дугаар"</string>
+    <string name="payphone" msgid="5743050584468748607">"Төлбөртэй утас"</string>
+    <string name="confCall" msgid="3181961445236675173">"Хурлын дуудлага"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Дуудлага таслагдсан"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Чанга яригч"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Утасны чихэвч"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Утастай чихэвч"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Дараах аяыг илгээх үү?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Ая илгээж байна\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Илгээх"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Тийм"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Үгүй"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Тэмдэгтийг дараахаар солих"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Хурлын дуудлага <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Дуут шуудангийн дугаар"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Залгаж байна"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Дахин залгаж байна"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Хурлын дуудлага"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Орох дуудлага"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Орох ажлын дуудлага"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Дуудлага дууссан"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Хүлээлгэнд"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Тасалж байна"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Дуудлагатай"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Миний дугаар <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Видеог холбож байна"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Видео дуудлага"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Видео хүлээж байна"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Видео дуудлагад холбогдож чадсангүй"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Бичлэг хийх хүсэлтийг зөвшөөрсөнгүй"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Таны буцаан залгах дугаар\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Таны яаралтай хулээн авах дугаар\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Залгаж байна"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Аваагүй дуудлага"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Аваагүй дуудлага"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> аваагүй дуудлага"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g>-н аваагүй дуудлага"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Залгаж буй дуудлага"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Холбогдсон албаны дуудлага"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Холбогдсон Wi-Fi дуудлага"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Залгаж буй Wi-Fi албаны дуудлага"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Хүлээгдэж байна"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Орох дуудлага"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Орох ажлын дуудлага"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Орох Wi-Fi дуудлага"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Орох Wi-Fi албаны дуудлага"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Орох видео дуудлага"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Орох видео хүсэлт"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Шинэ дуут шуудан"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Шинэ дуут шуудан (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> руу залгах"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Дуут шуудангийн дугаар тодорхойгүй"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Үйлчилгээ байхгүй"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Сонгосон сүлжээг (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) ашиглах боломжгүй"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Хариулт"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Таслах"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Видео"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Дуу хоолой"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Зөвшөөрөх"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Алгасах"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Буцааж залгах"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Зурвас"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Залгахын тулд эхлээд Нислэгийн горимоос гарна уу."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Сүлжээнд бүртгэгдээгүй байна."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Үүрэн сүлжээ байхгүй."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Залгахын тулд хүчин төгөлдөр дугаар оруулна уу."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Залгах боломжгүй байна."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI дарааллыг эхлүүлж байна…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Дэмжигдээгүй үйлчилгээ байна."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Дуудлагыг солих боломжгүй байна."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Дуудлагыг салгаж чадахгүй байна."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Шилжүүлэх боломжгүй байна."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Хурлын дуудлага хийх боломжгүй байна."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Дуудлагыг цуцлах боломжгүй байна."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Дуудлага чөлөөлөх боломжгүй байна."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP дуудлага"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"яаралтай"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Радиог асааж байна..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Ажиллагаагүй байна. Дахин оролдоно уу..."</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Залгах боломжгүй. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> нь яаралтай дугаар биш байна."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Залгах боломжгүй. Яаралтай дугаар луу залгана уу."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Залгахдаа гар ашиглана уу"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Дуудлага хүлээлгэх"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Дуудлагыг үргэлжлүүлэх"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Дуудлагыг дуусгах"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Залгах товчлуур"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Дуу хаах"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Дуудлага нэмэх"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Дуудлага нэгтгэх"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Солих"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Дуудлага удирдах"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Хурлын дуудлага удирдах"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Аудио"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Видео дуудлага"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Дуут дуудлага руу өөрчлөх"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Камер солих"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Видеог түр зогсоох"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Нэмэлт сонголт"</string>
+    <string name="player_started" msgid="3478865572468310331">"Тоглуулагчийг эхлүүлсэн"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Тоглуулагчийг зогсоосон"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Камер бэлэн бус байна"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Камер бэлэн байна"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Үл мэдэгдэх дуудлагын үе"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Үйлчилгээ"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Тохируулга"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"Тохируулаагүй"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Бусад дуудлагын тохиргоо"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g>-р залгаж байна"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g>-р ирж байна"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"харилцагчийн зураг"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"хувийн яриа"</string>
+    <string name="selectContact" msgid="92191462970821951">"харилцагч сонгох"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Өөрийн ...-г бичээрэй"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Цуцлах"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Илгээх"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Хариулт"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS илгээх"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Татгалзах"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Видео дуудлагаар хариулах"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Аудио дуудлагаар хариулах"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Видео хүсэлтийг хүлээн зөвшөөрөх"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Видео хүсэлтээс татгалзах"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Видео дамжуулах хүсэлтийг хүлээн зөвшөөрөх"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Видео дамжуулах хүсэлтээс татгалзах"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Видео хүлээж авах хүсэлтийг зөвшөөрөх"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Видео хүлээн авах хүсэлтээс татгалзах"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> хийх бол дээш гулсуулна уу."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>-г харахын тулд зүүн тийш гулсуулна уу."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> харахын тулд баруун тийш гулсуулна уу."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>-г харахын тулд доош гулсуулна уу."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Чичиргээ"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Чичиргээ"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Дуу"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Үндсэн дуу (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Утасны хонхны ая"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Хонх дуугарах үед чичрэх"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Хонхны ая, Чичиргээ"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Хурлын дуудлагыг удирдах"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Яаралтай дугаар"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> секунд</item>
+      <item quantity="one">1 секунд</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> минут</item>
+      <item quantity="one">1 минут</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> цаг</item>
+      <item quantity="one">1 цаг</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Профайл зураг"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Камер унтраалттай байна"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g>-р"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Тэмдэглэлийг илгээсэн"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Саяхны зурвас"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Бизнес мэдээлэл"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> милийн зайтай"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> км-н зайтай"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Маргааш <xliff:g id="OPEN_TIME">%s</xliff:g>-с нээгдэнэ"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Өнөөдөр <xliff:g id="OPEN_TIME">%s</xliff:g>-с нээгдэнэ"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g>-с хаадаг"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Өнөөдөр <xliff:g id="CLOSE_TIME">%s</xliff:g>-с хаасан"</string>
+    <string name="open_now" msgid="4615706338669555999">"Одоо нээлттэй"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Одоо хаалттай"</string>
+</resources>
diff --git a/InCallUI/res/values-mr-rIN/strings.xml b/InCallUI/res/values-mr-rIN/strings.xml
new file mode 100644
index 0000000..e620801
--- /dev/null
+++ b/InCallUI/res/values-mr-rIN/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"फोन"</string>
+    <string name="onHold" msgid="527593602772521700">"होल्ड वर"</string>
+    <string name="unknown" msgid="3646075119047488748">"अज्ञात"</string>
+    <string name="private_num" msgid="6081418498487514686">"खाजगी नंबर"</string>
+    <string name="payphone" msgid="5743050584468748607">"सार्वजनिक फोन"</string>
+    <string name="confCall" msgid="3181961445236675173">"परिषद कॉल"</string>
+    <string name="call_lost" msgid="8208184291640961172">"कॉल सोडला"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"स्पीकर"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"हँडसेट इअरपीस"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"वायर्ड हेडसेट"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"ब्लूटुथ"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"खालील टोन पाठवायचे?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"टोन पाठवित आहे\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"पाठवा"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"होय"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"नाही"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"खराब वर्णास यासह पुनर्स्थित करा"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"परिषद कॉल <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"व्हॉइसमेल नंबर"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"डायल करीत आहे"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"रीडायल करत आहे"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"परिषद कॉल"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"येणारा कॉल"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"येणारा कार्य कॉल"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"कॉल संपला"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"होल्ड वर"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"हँग अप करणेे"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"कॉल मधील"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"माझा नंबर <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g> आहे"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"व्हिडिओ कनेक्ट करत आहे"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"व्हिडिओ कॉल"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"व्हिडिओ विनंती करत आहे"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"व्हिडिओ कॉल कनेक्ट करू शकत नाही"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"व्हिडिओ विनंती नाकारली"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"आपला कॉलबॅक नंबर\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"आपला आणीबाणी कॉलबॅक नंबर\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"डायल करीत आहे"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"सुटलेला कॉल"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"सुटलेले कॉल"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> सुटलेले कॉल"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> कडील सुटलेला कॉल"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"सुरू असलेला कॉल"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"सुरु असलेला कार्य कॉल"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"सुरु असलेला वाय-फाय कॉल"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"सुरु असलेला वाय-फाय कार्य कॉल"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"होल्ड वर"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"येणारा कॉल"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"येणारा कार्य कॉल"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"येणारा वाय-फाय कॉल"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"येणारा वाय-फाय कार्य कॉल"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"येणारा व्हिडिओ कॉल"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"येणारी व्हिडिओ विनंती"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"नवीन व्हॉइसमेल"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"नवीन व्हॉइसमेल (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> डायल करा"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"व्हॉइसमेल नंबर अज्ञात"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"सेवा नाही"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"निवडलेले नेटवर्क (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) अनुपलब्ध"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"उत्तर"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"हँग अप"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"व्हिडिओ"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"व्हॉइस"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"स्वीकार करा"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"डिसमिस करा"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"पुन्हा कॉल करा"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"संदेश"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"कॉल करण्यासाठी, प्रथम विमान मोड बंद करा."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"नेटवर्कवर नोंदणीकृत नाही."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"मोबाईल नेटवर्क उपलब्ध नाही."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"कॉल करण्यासाठी, एक वैध नंबर प्रविष्ट करा."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"कॉल करू शकत नाही."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI क्रम प्रारंभ करीत आहे..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"सेवा समर्थित नाही."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"कॉल स्विच करू शकत नाही."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"कॉल विभक्त करू शकत नाही."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"हस्तांतर करू शकत नाही."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"परिषद घेऊ शकत नाही."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"कॉल नाकारू शकत नाही."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"कॉल रिलीझ करू शकत नाही."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP कॉल"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"आणीबाणी कॉल"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"रेडिओ चालू करीत आहे..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"सेवा नाही. पुन्हा प्रयत्न करत आहे…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"कॉल करू शकत नाही. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> हा आणीबाणी नंबर नाही."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"कॉल करू शकत नाही. आणीबाणी नंबर डायल करा."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"डायल करण्यासाठी कीबोर्डचा वापर करा"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"कॉल होल्ड करा"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"कॉल पुनः सुरु करा"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"कॉल समाप्त करा"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"डायलपॅड"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"नि:शब्द करा"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"कॉल जोडा"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"कॉल विलीन करा"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"अदलाबदल करा"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"कॉल व्यवस्थापित करा"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"परिषद कॉल व्यवस्थापित करा"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"ऑडिओ"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"व्हिडिओ कॉल"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"व्हॉइस कॉल वर बदला"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"कॅमेरा स्विच करा"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"व्हिडिओला विराम द्या"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"अधिक पर्याय"</string>
+    <string name="player_started" msgid="3478865572468310331">"प्लेअर सुरु झाले"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"प्लेअर थांबले"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"कॅमेरा सज्ज नाही"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"कॅमेरा सज्ज"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"अज्ञात कॉल सत्र इव्हेंट"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"सेवा"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"सेटअप"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;सेट नाही&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"इतर कॉल सेटिंग्ज"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> द्वारे कॉल करीत आहे"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> द्वारे येणारे"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"संपर्क फोटो"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"खाजगी व्हा"</string>
+    <string name="selectContact" msgid="92191462970821951">"संपर्क निवडा"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"आपण स्वतः लिहा…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"रद्द करा"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"पाठवा"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"उत्तर"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS पाठवा"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"नकार द्या"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"व्हिडिओ कॉल म्हणून उत्तर द्या"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"ऑडिओ कॉल म्हणून उत्तर द्या"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"व्हिडिओ विनंती स्वीकारा"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"व्हिडिओ विनंतीस नकार द्या"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"व्हिडिओ प्रसारण विनंती स्वीकार करा"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"व्हिडिओ प्रसारण विनंतीस नकार द्या"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"व्हिडिओ प्राप्त करा विनंती स्वीकार करा"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"व्हिडिओ प्राप्त करा विनंतीस नकार द्या"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> साठी वर स्लाइड करा."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> साठी डावीकडे स्लाइड करा."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> साठी उजवीकडे स्लाइड करा."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> साठी खाली स्लाइड करा."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"कंपन करा"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"कंपन करा"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"ध्वनी"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"डीफॉल्ट आवाज (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"फोन रिंगटोन"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"रिंग करताना कंपन करा"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"रिंगटोन आणि कंपन"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"परिषद कॉल व्यवस्थापित करा"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"आणीबाणी नंबर"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> सेकंद</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> सेकंद</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> मिनिट</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> मिनिटे</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> तास</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> तास</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"प्रोफाइल फोटो"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"कॅमेरा बंद"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> द्वारा"</string>
+    <string name="note_sent" msgid="7623014827902758398">"टीप पाठविली"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"अलीकडील संदेश"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"व्यवसाय माहिती"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> मैल दूर"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> किमी दूर"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"उद्या <xliff:g id="OPEN_TIME">%s</xliff:g> वाजता उघडेल"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"आज <xliff:g id="OPEN_TIME">%s</xliff:g> उघडेल"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"आज <xliff:g id="CLOSE_TIME">%s</xliff:g> वाजता बंद होईल"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"आज <xliff:g id="CLOSE_TIME">%s</xliff:g> वाजता बंद केले"</string>
+    <string name="open_now" msgid="4615706338669555999">"आता उघडा"</string>
+    <string name="closed_now" msgid="2635314668145282080">"आता बंद केले आहे"</string>
+</resources>
diff --git a/InCallUI/res/values-ms-rMY/strings.xml b/InCallUI/res/values-ms-rMY/strings.xml
new file mode 100644
index 0000000..83c4789
--- /dev/null
+++ b/InCallUI/res/values-ms-rMY/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Ditunda"</string>
+    <string name="unknown" msgid="3646075119047488748">"Tidak diketahui"</string>
+    <string name="private_num" msgid="6081418498487514686">"Nombor peribadi"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefon Awam"</string>
+    <string name="confCall" msgid="3181961445236675173">"Panggilan sidang"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Panggilan diputuskan"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Pembesar suara"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Alat dengar tel bimbit"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Set kepala berwayar"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Hantar nada berikut?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Menghantar nada\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Hantar"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ya"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Tidak"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Gantikan aksara bebas dengan"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Panggilan sidang <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Nombor mel suara"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Mendail"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Mendail semula"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Panggilan sidang"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Panggilan masuk"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Pgln masuk tempat kerja"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Panggilan tamat"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Ditunda"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Menamatkan panggilan"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Dalam panggilan"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Nombor saya ialah <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Menyambungkan video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Panggilan video"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Meminta video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Tidak dapat menyambungkan panggilan video"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Permintaan video ditolak"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Nombor panggilan balik anda<xliff:g id="DARK_NUMBER">%1$s</xliff:g>\n"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Nombor panggilan balik kecemasan anda\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Mendail"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Panggilan terlepas"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Panggilan terlepas"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> panggilan terlepas"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Panggilan tidak dijawab daripada <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Panggilan sedang berlangsung"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Panggilan sedang berlangsung daripada tempat kerja"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Panggilan Wi-Fi sedang berlangsung"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Panggian Wi-Fi sedang berlangsung daripada tempat kerja"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Ditunda"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Panggilan masuk"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Panggilan masuk daripada tempat kerja"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Panggilan masuk melalui Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Panggilan masuk melalui Wi-Fi daripada tempat kerja"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Panggilan video masuk"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Permintaan video masuk"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Mel suara baharu"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Mel suara baharu (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Dail <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Nombor mel suara tidak dikenali"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Tiada perkhidmatan"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Rangkaian pilihan (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) tidak tersedia"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Jawab"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Letakkan gagang"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Suara"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Terima"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Ketepikan"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Panggil balik"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Mesej"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Untuk membuat panggilan, matikan mod Pesawat terlebih dahulu."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Tidak didaftarkan pada rangkaian."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Rangkaian selular tidak tersedia."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Untuk membuat panggilan, masukkan nombor yang sah."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Tidak dapat memanggil."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Memulakan jujukan MMI..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Perkhidmatan tidak disokong."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Tidak dapat menukar panggilan."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Tidak dapat mengasingkan panggilan."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Tidak dapat memindahkan."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Tidak dapat membuat panggilan persidangan."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Tidak dapat menolak panggilan."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Tidak dapat melepaskan panggilan."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Panggilan SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Panggilan kecemasan"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Menghidupkan radio..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Tiada perkhidmatan. Mencuba lagi..."</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Tidak dapat memanggil. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> bukan nombor kecemasan."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Tidak dapat memanggil. Dail nombor kecemasan."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Gunakan papan kekunci untuk mendail"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Tahan Panggilan"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Sambung Semula Panggilan"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Tamatkan Panggilan"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Pad Pendail"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Redam"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Tambah panggilan"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Gabung panggilan"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Silih"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Urus panggilan"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Urus panggilan sidang"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Panggilan video"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Tukar ke panggilan suara"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Tukar kamera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Jeda video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Lagi pilihan"</string>
+    <string name="player_started" msgid="3478865572468310331">"Pemain Dimulakan"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Pemain Dihentikan"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera tidak bersedia"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera bersedia"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Acara sesi panggilan tidak diketahui"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Perkhidmatan"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Persediaan"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Tidak ditetapkan&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Tetapan panggilan lain"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Memanggil melalui <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Panggilan masuk melalui <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"foto kenalan"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"jadi peribadi"</string>
+    <string name="selectContact" msgid="92191462970821951">"pilih kenalan"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Tulis sendiri…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Batal"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Hantar"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Jawab"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Hantar SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Tolak"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Jawab sebagai panggilan video"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Jawab sebagai panggilan audio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Terima permintaan video"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Tolak permintaan video"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Terima permintaan hantar video"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Tolak permintaan hantar video"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Terima permintaan terima video"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Tolak permintaan terima video"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Luncurkan ke atas untuk <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Luncurkan ke kiri untuk <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Luncurkan ke kanan untuk <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Luncurkan ke bawah untuk <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Bergetar"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Bergetar"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Bunyi"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Bunyi lalai (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Nada dering telefon"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Bergetar apabila berdering"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Nada dering &amp; Bergetar"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Urus panggilan sidang"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Nombor kecemasan"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> saat</item>
+      <item quantity="one">1 saat</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minit</item>
+      <item quantity="one">1 minit</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> jam</item>
+      <item quantity="one">1 jam</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Foto profil"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera dimatikan"</string>
+    <string name="child_number" msgid="4469090994612105532">"melalui <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Nota dihantar"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Mesej terbaharu"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Maklumat perniagaan"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> batu dari sini"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km dari sini"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Dibuka esok pada pukul <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Dibuka hari ini pada pukul <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Tutup pada pukul <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Ditutup hari ini pada pukul <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Dibuka sekarang"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Ditutup sekarang"</string>
+</resources>
diff --git a/InCallUI/res/values-my-rMM/strings.xml b/InCallUI/res/values-my-rMM/strings.xml
new file mode 100644
index 0000000..f43ba0c
--- /dev/null
+++ b/InCallUI/res/values-my-rMM/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"ဖုန်း"</string>
+    <string name="onHold" msgid="527593602772521700">"ခဏ ကိုင်ထားစဉ်"</string>
+    <string name="unknown" msgid="3646075119047488748">"အမျိုးအမည်မသိ"</string>
+    <string name="private_num" msgid="6081418498487514686">"ကိုယ်ပိုင်ဖုန်းနံပါတ်"</string>
+    <string name="payphone" msgid="5743050584468748607">"အများသုံးဖုန်း"</string>
+    <string name="confCall" msgid="3181961445236675173">"အစည်းအဝေးခေါ်ဆိုမှု"</string>
+    <string name="call_lost" msgid="8208184291640961172">"ဖုန်းလိုင်းကျသွားခဲ့သည်"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"စပီကာ"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"လက်ကိုင်တယ်လီဖုန်းနားခွက်"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"ကြိုးတပ် မိုက်ခွက်ပါနားကြပ်"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"ဘလူးတုသ်"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"အောက်ပါ တီးလုံးများကို ပို့မလား။\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"အသံများ ပို့နေသည်\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"ပို့ပါ"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"ဟုတ်ပါသည်"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"မလိုပါ"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"အစားထိုး အထူးအက္ခရာတွင် အစားထိုးရန်"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"အစည်းအဝေးခေါ်ဆိုမှု <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"အသံစာနံပါတ်"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"ခေါ်ဆိုနေသည်"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"ပြန်ခေါ်နေသည်"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"အစည်းအဝေးခေါ်ဆိုမှု"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"အဝင် ခေါ်ဆိုမှု"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"အလုပ်ဆိုင်ရာ အဝင် ခေါ်ဆိုမှု"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"ဖုန်းခေါ်ဆိုမှု ပြီးဆုံးပါပြီ"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"ခဏ ကိုင်ထားစဉ်"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"ဖုန်းချနေပါသည်"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"ဖုန်းခေါ်ဆိုနေဆဲ"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"ကျွန်ုပ်၏ နံပါတ်မှာ <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g> ဖြစ်ပါသည်"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"ဗီဒီယို ချိတ်ဆက်နေသည်"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"ဗီဒီယို ခေါ်ဆိုမှု"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"ဗီဒီယိုခေါ်ဆိုနေသည်"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"ဗွီဒီယို ခေါ်ဆိုမှု ချိတ်ဆက်၍မရပါ။"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"ဗီဒီယို ခေါ်ဆိုမှုကို ပယ်ချလိုက်ပါပြီ"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"သင့်ကိုပြန်လည်ခေါ်ဆိုရန် နံပါတ်\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"သင့်ကိုအရေးပေါ် ပြန်လည်ခေါ်ဆိုရန် နံပါတ်\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"ဖုန်းခေါ်နေသည်"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"လွတ်သွားသော ခေါ်ဆိုမှု"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"လွတ်သွားသော ခေါ်ဆိုမှုများ"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"လွတ်သွားသော ခေါ်ဆိုမှု <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> မှလွတ်သွားသော ခေါ်ဆိုမှု"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"လက်ရှိခေါ်ဆိုမှု"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"လက်ရှိအလုပ်ခေါ်ဆိုမှု"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"လက်ရှိ Wi-Fi ခေါ်ဆိုမှု"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"လက်ရှိအလုပ် Wi-Fi ခေါ်ဆိုမှု"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"ခဏ ကိုင်ထားစဉ်"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"အဝင် ခေါ်ဆိုမှု"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"အလုပ်ဆိုင်ရာ အဝင်ခေါ်ဆိုမှု"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"အဝင် Wi-Fi ခေါ်ဆိုမှု"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"အလုပ်ဆိုင်ရာ အဝင် Wi-Fi ခေါ်ဆိုမှု"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"အဝင်ဗီဒီယိုခေါ်ဆိုမှု"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"ဗီဒီယိုအဝင် ခေါ်ဆိုမှု"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"အသံစာအသစ်"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"အသံစာ အသစ် (<xliff:g id="COUNT">%d</xliff:g>) ခု"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> ကိုခေါ်ပါ"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"အသံစာ၏နံပါတ်ကို မသိပါ"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"ဆက်သွယ်မှု ဧရိယာပြင်ပသို့ ရောက်ရှိနေသည်"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"ရွေးချယ်ထားသော ကွန်ယက် (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) မရရှိနိုင်ပါ"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"ဖြေကြားပါ"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"ဖုန်းချပါ"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"ဗီဒီယို"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"အသံ"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"လက်ခံပါ"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"ပယ်ပါ"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"ပြန်ခေါ်ပါ"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"မက်ဆေ့ဂျ်"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"ခေါ်ဆိုမှု ပြုလုပ်ရန်အတွက် လေယာဉ်ပျံမုဒ်ကို ဦးစွာပိတ်ပါ။"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"ကွန်ယက်ပေါ်တွင် မှတ်ပုံတင်ထားခြင်း မရှိပါ။"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"ဆယ်လူလာ ကွန်ရက် မရှိပါ။"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"ခေါ်ဆိုမှု ပြုလုပ်ရန်အတွက် မှန်ကန်သည့်နံပါတ်တစ်ခုကို ထည့်ပါ။"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"ခေါ်ဆို၍မရပါ။"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI အစီအစဉ် စတင်နေသည်..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"ဝန်ဆောင်မှုအား ပံ့ပိုးမထားပါ။"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"ခေါ်ဆိုမှုများကို လှည့်ပြောင်း၍မရပါ။"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"ခေါ်ဆိုမှုကို ခွဲခြား၍မရပါ။"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"မလွှဲပြောင်းနိုင်ပါ။"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"အစည်းအဝေးခေါ်ဆိုမှု ပြုလုပ်၍မရပါ။"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"ခေါ်ဆိုမှုကို ငြင်းဆို၍မရပါ။"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"ခေါ်ဆိုမှု(များ) ကို လွှတ်၍မရပါ။"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP ခေါ်ဆိုမှု"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"အရေးပေါ် ခေါ်ဆိုမှု"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"ရေဒီယို ဖွင့်နေသည်…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"ချိတ်ဆက်မှု ဧရိယာပြင်ပရောက်နေပါသည်။ ထပ်စမ်းကြည့်ပါ..."</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"ခေါ်ဆို၍မရနိုင်ပါ။ <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> သည်အရေးပေါ်နံပါတ်တစ်ခု မဟုတ်ပါ။"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"ခေါ်ဆို၍မရနိုင်ပါ။ အရေးပေါ်နံပါတ်တစ်ခုကို ခေါ်ဆိုပါ။"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ခေါ်ဆိုရန် ကီးဘုတ်ကိုအသုံးပြုပါ"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"ခေါ်ဆိုမှု ခေတ္တရပ်ထားပါ"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"ခေါ်ဆိုမှုကို ဆက်လုပ်ပါ"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"ခေါ်ဆိုမှု အပြီးသတ်ပါ"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"နံပါတ်ကွက်"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"အသံပိတ်ပါ"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"ခေါ်ဆိုမှုထည့်ပါ"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"ခေါ်ဆိုမှုများကို ပေါင်းစည်းပါ"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"ဖလှယ်ပါ"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"ခေါ်ဆိုမှုများကို စီမံခန့်ခွဲပါ"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"အစည်းအဝေးခေါ်ဆိုမှုကို စီမံခန့်ခွဲပါ"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"အသံ"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"ဗီဒီယို ခေါ်ဆိုမှု"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"အသံခေါ်ဆိုမှုသို့ ပြောင်းပါ"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"ကင်မရာပြောင်းပါ"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"ဗီဒီယို ခေတ္တရပ်ပါ"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"နောက်ထပ် ရွေးစရာများ"</string>
+    <string name="player_started" msgid="3478865572468310331">"ပလေယာ စပါပြီ"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"ပလေယာ ရပ်တန့်သွားပါပြီ"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"ကင်မရာအဆင်သင့် မဖြစ်သေးပါ"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"ကင်မရာအဆင်သင့်ဖြစ်ပါပြီ"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"အမျိုးအမည်မသိ ခေါ်ဆိုမှုအချိန်ကာလ"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"ဝန်ဆောင်မှု"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"စနစ်ထည့်သွင်းမှုပြုလုပ်ပါ"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;မသတ်မှတ်ထားပါ&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"အခြားခေါ်ဆိုမှုဆက်တင်များ"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> မှတစ်ဆင့် ခေါ်ဆိုခြင်း"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> မှတစ်ဆင့်အဝင်ခေါ်ဆိုမှု"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"အဆက်အသွယ်ဓာတ်ပုံ"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"တသီးတသန့်ချိတ်ဆက်ရန်"</string>
+    <string name="selectContact" msgid="92191462970821951">"လိပ်စာရွေးပါ"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"သင့်ကိုယ်ပိုင် စာသား ရေးပါ..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"မလုပ်တော့"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"ပို့ပါ"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"ဖြေကြားပါ"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS ပို့ပါ"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"ငြင်းပယ်ပါ"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"ဗီဒီယိုခေါ်ဆိုမှုအဖြစ် ဖြေကြားပါ"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"အသံခေါ်ဆိုမှုအဖြစ် ဖြေကြားပါ"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"ဗီဒီယိုခေါ်ဆိုမှုကို လက်ခံပါ"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"ဗီဒီယိုခေါ်ဆိုမှုကို ငြင်းပယ်ပါ"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"ဗီဒီယိုထုတ်လွှင့်ခြင်းတောင်းဆိုမှုကို လက်ခံပါ"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"ဗီဒီယိုထုတ်လွှင့်ခြင်းတောင်းဆိုမှုကို ငြင်းပယ်ပါ"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"ဗီဒီယိုလက်ခံရရှိမှုတောင်းဆိုချက်ကို လက်ခံပါ"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"ဗီဒီယိုလက်ခံရရှိကြောင်းတောင်းဆိုမှုကို ငြင်းပယ်ပါ"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> အတွက် အပေါ်ကို ပွတ်ဆွဲပါ"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> အတွက် ဘယ်ဖက်ကို ပွတ်ဆွဲပါ"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> အတွက် ညာဖက်ကို ပွတ်ဆွဲပါ"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> အတွက် အောက်ကို ပွတ်ဆွဲပါ"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"တုန်ခါပါ"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"တုန်ခါပါ"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"အသံ"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"မူရင်း အသံ (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"ဖုန်းမြည်သံ"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"ဖုန်းမြည်စဉ် တုန်ခါပါ"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"ဖုန်းမြည်သံ &amp; တုန်ခါသံ"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"အစည်းအဝေးခေါ်ဆိုမှုကို စီမံခန့်ခွဲပါ"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"အရေးပေါ်နံပါတ်"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> စက္ကန့်</item>
+      <item quantity="one">၁ စက္ကန့်</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> မိနစ်</item>
+      <item quantity="one"> ၁ မိနစ်</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> နာရီ</item>
+      <item quantity="one">၁ နာရီ</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"ပရိုဖိုင် ဓာတ်ပုံ"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"ကင်မရာ ပိတ်ပါ"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> မှတစ်ဆင့်"</string>
+    <string name="note_sent" msgid="7623014827902758398">"မှတ်ချက်ကို ပို့လိုက်ပါပြီ"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"မကြာသေးမီက မက်ဆေ့ဂျ်များ"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"စီးပွားရေး အချက်အလက်"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> မိုင်အကွာ"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> ကီလိုမီတာအကွာ"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>၊ <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>၊ <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"မနက်ဖြန် <xliff:g id="OPEN_TIME">%s</xliff:g> ၌ဖွင့်မည်"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"ယနေ့ <xliff:g id="OPEN_TIME">%s</xliff:g> ၌ဖွင့်မည်"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g> ၌ပိတ်ပါမည်"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"ယနေ့ <xliff:g id="CLOSE_TIME">%s</xliff:g> ၌ပိတ်ခဲ့သည်"</string>
+    <string name="open_now" msgid="4615706338669555999">"ယခုဖွင့်ပါ"</string>
+    <string name="closed_now" msgid="2635314668145282080">"ယခုပိတ်ပါ"</string>
+</resources>
diff --git a/InCallUI/res/values-nb/strings.xml b/InCallUI/res/values-nb/strings.xml
new file mode 100644
index 0000000..70f0500
--- /dev/null
+++ b/InCallUI/res/values-nb/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"På vent"</string>
+    <string name="unknown" msgid="3646075119047488748">"Ukjent"</string>
+    <string name="private_num" msgid="6081418498487514686">"Skjult nummer"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefonkiosk"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferansesamtale"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Anropet ble avbrutt"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Høyttaler"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Telefonhøyttaler"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Hodetelefoner med kabel"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Vil du sende disse lydene?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Sender lydene\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Send"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ja"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Nei"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Erstatt jokertegn med"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferansesamtale <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Nummeret til talepostkassen"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Ringer"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Ringer på nytt"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferansesamtale"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Innkommende anrop"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Innkommende jobbanrop"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Anropet er avsluttet"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"På vent"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Legger på"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Anrop pågår"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Nummeret mitt er <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Kobler til video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videoanrop"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Ber om video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Kan ikke koble til videoanropet"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Videoforespørselen er avvist"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Tilbakeringingsnummeret ditt\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Tilbakeringingsnummeret ditt for nødstilfeller\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Ringer"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Tapt anrop"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Tapte anrop"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> tapte anrop"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Tapt anrop fra <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Pågående anrop"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Pågående jobbanrop"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Pågående Wi-Fi-anrop"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Pågående jobbanrop via Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"På vent"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Innkommende anrop"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Innkommende jobbanrop"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Innkommende Wi-Fi-anrop"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Innkommende jobbanrop via Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Innkommende videoanrop"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Innkommende videoforespørsel"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Ny talepost"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Ny talepost (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Ring <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Nummeret til talepostkassen er ukjent"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Ingen tjeneste"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Det valgte nettverket (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) er ikke tilgjengelig"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Svar"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Legg på"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Uten video"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Godta"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Avvis"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Ring tilbake"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Melding"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"For å ringe, slå av flymodus først."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Ikke registrert på nettverket."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobilnettverket er ikke tilgjengelig."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"For å ringe, skriv inn et gyldig nummer."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Kan ikke ringe."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Starter MMI-sekvens …"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Tjenesten støttes ikke."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Kan ikke bytte samtaler."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Kan ikke splitte opp anropet."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Kan ikke overføre."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Kan ikke opprette konferanse."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Kan ikke avvise anropet."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Kan ikke frigjøre samtale(r)."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP-anrop"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Nødanrop"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Slår på radioen …"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Ingen tjeneste. Prøver på nytt …"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Kan ikke ringe. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> er ikke et nødnummer."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Kan ikke ringe. Ring et nødnummer."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Bruk tastaturet for å ringe"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Sett anropet på vent"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Gjenoppta anropet"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Avslutt anropet"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Talltastatur"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Kutt lyden"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Legg til anrop"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Slå sammen anrop"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Bytt"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Administrer anrop"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Administrer konferansesamtale"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Lyd"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videoanrop"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Bytt til taleanrop"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Bytt kamera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Sett videoen på pause"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Flere alternativer"</string>
+    <string name="player_started" msgid="3478865572468310331">"Avspilleren har startet"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Avspilleren har stoppet"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kameraet er ikke klart"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kameraet er klart"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Ukjent anrop"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Tjeneste"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Konfigurering"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Ikke angitt&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Andre anropsinnstillinger"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Ringer via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Innkommende via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"kontaktbilde"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"aktivér privat samtale"</string>
+    <string name="selectContact" msgid="92191462970821951">"velg kontakt"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Skriv ditt eget"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Avbryt"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Send"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Svar"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Send SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Avslå"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Svar med video"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Svar uten video"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Godta videoforespørselen"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Avslå videoforespørselen"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Godta forespørselen om å sende video"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Avslå forespørselen om å sende video"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Godta forespørselen om å motta video"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Avslå forespørselen om å motta video"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Dra opp for <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Dra til venstre for å <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Dra til høyre for å <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Dra ned for å <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrering"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrering"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Lyd"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Standardlyd (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Telefonringelyd"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrer når telefonen ringer"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Ringelyd og vibrering"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Administrer konferansesamtale"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Nødnummer"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekunder</item>
+      <item quantity="one">1 sekund</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutter</item>
+      <item quantity="one">1 minutt</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> timer</item>
+      <item quantity="one">1 time</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profilbilde"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kameraet er slått av"</string>
+    <string name="child_number" msgid="4469090994612105532">"via <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Notatet er sendt"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Nylige meldinger"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informasjon om bedriften"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mile unna"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km unna"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>–<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Åpner i morgen kl. <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Åpner i dag kl. <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Stenger kl. <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Stengte i dag kl. <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Åpen nå"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Stengt nå"</string>
+</resources>
diff --git a/InCallUI/res/values-ne-rNP/strings.xml b/InCallUI/res/values-ne-rNP/strings.xml
new file mode 100644
index 0000000..a61f0e3
--- /dev/null
+++ b/InCallUI/res/values-ne-rNP/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"फोन"</string>
+    <string name="onHold" msgid="527593602772521700">"होल्डमा"</string>
+    <string name="unknown" msgid="3646075119047488748">"अज्ञात"</string>
+    <string name="private_num" msgid="6081418498487514686">"निजी नम्बर"</string>
+    <string name="payphone" msgid="5743050584468748607">"पेफोन"</string>
+    <string name="confCall" msgid="3181961445236675173">"सम्मेलन कल"</string>
+    <string name="call_lost" msgid="8208184291640961172">"कल ड्रप भयो"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"स्पिकर"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"हेन्डसेट इयरपिस"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"तारसहितको हेडसेट"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"ब्लुटुथ"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"निम्न टोनहरू पठाउने?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"टोनहरू\n पठाउँदै"</string>
+    <string name="send_button" msgid="4054398309483035794">"पठाउनुहोस्"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"हो"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"होइन"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"यसलाई वाइल्ड वर्ण राखेर बदल्नुहोस्"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"सम्मेलन कल <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"भ्वाइस मेल नम्बर"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"डायल गर्दै"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"पुन: डायल गर्दै"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"सम्मेलन कल"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"आगमन कल"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"कार्यालयबाट आएको कल"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"कल अन्त्य भयो"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"होल्डमा छ"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"फोन काट्दै"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"कलमा"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"मेरो नम्बर <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g> हो"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"भिडियो जडान गरिँदै"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"भिडियो कल"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"भिडियोका लागि अनुरोध गर्दै"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"भिडियो कलमा जडान गर्न सक्दैन"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"भिडियो अनुरोध अस्वीकार गरियो"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"तपाईंको कलब्याक नम्बर\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"तपाईंको आपतकालीन कलब्याक नम्बर\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"डायल गर्दै"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"छुटेको कल"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"छुटेका कलहरू"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> छुटेका कलहरू"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> बाट आएको छुटेको कल"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"चलिरहेको कल"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"चालू रहेको कार्यालयको कल"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"चालू रहेको WI-Fi कल"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Wi-Fi मार्फत चालू रहेको कार्यालयको कल"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"होल्डमा"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"आगमन कल"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"कार्यालयबाट आएको कल"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"आगमन Wi-Fi कल"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Wi-Fi मार्फत कार्यालयबाट आएको कल"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"आगमन भिडियो कल"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"आगमन भिडियो अनुरोध"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"नयाँ भ्वाइस मेल"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"नयाँ भ्वाइसमेल (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> मा डायल गर्नुहोस्"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"भ्वाइस मेल नम्बर अज्ञात छ"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"कुनै सेवा छैन"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"चयन गरिएको नेटवर्क (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) अनुपलब्ध छ"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"जवाफ दिनुहोस्"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"राख्नुहोस्"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"भिडियो"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"आवाज"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"स्वीकार गर्नुहोस्"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"खारेज गर्नुहोस्"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"कल फर्काउने"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"सन्देश"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"कल गर्नका लागि, पहिले हवाइजहाज मोड बन्द गर्नुहोस्।"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"नेटवर्कमा दर्ता भएको छैन।"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"सेलुलर नेटवर्क उपलब्ध छैन।"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"एक कल गर्नको लागि, मान्य नम्बर प्रविष्ट गर्नुहोस्।"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"कल गर्न सकिंदैन।"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI अनुक्रम सुरु गर्दै..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"सेवा समर्थित छैन।"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"कल स्विच गर्न सक्दैन।"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"कल अलग गर्न सक्दैन।"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"ट्रान्सफर गर्न सक्दैन।"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"सम्मेलन गर्न सक्दैन।"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"कल अस्वीकार गर्न सक्दैन।"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"कल (हरू) जारी गर्न सकिंदैन।"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP कल"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"आपतकालीन कल"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"रेडियो खोल्दै..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"कुनै सेवा छैन। फेरि प्रयास गर्दै..."</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"कल गर्न सकिंदैन। <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> आपतकालीन नम्बर होइन।"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"कल गर्न सकिंदैन। आपतकालीन नम्बर डायल गर्नुहोस्।"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"डायल गर्न किबोर्ड प्रयोग गर्नुहोस्"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"कल होल्ड गर्नुहोस्"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"कललाई पुन: निरन्तरता दिनुहोस्"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"कल अन्त्य गर्नुहोस्"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"डायल प्याड"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"म्यूट गर्नुहोस्"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"कल थप्नुहोस्"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"कलहरू मर्ज गर्नुहोस्"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"स्वाप"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"कलहरूको प्रबन्ध मिलाउनुहोस्"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"सम्मेलन कलको प्रबन्ध मिलाउनहोस्"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"अडियो"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"भिडियो कल"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"आवाज कलमा परिवर्तन गर्नुहोस्"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"क्यामेरा स्विच गर्नुहोस्"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"भिडियो रोक्नुहोस्"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"थप विकल्पहरू"</string>
+    <string name="player_started" msgid="3478865572468310331">"प्लेयर सुरु भयो"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"प्लेयर रोकियो"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"क्यामेरा तयार छैन"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"क्यामेरा तयार छ"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"अज्ञात कल सत्र घटना"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"सेवा"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"सेटअप"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;सेट गरिएको छैन&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"अन्य कल सेटिङहरू"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> मार्फत कल गर्दै"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> मार्फत आगमन"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"सम्पर्क तस्बिर"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"निजी कलमा जानुहोस्"</string>
+    <string name="selectContact" msgid="92191462970821951">"सम्पर्क चयन गर्नुहोस्"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"तपाईंको आफ्नै लेख्नुहोस्..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"रद्द गर्नुहोस्"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"पठाउनुहोस्"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"जवाफ दिनुहोस्"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS पठाउनुहोस्"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"अस्वीकार गर्नुहोस्"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"भिडियो कलको रूपमा जवाफ दिनुहोस्"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"अडियो कलको रूपमा जवाफ दिनुहोस्"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"भिडियो अनुरोध स्वीकार गर्नुहोस्"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"भिडियो अनुरोध अस्वीकार गर्नुहोस्"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"भिडियो प्रसारण गर्ने अनुरोध स्वीकार गर्नुहोस्"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"भिडियो प्रसारण गर्ने अनुरोध अस्वीकार गर्नुहोस्"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"भिडियो प्राप्त गर्ने अनुरोधलाई स्वीकार गर्नुहोस्"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"भिडियो प्राप्त गर्ने अनुरोध अस्वीकार गर्नुहोस्"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> को लागि माथि स्लाइड गर्नुहोस्।"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> को लागि बायाँ स्लाइड गर्नुहोस्।"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> को लागि दायाँ स्लाइड गर्नुहोस्।"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> को लागि तल स्लाइड गर्नुहोस्।"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"कम्पन हुने"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"कम्पन हुने"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"आवाज"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"पूर्वनिर्धारित ध्वनि (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"फोनको रिङटोन"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"घन्टी बज्दा कम्पन गराउनुहोस्"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"रिङटोन &amp; कम्पन"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"सम्मेलन कलको प्रबन्ध मिलाउनुहोस्"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"आपतकालीन नम्बर"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> सेकेण्ड</item>
+      <item quantity="one">१ सेकेण्ड</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> मिनेट</item>
+      <item quantity="one">१ मिनेट</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> घण्टा</item>
+      <item quantity="one">१ घण्टा</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"प्रोफाइल तस्बिर"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"क्यामेरा बन्द छ"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> बाट"</string>
+    <string name="note_sent" msgid="7623014827902758398">"नोट पठाइयो"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"भर्खरैका सन्देशहरू"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"व्यवसाय जानकारी"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> माइल टाढा"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> किलोमिटर टाढा"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"भोली <xliff:g id="OPEN_TIME">%s</xliff:g> मा खुल्छ"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"आज <xliff:g id="OPEN_TIME">%s</xliff:g> मा खुल्छ"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g> मा बन्द हुन्छ"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"आज <xliff:g id="CLOSE_TIME">%s</xliff:g> मा बन्द भयो"</string>
+    <string name="open_now" msgid="4615706338669555999">"अहिले खुला छ"</string>
+    <string name="closed_now" msgid="2635314668145282080">"अब बन्द भयो"</string>
+</resources>
diff --git a/InCallUI/res/values-nl/strings.xml b/InCallUI/res/values-nl/strings.xml
new file mode 100644
index 0000000..3827546
--- /dev/null
+++ b/InCallUI/res/values-nl/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefoon"</string>
+    <string name="onHold" msgid="527593602772521700">"In de wacht"</string>
+    <string name="unknown" msgid="3646075119047488748">"Onbekend"</string>
+    <string name="private_num" msgid="6081418498487514686">"Privénummer"</string>
+    <string name="payphone" msgid="5743050584468748607">"Betaaltelefoon"</string>
+    <string name="confCall" msgid="3181961445236675173">"Telefonische vergadering"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Oproep beëindigd"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Luidspreker"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Oortelefoon van handset"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Bedrade headset"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"De volgende tonen verzenden?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Nummers verzenden\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Verzenden"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ja"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Nee"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Jokerteken vervangen door"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Telefonische vergadering <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Voicemailnummer"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Kiezen"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Opnieuw bellen"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Telefonische vergadering"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Inkomende oproep"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Inkom. zakelijke oproep"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Oproep beëindigd"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"In de wacht"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Ophangen"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"In gesprek"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mijn nummer is <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Verbinding maken met video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videogesprek"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Video aanvragen"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Kan geen videogesprek starten"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Videoverzoek geweigerd"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Je terugbelnummer\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Je terugbelnummer bij alarm\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Kiezen"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Gemiste oproep"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Gemiste oproepen"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> gemiste oproepen"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Gemiste oproep van <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Actieve oproep"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Actieve zakelijke oproep"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Actieve wifi-oproep"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Actieve zakelijke oproep via wifi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"In de wacht"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Inkomende oproep"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Inkomende zakelijke oproep"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Inkomende wifi-oproep"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Inkomende zakelijke oproep via wifi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Inkomend videogesprek"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Inkomend videoverzoek"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nieuwe voicemail"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nieuwe voicemail (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> bellen"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Voicemailnummer onbekend"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Geen service"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Geselecteerd netwerk (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) niet beschikbaar"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Beantwoorden"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Ophangen"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Spraak"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Accepteren"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Sluiten"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Terugbellen"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Bericht"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Als je wilt bellen, moet je eerst de vliegtuigmodus uitschakelen."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Niet geregistreerd op netwerk."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobiel netwerk niet beschikbaar."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Als je wilt bellen, moet je een geldig nummer invoeren."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Kan niet bellen."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI-reeks starten..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Service wordt niet ondersteund."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Kan niet schakelen tussen oproepen."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Kan oproep niet scheiden."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Kan niet doorschakelen."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Telefonische vergadering niet mogelijk."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Kan oproep niet weigeren."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Kan oproep(en) niet vrijgeven."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP-oproep"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Noodoproep"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Radio inschakelen…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Geen bereik. Opnieuw proberen…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Kan niet bellen. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> is geen alarmnummer."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Kan niet bellen. Bel een alarmnummer."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Toetsen gebruiken om te bellen"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Oproep in de wacht zetten"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Oproep hervatten"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Oproep beëindigen"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Toetsenblok"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Dempen"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Oproep toevoegen"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Samenvoegen"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Wisselen"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Oproepen beheren"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Telef. vergadering beheren"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Vid.gespr."</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Wijzigen in spraakoproep"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Van camera wisselen"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Video onderbreken"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Meer opties"</string>
+    <string name="player_started" msgid="3478865572468310331">"Speler gestart"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Speler gestopt"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Camera niet gereed"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Camera gereed"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Onbekende oproepsessiegebeurtenis"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Service"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Configuratie"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Niet ingesteld&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Andere instellingen voor bellen"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Bellen via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Inkomend via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"contactfoto"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"privé"</string>
+    <string name="selectContact" msgid="92191462970821951">"contact selecteren"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Eigen reactie opstellen..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Annuleren"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Verzenden"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Beantwoorden"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Sms verzenden"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Weigeren"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Beantwoorden als videogesprek"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Beantwoorden als audiogesprek"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Videoverzoek accepteren"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Videoverzoek weigeren"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Verzoek voor video-overdracht accepteren"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Verzoek voor video-overdracht weigeren"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Verzoek voor video-ontvangst accepteren"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Verzoek voor video-ontvangst weigeren"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Veeg omhoog voor <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Veeg naar links voor <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Veeg naar rechts voor <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Veeg omlaag voor <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Trillen"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Trillen"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Geluid"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Standaardgeluid (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Beltoon telefoon"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Trillen bij bellen"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Beltoon en trillen"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Telefonische vergadering beheren"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Alarmnummer"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> seconden</item>
+      <item quantity="one">1 seconde</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minuten</item>
+      <item quantity="one">1 minuut</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> uur</item>
+      <item quantity="one">1 uur</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profielfoto"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Camera uit"</string>
+    <string name="child_number" msgid="4469090994612105532">"via <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Notitie verzonden"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Recente berichten"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Bedrijfsinformatie"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mijl hiervandaan"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km hiervandaan"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Gaat morgen open om <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Gaat vandaag open om <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Sluit om <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Vandaag gesloten vanaf <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Nu geopend"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Nu gesloten"</string>
+</resources>
diff --git a/InCallUI/res/values-pa-rIN/strings.xml b/InCallUI/res/values-pa-rIN/strings.xml
new file mode 100644
index 0000000..eb807c6
--- /dev/null
+++ b/InCallUI/res/values-pa-rIN/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"ਫੋਨ"</string>
+    <string name="onHold" msgid="527593602772521700">"ਰੋਕੀ ਗਈ"</string>
+    <string name="unknown" msgid="3646075119047488748">"ਅਗਿਆਤ"</string>
+    <string name="private_num" msgid="6081418498487514686">"ਨਿੱਜੀ ਨੰਬਰ"</string>
+    <string name="payphone" msgid="5743050584468748607">"ਪੇ-ਫੋਨ"</string>
+    <string name="confCall" msgid="3181961445236675173">"ਕਾਨਫਰੰਸ ਕਾਲ"</string>
+    <string name="call_lost" msgid="8208184291640961172">"ਕਾਲ ਡ੍ਰੌਪ ਹੋਈ"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"ਸਪੀਕਰ"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"ਹੈੱਡਸੈੱਟ ਈਯਰਪੀਸ"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"ਵਾਇਰ ਵਾਲਾ ਹੈੱਡਸੈੱਟ"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"ਬਲੂਟੁੱਥ"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"ਕੀ ਅੱਗੇ ਦਿੱਤੀਆਂ ਗਈਆਂ ਧੁਨੀਆਂ ਭੇਜਣੀਆਂ ਹਨ?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"ਧੁਨੀਆਂ ਭੇਜੀਆਂ ਜਾ ਰਹੀਆਂ ਹਨ\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"ਭੇਜੋ"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"ਹਾਂ"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"ਨਹੀਂ"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"ਵਾਈਲਡ ਅੱਖਰ ਨੂੰ ਇਸ ਨਾਲ ਬਦਲੋ"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"ਕਾਨਫਰੰਸ ਕਾਲ <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"ਵੌਇਸਮੇਲ ਨੰਬਰ"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"ਡਾਇਲ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"ਦੁਬਾਰਾ ਡਾਇਲ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"ਕਾਨਫਰੰਸ ਕਾਲ"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"ਆ ਰਹੀ ਕਾਲ"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"ਕੰਮ ਸੰਬੰਧਿਤ ਆ ਰਹੀ ਕਾਲ"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"ਕਾਲ ਸਮਾਪਤ ਹੋਈ"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"ਰੋਕੀ ਗਈ"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"ਰੋਕੀ ਜਾ ਰਹੀ ਹੈ"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"ਚਾਲੂ ਕਾਲ"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"ਮੇਰਾ ਨੰਬਰ <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g> ਹੈ"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"ਵੀਡੀਓ ਨੂੰ ਕਨੈਕਟ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"ਵੀਡੀਓ ਕਾਲ"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"ਵੀਡੀਓ ਲਈ ਬੇਨਤੀ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"ਵੀਡੀਓ ਕਾਲ ਕਨੈਕਟ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"ਵੀਡੀਓ ਬੇਨਤੀ ਅਸਵੀਕਾਰ ਕੀਤੀ ਗਈ"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"ਤੁਹਾਡਾ ਕਾਲਬੈਕ ਨੰਬਰ \n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"ਤੁਹਾਡਾ ਐਮਰਜੈਂਸੀ ਕਾਲਬੈਕ ਨੰਬਰ\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"ਡਾਇਲ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"ਖੁੰਝੀ ਹੋਈ ਕਾਲ"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"ਖੁੰਝੀਆਂ ਹੋਈਆਂ ਕਾਲਾਂ"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ਖੁੰਝੀਆਂ ਹੋਈਆਂ ਕਾਲਾਂ"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> ਤੋਂ ਖੁੰਝੀ ਹੋਈ ਕਾਲ"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"ਜਾਰੀ ਕਾਲ"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"ਕੰਮ ਸੰਬੰਧਿਤ ਜਾਰੀ ਕਾਲ"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"ਜਾਰੀ Wi-Fi ਕਾਲ"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"ਕੰਮ ਸੰਬੰਧਿਤ ਜਾਰੀ Wi-Fi ਕਾਲ"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"ਰੋਕੀ ਗਈ"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"ਆ ਰਹੀ ਕਾਲ"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"ਕੰਮ ਸੰਬੰਧਿਤ ਆ ਰਹੀ ਕਾਲ"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"ਆ ਰਹੀ Wi-Fi ਕਾਲ"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"ਕੰਮ ਸੰਬੰਧਿਤ ਆ ਰਹੀ Wi-Fi ਕਾਲ"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"ਆ ਰਹੀ ਵੀਡੀਓ ਕਾਲ"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"ਆ ਰਹੀ ਵੀਡੀਓ ਬੇਨਤੀ"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"ਨਵੀਂ ਵੌਇਸਮੇਲ"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"ਨਵੀਂ ਵੌਇਸਮੇਲ (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> ਡਾਇਲ ਕਰੋ"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"ਵੌਇਸਮੇਲ ਨੰਬਰ ਅਗਿਆਤ"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"ਕੋਈ ਸੇਵਾ ਨਹੀਂ"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"ਚੁਣਿਆ ਗਿਆ ਨੈੱਟਵਰਕ (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) ਉਪਲਬਧ ਨਹੀਂ ਹੈ"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"ਜਵਾਬ ਦਿਓ"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"ਰੋਕੋ"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"ਵੀਡੀਓ"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"ਵੌਇਸ"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"ਸਵੀਕਾਰ ਕਰੋ"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"ਰੱਦ ਕਰੋ"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"ਵਾਪਸ ਕਾਲ ਕਰੋ"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"ਸੁਨੇਹਾ"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"ਇੱਕ ਕਾਲ ਕਰਨ ਲਈ, ਪਹਿਲਾਂ ਜਹਾਜ਼ ਮੋਡ ਬੰਦ ਕਰੋ।"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"ਨੈੱਟਵਰਕ \'ਤੇ ਰਜਿਸਟਰ ਨਹੀਂ।"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"ਸੈਲਿਊਲਰ ਨੈੱਟਵਰਕ ਉਪਲਬਧ ਨਹੀਂ ਹੈ।"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"ਇੱਕ ਕਾਲ ਕਰਨ ਲਈ, ਇੱਕ ਵੈਧ ਨੰਬਰ ਦਾਖਲ ਕਰੋ।"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"ਕਾਲ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ।"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI ਕੜੀ ਨੂੰ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"ਸੇਵਾ ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ।"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"ਕਾਲਾਂ ਸਵਿੱਚ ਨਹੀਂ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ।"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"ਵੱਖਰੇ ਤੌਰ \'ਤੇ ਕਾਲ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ।"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"ਕਾਲ ਟ੍ਰਾਂਸਫਰ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ।"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"ਕਾਨਫਰੰਸ ਕਾਲ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ।"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"ਕਾਲ ਰੱਦ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ।"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"ਕਾਲ(ਲਾਂ) ਰੀਲੀਜ਼ ਨਹੀਂ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ।"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP ਕਾਲ"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"ਐਮਰਜੈਂਸੀ ਕਾਲ"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"ਰੇਡੀਓ ਚਾਲੂ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"ਕੋਈ ਸੇਵਾ ਨਹੀਂ। ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"ਕਾਲ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ। <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> ਇੱਕ ਐਮਰਜੈਂਸੀ ਨੰਬਰ ਨਹੀਂ ਹੈ।"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"ਕਾਲ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ। ਇੱਕ ਐਮਰਜੈਂਸੀ ਨੰਬਰ ਡਾਇਲ ਕਰੋ।"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ਡਾਇਲ ਕਰਨ ਲਈ ਕੀ-ਬੋਰਡ ਵਰਤੋ"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"ਕਾਲ ਰੋਕੋ"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"ਕਾਲ ਮੁੜ-ਸ਼ੁਰੂ ਕਰੋ"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"ਕਾਲ ਸਮਾਪਤ ਕਰੋ"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"ਡਾਇਲਪੈਡ"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"ਮਿਊਟ ਕਰੋ"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"ਕਾਲ ਸ਼ਾਮਲ ਕਰੋ"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"ਕਾਲਾਂ ਸ਼ਾਮਲ ਕਰੋ"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"ਅਦਲਾ-ਬਦਲੀ ਕਰੋ"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"ਕਾਲਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰੋ"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"ਕਾਨਫਰੰਸ ਕਾਲ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰੋ"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"ਔਡੀਓ"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"ਵੀਡੀਓ ਕਾਲ"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"ਵੌਇਸ ਕਾਲ ਵਿੱਚ ਬਦਲੋ"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"ਕੈਮਰੇ \'ਤੇ ਬਦਲੋ"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"ਵੀਡੀਓ ਰੋਕੋ"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"ਹੋਰ ਚੋਣਾਂ"</string>
+    <string name="player_started" msgid="3478865572468310331">"ਪਲੇਅਰ ਸ਼ੁਰੂ ਹੋ ਗਿਆ"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"ਪਲੇਅਰ ਰੁਕ ਗਿਆ"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"ਕੈਮਰਾ ਤਿਆਰ ਨਹੀਂ ਹੈ"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"ਕੈਮਰਾ ਤਿਆਰ ਹੈ"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"ਅਗਿਆਤ ਕਾਲ ਸੈਸ਼ਨ ਵਰਤਾਰਾ"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"ਸੇਵਾ"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"ਸਥਾਪਨਾ"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;ਸੈੱਟ ਨਹੀਂ&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"ਹੋਰ ਕਾਲ ਸੈਟਿੰਗਾਂ"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> ਰਾਹੀਂ ਕਾਲ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> ਰਾਹੀਂ ਆ ਰਹੀਆਂ ਕਾਲਾਂ"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"ਸੰਪਰਕ ਫੋਟੋ"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"ਨਿੱਜੀ ਵਿੱਚ ਬਦਲੋ"</string>
+    <string name="selectContact" msgid="92191462970821951">"ਸੰਪਰਕ ਚੁਣੋ"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"ਆਪਣੇ ਆਪ ਲਿਖੋ..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"ਰੱਦ ਕਰੋ"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"ਭੇਜੋ"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"ਜਵਾਬ ਦਿਓ"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS ਭੇਜੋ"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"ਅਸਵੀਕਾਰ ਕਰੋ"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"ਵੀਡੀਓ ਕਾਲ ਵਜੋਂ ਜਵਾਬ ਦਿਓ"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"ਔਡੀਓ ਕਾਲ ਵਜੋਂ ਜਵਾਬ ਦਿਓ"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"ਵੀਡੀਓ ਬੇਨਤੀ ਸਵੀਕਾਰ ਕਰੋ"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"ਵੀਡੀਓ ਬੇਨਤੀ ਨੂੰ ਅਸਵੀਕਾਰ ਕਰੋ"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"ਵੀਡੀਓ ਟ੍ਰਾਂਸਮਿਟ ਬੇਨਤੀ ਨੂੰ ਸਵੀਕਾਰ ਕਰੋ"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"ਵੀਡੀਓ ਟ੍ਰਾਂਸਮਿਟ ਬੇਨਤੀ ਨੂੰ ਅਸਵੀਕਾਰ ਕਰੋ"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"ਵੀਡੀਓ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਬੇਨਤੀ ਨੂੰ ਸਵੀਕਾਰ ਕਰੋ"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"ਵੀਡੀਓ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਬੇਨਤੀ ਨੂੰ ਅਸਵੀਕਾਰ ਕਰੋ"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ਲਈ ਉੱਤੇ ਸਲਾਈਡ ਕਰੋ।"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ਲਈ ਖੱਬੇ ਪਾਸੇ ਸਲਾਈਡ ਕਰੋ।"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ਲਈ ਸੱਜੇ ਪਾਸੇ ਸਲਾਈਡ ਕਰੋ।"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ਲਈ ਹੇਠਾਂ ਸਲਾਈਡ ਕਰੋ।"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"ਥਰਥਰਾਹਟ"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"ਥਰਥਰਾਹਟ"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"ਧੁਨੀ"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"ਪੂਰਵ-ਨਿਰਧਾਰਤ ਧੁਨੀ (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"ਫੋਨ ਰਿੰਗਟੋਨ"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"ਘੰਟੀ ਵੱਜਣ \'ਤੇ ਥਰਥਰਾਹਟ"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"ਰਿੰਗਟੋਨ ਅਤੇ ਥਰਥਰਾਹਟ"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"ਕਾਨਫਰੰਸ ਕਾਲ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰੋ"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"ਐਮਰਜੈਂਸੀ ਨੰਬਰ"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ਸਕਿੰਟ</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ਸਕਿੰਟ</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ਮਿੰਟ</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ਮਿੰਟ</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ਘੰਟੇ</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ਘੰਟੇ</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"ਪ੍ਰੋਫਾਈਲ ਫੋਟੋ"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"ਕੈਮਰਾ ਬੰਦ ਹੈ"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> ਰਾਹੀਂ"</string>
+    <string name="note_sent" msgid="7623014827902758398">"ਨੋਟ-ਕਥਨ ਭੇਜਿਆ ਗਿਆ"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"ਹਾਲੀਆ ਸੁਨੇਹੇ"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"ਵਪਾਰ ਜਾਣਕਾਰੀ"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> ਮੀਲ ਦੂਰ"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> ਕਿ.ਮੀ. ਦੂਰ"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"ਕੱਲ੍ਹ <xliff:g id="OPEN_TIME">%s</xliff:g> ਵਜੇ ਖੁੱਲ੍ਹੇਗਾ"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"ਅੱਜ <xliff:g id="OPEN_TIME">%s</xliff:g> ਵਜੇ ਖੁੱਲ੍ਹੇਗਾ"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g> ਵਜੇ ਬੰਦ ਹੋਵੇਗਾ"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"ਅੱਜ <xliff:g id="CLOSE_TIME">%s</xliff:g> ਵਜੇ ਬੰਦ ਹੋਇਆ"</string>
+    <string name="open_now" msgid="4615706338669555999">"ਹੁਣ ਖੁੱਲ੍ਹਾ ਹੈ"</string>
+    <string name="closed_now" msgid="2635314668145282080">"ਹੁਣ ਬੰਦ ਹੈ"</string>
+</resources>
diff --git a/InCallUI/res/values-pl/strings.xml b/InCallUI/res/values-pl/strings.xml
new file mode 100644
index 0000000..8aa9795
--- /dev/null
+++ b/InCallUI/res/values-pl/strings.xml
@@ -0,0 +1,198 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Wstrzymane"</string>
+    <string name="unknown" msgid="3646075119047488748">"Nieznany"</string>
+    <string name="private_num" msgid="6081418498487514686">"Numer prywatny"</string>
+    <string name="payphone" msgid="5743050584468748607">"Automat telefoniczny"</string>
+    <string name="confCall" msgid="3181961445236675173">"Połączenie konferencyjne"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Połączenie przerwane"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Głośnik"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Słuchawka telefonu"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Przewodowy zestaw słuchawkowy"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Wysłać te tony?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Wysyłanie tonów\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Wyślij"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Tak"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Nie"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Zastąp symbol wieloznaczny"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Połączenie konferencyjne: <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Numer poczty głosowej"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Wybieranie"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Ponowne wybieranie numeru"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Połączenie konferencyjne"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Połączenie przychodzące"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Przychodzące połączenie służbowe"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Połączenie zakończone"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Wstrzymane"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Rozłączanie"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Trwa połączenie"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mój numer to <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Rozpoczynanie rozmowy wideo"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Rozmowa wideo"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Wysyłanie żądania wideo"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Nie można nawiązać połączenia wideo"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Żądanie wideo zostało odrzucone"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Twój numer oddzwaniania\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Twój numer oddzwaniania dla połączeń alarmowych\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Wybieranie"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Nieodebrane połączenie"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Nieodebrane połączenia"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"Nieodebrane połączenia: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Nieodebrane połączenie od: <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Trwa połączenie"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Trwa połączenie służbowe"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Trwa połączenie przez Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Trwa połączenie służbowe przez Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Wstrzymane"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Połączenie przychodzące"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Przychodzące połączenie służbowe"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Przychodzące połączenie przez Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Przychodzące połączenie służbowe przez Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Przychodząca rozmowa wideo"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Przychodzące żądanie wideo"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nowa poczta głosowa"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nowa poczta głosowa (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Wybierz numer <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Nieznany numer poczty głosowej"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Brak usługi"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Wybrana sieć (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) jest niedostępna"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Odbierz"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Rozłącz"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Wideo"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Głos"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Zaakceptuj"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Odrzuć"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Oddzwoń"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Wyślij SMS-a"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Aby rozpocząć połączenie, wyłącz najpierw tryb samolotowy."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Nie zarejestrowano w sieci."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Sieć komórkowa jest niedostępna."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Aby zadzwonić, wybierz prawidłowy numer."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Nie można dzwonić."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Rozpoczynam sekwencję MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Usługa nie jest obsługiwana."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Nie można przełączyć połączeń."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Nie można rozdzielić połączenia."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Nie można przekazać."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Nie można nawiązać połączenia konferencyjnego."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Nie można odrzucić połączenia."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Nie można zwolnić połączeń."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Połączenie SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Połączenie alarmowe"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Włączam radio…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Brak sieci. Próbuję ponownie…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Nie można dzwonić. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> nie jest numerem alarmowym."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Nie można dzwonić. Wybierz numer alarmowy."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Aby zadzwonić, użyj klawiatury"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Wstrzymaj połączenie"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Wznów połączenie"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Zakończ połączenie"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Klawiatura"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Wycisz"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Dodaj połączenie"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Scal połączenia"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Przełącz"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Zarządzaj połączeniami"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Zarządzaj połączeniem konferencyjnym"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Dźwięk"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Rozmowa wideo"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Zmień na połączenie głosowe"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Przełącz kamerę"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Wstrzymaj wideo"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Więcej opcji"</string>
+    <string name="player_started" msgid="3478865572468310331">"Odtwarzacz włączony"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Odtwarzacz zatrzymany"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera niegotowa"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera gotowa"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Nieznane zdarzenie sesji połączenia"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Usługa"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Konfiguracja"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Nie ustawiono&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Inne ustawienia połączeń"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Nawiązywanie połączenia przez <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Przychodzące z sieci <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"zdjęcie kontaktu"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"przejdź do rozmowy prywatnej"</string>
+    <string name="selectContact" msgid="92191462970821951">"wybierz kontakt"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Napisz własną..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Anuluj"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Wyślij"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Odbierz"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Wyślij SMS-a"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Odrzuć"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Odbierz jako rozmowę wideo"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Odbierz jako rozmowę audio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Zaakceptuj żądanie wideo"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Odrzuć żądanie wideo"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Zaakceptuj wysyłanie obrazu wideo"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Odrzuć wysyłanie obrazu wideo"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Zaakceptuj odbieranie obrazu wideo"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Odrzuć odbieranie obrazu wideo"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Przesuń w górę: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Przesuń w lewo: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Przesuń w prawo: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Przesuń w dół: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Wibracje"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Wibracje"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Dźwięk"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Domyślny dźwięk (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Dzwonek telefonu"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Wibracje z dzwonkiem"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Dzwonek i wibracje"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Zarządzaj połączeniem konferencyjnym"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Numer alarmowy"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> sekundy</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> sekund</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekundy</item>
+      <item quantity="one">1 sekunda</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> minuty</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> minut</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minuty</item>
+      <item quantity="one">1 minuta</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> godziny</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> godzin</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> godziny</item>
+      <item quantity="one">1 godzina</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Zdjęcie profilowe"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera wyłączona"</string>
+    <string name="child_number" msgid="4469090994612105532">"z <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Notatka wysłana"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Ostatnie wiadomości"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informacje o firmie"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mil(e) stąd"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km stąd"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>-<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Otwarte jutro od <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Otwarte dzisiaj od <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Zamknięte od <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Zamknięte dzisiaj od <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Teraz otwarte"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Teraz zamknięte"</string>
+</resources>
diff --git a/InCallUI/res/values-pt-rBR/strings.xml b/InCallUI/res/values-pt-rBR/strings.xml
new file mode 100644
index 0000000..06dc779
--- /dev/null
+++ b/InCallUI/res/values-pt-rBR/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefone"</string>
+    <string name="onHold" msgid="527593602772521700">"Em espera"</string>
+    <string name="unknown" msgid="3646075119047488748">"Desconhecido"</string>
+    <string name="private_num" msgid="6081418498487514686">"Número privado"</string>
+    <string name="payphone" msgid="5743050584468748607">"Chamada a cobrar"</string>
+    <string name="confCall" msgid="3181961445236675173">"Teleconferência"</string>
+    <string name="call_lost" msgid="8208184291640961172">"A chamada caiu."</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Alto-falante"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Minifone do aparelho"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Fone de ouvido com fio"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Enviar os seguintes tons?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Enviando tons\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Enviar"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Sim"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Não"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Substituir caractere curinga por"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Teleconferência <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Número do correio de voz"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Discando"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Rediscando"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Teleconferência"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Chamada recebida"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Chamada trabalho recebida"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Chamada encerrada"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Em espera"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Desligando"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Em chamada"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Meu número é <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Conectando vídeo"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videochamada"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Solicitando vídeo"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Não é possível conectar a videochamada"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Solicitação de vídeo rejeitada"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Seu número de retorno de chamada\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Seu número de retorno de chamada de emergência\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Discando"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Chamada perdida"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Chamadas perdidas"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> chamadas perdidas"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Chamada perdida de <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Chamanda em andamento"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Chamada de trabalho em andamento"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Chamada por Wi-Fi em andamento"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Chamada de trabalho por Wi-Fi em andamento"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Em espera"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Chamada recebida"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Chamada de trabalho recebida"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Chamada por Wi-Fi recebida"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Chamada de trabalho recebida por Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Videochamada recebida"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Solicitação de vídeo recebida"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Novo correio de voz"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Novo correio de voz (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Discar <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Número correio de voz desconhecido"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Sem serviço"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"A rede selecionada (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) está indisponível"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Atender"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Desligar"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Vídeo"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Voz"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Aceitar"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Dispensar"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Retor. cham."</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Mensagem"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Para fazer uma chamada, primeiro desative o modo avião."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Não registrado na rede."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Rede celular não disponível."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Para realizar uma chamada, digite um número válido."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Não é possível realizar chamadas."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Iniciando sequência MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Serviço não compatível."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Não é possível alternar as chamadas."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Não é possível separar a chamada."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Não é possível transferir a chamada."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Não é possível fazer uma conferência."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Não é possível rejeitar a chamada."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Não é possível liberar chamadas."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Chamada SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Chamada de emergência"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Ativando o rádio…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Sem serviço. Tentando novamente..."</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Não é possível realizar chamadas. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> não é um número de emergência."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Não é possível realizar chamadas. Disque um número de emergência."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Use o teclado para discar"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Colocar chamada em espera"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Retomar chamada"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Encerrar chamada"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Teclado"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Desativar som"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Adicionar chamada"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Mesclar chamadas"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Trocar"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Gerenciar chamadas"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Gerenciar teleconferência"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Áudio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videocham."</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Alterar para chamada de voz"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Alternar câmera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pausar vídeo"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Mais opções"</string>
+    <string name="player_started" msgid="3478865572468310331">"Player iniciado"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Player interrompido"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"A câmera não está pronta"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Câmera pronta"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Evento de sessão de chamada desconhecido"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Serviço"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Configuração"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Não definido&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Outras configurações de chamada"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Chamando via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Chamada de <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"foto do contato"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"conversar em particular"</string>
+    <string name="selectContact" msgid="92191462970821951">"selecionar contato"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Escreva sua resposta..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Cancelar"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Enviar"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Atender"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Enviar SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Recusar"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Atender como videochamada"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Atender como chamada de áudio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Aceitar solicitação de vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Recusar solicitação de vídeo"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Aceitar solicitação de transmissão de vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Recusar solicitação de transmissão de vídeo"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Aceitar solicitação de recebimento de vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Recusar solicitação de recebimento de vídeo"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>, deslize para cima."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>, deslize para a esquerda."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>, deslize para a direita."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>, deslize para baixo."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrar"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrar"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Som"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Som padrão (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Toque do telefone"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrar ao tocar"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Toque e vibração"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Gerenciar teleconferência"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Número de emergência"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> segundos</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> segundos</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> minutos</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutos</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> horas</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> horas</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Foto do perfil"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Câmera desligada"</string>
+    <string name="child_number" msgid="4469090994612105532">"via <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Nota enviada"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Mensagens recentes"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informações sobre a empresa"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> milhas de distância"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km de distância"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Abre amanhã às <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Abre hoje às <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Fecha às <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Fechou hoje às <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Aberto agora"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Fechado agora"</string>
+</resources>
diff --git a/InCallUI/res/values-pt-rPT/strings.xml b/InCallUI/res/values-pt-rPT/strings.xml
new file mode 100644
index 0000000..99e422c
--- /dev/null
+++ b/InCallUI/res/values-pt-rPT/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefone"</string>
+    <string name="onHold" msgid="527593602772521700">"Em espera"</string>
+    <string name="unknown" msgid="3646075119047488748">"Desconhecido"</string>
+    <string name="private_num" msgid="6081418498487514686">"Número privado"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefone público"</string>
+    <string name="confCall" msgid="3181961445236675173">"Conferência"</string>
+    <string name="call_lost" msgid="8208184291640961172">"A chamada caiu"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Altifalante"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Auricular do telefone"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Auscultadores com fios"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Pretende enviar os seguintes tons?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"A enviar tons\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Enviar"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Sim"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Não"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Substituir o caráter universal por"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Conferência <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Número do correio de voz"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"A marcar"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"A remarcar"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Conferência"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Chamada recebida"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Chamada de trab. recebida"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Chamada terminada"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Em espera"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"A desligar"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Numa chamada"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"O meu número é <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"A ligar vídeo"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videochamada"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"A solicitar vídeo"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Não é possível ligar a videochamada"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Pedido de vídeo rejeitado"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"O seu número de retorno de chamadas\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"O seu número de retorno de chamadas de emergência\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"A marcar"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Chamada não atendida"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Chamadas não atendidas"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> chamadas não atendidas"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Chamada não atendida de <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Chamada em curso"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Chamada de trabalho em curso"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Chamada Wi-Fi em curso"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Chamada de trabalho via Wi-Fi em curso"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Em espera"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Chamada recebida"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Chamada de trab. recebida"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Chamada Wi-Fi recebida"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Chamada de trabalho recebida via Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Videochamada recebida"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Pedido de vídeo recebido"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nova mensagem de correio de voz"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nova mensagem de correio de voz (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Marcar <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Número do correio de voz desconhecido"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Sem serviço"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Rede selecionada (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) indisponível"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Atender"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Desligar"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Vídeo"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Voz"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Aceitar"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Ignorar"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Ligar de volta"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Mensagem"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Para efetuar uma chamada, desative primeiro o Modo de avião."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Sem registo na rede."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Rede móvel não disponível."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Para efetuar uma chamada, introduza um número válido."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Não é possível telefonar."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"A iniciar sequência de MMI..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Serviço não suportado."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Não é possível alternar entre chamadas."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Não é possível separar a chamada."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Não é possível transferir."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Não é possível efetuar uma conferência."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Não é possível rejeitar a chamada."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Não é possível libertar as chamadas."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Chamada SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Chamada de emergência"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"A ligar o rádio..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Sem serviço. A tentar novamente…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Não é possível telefonar. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> não é um número de emergência."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Não é possível telefonar. Marque um número de emergência."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Utilizar o teclado para marcar"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Colocar chamada em espera"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Retomar chamada"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Terminar chamada"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Teclado"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Desativar som"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Adicionar chamada"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Intercalar chamadas"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Trocar"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Gerir chamadas"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Gerir conferência"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Áudio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videochamada"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Mudar para chamada de voz"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Trocar câmara"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Interromper vídeo"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Mais opções"</string>
+    <string name="player_started" msgid="3478865572468310331">"Leitor iniciado"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Leitor interrompido"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"A câmara não está pronta"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Câmara pronta"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Evento de sessão de chamada desconhecido"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Serviço"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Configuração"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Não definido&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Outras definições de chamadas"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"A telefonar através de <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Recebidas através de <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"foto do contacto"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"tornar privado"</string>
+    <string name="selectContact" msgid="92191462970821951">"selecionar contacto"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Escreva a sua própria..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Cancelar"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Enviar"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Atender"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Enviar SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Recusar"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Atender como videochamada"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Atender como chamada de áudio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Aceitar pedido de vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Recusar pedido de vídeo"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Aceitar pedido para transmitir vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Recusar pedido para transmitir vídeo"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Aceitar pedido para receber vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Recusar pedido para receber vídeo"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Deslize lentamente para cima para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Deslize lentamente para a esquerda para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Deslize lentamente para a direita para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Deslize lentamente para baixo para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrar"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrar"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Som"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Som predefinido (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Toque do telemóvel"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrar ao tocar"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Tocar e vibrar"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Gerir conferência"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Número de emergência"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> segundos</item>
+      <item quantity="one">1 segundo</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutos</item>
+      <item quantity="one">1 minuto</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> horas</item>
+      <item quantity="one">1 hora</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Foto do perfil"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Câmara desligada"</string>
+    <string name="child_number" msgid="4469090994612105532">"através de <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Nota enviada"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Mensagens recentes"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informações da empresa"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"A <xliff:g id="DISTANCE">%.1f</xliff:g> milhas de distância"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"A <xliff:g id="DISTANCE">%.1f</xliff:g> km de distância"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Abre amanhã às <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Abre hoje às <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Fecha às <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Fechou hoje às <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Aberto agora"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Fechado agora"</string>
+</resources>
diff --git a/InCallUI/res/values-pt/strings.xml b/InCallUI/res/values-pt/strings.xml
new file mode 100644
index 0000000..06dc779
--- /dev/null
+++ b/InCallUI/res/values-pt/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefone"</string>
+    <string name="onHold" msgid="527593602772521700">"Em espera"</string>
+    <string name="unknown" msgid="3646075119047488748">"Desconhecido"</string>
+    <string name="private_num" msgid="6081418498487514686">"Número privado"</string>
+    <string name="payphone" msgid="5743050584468748607">"Chamada a cobrar"</string>
+    <string name="confCall" msgid="3181961445236675173">"Teleconferência"</string>
+    <string name="call_lost" msgid="8208184291640961172">"A chamada caiu."</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Alto-falante"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Minifone do aparelho"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Fone de ouvido com fio"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Enviar os seguintes tons?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Enviando tons\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Enviar"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Sim"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Não"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Substituir caractere curinga por"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Teleconferência <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Número do correio de voz"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Discando"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Rediscando"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Teleconferência"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Chamada recebida"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Chamada trabalho recebida"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Chamada encerrada"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Em espera"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Desligando"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Em chamada"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Meu número é <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Conectando vídeo"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videochamada"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Solicitando vídeo"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Não é possível conectar a videochamada"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Solicitação de vídeo rejeitada"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Seu número de retorno de chamada\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Seu número de retorno de chamada de emergência\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Discando"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Chamada perdida"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Chamadas perdidas"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> chamadas perdidas"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Chamada perdida de <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Chamanda em andamento"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Chamada de trabalho em andamento"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Chamada por Wi-Fi em andamento"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Chamada de trabalho por Wi-Fi em andamento"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Em espera"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Chamada recebida"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Chamada de trabalho recebida"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Chamada por Wi-Fi recebida"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Chamada de trabalho recebida por Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Videochamada recebida"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Solicitação de vídeo recebida"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Novo correio de voz"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Novo correio de voz (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Discar <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Número correio de voz desconhecido"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Sem serviço"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"A rede selecionada (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) está indisponível"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Atender"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Desligar"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Vídeo"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Voz"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Aceitar"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Dispensar"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Retor. cham."</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Mensagem"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Para fazer uma chamada, primeiro desative o modo avião."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Não registrado na rede."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Rede celular não disponível."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Para realizar uma chamada, digite um número válido."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Não é possível realizar chamadas."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Iniciando sequência MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Serviço não compatível."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Não é possível alternar as chamadas."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Não é possível separar a chamada."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Não é possível transferir a chamada."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Não é possível fazer uma conferência."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Não é possível rejeitar a chamada."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Não é possível liberar chamadas."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Chamada SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Chamada de emergência"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Ativando o rádio…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Sem serviço. Tentando novamente..."</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Não é possível realizar chamadas. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> não é um número de emergência."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Não é possível realizar chamadas. Disque um número de emergência."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Use o teclado para discar"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Colocar chamada em espera"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Retomar chamada"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Encerrar chamada"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Teclado"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Desativar som"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Adicionar chamada"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Mesclar chamadas"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Trocar"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Gerenciar chamadas"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Gerenciar teleconferência"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Áudio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videocham."</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Alterar para chamada de voz"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Alternar câmera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pausar vídeo"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Mais opções"</string>
+    <string name="player_started" msgid="3478865572468310331">"Player iniciado"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Player interrompido"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"A câmera não está pronta"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Câmera pronta"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Evento de sessão de chamada desconhecido"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Serviço"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Configuração"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Não definido&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Outras configurações de chamada"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Chamando via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Chamada de <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"foto do contato"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"conversar em particular"</string>
+    <string name="selectContact" msgid="92191462970821951">"selecionar contato"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Escreva sua resposta..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Cancelar"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Enviar"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Atender"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Enviar SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Recusar"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Atender como videochamada"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Atender como chamada de áudio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Aceitar solicitação de vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Recusar solicitação de vídeo"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Aceitar solicitação de transmissão de vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Recusar solicitação de transmissão de vídeo"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Aceitar solicitação de recebimento de vídeo"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Recusar solicitação de recebimento de vídeo"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>, deslize para cima."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>, deslize para a esquerda."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>, deslize para a direita."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Para <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>, deslize para baixo."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrar"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrar"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Som"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Som padrão (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Toque do telefone"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrar ao tocar"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Toque e vibração"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Gerenciar teleconferência"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Número de emergência"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> segundos</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> segundos</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> minutos</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minutos</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> horas</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> horas</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Foto do perfil"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Câmera desligada"</string>
+    <string name="child_number" msgid="4469090994612105532">"via <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Nota enviada"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Mensagens recentes"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informações sobre a empresa"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> milhas de distância"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km de distância"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Abre amanhã às <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Abre hoje às <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Fecha às <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Fechou hoje às <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Aberto agora"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Fechado agora"</string>
+</resources>
diff --git a/InCallUI/res/values-ro/strings.xml b/InCallUI/res/values-ro/strings.xml
new file mode 100644
index 0000000..0dedab7
--- /dev/null
+++ b/InCallUI/res/values-ro/strings.xml
@@ -0,0 +1,195 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"În așteptare"</string>
+    <string name="unknown" msgid="3646075119047488748">"Necunoscut"</string>
+    <string name="private_num" msgid="6081418498487514686">"Număr privat"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefon public"</string>
+    <string name="confCall" msgid="3181961445236675173">"Conferință telefonică"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Apelul s-a încheiat"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Difuzor"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Casca receptorului"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Set căști-microfon cu fir"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Trimiteți următoarele tonuri?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Se trimit tonuri\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Trimiteți"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Da"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Nu"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Înlocuiți metacaracterul cu"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Conferință telefonică <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Numărul mesageriei vocale"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Se apelează"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Se reapelează"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Conferință telefonică"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Apel primit"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Apel de serviciu primit"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Apel încheiat"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"În așteptare"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Se încheie apelul"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Apel în desfășurare"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Numărul meu este <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Se conectează apelul video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Apel video"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Se solicită apel video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Nu se poate conecta apelul video"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Solicitarea pentru apel video a fost respinsă"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Numărul de apelare inversă\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Numărul de apelare inversă de urgență\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Se apelează"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Apel nepreluat"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Apeluri nepreluate"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> (de) apeluri nepreluate"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Apel nepreluat de la <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Apel în desfășurare"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Apel de serviciu în desfășurare"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Apel prin Wi-Fi în desfășurare"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Apel de serviciu prin Wi-Fi în desfășurare"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"În așteptare"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Apel primit"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Apel de serviciu primit"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Apel prin Wi-Fi primit"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Apel de serviciu prin Wi-Fi primit"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Apel video primit"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Solicitare de trecere la apel video"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Mesaj vocal nou"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Mesaj vocal nou (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Apelați <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Numărul mesageriei vocale este necunoscut"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Fără semnal"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Rețeaua selectată (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) nu este disponibilă"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Răspundeți"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Încheiați apelul"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Apel video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Apel vocal"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Acceptați"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Refuzați"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Apelați înapoi"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Trimiteți mesaj"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Pentru a apela, mai întâi dezactivați modul Avion."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Neînregistrat în rețea."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Rețeaua mobilă nu este disponibilă."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Pentru a apela, introduceți un număr valid."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Nu se poate apela."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Se pornește secvența MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Serviciul nu este acceptat."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Apelurile nu pot fi comutate."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Apelul nu poate fi separat."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Nu se poate transfera."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Conferința telefonică nu poate fi inițiată."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Apelul nu poate fi respins."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Apelurile nu pot fi eliberate."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Apel SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Apel de urgență"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Se activează radio…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Fără semnal. Se încearcă din nou…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Nu se poate apela. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> nu este un număr de urgență."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Nu se poate apela. Formați un număr de urgență."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Folosiți tastatura pentru a apela"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Puneți apelul în așteptare"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Reluați apelul"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Încheiați apelul"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Tastatură numerică"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Dezactivați sunetul"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Adăugați un apel"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Îmbinați apelurile"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Schimbați"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Gestionați apelurile"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Gestionați conferința telefonică"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Apel video"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Treceți la apel vocal"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Comutați camera foto"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Întrerupeți apelul video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Mai multe opțiuni"</string>
+    <string name="player_started" msgid="3478865572468310331">"Playerul a pornit"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Playerul s-a oprit"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Camera foto nu este pregătită"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Camera foto este pregătită"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Eveniment necunoscut privind o sesiune de apeluri"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Furnizor de servicii"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Configurați"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Nesetat&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Alte setări de apel"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Se apelează prin <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Primite prin <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"fotografia persoanei de contact"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"treceți în modul privat"</string>
+    <string name="selectContact" msgid="92191462970821951">"selectați o persoană de contact"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Scrieți propriul răspuns…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Anulați"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Trimiteți"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Răspundeți"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Trimiteți SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Refuzați"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Răspundeți ca apel video"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Răspundeți ca apel audio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Acceptați solicitarea de a trece la apel video"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Refuzați solicitarea de a trece la apel video"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Acceptați solicitarea de a transmite conținut video"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Refuzați solicitarea de a transmite conținut video"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Acceptați solicitarea de a primi conținut video"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Refuzați solicitarea de a primi conținut video"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Glisați în sus ca să <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Glisați spre stânga ca să <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Glisați spre dreapta ca să <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Glisați în jos ca să <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrații"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrații"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Sunet"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Sunet prestabilit (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Ton de sonerie pentru telefon"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrează când sună"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Ton de sonerie și vibrații"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Gestionați conferința telefonică"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Număr de urgență"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> secunde</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> de secunde</item>
+      <item quantity="one">O secundă</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> minute</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> de minute</item>
+      <item quantity="one">Un minut</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> ore</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> de ore</item>
+      <item quantity="one">O oră</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Fotografie de profil"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Camera foto este oprită"</string>
+    <string name="child_number" msgid="4469090994612105532">"pe <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Nota a fost trimisă"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Mesaje recente"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informații despre companie"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mi distanță"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km distanță"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Deschide mâine la <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Deschide astăzi la <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Închide la <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"A închis astăzi la <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Acum este deschis"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Acum este închis"</string>
+</resources>
diff --git a/InCallUI/res/values-ru/strings.xml b/InCallUI/res/values-ru/strings.xml
new file mode 100644
index 0000000..aa84999
--- /dev/null
+++ b/InCallUI/res/values-ru/strings.xml
@@ -0,0 +1,198 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Телефон"</string>
+    <string name="onHold" msgid="527593602772521700">"На удержании"</string>
+    <string name="unknown" msgid="3646075119047488748">"Неизвестный абонент"</string>
+    <string name="private_num" msgid="6081418498487514686">"Скрытый номер"</string>
+    <string name="payphone" msgid="5743050584468748607">"Телефон-автомат"</string>
+    <string name="confCall" msgid="3181961445236675173">"Конференц-вызов"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Звонок сброшен"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Динамик"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Динамик гарнитуры"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Проводная гарнитура"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Отправить следующие тоны?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Отправка тональных сигналов\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Отправить"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Да"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Нет"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Заменить универсальный символ на"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Конференц-вызов: <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Номер голосовой почты"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Набор номера…"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Повторный вызов"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Конференц-вызов"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Входящий вызов"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Входящий вызов (работа)"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Вызов завершен"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"На удержании"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Завершение разговора"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Вызов"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Мой номер: <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Подключение видео"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Видеовызов"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Запрос видео"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Не удалось совершить видеовызов"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Видеовызов отклонен"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Номер обратного вызова:\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Номер обратного вызова для экстренных служб:\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Набор номера…"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Пропущенный вызов"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Пропущенные вызовы"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"Пропущенных вызовов: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Пропущенные вызовы от абонента <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Текущий вызов"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Текущий звонок (работа)"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Текущий Wi-Fi-звонок"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Текущий Wi-Fi-звонок (работа)"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"На удержании"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Входящий вызов"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Входящий вызов (работа)"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Входящий Wi-Fi-звонок"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Входящий Wi-Fi-звонок (работа)"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Входящий видеовызов"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Входящий видеовызов"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Новое сообщение голосовой почты"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Новое сообщение голосовой почты (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Набрать номер <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Номер голосовой почты неизвестен"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Нет сигнала"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Выбранная сеть (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) недоступна."</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Ответить"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Завершить"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Видео"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Голос"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Разрешить"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Закрыть"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Перезвонить"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Написать SMS"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Отключите режим полета."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Нет регистрации в сети."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Мобильная сеть недоступна."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Недействительный номер."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Не удалось позвонить."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Запуск последовательности MMI..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Сервис не поддерживается."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Не удалось переключить вызов."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Не удалось разделить вызов."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Не удалось перенести."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Не удалось выполнить конференц-вызов."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Не удалось отклонить вызов."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Не удалось разъединить."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Вызов SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Экстренный вызов"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Включение радио…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Нет сигнала. Повторная попытка…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Не удалось позвонить. Номер <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> не принадлежит экстренным службам."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Не удалось позвонить. Наберите номер экстренных служб."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Используйте клавиатуру для набора номера"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Удерживать вызов"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Возобновить вызов"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Завершить вызов"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Кнопки"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Отключить звук"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Добавить вызов"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Объединить вызовы"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Перевести звонок"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Управление вызовами"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Настройка конференц-связи"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Аудио"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Видеовызов"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Отключить видео"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Сменить камеру"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Приостановить видео"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Другие настройки"</string>
+    <string name="player_started" msgid="3478865572468310331">"Видеоплеер включен"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Видеоплеер отключен"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Камера недоступна"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Камера доступна"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Неизвестное событие сеанса связи"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Служба"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Настройка"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Не задано&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Другие настройки вызовов"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Звонок через <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Входящий вызов (оператор: <xliff:g id="PROVIDER_NAME">%s</xliff:g>)"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"фотография контакта"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"приватная конференция"</string>
+    <string name="selectContact" msgid="92191462970821951">"выбрать контакт"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Ваш ответ…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Отмена"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Отправить"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Ответить"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Отправить SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Отклонить"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Ответить с видео"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Ответить на голосовой вызов"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Ответить на видеовызов"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Отклонить видеовызов"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Разрешить передачу видео"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Отклонить передачу видео"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Принять видео"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Отклонить видео"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Проведите вверх, чтобы <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Проведите влево, чтобы <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Проведите вправо, чтобы <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Проведите вниз, чтобы <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Вибросигнал"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Вибросигнал"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Звук"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"По умолчанию (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Рингтон"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Вибросигнал и рингтон"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Мелодия звонка и вибросигнал"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Настройка конференц-связи"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Экстренная служба"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> секунда</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> секунды</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> секунд</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> секунды</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> минута</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> минуты</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> минут</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> минуты</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> час</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> часа</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> часов</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> часа</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Фото профиля"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Камера отключена"</string>
+    <string name="child_number" msgid="4469090994612105532">"через <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Сообщение отправлено"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Недавние сообщения"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Информация о компании"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> мил."</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> км"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>–<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Откроется завтра в <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Откроется сегодня в <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Работает до <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Сегодня не работает с <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Сейчас открыто"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Сейчас закрыто"</string>
+</resources>
diff --git a/InCallUI/res/values-si-rLK/strings.xml b/InCallUI/res/values-si-rLK/strings.xml
new file mode 100644
index 0000000..afd74d0
--- /dev/null
+++ b/InCallUI/res/values-si-rLK/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"දුරකථනය"</string>
+    <string name="onHold" msgid="527593602772521700">"රඳවා ගනිමින්"</string>
+    <string name="unknown" msgid="3646075119047488748">"නොදනී"</string>
+    <string name="private_num" msgid="6081418498487514686">"රහසිගත අංකය"</string>
+    <string name="payphone" msgid="5743050584468748607">"පේෆෝනය"</string>
+    <string name="confCall" msgid="3181961445236675173">"සම්මන්ත්‍රණ ඇමතුම"</string>
+    <string name="call_lost" msgid="8208184291640961172">"ඇමතුම නැවතුණි"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"නාදකය"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"හෑන්ඩ්සෙටයේ සවන් කඬ"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"රැහැන් සහිත හෙඩ්සෙටය"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"බ්ලූටූත්"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"පහත නාද යවන්නද?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"නාද යවමින්\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"යවන්න"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"ඔව්"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"නැත"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"අනුලකුණ ප්‍රතිස්ථාපනය කරන්නේ"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"සම්මන්ත්‍රණ ඇමතුම <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"හඬ තැපැල් අංකය"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"ඩයල් කරමින්"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"නැවත ඩයල් කරමින්"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"සම්මන්ත්‍රණ ඇමතුම"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"එන ඇමතුම"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"එන කාර්යාල ඇමතුම"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"ඇමතුම අවසන් විය"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"රඳවා ගනිමින්"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"විසන්ධි කරමින්"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"ඇමතුමක"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"මගේ අංකය <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"වීඩියෝවකට සම්බන්ධ කරමින්"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"වීඩියෝ ඇමතුම"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"වීඩියෝවක් ඉල්ලමින්"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"වීඩියෝ ඇමතුම සම්බන්ධ කළ නොහැක"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"වීඩියෝ ඉල්ලීම ප්‍රතික්ෂේප කරන ලදී"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"ඔබේ පසුඇමතුම් අංකය\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"ඔබගේ හදිසි පසුඇමතුම් අංකය\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"ඩයල් කරමින්"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"මඟ හැරුණු ඇමතුම"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"මඟ හැරුණු ඇමතුම්"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"මඟ හැරුණු ඇමතුම් <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> වෙතින් මඟ හැරුණු ඇමතුම"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"කරගෙන යන ඇමතුම"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"කරගෙන යන කාර්යාල ඇමතුම"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"දැනට කරගෙන යන Wi-Fi ඇමතුම"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"කරගෙන යන Wi-Fi කාර්යාල ඇමතුම"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"රඳවා ගනිමින්"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"එන ඇමතුම"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"එන කාර්යාල ඇමතුම"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"එන Wi-Fi ඇමතුම"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"එන Wi-Fi කාර්යාල ඇමතුම"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"එන වීඩියෝ ඇමතුම"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"එන වීඩියෝ ඉල්ලීම"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"නව හඬ තැපෑල"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"නව හඬ තැපැල් (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> ඩයල් කරන්න"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"හඬ තැපැල් අංකය නොදනී"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"සේවාව නැත"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"තෝරා ඇති ජාලය (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) නොමැත"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"පිළිතුරු දෙන්න"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"විසන්ධි කරන්න"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"වීඩියෝව"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"හඬ"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"පිළිගන්න"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"අස් කරන්න"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"පසුඇමතුම"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"පණිවිඩය"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"ඇමතුමක් ගැනීමට, මුලින්ම ගුවන් යානා ප්‍රකාරය ක්‍රියාවිරහිත කරන්න."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"ජාලය මත ලියාපදිංචි වී නැත."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"සෙලියුලර් ජාලය නොතිබේ."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"ඇමතුමක් ගැනීමට, වලංගු අංකයක් ඇතුළු කරන්න."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"ඇමතුම් ගැනීමට නොහැක."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI අනුපිළිවෙළ ආරම්භ කරමින්…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"සේවාවට සහාය දක්වන්නේ නැත."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"ඇමතුම් මාරු කිරීම කළ නොහැක."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"ඇමතුම වෙන් කිරීම කළ නොහැක."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"මාරු කිරීමට නොහැක."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"සම්මන්ත්‍රණය කළ නොහැක."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"ඇමතුම ප්‍රතික්ෂේප කළ නොහැක."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"ඇමතුම(ම්) මුදාහැරීම කළ නොහැක."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP ඇමතුම"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"හදිසි ඇමතුම"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"රේඩියෝව ක්‍රියාත්මක කරමින්…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"සේවාව නැත. නැවත උත්සාහ කරමින්…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"ඇමතීමට නොහැකිය. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> මෙය හදිසි ඇමතුම් අංකයක් නොවේ."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"ඇමතිය නොහැක. හදිසි අංකයක් අමතන්න."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ඩයල් කිරීමට යතුරු පුවරුව භාවිත කරන්න"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"ඇමතුම රඳවා ගන්න"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"ඇමතුම නැවත පටන් ගන්න"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"ඇමතුම අවසන් කරන්න"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"ඩයල් පෑඩය"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"නිහඬ කරන්න"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"ඇමතුමක් එක් කරන්න"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"ඇමතුම් ඒකාබද්ධ කරන්න"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"මාරු කරන්න"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"ඇමතුම් කළමනාකරණය කරන්න"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"සම්මන්ත්‍රණ ඇමතුම කළමනාකරණය කරන්න"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"ශ්‍රව්‍යය"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"වීඩියෝ ඇමතුම"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"හඬ ඇමතුමක් වෙත මාරු කරන්න"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"කැමරාව මාරු කරන්න"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"විඩියෝව විරාම කරන්න"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"තවත් විකල්ප"</string>
+    <string name="player_started" msgid="3478865572468310331">"ධාවකය ආරම්භ කරන ලදි"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"ධාවකය නැවතුණි"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"කැමරාව සූදානම් නැහැ"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"කැමරාව සූදානම්"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"නොදන්නා ඇමතුම් සැසි සිදුවීම"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"සේවාව"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"පිහිටුවීම"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;පිහිටුවා නැත&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"වෙනත් ඇමතුම් සැකසීම්"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> හරහා අමතමින්"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> හරහා එන"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"සම්බන්ධතා ඡායාරූපය"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"රහසිගත වන්න"</string>
+    <string name="selectContact" msgid="92191462970821951">"සම්බන්ධතාවය තෝරාගන්න"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"ඔබේම එකක් ලියන්න..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"අවලංගු කරන්න"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"යවන්න"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"පිළිතුරු දෙන්න"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS යවන්න"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"ප්‍රතික්ෂේප කිරීම"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"වීඩියෝ ඇමතුමට පිළිතුරු දෙන්න"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"ශ්‍රව්‍ය ඇමතුමට පිළිතුරු දෙන්න"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"වීඩියෝ ඉල්ලීම පිළිගන්න"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"වීඩියෝ ඉල්ලීම ප්‍රතික්ෂේප කරන්න"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"වීඩියෝ සම්ප්‍ර්ෂණ ඉල්ලීම පිළිගන්න"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"වීඩියෝ සම්ප්‍ර්ෂණ ඉල්ලීම ප්‍රතික්ෂේප කරන්න"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"වීඩියෝ ලැබීමේ ඉල්ලීම පිළිගන්නා ලදි"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"වීඩියෝ ලැබීමේ ඉල්ලීම ප්‍රතික්ෂේප කරන්න"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> සඳහා උඩට සර්පණය කරන්න."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> සඳහා වමට සර්පණය කරන්න."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> සඳහා දකුණට සර්පණය කරන්න."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> සඳහා පහළට සර්පණය කරන්න."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"කම්පනය"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"කම්පනය"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"හඬ"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"පෙරනිමි ශබ්දය (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"දුරකථන රිගින්ටෝනය"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"රිගින් වන විට කම්පන වන්න"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"රිගින් ටෝන් සහ කම්පනය කරන්න"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"සම්මන්ත්‍රණ ඇමතුම කළමනාකරණය කරන්න"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"හදිසි ඇමතුම් අංකය"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one">තත්පර <xliff:g id="COUNT">%d</xliff:g></item>
+      <item quantity="other">තත්පර <xliff:g id="COUNT">%d</xliff:g></item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one">මිනිත්තු <xliff:g id="COUNT">%d</xliff:g></item>
+      <item quantity="other">මිනිත්තු <xliff:g id="COUNT">%d</xliff:g></item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one">පැය <xliff:g id="COUNT">%d</xliff:g></item>
+      <item quantity="other">පැය <xliff:g id="COUNT">%d</xliff:g></item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"පැතිකඩ ඡායාරූපය"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"කැමරාව ක්‍රියාවිරහිතයි"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> හරහා"</string>
+    <string name="note_sent" msgid="7623014827902758398">"සටහන යවන ලදී"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"මෑත පණිවිඩ"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"ව්‍යාපාර තොරතුරු"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"සැතපුම් <xliff:g id="DISTANCE">%.1f</xliff:g>ක් ඈතින්"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"කි.මි. <xliff:g id="DISTANCE">%.1f</xliff:g>ක් ඈතින්"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"හෙට <xliff:g id="OPEN_TIME">%s</xliff:g>ට විවෘත කෙරේ"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"අද <xliff:g id="OPEN_TIME">%s</xliff:g>ට විවෘත කෙරේ"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g>ට වසයි"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"අද <xliff:g id="CLOSE_TIME">%s</xliff:g>ට වසන ලදී"</string>
+    <string name="open_now" msgid="4615706338669555999">"දැන් විවෘතයි"</string>
+    <string name="closed_now" msgid="2635314668145282080">"දැන් වසා ඇත"</string>
+</resources>
diff --git a/InCallUI/res/values-sk/strings.xml b/InCallUI/res/values-sk/strings.xml
new file mode 100644
index 0000000..9064041
--- /dev/null
+++ b/InCallUI/res/values-sk/strings.xml
@@ -0,0 +1,198 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefón"</string>
+    <string name="onHold" msgid="527593602772521700">"Podržaný hovor"</string>
+    <string name="unknown" msgid="3646075119047488748">"Neznáme"</string>
+    <string name="private_num" msgid="6081418498487514686">"Súkromné číslo"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefónny automat"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferenčný hovor"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Hovor bol prerušený"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Reproduktor"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Slúchadlo"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Náhlavná súprava s káblom"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Odoslať nasledujúce tóny?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Odosielanie tónov\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Odoslať"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Áno"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Nie"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Nahradiť zástupný znak znakom"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferenčný hovor <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Číslo hlasovej schránky"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Vytáča sa"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Znova sa vytáča"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferenčný hovor"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Prichádzajúci hovor"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Prichádzajúci prac. hovor"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Hovor bol ukončený"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Podržaný hovor"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Ukončovanie hovoru"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Prebieha hovor"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Moje číslo je <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Pripája sa video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videohovor"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Žiada sa video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Videohovor nie je možné pripojiť"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Žiadosť o video bola odmietnutá"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Vaše číslo na spätné volanie\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Vaše číslo na spätné tiesňové volanie\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Vytáča sa"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Zmeškaný hovor"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Zmeškané hovory"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"Zmeškané hovory: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Zmeškaný hovor od volajúceho <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Prebiehajúci hovor"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Prebiehajúci pracovný hovor"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Odchádzajúci hovor cez Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Prebiehajúci pracovný hovor cez Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Podržaný hovor"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Prichádzajúci hovor"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Prichádzajúci pracovný hovor"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Prichádzajúci hovor cez Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Prichádzajúci pracovný hovor cez Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Prichádzajúci videohovor"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Prichádzajúca žiadosť o video"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nová hlasová správa"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nová hlasová správa (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Zavolať hlasovú schránku <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Číslo hlasovej schránky je neznáme"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Žiadny signál"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Vybraná sieť (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) nie je k dispozícii"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Prijať"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Položiť"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Hlas"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Prijať"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Zatvoriť"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Zavolať späť"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Správa"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Ak chcete volať, vypnite najprv režim v lietadle."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Prihlásenie do siete nebolo úspešné."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobilná sieť nie je k dispozícii."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Ak chcete volať, zadajte platné číslo."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Hovor sa nedá uskutočniť."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Prebieha spúšťanie sekvencie MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Služba nie je podporovaná."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Nedajú sa prepínať hovory."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Nedá sa rozdeliť hovor."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Nedá sa preniesť."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Konferenčný hovor sa nedá uskutočniť."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Nedá sa odmietnuť hovor."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Nedajú sa ukončiť hovory."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Hovor SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Tiesňové volanie"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Zapína sa rádio..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Žiadny signál. Prebieha ďalší pokus…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Hovor sa nedá uskutočniť. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> nie je číslo tiesňového volania."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Hovor nie je možné uskutočniť. Vytočte číslo tiesňového volania."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Číslo vytočíte pomocou klávesnice"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Podržať hovor"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Obnoviť hovor"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Ukončiť hovor"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Číselná klávesnica"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Ignorovať"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Pridať hovor"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Zlúčiť hovory"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Zameniť"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Spravovať hovory"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Spravovať konferenčný hovor"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Zvuk"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videohovor"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Zmeniť na hlasový hovor"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Zapnúť kameru"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pozastaviť video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Ďalšie možnosti"</string>
+    <string name="player_started" msgid="3478865572468310331">"Prehrávač bol spustený"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Prehrávač bol zastavený"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera nie je pripravená"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera je pripravená"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Neznáma udalosť relácie volania"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Služba"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Nastavenie"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Nenastavené&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Ďalšie nastavenia hovorov"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Voláte prostredníctvom poskytovateľa <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Prichádz. hovor prostred. poskytovateľa <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"fotka kontaktu"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"prepnúť na súkromné"</string>
+    <string name="selectContact" msgid="92191462970821951">"vybrať kontakt"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Napísať vlastnú..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Zrušiť"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Odoslať"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Prijať"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Odoslať SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Odmietnuť"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Prijať ako videohovor"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Prijať ako zvukový hovor"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Prijať žiadosť o videohovor"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Odmietnuť žiadosť o videohovor"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Prijať žiadosť o prenos videa"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Odmietnuť žiadosť o prenos videa"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Povoliť žiadosť o prijatie videa"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Odmietnuť žiadosť o prijatie videa"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Prejdite prstom nahor: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Prejdite prstom doľava: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Prejdite prstom doprava: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Prejdite prstom nadol: <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrovanie"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrovanie"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Zvuk"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Predvolený zvuk (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Tón zvonenia telefónu"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibrovať pri zvonení"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Vyzváňací tón a vibrovanie"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Správa konferenčného hovoru"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Číslo tiesňového volania"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> sekundy</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> sekundy</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekúnd</item>
+      <item quantity="one">1 sekunda</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> minúty</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> minúty</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minút</item>
+      <item quantity="one">1 minúta</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> hodiny</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> hodiny</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> hodín</item>
+      <item quantity="one">1 hodina</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profilová fotka"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera je vypnutá"</string>
+    <string name="child_number" msgid="4469090994612105532">"na čísle <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Poznámka bola odoslaná"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Nedávne správy"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informácie o firme"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"Vzdialené <xliff:g id="DISTANCE">%.1f</xliff:g> mi"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"Vzdialené <xliff:g id="DISTANCE">%.1f</xliff:g> km"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Zajtra sa otvára o <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Dnes sa otvára o <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Zatvára sa o <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Dnes bolo zatvorené o <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Otvorené"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Zatvorené"</string>
+</resources>
diff --git a/InCallUI/res/values-sl/strings.xml b/InCallUI/res/values-sl/strings.xml
new file mode 100644
index 0000000..be7bf42
--- /dev/null
+++ b/InCallUI/res/values-sl/strings.xml
@@ -0,0 +1,198 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Zadržan"</string>
+    <string name="unknown" msgid="3646075119047488748">"Neznan"</string>
+    <string name="private_num" msgid="6081418498487514686">"Zasebna številka"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefonska govorilnica"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferenčni klic"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Klic je bil prekinjen"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Zvočnik"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Slušalka"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Žične slušalke"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Ali želite poslati naslednje tone?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Pošiljanje tonov\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Pošlji"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Da"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Ne"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Zamenjaj nadomestni znak z"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferenčni klic: <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Številka odzivnika"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Klicanje"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Vnovično klicanje"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferenčni klic"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Dohodni klic"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Dohodni delovni klic"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Klic je končan"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Zadržan"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Prekinjanje"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Klic poteka"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Moja številka je <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Povezovanje videa"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videoklic"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Zahtevanje videa"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Videoklica ni mogoče vzpostaviti"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Zavrnjena zahteva za videoklic"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Vaša številka za povratni klic:\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Vaša številka za povratni klic v sili:\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Klicanje"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Neodgovorjeni klic"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Neodgovorjeni klici"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"Št. neodgovorjenih klicev: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Neodgovorjeni klic od: <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Aktivni klic"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Aktivni delovni klic"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Aktivni klic prek omrežja Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Aktivni delovni klic prek omrežja Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Zadržan"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Dohodni klic"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Dohodni delovni klic"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Dohodni klic Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Dohodni delovni klic prek omrežja Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Dohodni videoklic"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Zahteva za dohodni video"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Novo sporočilo v odzivniku"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Novo sporočilo v odzivniku (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Klic: <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Neznana številka odzivnika"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Ni signala"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Izbrano omrežje (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) ni na voljo"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Odgovor"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Prekinitev"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Govor"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Sprejmem"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Opusti"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Povrat. klic"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"SMS"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Če želite poklicati, najprej izklopite način za letalo."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Ni registrirano v omrežju."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mobilno omrežje ni na voljo."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Če želite opraviti klic, vnesite veljavno številko."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Klicanje ni mogoče."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Začetek zaporedja MMI ..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Storitev ni podprta."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Preklop med klici ni mogoč."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Ločitev klica ni mogoča."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Prenos ni mogoč."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Konferenčni klic ni mogoč."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Zavrnitev klica ni mogoča."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Prekinitev klica ni mogoča."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Klic SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Klic v sili"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Vklop radia …"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Ni signala. Vnovičen poskus …"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Klicanje ni mogoče. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> ni številka za klic v sili."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Klicanje ni mogoče. Opravite klic v sili."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Za izbiranje številke uporabite tipkovnico"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Zadrži klic"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Nadaljuj klic"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Končaj klic"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Tipkovnica"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Izklopi zvok"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Dodaj klic"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Združi klice"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Zamenjaj"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Upravljaj klice"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Upravljaj konferenčne klice"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Zvok"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videoklic"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Preklopi na glasovni klic"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Preklopi med fotoaparati"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Zaustavi video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Več možnosti"</string>
+    <string name="player_started" msgid="3478865572468310331">"Predvajanje začeto"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Predvajanje ustavljeno"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Fotoaparat ni pripravljen"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Fotoaparat je pripravljen"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Neznan dogodek seje klica"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Storitev"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Nastavitev"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Ni nastavljeno&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Druge klicne nastavitve"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Klicanje prek ponudnika <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Dohodni prek <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"fotografija stika"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"zasebno"</string>
+    <string name="selectContact" msgid="92191462970821951">"izbira stika"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Napišite lasten odgovor …"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Prekliči"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Pošlji"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Odgovor"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Pošiljanje SMS-ja"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Zavrnitev"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Odgovor z video povezavo"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Odgovor z zvočno povezavo"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Sprejemanje zahteve za video"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Zavrnitev zahteve za video"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Sprejemanje zahteve za pošiljanje videa"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Zavrnitev zahteve za pošiljanje videa"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Sprejemanje zahteve za prejem videa"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Zavrnitev zahteve za prejem videa"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Povlecite navzgor za <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Povlecite v levo za <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Povlecite v desno za <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Povlecite navzdol za <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibriranje"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibriranje"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Zvok"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Privzeti zvok (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Ton zvonjenja telefona"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Vibriranje ob zvonjenju"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Zvonjenje in vibriranje"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Upravljanje konferenčnih klicev"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Številka za klic v sili"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> sekunda</item>
+      <item quantity="two"><xliff:g id="COUNT">%d</xliff:g> sekundi</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> sekunde</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekund</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> minuta</item>
+      <item quantity="two"><xliff:g id="COUNT">%d</xliff:g> minuti</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> minute</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minut</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> ura</item>
+      <item quantity="two"><xliff:g id="COUNT">%d</xliff:g> uri</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> ure</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ur</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Fotografija profila"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Fotoaparat je izklopljen"</string>
+    <string name="child_number" msgid="4469090994612105532">"prek <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Opomba poslana"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Nedavna sporočila"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Podatki o podjetju"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mi stran"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km stran"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>–<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Odpre se jutri ob <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Odpre se danes ob <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Zapre se ob <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Zaprto danes ob <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Trenutno odprto"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Trenutno zaprto"</string>
+</resources>
diff --git a/InCallUI/res/values-sq-rAL/strings.xml b/InCallUI/res/values-sq-rAL/strings.xml
new file mode 100644
index 0000000..83900fe
--- /dev/null
+++ b/InCallUI/res/values-sq-rAL/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefoni"</string>
+    <string name="onHold" msgid="527593602772521700">"Në pritje"</string>
+    <string name="unknown" msgid="3646075119047488748">"I panjohur"</string>
+    <string name="private_num" msgid="6081418498487514686">"Numër privat"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefon me pagesë"</string>
+    <string name="confCall" msgid="3181961445236675173">"Telefonatë konferencë"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Telefonata ra"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Altoparlant"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Kufje për vesh"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Kufje me tel"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Dërgo tonet e mëposhtme?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Po dërgon tone\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Dërgo"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Po"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Jo"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Zëvendëso karakterin variabël me"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Telefonatë konferencë <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Numri i postës zanore"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Po formon numrin"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Po riformon numrin"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Telefonatë konferencë"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Telefonatë hyrëse"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Telefonatë pune hyrëse"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Telefonata përfundoi"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Në pritje"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Mbyllja"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Në telefonatë"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Numri im është <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Po rilidh videon"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Telefonatë me video"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Po kërkon video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Nuk mund të lidhë telefonatën me video"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Kërkesa me video u refuzua"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Numri i kthimit të telefonatës\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Numri i kthimit të telefonatës së urgjencës\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Po formon numrin"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Telefonatë e humbur"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Telefonata të humbura"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> telefonata të humbura"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Telefonatë e humbur nga <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Telefonatë në vazhdim"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Telefonatë pune dalëse"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Telefonatë me Wi-Fi në vazhdim"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Telefonatë pune dalëse me Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Në pritje"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Telefonatë hyrëse"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Telefonatë pune hyrëse"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Telefonatë hyrëse me Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Telefonatë pune hyrëse me Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Telefonatë hyrëse me video"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Kërkesë për video hyrëse"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Postë e re zanore"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Postë e re zanore (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Formo numrin <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Numri i postës zanore është i panjohur"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Nuk ka shërbim"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Rrjeti i zgjedhur (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) i padisponueshëm"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Përgjigju"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Mbyll"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Zanore"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Prano"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Largoje"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Ri-telefono"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Mesazh"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Për të kryer telefonatë, së pari çaktivizo modalitetin e aeroplanit."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"I paregjistruar në rrjet."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Rrjeti celular nuk mundësohet."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Për të kryer një telefonatë, fut një numër të vlefshëm."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Nuk mund të telefonojë."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Po fillon sekuencën MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Shërbimi nuk mbështetet."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Nuk mund të ndryshojë telefonatat."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Nuk mund të ndajë telefonatën."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Nuk mund të transferojë."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Nuk mund të kryejë telefonatë konference."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Nuk mund të refuzojë telefonatën."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Nuk mund të lëshojë telefonatën(at)."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Telefonatë SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Telefonata e urgjencës"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Po aktivizon radion…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Nuk ka shërbim. Po provon sërish…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Nuk mund të telefonohet. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> nuk është një numër urgjence."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Nuk mund të telefonohet. Formo një numër urgjence."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Përdor tastierën për të formuar numrin"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Vendose në pritje telefonatën"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Rifillo telefonatën"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Mbylle telefonatën"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Blloku i formimit të numrit"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Çaktivizo audion"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Shto telefonatë"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Shkri telefonatat"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Shkëmbe"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Menaxho telefonatat"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Menaxho telefonatën konferencë"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audioja"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Telefonatë me video"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Ndërro në telefonatë me video"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Ndërro kamerën"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Vendose në pauzë videon"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Opsione të tjera"</string>
+    <string name="player_started" msgid="3478865572468310331">"Luajtësi filloi"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Luajtësi ndaloi"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera nuk është gati"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera është gati"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Ngjarje e panjohur në sesionin e telefonatës"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Shërbimi"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Konfigurimi"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;I pavendosur&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Cilësime të tjera të telefonatës"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Telefonatë nëpërmjet <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Hyrëse nëpërmjet <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"fotografia e kontaktit"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"bëje private"</string>
+    <string name="selectContact" msgid="92191462970821951">"përzgjidh kontaktin"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Shkruaj përgjigjen tënde..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Anulo"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Dërgo"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Përgjigju"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Dërgo SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Refuzo"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Përgjigju si telefonatë me video"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Përgjigju si telefonatë me audio"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Prano kërkesën për video"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Refuzo kërkesën për video"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Prano kërkesën për transmetimin e videos"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Refuzo kërkesën për transmetimin e videos"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Prano kërkesën për marrjen e videos"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Refuzo kërkesën për marrjen e videos"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Rrëshqit lart për <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Rrëshqit majtas për <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Rrëshqit djathtas për <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Rrëshqit poshtë për <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Dridhja"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Dridhja"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Tingulli"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Tingulli i parazgjedhur (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Toni i ziles i telefonit"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Dridhje edhe kur bie zilja"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Me zile dhe me dridhje"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Menaxho telefonatën konferencë"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Numri i urgjencës"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekonda</item>
+      <item quantity="one">1 sekondë</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minuta</item>
+      <item quantity="one">1 minutë</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> orë</item>
+      <item quantity="one">1 orë</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Fotografia e profilit"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera joaktive"</string>
+    <string name="child_number" msgid="4469090994612105532">"përmes <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Shënimi u dërgua"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Mesazhet e fundit"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Informacioni i biznesit"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> milje larg"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km larg"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Hapet nesër në <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Hapet sot në <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Mbyllet në <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Mbyllur sot në <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Tani është hapur"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Tani është mbyllur"</string>
+</resources>
diff --git a/InCallUI/res/values-sr/strings.xml b/InCallUI/res/values-sr/strings.xml
new file mode 100644
index 0000000..06a2873
--- /dev/null
+++ b/InCallUI/res/values-sr/strings.xml
@@ -0,0 +1,195 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Телефон"</string>
+    <string name="onHold" msgid="527593602772521700">"На чекању"</string>
+    <string name="unknown" msgid="3646075119047488748">"Непознат"</string>
+    <string name="private_num" msgid="6081418498487514686">"Приватан број"</string>
+    <string name="payphone" msgid="5743050584468748607">"Телефонска говорница"</string>
+    <string name="confCall" msgid="3181961445236675173">"Конференцијски позив"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Позив је прекинут"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Звучник"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Слушалица телефона"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Жичане наглавне слушалице"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Желите ли да пошаљете следеће тонове?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Тонови се шаљу\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Пошаљи"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Да"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Не"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Замените џокер знак са"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Конференцијски позив <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Број говорне поште"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Позива се"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Поново се бира"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Конференцијски позив"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Долазни позив"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Долазни позив за Work"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Позив је завршен"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"На чекању"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Веза се прекида"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Позив је у току"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Мој број је <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Повезује се видео позив"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Видео позив"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Захтева се видео позив"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Повезивање видео позива није успело"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Захтев за видео позив је одбијен"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Број за повратни позив\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Број за хитан повратни позив\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Позива се"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Пропуштен позив"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Пропуштени позиви"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"Број пропуштених позива: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Пропуштен позив од: <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Текући позив"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Текући позив за Work"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Текући Wi-Fi позив"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Текући позив за Work преко Wi-Fi-ја"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"На чекању"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Долазни позив"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Долазни позив за Work"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Долазни Wi-Fi позив"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Долазни позив за Work преко Wi-Fi-ја"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Долазни видео позив"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Захтев за долазни видео позив"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Нова порука говорне поште"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Нова порука говорне поште (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Позови <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Непознат број говорне поште"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Мобилна мрежа није доступна"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Изабрана мрежа (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) није доступна"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Одговори"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Прекини везу"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Видео"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Гласовни"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Прихватам"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Одбаци"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Узврати позив"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Пошаљи SMS"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Да бисте упутили позив, прво искључите режим рада у авиону."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Није регистровано на мрежи."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Мобилна мрежа није доступна."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Да бисте упутили позив, унесите важећи број."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Позив није успео."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Покреће се MMI секвенца..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Услуга није подржана."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Замена позива није успела."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Раздвајање позива није успело."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Пребацивање није успело."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Конференцијски позив није успео."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Одбијање позива није успело."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Успостављање позива није успело."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP позив"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Хитни позив"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Укључује се радио…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Мобилна мрежа није доступна. Покушавамо поново…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Позив није успео. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> није број за хитне случајеве."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Позив није успео. Позовите број за хитне случајеве."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Користите тастатуру за позивање"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Стави позив на чекање"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Настави позив"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Заврши позив"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Нумеричка тастатура"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Игнориши"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Додај позив"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Обједини позиве"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Замени"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Управљај позивима"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Управљај конференцијским позивом"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Аудио"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Видео позив"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Промени у гласовни позив"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Промени камеру"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Паузирај видео"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Још опција"</string>
+    <string name="player_started" msgid="3478865572468310331">"Плејер је покренут"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Плејер је заустављен"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Камера није спремна"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Камера је спремна"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Непознат догађај сесије позива"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Услуга"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Подешавање"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Није подешено&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Друга подешавања позива"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Позива се преко добављача <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Долазни позив преко <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"слика контакта"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"иди на приватно"</string>
+    <string name="selectContact" msgid="92191462970821951">"изаберите контакт"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Напишите сами…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Откажи"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Пошаљи"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Одговори"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Пошаљи SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Одбиј"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Одговори видео позивом"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Одговори аудио-позивом"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Прихвати захтев за видео"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Одбиј захтев за видео"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Прихвати захтев за одлазни видео позив"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Одбиј захтев за одлазни видео позив"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Прихвати захтев за долазни видео позив"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Одбиј захтев за долазни видео позив"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Превуците нагоре за <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Превуците улево за <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Превуците удесно за <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Превуците надоле за <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Вибрација"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Вибрација"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Звук"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Подразумевани звук (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Мелодија звона телефона"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Вибрирај када звони"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Мелодија звона и вибрација"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Управљај конференцијским позивом"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Број за хитне случајеве"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> секунда</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> секунде</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> секунди</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> минут</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> минута</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> минута</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> сат</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> сата</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> сати</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Слика профила"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Камера је искључена"</string>
+    <string name="child_number" msgid="4469090994612105532">"на <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Белешка је послата"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Недавне поруке"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Информације о предузећу"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"Удаљеност је <xliff:g id="DISTANCE">%.1f</xliff:g> mi"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"Удаљеност је <xliff:g id="DISTANCE">%.1f</xliff:g> km"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>–<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Отвара се сутра у <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Отвара се данас у <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Затвара се у <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Затворило се данас у <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Тренутно отворено"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Тренутно затворено"</string>
+</resources>
diff --git a/InCallUI/res/values-sv/strings.xml b/InCallUI/res/values-sv/strings.xml
new file mode 100644
index 0000000..7c10355
--- /dev/null
+++ b/InCallUI/res/values-sv/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Parkerat"</string>
+    <string name="unknown" msgid="3646075119047488748">"Okänd"</string>
+    <string name="private_num" msgid="6081418498487514686">"Privat nummer"</string>
+    <string name="payphone" msgid="5743050584468748607">"Telefonautomat"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferenssamtal"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Samtalet avbröts"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Högtalare"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Telefonlur"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Trådanslutet headset"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Ska följande toner skickas?\nBREAK"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Skickar signaler\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Skicka"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ja"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Nej"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Ersätt jokertecknet med"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferenssamtal <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Nummer till röstbrevlåda"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Ringer"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Ringer upp igen"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferenssamtal"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Inkommande samtal"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Inkommande jobbsamtal"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Samtal avslutat"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Parkerat"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Lägger på"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"I samtal"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mitt telefonnummer är <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Ansluter video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Videosamtal"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Begär video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Det gick inte att ansluta till videosamtalet"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Videobegäran avslogs"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Ditt nummer för återuppringning\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Ditt nummer för återuppringning vid nödsamtal\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Ringer"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Missat samtal"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Missade samtal"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> missade samtal"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Missat samtal från <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Pågående samtal"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Pågående jobbsamtal"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Pågående Wi-Fi-samtal"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Pågående jobbsamtal via Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Parkerat"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Inkommande samtal"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Inkommande jobbsamtal"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Inkommande Wi-Fi-samtal"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Inkommande jobbsamtal via Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Inkommande videosamtal"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Inkommande begäran om videosamtal"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Nytt röstmeddelande"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Nytt röstmeddelande (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Ring <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Nummer till röstbrevlåda okänt"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Ingen tjänst"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Det valda nätverket (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) är inte tillgängligt"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Svara"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Lägg på"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Röstsamtal"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Godkänn"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Ignorera"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Ring upp"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Meddelande"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Om du vill ringa måste du först inaktivera flygplansläge."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Inte registrerat på nätverk."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Det finns inget mobilnät tillgängligt."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Ange ett giltigt nummer om du vill ringa ett samtal."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Det gick inte att ringa."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Startar sekvens för MMI-kod …"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Tjänsten stöds inte."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Det gick inte att växla mellan samtal."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Det gick inte att koppla isär samtalen."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Det gick inte att överföra."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Det gick inte att starta ett konferenssamtal."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Det gick inte att avvisa samtalet."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Det gick inte att släppa samtal."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP-samtal"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Nödsamtal"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Sätter på radion …"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Ingen tjänst. Försöker igen …"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Det gick inte att ringa. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> är inget nödnummer."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Det gick inte att ringa. Slå ett nödnummer."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Använd tangentbordet om du vill ringa"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Parkera samtal"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Återuppta samtal"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Avsluta samtal"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Knappsats"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Ljud av"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Lägg till samtal"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Koppla ihop samtal"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Byt"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Hantera samtal"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Hantera konferenssamtal"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Ljud"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Videosamt."</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Byt till röstsamtal"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Byt kamera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Pausa video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Fler alternativ"</string>
+    <string name="player_started" msgid="3478865572468310331">"Videospelaren har startats"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Videospelaren har stoppats"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kameran är inte klar"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kameran är klar"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Okänd händelse vid samtalssession"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Tjänst"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Konfiguration"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Har inte angetts&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Övriga samtalsinställningar"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Ringer via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Inkommande via <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"kontaktbild"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"gör privat"</string>
+    <string name="selectContact" msgid="92191462970821951">"välj kontakt"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Skriv ett eget svar …"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Avbryt"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Skicka"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Svara"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Skicka sms"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Avvisa"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Svara som videosamtal"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Svara som röstsamtal"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Godkänn videobegäran"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Avvisa videobegäran"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Godkänn begäran om att skicka video"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Avvisa begäran om att skicka video"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Godkänn begäran om att ta emot video"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Avvisa begäran om att ta emot video"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> genom att dra uppåt."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> genom att dra åt vänster."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> genom att dra åt höger."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> genom att dra nedåt."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Vibrera"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Vibrera"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Ljud"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Standardsignal (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Ringsignal"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Enheten vibrerar vid samtal"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Ringsignal och vibration"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Hantera konferenssamtal"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Nödsamtalsnummer"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> sekunder</item>
+      <item quantity="one">1 sekund</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> minuter</item>
+      <item quantity="one">1 minut</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> timmar</item>
+      <item quantity="one">1 timme</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profilfoto"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera av"</string>
+    <string name="child_number" msgid="4469090994612105532">"via <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Anteckningen har skickats"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Senaste meddelandena"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Företagsuppgifter"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> miles bort"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km bort"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>–<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Öppnar i morgon kl. <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Öppnar i dag kl. <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Stänger kl. <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Stängde i dag kl. <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Öppet"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Stängt"</string>
+</resources>
diff --git a/InCallUI/res/values-sw/strings.xml b/InCallUI/res/values-sw/strings.xml
new file mode 100644
index 0000000..f1a2e1d
--- /dev/null
+++ b/InCallUI/res/values-sw/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Simu"</string>
+    <string name="onHold" msgid="527593602772521700">"Inangoja"</string>
+    <string name="unknown" msgid="3646075119047488748">"Isiyojulikana"</string>
+    <string name="private_num" msgid="6081418498487514686">"Nambari ya faragha"</string>
+    <string name="payphone" msgid="5743050584468748607">"Simu ya kulipia"</string>
+    <string name="confCall" msgid="3181961445236675173">"Simu ya mkutano"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Simu imekatwa"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Spika"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Kipaza sauti cha kichwani"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Vifaa vya sauti visivyo na waya"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Ungependa kutuma milio ya sauti inayofuata? \n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Inatuma milio ya simu\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Tuma"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ndiyo"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Hapana"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Badilisha herufi inayojitegemea kwa"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Simu ya mkutano <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Nambari ya ujumbe wa sauti"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Inapiga"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Inapiga simu tena"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Simu ya mkutano"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Unapigiwa simu"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Simu ya kazi inayoingia"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Simu imekamilika"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Inangoja"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Kukata simu"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Katika simu"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Nambari yangu ni <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Inaunganisha video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Hangout ya Video"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Inaomba video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Haiwezi kuunganisha Hangout ya video"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Ombi la video limekataliwa"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Nambari yako ya kupigiwa simu\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Nambari yako ya dharura ya kupigiwa simu\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Inapiga"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Simu ambayo hukujibu"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Simu ambazo hukujibu"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"Simu <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ambazo hukujibu"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Simu ambayo hukujibu kutoka <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Simu inayoendelea"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Simu ya kazi inayoendelea"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Simu ya Wi-Fi inayoendelea"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Simu ya Wi-Fi ya kazi inayoendelea"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Inangoja"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Unapigiwa simu"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Unapigiwa simu ya kazi"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Unapigiwa simu kupitia Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Unapigiwa simu ya kazini kupitia Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Hangout ya Video inayoingia"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Ombi linaloingia la video"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Ujumbe mpya wa sauti"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Ujumbe (<xliff:g id="COUNT">%d</xliff:g>) mpya wa sauti"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Piga <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Nambari ya ujumbe wa sauti haijulikani."</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Hakuna huduma"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Mtandao uliochaguliwa (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) haupatikani"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Jibu"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Kata simu"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Sauti"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Kubali"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Ondoa"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Mpigie"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Ujumbe"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Ili upige simu kwanza, zima Hali ya ndegeni."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Haijasajiliwa kwenye mtandao."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Mitandao ya simu za mkononi haipatikani."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Ili upige simu, weka nambari sahihi."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Haiwezi kupiga simu."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Inaanzisha msururu wa MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Huduma haitumiki."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Haiwezi kubadili simu."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Haiwezi kutenganisha simu."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Haiwezi kuhamisha."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Haiwezi kushiriki katika simu ya mkutano."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Haiwezi kukataa simu."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Haiwezi kutoa simu."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Simu ya SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Simu ya dharura"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Inawasha redio..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Hakuna huduma. Inajaribu tena..."</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Haiwezi kupiga simu. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> si nambari ya dharura."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Haiwezi kupiga simu. Piga simu nambari ya dharura."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Tumia kibodi kubonyeza"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Shikilia Simu"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Endelea na Simu"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Kata Simu"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Vitufe vya kupiga simu"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Komesha"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Ongeza simu"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Unganisha simu"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Badili"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Dhibiti simu"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Dhibiti simu ya mkutano"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Sauti"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Hangout ya Video"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Badilisha iwe simu ya sauti"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Badilisha kamera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Sitisha video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Chaguo zaidi"</string>
+    <string name="player_started" msgid="3478865572468310331">"Kichezaji Kimeanzishwa"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Kichezaji Kimekomeshwa"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera haiko tayari"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera iko tayari"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Tukio lisilojulikana la kipindi cha simu"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Huduma"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Weka mipangilio"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Haijawekwa&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Mipangilio mingine ya simu"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Kupiga simu kupitia <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Simu zinazoingia kupitia <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"picha ya anwani"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"tumia kwa faragha"</string>
+    <string name="selectContact" msgid="92191462970821951">"chagua anwani"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Andika yako binafsi..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Ghairi"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Tuma"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Jibu"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Tuma SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Kataa"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Pokea kama Hangout ya Video"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Pokea kama simu ya sauti"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Kubali ombi la video"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Kataa ombi la video"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Kubali ombi la kutuma kupitia hangout ya video"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Kataa ombi la kutuma kupitia hangout ya video"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Kubali ombi la kupokea kupitia hangout ya video"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Kataa ombi la kupokea kupitia hangout ya video"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Telezesha kidole juu ili <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> ."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Telezesha kidole kushoto ili <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Telezesha kidole kulia ili <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Telezesha kidole chini ili <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Mtetemo"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Mtetemo"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Mlio"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Sauti chaguo-msingi (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Mlio wa simu"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Tetema wakati wa kuita"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Mlio wa simu na Mtetemo"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Dhibiti simu ya mkutano"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Nambari ya dharura"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other">Sekunde <xliff:g id="COUNT">%d</xliff:g></item>
+      <item quantity="one">Sekunde 1</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other">Dakika <xliff:g id="COUNT">%d</xliff:g></item>
+      <item quantity="one">Dakika 1</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other">Saa <xliff:g id="COUNT">%d</xliff:g> </item>
+      <item quantity="one">Saa 1</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Picha ya wasifu"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera imezimwa"</string>
+    <string name="child_number" msgid="4469090994612105532">"kupitia <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Dokezo limetumwa"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Ujumbe wa hivi majuzi"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Maelezo ya biashara"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"Umbali wa maili <xliff:g id="DISTANCE">%.1f</xliff:g>"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"Umbali wa kilomita <xliff:g id="DISTANCE">%.1f</xliff:g>"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Itafunguliwa kesho saa <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Itafunguliwa leo saa <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Hufungwa saa <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Imefungwa leo saa <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Sasa imefunguliwa"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Sasa imefungwa"</string>
+</resources>
diff --git a/InCallUI/res/values-sw360dp/dimens.xml b/InCallUI/res/values-sw360dp/dimens.xml
new file mode 100644
index 0000000..9fbcd60
--- /dev/null
+++ b/InCallUI/res/values-sw360dp/dimens.xml
@@ -0,0 +1,35 @@
+<?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
+  -->
+
+<resources>
+    <!-- Dimensions for CallCard elements (the normal in-call UI) -->
+
+    <!-- Text size for the name in the call info. -->
+    <dimen name="call_status_text_size">22sp</dimen>
+    <dimen name="call_status_text_min_size">18sp</dimen>
+    <dimen name="call_name_text_size">45dp</dimen>
+    <dimen name="call_name_text_min_size">34sp</dimen>
+    <dimen name="call_label_text_size">18sp</dimen>
+
+    <!-- The InCallUI dialpad will sometimes want digits sizes that are different from dialer. -->
+    <dimen name="dialpad_key_number_margin_bottom">@dimen/dialpad_key_number_default_margin_bottom</dimen>
+    <!-- Zero key should have less space between self and text because "+" is smaller -->
+    <dimen name="dialpad_zero_key_number_margin_bottom">@dimen/dialpad_zero_key_number_default_margin_bottom</dimen>
+    <dimen name="dialpad_digits_adjustable_text_size">@dimen/dialpad_digits_text_size</dimen>
+    <dimen name="dialpad_digits_adjustable_height">@dimen/dialpad_digits_height</dimen>
+    <dimen name="dialpad_key_numbers_size">@dimen/dialpad_key_numbers_default_size</dimen>
+</resources>
diff --git a/InCallUI/res/values-sw410dp/config.xml b/InCallUI/res/values-sw410dp/config.xml
new file mode 100644
index 0000000..a57f867
--- /dev/null
+++ b/InCallUI/res/values-sw410dp/config.xml
@@ -0,0 +1,21 @@
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<resources>
+    <!-- Determines the maximum number of buttons visible on the call card.  Any buttons over this
+         count are put into the overflow menu. -->
+    <integer name="call_card_max_buttons">6</integer>
+</resources>
\ No newline at end of file
diff --git a/InCallUI/res/values-ta-rIN/strings.xml b/InCallUI/res/values-ta-rIN/strings.xml
new file mode 100644
index 0000000..a3f496a
--- /dev/null
+++ b/InCallUI/res/values-ta-rIN/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"ஃபோன்"</string>
+    <string name="onHold" msgid="527593602772521700">"ஹோல்டில் உள்ளது"</string>
+    <string name="unknown" msgid="3646075119047488748">"தெரியாத எண்"</string>
+    <string name="private_num" msgid="6081418498487514686">"தனிப்பட்ட எண்"</string>
+    <string name="payphone" msgid="5743050584468748607">"கட்டணத் தொலைபேசி"</string>
+    <string name="confCall" msgid="3181961445236675173">"குழு அழைப்பு"</string>
+    <string name="call_lost" msgid="8208184291640961172">"அழைப்பு நிறுத்தப்பட்டது"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"ஸ்பீக்கர்"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"ஹேண்ட்செட் இயர்ஃபீஸ்"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"வயருள்ள ஹெட்செட்"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"புளூடூத்"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"பின்வரும் டோன்களை அனுப்பவா?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"டோன்களை அனுப்புகிறது\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"அனுப்பு"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"ஆம்"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"வேண்டாம்"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"இதற்குப் பதிலாக சிறப்புக்குறியை மாற்றியமை"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"குழு அழைப்பு: <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"குரலஞ்சல் எண்"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"அழைக்கிறது"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"மீண்டும் டயல் செய்கிறது"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"குழு அழைப்பு"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"உள்வரும் அழைப்பு"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"உள்வரும் அழைப்பு (பணி)"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"அழைப்பு முடிந்தது"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"ஹோல்டில் உள்ளது"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"துண்டிக்கிறது"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"அழைப்பில்"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"எனது எண்: <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"வீடியோவை இணைக்கிறது"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"வீடியோ அழைப்பு"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"வீடியோவைக் கோருகிறது"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"வீடியோ அழைப்பை இணைக்க முடியவில்லை"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"வீடியோ கோரிக்கை நிராகரிக்கப்பட்டது"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"உங்களைத் திரும்ப அழைப்பதற்கான எண்\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"அவசர அழைப்பு எண்\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"அழைக்கிறது"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"தவறிய அழைப்பு"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"தவறிய அழைப்புகள்"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> தவறிய அழைப்புகள்"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> இடமிருந்து தவறிய அழைப்பு"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"செயலில் இருக்கும் அழைப்பு"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"செயலில் இருக்கும் அழைப்பு (பணி)"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"செயலில் இருக்கும் வைஃபை அழைப்பு"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"செயலில் இருக்கும் வைஃபை அழைப்பு"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"ஹோல்டில் உள்ளது"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"உள்வரும் அழைப்பு"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"உள்வரும் அழைப்பு (பணி)"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"உள்வரும் வைஃபை அழைப்பு"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"உள்வரும் வைஃபை அழைப்பு (பணி)"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"உள்வரும் வீடியோ அழைப்பு"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"உள்வரும் வீடியோ கோரிக்கை"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"புதிய குரலஞ்சல்"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"புதிய குரலஞ்சல் (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>ஐ அழை"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"குரலஞ்சல் எண் அறியப்படவில்லை"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"சேவை இல்லை"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"தேர்ந்தெடுத்த நெட்வொர்க் (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) கிடைக்கவில்லை"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"பதிலளி"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"துண்டி"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"வீடியோ"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"குரல்"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"ஏற்கிறேன்"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"நிராகரி"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"திரும்ப அழை"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"செய்தி அனுப்பு"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"அழைப்பதற்கு, முதலில் விமானப் பயன்முறையை முடக்கவும்."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"நெட்வொர்க்கில் பதிவுசெய்யப்படவில்லை."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"செல்லுலார் நெட்வொர்க் கிடைக்கவில்லை."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"அழைக்க, சரியான எண்ணை உள்ளிடவும்."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"அழைக்க முடியாது."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI வரிசையைத் தொடங்குகிறது..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"சேவை ஆதரிக்கப்படவில்லை."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"அழைப்புகளில் மாற முடியாது."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"அழைப்பைப் பிரிக்க முடியாது."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"மாற்ற முடியாது."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"குழு அழைப்பு செய்ய முடியாது."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"அழைப்பை நிராகரிக்க முடியாது."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"அழைப்பை(அழைப்புகளை) விடுவிக்க முடியாது."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP அழைப்பு"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"அவசர அழைப்பு"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"ரேடியோவை இயக்குகிறது…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"சேவை இல்லை. மீண்டும் முயல்கிறது…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"<xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> என்பது அவசர அழைப்பு எண் இல்லை என்பதால் அழைக்க முடியாது."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"அழைக்க முடியாது. அவசர அழைப்பு எண்ணை அழைக்கவும்."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"டயல் செய்ய, விசைப்பலகையைப் பயன்படுத்தவும்"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"அழைப்பை ஹோல்டில் வை"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"அழைப்பை மீண்டும் தொடங்கு"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"அழைப்பை முடி"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"டயல்பேடு"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"முடக்கு"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"அழைப்பைச் சேர்"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"அழைப்புகளை இணை"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"மாற்று"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"அழைப்புகளை நிர்வகி"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"குழு அழைப்பை நிர்வகி"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"ஆடியோ"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"வீடியோ அழைப்பு"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"குரல் அழைப்பிற்கு மாறு"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"கேமராவை மாற்று"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"வீடியோவை இடைநிறுத்து"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"கூடுதல் விருப்பங்கள்"</string>
+    <string name="player_started" msgid="3478865572468310331">"வீடியோ பிளேயர் துவங்கியது"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"வீடியோ பிளேயர் நிறுத்தப்பட்டது"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"கேமரா தயாராக இல்லை"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"கேமரா தயார்"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"தெரியாத அழைப்பு நேர நிகழ்வு"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"சேவை"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"அமை"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;அமைக்கப்படவில்லை&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"பிற அழைப்பு அமைப்புகள்"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> வழியாக அழைக்கிறது"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> மூலம் உள்வரும் அழைப்புகள்"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"தொடர்புப் படம்"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"தனிப்பட்டதிற்குச் செல்"</string>
+    <string name="selectContact" msgid="92191462970821951">"தொடர்பைத் தேர்ந்தெடுக்கவும்"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"சொந்தமாக எழுதவும்..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"ரத்துசெய்"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"அனுப்பு"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"பதிலளி"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS அனுப்பு"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"நிராகரி"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"வீடியோ அழைப்பில் பதிலளி"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"ஆடியோ அழைப்பில் பதிலளி"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"வீடியோ கோரிக்கையை அனுமதி"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"வீடியோ கோரிக்கையை நிராகரி"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"வீடியோவைப் பரிமாற்றும் கோரிக்கையை அனுமதி"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"வீடியோவைப் பரிமாற்றும் கோரிக்கையை நிராகரி"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"வீடியோவைப் பெறும் கோரிக்கையை அனுமதி"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"வீடியோவைப் பெறும் கோரிக்கையை நிராகரி"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>, மேலே ஸ்லைடு செய்க."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>, இடப்புறம் ஸ்லைடு செய்க."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>, வலப்புறம் ஸ்லைடு செய்க."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>, கீழே ஸ்லைடு செய்க."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"அதிர்வுறு"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"அதிர்வுறு"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"ஒலி"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"இயல்பு ஒலி (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"ஃபோனின் ரிங்டோன்"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"அழைக்கும் போது அதிர்வுறு"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"ரிங்டோன் &amp; அதிர்வு"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"குழு அழைப்பை நிர்வகி"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"அவசர அழைப்பு எண்"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> வினாடிகள்</item>
+      <item quantity="one">1 வினாடி</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> நிமிடங்கள்</item>
+      <item quantity="one">1 நிமிடம்</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> மணிநேரம்</item>
+      <item quantity="one">1 மணிநேரம்</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"சுயவிவரப் படம்"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"கேமரா முடக்கப்பட்டது"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> வழியாக"</string>
+    <string name="note_sent" msgid="7623014827902758398">"குறிப்பு அனுப்பப்பட்டது"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"சமீபத்திய செய்திகள்"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"வணிகத் தகவல்"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> மைல் தொலைவில்"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> கிமீ தொலைவில்"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"நாளை <xliff:g id="OPEN_TIME">%s</xliff:g>க்குத் திறக்கப்படும்"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"இன்று <xliff:g id="OPEN_TIME">%s</xliff:g>க்குத் திறக்கப்படும்"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g>க்கு மூடப்படும்"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"இன்று <xliff:g id="CLOSE_TIME">%s</xliff:g>க்கு மூடப்பட்டது"</string>
+    <string name="open_now" msgid="4615706338669555999">"இப்போது திறக்கப்பட்டுள்ளது"</string>
+    <string name="closed_now" msgid="2635314668145282080">"இப்போது மூடப்பட்டுள்ளது"</string>
+</resources>
diff --git a/InCallUI/res/values-te-rIN/strings.xml b/InCallUI/res/values-te-rIN/strings.xml
new file mode 100644
index 0000000..f122aa6
--- /dev/null
+++ b/InCallUI/res/values-te-rIN/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"ఫోన్"</string>
+    <string name="onHold" msgid="527593602772521700">"హోల్డ్‌లో ఉంది"</string>
+    <string name="unknown" msgid="3646075119047488748">"తెలియదు"</string>
+    <string name="private_num" msgid="6081418498487514686">"ప్రైవేట్ నంబర్"</string>
+    <string name="payphone" msgid="5743050584468748607">"పే ఫోన్"</string>
+    <string name="confCall" msgid="3181961445236675173">"కాన్ఫరెన్స్ కాల్"</string>
+    <string name="call_lost" msgid="8208184291640961172">"కాల్ కట్ అయింది"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"స్పీకర్"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"హ్యాండ్‌సెట్ ఇయర్‌పీస్"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"వైర్ గల హెడ్‌సెట్"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"బ్లూటూత్"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"కింది టోన్‌లను పంపాలా?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"టోన్‌లు పంపుతోంది\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"పంపు"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"అవును"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"వద్దు"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"దీనితో వైల్డ అక్షరాన్ని భర్తీ చేయండి"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"కాన్ఫరెన్స్ కాల్ <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"వాయిస్ మెయిల్ నంబర్"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"డయల్ చేస్తోంది"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"మళ్లీ డయల్ చేస్తోంది"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"కాన్ఫరెన్స్ కాల్"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"ఇన్‌కమింగ్ కాల్"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"ఇన్‌కమింగ్ కార్యాలయ కాల్"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"కాల్ ముగిసింది"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"హోల్డ్‌లో ఉంది"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"ముగిస్తోంది"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"కాల్‌లో ఉంది"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"నా నంబర్ <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"వీడియోను కనెక్ట్ చేస్తోంది"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"వీడియో కాల్"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"వీడియో కోసం అభ్యర్థిస్తోంది"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"వీడియో కాల్‌ను కనెక్ట్ చేయలేరు"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"వీడియో అభ్యర్థన తిరస్కరించబడింది"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"మీ కాల్‌బ్యాక్ నంబర్\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"మీ అత్యవసర కాల్‌బ్యాక్ నంబర్\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"డయల్ చేస్తోంది"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"సమాధానం ఇవ్వని కాల్"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"సమాధానం ఇవ్వని కాల్‌లు"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> సమాధానం ఇవ్వని కాల్‌లు"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> నుండి సమాధానం ఇవ్వని కాల్"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"కాల్ కొనసాగుతోంది"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"కార్యాలయ కాల్ కొనసాగుతోంది"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Wi-Fi కాల్ కొనసాగుతోంది"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Wi-Fi కార్యాలయ కాల్ కొనసాగుతోంది"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"హోల్డ్‌లో ఉంది"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"ఇన్‌కమింగ్ కాల్"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"ఇన్‌కమింగ్ కార్యాలయ కాల్"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"ఇన్‌కమింగ్ Wi-Fi కాల్"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"ఇన్‌కమింగ్ Wi-Fi కార్యాలయ కాల్"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"ఇన్‌కమింగ్ వీడియో కాల్"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"ఇన్‌కమింగ్ వీడియో అభ్యర్థన"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"కొత్త వాయిస్ మెయిల్"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"కొత్త వాయిస్ మెయిల్ (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>కు డయల్ చేయండి"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"వాయిస్ మెయిల్ నంబర్ తెలియదు"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"సేవ లేదు"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"ఎంచుకున్న నెట్‌వర్క్ (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) అందుబాటులో లేదు"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"సమాధానం"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"కాల్ ముగించు"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"వీడియో"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"వాయిస్"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"ఆమోదిస్తున్నాను"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"తీసివేయి"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"తిరిగి కాల్ చేయి"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"సందేశం పంపు"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"కాల్ చేయడానికి, ముందుగా ఎయిర్‌ప్లైన్ మోడ్‌ను ఆపివేయండి."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"నెట్‌వర్క్‌లో నమోదు కాలేదు."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"సెల్యులార్ నెట్‌వర్క్ అందుబాటులో లేదు."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"కాల్ చేయడానికి, చెల్లుబాటు అయ్యే నంబర్‌ను నమోదు చేయండి."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"కాల్ చేయలేరు."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI శ్రేణిని ప్రారంభిస్తోంది…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"సేవకు మద్దతు లేదు."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"కాల్‌లను మార్చలేరు."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"కాల్‌ను వేరు చేయలేరు."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"బదిలీ చేయలేరు."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"కాన్ఫరెన్స్ కాల్ కుదరదు."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"కాల్‌ను తిరస్కరించలేరు."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"కాల్(ల)ను విడిచిపెట్టలేరు."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP కాల్"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"అత్యవసర కాల్"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"రేడియోను ఆన్ చేస్తోంది…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"సేవ లేదు. మళ్లీ ప్రయత్నిస్తోంది…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"కాల్ చేయలేరు. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> అత్యవసర నంబర్ కాదు."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"కాల్ చేయలేరు. అత్యవసర నంబర్‌కు డయల్ చేయండి."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"డయల్ చేయడానికి కీబోర్డ్‌ను ఉపయోగించండి"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"కాల్‌ను హోల్డ్‌లో ఉంచు"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"కాల్‌ను పునఃప్రారంభించు"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"కాల్‌ని ముగించు"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"డయిల్‌ప్యాడ్"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"మ్యూట్ చేయి"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"కాల్‌ను జోడించు"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"కాల్‌లను విలీనం చేయి"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"స్వాప్ చేయి"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"కాల్‌లను నిర్వహించు"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"కాన్ఫరెన్స్ కాల్‌ను నిర్వహించు"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"ఆడియో"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"వీడియో కాల్"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"వాయిస్ కాల్‌కి మార్చు"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"కెమెరాను మార్చు"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"వీడియోను పాజ్ చేయి"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"మరిన్ని ఎంపికలు"</string>
+    <string name="player_started" msgid="3478865572468310331">"ప్లేయర్ ప్రారంభమైంది"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"ప్లేయర్ ఆపివేయబడింది"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"కెమెరా సిద్ధంగా లేదు"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"కెమెరా సిద్ధంగా ఉంది"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"తెలియని కాల్ సెషన్ ఉదంతం"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"సేవ"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"సెటప్ చేయండి"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;సెట్ చేయలేదు&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"ఇతర కాల్ సెట్టింగ్‌లు"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> ద్వారా కాల్ చేయబడుతోంది"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> ద్వారా ఇన్‌కమింగ్"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"పరిచయం ఫోటో"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"ప్రైవేట్‌గా వెళ్లు"</string>
+    <string name="selectContact" msgid="92191462970821951">"పరిచయాన్ని ఎంచుకోండి"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"మీ స్వంతంగా వ్రాయండి…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"రద్దు చేయి"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"పంపు"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"సమాధానం"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMSని పంపుతుంది"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"తిరస్కరిస్తుంది"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"వీడియో కాల్ రూపంలో సమాధానం"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"ఆడియో కాల్ రూపంలో సమాధానం"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"వీడియో అభ్యర్థనను ఆమోదిస్తుంది"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"వీడియో అభ్యర్థనను తిరస్కరిస్తుంది"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"వీడియో ప్రసరణ అభ్యర్థనను ఆమోదిస్తుంది"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"వీడియో ప్రసరణ అభ్యర్థనను తిరస్కరిస్తుంది"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"వీడియో స్వీకరణ అభ్యర్థనను ఆమోదిస్తుంది"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"వీడియో స్వీకరణ అభ్యర్థనను తిరస్కరిస్తుంది"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> కోసం పైకి స్లైడ్ చేయండి."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> కోసం ఎడమవైపుకు స్లైడ్ చేయండి."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> కోసం కుడివైపుకు స్లైడ్ చేయండి."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> కోసం కిందికి స్లైడ్ చేయండి."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"వైబ్రేట్"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"వైబ్రేట్"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"ధ్వని"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"డిఫాల్ట్ ధ్వని (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"ఫోన్ రింగ్‌టోన్"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"రింగ్ అయ్యేప్పుడు వైబ్రేషన్"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"రింగ్‌టోన్ &amp; వైబ్రేట్"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"కాన్ఫరెన్స్ కాల్‌ను నిర్వహించు"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"అత్యవసర నంబర్"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> సెకన్లు</item>
+      <item quantity="one">1 సెకను</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> నిమిషాలు</item>
+      <item quantity="one">1 నిమిషం</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> గంటలు</item>
+      <item quantity="one">1 గంట</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"ప్రొఫైల్ ఫోటో"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"కెమెరా ఆఫ్‌లో ఉంది"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> ద్వారా"</string>
+    <string name="note_sent" msgid="7623014827902758398">"గమనిక పంపబడింది"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"ఇటీవలి సందేశాలు"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"వ్యాపార సంస్థ సమాచారం"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> మై దూరంలో ఉంది"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> కి.మీ దూరంలో ఉంది"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"రేపు <xliff:g id="OPEN_TIME">%s</xliff:g>కి తెరవబడుతుంది"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"ఈరోజు <xliff:g id="OPEN_TIME">%s</xliff:g>కి తెరవబడుతుంది"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g>కి మూసివేయబడుతుంది"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"ఈరోజు <xliff:g id="CLOSE_TIME">%s</xliff:g>కి మూసివేయబడి ఉంటుంది"</string>
+    <string name="open_now" msgid="4615706338669555999">"ఇప్పుడు తెరిచి ఉంది"</string>
+    <string name="closed_now" msgid="2635314668145282080">"ఇప్పుడు మూసివేయబడింది"</string>
+</resources>
diff --git a/InCallUI/res/values-th/strings.xml b/InCallUI/res/values-th/strings.xml
new file mode 100644
index 0000000..ef9cf23
--- /dev/null
+++ b/InCallUI/res/values-th/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"โทรศัพท์"</string>
+    <string name="onHold" msgid="527593602772521700">"พักสาย"</string>
+    <string name="unknown" msgid="3646075119047488748">"ไม่ทราบ"</string>
+    <string name="private_num" msgid="6081418498487514686">"หมายเลขส่วนตัว"</string>
+    <string name="payphone" msgid="5743050584468748607">"โทรศัพท์สาธารณะ"</string>
+    <string name="confCall" msgid="3181961445236675173">"การประชุมสาย"</string>
+    <string name="call_lost" msgid="8208184291640961172">"สายหลุด"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"ลำโพง"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"ชุดหูฟังโทรศัพท์"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"ชุดหูฟังแบบมีสาย"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"บลูทูธ"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"ส่งหมายเลขต่อไปไหม\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"กำลังส่งหมายเลข\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"ส่ง"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"ใช่"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"ไม่"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"แทนที่อักขระแทนด้วย"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"การประชุมสาย <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"หมายเลขข้อความเสียง"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"กำลังโทรออก"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"โทรใหม่"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"การประชุมสาย"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"สายเรียกเข้า"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"มีสายเรียกเข้าจากที่ทำงาน"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"วางสายแล้ว"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"พักสาย"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"กำลังวางสาย"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"กำลังใช้สาย"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"หมายเลขของฉันคือ <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"กำลังเชื่อมต่อวิดีโอ"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"แฮงเอาท์วิดีโอ"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"กำลังขอวิดีโอ"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"ไม่สามารถเชื่อมต่อแฮงเอาท์วิดีโอได้"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"คำขอวิดีโอถูกปฏิเสธ"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"หมายเลขโทรกลับของคุณ\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"หมายเลขโทรกลับฉุกเฉินของคุณ\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"กำลังโทรออก"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"สายที่ไม่ได้รับ"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"สายที่ไม่ได้รับ"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"ไม่ได้รับ <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> สาย"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"สายที่ไม่ได้รับจาก <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"โทรต่อเนื่อง"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"กำลังอยู่ในสายจากที่ทำงาน"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"กำลังโทรผ่าน Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"กำลังอยู่ในสายจากที่ทำงานผ่าน Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"พักสาย"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"สายเรียกเข้า"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"มีสายเรียกเข้าจากที่ทำงาน"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"สายโทรเข้าผ่าน Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"มีสายเรียกเข้าจากที่ทำงานผ่าน Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"แฮงเอาท์วิดีโอเรียกเข้า"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"คำขอโทรเข้าเป็นวิดีโอ"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"ข้อความเสียงใหม่"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"ข้อความเสียงใหม่ (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"หมุนหมายเลข <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"ไม่ทราบหมายเลขข้อความเสียง"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"ไม่มีบริการ"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"เครือข่ายที่เลือกไว้ (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) ไม่พร้อมใช้งาน"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"รับสาย"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"วางสาย"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"วิดีโอ"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"เสียง"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"ยอมรับ"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"ปิด"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"โทรกลับ"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"ข้อความ"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"หากต้องการโทรออก ให้ปิดโหมดบนเครื่องบินก่อน"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"ยังไม่ได้ลงทะเบียนบนเครือข่าย"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"เครือข่ายมือถือใช้งานไม่ได้"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"หากต้องการโทรออก โปรดป้อนหมายเลขที่ถูกต้อง"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"ไม่สามารถโทรได้"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"กำลังเริ่มต้นลำดับ MMI..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"ไม่สนับสนุนบริการนี้"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"ไม่สามารถสลับสายได้"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"ไม่สามารถแยกสายได้"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"ไม่สามารถโอนได้"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"ไม่สามารถประชุมได้"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"ไม่สามารถปฏิเสธสายได้"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"ไม่สามารถเริ่มการโทรได้"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"โทรแบบ SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"หมายเลขฉุกเฉิน"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"กำลังเปิดวิทยุ…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"ไม่มีบริการ โปรดลองอีกครั้ง…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"โทรออกไม่ได้ <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> ไม่ใช่หมายเลขฉุกเฉิน"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"ไม่สามารถโทรออก โทรหมายเลขฉุกเฉิน"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ใช้แป้นพิมพ์กดหมายเลขโทรศัพท์"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"พักสาย"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"โทรต่อ"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"วางสาย"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"แป้นหมายเลข"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"ปิด"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"เพิ่มการโทร"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"รวมสาย"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"สลับ"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"จัดการการโทร"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"จัดการการประชุมสาย"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"เสียง"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"แฮงเอาท์วิดีโอ"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"เปลี่ยนเป็นการโทรด้วยเสียง"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"เปลี่ยนกล้อง"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"หยุดวิดีโอชั่วคราว"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"ตัวเลือกเพิ่มเติม"</string>
+    <string name="player_started" msgid="3478865572468310331">"โปรแกรมเล่นเริ่มทำงานแล้ว"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"โปรแกรมเล่นหยุดแล้ว"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"กล้องไม่พร้อมทำงาน"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"กล้องพร้อมทำงาน"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"เหตุการณ์เซสชันการโทรที่ไม่รู้จัก"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"บริการ"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"ตั้งค่า"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;ไม่ได้ตั้งค่า&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"การตั้งค่าการโทรอื่นๆ"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"โทรผ่าน <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"สายเรียกเข้าผ่าน <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"ภาพของรายชื่อติดต่อ"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"เข้าสู่โหมดส่วนตัว"</string>
+    <string name="selectContact" msgid="92191462970821951">"เลือกรายชื่อติดต่อ"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"เขียนคำตอบของคุณเอง..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"ยกเลิก"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"ส่ง"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"รับสาย"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"ส่ง SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"ปฏิเสธ"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"รับสายเป็นแฮงเอาท์วิดีโอ"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"รับสายเป็นการโทรด้วยเสียง"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"ยอมรับคำขอวิดีโอ"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"ปฏิเสธคำขอวิดีโอ"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"ยอมรับคำขอให้ส่งวิดีโอ"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"ปฏิเสธคำขอให้ส่งวิดีโอ"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"ยอมรับคำขอให้รับวิดีโอ"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"ปฏิเสธคำขอให้รับวิดีโอ"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"เลื่อนไปข้างบนเพื่อ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"เลื่อนไปทางซ้ายเพื่อ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"เลื่อนไปทางขวาเพื่อ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"เลื่อนลงเพื่อ <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"สั่น"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"สั่น"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"เสียง"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"เสียงเริ่มต้น (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"เสียงเรียกเข้าโทรศัพท์"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"สั่นเมื่อมีสายเข้า"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"เสียงเรียกเข้าและสั่น"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"จัดการการประชุมสาย"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"หมายเลขฉุกเฉิน"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> วินาที</item>
+      <item quantity="one">1 วินาที</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> นาที</item>
+      <item quantity="one">1 นาที</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> ชั่วโมง</item>
+      <item quantity="one">1 ชั่วโมง</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"รูปโปรไฟล์"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"ปิดกล้อง"</string>
+    <string name="child_number" msgid="4469090994612105532">"ผ่านหมายเลข <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"ส่งโน้ตแล้ว"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"ข้อความล่าสุด"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"ข้อมูลธุรกิจ"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"อยู่ห่างออกไป <xliff:g id="DISTANCE">%.1f</xliff:g> ไมล์"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"อยู่ห่างออกไป <xliff:g id="DISTANCE">%.1f</xliff:g> กม."</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"เปิดให้บริการพรุ่งนี้เวลา <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"เปิดให้บริการวันนี้เวลา <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"ปิดให้บริการเวลา <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"ปิดให้บริการแล้ววันนี้เวลา <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"ขณะนี้เปิดทำการ"</string>
+    <string name="closed_now" msgid="2635314668145282080">"ขณะนี้ปิดทำการ"</string>
+</resources>
diff --git a/InCallUI/res/values-tl/strings.xml b/InCallUI/res/values-tl/strings.xml
new file mode 100644
index 0000000..578ebd5
--- /dev/null
+++ b/InCallUI/res/values-tl/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telepono"</string>
+    <string name="onHold" msgid="527593602772521700">"Naka-hold"</string>
+    <string name="unknown" msgid="3646075119047488748">"Hindi alam"</string>
+    <string name="private_num" msgid="6081418498487514686">"Pribadong numero"</string>
+    <string name="payphone" msgid="5743050584468748607">"Payphone"</string>
+    <string name="confCall" msgid="3181961445236675173">"Conference call"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Naputol ang tawag"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Speaker"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Handset earpiece"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Wired na headset"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Ipapadala ba ang mga sumusunod na tono?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Nagpapadala ng mga tono\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Ipadala"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Oo"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Hindi"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Palitan ang wild character ng"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Conference call <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Numero ng voicemail"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Dina-dial"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Muling dina-dial"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Conference call"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Papasok na tawag"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Papasok na tawag sa trabaho"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Ibinaba ang tawag"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Naka-hold"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Binababa"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Nasa tawag"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Ang aking numero ay <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Ikinokonekta ang video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Mag-video call"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Humihiling ng video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Hindi makakonekta sa video call"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Tinanggihan ang kahilingan sa video"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Ang iyong numero ng callback\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Ang iyong emergency na numero ng callback\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Dina-dial"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Hindi nasagot na tawag"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Mga hindi nasagot na tawag"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> (na) hindi nasagot na tawag"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Hindi nasagot ang tawag mula kay <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Kasalukuyang tawag"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Kasalukuyang tawag sa trabaho"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Kasalukuyang tawag sa Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Kasalukuyang tawag sa trabaho sa pamamagitan ng Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Naka-hold"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Papasok na tawag"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Papasok na tawag sa trabaho"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Papasok na tawag sa Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Papasok na tawag sa trabaho sa pamamagitan ng Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Papasok na video call"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Papasok na kahilingan ng video"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Bagong voicemail"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Bagong voicemail (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"I-dial ang <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Hindi kilala ang numero ng voicemail"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Walang serbisyo"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Hindi available ang piniling network (<xliff:g id="OPERATOR_NAME">%s</xliff:g>)"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Sagutin"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Ibaba"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Boses"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Tanggapin"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"I-dismiss"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Tawagan"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Mensahe"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Upang tumawag, paki-off muna ang Airplane mode."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Hindi nakarehistro sa network."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Hindi available ang cellular network."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Upang tumawag, maglagay ng wastong numero."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Hindi makatawag."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Sinisimulan ang pagkakasunud-sunod ng MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Hindi sinusuportahan ang serbisyo."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Hindi mailipat ang mga tawag."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Hindi mapaghiwalay ang tawag."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Hindi mailipat."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Hindi makapag-conference."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Hindi matanggihan ang tawag."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Hindi mailabas ang (mga) tawag."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Tawag sa SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Emergency na tawag"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Ino-on ang radyo…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Walang serbisyo. Sinusubukang muli…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Hindi makatawag. Ang <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> ay hindi isang pang-emergency na numero."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Hindi makatawag. Mag-dial ng pang-emergency na numero."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Gamitin ang keyboard upang mag-dial"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"I-hold ang Tawag"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Ituloy ang Tawag"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Ibaba ang Tawag"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Dialpad"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"I-mute"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Magdagdag ng tawag"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Pagsamahin ang mga tawag"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Pagpalitin"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Pamahalaan ang mga tawag"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Pamahalaan ang conference call"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Mag-video call"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Gawing voice call"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Lumipat ng camera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"I-pause ang video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Higit pang mga opsyon"</string>
+    <string name="player_started" msgid="3478865572468310331">"Nagsimula na ang Player"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Huminto ang Player"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Hindi pa handa ang camera"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Handa na ang camera"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Hindi alam na kaganapan ng session ng tawag"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Serbisyo"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"I-setup"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Hindi nakatakda&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Iba pang mga setting ng tawag"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Tumatawag sa pamamagitan ng <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Papasok sa pamamagitan ng <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"larawan ng contact"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"maging pribado"</string>
+    <string name="selectContact" msgid="92191462970821951">"pumili ng contact"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Sumulat ng sarili mong tugon…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Kanselahin"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Ipadala"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Sagutin"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Magpadala ng SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Tanggihan"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Sagutin bilang video call"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Sagutin bilang audio call"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Tanggapin ang kahilingan sa video"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Tanggihan ang kahilingan sa video"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Tanggapin ang kahilingan sa pagpapadala ng video"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Tanggihan ang kahilingan sa pagpapadala ng video"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Tanggapin ang kahilingan sa pagtanggap ng video"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Tanggihan ang kahilingan sa pagtanggap ng video"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Mag-slide pataas para sa <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Mag-slide pakaliwa para sa <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Mag-slide pakanan para sa <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Mag-slide pababa para sa <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Mag-vibrate"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Mag-vibrate"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Tunog"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Default na tunog (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Ringtone ng telepono"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Mag-vibrate kapag nagri-ring"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Ringtone at Pag-vibrate"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Pamahalaan ang conference call"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Pang-emergency na numero"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> segundo</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> na segundo</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> minuto</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> na minuto</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> oras</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> na oras</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Larawan sa profile"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Naka-off ang camera"</string>
+    <string name="child_number" msgid="4469090994612105532">"sa pamamagitan ng <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Naipadala ang tala"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Mga kamakailang mensahe"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Impormasyon ng negosyo"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> (na) milya ang layo"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> (na) kilometro ang layo"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Magbubukas bukas nang <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Magbubukas ngayon nang <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Magsasara nang <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Sarado ngayon nang <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Bukas ngayon"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Sarado ngayon"</string>
+</resources>
diff --git a/InCallUI/res/values-tr/strings.xml b/InCallUI/res/values-tr/strings.xml
new file mode 100644
index 0000000..a52b007
--- /dev/null
+++ b/InCallUI/res/values-tr/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Beklemede"</string>
+    <string name="unknown" msgid="3646075119047488748">"Bilinmiyor"</string>
+    <string name="private_num" msgid="6081418498487514686">"Gizli numara"</string>
+    <string name="payphone" msgid="5743050584468748607">"Ankesörlü telefon"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferans görüşmesi"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Çağrı kesildi"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Hoparlör"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Mobil cihaz kulaklığı"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Kablolu kulaklık"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Aşağıdaki zil sesleri gönderilsin mi?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Numara tonları gönderiliyor\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Gönder"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Evet"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Hayır"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Joker karakteri şununla değiştir:"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferans görüşmesi <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Sesli mesaj numarası"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Numara çevriliyor"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Yeniden çevriliyor"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferans görüşmesi"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Gelen çağrı"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"İşle ilgili gelen çağrı"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Çağrı sonlandırıldı"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Beklemede"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Sonlandırılıyor"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Görüşmede"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Numaram: <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Video bağlanıyor"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Video görüşmesi"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Video isteniyor"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Video görüşmesi bağlantısı yapılamıyor"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Video isteği reddedildi"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Geri aranacağınız numara\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Acil durumda geri aranacağınız numara\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Numara çevriliyor"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Cevapsız çağrı"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Cevapsız çağrılar"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> cevapsız çağrı"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Cevapsız çağrı: <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Devam eden çağrı"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"İşle ilgili devam eden çağrı"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Devam eden kablosuz çağrı"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"İşle ilgili devam eden kablosuz çağrı"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Beklemede"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Gelen çağrı"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"İşle ilgili gelen çağrı"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Gelen kablosuz çağrı"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"İşle ilgili gelen kablosuz çağrı"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Gelen video görüşmesi isteği"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Gelen video isteği"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Yeni sesli mesaj"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Yeni sesli mesaj (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Çevir: <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Sesli mesaj numarası bilinmiyor"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Servis yok"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Seçili ağ (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) kullanılamıyor"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Yanıtla"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Kapat"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Ses"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Kabul et"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Yok say"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Geri ara"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"İleti"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Çağrı yapmak için öncelikle Uçak modunu kapatın."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Ağda kayıtlı değil."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Hücresel ağ kullanılamıyor."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Çağrı yapmak için geçerli bir numara girin."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Çağrı yapılamıyor."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI dizisi başlatılıyor…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Service desteklenmiyor"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Çağrı geçişi yapılamıyor."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Çağrı ayrılamıyor."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Aktarılamıyor."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Konferans çağrısı yapılamıyor."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Çağrı reddedilemiyor."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Çağrılar bırakılamıyor."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP çağrısı"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Acil durum çağrısı"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Radyo açılıyor…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Servis yok. Tekrar deneniyor…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Çağrı yapılamıyor. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> bir acil durum numarası değil."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Çağrı yapılamıyor. Acil durum numarasını çevirin."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Çevirmek için klavyeyi kullan"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Çağrıyı Beklet"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Çağrıyı Devam Ettir"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Çağrıyı Sonlandır"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Tuş takımı"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Yok say"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Çağrı ekle"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Çağrıları birleştir"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Değiştir"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Çağrıları yönet"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Konferans çağrısını yönet"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Ses"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Vid. görşm"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Sesli çağrıya geç"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Kamerayı değiştir"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Videoyu duraklat"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Diğer seçenekler"</string>
+    <string name="player_started" msgid="3478865572468310331">"Oynatıcı Başlatıldı"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Oynatıcı Durduruldu"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera hazır değil"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera hazır"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Bilinmeyen çağrı oturumu etkinliği"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Hizmet"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Kurulum"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Ayarlanmadı&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Diğer çağrı ayarları"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> üzerinden çağrı yapılıyor"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> adlı sağlayıcı üzerinden gelen çağrı"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"kişi fotoğrafı"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"özel görüşmeye geç"</string>
+    <string name="selectContact" msgid="92191462970821951">"kişi seçin"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Kendi yanıtınızı oluşturun…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"İptal"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Gönder"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Yanıtla"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS gönder"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Reddet"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Video görüşmesi olarak yanıtla"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Sesli görüşme olarak yanıtla"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Video isteğini kabul et"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Video isteğini reddet"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Video aktarma isteğini kabul et"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Video aktarma isteğini reddet"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Video alma isteğini kabul et"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Video alma isteğini reddet"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> için yukarı kaydırın."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> için sola kaydırın."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> için sağa kaydırın."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> için aşağı kaydırın."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Titreşim"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Titreşim"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Ses"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Varsayılan ses (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Telefon zil sesi"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Çalarken titret"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Zil Sesi ve Titreşim"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Konferans çağrısını yönetin"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Acil durum numarası"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> saniye</item>
+      <item quantity="one">1 saniye</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> dakika</item>
+      <item quantity="one">1 dakika</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> saat</item>
+      <item quantity="one">1 saat</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profil fotoğrafı"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera kapalı"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> üzerinden"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Not gönderildi"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Son iletiler"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"İşletme bilgileri"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mil uzakta"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km uzakta"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Yarın açılış saati: <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Bugün açılış saati: <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Kapanış saati: <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Bugün kapanış saati: <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Şu an açık"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Şu an kapalı"</string>
+</resources>
diff --git a/InCallUI/res/values-uk/strings.xml b/InCallUI/res/values-uk/strings.xml
new file mode 100644
index 0000000..5bdc3c8
--- /dev/null
+++ b/InCallUI/res/values-uk/strings.xml
@@ -0,0 +1,198 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Номер телефону"</string>
+    <string name="onHold" msgid="527593602772521700">"Очікування"</string>
+    <string name="unknown" msgid="3646075119047488748">"Невідомо"</string>
+    <string name="private_num" msgid="6081418498487514686">"Приватний номер"</string>
+    <string name="payphone" msgid="5743050584468748607">"Таксофон"</string>
+    <string name="confCall" msgid="3181961445236675173">"Конференц-зв’язок"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Виклик перервано"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Динамік"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Динамік гарнітури"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Дротова гарнітура"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Надіслати вказані нижче сигнали?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Надсилання сигналів\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Надіслати"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Так"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Ні"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Замінити довільний символ на"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Конференц-зв’язок <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Номер голосової пошти"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Набір номера"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Повторний набір"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Конференц-зв’язок"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Вхідний виклик"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Вхідний робочий виклик"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Виклик завершено"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Очікування"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Завершення виклику"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Триває виклик"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Мій номер: <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Відеодзвінок: з’єднання"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Відеодзвінок"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Надсилання запиту на відеодзвінок"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Не вдалося здійснити відеодзвінок"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Запрошення на відеодзвінок відхилено"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Номер для зв’язку:\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Екстрений номер:\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Набір номера"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Пропущений виклик"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Пропущені виклики"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"Пропущено викликів: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Пропущений виклик: <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Поточний виклик"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Поточний виклик на робочий телефон"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Поточний виклик через Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Поточний виклик на робочий телефон через Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Очікування"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Вхідний виклик"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Вхідний виклик на робочий телефон"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Вхідний виклик через Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Вхідний виклик на робочий телефон через Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Вхідний відеодзвінок"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Запит на вхідний відеодзвінок"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Нові голосові повідомлення"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Нові голосові повідомлення (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Набрати <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Невідомий номер голосової пошти"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Немає зв’язку"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Вибрана мережа (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) недоступна"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Відповісти"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Завершити"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Відео"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Гол. виклик"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Прийняти"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Відхилити"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Передзвонити"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Написати SMS"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Щоб зателефонувати, вимкніть режим польоту."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Не зареєстровано в мережі."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Мобільна мережа недоступна."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Щоб зателефонувати, введіть дійсний номер."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Не вдається зателефонувати."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Запуск ряду MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Служба не підтримується."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Неможливо переключитися між викликами."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Неможливо розділити виклик."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Неможливо перенести."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Конференц-зв’язок недоступний."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Неможливо відхилити виклик."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Неможливо телефонувати."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Виклик через протокол SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Екстрений виклик"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Увімкнення радіо…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Немає зв’язку. Повторна спроба…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Не вдається зателефонувати. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> не є екстреним номером."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Не вдається зателефонувати. Наберіть екстрений номер."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Використовуйте для набору клавіатуру"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Призупинити виклик"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Відновити виклик"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Завершити виклик"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Цифрова клавіатура"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Вимкнути звук"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Додати виклик"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Об’єднати виклики"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Поміняти виклики"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Керувати викликами"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Керувати конференц-зв’язком"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Аудіо"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Відеодзвінок"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Перейти в режим голосового виклику"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Вибрати камеру"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Призупинити відео"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Інші опції"</string>
+    <string name="player_started" msgid="3478865572468310331">"Програвач запущено"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Програвач зупинено"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Камера неготова"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Камера готова"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Невідомий сеанс виклику"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Служба"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Налаштування"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Не налаштовано&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Інші налаштування виклику"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Виклик здійснюється через оператора <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Вхідні виклики через оператора <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"фото контакта"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"приватна розмова"</string>
+    <string name="selectContact" msgid="92191462970821951">"вибрати контакт"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Напишіть власну відповідь…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Скасувати"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Надіслати"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Відповісти"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Надіслати SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Відхилити"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Відповісти в режимі відеодзвінка"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Відповісти в режимі аудіодзвінка"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Прийняти запит на відео"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Відхилити запит на відео"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Прийняти запит на передавання відео"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Відхилити запит на передавання відео"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Прийняти запит на отримання відео"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Відхилити запит на отримання відео"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Проведіть пальцем угору, щоб <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Проведіть пальцем ліворуч, щоб <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Проведіть пальцем праворуч, щоб <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Проведіть пальцем донизу, щоб <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Вібросигнал"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Вібросигнал"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Звук"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Звук за умовчанням (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Сигнал дзвінка телефона"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Вібрувати під час виклику"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Сигнал дзвінка та вібросигнал"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Керування конференц-зв’язком"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Екстрений номер"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> секунда</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> секунди</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> секунд</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> секунди</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> хвилина</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> хвилини</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> хвилин</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> хвилини</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> година</item>
+      <item quantity="few"><xliff:g id="COUNT">%d</xliff:g> години</item>
+      <item quantity="many"><xliff:g id="COUNT">%d</xliff:g> годин</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> години</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Фотографія профілю"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Камеру вимкнено"</string>
+    <string name="child_number" msgid="4469090994612105532">"на номер <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Нотатку надіслано"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Нещодавні повідомлення"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Інформація про компанію"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"За <xliff:g id="DISTANCE">%.1f</xliff:g> мил."</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"За <xliff:g id="DISTANCE">%.1f</xliff:g> км"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g>–<xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Відчиняється завтра о <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Відчиняється сьогодні о <xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Зачиняється о <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Зачинено сьогодні о <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Відчинено"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Зачинено"</string>
+</resources>
diff --git a/InCallUI/res/values-ur-rPK/strings.xml b/InCallUI/res/values-ur-rPK/strings.xml
new file mode 100644
index 0000000..7a6fd3b
--- /dev/null
+++ b/InCallUI/res/values-ur-rPK/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"فون"</string>
+    <string name="onHold" msgid="527593602772521700">"ہولڈ پر ہے"</string>
+    <string name="unknown" msgid="3646075119047488748">"نامعلوم"</string>
+    <string name="private_num" msgid="6081418498487514686">"نجی نمبر"</string>
+    <string name="payphone" msgid="5743050584468748607">"پے فون"</string>
+    <string name="confCall" msgid="3181961445236675173">"کانفرنس کال"</string>
+    <string name="call_lost" msgid="8208184291640961172">"کال ختم ہو گئی"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"اسپیکر"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"ہینڈسیٹ ایئرپیس"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"تار والا ہیڈسیٹ"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"بلوٹوتھ"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"درج ذیل ٹونز بھیجیں؟\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"ٹونز بھیج رہا ہے\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"بھیجیں"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"ہاں"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"نہیں"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"وائلڈ کریکٹر کو اس کے ساتھ بدلیں"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"کانفرنس کال <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"صوتی میل نمبر"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"ڈائل ہو رہا ہے"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"دوبارہ ڈائل ہو رہا ہے"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"کانفرنس کال"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"آنے والی کال"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"کام سے متعلق آنے والی کال"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"کال ختم ہوگئی"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"ہولڈ پر ہے"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"کال منقطع ہو رہی ہے"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"کال میں"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"میرا نمبر ہے <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"ویڈیو منسلک ہو رہی ہے"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"ویڈیو کال"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"ویڈیو کی درخواست کی جا رہی ہے"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"ویڈیو کال منسلک نہیں ہو سکتی"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"ویڈیو کی درخواست مسترد ہو گئی"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"‏آپ کا کال بیک نمبر‎\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"‏آپ کا ہنگامی کال بیک نمبر‎\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"ڈائل ہو رہا ہے"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"چھوٹی ہوئی کال"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"چھوٹی ہوئی کالیں"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> چھوٹی ہوئی کالیں"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> کی جانب سے چھوٹی ہوئی کال"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"جاری کال"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"کام سے متعلق جاری کال"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"‏Wi-Fi کال جاری ہے"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"‏کام سے متعلق جاری Wi-Fi کال"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"ہولڈ پر ہے"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"آنے والی کال"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"کام سے متعلق آنے والی کال"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"‏آنے والی Wi-Fi کال"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"‏کام سے متعلق آنے والی Wi-Fi کال"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"آنے والی ویڈیو کال"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"آنے والی ویڈیو کی درخواست"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"نیا صوتی میل"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"نیا صوتی میل (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> ڈائل کریں"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"صوتی میل نمبر نامعلوم ہے"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"کوئی سروس نہیں ہے"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"منتخب کردہ نیٹ ورک (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) دستیاب نہیں ہے"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"جواب"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"کال منقطع کریں"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"ویڈیو"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"آواز"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"قبول کریں"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"برخاست کریں"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"واپس کال کریں"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"پیغام"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"کال کرنے کیلئے، پہلے ہوائی جہاز طرز کو آف کریں۔"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"نیٹ ورک پر رجسٹرڈ نہیں ہے۔"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"سیلولر نیٹ ورک دستیاب نہیں ہے۔"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"کال کرنے کیلئے، ایک درست نمبر درج کریں۔"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"کال نہیں ہو سکتی۔"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"‏MMI ترتیب شروع ہو رہی ہے…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"سروس تعاون یافتہ نہیں ہے۔"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"کالز سوئچ نہیں ہو سکتیں۔"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"کال الگ نہیں ہو سکتی۔"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"منتقل نہیں ہو سکتی۔"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"کانفرنس نہیں ہو سکتی۔"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"کال مسترد نہیں ہو سکتی۔"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"کال(ز) ریلیز نہیں ہو سکتیں۔"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"‏SIP کال"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"ہنگامی کال"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"ریڈیو آن ہو رہا ہے…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"کوئی سروس نہیں ہے۔ دوبارہ کوشش کی جا رہی ہے…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"کال نہیں کی جا سکتی۔ <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> ایک ہنگامی نمبر نہیں ہے۔"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"کال نہیں کی جا سکتی۔ ایک ہنگامی نمبر ڈائل کریں۔"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"ڈائل کرنے کیلئے کی بورڈ استعمال کریں"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"کال کو ہولڈ کریں"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"کال کو دوبارہ شروع کریں"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"کال ختم کریں"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"ڈائل پیڈ"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"خاموش کریں"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"کال شامل کریں"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"کالز کو ضم کریں"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"تبادلہ کریں"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"کالز کا نظم کریں"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"کانفرنس کال کا نظم کریں"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"آڈیو"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"ویڈیو کال"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"صوتی کال میں تبدیل کریں"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"کیمرا سوئچ کریں"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"ویڈیو موقوف کریں"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"مزید اختیارات"</string>
+    <string name="player_started" msgid="3478865572468310331">"پلیئر شروع ہوگیا"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"پلیئر بند ہوگیا"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"کیمرا تیار نہیں ہے"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"کیمرا تیار ہے"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"نامعلوم کال سیشن ایونٹ"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"سروس"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"ترتیب دیں"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"‏‎&lt;سیٹ نہیں ہے&gt;‎"</string>
+    <string name="other_settings" msgid="6699076019841942826">"کال کی دیگر ترتیبات"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"کالنگ بذریعہ <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> کے ذریعے آنے والی"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"رابطہ کی تصویر"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"نجی ہوجائیں"</string>
+    <string name="selectContact" msgid="92191462970821951">"رابطہ منتخب کریں"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"اپنا ذاتی تحریر کریں…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"منسوخ کریں"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"بھیجیں"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"جواب دیں"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"‏SMS بھیجیں"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"مسترد کریں"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"ویڈیو کال کے بطور جواب دیں"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"آڈیو کال کے بطور جواب دیں"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"ویڈیو کی درخواست قبول کریں"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"ویڈیو کی درخواست مسترد کریں"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"ویڈیو منتقل کرنے کی درخواست قبول کریں"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"ویڈیو منتقل کرنے کی درخواست مسترد کریں"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"ویڈیو موصول کرنے کی درخواست قبول کریں"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"ویڈیو موصول کرنے کی درخواست مسترد کریں"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> کیلئے اوپر سلائیڈ کریں۔"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> کیلئے بائیں سلائیڈ کریں۔"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> کیلئے دائیں سلائیڈ کریں۔"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> کیلئے نیچے سلائیڈ کریں۔"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"ارتعاش"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"ارتعاش"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"آواز"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"ڈیفالٹ آواز (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"فون رِنگ ٹون"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"رِنگ کے وقت مرتعش کریں"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"رنگ ٹون اور ارتعاش"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"کانفرنس کال کا نظم کریں"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"ہنگامی نمبر"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> سیکنڈ</item>
+      <item quantity="one">1 سیکنڈ</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"> منٹ</item>
+      <item quantity="one">1 منٹ</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> گھنٹے</item>
+      <item quantity="one">1 گھنٹہ</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"پروفائل کی تصویر"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"کیمرا آف ہے"</string>
+    <string name="child_number" msgid="4469090994612105532">"بذریعہ <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"نوٹ بھیج دیا گیا"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"حالیہ پیغامات"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"کاروباری معلومات"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> میل دور"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> کلومیٹر دور"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>، <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>، <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"کل <xliff:g id="OPEN_TIME">%s</xliff:g> بجے کھلے گا"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"آج <xliff:g id="OPEN_TIME">%s</xliff:g> بجے کھلے گا"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g> بجے بند ہوگا"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"آج <xliff:g id="CLOSE_TIME">%s</xliff:g> بجے بند ہوا"</string>
+    <string name="open_now" msgid="4615706338669555999">"ابھی کھلا ہے"</string>
+    <string name="closed_now" msgid="2635314668145282080">"اب بند ہے"</string>
+</resources>
diff --git a/InCallUI/res/values-uz-rUZ/strings.xml b/InCallUI/res/values-uz-rUZ/strings.xml
new file mode 100644
index 0000000..fbf86d4
--- /dev/null
+++ b/InCallUI/res/values-uz-rUZ/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Telefon"</string>
+    <string name="onHold" msgid="527593602772521700">"Kutmoqda"</string>
+    <string name="unknown" msgid="3646075119047488748">"Noma’lum"</string>
+    <string name="private_num" msgid="6081418498487514686">"Shaxsiy raqam"</string>
+    <string name="payphone" msgid="5743050584468748607">"Taksofon"</string>
+    <string name="confCall" msgid="3181961445236675173">"Konferensiya qo‘ng‘irog‘i"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Qo‘ng‘iroq tugatildi"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Karnay"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Telefon quloqchini"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Simli garnitura"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Quyidagi tovushlar jo‘natilsinmi?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Tovushlar jo‘natilmoqda\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Yuborish"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Ha"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Yo‘q"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Belgilarni quyidagilar bilan almashtiring:"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Konferensiya qo‘ng‘irog‘i <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Ovozli pochta raqami"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Raqam terilmoqda"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Qayta terilmoqda"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Konferensiya qo‘ng‘irog‘i"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Kiruvchi qo‘ng‘iroq"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Kiruvchi ishchi qo‘ng‘irog‘i"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Qo‘ng‘iroq tugadi"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Kutmoqda"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Suhbat tugatilmoqda"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Band"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Mening raqamim – <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Videoga ulanmoqda"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Video qo‘ng‘iroq"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Video so‘ralmoqda"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Video qo‘ng‘iroqqa ulanib bo‘lmadi"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Video qo‘ng‘iroq so‘rovi rad etildi"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Teskari qo‘ng‘iroq raqamingiz\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Favqulodda holatlar uchun teskari qo‘ng‘iroq raqamingiz\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Raqam terilmoqda"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Javobsiz qo‘ng‘iroq"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Javobsiz qo‘ng‘iroqlar"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ta javobsiz qo‘ng‘iroq"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"<xliff:g id="MISSED_CALL_FROM">%s</xliff:g> qo‘ng‘irog‘i javobsiz qoldirildi"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Joriy qo‘ng‘iroq"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Chiquvchi ishchi qo‘ng‘irog‘i"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Chiquvchi Wi-Fi qo‘ng‘irog‘i"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Chiquvchi Wi-Fi ishchi qo‘ng‘irog‘i"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Kutmoqda"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Kiruvchi qo‘ng‘iroq"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Kiruvchi ishchi qo‘ng‘irog‘i"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Kiruvchi Wi-Fi qo‘ng‘irog‘i"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Kiruvchi Wi-Fi ishchi qo‘ng‘irog‘i"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Kiruvchi video qo‘ng‘iroq"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Kiruvchi video qo‘ng‘iroq"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Yangi ovozli xabar"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Yangi ovozli xabar (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g> raqamini terish"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Ovozli pochta raqami noma’lum"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Xizmat mavjud emas"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Tanlangan tarmoq (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) mavjud emas"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Javob"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Suhbatni tugatish"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video aloqa"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Ovozli aloqa"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Qabul qilish"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Rad etish"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Telefon qilish"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"SMS yuborish"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Qo‘ng‘iroq qilish uchun, avval “Parvoz rejimi” o‘chirilishi kerak."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Tarmoqda ro‘yxatdan o‘tmagan."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Uyali tarmoq mavjud emas."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Qo‘ng‘iroq qilish uchun raqamni to‘g‘ri kiriting."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Qo‘ng‘iroq qilib bo‘lmadi."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"MMI tartibi ishga tushmoqda…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Xizmat qo‘llab-quvvatlanmaydi."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Qo‘ng‘iroqlarni almashtirib bo‘lmadi."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Qo‘ng‘iroqni ajratib bo‘lmadi."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"O‘tkazib bo‘lmadi."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Konferens-aloqa o‘rnatib bo‘lmadi."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Qo‘ng‘iroqni rad qilib bo‘lmadi."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Qo‘ng‘iroq(lar)ni chiqarib bo‘lmadi."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP qo‘ng‘iroq"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Favqulodda qo‘ng‘iroq"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Radio yoqilmoqda…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Aloqa yo‘q. Qayta urinilmoqda…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Qo‘ng‘iroq qilib bo‘lmadi. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> favqulodda raqam emas."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Qo‘ng‘iroq qilib bo‘lmadi. Favqulodda raqamga tering."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Terish uchun klaviaturadan foydalaning"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Qo‘ng‘iroqni ushlab turish"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Qo‘ng‘iroqni davom ettirish"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Qo‘ng‘iroqni tugatish"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Tugmachalar"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Ovozni o‘chirish"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Qo‘ng‘iroq qo‘shish"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Qo‘ng‘iroqlarni birlashtirish"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Almashtirish"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Qo‘ng‘iroqlarni boshqarish"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Konf. qo‘ng‘irog‘ini boshqarish"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Audio"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Video qo‘ng‘iroq"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Ovozli qo‘ng‘iroqqa o‘zgartirish"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Kamerani almashtirish"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Videoni to‘xtatib turish"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Ko‘proq"</string>
+    <string name="player_started" msgid="3478865572468310331">"Pleyer ishga tushirildi"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Pleyer to‘xtatildi"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Kamera tayyor emas"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Kamera tayyor"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Noma’lum qo‘ng‘iroq sessiyasi hodisasi"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Xizmat"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Sozlash"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;O‘rnatilmagan&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Boshqa qo‘ng‘iroq sozlamalari"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> orqali qo‘ng‘rioq qilinmoqda"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"<xliff:g id="PROVIDER_NAME">%s</xliff:g> orqali kiruvchi qo‘ng‘iroqlar"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"kontakt surati"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"alohidaga o‘tish"</string>
+    <string name="selectContact" msgid="92191462970821951">"kontaktni tanlash"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"O‘z javobingizni yozing…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Bekor qilish"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Yuborish"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Javob"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"SMS yuborish"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Rad etish"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Video qo‘ng‘iroq sifatida javob berish"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Audio qo‘ng‘iroq sifatida javob berish"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Video qo‘ng‘iroq so‘rovini qabul qilish"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Video qo‘ng‘iroq so‘rovini rad etish"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Video jo‘natmani qabul qilish"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Video jo‘natmani rad etish"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Kiruvchi video qo‘ng‘iroqni qabul qilish"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Kiruvchi video qo‘ng‘iroqni rad etish"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> uchun tepaga suring."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> uchun chapga suring."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> uchun o‘ngga suring."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g> uchun pastga suring."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Tebranish"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Tebranish"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Ovoz"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Standart ovoz (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Telefon ringtoni"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Jiringlash vaqtida tebranish"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Qo‘ng‘iroq ohangi va tebranish"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Konferensiya qo‘ng‘irog‘ini boshqarish"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Favqulodda qo‘ng‘iroq raqami"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> soniya</item>
+      <item quantity="one">1 soniya</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> daqiqa</item>
+      <item quantity="one">1 daqiqa</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> soat</item>
+      <item quantity="one">1 soat</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Profil rasmi"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Kamera o‘chiq"</string>
+    <string name="child_number" msgid="4469090994612105532">"<xliff:g id="CHILD_NUMBER">%s</xliff:g> orqali"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Qayd yuborildi"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"So‘nggi xabarlar"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Korporativ ma’lumotlar"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> mil uzoqda"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> km uzoqda"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> – <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Ertaga <xliff:g id="OPEN_TIME">%s</xliff:g> da ochiladi"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Bugun <xliff:g id="OPEN_TIME">%s</xliff:g> da ochiladi"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"<xliff:g id="CLOSE_TIME">%s</xliff:g> da yopiladi"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Bugun <xliff:g id="CLOSE_TIME">%s</xliff:g> da yopiladi"</string>
+    <string name="open_now" msgid="4615706338669555999">"Ochiq"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Yopiq"</string>
+</resources>
diff --git a/InCallUI/res/values-vi/strings.xml b/InCallUI/res/values-vi/strings.xml
new file mode 100644
index 0000000..1c73617
--- /dev/null
+++ b/InCallUI/res/values-vi/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Điện thoại"</string>
+    <string name="onHold" msgid="527593602772521700">"Đang chờ"</string>
+    <string name="unknown" msgid="3646075119047488748">"Không xác định"</string>
+    <string name="private_num" msgid="6081418498487514686">"Số cá nhân"</string>
+    <string name="payphone" msgid="5743050584468748607">"Điện thoại trả tiền"</string>
+    <string name="confCall" msgid="3181961445236675173">"Cuộc gọi nhiều bên"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Cuộc gọi bị gián đoạn"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Loa"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Tai nghe ĐTDĐ"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Tai nghe có dây"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Gửi các âm sau?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Đang gửi âm\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Gửi"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Có"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Không"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Thay thế ký tự tự do bằng"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Cuộc gọi nhiều bên <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Số thư thoại"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Đang gọi"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Đang quay số lại"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Cuộc gọi nhiều bên"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Cuộc gọi đến"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Cuộc gọi đến về công việc"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Cuộc gọi đã kết thúc"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Đang chờ"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Kết thúc cuộc gọi"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Trong cuộc gọi"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Số điện thoại của tôi là <xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Đang kết nối video"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Cuộc gọi điện video"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Đang yêu cầu video"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Không kết nối được cuộc gọi điện video"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Đã từ chối yêu cầu video"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Số gọi lại của bạn\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Số gọi lại khẩn cấp của bạn\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Đang gọi"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Cuộc gọi nhỡ"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Cuộc gọi nhỡ"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> cuộc gọi nhỡ"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Cuộc gọi nhỡ từ <xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Cuộc gọi đang thực hiện"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Cuộc gọi đang diễn ra về công việc"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Cuộc gọi đang diễn ra qua Wi-Fi"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Cuộc gọi đang diễn ra qua Wi-Fi về công việc"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Đang chờ"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Cuộc gọi đến"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Cuộc gọi đến về công việc"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Cuộc gọi đến qua Wi-Fi"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Cuộc gọi đến qua Wi-Fi về công việc"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Cuộc gọi điện video đến"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Yêu cầu video đến"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Thư thoại mới"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Thư thoại mới (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Quay số <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Số thư thoại không xác định"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Không có dịch vụ"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Mạng được chọn (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) không khả dụng"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Trả lời"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Gác máy"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Video"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Thoại"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Chấp nhận"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Loại bỏ"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Gọi lại"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Tin nhắn"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Để thực hiện cuộc gọi, trước tiên, hãy tắt chế độ trên Máy bay."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Chưa được đăng ký trên mạng."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Không có mạng di động."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Để thực hiện cuộc gọi, hãy nhập một số hợp lệ."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Không thực hiện được cuộc gọi."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Đang khởi động chuỗi MMI…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Dịch vụ không được hỗ trợ."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Không chuyển đổi được cuộc gọi."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Không tách được cuộc gọi."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Không chuyển được cuộc gọi."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Không thực hiện được cuộc gọi nhiều bên."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Không từ chối được cuộc gọi."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Không thực hiện được cuộc gọi."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Cuộc gọi qua SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Cuộc gọi khẩn cấp"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Đang bật radio..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Không có dịch vụ nào. Đang thử lại…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Không thực hiện được cuộc gọi. <xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> không phải là số khẩn cấp."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Không thực hiện được cuộc gọi. Hãy quay số khẩn cấp."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Sử dụng bàn phím để quay số"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Giữ cuộc gọi"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Tiếp tục cuộc gọi"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Kết thúc cuộc gọi"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Bàn phím số"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Bỏ qua"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Thêm cuộc gọi"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Hợp nhất cuộc gọi"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Hoán đổi"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Quản lý cuộc gọi"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Quản lý cuộc gọi nhiều bên"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Âm thanh"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Cuộc gọi điện video"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Thay đổi thành cuộc gọi thoại"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Chuyển máy ảnh"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Dừng video"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Tùy chọn khác"</string>
+    <string name="player_started" msgid="3478865572468310331">"Đã khởi động trình phát"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Đã dừng trình phát"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Máy ảnh chưa sẵn sàng"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Máy ảnh đã sẵn sàng"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Sự kiện phiên cuộc gọi không xác định"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Dịch vụ"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Thiết lập"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Chưa được đặt&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Cài đặt cuộc gọi khác"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Gọi điện qua <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Cuộc gọi đến qua <xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"ảnh liên hệ"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"chuyển thành riêng tư"</string>
+    <string name="selectContact" msgid="92191462970821951">"chọn địa chỉ liên hệ"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Viết trả lời của riêng bạn..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Hủy"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Gửi"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Trả lời"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Gửi SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Từ chối"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Trả lời là cuộc gọi điện video"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Trả lời là cuộc gọi âm thanh"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Chấp nhận yêu cầu cuộc gọi video"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Từ chối yêu cầu cuộc gọi video"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Chấp nhận yêu cầu truyền video"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Từ chối yêu cầu truyền video"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Chấp nhận yêu cầu nhận video"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Từ chối yêu cầu nhận video"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Trượt lên để <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Trượt sang trái để <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Trượt sang phải để <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Trượt xuống để <xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Rung"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Rung"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Âm thanh"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Âm thanh mặc định (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Nhạc chuông điện thoại"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Rung khi đổ chuông"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Nhạc chuông và rung"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Quản lý cuộc gọi nhiều bên"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Số khẩn cấp"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> giây</item>
+      <item quantity="one">1 giây</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> phút</item>
+      <item quantity="one">1 phút</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> giờ</item>
+      <item quantity="one">1 giờ</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Ảnh hồ sơ"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Tắt máy ảnh"</string>
+    <string name="child_number" msgid="4469090994612105532">"qua <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Đã gửi ghi chú"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Tin nhắn gần đây"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Thông tin doanh nghiệp"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"Cách <xliff:g id="DISTANCE">%.1f</xliff:g> dặm"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"Cách <xliff:g id="DISTANCE">%.1f</xliff:g> km"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Mở cửa lúc <xliff:g id="OPEN_TIME">%s</xliff:g> ngày mai"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Mở cửa lúc <xliff:g id="OPEN_TIME">%s</xliff:g> hôm nay"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Đóng cửa lúc <xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Đã đóng cửa lúc <xliff:g id="CLOSE_TIME">%s</xliff:g> hôm nay"</string>
+    <string name="open_now" msgid="4615706338669555999">"Mở ngay bây giờ"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Hiện đã đóng cửa"</string>
+</resources>
diff --git a/InCallUI/res/values-w600dp-land/colors.xml b/InCallUI/res/values-w600dp-land/colors.xml
new file mode 100644
index 0000000..77eea2e
--- /dev/null
+++ b/InCallUI/res/values-w600dp-land/colors.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<resources>
+    <!-- Background color for status bar. For portrait this will be ignored. -->
+    <color name="statusbar_background_color">#000000</color>
+</resources>
diff --git a/InCallUI/res/values-w600dp-land/dimens.xml b/InCallUI/res/values-w600dp-land/dimens.xml
new file mode 100644
index 0000000..59a5a9a
--- /dev/null
+++ b/InCallUI/res/values-w600dp-land/dimens.xml
@@ -0,0 +1,26 @@
+<?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
+  -->
+
+<resources>
+    <!-- Whether or not the landscape mode layout is currently being used -->
+    <bool name="is_layout_landscape">true</bool>
+    <!-- Height and width of the in-call buttons. -->
+    <dimen name="in_call_button_dimension">40dp</dimen>
+    <!-- Margin underneath the call buttons. This is used only in landscape mode and is sized
+         so that the call buttons are center aligned with the end call button. -->
+    <dimen name="call_buttons_bottom_margin">30dp</dimen>
+</resources>
diff --git a/InCallUI/res/values-zh-rCN/strings.xml b/InCallUI/res/values-zh-rCN/strings.xml
new file mode 100644
index 0000000..38af8a9
--- /dev/null
+++ b/InCallUI/res/values-zh-rCN/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"电话"</string>
+    <string name="onHold" msgid="527593602772521700">"保持"</string>
+    <string name="unknown" msgid="3646075119047488748">"未知"</string>
+    <string name="private_num" msgid="6081418498487514686">"私密号码"</string>
+    <string name="payphone" msgid="5743050584468748607">"公用电话"</string>
+    <string name="confCall" msgid="3181961445236675173">"电话会议"</string>
+    <string name="call_lost" msgid="8208184291640961172">"通话中断"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"扬声器"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"手机听筒"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"有线耳机"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"蓝牙"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"发送以下信号音？\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"正在发送信号音\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"发送"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"是"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"否"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"将通配符替换为"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"电话会议（<xliff:g id="CONF_CALL_TIME">%s</xliff:g>）"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"语音信箱号码"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"正在拨号"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"正在重拨"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"电话会议"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"来电"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"工作来电"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"通话已结束"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"保持"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"正在挂断"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"正在通话"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"我的电话号码：<xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"正在建立视频连接"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"视频通话"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"正在发出视频请求"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"无法建立视频通话连接"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"视频请求遭拒"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"您的回拨号码如下：\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"您的紧急回拨号码如下：\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"正在拨号"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"未接电话"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"未接电话"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> 个未接电话"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"来自<xliff:g id="MISSED_CALL_FROM">%s</xliff:g>的未接电话"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"通话进行中"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"工作通话进行中"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"WLAN 通话进行中"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"WLAN 工作通话进行中"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"保持"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"来电"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"工作来电"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"WLAN 来电"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"WLAN 工作来电"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"视频通话来电"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"收到视频请求"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"新语音邮件"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"新语音邮件 (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"拨打 <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"语音信箱号码未知"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"没有服务"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"所选网络（<xliff:g id="OPERATOR_NAME">%s</xliff:g>）不可用"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"接听"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"挂断"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"视频"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"语音"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"接受"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"拒绝"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"回电"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"发短信"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"要拨打电话，请先关闭飞行模式。"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"尚未注册网络。"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"无法连接到移动网络。"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"要拨打电话，请输入有效的电话号码。"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"无法拨打该电话。"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"正在启动 MMI 序列…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"服务不受支持。"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"无法切换通话。"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"无法单独通话。"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"无法转移呼叫。"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"无法进行电话会议。"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"无法拒接来电。"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"无法挂断。"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP 通话"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"紧急呼救"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"正在开启无线装置…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"找不到服务信号，正在重试…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"无法拨打该电话。<xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> 不是紧急呼救号码。"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"无法拨打该电话。请拨打紧急呼救号码。"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"使用键盘拨号"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"保持通话"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"恢复通话"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"结束通话"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"拨号键盘"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"静音"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"添加通话"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"合并通话"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"切换"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"管理通话"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"管理电话会议"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"音频"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"视频通话"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"改为语音通话"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"切换摄像头"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"暂停视频"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"更多选项"</string>
+    <string name="player_started" msgid="3478865572468310331">"播放器已启动"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"播放器已停止"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"摄像头尚未准备就绪"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"摄像头已准备就绪"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"未知通话事件"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"服务"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"设置"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;未设置&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"其他通话设置"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"正在通过<xliff:g id="PROVIDER_NAME">%s</xliff:g>进行通话"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"有人通过<xliff:g id="PROVIDER_NAME">%s</xliff:g>来电"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"联系人照片"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"私聊"</string>
+    <string name="selectContact" msgid="92191462970821951">"选择联系人"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"自行撰写回复…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"取消"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"发送"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"接听"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"发送短信"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"拒绝"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"以视频通话的形式接听"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"以音频通话的形式接听"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"接受视频请求"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"拒绝视频请求"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"接受视频传输请求"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"拒绝视频传输请求"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"接受视频接收请求"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"拒绝视频接收请求"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"向上滑动即可<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>。"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"向左滑动即可<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>。"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"向右滑动即可<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>。"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"向下滑动即可<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>。"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"振动"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"振动"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"提示音"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"默认提示音（<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>）"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"手机铃声"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"响铃时振动"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"铃声和振动"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"管理电话会议"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"紧急呼救号码"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> 秒</item>
+      <item quantity="one">1 秒</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> 分钟</item>
+      <item quantity="one">1 分钟</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> 小时</item>
+      <item quantity="one">1 小时</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"个人资料照片"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"摄像头已关闭"</string>
+    <string name="child_number" msgid="4469090994612105532">"通过 <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"已发送记事"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"最近的信息"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"商家信息"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> 英里远"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> 公里远"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="LOCALITY">%2$s</xliff:g><xliff:g id="STREET_ADDRESS">%1$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>，<xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"将于明天<xliff:g id="OPEN_TIME">%s</xliff:g>开始营业"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"将于今天<xliff:g id="OPEN_TIME">%s</xliff:g>开始营业"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"将于<xliff:g id="CLOSE_TIME">%s</xliff:g>结束营业"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"已于今天<xliff:g id="CLOSE_TIME">%s</xliff:g>结束营业"</string>
+    <string name="open_now" msgid="4615706338669555999">"营业中"</string>
+    <string name="closed_now" msgid="2635314668145282080">"现已结束营业"</string>
+</resources>
diff --git a/InCallUI/res/values-zh-rHK/strings.xml b/InCallUI/res/values-zh-rHK/strings.xml
new file mode 100644
index 0000000..67af0f8
--- /dev/null
+++ b/InCallUI/res/values-zh-rHK/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"電話"</string>
+    <string name="onHold" msgid="527593602772521700">"保留通話"</string>
+    <string name="unknown" msgid="3646075119047488748">"不明"</string>
+    <string name="private_num" msgid="6081418498487514686">"私人號碼"</string>
+    <string name="payphone" msgid="5743050584468748607">"公共電話"</string>
+    <string name="confCall" msgid="3181961445236675173">"會議通話"</string>
+    <string name="call_lost" msgid="8208184291640961172">"通話已中斷"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"喇叭"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"免提聽筒"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"有線耳機"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"藍牙"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"要傳送以下訊號音嗎？\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"正在傳送訊號音\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"傳送"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"是"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"否"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"將萬用字元改為"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"會議通話：<xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"留言號碼"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"正在撥號"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"正在重撥"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"會議通話"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"來電"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"工作來電"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"通話已結束"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"保留通話"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"正在掛斷電話"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"正在通話"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"我的電話號碼：<xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"正在建立視像通話連線"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"視像通話"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"正在提出視像通話要求"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"無法建立視像通話連線"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"視像通話要求被拒"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"您的回撥號碼：\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"您的緊急回撥號碼：\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"正在撥號"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"未接來電"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"未接來電"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> 個未接來電"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"來自 <xliff:g id="MISSED_CALL_FROM">%s</xliff:g> 的未接來電"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"通話中"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"正在進行工作通話"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"正在進行 Wi-Fi 通話"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"正在進行 Wi-Fi 工作通話"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"保留通話"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"來電"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"工作來電"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Wi-Fi 來電"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Wi-Fi 工作來電"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"視像通話來電"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"收到視像通話要求"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"新留言"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"新留言 (<xliff:g id="COUNT">%d</xliff:g> 個)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"撥打 <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"留言號碼不明"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"沒有服務"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"您選取的網絡 (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) 無法使用"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"接聽"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"掛斷電話"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"視像通話"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"語音通話"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"接受"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"拒絕"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"回電"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"短訊"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"如要撥打電話，請先關閉飛行模式。"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"未在網絡上註冊。"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"無法連線至流動網絡。"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"如要撥打電話，請輸入有效的號碼。"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"無法通話。"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"開始 MMI 序列…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"不支援此服務。"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"無法切換通話。"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"無法分開通話。"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"無法轉接。"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"無法進行會議通話。"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"無法拒接來電。"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"無法結束通話。"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP 通話"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"緊急電話"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"正在開啟無線電…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"找不到服務，請再試一次…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"無法通話。<xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> 不是緊急電話號碼。"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"無法通話。請撥打緊急電話號碼。"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"使用鍵盤撥號"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"保留通話"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"恢復通話"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"結束通話"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"撥號鍵盤"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"靜音"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"新增通話"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"合併通話"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"切換"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"管理通話"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"管理會議通話"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"音訊"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"視像通話"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"變更為語音通話"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"切換鏡頭"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"暫停視像通話"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"更多選項"</string>
+    <string name="player_started" msgid="3478865572468310331">"已啟動播放器"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"已停止播放器"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"相機未準備好"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"相機已準備就緒"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"不明的通話工作階段活動"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"服務"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"設定"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;未設定&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"其他通話設定"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"正在透過 <xliff:g id="PROVIDER_NAME">%s</xliff:g> 撥號"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"有人透過 <xliff:g id="PROVIDER_NAME">%s</xliff:g> 來電"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"聯絡人相片"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"私人通話"</string>
+    <string name="selectContact" msgid="92191462970821951">"選取聯絡人"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"自行撰寫回覆..."</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"取消"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"傳送"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"接聽"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"傳送短訊"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"拒絕"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"接聽視像通話"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"接聽語音通話"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"接受視像通話要求"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"拒絕視像通話要求"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"接受視像通話轉駁要求"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"拒絕視像通話轉駁要求"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"接受視像接收要求"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"拒絕視像接收要求"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"向上滑動即可<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>。"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"向左滑動即可<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>。"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"向右滑動即可<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>。"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"向下滑動即可<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>。"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"震動"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"震動"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"音效"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"預設音效 (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"手機鈴聲"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"響鈴時震動"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"鈴聲和震動"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"管理會議通話"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"緊急電話號碼"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> 秒</item>
+      <item quantity="one">1 秒</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> 分鐘</item>
+      <item quantity="one">1 分鐘</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> 小時</item>
+      <item quantity="one">1 小時</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"個人檔案相片"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"相機已關閉"</string>
+    <string name="child_number" msgid="4469090994612105532">"透過 <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"已傳送筆記"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"最近的訊息"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"公司資料"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> 英里外"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> 公里外"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="LOCALITY">%2$s</xliff:g><xliff:g id="STREET_ADDRESS">%1$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>，<xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"將於明天<xliff:g id="OPEN_TIME">%s</xliff:g>開始營業"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"將於今天<xliff:g id="OPEN_TIME">%s</xliff:g>開始營業"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"將於<xliff:g id="CLOSE_TIME">%s</xliff:g>關門"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"已於今天<xliff:g id="CLOSE_TIME">%s</xliff:g>關門"</string>
+    <string name="open_now" msgid="4615706338669555999">"營業中"</string>
+    <string name="closed_now" msgid="2635314668145282080">"目前休息"</string>
+</resources>
diff --git a/InCallUI/res/values-zh-rTW/strings.xml b/InCallUI/res/values-zh-rTW/strings.xml
new file mode 100644
index 0000000..0ef733f
--- /dev/null
+++ b/InCallUI/res/values-zh-rTW/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"電話"</string>
+    <string name="onHold" msgid="527593602772521700">"保留"</string>
+    <string name="unknown" msgid="3646075119047488748">"不明"</string>
+    <string name="private_num" msgid="6081418498487514686">"私人號碼"</string>
+    <string name="payphone" msgid="5743050584468748607">"公用電話"</string>
+    <string name="confCall" msgid="3181961445236675173">"電話會議"</string>
+    <string name="call_lost" msgid="8208184291640961172">"通話已中斷"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"喇叭"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"手機聽筒"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"有線耳機"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"藍牙"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"要傳送以下的信號音嗎？\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"正在傳送信號音\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"傳送"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"是"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"否"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"將萬用字元替換為"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"電話會議 <xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"語音留言號碼"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"撥號中"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"重撥中"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"電話會議"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"來電"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"公司來電"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"通話已結束"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"保留"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"掛斷中"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"通話中"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"我的電話號碼：<xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"正在建立視訊通話連線"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"視訊通話"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"正在提出視訊通話要求"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"無法建立視訊通話連線"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"視訊通話要求遭拒"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"您的回撥號碼如下\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"您的緊急回撥號碼如下\n <xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"撥號中"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"未接來電"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"未接來電"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> 通未接來電"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"來自 <xliff:g id="MISSED_CALL_FROM">%s</xliff:g> 的未接來電"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"進行中的通話"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"進行中的公司通話"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"進行中的通話 (透過 Wi-Fi)"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"進行中的公司通話 (透過 Wi-Fi)"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"保留"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"來電"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"公司來電"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"來電 (透過 Wi-Fi)"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"公司來電 (透過 Wi-Fi)"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"視訊通話來電"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"收到視訊通話要求"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"新的語音留言"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"新的語音留言 (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"撥打 <xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"語音留言號碼不明"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"沒有服務"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"您所選取的網路 (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) 無法使用"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"接聽"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"掛斷"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"視訊通話"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"語音通話"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"接受"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"拒絕"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"回撥"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"傳送簡訊"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"撥號前，請先關閉飛航模式。"</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"尚未註冊網路。"</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"無法連線到行動網路。"</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"如要撥打電話，請輸入有效的號碼。"</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"無法通話。"</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"開始 MMI 序列…"</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"不支援的服務。"</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"無法切換通話。"</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"無法分割通話。"</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"無法轉接。"</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"無法進行電話會議。"</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"無法拒接來電。"</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"無法掛斷電話。"</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"SIP 通話"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"緊急電話"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"正在開啟無線通訊…"</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"找不到服務訊號，重試中…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"無法通話。<xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> 不是緊急電話號碼。"</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"無法通話。只能撥打緊急號碼。"</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"使用鍵盤撥號"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"保留通話"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"恢復通話"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"結束通話"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"撥號鍵盤"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"靜音"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"新增通話"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"合併通話"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"切換"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"管理通話"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"管理電話會議"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"音訊"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"視訊通話"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"變更為語音通話"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"切換鏡頭"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"暫停視訊畫面"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"更多選項"</string>
+    <string name="player_started" msgid="3478865572468310331">"已啟動播放器"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"已停止播放器"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"相機尚未就緒"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"相機已準備就緒"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"不明的通話工作階段事件"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"服務"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"設定"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;未設定&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"其他通話設定"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"正在透過 <xliff:g id="PROVIDER_NAME">%s</xliff:g> 撥號"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"有人透過 <xliff:g id="PROVIDER_NAME">%s</xliff:g> 來電"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"聯絡人相片"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"私人通話"</string>
+    <string name="selectContact" msgid="92191462970821951">"選取聯絡人"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"自行撰寫回應…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"取消"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"傳送"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"接聽"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"傳送簡訊"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"拒絕"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"接聽視訊通話"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"接聽語音通話"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"接受視訊通話要求"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"拒絕視訊通話要求"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"接受視訊傳送要求"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"拒絕視訊傳送要求"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"接受視訊接收要求"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"拒絕視訊接收要求"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"向上滑動即可<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>。"</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"向左滑動即可<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>。"</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"向右滑動即可<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>。"</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"向下滑動即可<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>。"</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"震動"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"震動"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"音效"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"預設音效 (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"手機鈴聲"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"鈴響時震動"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"鈴聲與震動"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"管理電話會議"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"緊急電話號碼"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> 秒</item>
+      <item quantity="one">1 秒</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> 分鐘</item>
+      <item quantity="one">1 分鐘</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> 小時</item>
+      <item quantity="one">1 小時</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"個人資料相片"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"相機已停用"</string>
+    <string name="child_number" msgid="4469090994612105532">"透過 <xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"備註已送出"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"最近的訊息"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"商家資訊"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> 英里遠"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> 公里遠"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="LOCALITY">%2$s</xliff:g>，<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>，<xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"將於明日<xliff:g id="OPEN_TIME">%s</xliff:g>開始營業"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"將於本日<xliff:g id="OPEN_TIME">%s</xliff:g>開始營業"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"將於<xliff:g id="CLOSE_TIME">%s</xliff:g>結束營業"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"已於本日<xliff:g id="CLOSE_TIME">%s</xliff:g>結束營業"</string>
+    <string name="open_now" msgid="4615706338669555999">"營業中"</string>
+    <string name="closed_now" msgid="2635314668145282080">"本日已結束營業"</string>
+</resources>
diff --git a/InCallUI/res/values-zu/strings.xml b/InCallUI/res/values-zu/strings.xml
new file mode 100644
index 0000000..11195de
--- /dev/null
+++ b/InCallUI/res/values-zu/strings.xml
@@ -0,0 +1,192 @@
+<?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
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="phoneAppLabel" product="default" msgid="4753450867264774000">"Ifoni"</string>
+    <string name="onHold" msgid="527593602772521700">"Ibanjiwe"</string>
+    <string name="unknown" msgid="3646075119047488748">"Akwaziwa"</string>
+    <string name="private_num" msgid="6081418498487514686">"Inombolo eyimfihlo"</string>
+    <string name="payphone" msgid="5743050584468748607">"Ucingo olufakwa imali"</string>
+    <string name="confCall" msgid="3181961445236675173">"Ikholi yenkomfa"</string>
+    <string name="call_lost" msgid="8208184291640961172">"Ikholi ivaliwe"</string>
+    <string name="audio_mode_speaker" msgid="6160127758732918123">"Isipikha"</string>
+    <string name="audio_mode_earpiece" msgid="3138677187223932893">"Isipikha sendlebe sama-ear phone"</string>
+    <string name="audio_mode_wired_headset" msgid="583080366967943196">"Ama-earphone anezintambo"</string>
+    <string name="audio_mode_bluetooth" msgid="3188504589946495676">"I-Bluetooth"</string>
+    <string name="wait_prompt_str" msgid="3784275777844586675">"Thumela amathoni alandelayo?\n"</string>
+    <string name="pause_prompt_str" msgid="4507496811727697620">"Ithumela amathoni\n"</string>
+    <string name="send_button" msgid="4054398309483035794">"Thumela"</string>
+    <string name="pause_prompt_yes" msgid="6738588490007499118">"Yebo"</string>
+    <string name="pause_prompt_no" msgid="417286529736964178">"Cha"</string>
+    <string name="wild_prompt_str" msgid="8178750766679617355">"Miselela uhlamvu lwasendle nge"</string>
+    <string name="caller_manage_header" msgid="4036790479287738218">"Ikholi yenkomfa engu-<xliff:g id="CONF_CALL_TIME">%s</xliff:g>"</string>
+    <string name="voicemail_settings_number_label" msgid="2951965862286532957">"Inombolo yevoyisimeyili"</string>
+    <string name="card_title_dialing" msgid="5046026076417718916">"Iyadayela"</string>
+    <string name="card_title_redialing" msgid="8072468059192027844">"Iphinda iyadayela"</string>
+    <string name="card_title_conf_call" msgid="1747835072739982104">"Ikholi yenkomfa"</string>
+    <string name="card_title_incoming_call" msgid="4138485434087223132">"Ikholi engenayo"</string>
+    <string name="card_title_incoming_work_call" msgid="7000583925426981712">"Ikholi engenayo yomsebenzi"</string>
+    <string name="card_title_call_ended" msgid="5249815286629136486">"Ikholi iqediwe"</string>
+    <string name="card_title_on_hold" msgid="5633854828341577689">"Ibanjiwe"</string>
+    <string name="card_title_hanging_up" msgid="3402022578391538671">"Iyavala"</string>
+    <string name="card_title_in_call" msgid="5029165346952099302">"Ukukholi"</string>
+    <string name="card_title_my_phone_number" msgid="3749572971322520177">"Inombolo yami ngu-<xliff:g id="MY_PHONE_NUMBER">%s</xliff:g>"</string>
+    <string name="card_title_video_call_connecting" msgid="9171270899902894036">"Ixhuma ividiyo"</string>
+    <string name="card_title_video_call" msgid="6519406270853889302">"Ikholi yevidiyo"</string>
+    <string name="card_title_video_call_requesting" msgid="1611293204379882739">"Icela ividiyo"</string>
+    <string name="card_title_video_call_error" msgid="8488074823425848193">"Ayikwazi ukuxhuma ikholi yevidiyo"</string>
+    <string name="card_title_video_call_rejected" msgid="2885215432045215465">"Isicelo sevidiyo sinqatshelwe"</string>
+    <string name="card_title_callback_number" msgid="7646082782307705748">"Inombolo yakho yokuphinda ushaye\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="card_title_callback_number_emergency" msgid="8916355112472826080">"Inombolo yakho yokuphinda ushayelwe yesimo esiphuthumayo\n<xliff:g id="DARK_NUMBER">%1$s</xliff:g>"</string>
+    <string name="notification_dialing" msgid="8080968169444117163">"Iyadayela"</string>
+    <string name="notification_missedCallTitle" msgid="2774630248151712215">"Ikholi ephuthelwe"</string>
+    <string name="notification_missedCallsTitle" msgid="263275811089605859">"Amakholi akuphuthele"</string>
+    <string name="notification_missedCallsMsg" msgid="69408330370667429">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> amakholi akulahlekele"</string>
+    <string name="notification_missedCallTicker" msgid="1599269453813734699">"Uphuthelwe ikholi kusukela ku-<xliff:g id="MISSED_CALL_FROM">%s</xliff:g>"</string>
+    <string name="notification_ongoing_call" msgid="8633734299234807397">"Ikholi eqhubekayo"</string>
+    <string name="notification_ongoing_work_call" msgid="3465083293325006579">"Ikholi yomsebenzi eqhubekayo"</string>
+    <string name="notification_ongoing_call_wifi" msgid="4140639349603930166">"Ikholi ye-Wi-Fi eqhubekayo"</string>
+    <string name="notification_ongoing_work_call_wifi" msgid="8469582753279163976">"Ikholi yomsebenzi eqhubekayo ye-Wi-Fi"</string>
+    <string name="notification_on_hold" msgid="3151343576023182586">"Ibanjiwe"</string>
+    <string name="notification_incoming_call" msgid="5904745644632328863">"Ikholi engenayo"</string>
+    <string name="notification_incoming_work_call" msgid="281305845895342925">"Ikholi engenayo yomsebenzi"</string>
+    <string name="notification_incoming_call_wifi" msgid="8337740714221114955">"Ikholi ye-Wi-Fi engenayo"</string>
+    <string name="notification_incoming_work_call_wifi" msgid="3248418394186803763">"Ikholi engenayo yomsebenzi ye-Wi-Fi"</string>
+    <string name="notification_incoming_video_call" msgid="7814873581838165772">"Ikholi yevidiyo engenayo"</string>
+    <string name="notification_requesting_video_call" msgid="4844596091477863245">"Isicelo sevidiyo engenayo"</string>
+    <string name="notification_voicemail_title" msgid="7595628197933709144">"Ivoyisimeyili entsha"</string>
+    <string name="notification_voicemail_title_count" msgid="1241573926817248239">"Ivoyisimeyili entsha (<xliff:g id="COUNT">%d</xliff:g>)"</string>
+    <string name="notification_voicemail_text_format" msgid="6496440879085042069">"Dayela u-<xliff:g id="VOICEMAIL_NUMBER">%s</xliff:g>"</string>
+    <string name="notification_voicemail_no_vm_number" msgid="5433652017869242375">"Inombolo yevoyisimeyili ayaziwa"</string>
+    <string name="notification_network_selection_title" msgid="6785177943238085441">"Ayikho isevisi"</string>
+    <string name="notification_network_selection_text" msgid="9097902390701009591">"Inethiwekhi ekhethiwe (<xliff:g id="OPERATOR_NAME">%s</xliff:g>) ayitholakali"</string>
+    <string name="notification_action_answer" msgid="8418990052527593953">"Phendula"</string>
+    <string name="notification_action_end_call" msgid="2152010639043225860">"Vala ikholi"</string>
+    <string name="notification_action_answer_video" msgid="2400233093494856655">"Ividiyo"</string>
+    <string name="notification_action_answer_voice" msgid="3206168292649273866">"Izwi"</string>
+    <string name="notification_action_accept" msgid="8595047032790476122">"Yamukela"</string>
+    <string name="notification_action_dismiss" msgid="1998811618480434300">"Cashisa"</string>
+    <string name="notification_missedCall_call_back" msgid="7855043480614703539">"Phinda ushayele"</string>
+    <string name="notification_missedCall_message" msgid="2407410183079324393">"Umlayezo"</string>
+    <string name="incall_error_power_off" msgid="3626117639377110403">"Ukwenza ikholi, vala kuqala imodi Yendiza."</string>
+    <string name="incall_error_emergency_only" msgid="8704761887752183855">"Ayibhalisiwe kwinethiwekhi."</string>
+    <string name="incall_error_out_of_service" msgid="1830319376612608339">"Inethiwekhi yeselula ayitholakali."</string>
+    <string name="incall_error_no_phone_number_supplied" msgid="3042963797202928322">"Ukuze wenze ikholi, faka inombolo evumelekile."</string>
+    <string name="incall_error_call_failed" msgid="2213413937257570551">"Ayikwazi ukushaya."</string>
+    <string name="incall_status_dialed_mmi" msgid="8864341962086874751">"Iqalisa ukulandelana kwe-MMI..."</string>
+    <string name="incall_error_supp_service_unknown" msgid="3390926762577861268">"Isevisi ayisekelwe."</string>
+    <string name="incall_error_supp_service_switch" msgid="4893764463854753730">"Ayikwazi ukushintsha amakholi."</string>
+    <string name="incall_error_supp_service_separate" msgid="5469628699581380277">"Ayikwazi ukuhlukanisa ikholi."</string>
+    <string name="incall_error_supp_service_transfer" msgid="3220469890457973326">"Ayikwazi ukudlulisela."</string>
+    <string name="incall_error_supp_service_conference" msgid="3100373998543200356">"Ayikwazi ukwenza inkomfa."</string>
+    <string name="incall_error_supp_service_reject" msgid="4543915892409365831">"Ayikwazi ukunqabela ikholi."</string>
+    <string name="incall_error_supp_service_hangup" msgid="101167589969625637">"Ayikwazi ukukhipha amakholi."</string>
+    <string name="incall_call_type_label_sip" msgid="1327822795765282192">"Ikholi ye-SIP"</string>
+    <string name="emergency_enable_radio_dialog_title" msgid="7882321703828314787">"Ikholi ephuthumayo"</string>
+    <string name="emergency_enable_radio_dialog_message" msgid="4382752053654184327">"Ivula irediyo..."</string>
+    <string name="emergency_enable_radio_dialog_retry" msgid="1672288458940152814">"Ayikho isevisi. Iyazama futhi…"</string>
+    <string name="dial_emergency_error" msgid="582305854626092376">"Ayikwazi ukushaya. U-<xliff:g id="NON_EMERGENCY_NUMBER">%s</xliff:g> akuyona inombolo yesimo esiphuthumayo."</string>
+    <string name="dial_emergency_empty_error" msgid="199888628163390267">"Ayikwazi ukushaya. Shayela inombolo yesimo esiphuthumayo."</string>
+    <string name="dialerKeyboardHintText" msgid="8533449463925408141">"Sebenzisa ikhibhodi ukudayela"</string>
+    <string name="onscreenHoldText_unselected" msgid="4509232821220492533">"Bamba ikholi"</string>
+    <string name="onscreenHoldText_selected" msgid="2988100347384733032">"Qalisa kabusha ikholi"</string>
+    <string name="onscreenEndCallText" msgid="1416981593311001074">"Qeda ikholi"</string>
+    <string name="onscreenShowDialpadText" msgid="8798170898298132499">"Iphedi yokudayela"</string>
+    <string name="onscreenMuteText" msgid="5303380507675232140">"Thulisa"</string>
+    <string name="onscreenAddCallText" msgid="5577548650466595598">"Engeza ikholi"</string>
+    <string name="onscreenMergeCallsText" msgid="4946687067221459357">"Hlanganisa amakholi"</string>
+    <string name="onscreenSwapCallsText" msgid="8272036175646846198">"Shintsha"</string>
+    <string name="onscreenManageCallsText" msgid="5491297234697209677">"Phatha amakholi"</string>
+    <string name="onscreenManageConferenceText" msgid="7043499154946980355">"Phatha ucingo lwengqungquthela"</string>
+    <string name="onscreenAudioText" msgid="8963459818052898299">"Umsindo"</string>
+    <string name="onscreenVideoCallText" msgid="1578940167445068369">"Ikholi yevidiyo"</string>
+    <string name="onscreenChangeToVoiceText" msgid="6249580619992009182">"Shintshela kukholi yezwi"</string>
+    <string name="onscreenSwitchCameraText" msgid="7141261218152736690">"Shintsha Ikhamera"</string>
+    <string name="onscreenPauseVideoText" msgid="1268768027709892604">"Misa isikhashana ividiyo"</string>
+    <string name="onscreenOverflowText" msgid="7932741239724473887">"Izinketho eziningi"</string>
+    <string name="player_started" msgid="3478865572468310331">"Umdlali uqalile"</string>
+    <string name="player_stopped" msgid="1278611664986561535">"Umdlali umisiwe"</string>
+    <string name="camera_not_ready" msgid="6614469280264241251">"Ikhamera ayilungile"</string>
+    <string name="camera_ready" msgid="2614541247814590887">"Ikhamera ilungile"</string>
+    <string name="unknown_call_session_event" msgid="2947023743819984299">"Umcimbi wesikhathi sekholi ongaziwa"</string>
+    <string name="voicemail_provider" msgid="2878119321474918370">"Isevisi"</string>
+    <string name="voicemail_settings" msgid="7548868784816068975">"Ukusetha"</string>
+    <string name="voicemail_number_not_set" msgid="2690477999015436138">"&lt;Ayisethiwe&gt;"</string>
+    <string name="other_settings" msgid="6699076019841942826">"Ezinye izilungiselelo zekholi"</string>
+    <string name="calling_via_template" msgid="3539373093109976255">"Ishaya nge-<xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="incoming_via_template" msgid="6281138766370092800">"Ingena nge-<xliff:g id="PROVIDER_NAME">%s</xliff:g>"</string>
+    <string name="contactPhoto" msgid="6028825355597675193">"isithombe soxhumana naye"</string>
+    <string name="goPrivate" msgid="3554069451018659483">"yenza kube imfihlo"</string>
+    <string name="selectContact" msgid="92191462970821951">"khetha othintana naye"</string>
+    <string name="respond_via_sms_custom_message" msgid="8210393177674619127">"Bhala okwakho…"</string>
+    <string name="custom_message_cancel" msgid="5920059627508662163">"Khansela"</string>
+    <string name="custom_message_send" msgid="3798076337006735995">"Thumela"</string>
+    <string name="description_target_answer" msgid="1111945818996518320">"Phendula"</string>
+    <string name="description_target_send_sms" msgid="3652217769615310018">"Thumela i-SMS"</string>
+    <string name="description_target_decline" msgid="7108154434759234035">"Yenqaba"</string>
+    <string name="description_target_answer_video_call" msgid="4655616461181308405">"Phendula njengekholi yevidiyo"</string>
+    <string name="description_target_answer_audio_call" msgid="3234714934649708854">"Phendula njengekholi yomsindo"</string>
+    <string name="description_target_accept_upgrade_to_video_request" msgid="384894008955682630">"Yamukela isicelo sevidiyo"</string>
+    <string name="description_target_decline_upgrade_to_video_request" msgid="7342968876159189300">"Yenqaba isicelo sevidiyo"</string>
+    <string name="description_target_accept_upgrade_to_video_transmit_request" msgid="4586773853073826378">"Yamukela isicelo sokudlulisa ividiyo"</string>
+    <string name="description_target_decline_upgrade_to_video_transmit_request" msgid="1191166008711514234">"Yenqaba isicelo sokudlulisa ividiyo"</string>
+    <string name="description_target_accept_upgrade_to_video_receive_request" msgid="2224978927364021080">"Yamukela isicelo sokwamukela ividiyo"</string>
+    <string name="description_target_decline_upgrade_to_video_receive_request" msgid="3151115394424918077">"Yenqaba isicelo sokwamukela ividiyo"</string>
+    <string name="description_direction_up" msgid="1735018141439291766">"Slayidela phezulu ku-<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_left" msgid="6811598791620851239">"Slayida ngakwesokunxele ku-<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_right" msgid="5461971399586296023">"Slayida ngakwesokudla ku-<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="description_direction_down" msgid="3331715227997561639">"Slayida ngezansi ku-<xliff:g id="TARGET_DESCRIPTION">%s</xliff:g>."</string>
+    <string name="voicemail_notification_vibrate_when_title" msgid="4595145399183729630">"Dlidlizela"</string>
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="2390729279972461242">"Dlidlizela"</string>
+    <string name="voicemail_notification_ringtone_title" msgid="1996920553949534944">"Umsindo"</string>
+    <string name="default_notification_description" msgid="4950807644546509965">"Umsindo ozenzakalelayo (<xliff:g id="DEFAULT_SOUND_TITLE">%1$s</xliff:g>)"</string>
+    <string name="ringtone_title" msgid="835582004693335905">"Ithoni yokukhala yefoni"</string>
+    <string name="vibrate_on_ring_title" msgid="5019791043398986665">"Dlidlizisa uma ikhala"</string>
+    <string name="preference_category_ringtone" msgid="6246687516643676729">"Ithoni yokukhala nokudlidliza"</string>
+    <string name="manageConferenceLabel" msgid="7237614418556336108">"Phatha ucingo lwengqungquthela"</string>
+    <string name="emergency_call_dialog_number_for_display" msgid="7244995877625769187">"Inombolo ephuthumayo"</string>
+    <plurals name="duration_seconds" formatted="false" msgid="2544699588744957418">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> amasekhondi</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> amasekhondi</item>
+    </plurals>
+    <plurals name="duration_minutes" formatted="false" msgid="8379077285441507101">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> amaminithi</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> amaminithi</item>
+    </plurals>
+    <plurals name="duration_hours" formatted="false" msgid="7420759096931824344">
+      <item quantity="one"><xliff:g id="COUNT">%d</xliff:g> amahora</item>
+      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> amahora</item>
+    </plurals>
+    <string name="profile_photo_description" msgid="7958198110870319358">"Isithombe sephrofayela"</string>
+    <string name="camera_off_description" msgid="4220023868645225790">"Ikhamera ivaliwe"</string>
+    <string name="child_number" msgid="4469090994612105532">"nge-<xliff:g id="CHILD_NUMBER">%s</xliff:g>"</string>
+    <string name="note_sent" msgid="7623014827902758398">"Inothi lithunyelwe"</string>
+    <string name="person_contact_context_title" msgid="8490058088809090979">"Imilayezo yakamuva"</string>
+    <string name="business_contact_context_title" msgid="8448362898576496764">"Ulwazi lwebhizinisi"</string>
+    <string name="distance_imperial_away" msgid="2083362798225798740">"<xliff:g id="DISTANCE">%.1f</xliff:g> amamitha kude"</string>
+    <string name="distance_metric_away" msgid="9021396592464955256">"<xliff:g id="DISTANCE">%.1f</xliff:g> amakhilomitha kude"</string>
+    <string name="display_address" msgid="444235484565491291">"<xliff:g id="STREET_ADDRESS">%1$s</xliff:g>, <xliff:g id="LOCALITY">%2$s</xliff:g>"</string>
+    <string name="open_time_span" msgid="2762952234657271236">"<xliff:g id="OPEN_TIME">%1$s</xliff:g> - <xliff:g id="CLOSE_TIME">%2$s</xliff:g>"</string>
+    <string name="opening_hours" msgid="7803506319518398380">"<xliff:g id="EARLIER_TIMES">%1$s</xliff:g>, <xliff:g id="LATER_TIME">%2$s</xliff:g>"</string>
+    <string name="opens_tomorrow_at" msgid="3567511490448488788">"Kuvulwa kusasa ngo-<xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="opens_today_at" msgid="6281212768937222891">"Kuvulwa namuhla ngo-<xliff:g id="OPEN_TIME">%s</xliff:g>"</string>
+    <string name="closes_today_at" msgid="4822369201263491509">"Kuvalwa ngo-<xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="closed_today_at" msgid="4060072663433467233">"Kuvalwe namuhla ngo-<xliff:g id="CLOSE_TIME">%s</xliff:g>"</string>
+    <string name="open_now" msgid="4615706338669555999">"Kuvuliwe manje"</string>
+    <string name="closed_now" msgid="2635314668145282080">"Kuvaliwe manje"</string>
+</resources>
diff --git a/InCallUI/res/values/animation_constants.xml b/InCallUI/res/values/animation_constants.xml
new file mode 100644
index 0000000..8df6a72
--- /dev/null
+++ b/InCallUI/res/values/animation_constants.xml
@@ -0,0 +1,22 @@
+<?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
+  -->
+<resources>
+    <!-- Duration of the InCallUI reveal and shrink animations after a call is placed -->
+    <integer name="reveal_animation_duration">333</integer>
+    <integer name="shrink_animation_duration">333</integer>
+    <integer name="video_animation_duration">257</integer>
+</resources>
diff --git a/InCallUI/res/values/array.xml b/InCallUI/res/values/array.xml
new file mode 100644
index 0000000..8744d3e
--- /dev/null
+++ b/InCallUI/res/values/array.xml
@@ -0,0 +1,135 @@
+<?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
+  -->
+
+<!-- Array resources for the Phone app. -->
+<resources>
+    <!-- "Target" resources for the GlowPadView widget used for incoming calls;
+         see InCallTouchUi.showIncomingCallWidget() and incall_touch_ui.xml.  -->
+
+    <!-- For audio calls, if respond via SMS is disabled:
+         - Answer (drag right)
+         - Decline (drag left) -->
+    <array name="incoming_call_widget_audio_without_sms_targets">
+        <item>@drawable/ic_lockscreen_answer</item>
+        <item>@null</item>
+        <item>@drawable/ic_lockscreen_decline</item>
+        <item>@null</item>"
+    </array>
+    <array name="incoming_call_widget_audio_without_sms_target_descriptions">
+        <item>@string/description_target_answer</item>
+        <item>@null</item>
+        <item>@string/description_target_decline</item>
+        <item>@null</item>"
+    </array>
+    <array name="incoming_call_widget_audio_without_sms_direction_descriptions">
+        <item>@string/description_direction_right</item>
+        <item>@null</item>
+        <item>@string/description_direction_left</item>
+        <item>@null</item>
+    </array>
+
+    <!-- For audio calls, if respond via SMS is enabled:
+         - Answer (drag right)
+         - Respond via SMS (drag up)
+         - Decline (drag left) -->
+    <array name="incoming_call_widget_audio_with_sms_targets">
+        <item>@drawable/ic_lockscreen_answer</item>
+        <item>@drawable/ic_lockscreen_text</item>
+        <item>@drawable/ic_lockscreen_decline</item>
+        <item>@null</item>"
+    </array>
+    <array name="incoming_call_widget_audio_with_sms_target_descriptions">
+        <item>@string/description_target_answer</item>
+        <item>@string/description_target_send_sms</item>
+        <item>@string/description_target_decline</item>
+        <item>@null</item>"
+    </array>
+    <array name="incoming_call_widget_audio_with_sms_direction_descriptions">
+        <item>@string/description_direction_right</item>
+        <item>@string/description_direction_up</item>
+        <item>@string/description_direction_left</item>
+        <item>@null</item>
+    </array>
+
+    <!-- For video calls, if respond via SMS is disabled:
+         - Answer as video call (drag right)
+         - Decline (drag left)
+         - Answer as audio call (drag down) -->
+    <array name="incoming_call_widget_video_without_sms_targets">
+        <item>@drawable/ic_lockscreen_answer</item>
+        <item>@null</item>
+        <item>@drawable/ic_lockscreen_decline</item>
+        <item>@drawable/ic_lockscreen_answer_video</item>
+    </array>
+    <array name="incoming_call_widget_video_without_sms_target_descriptions">
+        <item>@string/description_target_answer_audio_call</item>
+        <item>@null</item>
+        <item>@string/description_target_decline</item>
+        <item>@string/description_target_answer_video_call</item>
+    </array>
+    <array name="incoming_call_widget_video_without_sms_direction_descriptions">
+        <item>@string/description_direction_right</item>
+        <item>@null</item>
+        <item>@string/description_direction_left</item>
+        <item>@string/description_direction_down</item>
+    </array>
+
+    <!-- For video calls, if respond via SMS is enabled:
+         - Answer as audio call (drag right)
+         - Respond via SMS (drag up)
+         - Decline (drag left)
+         - Answer as video call (drag down) -->
+    <array name="incoming_call_widget_video_with_sms_targets">
+        <item>@drawable/ic_lockscreen_answer</item>
+        <item>@drawable/ic_lockscreen_text</item>
+        <item>@drawable/ic_lockscreen_decline</item>
+        <item>@drawable/ic_lockscreen_answer_video</item>
+    </array>
+    <array name="incoming_call_widget_video_with_sms_target_descriptions">
+        <item>@string/description_target_answer_audio_call</item>
+        <item>@string/description_target_send_sms</item>
+        <item>@string/description_target_decline</item>
+        <item>@string/description_target_answer_video_call</item>
+    </array>
+    <array name="incoming_call_widget_video_with_sms_direction_descriptions">
+        <item>@string/description_direction_right</item>
+        <item>@string/description_direction_up</item>
+        <item>@string/description_direction_left</item>
+        <item>@string/description_direction_down</item>
+    </array>
+
+    <!-- For accept/reject upgrade to video in active video call
+         - Accept upgrade to video request (drag right)
+         - Decline upgrade to video request (drag left)-->
+    <array name="incoming_call_widget_video_request_targets">
+        <item>@drawable/ic_lockscreen_answer_video</item>
+        <item>@drawable/ic_lockscreen_decline_video</item>
+    </array>
+
+    <array name="incoming_call_widget_video_request_target_descriptions">
+        <item>@string/description_target_accept_upgrade_to_video_request</item>
+        <item>@null</item>
+        <item>@string/description_target_decline_upgrade_to_video_request</item>
+        <item>@null</item>"
+    </array>
+    <array name="incoming_call_widget_video_request_target_direction_descriptions">
+        <item>@string/description_direction_right</item>
+        <item>@null</item>
+        <item>@string/description_direction_left</item>
+        <item>@null</item>
+    </array>
+</resources>
diff --git a/InCallUI/res/values/attrs.xml b/InCallUI/res/values/attrs.xml
new file mode 100644
index 0000000..e135fb7
--- /dev/null
+++ b/InCallUI/res/values/attrs.xml
@@ -0,0 +1,71 @@
+<?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
+  -->
+
+<resources>
+    <declare-styleable name="GlowPadView">
+        <attr name="android:gravity"/>
+
+        <!-- Reference to an array resource that be shown as targets around a circle. -->
+        <attr name="targetDrawables" format="reference"/>
+
+        <!-- Reference to an array resource that be used as description for the targets around the circle. -->
+        <attr name="targetDescriptions" format="reference"/>
+
+        <!-- Reference to an array resource that be used to announce the directions with targets around the circle. -->
+        <attr name="directionDescriptions" format="reference"/>
+
+        <!-- Sets a drawable as the center. -->
+        <attr name="handleDrawable" format="reference"/>
+
+        <!-- Drawable to use for wave ripple animation. -->
+        <attr name="outerRingDrawable" format="reference"/>
+
+        <!-- Drawble used for drawing points -->
+        <attr name="pointDrawable" format="reference"/>
+
+        <!-- Inner radius of glow area. -->
+        <attr name="innerRadius" format="dimension"/>
+
+        <!-- Outer radius of glow area. Target icons will be drawn on this circle. -->
+        <attr name="outerRadius" format="dimension"/>
+
+        <!-- Size of target radius. Points within this distance of target center is a "hit". -->
+        <!--
+        <attr name="hitRadius" format="dimension"/>
+        -->
+
+        <!-- Radius of glow under finger. -->
+        <attr name="glowRadius" format="dimension"/>
+
+        <!-- Tactile feedback duration for actions. Set to '0' for no vibration. -->
+        <attr name="vibrationDuration" format="integer"/>
+
+        <!-- How close we need to be before snapping to a target. -->
+        <attr name="snapMargin" format="dimension"/>
+
+        <!-- Number of waves/chevrons to show in animation. -->
+        <attr name="feedbackCount" format="integer"/>
+
+        <!-- Used when the handle shouldn't wait to be hit before following the finger -->
+        <attr name="alwaysTrackFinger" format="boolean"/>
+
+        <!-- Determine whether the glow pad is allowed to scale to fit the bounds indicated
+            by its parent. If this is set to false, no scaling will occur. If this is set to true
+            scaling will occur to fit for any axis in which gravity is set to center. -->
+        <attr name="allowScaling" format="boolean" />
+    </declare-styleable>
+</resources>
diff --git a/InCallUI/res/values/colors.xml b/InCallUI/res/values/colors.xml
new file mode 100644
index 0000000..60a017c
--- /dev/null
+++ b/InCallUI/res/values/colors.xml
@@ -0,0 +1,122 @@
+<?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
+  -->
+
+<resources>
+
+    <!-- In-call UI background color. -->
+    <color name="incall_background_color">@color/dialer_theme_color</color>
+    <color name="incall_accent_color">#ffffff</color>
+
+    <!-- Background color of main banner. -->
+    <color name="incall_call_banner_background_color">@color/incall_background_color</color>
+    <color name="incall_call_banner_text_color">#ffffff</color>
+    <!-- 80% opacity, white -->
+    <color name="incall_call_banner_subtext_color">#ccffffff</color>
+    <color name="incall_banner_secondary_background_color">#f5f5f5</color>
+    <color name="incall_banner_secondary_text_color">#333333</color>
+
+    <color name="incall_action_bar_background_color">@color/incall_background_color</color>
+    <color name="incall_action_bar_text_color">@color/incall_call_banner_text_color</color>
+
+    <color name="incall_photo_background_color">#545454</color>
+
+    <!-- Put on top of each photo, implying 80% darker than usual. -->
+    <color name="on_hold_dim_effect">#cc000000</color>
+
+    <color name="conference_call_manager_background_color">#f8f8f8</color>
+    <color name="conference_call_manager_caller_name_text_color">#4d4d4d</color>
+    <color name="conference_call_manager_icon_color">#999999</color>
+    <!-- Used with some smaller texts in manage conference screen. -->
+    <color name="conference_call_manager_secondary_text_color">#999999</color>
+    <color name="secondary_call_info_divider_highlight_color">#ffffff</color>
+
+    <color name="end_call_touch_feedback_tint">#dddddd</color>
+
+    <!-- Color of dialpad digits -->
+    <color name="dialpad_digits_text_color">#333</color>
+
+    <color name="incall_dialpad_background">#ffffff</color>
+    <color name="incall_dialpad_background_pressed">#ccaaaaaa</color>
+
+    <color name="button_background_color">@color/incall_background_color</color>
+    <color name="button_selected_color">@color/dialer_theme_color_dark</color>
+    <!-- 70% opacity, white. -->
+    <color name="button_default_color">#b3ffffff</color>
+    <!-- 20% opacity, white. -->
+    <color name="button_disabled_color">#33ffffff</color>
+
+    <!-- Background color of action bars -->
+    <color name="actionbar_background_color">@color/dialer_theme_color</color>
+    <!-- Background color for status bar. For portrait this will be ignored. -->
+    <color name="statusbar_background_color">@color/dialer_theme_color</color>
+
+    <color name="translucent_shadow">#33999999</color>
+
+    <!-- 70% opacity, black. -->
+    <color name="glowpad_background_color">#b3000000</color>
+    <!-- 15% opacity, white. -->
+    <color name="glowpad_outer_ring_color">#26ffffff</color>
+    <color name="glowpad_text_widget_ring_color">#ffffff</color>
+    <color name="glowpad_widget_active_color">#ffffff</color>
+    <color name="glowpad_text_widget_normal_tint">#cccccc</color>
+    <color name="glowpad_call_widget_normal_tint">#00c853</color>
+    <color name="glowpad_end_call_widget_normal_tint">#ff1744</color>
+    <color name="glowpad_incoming_widget_tint">#a3a3a3</color>
+    <color name="glowpad_incoming_widget_background_tint">#ffffff</color>
+
+    <!-- 70% opacity, white. -->
+    <color name="accessible_answer_hint_text_color">#B2FFFFFF</color>
+
+    <!-- 20% opacity, theme color. -->
+    <color name="incall_dialpad_touch_tint">#330288d1</color>
+
+    <!-- Background colors for InCallUI. This set of colors is a subset of
+        https://spec.googleplex.com/quantumpalette#extended which pass WCAG AA and all have a
+        contrast ratio over 5:1.
+
+        These colors are also used by InCallUIMaterialColorMapUtils to generate primary
+        activity colors.
+    -->
+    <array name="background_colors">
+        <item>#00796B</item>
+        <item>#3367D6</item>
+        <item>#303F9F</item>
+        <item>#7B1FA2</item>
+        <item>#C2185B</item>
+        <item>#C53929</item>
+    </array>
+
+    <!-- Darker versions of background_colors, two shades darker. These colors are used for the
+         status bar. -->
+    <array name="background_colors_dark">
+        <item>#00695C</item>
+        <item>#2A56C6</item>
+        <item>#283593</item>
+        <item>#6A1B9A</item>
+        <item>#AD1457</item>
+        <item>#B93221</item>
+    </array>
+
+    <!-- Ripple color used over light backgrounds. -->
+    <color name="ripple_light">#40000000</color>
+
+    <color name="contact_context_title_text_color">@color/incall_call_banner_subtext_color</color>
+    <color name="person_contact_context_message_text_color">@color/dialer_theme_color</color>
+    <color name="person_contact_context_message_background_color">@color/incall_call_banner_subtext_color</color>
+    <color name="person_contact_context_detail_text_color">@color/incall_call_banner_subtext_color</color>
+    <color name="business_contact_context_text_color">@color/incall_call_banner_subtext_color</color>
+</resources>
diff --git a/InCallUI/res/values/config.xml b/InCallUI/res/values/config.xml
new file mode 100644
index 0000000..b81ba3c
--- /dev/null
+++ b/InCallUI/res/values/config.xml
@@ -0,0 +1,27 @@
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+    <!-- Determines the maximum number of buttons visible on the call card.  Any buttons over this
+         count are put into the overflow menu. -->
+    <integer name="call_card_max_buttons">5</integer>
+
+    <!-- Determines video calls will automatically enter fullscreen mode after the start of the
+         call. -->
+    <bool name="video_call_auto_fullscreen">true</bool>
+    <!-- The number of milliseconds after which a video call will automatically enter fullscreen
+         mode (requires video_call_auto_fullscreen to be true). -->
+    <integer name="video_call_auto_fullscreen_timeout">5000</integer>
+</resources>
\ No newline at end of file
diff --git a/InCallUI/res/values/dimens.xml b/InCallUI/res/values/dimens.xml
new file mode 100644
index 0000000..d6c47a2
--- /dev/null
+++ b/InCallUI/res/values/dimens.xml
@@ -0,0 +1,147 @@
+<?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
+  -->
+
+<resources>
+    <!-- Whether or not the landscape mode layout is currently being used -->
+    <bool name="is_layout_landscape">false</bool>
+
+    <!-- Dimensions for CallCard elements (the normal in-call UI) -->
+
+    <dimen name="call_banner_height">0dp</dimen>
+    <dimen name="call_banner_vertical_margin">20dp</dimen>
+
+    <dimen name="incall_action_bar_elevation">3dp</dimen>
+
+    <!-- Margin between the bottom of the "call card" photo
+         and the top of the in-call button cluster. -->
+    <dimen name="in_call_touch_ui_upper_margin">2dp</dimen>
+
+    <!-- Padding at the left and right edges of the "call banner". -->
+    <dimen name="call_banner_side_padding">24dp</dimen>
+    <!-- Padding at the top and bottom edges of the "call banner". -->
+    <dimen name="call_banner_primary_call_container_top_padding">16dp</dimen>
+    <dimen name="secondary_call_info_horizontal_padding">24dp</dimen>
+    <dimen name="secondary_call_info_vertical_padding">32dp</dimen>
+    <dimen name="secondary_call_info_text_size">16sp</dimen>
+
+    <!-- Padding at the top and bottom edges of the "provider information" -->
+    <dimen name="provider_info_top_bottom_padding">8dp</dimen>
+
+    <!-- Text sizes for information in the call card.
+         Note: These are the default sizes for small (<600dp height) devices: larger screen sizes
+         apply the values in values-sw360dp/dimens.xml. -->
+    <dimen name="call_status_text_size">16sp</dimen>
+    <dimen name="call_status_text_min_size">12sp</dimen>
+    <dimen name="call_name_text_size">34dp</dimen>
+    <dimen name="call_name_text_min_size">28sp</dimen>
+    <dimen name="call_label_text_size">16sp</dimen>
+    <!-- Right padding for name and number fields in the call banner.
+         This padding is used to ensure that ultra-long names or
+         numbers won't overlap the elapsed time indication. -->
+    <dimen name="call_banner_name_number_right_padding">50sp</dimen>
+
+    <!-- Height and width of the in-call buttons. -->
+    <dimen name="in_call_button_dimension">48dp</dimen>
+
+    <dimen name="primary_call_elevation">5dp</dimen>
+    <dimen name="dialpad_elevation">2dp</dimen>
+
+    <!-- The InCallUI dialpad will sometimes want digits sizes that are different from dialer.
+         Note: These are the default sizes for small (<600dp height) devices: larger screen sizes
+         apply the values in values-h600dp/dimens.xml. -->
+    <dimen name="dialpad_key_number_margin_bottom">1dp</dimen>
+    <!-- Zero key should have less space between self and text because "+" is smaller -->
+    <dimen name="dialpad_zero_key_number_margin_bottom">0dp</dimen>
+    <dimen name="dialpad_digits_adjustable_text_size">20sp</dimen>
+    <dimen name="dialpad_digits_adjustable_height">50dp</dimen>
+    <dimen name="dialpad_key_numbers_size">36dp</dimen>
+
+    <dimen name="floating_action_button_vertical_offset">-10dp</dimen>
+
+    <dimen name="call_button_margin_vertical">8dp</dimen>
+    <dimen name="call_button_margin_horizontal">6dp</dimen>
+
+    <!-- Dimensions for OTA Call Card -->
+    <dimen name="otaactivate_layout_marginTop">10dp</dimen>
+    <dimen name="otalistenprogress_layout_marginTop">5dp</dimen>
+    <dimen name="otasuccessfail_layout_marginTop">10dp</dimen>
+
+    <!-- Dimension used to possibly down-scale high-res photo into what is suitable
+         for notification's large icon. -->
+    <dimen name="notification_icon_size">64dp</dimen>
+
+    <!-- Circle size for incoming call widget's each item. -->
+    <dimen name="incoming_call_widget_circle_size">56dp</dimen>
+
+    <!-- Size of alarm alert outer ring. -->
+    <dimen name="glowpadview_outerring_diameter">250dp</dimen>
+    <!-- Default target placement radius for GlowPadView. Should be 1/2 of outerring diameter. -->
+    <dimen name="glowpadview_target_placement_radius">125dp</dimen>
+
+    <!-- Default glow radius for GlowPadView -->
+    <dimen name="glowpadview_glow_radius">70dip</dimen>
+
+    <!-- Default distance beyond which GlowPadView snaps to the matching target -->
+    <dimen name="glowpadview_snap_margin">40dip</dimen>
+
+    <!-- Default distance from each snap target that GlowPadView considers a "hit" -->
+    <dimen name="glowpadview_inner_radius">15dip</dimen>
+
+    <dimen name="glowpadview_margin_bottom">-48dip</dimen>
+    <dimen name="glowpadview_margin_right">0dip</dimen>
+    <!-- Height of translucent shadow effect -->
+    <dimen name="translucent_shadow_height">2dp</dimen>
+
+    <dimen name="end_call_button_margin_bottom">2dp</dimen>
+
+    <dimen name="call_card_anim_translate_y_offset">50dp</dimen>
+
+    <!-- The smaller dimension of the video preview.  When in portrait orientation this is the
+         width of the preview.  When in landscape, this is the height. -->
+    <dimen name="video_preview_small_dimension">90dp</dimen>
+
+    <dimen name="video_preview_margin">20dp</dimen>
+
+    <dimen name="end_call_floating_action_button_diameter">72dp</dimen>
+    <dimen name="end_call_floating_action_button_small_diameter">56dp</dimen>
+
+    <dimen name="conference_call_manager_padding_top">64dp</dimen>
+    <dimen name="conference_call_manager_button_dimension">46dp</dimen>
+
+    <dimen name="contact_context_title_text_size">14sp</dimen>
+    <dimen name="contact_context_title_image_size">19dp</dimen>
+    <dimen name="contact_context_title_image_side_padding">23dp</dimen>
+    <dimen name="contact_context_title_margin_bottom">13dp</dimen>
+    <dimen name="contact_context_list_item_padding">13dp</dimen>
+
+    <dimen name="person_contact_context_horizontal_padding">30dp</dimen>
+    <dimen name="person_contact_context_message_text_size">16sp</dimen>
+    <dimen name="person_contact_context_message_vertical_padding">7dp</dimen>
+    <dimen name="person_contact_context_message_horizontal_padding">12dp</dimen>
+    <dimen name="person_contact_context_message_background_main_radius">15dp</dimen>
+    <dimen name="person_contact_context_message_background_accent_radius">2dp</dimen>
+    <dimen name="person_contact_context_detail_padding_top">7dp</dimen>
+    <dimen name="person_contact_context_detail_text_size">14sp</dimen>
+
+    <dimen name="business_contact_context_end_padding">10dp</dimen>
+    <dimen name="business_contact_context_image_size">25dp</dimen>
+    <dimen name="business_contact_context_image_padding">20dp</dimen>
+    <dimen name="business_contact_context_heading_font_size">16sp</dimen>
+    <dimen name="business_contact_context_detail_font_size">12sp</dimen>
+
+    <dimen name="contact_context_small_photo_size">40dp</dimen>
+</resources>
diff --git a/InCallUI/res/values/ids.xml b/InCallUI/res/values/ids.xml
new file mode 100644
index 0000000..accb8fb
--- /dev/null
+++ b/InCallUI/res/values/ids.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2008 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<resources>
+    <item type="id" name="fadeState" />
+    <item type="id" name="view_tag_callcard_actual_height" />
+</resources>
diff --git a/InCallUI/res/values/strings.xml b/InCallUI/res/values/strings.xml
new file mode 100644
index 0000000..df588d5
--- /dev/null
+++ b/InCallUI/res/values/strings.xml
@@ -0,0 +1,514 @@
+<?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
+  -->
+
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+
+    <!-- Official label of the phone app, as seen in "Manage Applications"
+         and other settings UIs. -->
+    <string name="phoneAppLabel" product="default">Phone</string>
+
+    <!-- Official label for the in-call UI. DO NOT TRANSLATE. -->
+    <string name="inCallLabel" translate="false">InCallUI</string>
+
+    <!-- Call status -->
+
+    <!-- In-call screen: status label for a call that's on hold -->
+    <string name="onHold">On hold</string>
+
+    <!-- Incoming call screen, name of "unknown" caller -->
+    <string name="unknown">Unknown</string>
+    <!-- Incoming call screen, string when number hidden -->
+    <string name="private_num">Private number</string>
+    <!-- Incoming call screen, string when called from a pay phone -->
+    <string name="payphone">Payphone</string>
+
+    <!-- In-call screen: status label for a conference call -->
+    <string name="confCall">Conference call</string>
+    <!-- In-call screen: call lost dialog text -->
+    <string name="call_lost">Call dropped</string>
+
+    <!-- MMI dialog strings -->
+    <!-- Dialog label when an MMI code starts running -->
+
+    <!-- "Audio mode" popup menu: Item label to select the speakerphone [CHAR LIMIT=25] -->
+    <string name="audio_mode_speaker">Speaker</string>
+    <!-- "Audio mode" popup menu: Item label to select the handset earpiece [CHAR LIMIT=25] -->
+    <string name="audio_mode_earpiece">Handset earpiece</string>
+    <!-- "Audio mode" popup menu: Item label to select the wired headset [CHAR LIMIT=25] -->
+    <string name="audio_mode_wired_headset">Wired headset</string>
+    <!-- "Audio mode" popup menu: Item label to select the bluetooth headset [CHAR LIMIT=25] -->
+    <string name="audio_mode_bluetooth">Bluetooth</string>
+
+    <!-- post dial -->
+    <!-- In-call screen: body text of the dialog that appears when we encounter
+         the "wait" character in a phone number to be dialed; this dialog asks the
+         user if it's OK to send the numbers following the "wait". -->
+    <string name="wait_prompt_str">Send the following tones?\n</string>
+    <!-- In-call screen: body text of the dialog that appears when we encounter
+         the "PAUSE" character in a phone number to be dialed; this dialog gives
+         informative message to the user to show the sending numbers following the "Pause". -->
+    <string name="pause_prompt_str">Sending tones\n</string>
+    <!-- In-call screen: button label on the "wait" prompt dialog -->
+    <string name="send_button">Send</string>
+    <!-- In-call screen: button label on the "wait" prompt dialog in CDMA Mode-->
+    <string name="pause_prompt_yes">Yes</string>
+    <!-- In-call screen: button label on the "wait" prompt dialog in CDMA Mode-->
+    <string name="pause_prompt_no">No</string>
+    <!-- In-call screen: on the "wild" character dialog, this is the label
+         for a text widget that lets the user enter the digits that should
+         replace the "wild" character. -->
+    <string name="wild_prompt_str">Replace wild character with</string>
+
+    <!-- In-call screen: status label for a conference call -->
+    <string name="caller_manage_header">Conference call <xliff:g id="conf_call_time">%s</xliff:g></string>
+
+    <!-- Used in FakePhoneActivity test code.  DO NOT TRANSLATE. -->
+    <string name="fake_phone_activity_phoneNumber_text" translatable="false">(650) 555-1234</string>
+    <!-- Used in FakePhoneActivity test code.  DO NOT TRANSLATE. -->
+    <string name="fake_phone_activity_infoText_text" translatable="false">Incoming phone number</string>
+    <!-- Used in FakePhoneActivity test code.  DO NOT TRANSLATE. -->
+    <string name="fake_phone_activity_placeCall_text" translatable="false">Fake Incoming Call</string>
+
+    <!-- Call settings screen, Set voicemail dialog title -->
+    <string name="voicemail_settings_number_label">Voicemail number</string>
+
+    <!-- Card titles -->
+    <!-- In-call screen: status label for a call in the "dialing" state [CHAR LIMIT=25] -->
+    <string name="card_title_dialing">Dialing</string>
+    <!-- In-call screen: status label for a re-dialing call [CHAR LIMIT=25] -->
+    <string name="card_title_redialing">Redialing</string>
+    <!-- In-call screen: status label for a conference call [CHAR LIMIT=25] -->
+    <string name="card_title_conf_call">Conference call</string>
+    <!-- In-call screen: status label for an incoming call [CHAR LIMIT=25] -->
+    <string name="card_title_incoming_call">Incoming call</string>
+    <!-- In-call screen: status label for an incoming work call [CHAR LIMIT=25] -->
+    <string name="card_title_incoming_work_call">Incoming work call</string>
+    <!-- In-call screen: status label displayed briefly after a call ends [CHAR LIMIT=25] -->
+    <string name="card_title_call_ended">Call ended</string>
+    <!-- In-call screen: status label for call that's on hold [CHAR LIMIT=25] -->
+    <string name="card_title_on_hold">On hold</string>
+    <!-- In-call screen: status label for a call that's in the process of hanging up [CHAR LIMIT=25] -->
+    <string name="card_title_hanging_up">Hanging up</string>
+    <!-- In-call screen: status label for a call that's in CDMA flash mode [CHAR LIMIT=25] -->
+    <string name="card_title_in_call">In call</string>
+    <!-- In-call screen: special status label that shows your own phone
+         number during emergency callback mode (ECM) [CHAR LIMIT=30] -->
+    <string name="card_title_my_phone_number">My number is <xliff:g id="my_phone_number">%s</xliff:g></string>
+    <!-- In-call screen: status label when connecting video. -->
+    <string name="card_title_video_call_connecting">Connecting video</string>
+    <!-- In-call screen: status label when in a video call. -->
+    <string name="card_title_video_call">Video call</string>
+    <!-- In-call screen: status label when requesting video. -->
+    <string name="card_title_video_call_requesting">Requesting video</string>
+    <!-- In-call screen: status label when there is a problem connecting a video call. -->
+    <string name="card_title_video_call_error">Can\'t connect video call</string>
+    <!-- In-call screen: status label when the remote party rejects a video call request. -->
+    <string name="card_title_video_call_rejected">Video request rejected</string>
+
+    <!-- In-call screen: string shown to the user when their outgoing number is different than the
+         number reported by TelephonyManager#getLine1Number() -->
+    <string name="card_title_callback_number">Your callback number\n
+        <xliff:g id="dark_number">%1$s</xliff:g>
+    </string>
+
+    <!-- In-call screen: string shown to the user when their outgoing number is different than the
+         number reported by TelephonyManager#getLine1Number() and they're calling emergency
+         services. -->
+    <string name="card_title_callback_number_emergency">Your emergency callback number\n
+        <xliff:g id="dark_number">%1$s</xliff:g>
+    </string>
+
+    <!-- Notification strings -->
+    <!-- The "label" of the in-call Notification for a dialing call, used
+         as the format string for a Chronometer widget. [CHAR LIMIT=60] -->
+    <string name="notification_dialing">Dialing</string>
+    <!-- Missed call notification label, used when there's exactly one missed call -->
+    <string name="notification_missedCallTitle">Missed call</string>
+    <!-- Missed call notification label, used when there are two or more missed calls -->
+    <string name="notification_missedCallsTitle">Missed calls</string>
+    <!-- Missed call notification message used when there are multiple missed calls -->
+    <string name="notification_missedCallsMsg"><xliff:g id="num_missed_calls">%s</xliff:g> missed calls</string>
+    <!-- Missed call notification message used for a single missed call, including
+         the caller-id info from the missed call -->
+    <string name="notification_missedCallTicker">Missed call from <xliff:g id="missed_call_from">%s</xliff:g></string>
+    <!-- The "label" of the in-call Notification for an ongoing call. [CHAR LIMIT=60] -->
+    <string name="notification_ongoing_call">Ongoing call</string>
+    <!-- The "label" of the in-call Notification for an ongoing work call. [CHAR LIMIT=60] -->
+    <string name="notification_ongoing_work_call">Ongoing work call</string>
+    <!-- The "label" of the in-call Notification for an ongoing call, which is being made over
+         Wi-Fi. [CHAR LIMIT=60] -->
+    <string name="notification_ongoing_call_wifi">Ongoing Wi-Fi call</string>
+    <!-- The "label" of the in-call Notification for an ongoing work call, which is being made
+         over Wi-Fi. [CHAR LIMIT=60] -->
+    <string name="notification_ongoing_work_call_wifi">Ongoing Wi-Fi work call</string>
+    <!-- The "label" of the in-call Notification for a call that's on hold -->
+    <string name="notification_on_hold">On hold</string>
+    <!-- The "label" of the in-call Notification for an incoming ringing call. [CHAR LIMIT=60] -->
+    <string name="notification_incoming_call">Incoming call</string>
+    <!-- The "label" of the in-call Notification for an incoming ringing call. [CHAR LIMIT=60] -->
+    <string name="notification_incoming_work_call">Incoming work call</string>
+    <!-- The "label" of the in-call Notification for an incoming ringing call,
+         which is being made over Wi-Fi. [CHAR LIMIT=60] -->
+    <string name="notification_incoming_call_wifi">Incoming Wi-Fi call</string>
+    <!-- The "label" of the in-call Notification for an incoming ringing work call,
+         which is being made over Wi-Fi. [CHAR LIMIT=60] -->
+    <string name="notification_incoming_work_call_wifi">Incoming Wi-Fi work call</string>
+    <!-- The "label" of the in-call Notification for an incoming ringing video call. -->
+    <string name="notification_incoming_video_call">Incoming video call</string>
+    <!-- The "label" of the in-call Notification for upgrading an existing call to a video call. -->
+    <string name="notification_requesting_video_call">Incoming video request</string>
+    <!-- Label for the "Voicemail" notification item, when expanded. -->
+    <string name="notification_voicemail_title">New voicemail</string>
+    <!-- Label for the expanded "Voicemail" notification item,
+         including a count of messages. -->
+    <string name="notification_voicemail_title_count">New voicemail (<xliff:g id="count">%d</xliff:g>)</string>
+    <!-- Message displayed in the "Voicemail" notification item, allowing the user
+         to dial the indicated number. -->
+    <string name="notification_voicemail_text_format">Dial <xliff:g id="voicemail_number">%s</xliff:g></string>
+    <!-- Message displayed in the "Voicemail" notification item,
+         indicating that there's no voicemail number available -->
+    <string name="notification_voicemail_no_vm_number">Voicemail number unknown</string>
+    <!-- Label for the "No service" notification item, when expanded. -->
+    <string name="notification_network_selection_title">No service</string>
+    <!-- Label for the expanded "No service" notification item, including the
+         operator name set by user -->
+    <string name="notification_network_selection_text">Selected network (<xliff:g id="operator_name">%s</xliff:g>) unavailable</string>
+    <!-- Label for the "Answer call" action. This is the displayed label for the action that answers
+         an incoming call. [CHAR LIMIT=12] -->
+    <string name="notification_action_answer">Answer</string>
+    <!-- Label for "end call" Action.
+         It is displayed in the "Ongoing call" notification, which is shown
+         when the user is outside the in-call screen while the phone call is still
+         active. [CHAR LIMIT=12] -->
+    <string name="notification_action_end_call">Hang up</string>
+    <!-- Label for "Video Call" notification action. This is a displayed on the notification for an
+         incoming video call, and answers the call as a video call. [CHAR LIMIT=12] -->
+    <string name="notification_action_answer_video">Video</string>
+    <!-- Label for "Voice" notification action. This is a displayed on the notification for an
+         incoming video call, and answers the call as an audio call. [CHAR LIMIT=12] -->
+    <string name="notification_action_answer_voice">Voice</string>
+    <!-- Label for "Accept" notification action. This is somewhat generic, and may refer to
+         scenarios such as accepting an incoming call or accepting a video call request.
+         [CHAR LIMIT=12] -->
+    <string name="notification_action_accept">Accept</string>
+    <!-- Label for "Dismiss" notification action. This is somewhat generic, and may refer to
+         scenarios such as declining an incoming call or declining a video call request.
+         [CHAR LIMIT=12] -->
+    <string name="notification_action_dismiss">Dismiss</string>
+
+    <!-- Message for "call back" Action, which is displayed in the missed call notification.
+         The user will be able to call back to the person or the phone number.
+         [CHAR LIMIT=12] -->
+    <string name="notification_missedCall_call_back">Call back</string>
+    <!-- Message for "reply via sms" action, which is displayed in the missed call notification.
+         The user will be able to send text messages using the phone number.
+         [CHAR LIMIT=12] -->
+    <string name="notification_missedCall_message">Message</string>
+
+    <!-- In-call screen: call failure message displayed in an error dialog -->
+    <string name="incall_error_power_off">To place a call, first turn off Airplane mode.</string>
+    <!-- In-call screen: call failure message displayed in an error dialog.
+         This string is currently unused (see comments in InCallActivity.java.) -->
+    <string name="incall_error_emergency_only">Not registered on network.</string>
+    <!-- In-call screen: call failure message displayed in an error dialog -->
+    <string name="incall_error_out_of_service">Cellular network not available.</string>
+    <!-- In-call screen: call failure message displayed in an error dialog -->
+    <string name="incall_error_no_phone_number_supplied">To place a call, enter a valid number.</string>
+    <!-- In-call screen: call failure message displayed in an error dialog -->
+    <string name="incall_error_call_failed">Can\'t call.</string>
+    <!-- In-call screen: status message displayed in a dialog when starting an MMI -->
+    <string name="incall_status_dialed_mmi">Starting MMI sequence\u2026</string>
+    <!-- In-call screen: message displayed in an error dialog -->
+    <string name="incall_error_supp_service_unknown">Service not supported.</string>
+    <!-- In-call screen: message displayed in an error dialog -->
+    <string name="incall_error_supp_service_switch">Can\'t switch calls.</string>
+    <!-- In-call screen: message displayed in an error dialog -->
+    <string name="incall_error_supp_service_separate">Can\'t separate call.</string>
+    <!-- In-call screen: message displayed in an error dialog -->
+    <string name="incall_error_supp_service_transfer">Can\'t transfer.</string>
+    <!-- In-call screen: message displayed in an error dialog -->
+    <string name="incall_error_supp_service_conference">Can\'t conference.</string>
+    <!-- In-call screen: message displayed in an error dialog -->
+    <string name="incall_error_supp_service_reject">Can\'t reject call.</string>
+    <!-- In-call screen: message displayed in an error dialog -->
+    <string name="incall_error_supp_service_hangup">Can\'t release call(s).</string>
+
+    <!-- In-call screen: "call type" indication for a SIP call [CHAR LIMIT=30]  -->
+    <string name="incall_call_type_label_sip">SIP call</string>
+
+    <!-- Dialog title for the "radio enable" UI for emergency calls -->
+    <string name="emergency_enable_radio_dialog_title">Emergency call</string>
+    <!-- Status message for the "radio enable" UI for emergency calls -->
+    <string name="emergency_enable_radio_dialog_message">Turning on radio\u2026</string>
+    <!-- Status message for the "radio enable" UI for emergency calls -->
+    <string name="emergency_enable_radio_dialog_retry">No service. Trying again\u2026</string>
+
+    <!-- Dialer text on Emergency Dialer -->
+    <!-- Emergency dialer: message displayed in an error dialog -->
+    <string name="dial_emergency_error">Can\'t call. <xliff:g id="non_emergency_number">%s</xliff:g> is not an emergency number.</string>
+    <!-- Emergency dialer: message displayed in an error dialog -->
+    <string name="dial_emergency_empty_error">Can\'t call. Dial an emergency number.</string>
+
+    <!-- Displayed in the text entry box in the dialer when in landscape mode to guide the user
+         to dial using the physical keyboard -->
+    <string name="dialerKeyboardHintText">Use keyboard to dial</string>
+
+    <!-- Text for the onscreen "Hold" button when it is not selected. Pressing it will put
+         the call on hold. -->
+    <string name="onscreenHoldText_unselected">Hold Call</string>
+    <!-- Text for the onscreen "Hold" button when it is selected. Pressing it will resume
+         the call from a previously held state. -->
+    <string name="onscreenHoldText_selected">Resume Call</string>
+    <!-- Text for the onscreen "End call" button -->
+    <string name="onscreenEndCallText">End Call</string>
+    <!-- Text for the onscreen "Show Dialpad" button -->
+    <string name="onscreenShowDialpadText">Dialpad</string>
+    <!-- Text for the onscreen "Mute" button -->
+    <string name="onscreenMuteText">Mute</string>
+    <!-- Text for the onscreen "Add call" button -->
+    <string name="onscreenAddCallText">Add call</string>
+    <!-- Text for the onscreen "Merge calls" button -->
+    <string name="onscreenMergeCallsText">Merge calls</string>
+    <!-- Text for the onscreen "Swap calls" button -->
+    <string name="onscreenSwapCallsText">Swap</string>
+    <!-- Text for the onscreen "Manage calls" button -->
+    <string name="onscreenManageCallsText">Manage calls</string>
+    <!-- Text for the onscreen "Manage conference" button [CHAR LIMIT=30] -->
+    <string name="onscreenManageConferenceText">Manage conference call</string>
+    <!-- Text for the onscreen "Audio" button that lets you switch
+         between speaker / bluetooth / earpiece [CHAR LIMIT=10] -->
+    <string name="onscreenAudioText">Audio</string>
+    <!-- Text for the onscreen "Video call" button used to change a voice call
+         to a video call. [CHAR LIMIT=10] -->
+    <string name="onscreenVideoCallText">Video call</string>
+    <!-- Text for the onscreen "Change to voice" button. When clicked, this downgrades a video call
+         to a voice call. -->
+    <string name="onscreenChangeToVoiceText">Change to voice call</string>
+    <!-- Text for the onscreen "Switch camera" button. When clicked, this switches the user's camera
+         for video calling between the front-facing camera and the back-facing camera. -->
+    <string name="onscreenSwitchCameraText">Switch camera</string>
+    <!-- Text for the onscreen "Pause video" button. -->
+    <string name="onscreenPauseVideoText">Pause video</string>
+    <!-- Text for the onscreen overflow button, to see additional actions which can be done. -->
+    <string name="onscreenOverflowText">More options</string>
+
+    <!-- Message indicating that Video Started flowing for IMS-VT calls -->
+    <string name="player_started">Player Started</string>
+    <!-- Message indicating that Video Stopped flowing for IMS-VT calls -->
+    <string name="player_stopped">Player Stopped</string>
+    <!-- Message indicating that camera failure has occurred for the selected camera and
+         as result camera is not ready -->
+    <string name="camera_not_ready">Camera not ready</string>
+    <!-- Message indicating that camera is ready/available -->
+    <string name="camera_ready">Camera ready</string>
+    <!-- Message indicating unknown call session event -->
+    <string name="unknown_call_session_event">"Unkown call session event"</string>
+
+    <!-- For incoming calls, this is a string we can get from a CDMA network instead of
+         the actual phone number, to indicate there's no number present.  DO NOT TRANSLATE. -->
+    <string-array name="absent_num" translatable="false">
+        <item>ABSENT NUMBER</item>
+        <item>ABSENTNUMBER</item>
+    </string-array>
+
+    <!-- Preference for Voicemail service provider under "Voicemail" settings.
+         [CHAR LIMIT=40] -->
+    <string name="voicemail_provider">Service</string>
+
+    <!-- Preference for Voicemail setting of each provider.
+         [CHAR LIMIT=40] -->
+    <string name="voicemail_settings">Setup</string>
+
+    <!-- String to display in voicemail number summary when no voicemail num is set -->
+    <string name="voicemail_number_not_set">&lt;Not set&gt;</string>
+
+    <!-- Title displayed above settings coming after voicemail in the call features screen -->
+    <string name="other_settings">Other call settings</string>
+
+    <!-- Title displayed in the overlay for outgoing calls which include the name of the provider.
+         [CHAR LIMIT=40] -->
+    <string name="calling_via_template">Calling via <xliff:g id="provider_name">%s</xliff:g></string>
+    <!-- Title displayed in the overlay for incoming calls which include the name of the provider.
+         [CHAR LIMIT=40] -->
+    <string name="incoming_via_template">Incoming via <xliff:g id="provider_name">%s</xliff:g></string>
+
+    <!-- Use this as a default to describe the contact photo; currently for screen readers through accessibility. -->
+    <string name="contactPhoto">contact photo</string>
+    <!-- Use this to describe the separate conference call button; currently for screen readers through accessibility. -->
+    <string name="goPrivate">go private</string>
+    <!--  Use this to describe the select contact button in EditPhoneNumberPreference; currently for screen readers through accessibility. -->
+    <string name="selectContact">select contact</string>
+
+    <!-- "Respond via SMS" option that lets you compose a custom response. [CHAR LIMIT=30] -->
+    <string name="respond_via_sms_custom_message">Write your own...</string>
+    <!-- "Custom Message" Cancel alert dialog button -->
+    <string name="custom_message_cancel">Cancel</string>
+    <!-- "Custom Message" Send alert dialog button -->
+    <string name="custom_message_send">Send</string>
+
+    <!-- Description of the answer target in the Slide unlock screen of Phone. [CHAR LIMIT=NONE] -->
+    <string name="description_target_answer">Answer</string>
+    <!-- Description of the send_sms target in the Slide unlock screen of Phone. [CHAR LIMIT=NONE] -->
+    <string name="description_target_send_sms">Send SMS</string>
+    <!-- Description of the decline target in the Slide unlock screen. [CHAR LIMIT=NONE] -->
+    <string name="description_target_decline">Decline</string>
+    <!-- Description of the target to answer a call as a video call in the Slide unlock screen.
+         [CHAR LIMIT=NONE] -->
+    <string name="description_target_answer_video_call">Answer as video call</string>
+    <!-- Description of the target to answer a call as an audio call in the Slide unlock screen.
+         [CHAR LIMIT=NONE] -->
+    <string name="description_target_answer_audio_call">Answer as audio call</string>
+    <!-- Description of the target to accept a request to upgrade from an audio call to a video call.
+         [CHAR LIMIT=NONE] -->
+    <string name="description_target_accept_upgrade_to_video_request">Accept video request</string>
+    <!-- Description of the target to decline a request to upgrade from an audio call to a video call.
+         [CHAR LIMIT=NONE] -->
+    <string name="description_target_decline_upgrade_to_video_request">Decline video request</string>
+    <!-- Description of the target to accept a request to upgrade from any call to a video transmit call.
+         [CHAR LIMIT=NONE] -->
+    <string name="description_target_accept_upgrade_to_video_transmit_request">Accept video transmit request</string>
+    <!-- Description of the target to decline a request to upgrade from any call to a video transmit call.
+         [CHAR LIMIT=NONE] -->
+    <string name="description_target_decline_upgrade_to_video_transmit_request">Decline video transmit request</string>
+        <!-- Description of the target to accept a request to upgrade from any call to a video receive call.
+         [CHAR LIMIT=NONE] -->
+    <string name="description_target_accept_upgrade_to_video_receive_request">Accept video receive request</string>
+    <!-- Description of the target to decline a request to upgrade from any call to a video receive call.
+         [CHAR LIMIT=NONE] -->
+    <string name="description_target_decline_upgrade_to_video_receive_request">Decline video receive request</string>
+
+    <!-- Description of the up direction in which one can to slide the handle in the phone answer screen. [CHAR LIMIT=NONE] -->
+    <string name="description_direction_up">Slide up for <xliff:g id="target_description" example="Unlock">%s</xliff:g>.</string>
+    <!-- Description of the left direction in which one can to slide the handle in the phone answer screen. [CHAR LIMIT=NONE] -->
+    <string name="description_direction_left">"Slide left for <xliff:g id="target_description" example="Unlock">%s</xliff:g>.</string>
+    <!-- Description of the right direction in which one can to slide the handle in the phone answer screen. [CHAR LIMIT=NONE] -->
+    <string name="description_direction_right">Slide right for <xliff:g id="target_description" example="Unlock">%s</xliff:g>.</string>
+    <!-- Description of the down direction in which one can to slide the handle in the phone answer screen. [CHAR LIMIT=NONE] -->
+    <string name="description_direction_down">Slide down for <xliff:g id="target_description" example="Unlock">%s</xliff:g>.</string>
+
+    <!-- Dialog title for the vibration settings for voicemail notifications [CHAR LIMIT=40] -->
+    <string name="voicemail_notification_vibrate_when_title" msgid="8731372580674292759">Vibrate</string>
+    <!-- Dialog title for the vibration settings for voice mail notifications [CHAR LIMIT=40]-->
+    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="8995274609647451109">Vibrate</string>
+
+    <!-- Voicemail ringtone title. The user clicks on this preference to select
+         which sound to play when a voicemail notification is received.
+         [CHAR LIMIT=30] -->
+    <string name="voicemail_notification_ringtone_title">Sound</string>
+
+    <!--  The string used to describe a notification if it is the default one in the system. For
+          example, if the user selects the default notification, it will appear as something like
+          Default sound(Capella) in the notification summary.
+          [CHAR LIMIT=40] -->
+    <string name="default_notification_description">Default sound (<xliff:g id="default_sound_title">%1$s</xliff:g>)</string>
+
+    <!-- The default value value for voicemail notification. -->
+    <string name="voicemail_notification_vibrate_when_default" translatable="false">never</string>
+
+    <!-- Actual values used in our code for voicemail notifications. DO NOT TRANSLATE -->
+    <string-array name="voicemail_notification_vibrate_when_values" translatable="false">
+        <item>always</item>
+        <item>silent</item>
+        <item>never</item>
+    </string-array>
+
+    <!-- Setting option name to pick ringtone (a list dialog comes up). [CHAR LIMIT=30] -->
+    <string name="ringtone_title" msgid="5379026328015343686">Phone ringtone</string>
+
+    <!-- Setting option name to enable or disable vibration when ringing
+         the phone.
+         [CHAR LIMIT=30] -->
+    <string name="vibrate_on_ring_title">Vibrate when ringing</string>
+
+    <!-- Title for the category "ringtone", which is shown above ringtone and vibration
+         related settings.
+         [CHAR LIMIT=30] -->
+    <string name="preference_category_ringtone">Ringtone &amp; Vibrate</string>
+
+    <!-- Label for "Manage conference call" panel [CHAR LIMIT=40] -->
+    <string name="manageConferenceLabel">Manage conference call</string>
+
+    <!-- This can be used in any application wanting to disable the text "Emergency number" -->
+    <string name="emergency_call_dialog_number_for_display">Emergency number</string>
+
+    <!-- Phrase describing a time duration using seconds [CHAR LIMIT=16] -->
+    <plurals name="duration_seconds">
+        <item quantity="one">1 second</item>
+        <item quantity="other"><xliff:g id="count">%d</xliff:g> seconds</item>
+    </plurals>
+    <!-- Phrase describing a time duration using minutes [CHAR LIMIT=16] -->
+    <plurals name="duration_minutes">
+        <item quantity="one">1 minute</item>
+        <item quantity="other"><xliff:g id="count">%d</xliff:g> minutes</item>
+    </plurals>
+    <!-- Phrase describing a time duration using hours [CHAR LIMIT=16] -->
+    <plurals name="duration_hours">
+        <item quantity="one">1 hour</item>
+        <item quantity="other"><xliff:g id="count">%d</xliff:g> hours</item>
+    </plurals>
+
+    <!-- Description of the profile photo shown when the device's camera is disabled udring a video
+        call. [CHAR LIMIT=NONE] -->
+    <string name="profile_photo_description">Profile photo</string>
+
+    <!-- Description of the "camera off" icon displayed when the device's camera is disabled during
+         a video call. [CHAR LIMIT=NONE] -->
+    <string name="camera_off_description">Camera off</string>
+
+    <!-- Used to inform the user that a call was received via a number other than the primary
+        phone number associated with their device. [CHAR LIMIT=16] -->
+    <string name="child_number">via <xliff:g id="child_number" example="650-555-1212">%s</xliff:g></string>
+
+    <!-- Used to inform the user that the note associated with an outgoing call has been sent.
+         [CHAR LIMIT=32] -->
+    <string name="note_sent">Note sent</string>
+
+    <!-- Title for the call context with a person-type contact. [CHAR LIMIT=40] -->
+    <string name="person_contact_context_title">Recent messages</string>
+
+    <!-- Title for the call context with a business-type contact. [CHAR LIMIT=40] -->
+    <string name="business_contact_context_title">Business info</string>
+
+    <!-- Distance strings for business caller ID context. -->
+
+    <!-- Used to inform the user how far away a location is in miles. [CHAR LIMIT=NONE] -->
+    <string name="distance_imperial_away"><xliff:g id="distance">%.1f</xliff:g> mi away</string>
+    <!-- Used to inform the user how far away a location is in kilometers. [CHAR LIMIT=NONE] -->
+    <string name="distance_metric_away"><xliff:g id="distance">%.1f</xliff:g> km away</string>
+    <!-- A shortened way to display a business address. Formatted [street address], [city/locality]. -->
+    <string name="display_address"><xliff:g id="street_address">%1$s</xliff:g>, <xliff:g id="locality">%2$s</xliff:g></string>
+    <!-- Used to indicate hours of operation for a location as a time span. e.g. "11 am - 9 pm" [CHAR LIMIT=NONE] -->
+    <string name="open_time_span"><xliff:g id="open_time">%1$s</xliff:g> - <xliff:g id="close_time">%2$s</xliff:g></string>
+    <!-- Used to indicate a series of opening hours for a location.
+         This first argument may be one or more time spans. e.g. "11 am - 9 pm, 9 pm - 11 pm"
+         The second argument is an additional time span. e.g. "11 pm - 1 am"
+         The string is used to build a list of opening hours.
+         [CHAR LIMIT=NONE] -->
+    <string name="opening_hours"><xliff:g id="earlier_times">%1$s</xliff:g>, <xliff:g id="later_time">%2$s</xliff:g></string>
+    <!-- Used to express when a location will open the next day. [CHAR LIMIT=NONE] -->
+    <string name="opens_tomorrow_at">Opens tomorrow at <xliff:g id="open_time">%s</xliff:g></string>
+    <!-- Used to express the next time at which a location will be open today. [CHAR LIMIT=NONE] -->
+    <string name="opens_today_at">Opens today at <xliff:g id="open_time">%s</xliff:g></string>
+    <!-- Used to express the next time at which a location will close today. [CHAR LIMIT=NONE] -->
+    <string name="closes_today_at">Closes at <xliff:g id="close_time">%s</xliff:g></string>
+    <!-- Used to express the next time at which a location closed today if it is already closed. [CHAR LIMIT=NONE] -->
+    <string name="closed_today_at">Closed today at <xliff:g id="close_time">%s</xliff:g></string>
+    <!-- Displayed when a place is open. -->
+    <string name="open_now">Open now</string>
+    <!-- Displayed when a place is closed. -->
+    <string name="closed_now">Closed now</string>
+</resources>
diff --git a/InCallUI/res/values/styles.xml b/InCallUI/res/values/styles.xml
new file mode 100644
index 0000000..11d6362
--- /dev/null
+++ b/InCallUI/res/values/styles.xml
@@ -0,0 +1,100 @@
+<?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
+  -->
+
+<resources>
+    <drawable name="grayBg">#FF333333</drawable>
+
+    <style name="info_label">
+        <item name="android:layout_height">wrap_content</item>
+        <item name="android:layout_width">wrap_content</item>
+        <item name="android:textAppearance">@style/TextAppearance.info_label</item>
+        <item name="android:paddingEnd">4dip</item>
+    </style>
+
+    <style name="info_layout">
+        <item name="android:orientation">vertical</item>
+        <item name="android:paddingStart">10dip</item>
+        <item name="android:paddingTop">10dip</item>
+        <item name="android:paddingEnd">10dip</item>
+        <item name="android:paddingBottom">10dip</item>
+        <item name="android:layout_width">match_parent</item>
+        <item name="android:layout_height">match_parent</item>
+    </style>
+
+    <style name="entry_layout">
+        <item name="android:orientation">vertical</item>
+        <item name="android:layout_width">wrap_content</item>
+        <item name="android:layout_height">wrap_content</item>
+    </style>
+
+    <style name="TextAppearance" parent="android:TextAppearance">
+    </style>
+
+    <style name="TextAppearance.info_label">
+        <item name="android:textSize">14sp</item>
+        <item name="android:textStyle">bold</item>
+    </style>
+
+
+    <!-- Buttons in the main "button row" of the in-call onscreen touch UI. -->
+    <style name="InCallButton">
+        <item name="android:layout_width">@dimen/in_call_button_dimension</item>
+        <item name="android:layout_height">@dimen/in_call_button_dimension</item>
+        <item name="android:layout_marginBottom">@dimen/call_button_margin_vertical</item>
+        <item name="android:layout_marginLeft">@dimen/call_button_margin_horizontal</item>
+        <item name="android:layout_marginRight">@dimen/call_button_margin_horizontal</item>
+        <item name="android:background">?android:attr/selectableItemBackground</item>
+    </style>
+
+    <!-- "Compound button" variation of InCallButton.
+         These buttons have the concept of two states: checked and unchecked. This style is just
+         like "InCallButton" except that we also clear out android:background, android:textOn,
+         android:textOff, to avoid the default behavior of the ToggleButton class. -->
+    <style name="InCallCompoundButton" parent="InCallButton">
+        <item name="android:background">@null</item>
+        <item name="android:textOn">@null</item>
+        <item name="android:textOff">@null</item>
+    </style>
+
+    <!-- Theme for the InCallActivity activity. Should have a transparent background for the
+         circular reveal animation for a new outgoing call to work correctly. We don't just use
+         Theme.Black.NoTitleBar directly, since we want any popups or dialogs from the
+         InCallActivity to have the correct Material style. -->
+    <style name="Theme.InCallScreen" parent="@android:style/Theme.Material.Light">
+        <item name="android:windowAnimationStyle">@null</item>
+        <item name="android:windowIsTranslucent">true</item>
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowContentOverlay">@null</item>
+        <item name="dialpad_key_button_touch_tint">@color/incall_dialpad_touch_tint</item>
+        <item name="android:textColorPrimary">@color/incall_call_banner_text_color</item>
+        <item name="android:colorPrimaryDark">@color/dialer_theme_color_dark</item>
+        <item name="android:popupMenuStyle">@style/InCallPopupMenuStyle</item>
+        <item name="android:actionBarStyle">@style/InCallActionBarStyle</item>
+        <item name="android:buttonStyleToggle">@style/InCallCompoundButton</item>
+        <item name="android:alertDialogTheme">@android:style/Theme.Material.Light.Dialog.Alert</item>
+    </style>
+
+    <style name="InCallPopupMenuStyle" parent="@android:style/Theme.Material.Light">
+        <item name="android:textColorPrimary">@color/popup_menu_color</item>
+    </style>
+
+    <style name="InCallActionBarStyle" parent="@android:style/Widget.Material.Light.ActionBar">
+        <item name="android:background">@color/incall_action_bar_background_color</item>
+        <item name="android:textColor">@color/incall_action_bar_text_color</item>
+    </style>
+
+</resources>
diff --git a/InCallUI/src/com/android/incallui/AccelerometerListener.java b/InCallUI/src/com/android/incallui/AccelerometerListener.java
new file mode 100644
index 0000000..b5ad296
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/AccelerometerListener.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.os.Handler;
+import android.os.Message;
+import android.util.Log;
+
+/**
+ * This class is used to listen to the accelerometer to monitor the
+ * orientation of the phone. The client of this class is notified when
+ * the orientation changes between horizontal and vertical.
+ */
+public class AccelerometerListener {
+    private static final String TAG = "AccelerometerListener";
+    private static final boolean DEBUG = true;
+    private static final boolean VDEBUG = false;
+
+    private SensorManager mSensorManager;
+    private Sensor mSensor;
+
+    // mOrientation is the orientation value most recently reported to the client.
+    private int mOrientation;
+
+    // mPendingOrientation is the latest orientation computed based on the sensor value.
+    // This is sent to the client after a rebounce delay, at which point it is copied to
+    // mOrientation.
+    private int mPendingOrientation;
+
+    private OrientationListener mListener;
+
+    // Device orientation
+    public static final int ORIENTATION_UNKNOWN = 0;
+    public static final int ORIENTATION_VERTICAL = 1;
+    public static final int ORIENTATION_HORIZONTAL = 2;
+
+    private static final int ORIENTATION_CHANGED = 1234;
+
+    private static final int VERTICAL_DEBOUNCE = 100;
+    private static final int HORIZONTAL_DEBOUNCE = 500;
+    private static final double VERTICAL_ANGLE = 50.0;
+
+    public interface OrientationListener {
+        public void orientationChanged(int orientation);
+    }
+
+    public AccelerometerListener(Context context) {
+        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
+        mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
+    }
+
+    public void setListener(OrientationListener listener) {
+        mListener = listener;
+    }
+
+    public void enable(boolean enable) {
+        if (DEBUG) Log.d(TAG, "enable(" + enable + ")");
+        synchronized (this) {
+            if (enable) {
+                mOrientation = ORIENTATION_UNKNOWN;
+                mPendingOrientation = ORIENTATION_UNKNOWN;
+                mSensorManager.registerListener(mSensorListener, mSensor,
+                        SensorManager.SENSOR_DELAY_NORMAL);
+            } else {
+                mSensorManager.unregisterListener(mSensorListener);
+                mHandler.removeMessages(ORIENTATION_CHANGED);
+            }
+        }
+    }
+
+    private void setOrientation(int orientation) {
+        synchronized (this) {
+            if (mPendingOrientation == orientation) {
+                // Pending orientation has not changed, so do nothing.
+                return;
+            }
+
+            // Cancel any pending messages.
+            // We will either start a new timer or cancel alltogether
+            // if the orientation has not changed.
+            mHandler.removeMessages(ORIENTATION_CHANGED);
+
+            if (mOrientation != orientation) {
+                // Set timer to send an event if the orientation has changed since its
+                // previously reported value.
+                mPendingOrientation = orientation;
+                final Message m = mHandler.obtainMessage(ORIENTATION_CHANGED);
+                // set delay to our debounce timeout
+                int delay = (orientation == ORIENTATION_VERTICAL ? VERTICAL_DEBOUNCE
+                                                                 : HORIZONTAL_DEBOUNCE);
+                mHandler.sendMessageDelayed(m, delay);
+            } else {
+                // no message is pending
+                mPendingOrientation = ORIENTATION_UNKNOWN;
+            }
+        }
+    }
+
+    private void onSensorEvent(double x, double y, double z) {
+        if (VDEBUG) Log.d(TAG, "onSensorEvent(" + x + ", " + y + ", " + z + ")");
+
+        // If some values are exactly zero, then likely the sensor is not powered up yet.
+        // ignore these events to avoid false horizontal positives.
+        if (x == 0.0 || y == 0.0 || z == 0.0) return;
+
+        // magnitude of the acceleration vector projected onto XY plane
+        final double xy = Math.hypot(x, y);
+        // compute the vertical angle
+        double angle = Math.atan2(xy, z);
+        // convert to degrees
+        angle = angle * 180.0 / Math.PI;
+        final int orientation = (angle >  VERTICAL_ANGLE ? ORIENTATION_VERTICAL : ORIENTATION_HORIZONTAL);
+        if (VDEBUG) Log.d(TAG, "angle: " + angle + " orientation: " + orientation);
+        setOrientation(orientation);
+    }
+
+    SensorEventListener mSensorListener = new SensorEventListener() {
+        @Override
+        public void onSensorChanged(SensorEvent event) {
+            onSensorEvent(event.values[0], event.values[1], event.values[2]);
+        }
+
+        @Override
+        public void onAccuracyChanged(Sensor sensor, int accuracy) {
+            // ignore
+        }
+    };
+
+    Handler mHandler = new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+            case ORIENTATION_CHANGED:
+                synchronized (this) {
+                    mOrientation = mPendingOrientation;
+                    if (DEBUG) {
+                        Log.d(TAG, "orientation: " +
+                            (mOrientation == ORIENTATION_HORIZONTAL ? "horizontal"
+                                : (mOrientation == ORIENTATION_VERTICAL ? "vertical"
+                                    : "unknown")));
+                    }
+                    if (mListener != null) {
+                        mListener.orientationChanged(mOrientation);
+                    }
+                }
+                break;
+            }
+        }
+    };
+}
diff --git a/InCallUI/src/com/android/incallui/AccessibleAnswerFragment.java b/InCallUI/src/com/android/incallui/AccessibleAnswerFragment.java
new file mode 100644
index 0000000..89c78ec
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/AccessibleAnswerFragment.java
@@ -0,0 +1,157 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.os.Bundle;
+import android.telecom.VideoProfile;
+import android.view.GestureDetector;
+import android.view.GestureDetector.SimpleOnGestureListener;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.android.dialer.R;
+
+/**
+ * AnswerFragment to use when touch exploration is enabled in accessibility.
+ */
+public class AccessibleAnswerFragment extends AnswerFragment {
+
+    private static final String TAG = AccessibleAnswerFragment.class.getSimpleName();
+    private static final int SWIPE_THRESHOLD = 100;
+
+    private View mAnswer;
+    private View mDecline;
+    private View mText;
+
+    private TouchListener mTouchListener;
+    private GestureDetector mGestureDetector;
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        ViewGroup group = (ViewGroup) inflater.inflate(R.layout.accessible_answer_fragment,
+                container, false);
+
+        mTouchListener = new TouchListener();
+        mGestureDetector = new GestureDetector(getContext(), new SimpleOnGestureListener() {
+            @Override
+            public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
+                    float velocityY) {
+                return AccessibleAnswerFragment.this.onFling(e1, e2, velocityX, velocityX);
+            }
+        });
+
+        mAnswer = group.findViewById(R.id.accessible_answer_fragment_answer);
+        mAnswer.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                Log.d(TAG, "Answer Button Clicked");
+                onAnswer(VideoProfile.STATE_AUDIO_ONLY, getContext());
+            }
+        });
+        mDecline = group.findViewById(R.id.accessible_answer_fragment_decline);
+        mDecline.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                Log.d(TAG, "Decline Button Clicked");
+                onDecline(getContext());
+            }
+        });
+
+        mText = group.findViewById(R.id.accessible_answer_fragment_text);
+        mText.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                Log.d(TAG, "Text Button Clicked");
+                onText();
+            }
+        });
+        return group;
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        // Intercept all touch events for full screen swiping gesture.
+        InCallActivity activity = (InCallActivity) getActivity();
+        activity.setDispatchTouchEventListener(mTouchListener);
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        InCallActivity activity = (InCallActivity) getActivity();
+        activity.setDispatchTouchEventListener(null);
+    }
+
+    private class TouchListener implements View.OnTouchListener {
+        @Override
+        public boolean onTouch(View v, MotionEvent event) {
+            return mGestureDetector.onTouchEvent(event);
+        }
+    }
+
+    private boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
+            float velocityY) {
+        if (hasPendingDialogs()) {
+            return false;
+        }
+
+        float diffY = e2.getY() - e1.getY();
+        float diffX = e2.getX() - e1.getX();
+        if (Math.abs(diffX) > Math.abs(diffY)) {
+            if (Math.abs(diffX) > SWIPE_THRESHOLD) {
+                if (diffX > 0) {
+                    onSwipeRight();
+                } else {
+                    onSwipeLeft();
+                }
+            }
+            return true;
+        } else if (Math.abs(diffY) > SWIPE_THRESHOLD) {
+            if (diffY > 0) {
+                onSwipeDown();
+            } else {
+                onSwipeUp();
+            }
+            return true;
+        }
+
+        return false;
+    }
+
+    private void onSwipeUp() {
+        Log.d(TAG, "onSwipeUp");
+        onText();
+    }
+
+    private void onSwipeDown() {
+        Log.d(TAG, "onSwipeDown");
+    }
+
+    private void onSwipeLeft() {
+        Log.d(TAG, "onSwipeLeft");
+        onDecline(getContext());
+    }
+
+    private void onSwipeRight() {
+        Log.d(TAG, "onSwipeRight");
+        onAnswer(VideoProfile.STATE_AUDIO_ONLY, getContext());
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/AnswerFragment.java b/InCallUI/src/com/android/incallui/AnswerFragment.java
new file mode 100644
index 0000000..44ddfcd
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/AnswerFragment.java
@@ -0,0 +1,307 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.WindowManager;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ListView;
+
+import com.android.dialer.R;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * Provides only common interface and functions. Should be derived to implement the actual UI.
+ */
+public abstract class AnswerFragment extends BaseFragment<AnswerPresenter, AnswerPresenter.AnswerUi>
+        implements AnswerPresenter.AnswerUi {
+
+    public static final int TARGET_SET_FOR_AUDIO_WITHOUT_SMS = 0;
+    public static final int TARGET_SET_FOR_AUDIO_WITH_SMS = 1;
+    public static final int TARGET_SET_FOR_VIDEO_WITHOUT_SMS = 2;
+    public static final int TARGET_SET_FOR_VIDEO_WITH_SMS = 3;
+    public static final int TARGET_SET_FOR_VIDEO_ACCEPT_REJECT_REQUEST = 4;
+
+    /**
+     * This fragment implement no UI at all. Derived class should do it.
+     */
+    @Override
+    public abstract View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState);
+
+    /**
+     * The popup showing the list of canned responses.
+     *
+     * This is an AlertDialog containing a ListView showing the possible choices.  This may be null
+     * if the InCallScreen hasn't ever called showRespondViaSmsPopup() yet, or if the popup was
+     * visible once but then got dismissed.
+     */
+    private Dialog mCannedResponsePopup = null;
+
+    /**
+     * The popup showing a text field for users to type in their custom message.
+     */
+    private AlertDialog mCustomMessagePopup = null;
+
+    private ArrayAdapter<String> mSmsResponsesAdapter;
+
+    private final List<String> mSmsResponses = new ArrayList<>();
+
+    @Override
+    public AnswerPresenter createPresenter() {
+        return InCallPresenter.getInstance().getAnswerPresenter();
+    }
+
+    @Override
+    public AnswerPresenter.AnswerUi getUi() {
+        return this;
+    }
+
+    @Override
+    public void showMessageDialog() {
+        final AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+
+        mSmsResponsesAdapter = new ArrayAdapter<>(builder.getContext(),
+                android.R.layout.simple_list_item_1, android.R.id.text1, mSmsResponses);
+
+        final ListView lv = new ListView(getActivity());
+        lv.setAdapter(mSmsResponsesAdapter);
+        lv.setOnItemClickListener(new RespondViaSmsItemClickListener());
+
+        builder.setCancelable(true).setView(lv).setOnCancelListener(
+                new DialogInterface.OnCancelListener() {
+                    @Override
+                    public void onCancel(DialogInterface dialogInterface) {
+                        onMessageDialogCancel();
+                        dismissCannedResponsePopup();
+                        getPresenter().onDismissDialog();
+                    }
+                });
+        mCannedResponsePopup = builder.create();
+        mCannedResponsePopup.getWindow().addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
+        mCannedResponsePopup.show();
+    }
+
+    private boolean isCannedResponsePopupShowing() {
+        if (mCannedResponsePopup != null) {
+            return mCannedResponsePopup.isShowing();
+        }
+        return false;
+    }
+
+    private boolean isCustomMessagePopupShowing() {
+        if (mCustomMessagePopup != null) {
+            return mCustomMessagePopup.isShowing();
+        }
+        return false;
+    }
+
+    /**
+     * Dismiss the canned response list popup.
+     *
+     * This is safe to call even if the popup is already dismissed, and even if you never called
+     * showRespondViaSmsPopup() in the first place.
+     */
+    protected void dismissCannedResponsePopup() {
+        if (mCannedResponsePopup != null) {
+            mCannedResponsePopup.dismiss();  // safe even if already dismissed
+            mCannedResponsePopup = null;
+        }
+    }
+
+    /**
+     * Dismiss the custom compose message popup.
+     */
+    private void dismissCustomMessagePopup() {
+        if (mCustomMessagePopup != null) {
+            mCustomMessagePopup.dismiss();
+            mCustomMessagePopup = null;
+        }
+    }
+
+    public void dismissPendingDialogs() {
+        if (isCannedResponsePopupShowing()) {
+            dismissCannedResponsePopup();
+        }
+
+        if (isCustomMessagePopupShowing()) {
+            dismissCustomMessagePopup();
+        }
+    }
+
+    public boolean hasPendingDialogs() {
+        return !(mCannedResponsePopup == null && mCustomMessagePopup == null);
+    }
+
+    /**
+     * Shows the custom message entry dialog.
+     */
+    public void showCustomMessageDialog() {
+        // Create an alert dialog containing an EditText
+        final AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+        final EditText et = new EditText(builder.getContext());
+        builder.setCancelable(true).setView(et)
+                .setPositiveButton(R.string.custom_message_send,
+                        new DialogInterface.OnClickListener() {
+                            @Override
+                            public void onClick(DialogInterface dialog, int which) {
+                                // The order is arranged in a way that the popup will be destroyed
+                                // when the InCallActivity is about to finish.
+                                final String textMessage = et.getText().toString().trim();
+                                dismissCustomMessagePopup();
+                                getPresenter().rejectCallWithMessage(textMessage);
+                            }
+                        })
+                .setNegativeButton(R.string.custom_message_cancel,
+                        new DialogInterface.OnClickListener() {
+                            @Override
+                            public void onClick(DialogInterface dialog, int which) {
+                                dismissCustomMessagePopup();
+                                getPresenter().onDismissDialog();
+                            }
+                        })
+                .setOnCancelListener(new DialogInterface.OnCancelListener() {
+                    @Override
+                    public void onCancel(DialogInterface dialogInterface) {
+                        dismissCustomMessagePopup();
+                        getPresenter().onDismissDialog();
+                    }
+                })
+                .setTitle(R.string.respond_via_sms_custom_message);
+        mCustomMessagePopup = builder.create();
+
+        // Enable/disable the send button based on whether there is a message in the EditText
+        et.addTextChangedListener(new TextWatcher() {
+            @Override
+            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+            }
+
+            @Override
+            public void onTextChanged(CharSequence s, int start, int before, int count) {
+            }
+
+            @Override
+            public void afterTextChanged(Editable s) {
+                final Button sendButton = mCustomMessagePopup.getButton(
+                        DialogInterface.BUTTON_POSITIVE);
+                sendButton.setEnabled(s != null && s.toString().trim().length() != 0);
+            }
+        });
+
+        // Keyboard up, show the dialog
+        mCustomMessagePopup.getWindow().setSoftInputMode(
+                WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
+        mCustomMessagePopup.getWindow().addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
+        mCustomMessagePopup.show();
+
+        // Send button starts out disabled
+        final Button sendButton = mCustomMessagePopup.getButton(DialogInterface.BUTTON_POSITIVE);
+        sendButton.setEnabled(false);
+    }
+
+    @Override
+    public void configureMessageDialog(List<String> textResponses) {
+        mSmsResponses.clear();
+        mSmsResponses.addAll(textResponses);
+        mSmsResponses.add(getResources().getString(
+                R.string.respond_via_sms_custom_message));
+        if (mSmsResponsesAdapter != null) {
+            mSmsResponsesAdapter.notifyDataSetChanged();
+        }
+    }
+
+    @Override
+    public Context getContext() {
+        return getActivity();
+    }
+
+    public void onAnswer(int videoState, Context context) {
+        Log.d(this, "onAnswer videoState=" + videoState + " context=" + context);
+        getPresenter().onAnswer(videoState, context);
+    }
+
+    public void onDecline(Context context) {
+        getPresenter().onDecline(context);
+    }
+
+    public void onDeclineUpgradeRequest(Context context) {
+        InCallPresenter.getInstance().declineUpgradeRequest(context);
+    }
+
+    public void onText() {
+        getPresenter().onText();
+    }
+
+    /**
+     * OnItemClickListener for the "Respond via SMS" popup.
+     */
+    public class RespondViaSmsItemClickListener implements AdapterView.OnItemClickListener {
+
+        /**
+         * Handles the user selecting an item from the popup.
+         */
+        @Override
+        public void onItemClick(AdapterView<?> parent,  // The ListView
+                View view,  // The TextView that was clicked
+                int position, long id) {
+            Log.d(this, "RespondViaSmsItemClickListener.onItemClick(" + position + ")...");
+            final String message = (String) parent.getItemAtPosition(position);
+            Log.v(this, "- message: '" + message + "'");
+            dismissCannedResponsePopup();
+
+            // The "Custom" choice is a special case.
+            // (For now, it's guaranteed to be the last item.)
+            if (position == (parent.getCount() - 1)) {
+                // Show the custom message dialog
+                showCustomMessageDialog();
+            } else {
+                getPresenter().rejectCallWithMessage(message);
+            }
+        }
+    }
+
+    public void onShowAnswerUi(boolean shown) {
+        // Do Nothing
+    }
+
+    public void showTargets(int targetSet) {
+        // Do Nothing
+    }
+
+    public void showTargets(int targetSet, int videoState) {
+        // Do Nothing
+    }
+
+    protected void onMessageDialogCancel() {
+        // Do nothing.
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/AnswerPresenter.java b/InCallUI/src/com/android/incallui/AnswerPresenter.java
new file mode 100644
index 0000000..6e1fb3c
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/AnswerPresenter.java
@@ -0,0 +1,314 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+
+import com.android.dialer.compat.UserManagerCompat;
+import com.android.dialer.util.TelecomUtil;
+import com.android.incallui.InCallPresenter.InCallState;
+
+import java.util.List;
+
+/**
+ * Presenter for the Incoming call widget. The {@link AnswerPresenter} handles the logic during
+ * incoming calls. It is also in charge of responding to incoming calls, so there needs to be
+ * an instance alive so that it can receive onIncomingCall callbacks.
+ *
+ * An instance of {@link AnswerPresenter} is created by InCallPresenter at startup, registers
+ * for callbacks via InCallPresenter, and shows/hides the {@link AnswerFragment} via IncallActivity.
+ *
+ */
+public class AnswerPresenter extends Presenter<AnswerPresenter.AnswerUi>
+        implements CallList.CallUpdateListener, InCallPresenter.InCallUiListener,
+                InCallPresenter.IncomingCallListener,
+                CallList.Listener {
+
+    private static final String TAG = AnswerPresenter.class.getSimpleName();
+
+    private String mCallId;
+    private Call mCall = null;
+    private boolean mHasTextMessages = false;
+
+    @Override
+    public void onUiShowing(boolean showing) {
+        if (showing) {
+            CallList.getInstance().addListener(this);
+            final CallList calls = CallList.getInstance();
+            Call call;
+            call = calls.getIncomingCall();
+            if (call != null) {
+                processIncomingCall(call);
+            }
+            call = calls.getVideoUpgradeRequestCall();
+            Log.d(this, "getVideoUpgradeRequestCall call =" + call);
+            if (call != null) {
+                processVideoUpgradeRequestCall(call);
+            }
+        } else {
+            CallList.getInstance().removeListener(this);
+            // This is necessary because the activity can be destroyed while an incoming call exists.
+            // This happens when back button is pressed while incoming call is still being shown.
+            if (mCallId != null) {
+                CallList.getInstance().removeCallUpdateListener(mCallId, this);
+            }
+        }
+    }
+
+    @Override
+    public void onIncomingCall(InCallState oldState, InCallState newState, Call call) {
+        Log.d(this, "onIncomingCall: " + this);
+        Call modifyCall = CallList.getInstance().getVideoUpgradeRequestCall();
+        if (modifyCall != null) {
+            showAnswerUi(false);
+            Log.d(this, "declining upgrade request id: ");
+            CallList.getInstance().removeCallUpdateListener(mCallId, this);
+            InCallPresenter.getInstance().declineUpgradeRequest(getUi().getContext());
+        }
+        if (!call.getId().equals(mCallId)) {
+            // A new call is coming in.
+            processIncomingCall(call);
+        }
+    }
+
+    @Override
+    public void onIncomingCall(Call call) {
+    }
+
+    @Override
+    public void onCallListChange(CallList list) {
+    }
+
+    @Override
+    public void onDisconnect(Call call) {
+        // no-op
+    }
+
+    public void onSessionModificationStateChange(int sessionModificationState) {
+        boolean isUpgradePending = sessionModificationState ==
+                Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST;
+
+        if (!isUpgradePending) {
+            // Stop listening for updates.
+            CallList.getInstance().removeCallUpdateListener(mCallId, this);
+            showAnswerUi(false);
+        }
+    }
+
+    @Override
+    public void onLastForwardedNumberChange() {
+        // no-op
+    }
+
+    @Override
+    public void onChildNumberChange() {
+        // no-op
+    }
+
+    private boolean isVideoUpgradePending(Call call) {
+        return call.getSessionModificationState()
+                == Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST;
+    }
+
+    @Override
+    public void onUpgradeToVideo(Call call) {
+        Log.d(this, "onUpgradeToVideo: " + this + " call=" + call);
+        if (getUi() == null) {
+            Log.d(this, "onUpgradeToVideo ui is null");
+            return;
+        }
+        boolean isUpgradePending = isVideoUpgradePending(call);
+        InCallPresenter inCallPresenter = InCallPresenter.getInstance();
+        if (isUpgradePending
+                && inCallPresenter.getInCallState() == InCallPresenter.InCallState.INCOMING) {
+            Log.d(this, "declining upgrade request");
+            //If there is incoming call reject upgrade request
+            inCallPresenter.declineUpgradeRequest(getUi().getContext());
+        } else if (isUpgradePending) {
+            Log.d(this, "process upgrade request as no MT call");
+            processVideoUpgradeRequestCall(call);
+        }
+    }
+
+    private void processIncomingCall(Call call) {
+        mCallId = call.getId();
+        mCall = call;
+
+        // Listen for call updates for the current call.
+        CallList.getInstance().addCallUpdateListener(mCallId, this);
+
+        Log.d(TAG, "Showing incoming for call id: " + mCallId + " " + this);
+        if (showAnswerUi(true)) {
+            final List<String> textMsgs = CallList.getInstance().getTextResponses(call.getId());
+            configureAnswerTargetsForSms(call, textMsgs);
+        }
+    }
+
+    private boolean showAnswerUi(boolean show) {
+        final InCallActivity activity = InCallPresenter.getInstance().getActivity();
+        if (activity != null) {
+            activity.showAnswerFragment(show);
+            if (getUi() != null) {
+                getUi().onShowAnswerUi(show);
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    private void processVideoUpgradeRequestCall(Call call) {
+        Log.d(this, " processVideoUpgradeRequestCall call=" + call);
+        mCallId = call.getId();
+        mCall = call;
+
+        // Listen for call updates for the current call.
+        CallList.getInstance().addCallUpdateListener(mCallId, this);
+
+        final int currentVideoState = call.getVideoState();
+        final int modifyToVideoState = call.getRequestedVideoState();
+
+        if (currentVideoState == modifyToVideoState) {
+            Log.w(this, "processVideoUpgradeRequestCall: Video states are same. Return.");
+            return;
+        }
+
+        AnswerUi ui = getUi();
+
+        if (ui == null) {
+            Log.e(this, "Ui is null. Can't process upgrade request");
+            return;
+        }
+        showAnswerUi(true);
+        ui.showTargets(AnswerFragment.TARGET_SET_FOR_VIDEO_ACCEPT_REJECT_REQUEST,
+                modifyToVideoState);
+    }
+
+    private boolean isEnabled(int videoState, int mask) {
+        return (videoState & mask) == mask;
+    }
+
+    @Override
+    public void onCallChanged(Call call) {
+        Log.d(this, "onCallStateChange() " + call + " " + this);
+        if (call.getState() != Call.State.INCOMING) {
+            boolean isUpgradePending = isVideoUpgradePending(call);
+            if (!isUpgradePending) {
+                // Stop listening for updates.
+                CallList.getInstance().removeCallUpdateListener(mCallId, this);
+            }
+
+            final Call incall = CallList.getInstance().getIncomingCall();
+            if (incall != null || isUpgradePending) {
+                showAnswerUi(true);
+            } else {
+                showAnswerUi(false);
+            }
+
+            mHasTextMessages = false;
+        } else if (!mHasTextMessages) {
+            final List<String> textMsgs = CallList.getInstance().getTextResponses(call.getId());
+            if (textMsgs != null) {
+                configureAnswerTargetsForSms(call, textMsgs);
+            }
+        }
+    }
+
+    public void onAnswer(int videoState, Context context) {
+        if (mCallId == null) {
+            return;
+        }
+
+        if (mCall.getSessionModificationState()
+                == Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+            Log.d(this, "onAnswer (upgradeCall) mCallId=" + mCallId + " videoState=" + videoState);
+            InCallPresenter.getInstance().acceptUpgradeRequest(videoState, context);
+        } else {
+            Log.d(this, "onAnswer (answerCall) mCallId=" + mCallId + " videoState=" + videoState);
+            TelecomAdapter.getInstance().answerCall(mCall.getId(), videoState);
+        }
+    }
+
+    /**
+     * TODO: We are using reject and decline interchangeably. We should settle on
+     * reject since it seems to be more prevalent.
+     */
+    public void onDecline(Context context) {
+        Log.d(this, "onDecline " + mCallId);
+        if (mCall.getSessionModificationState()
+                == Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+            InCallPresenter.getInstance().declineUpgradeRequest(context);
+        } else {
+            TelecomAdapter.getInstance().rejectCall(mCall.getId(), false, null);
+        }
+    }
+
+    public void onText() {
+        if (getUi() != null) {
+            TelecomUtil.silenceRinger(getUi().getContext());
+            getUi().showMessageDialog();
+        }
+    }
+
+    public void rejectCallWithMessage(String message) {
+        Log.d(this, "sendTextToDefaultActivity()...");
+        TelecomAdapter.getInstance().rejectCall(mCall.getId(), true, message);
+
+        onDismissDialog();
+    }
+
+    public void onDismissDialog() {
+        InCallPresenter.getInstance().onDismissDialog();
+    }
+
+    private void configureAnswerTargetsForSms(Call call, List<String> textMsgs) {
+        if (getUi() == null) {
+            return;
+        }
+        mHasTextMessages = textMsgs != null;
+        boolean withSms = UserManagerCompat.isUserUnlocked(getUi().getContext())
+                && call.can(android.telecom.Call.Details.CAPABILITY_RESPOND_VIA_TEXT)
+                && mHasTextMessages;
+
+        // Only present the user with the option to answer as a video call if the incoming call is
+        // a bi-directional video call.
+        if (VideoUtils.isBidirectionalVideoCall(call)) {
+            if (withSms) {
+                getUi().showTargets(AnswerFragment.TARGET_SET_FOR_VIDEO_WITH_SMS);
+                getUi().configureMessageDialog(textMsgs);
+            } else {
+                getUi().showTargets(AnswerFragment.TARGET_SET_FOR_VIDEO_WITHOUT_SMS);
+            }
+        } else {
+            if (withSms) {
+                getUi().showTargets(AnswerFragment.TARGET_SET_FOR_AUDIO_WITH_SMS);
+                getUi().configureMessageDialog(textMsgs);
+            } else {
+                getUi().showTargets(AnswerFragment.TARGET_SET_FOR_AUDIO_WITHOUT_SMS);
+            }
+        }
+    }
+
+    interface AnswerUi extends Ui {
+        public void onShowAnswerUi(boolean shown);
+        public void showTargets(int targetSet);
+        public void showTargets(int targetSet, int videoState);
+        public void showMessageDialog();
+        public void configureMessageDialog(List<String> textResponses);
+        public Context getContext();
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/AudioModeProvider.java b/InCallUI/src/com/android/incallui/AudioModeProvider.java
new file mode 100644
index 0000000..961fb11
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/AudioModeProvider.java
@@ -0,0 +1,105 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import com.google.common.collect.Lists;
+
+import com.android.dialer.compat.CallAudioStateCompat;
+
+import java.util.List;
+
+/**
+ * Proxy class for getting and setting the audio mode.
+ */
+public class AudioModeProvider {
+
+    static final int AUDIO_MODE_INVALID = 0;
+
+    private static AudioModeProvider sAudioModeProvider = new AudioModeProvider();
+    private int mAudioMode = CallAudioStateCompat.ROUTE_EARPIECE;
+    private boolean mMuted = false;
+    private int mSupportedModes = CallAudioStateCompat.ROUTE_EARPIECE
+            | CallAudioStateCompat.ROUTE_BLUETOOTH | CallAudioStateCompat.ROUTE_WIRED_HEADSET
+            | CallAudioStateCompat.ROUTE_SPEAKER;
+    private final List<AudioModeListener> mListeners = Lists.newArrayList();
+
+    public static AudioModeProvider getInstance() {
+        return sAudioModeProvider;
+    }
+
+    public void onAudioStateChanged(boolean isMuted, int route, int supportedRouteMask) {
+        onAudioModeChange(route, isMuted);
+        onSupportedAudioModeChange(supportedRouteMask);
+    }
+
+    public void onAudioModeChange(int newMode, boolean muted) {
+        if (mAudioMode != newMode) {
+            mAudioMode = newMode;
+            for (AudioModeListener l : mListeners) {
+                l.onAudioMode(mAudioMode);
+            }
+        }
+
+        if (mMuted != muted) {
+            mMuted = muted;
+            for (AudioModeListener l : mListeners) {
+                l.onMute(mMuted);
+            }
+        }
+    }
+
+    public void onSupportedAudioModeChange(int newModeMask) {
+        mSupportedModes = newModeMask;
+
+        for (AudioModeListener l : mListeners) {
+            l.onSupportedAudioMode(mSupportedModes);
+        }
+    }
+
+    public void addListener(AudioModeListener listener) {
+        if (!mListeners.contains(listener)) {
+            mListeners.add(listener);
+            listener.onSupportedAudioMode(mSupportedModes);
+            listener.onAudioMode(mAudioMode);
+            listener.onMute(mMuted);
+        }
+    }
+
+    public void removeListener(AudioModeListener listener) {
+        if (mListeners.contains(listener)) {
+            mListeners.remove(listener);
+        }
+    }
+
+    public int getSupportedModes() {
+        return mSupportedModes;
+    }
+
+    public int getAudioMode() {
+        return mAudioMode;
+    }
+
+    public boolean getMute() {
+        return mMuted;
+    }
+
+    /* package */ interface AudioModeListener {
+        void onAudioMode(int newMode);
+        void onMute(boolean muted);
+        void onSupportedAudioMode(int modeMask);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/BaseFragment.java b/InCallUI/src/com/android/incallui/BaseFragment.java
new file mode 100644
index 0000000..58d991a
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/BaseFragment.java
@@ -0,0 +1,84 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.app.Activity;
+import android.app.Fragment;
+import android.os.Bundle;
+
+/**
+ * Parent for all fragments that use Presenters and Ui design.
+ */
+public abstract class BaseFragment<T extends Presenter<U>, U extends Ui> extends Fragment {
+
+    private static final String KEY_FRAGMENT_HIDDEN = "key_fragment_hidden";
+
+    private T mPresenter;
+
+    public abstract T createPresenter();
+
+    public abstract U getUi();
+
+    protected BaseFragment() {
+        mPresenter = createPresenter();
+    }
+
+    /**
+     * Presenter will be available after onActivityCreated().
+     *
+     * @return The presenter associated with this fragment.
+     */
+    public T getPresenter() {
+        return mPresenter;
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+        mPresenter.onUiReady(getUi());
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        if (savedInstanceState != null) {
+            mPresenter.onRestoreInstanceState(savedInstanceState);
+            if (savedInstanceState.getBoolean(KEY_FRAGMENT_HIDDEN)) {
+                getFragmentManager().beginTransaction().hide(this).commit();
+            }
+        }
+    }
+
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+        mPresenter.onUiDestroy(getUi());
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        mPresenter.onSaveInstanceState(outState);
+        outState.putBoolean(KEY_FRAGMENT_HIDDEN, isHidden());
+    }
+
+    @Override
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+        ((FragmentDisplayManager) activity).onFragmentAttached(this);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/Call.java b/InCallUI/src/com/android/incallui/Call.java
new file mode 100644
index 0000000..aec806f
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/Call.java
@@ -0,0 +1,1004 @@
+/*
+ * 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.
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.hardware.camera2.CameraCharacteristics;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Trace;
+import android.telecom.Connection;
+import android.telecom.DisconnectCause;
+import android.telecom.GatewayInfo;
+import android.telecom.InCallService.VideoCall;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.TelecomManager;
+import android.telecom.VideoProfile;
+import android.text.TextUtils;
+
+import com.android.contacts.common.CallUtil;
+import com.android.contacts.common.compat.SdkVersionOverride;
+import com.android.contacts.common.compat.telecom.TelecomManagerCompat;
+import com.android.contacts.common.testing.NeededForTesting;
+import com.android.dialer.util.IntentUtil;
+import com.android.incallui.compat.telecom.DetailsCompat;
+import com.android.incallui.compat.telecom.VideoProfileCompat;
+import com.android.incallui.util.TelecomCallUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+
+/**
+ * Describes a single call and its state.
+ */
+@NeededForTesting
+public class Call {
+    /* Defines different states of this call */
+    public static class State {
+        public static final int INVALID = 0;
+        public static final int NEW = 1;            /* The call is new. */
+        public static final int IDLE = 2;           /* The call is idle.  Nothing active */
+        public static final int ACTIVE = 3;         /* There is an active call */
+        public static final int INCOMING = 4;       /* A normal incoming phone call */
+        public static final int CALL_WAITING = 5;   /* Incoming call while another is active */
+        public static final int DIALING = 6;        /* An outgoing call during dial phase */
+        public static final int REDIALING = 7;      /* Subsequent dialing attempt after a failure */
+        public static final int ONHOLD = 8;         /* An active phone call placed on hold */
+        public static final int DISCONNECTING = 9;  /* A call is being ended. */
+        public static final int DISCONNECTED = 10;  /* State after a call disconnects */
+        public static final int CONFERENCED = 11;   /* Call part of a conference call */
+        public static final int SELECT_PHONE_ACCOUNT = 12; /* Waiting for account selection */
+        public static final int CONNECTING = 13;    /* Waiting for Telecom broadcast to finish */
+        public static final int BLOCKED = 14;       /* The number was found on the block list */
+
+
+        public static boolean isConnectingOrConnected(int state) {
+            switch(state) {
+                case ACTIVE:
+                case INCOMING:
+                case CALL_WAITING:
+                case CONNECTING:
+                case DIALING:
+                case REDIALING:
+                case ONHOLD:
+                case CONFERENCED:
+                    return true;
+                default:
+            }
+            return false;
+        }
+
+        public static boolean isDialing(int state) {
+            return state == DIALING || state == REDIALING;
+        }
+
+        public static String toString(int state) {
+            switch (state) {
+                case INVALID:
+                    return "INVALID";
+                case NEW:
+                    return "NEW";
+                case IDLE:
+                    return "IDLE";
+                case ACTIVE:
+                    return "ACTIVE";
+                case INCOMING:
+                    return "INCOMING";
+                case CALL_WAITING:
+                    return "CALL_WAITING";
+                case DIALING:
+                    return "DIALING";
+                case REDIALING:
+                    return "REDIALING";
+                case ONHOLD:
+                    return "ONHOLD";
+                case DISCONNECTING:
+                    return "DISCONNECTING";
+                case DISCONNECTED:
+                    return "DISCONNECTED";
+                case CONFERENCED:
+                    return "CONFERENCED";
+                case SELECT_PHONE_ACCOUNT:
+                    return "SELECT_PHONE_ACCOUNT";
+                case CONNECTING:
+                    return "CONNECTING";
+                case BLOCKED:
+                    return "BLOCKED";
+                default:
+                    return "UNKNOWN";
+            }
+        }
+    }
+
+    /**
+     * Defines different states of session modify requests, which are used to upgrade to video, or
+     * downgrade to audio.
+     */
+    public static class SessionModificationState {
+        public static final int NO_REQUEST = 0;
+        public static final int WAITING_FOR_RESPONSE = 1;
+        public static final int REQUEST_FAILED = 2;
+        public static final int RECEIVED_UPGRADE_TO_VIDEO_REQUEST = 3;
+        public static final int UPGRADE_TO_VIDEO_REQUEST_TIMED_OUT = 4;
+        public static final int REQUEST_REJECTED = 5;
+    }
+
+    public static class VideoSettings {
+        public static final int CAMERA_DIRECTION_UNKNOWN = -1;
+        public static final int CAMERA_DIRECTION_FRONT_FACING =
+                CameraCharacteristics.LENS_FACING_FRONT;
+        public static final int CAMERA_DIRECTION_BACK_FACING =
+                CameraCharacteristics.LENS_FACING_BACK;
+
+        private int mCameraDirection = CAMERA_DIRECTION_UNKNOWN;
+
+        /**
+         * Sets the camera direction. if camera direction is set to CAMERA_DIRECTION_UNKNOWN,
+         * the video state of the call should be used to infer the camera direction.
+         *
+         * @see {@link CameraCharacteristics#LENS_FACING_FRONT}
+         * @see {@link CameraCharacteristics#LENS_FACING_BACK}
+         */
+        public void setCameraDir(int cameraDirection) {
+            if (cameraDirection == CAMERA_DIRECTION_FRONT_FACING
+               || cameraDirection == CAMERA_DIRECTION_BACK_FACING) {
+                mCameraDirection = cameraDirection;
+            } else {
+                mCameraDirection = CAMERA_DIRECTION_UNKNOWN;
+            }
+        }
+
+        /**
+         * Gets the camera direction. if camera direction is set to CAMERA_DIRECTION_UNKNOWN,
+         * the video state of the call should be used to infer the camera direction.
+         *
+         * @see {@link CameraCharacteristics#LENS_FACING_FRONT}
+         * @see {@link CameraCharacteristics#LENS_FACING_BACK}
+         */
+        public int getCameraDir() {
+            return mCameraDirection;
+        }
+
+        @Override
+        public String toString() {
+            return "(CameraDir:" + getCameraDir() + ")";
+        }
+    }
+
+    /**
+     * Tracks any state variables that is useful for logging. There is some amount of overlap with
+     * existing call member variables, but this duplication helps to ensure that none of these
+     * logging variables will interface with/and affect call logic.
+     */
+    public static class LogState {
+
+        // Contact lookup type constants
+        // Unknown lookup result (lookup not completed yet?)
+        public static final int LOOKUP_UNKNOWN = 0;
+        public static final int LOOKUP_NOT_FOUND = 1;
+        public static final int LOOKUP_LOCAL_CONTACT = 2;
+        public static final int LOOKUP_LOCAL_CACHE = 3;
+        public static final int LOOKUP_REMOTE_CONTACT = 4;
+        public static final int LOOKUP_EMERGENCY = 5;
+        public static final int LOOKUP_VOICEMAIL = 6;
+
+        // Call initiation type constants
+        public static final int INITIATION_UNKNOWN = 0;
+        public static final int INITIATION_INCOMING = 1;
+        public static final int INITIATION_DIALPAD = 2;
+        public static final int INITIATION_SPEED_DIAL = 3;
+        public static final int INITIATION_REMOTE_DIRECTORY = 4;
+        public static final int INITIATION_SMART_DIAL = 5;
+        public static final int INITIATION_REGULAR_SEARCH = 6;
+        public static final int INITIATION_CALL_LOG = 7;
+        public static final int INITIATION_CALL_LOG_FILTER = 8;
+        public static final int INITIATION_VOICEMAIL_LOG = 9;
+        public static final int INITIATION_CALL_DETAILS = 10;
+        public static final int INITIATION_QUICK_CONTACTS = 11;
+        public static final int INITIATION_EXTERNAL = 12;
+
+        public DisconnectCause disconnectCause;
+        public boolean isIncoming = false;
+        public int contactLookupResult = LOOKUP_UNKNOWN;
+        public int callInitiationMethod = INITIATION_EXTERNAL;
+        // If this was a conference call, the total number of calls involved in the conference.
+        public int conferencedCalls = 0;
+        public long duration = 0;
+        public boolean isLogged = false;
+
+        @Override
+        public String toString() {
+            return String.format(Locale.US, "["
+                        + "%s, " // DisconnectCause toString already describes the object type
+                        + "isIncoming: %s, "
+                        + "contactLookup: %s, "
+                        + "callInitiation: %s, "
+                        + "duration: %s"
+                        + "]",
+                    disconnectCause,
+                    isIncoming,
+                    lookupToString(contactLookupResult),
+                    initiationToString(callInitiationMethod),
+                    duration);
+        }
+
+        private static String lookupToString(int lookupType) {
+            switch (lookupType) {
+                case LOOKUP_LOCAL_CONTACT:
+                    return "Local";
+                case LOOKUP_LOCAL_CACHE:
+                    return "Cache";
+                case LOOKUP_REMOTE_CONTACT:
+                    return "Remote";
+                case LOOKUP_EMERGENCY:
+                    return "Emergency";
+                case LOOKUP_VOICEMAIL:
+                    return "Voicemail";
+                default:
+                    return "Not found";
+            }
+        }
+
+        private static String initiationToString(int initiationType) {
+            switch (initiationType) {
+                case INITIATION_INCOMING:
+                    return "Incoming";
+                case INITIATION_DIALPAD:
+                    return "Dialpad";
+                case INITIATION_SPEED_DIAL:
+                    return "Speed Dial";
+                case INITIATION_REMOTE_DIRECTORY:
+                    return "Remote Directory";
+                case INITIATION_SMART_DIAL:
+                    return "Smart Dial";
+                case INITIATION_REGULAR_SEARCH:
+                    return "Regular Search";
+                case INITIATION_CALL_LOG:
+                    return "Call Log";
+                case INITIATION_CALL_LOG_FILTER:
+                    return "Call Log Filter";
+                case INITIATION_VOICEMAIL_LOG:
+                    return "Voicemail Log";
+                case INITIATION_CALL_DETAILS:
+                    return "Call Details";
+                case INITIATION_QUICK_CONTACTS:
+                    return "Quick Contacts";
+                default:
+                    return "Unknown";
+            }
+        }
+    }
+
+
+    private static final String ID_PREFIX = Call.class.getSimpleName() + "_";
+    private static int sIdCounter = 0;
+
+    private Object mTelecomCallCallback = newTelecomCallCallback();
+
+    private Object newTelecomCallCallback() {
+        if (SdkVersionOverride.getSdkVersion(Build.VERSION_CODES.M) >= Build.VERSION_CODES.M) {
+            return newMarshmallowTelecomCallCallback();
+        }
+        return newLollipopTelecomCallCallback();
+    }
+
+    private Object newMarshmallowTelecomCallCallback() {
+        Log.i(this, "Using an android.telecom.Call$Callback");
+        return new android.telecom.Call.Callback() {
+            @Override
+            public void onStateChanged(android.telecom.Call call, int newState) {
+                Log.d(this, "TelecomCallCallback onStateChanged call=" + call + " newState="
+                        + newState);
+                update();
+            }
+
+            @Override
+            public void onParentChanged(android.telecom.Call call,
+                    android.telecom.Call newParent) {
+                Log.d(this, "TelecomCallCallback onParentChanged call=" + call + " newParent="
+                        + newParent);
+                update();
+            }
+
+            @Override
+            public void onChildrenChanged(android.telecom.Call call,
+                    List<android.telecom.Call> children) {
+                update();
+            }
+
+            @Override
+            public void onDetailsChanged(android.telecom.Call call,
+                    android.telecom.Call.Details details) {
+                Log.d(this, "TelecomCallCallback onStateChanged call=" + call + " details="
+                        + details);
+                update();
+            }
+
+            @Override
+            public void onCannedTextResponsesLoaded(android.telecom.Call call,
+                    List<String> cannedTextResponses) {
+                Log.d(this, "TelecomCallCallback onStateChanged call=" + call
+                        + " cannedTextResponses=" + cannedTextResponses);
+                update();
+            }
+
+            @Override
+            public void onPostDialWait(android.telecom.Call call,
+                    String remainingPostDialSequence) {
+                Log.d(this, "TelecomCallCallback onStateChanged call=" + call
+                        + " remainingPostDialSequence=" + remainingPostDialSequence);
+                update();
+            }
+
+            @Override
+            public void onVideoCallChanged(android.telecom.Call call,
+                    VideoCall videoCall) {
+                Log.d(this, "TelecomCallCallback onStateChanged call=" + call + " videoCall="
+                        + videoCall);
+                update();
+            }
+
+            @Override
+            public void onCallDestroyed(android.telecom.Call call) {
+                Log.d(this, "TelecomCallCallback onStateChanged call=" + call);
+                call.unregisterCallback(this);
+            }
+
+            @Override
+            public void onConferenceableCallsChanged(android.telecom.Call call,
+                    List<android.telecom.Call> conferenceableCalls) {
+                update();
+            }
+        };
+    }
+
+    private Object newLollipopTelecomCallCallback() {
+        // This code only runs for Google Experience phones on the pre-M sdk since only the system
+        // dialer can invoke the InCallUI code. This allows us to safely use the
+        // android.telecom.Call.Listener interface
+        Log.i(this, "Using an android.telecom.Call$Listener");
+        return new android.telecom.Call.Listener() {
+            @Override
+            public void onStateChanged(android.telecom.Call call, int newState) {
+                Log.d(this, "TelecomCallCallback onStateChanged call=" + call + " newState="
+                        + newState);
+                update();
+            }
+
+            @Override
+            public void onParentChanged(android.telecom.Call call,
+                    android.telecom.Call newParent) {
+                Log.d(this, "TelecomCallCallback onParentChanged call=" + call + " newParent="
+                        + newParent);
+                update();
+            }
+
+            @Override
+            public void onChildrenChanged(android.telecom.Call call,
+                    List<android.telecom.Call> children) {
+                update();
+            }
+
+            @Override
+            public void onDetailsChanged(android.telecom.Call call,
+                    android.telecom.Call.Details details) {
+                Log.d(this, "TelecomCallCallback onStateChanged call=" + call + " details="
+                        + details);
+                update();
+            }
+
+            @Override
+            public void onCannedTextResponsesLoaded(android.telecom.Call call,
+                    List<String> cannedTextResponses) {
+                Log.d(this, "TelecomCallCallback onStateChanged call=" + call
+                        + " cannedTextResponses=" + cannedTextResponses);
+                update();
+            }
+
+            @Override
+            public void onPostDialWait(android.telecom.Call call,
+                    String remainingPostDialSequence) {
+                Log.d(this, "TelecomCallCallback onStateChanged call=" + call
+                        + " remainingPostDialSequence=" + remainingPostDialSequence);
+                update();
+            }
+
+            @Override
+            public void onVideoCallChanged(android.telecom.Call call,
+                    VideoCall videoCall) {
+                Log.d(this, "TelecomCallCallback onStateChanged call=" + call + " videoCall="
+                        + videoCall);
+                update();
+            }
+
+            @Override
+            public void onCallDestroyed(android.telecom.Call call) {
+                Log.d(this, "TelecomCallCallback onStateChanged call=" + call);
+                call.removeListener(this);
+            }
+
+            @Override
+            public void onConferenceableCallsChanged(android.telecom.Call call,
+                    List<android.telecom.Call> conferenceableCalls) {
+                update();
+            }
+        };
+    }
+
+    private android.telecom.Call mTelecomCall;
+    private boolean mIsEmergencyCall;
+    private Uri mHandle;
+    private final String mId;
+    private int mState = State.INVALID;
+    private DisconnectCause mDisconnectCause;
+    private int mSessionModificationState;
+    private final List<String> mChildCallIds = new ArrayList<>();
+    private final VideoSettings mVideoSettings = new VideoSettings();
+    private int mVideoState;
+
+    /**
+     * mRequestedVideoState is used to store requested upgrade / downgrade video state
+     */
+    private int mRequestedVideoState = VideoProfile.STATE_AUDIO_ONLY;
+
+    private InCallVideoCallCallback mVideoCallCallback;
+    private String mChildNumber;
+    private String mLastForwardedNumber;
+    private String mCallSubject;
+    private PhoneAccountHandle mPhoneAccountHandle;
+
+    /**
+     * Indicates whether the phone account associated with this call supports specifying a call
+     * subject.
+     */
+    private boolean mIsCallSubjectSupported;
+
+    private long mTimeAddedMs;
+
+    private LogState mLogState = new LogState();
+
+    /**
+     * Used only to create mock calls for testing
+     */
+    @NeededForTesting
+    Call(int state) {
+        mTelecomCall = null;
+        mId = ID_PREFIX + Integer.toString(sIdCounter++);
+        setState(state);
+    }
+
+    public Call(android.telecom.Call telecomCall) {
+        mTelecomCall = telecomCall;
+        mId = ID_PREFIX + Integer.toString(sIdCounter++);
+
+        updateFromTelecomCall();
+
+        if (SdkVersionOverride.getSdkVersion(Build.VERSION_CODES.M) >= Build.VERSION_CODES.M) {
+            mTelecomCall.registerCallback((android.telecom.Call.Callback) mTelecomCallCallback);
+        } else {
+            mTelecomCall.addListener((android.telecom.Call.Listener) mTelecomCallCallback);
+        }
+
+        mTimeAddedMs = System.currentTimeMillis();
+    }
+
+    public android.telecom.Call getTelecomCall() {
+        return mTelecomCall;
+    }
+
+    /**
+     * @return video settings of the call, null if the call is not a video call.
+     * @see VideoProfile
+     */
+    public VideoSettings getVideoSettings() {
+        return mVideoSettings;
+    }
+
+    private void update() {
+        Trace.beginSection("Update");
+        int oldState = getState();
+        updateFromTelecomCall();
+        if (oldState != getState() && getState() == Call.State.DISCONNECTED) {
+            CallList.getInstance().onDisconnect(this);
+        } else {
+            CallList.getInstance().onUpdate(this);
+        }
+        Trace.endSection();
+    }
+
+    private void updateFromTelecomCall() {
+        Log.d(this, "updateFromTelecomCall: " + mTelecomCall.toString());
+        final int translatedState = translateState(mTelecomCall.getState());
+        if (mState != State.BLOCKED) {
+            setState(translatedState);
+            setDisconnectCause(mTelecomCall.getDetails().getDisconnectCause());
+            maybeCancelVideoUpgrade(mTelecomCall.getDetails().getVideoState());
+        }
+
+        if (mTelecomCall.getVideoCall() != null) {
+            if (mVideoCallCallback == null) {
+                mVideoCallCallback = new InCallVideoCallCallback(this);
+            }
+            mTelecomCall.getVideoCall().registerCallback(mVideoCallCallback);
+        }
+
+        mChildCallIds.clear();
+        final int numChildCalls = mTelecomCall.getChildren().size();
+        for (int i = 0; i < numChildCalls; i++) {
+            mChildCallIds.add(
+                    CallList.getInstance().getCallByTelecomCall(
+                            mTelecomCall.getChildren().get(i)).getId());
+        }
+
+        // The number of conferenced calls can change over the course of the call, so use the
+        // maximum number of conferenced child calls as the metric for conference call usage.
+        mLogState.conferencedCalls = Math.max(numChildCalls, mLogState.conferencedCalls);
+
+        updateFromCallExtras(mTelecomCall.getDetails().getExtras());
+
+        // If the handle of the call has changed, update state for the call determining if it is an
+        // emergency call.
+        Uri newHandle = mTelecomCall.getDetails().getHandle();
+        if (!Objects.equals(mHandle, newHandle)) {
+            mHandle = newHandle;
+            updateEmergencyCallState();
+        }
+
+        // If the phone account handle of the call is set, cache capability bit indicating whether
+        // the phone account supports call subjects.
+        PhoneAccountHandle newPhoneAccountHandle = mTelecomCall.getDetails().getAccountHandle();
+        if (!Objects.equals(mPhoneAccountHandle, newPhoneAccountHandle)) {
+            mPhoneAccountHandle = newPhoneAccountHandle;
+
+            if (mPhoneAccountHandle != null) {
+                TelecomManager mgr = InCallPresenter.getInstance().getTelecomManager();
+                PhoneAccount phoneAccount =
+                        TelecomManagerCompat.getPhoneAccount(mgr, mPhoneAccountHandle);
+                if (phoneAccount != null) {
+                    mIsCallSubjectSupported = phoneAccount.hasCapabilities(
+                            PhoneAccount.CAPABILITY_CALL_SUBJECT);
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests corruption of the {@code callExtras} bundle by calling {@link
+     * Bundle#containsKey(String)}. If the bundle is corrupted a {@link IllegalArgumentException}
+     * will be thrown and caught by this function.
+     *
+     * @param callExtras the bundle to verify
+     * @returns {@code true} if the bundle is corrupted, {@code false} otherwise.
+     */
+    protected boolean areCallExtrasCorrupted(Bundle callExtras) {
+        /**
+         * There's currently a bug in Telephony service (b/25613098) that could corrupt the
+         * extras bundle, resulting in a IllegalArgumentException while validating data under
+         * {@link Bundle#containsKey(String)}.
+         */
+        try {
+            callExtras.containsKey(Connection.EXTRA_CHILD_ADDRESS);
+            return false;
+        } catch (IllegalArgumentException e) {
+            Log.e(this, "CallExtras is corrupted, ignoring exception", e);
+            return true;
+        }
+    }
+
+    protected void updateFromCallExtras(Bundle callExtras) {
+        if (callExtras == null || areCallExtrasCorrupted(callExtras)) {
+            /**
+             * If the bundle is corrupted, abandon information update as a work around. These are
+             * not critical for the dialer to function.
+             */
+            return;
+        }
+        // Check for a change in the child address and notify any listeners.
+        if (callExtras.containsKey(Connection.EXTRA_CHILD_ADDRESS)) {
+            String childNumber = callExtras.getString(Connection.EXTRA_CHILD_ADDRESS);
+            if (!Objects.equals(childNumber, mChildNumber)) {
+                mChildNumber = childNumber;
+                CallList.getInstance().onChildNumberChange(this);
+            }
+        }
+
+        // Last forwarded number comes in as an array of strings.  We want to choose the
+        // last item in the array.  The forwarding numbers arrive independently of when the
+        // call is originally set up, so we need to notify the the UI of the change.
+        if (callExtras.containsKey(Connection.EXTRA_LAST_FORWARDED_NUMBER)) {
+            ArrayList<String> lastForwardedNumbers =
+                    callExtras.getStringArrayList(Connection.EXTRA_LAST_FORWARDED_NUMBER);
+
+            if (lastForwardedNumbers != null) {
+                String lastForwardedNumber = null;
+                if (!lastForwardedNumbers.isEmpty()) {
+                    lastForwardedNumber = lastForwardedNumbers.get(
+                            lastForwardedNumbers.size() - 1);
+                }
+
+                if (!Objects.equals(lastForwardedNumber, mLastForwardedNumber)) {
+                    mLastForwardedNumber = lastForwardedNumber;
+                    CallList.getInstance().onLastForwardedNumberChange(this);
+                }
+            }
+        }
+
+        // Call subject is present in the extras at the start of call, so we do not need to
+        // notify any other listeners of this.
+        if (callExtras.containsKey(Connection.EXTRA_CALL_SUBJECT)) {
+            String callSubject = callExtras.getString(Connection.EXTRA_CALL_SUBJECT);
+            if (!Objects.equals(mCallSubject, callSubject)) {
+                mCallSubject = callSubject;
+            }
+        }
+    }
+
+    /**
+     * Determines if a received upgrade to video request should be cancelled.  This can happen if
+     * another InCall UI responds to the upgrade to video request.
+     *
+     * @param newVideoState The new video state.
+     */
+    private void maybeCancelVideoUpgrade(int newVideoState) {
+        boolean isVideoStateChanged = mVideoState != newVideoState;
+
+        if (mSessionModificationState == SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST
+                && isVideoStateChanged) {
+
+            Log.v(this, "maybeCancelVideoUpgrade : cancelling upgrade notification");
+            setSessionModificationState(SessionModificationState.NO_REQUEST);
+        }
+        mVideoState = newVideoState;
+    }
+    private static int translateState(int state) {
+        switch (state) {
+            case android.telecom.Call.STATE_NEW:
+            case android.telecom.Call.STATE_CONNECTING:
+                return Call.State.CONNECTING;
+            case android.telecom.Call.STATE_SELECT_PHONE_ACCOUNT:
+                return Call.State.SELECT_PHONE_ACCOUNT;
+            case android.telecom.Call.STATE_DIALING:
+                return Call.State.DIALING;
+            case android.telecom.Call.STATE_RINGING:
+                return Call.State.INCOMING;
+            case android.telecom.Call.STATE_ACTIVE:
+                return Call.State.ACTIVE;
+            case android.telecom.Call.STATE_HOLDING:
+                return Call.State.ONHOLD;
+            case android.telecom.Call.STATE_DISCONNECTED:
+                return Call.State.DISCONNECTED;
+            case android.telecom.Call.STATE_DISCONNECTING:
+                return Call.State.DISCONNECTING;
+            default:
+                return Call.State.INVALID;
+        }
+    }
+
+    public String getId() {
+        return mId;
+    }
+
+    public long getTimeAddedMs() {
+        return mTimeAddedMs;
+    }
+
+    public String getNumber() {
+        return TelecomCallUtil.getNumber(mTelecomCall);
+    }
+
+    public void blockCall() {
+        mTelecomCall.reject(false, null);
+        setState(State.BLOCKED);
+    }
+
+    public Uri getHandle() {
+        return mTelecomCall == null ? null : mTelecomCall.getDetails().getHandle();
+    }
+
+    public boolean isEmergencyCall() {
+        return mIsEmergencyCall;
+    }
+
+    public int getState() {
+        if (mTelecomCall != null && mTelecomCall.getParent() != null) {
+            return State.CONFERENCED;
+        } else {
+            return mState;
+        }
+    }
+
+    public void setState(int state) {
+        mState = state;
+        if (mState == State.INCOMING) {
+            mLogState.isIncoming = true;
+        } else if (mState == State.DISCONNECTED) {
+            mLogState.duration = getConnectTimeMillis() == 0 ?
+                    0: System.currentTimeMillis() - getConnectTimeMillis();
+        }
+    }
+
+    public int getNumberPresentation() {
+        return mTelecomCall == null ? null : mTelecomCall.getDetails().getHandlePresentation();
+    }
+
+    public int getCnapNamePresentation() {
+        return mTelecomCall == null ? null
+                : mTelecomCall.getDetails().getCallerDisplayNamePresentation();
+    }
+
+    public String getCnapName() {
+        return mTelecomCall == null ? null
+                : getTelecomCall().getDetails().getCallerDisplayName();
+    }
+
+    public Bundle getIntentExtras() {
+        return DetailsCompat.getIntentExtras(mTelecomCall.getDetails());
+    }
+
+    public Bundle getExtras() {
+        return mTelecomCall == null ? null : mTelecomCall.getDetails().getExtras();
+    }
+
+    /**
+     * @return The child number for the call, or {@code null} if none specified.
+     */
+    public String getChildNumber() {
+        return mChildNumber;
+    }
+
+    /**
+     * @return The last forwarded number for the call, or {@code null} if none specified.
+     */
+    public String getLastForwardedNumber() {
+        return mLastForwardedNumber;
+    }
+
+    /**
+     * @return The call subject, or {@code null} if none specified.
+     */
+    public String getCallSubject() {
+        return mCallSubject;
+    }
+
+    /**
+     * @return {@code true} if the call's phone account supports call subjects, {@code false}
+     *      otherwise.
+     */
+    public boolean isCallSubjectSupported() {
+        return mIsCallSubjectSupported;
+    }
+
+    /** Returns call disconnect cause, defined by {@link DisconnectCause}. */
+    public DisconnectCause getDisconnectCause() {
+        if (mState == State.DISCONNECTED || mState == State.IDLE) {
+            return mDisconnectCause;
+        }
+
+        return new DisconnectCause(DisconnectCause.UNKNOWN);
+    }
+
+    public void setDisconnectCause(DisconnectCause disconnectCause) {
+        mDisconnectCause = disconnectCause;
+        mLogState.disconnectCause = mDisconnectCause;
+    }
+
+    /** Returns the possible text message responses. */
+    public List<String> getCannedSmsResponses() {
+        return mTelecomCall.getCannedTextResponses();
+    }
+
+    /** Checks if the call supports the given set of capabilities supplied as a bit mask. */
+    public boolean can(int capabilities) {
+        int supportedCapabilities = mTelecomCall.getDetails().getCallCapabilities();
+
+        if ((capabilities & android.telecom.Call.Details.CAPABILITY_MERGE_CONFERENCE) != 0) {
+            // We allow you to merge if the capabilities allow it or if it is a call with
+            // conferenceable calls.
+            if (mTelecomCall.getConferenceableCalls().isEmpty() &&
+                ((android.telecom.Call.Details.CAPABILITY_MERGE_CONFERENCE
+                        & supportedCapabilities) == 0)) {
+                // Cannot merge calls if there are no calls to merge with.
+                return false;
+            }
+            capabilities &= ~android.telecom.Call.Details.CAPABILITY_MERGE_CONFERENCE;
+        }
+        return (capabilities == (capabilities & mTelecomCall.getDetails().getCallCapabilities()));
+    }
+
+    public boolean hasProperty(int property) {
+        return DetailsCompat.hasProperty(mTelecomCall.getDetails(), property);
+    }
+
+    /** Gets the time when the call first became active. */
+    public long getConnectTimeMillis() {
+        return mTelecomCall.getDetails().getConnectTimeMillis();
+    }
+
+    public boolean isConferenceCall() {
+        return hasProperty(android.telecom.Call.Details.PROPERTY_CONFERENCE);
+    }
+
+    public GatewayInfo getGatewayInfo() {
+        return mTelecomCall == null ? null : mTelecomCall.getDetails().getGatewayInfo();
+    }
+
+    public PhoneAccountHandle getAccountHandle() {
+        return mTelecomCall == null ? null : mTelecomCall.getDetails().getAccountHandle();
+    }
+
+    public VideoCall getVideoCall() {
+        return mTelecomCall == null ? null : mTelecomCall.getVideoCall();
+    }
+
+    public List<String> getChildCallIds() {
+        return mChildCallIds;
+    }
+
+    public String getParentId() {
+        android.telecom.Call parentCall = mTelecomCall.getParent();
+        if (parentCall != null) {
+            return CallList.getInstance().getCallByTelecomCall(parentCall).getId();
+        }
+        return null;
+    }
+
+    public int getVideoState() {
+        return mTelecomCall.getDetails().getVideoState();
+    }
+
+    public boolean isVideoCall(Context context) {
+        return CallUtil.isVideoEnabled(context) &&
+                VideoUtils.isVideoCall(getVideoState());
+    }
+
+    /**
+     * Handles incoming session modification requests.  Stores the pending video request and sets
+     * the session modification state to
+     * {@link SessionModificationState#RECEIVED_UPGRADE_TO_VIDEO_REQUEST} so that we can keep track
+     * of the fact the request was received.  Only upgrade requests require user confirmation and
+     * will be handled by this method.  The remote user can turn off their own camera without
+     * confirmation.
+     *
+     * @param videoState The requested video state.
+     */
+    public void setRequestedVideoState(int videoState) {
+        Log.d(this, "setRequestedVideoState - video state= " + videoState);
+        if (videoState == getVideoState()) {
+            mSessionModificationState = Call.SessionModificationState.NO_REQUEST;
+            Log.w(this,"setRequestedVideoState - Clearing session modification state");
+            return;
+        }
+
+        mSessionModificationState = Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST;
+        mRequestedVideoState = videoState;
+        CallList.getInstance().onUpgradeToVideo(this);
+
+        Log.d(this, "setRequestedVideoState - mSessionModificationState="
+            + mSessionModificationState + " video state= " + videoState);
+        update();
+    }
+
+    /**
+     * Set the session modification state.  Used to keep track of pending video session modification
+     * operations and to inform listeners of these changes.
+     *
+     * @param state the new session modification state.
+     */
+    public void setSessionModificationState(int state) {
+        boolean hasChanged = mSessionModificationState != state;
+        mSessionModificationState = state;
+        Log.d(this, "setSessionModificationState " + state + " mSessionModificationState="
+                + mSessionModificationState);
+        if (hasChanged) {
+            CallList.getInstance().onSessionModificationStateChange(this, state);
+        }
+    }
+
+    /**
+     * Determines if the call handle is an emergency number or not and caches the result to avoid
+     * repeated calls to isEmergencyNumber.
+     */
+    private void updateEmergencyCallState() {
+        mIsEmergencyCall = TelecomCallUtil.isEmergencyCall(mTelecomCall);
+    }
+
+    /**
+     * Gets the video state which was requested via a session modification request.
+     *
+     * @return The video state.
+     */
+    public int getRequestedVideoState() {
+        return mRequestedVideoState;
+    }
+
+    public static boolean areSame(Call call1, Call call2) {
+        if (call1 == null && call2 == null) {
+            return true;
+        } else if (call1 == null || call2 == null) {
+            return false;
+        }
+
+        // otherwise compare call Ids
+        return call1.getId().equals(call2.getId());
+    }
+
+    public static boolean areSameNumber(Call call1, Call call2) {
+        if (call1 == null && call2 == null) {
+            return true;
+        } else if (call1 == null || call2 == null) {
+            return false;
+        }
+
+        // otherwise compare call Numbers
+        return TextUtils.equals(call1.getNumber(), call2.getNumber());
+    }
+
+    /**
+     *  Gets the current video session modification state.
+     *
+     * @return The session modification state.
+     */
+    public int getSessionModificationState() {
+        return mSessionModificationState;
+    }
+
+    public LogState getLogState() {
+        return mLogState;
+    }
+
+    /**
+     * Logging utility methods
+     */
+    public void logCallInitiationType() {
+        if (getState() == State.INCOMING) {
+            getLogState().callInitiationMethod = LogState.INITIATION_INCOMING;
+        } else if (getIntentExtras() != null) {
+            getLogState().callInitiationMethod =
+                getIntentExtras().getInt(IntentUtil.EXTRA_CALL_INITIATION_TYPE,
+                        LogState.INITIATION_EXTERNAL);
+        }
+    }
+
+    @Override
+    public String toString() {
+        if (mTelecomCall == null) {
+            // This should happen only in testing since otherwise we would never have a null
+            // Telecom call.
+            return String.valueOf(mId);
+        }
+
+        return String.format(Locale.US, "[%s, %s, %s, children:%s, parent:%s, conferenceable:%s, " +
+                "videoState:%s, mSessionModificationState:%d, VideoSettings:%s]",
+                mId,
+                State.toString(getState()),
+                DetailsCompat.capabilitiesToString(mTelecomCall.getDetails().getCallCapabilities()),
+                mChildCallIds,
+                getParentId(),
+                this.mTelecomCall.getConferenceableCalls(),
+                VideoProfileCompat.videoStateToString(mTelecomCall.getDetails().getVideoState()),
+                mSessionModificationState,
+                getVideoSettings());
+    }
+
+    public String toSimpleString() {
+        return super.toString();
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/CallButtonFragment.java b/InCallUI/src/com/android/incallui/CallButtonFragment.java
new file mode 100644
index 0000000..1904ab0
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/CallButtonFragment.java
@@ -0,0 +1,829 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_ADD_CALL;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_AUDIO;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_COUNT;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_DIALPAD;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_DOWNGRADE_TO_AUDIO;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_HOLD;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_MANAGE_VIDEO_CONFERENCE;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_MERGE;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_MUTE;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_PAUSE_VIDEO;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_SWAP;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_SWITCH_CAMERA;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_UPGRADE_TO_VIDEO;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.content.res.Resources;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.GradientDrawable;
+import android.graphics.drawable.LayerDrawable;
+import android.graphics.drawable.RippleDrawable;
+import android.graphics.drawable.StateListDrawable;
+import android.os.Bundle;
+import android.util.SparseIntArray;
+import android.view.ContextThemeWrapper;
+import android.view.HapticFeedbackConstants;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CompoundButton;
+import android.widget.ImageButton;
+import android.widget.PopupMenu;
+import android.widget.PopupMenu.OnDismissListener;
+import android.widget.PopupMenu.OnMenuItemClickListener;
+
+import com.android.contacts.common.util.MaterialColorMapUtils.MaterialPalette;
+import com.android.dialer.compat.CallAudioStateCompat;
+
+/**
+ * Fragment for call control buttons
+ */
+public class CallButtonFragment
+        extends BaseFragment<CallButtonPresenter, CallButtonPresenter.CallButtonUi>
+        implements CallButtonPresenter.CallButtonUi, OnMenuItemClickListener, OnDismissListener,
+        View.OnClickListener {
+
+    private static final int INVALID_INDEX = -1;
+    private int mButtonMaxVisible;
+    // The button is currently visible in the UI
+    private static final int BUTTON_VISIBLE = 1;
+    // The button is hidden in the UI
+    private static final int BUTTON_HIDDEN = 2;
+    // The button has been collapsed into the overflow menu
+    private static final int BUTTON_MENU = 3;
+
+    public interface Buttons {
+
+        public static final int BUTTON_AUDIO = 0;
+        public static final int BUTTON_MUTE = 1;
+        public static final int BUTTON_DIALPAD = 2;
+        public static final int BUTTON_HOLD = 3;
+        public static final int BUTTON_SWAP = 4;
+        public static final int BUTTON_UPGRADE_TO_VIDEO = 5;
+        public static final int BUTTON_SWITCH_CAMERA = 6;
+        public static final int BUTTON_DOWNGRADE_TO_AUDIO = 7;
+        public static final int BUTTON_ADD_CALL = 8;
+        public static final int BUTTON_MERGE = 9;
+        public static final int BUTTON_PAUSE_VIDEO = 10;
+        public static final int BUTTON_MANAGE_VIDEO_CONFERENCE = 11;
+        public static final int BUTTON_COUNT = 12;
+    }
+
+    private SparseIntArray mButtonVisibilityMap = new SparseIntArray(BUTTON_COUNT);
+
+    private CompoundButton mAudioButton;
+    private CompoundButton mMuteButton;
+    private CompoundButton mShowDialpadButton;
+    private CompoundButton mHoldButton;
+    private ImageButton mSwapButton;
+    private ImageButton mChangeToVideoButton;
+    private ImageButton mChangeToVoiceButton;
+    private CompoundButton mSwitchCameraButton;
+    private ImageButton mAddCallButton;
+    private ImageButton mMergeButton;
+    private CompoundButton mPauseVideoButton;
+    private ImageButton mOverflowButton;
+    private ImageButton mManageVideoCallConferenceButton;
+
+    private PopupMenu mAudioModePopup;
+    private boolean mAudioModePopupVisible;
+    private PopupMenu mOverflowPopup;
+
+    private int mPrevAudioMode = 0;
+
+    // Constants for Drawable.setAlpha()
+    private static final int HIDDEN = 0;
+    private static final int VISIBLE = 255;
+
+    private boolean mIsEnabled;
+    private MaterialPalette mCurrentThemeColors;
+
+    @Override
+    public CallButtonPresenter createPresenter() {
+        // TODO: find a cleaner way to include audio mode provider than having a singleton instance.
+        return new CallButtonPresenter();
+    }
+
+    @Override
+    public CallButtonPresenter.CallButtonUi getUi() {
+        return this;
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        for (int i = 0; i < BUTTON_COUNT; i++) {
+            mButtonVisibilityMap.put(i, BUTTON_HIDDEN);
+        }
+
+        mButtonMaxVisible = getResources().getInteger(R.integer.call_card_max_buttons);
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        final View parent = inflater.inflate(R.layout.call_button_fragment, container, false);
+
+        mAudioButton = (CompoundButton) parent.findViewById(R.id.audioButton);
+        mAudioButton.setOnClickListener(this);
+        mMuteButton = (CompoundButton) parent.findViewById(R.id.muteButton);
+        mMuteButton.setOnClickListener(this);
+        mShowDialpadButton = (CompoundButton) parent.findViewById(R.id.dialpadButton);
+        mShowDialpadButton.setOnClickListener(this);
+        mHoldButton = (CompoundButton) parent.findViewById(R.id.holdButton);
+        mHoldButton.setOnClickListener(this);
+        mSwapButton = (ImageButton) parent.findViewById(R.id.swapButton);
+        mSwapButton.setOnClickListener(this);
+        mChangeToVideoButton = (ImageButton) parent.findViewById(R.id.changeToVideoButton);
+        mChangeToVideoButton.setOnClickListener(this);
+        mChangeToVoiceButton = (ImageButton) parent.findViewById(R.id.changeToVoiceButton);
+        mChangeToVoiceButton.setOnClickListener(this);
+        mSwitchCameraButton = (CompoundButton) parent.findViewById(R.id.switchCameraButton);
+        mSwitchCameraButton.setOnClickListener(this);
+        mAddCallButton = (ImageButton) parent.findViewById(R.id.addButton);
+        mAddCallButton.setOnClickListener(this);
+        mMergeButton = (ImageButton) parent.findViewById(R.id.mergeButton);
+        mMergeButton.setOnClickListener(this);
+        mPauseVideoButton = (CompoundButton) parent.findViewById(R.id.pauseVideoButton);
+        mPauseVideoButton.setOnClickListener(this);
+        mOverflowButton = (ImageButton) parent.findViewById(R.id.overflowButton);
+        mOverflowButton.setOnClickListener(this);
+        mManageVideoCallConferenceButton = (ImageButton) parent.findViewById(
+                R.id.manageVideoCallConferenceButton);
+        mManageVideoCallConferenceButton.setOnClickListener(this);
+        return parent;
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+
+        // set the buttons
+        updateAudioButtons(getPresenter().getSupportedAudio());
+    }
+
+    @Override
+    public void onResume() {
+        if (getPresenter() != null) {
+            getPresenter().refreshMuteState();
+        }
+        super.onResume();
+
+        updateColors();
+    }
+
+    @Override
+    public void onClick(View view) {
+        int id = view.getId();
+        Log.d(this, "onClick(View " + view + ", id " + id + ")...");
+
+        switch (id) {
+            case R.id.audioButton:
+                onAudioButtonClicked();
+                break;
+            case R.id.addButton:
+                getPresenter().addCallClicked();
+                break;
+            case R.id.muteButton: {
+                getPresenter().muteClicked(!mMuteButton.isSelected());
+                break;
+            }
+            case R.id.mergeButton:
+                getPresenter().mergeClicked();
+                mMergeButton.setEnabled(false);
+                break;
+            case R.id.holdButton: {
+                getPresenter().holdClicked(!mHoldButton.isSelected());
+                break;
+            }
+            case R.id.swapButton:
+                getPresenter().swapClicked();
+                break;
+            case R.id.dialpadButton:
+                getPresenter().showDialpadClicked(!mShowDialpadButton.isSelected());
+                break;
+            case R.id.changeToVideoButton:
+                getPresenter().changeToVideoClicked();
+                break;
+            case R.id.changeToVoiceButton:
+                getPresenter().changeToVoiceClicked();
+                break;
+            case R.id.switchCameraButton:
+                getPresenter().switchCameraClicked(
+                        mSwitchCameraButton.isSelected() /* useFrontFacingCamera */);
+                break;
+            case R.id.pauseVideoButton:
+                getPresenter().pauseVideoClicked(
+                        !mPauseVideoButton.isSelected() /* pause */);
+                break;
+            case R.id.overflowButton:
+                if (mOverflowPopup != null) {
+                    mOverflowPopup.show();
+                }
+                break;
+            case R.id.manageVideoCallConferenceButton:
+                onManageVideoCallConferenceClicked();
+                break;
+            default:
+                Log.wtf(this, "onClick: unexpected");
+                return;
+        }
+
+        view.performHapticFeedback(
+                HapticFeedbackConstants.VIRTUAL_KEY,
+                HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING);
+    }
+
+    public void updateColors() {
+        MaterialPalette themeColors = InCallPresenter.getInstance().getThemeColors();
+
+        if (mCurrentThemeColors != null && mCurrentThemeColors.equals(themeColors)) {
+            return;
+        }
+
+        View[] compoundButtons = {
+                mAudioButton,
+                mMuteButton,
+                mShowDialpadButton,
+                mHoldButton,
+                mSwitchCameraButton,
+                mPauseVideoButton
+        };
+
+        for (View button : compoundButtons) {
+            final LayerDrawable layers = (LayerDrawable) button.getBackground();
+            final RippleDrawable btnCompoundDrawable = compoundBackgroundDrawable(themeColors);
+            layers.setDrawableByLayerId(R.id.compoundBackgroundItem, btnCompoundDrawable);
+        }
+
+        ImageButton[] normalButtons = {
+                mSwapButton,
+                mChangeToVideoButton,
+                mChangeToVoiceButton,
+                mAddCallButton,
+                mMergeButton,
+                mOverflowButton
+        };
+
+        for (ImageButton button : normalButtons) {
+            final LayerDrawable layers = (LayerDrawable) button.getBackground();
+            final RippleDrawable btnDrawable = backgroundDrawable(themeColors);
+            layers.setDrawableByLayerId(R.id.backgroundItem, btnDrawable);
+        }
+
+        mCurrentThemeColors = themeColors;
+    }
+
+    /**
+     * Generate a RippleDrawable which will be the background for a compound button, i.e.
+     * a button with pressed and unpressed states. The unpressed state will be the same color
+     * as the rest of the call card, the pressed state will be the dark version of that color.
+     */
+    private RippleDrawable compoundBackgroundDrawable(MaterialPalette palette) {
+        Resources res = getResources();
+        ColorStateList rippleColor =
+                ColorStateList.valueOf(res.getColor(R.color.incall_accent_color));
+
+        StateListDrawable stateListDrawable = new StateListDrawable();
+        addSelectedAndFocused(res, stateListDrawable);
+        addFocused(res, stateListDrawable);
+        addSelected(res, stateListDrawable, palette);
+        addUnselected(res, stateListDrawable, palette);
+
+        return new RippleDrawable(rippleColor, stateListDrawable, null);
+    }
+
+    /**
+     * Generate a RippleDrawable which will be the background of a button to ensure it
+     * is the same color as the rest of the call card.
+     */
+    private RippleDrawable backgroundDrawable(MaterialPalette palette) {
+        Resources res = getResources();
+        ColorStateList rippleColor =
+                ColorStateList.valueOf(res.getColor(R.color.incall_accent_color));
+
+        StateListDrawable stateListDrawable = new StateListDrawable();
+        addFocused(res, stateListDrawable);
+        addUnselected(res, stateListDrawable, palette);
+
+        return new RippleDrawable(rippleColor, stateListDrawable, null);
+    }
+
+    // state_selected and state_focused
+    private void addSelectedAndFocused(Resources res, StateListDrawable drawable) {
+        int[] selectedAndFocused = {android.R.attr.state_selected, android.R.attr.state_focused};
+        Drawable selectedAndFocusedDrawable = res.getDrawable(R.drawable.btn_selected_focused);
+        drawable.addState(selectedAndFocused, selectedAndFocusedDrawable);
+    }
+
+    // state_focused
+    private void addFocused(Resources res, StateListDrawable drawable) {
+        int[] focused = {android.R.attr.state_focused};
+        Drawable focusedDrawable = res.getDrawable(R.drawable.btn_unselected_focused);
+        drawable.addState(focused, focusedDrawable);
+    }
+
+    // state_selected
+    private void addSelected(Resources res, StateListDrawable drawable, MaterialPalette palette) {
+        int[] selected = {android.R.attr.state_selected};
+        LayerDrawable selectedDrawable = (LayerDrawable) res.getDrawable(R.drawable.btn_selected);
+        ((GradientDrawable) selectedDrawable.getDrawable(0)).setColor(palette.mSecondaryColor);
+        drawable.addState(selected, selectedDrawable);
+    }
+
+    // default
+    private void addUnselected(Resources res, StateListDrawable drawable, MaterialPalette palette) {
+        LayerDrawable unselectedDrawable =
+                (LayerDrawable) res.getDrawable(R.drawable.btn_unselected);
+        ((GradientDrawable) unselectedDrawable.getDrawable(0)).setColor(palette.mPrimaryColor);
+        drawable.addState(new int[0], unselectedDrawable);
+    }
+
+    @Override
+    public void setEnabled(boolean isEnabled) {
+        mIsEnabled = isEnabled;
+
+        mAudioButton.setEnabled(isEnabled);
+        mMuteButton.setEnabled(isEnabled);
+        mShowDialpadButton.setEnabled(isEnabled);
+        mHoldButton.setEnabled(isEnabled);
+        mSwapButton.setEnabled(isEnabled);
+        mChangeToVideoButton.setEnabled(isEnabled);
+        mChangeToVoiceButton.setEnabled(isEnabled);
+        mSwitchCameraButton.setEnabled(isEnabled);
+        mAddCallButton.setEnabled(isEnabled);
+        mMergeButton.setEnabled(isEnabled);
+        mPauseVideoButton.setEnabled(isEnabled);
+        mOverflowButton.setEnabled(isEnabled);
+        mManageVideoCallConferenceButton.setEnabled(isEnabled);
+    }
+
+    @Override
+    public void showButton(int buttonId, boolean show) {
+        mButtonVisibilityMap.put(buttonId, show ? BUTTON_VISIBLE : BUTTON_HIDDEN);
+    }
+
+    @Override
+    public void enableButton(int buttonId, boolean enable) {
+        final View button = getButtonById(buttonId);
+        if (button != null) {
+            button.setEnabled(enable);
+        }
+    }
+
+    private View getButtonById(int id) {
+        switch (id) {
+            case BUTTON_AUDIO:
+                return mAudioButton;
+            case BUTTON_MUTE:
+                return mMuteButton;
+            case BUTTON_DIALPAD:
+                return mShowDialpadButton;
+            case BUTTON_HOLD:
+                return mHoldButton;
+            case BUTTON_SWAP:
+                return mSwapButton;
+            case BUTTON_UPGRADE_TO_VIDEO:
+                return mChangeToVideoButton;
+            case BUTTON_DOWNGRADE_TO_AUDIO:
+                return mChangeToVoiceButton;
+            case BUTTON_SWITCH_CAMERA:
+                return mSwitchCameraButton;
+            case BUTTON_ADD_CALL:
+                return mAddCallButton;
+            case BUTTON_MERGE:
+                return mMergeButton;
+            case BUTTON_PAUSE_VIDEO:
+                return mPauseVideoButton;
+            case BUTTON_MANAGE_VIDEO_CONFERENCE:
+                return mManageVideoCallConferenceButton;
+            default:
+                Log.w(this, "Invalid button id");
+                return null;
+        }
+    }
+
+    @Override
+    public void setHold(boolean value) {
+        if (mHoldButton.isSelected() != value) {
+            mHoldButton.setSelected(value);
+            mHoldButton.setContentDescription(getContext().getString(
+                    value ? R.string.onscreenHoldText_selected
+                            : R.string.onscreenHoldText_unselected));
+        }
+    }
+
+    @Override
+    public void setCameraSwitched(boolean isBackFacingCamera) {
+        mSwitchCameraButton.setSelected(isBackFacingCamera);
+    }
+
+    @Override
+    public void setVideoPaused(boolean isPaused) {
+        mPauseVideoButton.setSelected(isPaused);
+    }
+
+    @Override
+    public void setMute(boolean value) {
+        if (mMuteButton.isSelected() != value) {
+            mMuteButton.setSelected(value);
+        }
+    }
+
+    private void addToOverflowMenu(int id, View button, PopupMenu menu) {
+        button.setVisibility(View.GONE);
+        menu.getMenu().add(Menu.NONE, id, Menu.NONE, button.getContentDescription());
+        mButtonVisibilityMap.put(id, BUTTON_MENU);
+    }
+
+    private PopupMenu getPopupMenu() {
+        return new PopupMenu(new ContextThemeWrapper(getActivity(), R.style.InCallPopupMenuStyle),
+                mOverflowButton);
+    }
+
+    /**
+     * Iterates through the list of buttons and toggles their visibility depending on the
+     * setting configured by the CallButtonPresenter. If there are more visible buttons than
+     * the allowed maximum, the excess buttons are collapsed into a single overflow menu.
+     */
+    @Override
+    public void updateButtonStates() {
+        View prevVisibleButton = null;
+        int prevVisibleId = -1;
+        PopupMenu menu = null;
+        int visibleCount = 0;
+        for (int i = 0; i < BUTTON_COUNT; i++) {
+            final int visibility = mButtonVisibilityMap.get(i);
+            final View button = getButtonById(i);
+            if (visibility == BUTTON_VISIBLE) {
+                visibleCount++;
+                if (visibleCount <= mButtonMaxVisible) {
+                    button.setVisibility(View.VISIBLE);
+                    prevVisibleButton = button;
+                    prevVisibleId = i;
+                } else {
+                    if (menu == null) {
+                        menu = getPopupMenu();
+                    }
+                    // Collapse the current button into the overflow menu. If is the first visible
+                    // button that exceeds the threshold, also collapse the previous visible button
+                    // so that the total number of visible buttons will never exceed the threshold.
+                    if (prevVisibleButton != null) {
+                        addToOverflowMenu(prevVisibleId, prevVisibleButton, menu);
+                        prevVisibleButton = null;
+                        prevVisibleId = -1;
+                    }
+                    addToOverflowMenu(i, button, menu);
+                }
+            } else if (visibility == BUTTON_HIDDEN) {
+                button.setVisibility(View.GONE);
+            }
+        }
+
+        mOverflowButton.setVisibility(menu != null ? View.VISIBLE : View.GONE);
+        if (menu != null) {
+            mOverflowPopup = menu;
+            mOverflowPopup.setOnMenuItemClickListener(new OnMenuItemClickListener() {
+                @Override
+                public boolean onMenuItemClick(MenuItem item) {
+                    final int id = item.getItemId();
+                    getButtonById(id).performClick();
+                    return true;
+                }
+            });
+        }
+    }
+
+    @Override
+    public void setAudio(int mode) {
+        updateAudioButtons(getPresenter().getSupportedAudio());
+        refreshAudioModePopup();
+
+        if (mPrevAudioMode != mode) {
+            updateAudioButtonContentDescription(mode);
+            mPrevAudioMode = mode;
+        }
+    }
+
+    @Override
+    public void setSupportedAudio(int modeMask) {
+        updateAudioButtons(modeMask);
+        refreshAudioModePopup();
+    }
+
+    @Override
+    public boolean onMenuItemClick(MenuItem item) {
+        Log.d(this, "- onMenuItemClick: " + item);
+        Log.d(this, "  id: " + item.getItemId());
+        Log.d(this, "  title: '" + item.getTitle() + "'");
+
+        int mode = CallAudioStateCompat.ROUTE_WIRED_OR_EARPIECE;
+
+        switch (item.getItemId()) {
+            case R.id.audio_mode_speaker:
+                mode = CallAudioStateCompat.ROUTE_SPEAKER;
+                break;
+            case R.id.audio_mode_earpiece:
+            case R.id.audio_mode_wired_headset:
+                // InCallCallAudioState.ROUTE_EARPIECE means either the handset earpiece,
+                // or the wired headset (if connected.)
+                mode = CallAudioStateCompat.ROUTE_WIRED_OR_EARPIECE;
+                break;
+            case R.id.audio_mode_bluetooth:
+                mode = CallAudioStateCompat.ROUTE_BLUETOOTH;
+                break;
+            default:
+                Log.e(this, "onMenuItemClick:  unexpected View ID " + item.getItemId()
+                        + " (MenuItem = '" + item + "')");
+                break;
+        }
+
+        getPresenter().setAudioMode(mode);
+
+        return true;
+    }
+
+    // PopupMenu.OnDismissListener implementation; see showAudioModePopup().
+    // This gets called when the PopupMenu gets dismissed for *any* reason, like
+    // the user tapping outside its bounds, or pressing Back, or selecting one
+    // of the menu items.
+    @Override
+    public void onDismiss(PopupMenu menu) {
+        Log.d(this, "- onDismiss: " + menu);
+        mAudioModePopupVisible = false;
+        updateAudioButtons(getPresenter().getSupportedAudio());
+    }
+
+    /**
+     * Checks for supporting modes.  If bluetooth is supported, it uses the audio
+     * pop up menu.  Otherwise, it toggles the speakerphone.
+     */
+    private void onAudioButtonClicked() {
+        Log.d(this, "onAudioButtonClicked: " +
+                CallAudioStateCompat.audioRouteToString(getPresenter().getSupportedAudio()));
+
+        if (isSupported(CallAudioStateCompat.ROUTE_BLUETOOTH)) {
+            showAudioModePopup();
+        } else {
+            getPresenter().toggleSpeakerphone();
+        }
+    }
+
+    private void onManageVideoCallConferenceClicked() {
+        Log.d(this, "onManageVideoCallConferenceClicked");
+        InCallPresenter.getInstance().showConferenceCallManager(true);
+    }
+
+    /**
+     * Refreshes the "Audio mode" popup if it's visible.  This is useful
+     * (for example) when a wired headset is plugged or unplugged,
+     * since we need to switch back and forth between the "earpiece"
+     * and "wired headset" items.
+     *
+     * This is safe to call even if the popup is already dismissed, or even if
+     * you never called showAudioModePopup() in the first place.
+     */
+    public void refreshAudioModePopup() {
+        if (mAudioModePopup != null && mAudioModePopupVisible) {
+            // Dismiss the previous one
+            mAudioModePopup.dismiss();  // safe even if already dismissed
+            // And bring up a fresh PopupMenu
+            showAudioModePopup();
+        }
+    }
+
+    /**
+     * Updates the audio button so that the appriopriate visual layers
+     * are visible based on the supported audio formats.
+     */
+    private void updateAudioButtons(int supportedModes) {
+        final boolean bluetoothSupported = isSupported(CallAudioStateCompat.ROUTE_BLUETOOTH);
+        final boolean speakerSupported = isSupported(CallAudioStateCompat.ROUTE_SPEAKER);
+
+        boolean audioButtonEnabled = false;
+        boolean audioButtonChecked = false;
+        boolean showMoreIndicator = false;
+
+        boolean showBluetoothIcon = false;
+        boolean showSpeakerphoneIcon = false;
+        boolean showHandsetIcon = false;
+
+        boolean showToggleIndicator = false;
+
+        if (bluetoothSupported) {
+            Log.d(this, "updateAudioButtons - popup menu mode");
+
+            audioButtonEnabled = true;
+            audioButtonChecked = true;
+            showMoreIndicator = true;
+
+            // Update desired layers:
+            if (isAudio(CallAudioStateCompat.ROUTE_BLUETOOTH)) {
+                showBluetoothIcon = true;
+            } else if (isAudio(CallAudioStateCompat.ROUTE_SPEAKER)) {
+                showSpeakerphoneIcon = true;
+            } else {
+                showHandsetIcon = true;
+                // TODO: if a wired headset is plugged in, that takes precedence
+                // over the handset earpiece.  If so, maybe we should show some
+                // sort of "wired headset" icon here instead of the "handset
+                // earpiece" icon.  (Still need an asset for that, though.)
+            }
+
+            // The audio button is NOT a toggle in this state, so set selected to false.
+            mAudioButton.setSelected(false);
+        } else if (speakerSupported) {
+            Log.d(this, "updateAudioButtons - speaker toggle mode");
+
+            audioButtonEnabled = true;
+
+            // The audio button *is* a toggle in this state, and indicated the
+            // current state of the speakerphone.
+            audioButtonChecked = isAudio(CallAudioStateCompat.ROUTE_SPEAKER);
+            mAudioButton.setSelected(audioButtonChecked);
+
+            // update desired layers:
+            showToggleIndicator = true;
+            showSpeakerphoneIcon = true;
+        } else {
+            Log.d(this, "updateAudioButtons - disabled...");
+
+            // The audio button is a toggle in this state, but that's mostly
+            // irrelevant since it's always disabled and unchecked.
+            audioButtonEnabled = false;
+            audioButtonChecked = false;
+            mAudioButton.setSelected(false);
+
+            // update desired layers:
+            showToggleIndicator = true;
+            showSpeakerphoneIcon = true;
+        }
+
+        // Finally, update it all!
+
+        Log.v(this, "audioButtonEnabled: " + audioButtonEnabled);
+        Log.v(this, "audioButtonChecked: " + audioButtonChecked);
+        Log.v(this, "showMoreIndicator: " + showMoreIndicator);
+        Log.v(this, "showBluetoothIcon: " + showBluetoothIcon);
+        Log.v(this, "showSpeakerphoneIcon: " + showSpeakerphoneIcon);
+        Log.v(this, "showHandsetIcon: " + showHandsetIcon);
+
+        // Only enable the audio button if the fragment is enabled.
+        mAudioButton.setEnabled(audioButtonEnabled && mIsEnabled);
+        mAudioButton.setChecked(audioButtonChecked);
+
+        final LayerDrawable layers = (LayerDrawable) mAudioButton.getBackground();
+        Log.d(this, "'layers' drawable: " + layers);
+
+        layers.findDrawableByLayerId(R.id.compoundBackgroundItem)
+                .setAlpha(showToggleIndicator ? VISIBLE : HIDDEN);
+
+        layers.findDrawableByLayerId(R.id.moreIndicatorItem)
+                .setAlpha(showMoreIndicator ? VISIBLE : HIDDEN);
+
+        layers.findDrawableByLayerId(R.id.bluetoothItem)
+                .setAlpha(showBluetoothIcon ? VISIBLE : HIDDEN);
+
+        layers.findDrawableByLayerId(R.id.handsetItem)
+                .setAlpha(showHandsetIcon ? VISIBLE : HIDDEN);
+
+        layers.findDrawableByLayerId(R.id.speakerphoneItem)
+                .setAlpha(showSpeakerphoneIcon ? VISIBLE : HIDDEN);
+
+    }
+
+    /**
+     * Update the content description of the audio button.
+     */
+    private void updateAudioButtonContentDescription(int mode) {
+        int stringId = 0;
+
+        // If bluetooth is not supported, the audio buttion will toggle, so use the label "speaker".
+        // Otherwise, use the label of the currently selected audio mode.
+        if (!isSupported(CallAudioStateCompat.ROUTE_BLUETOOTH)) {
+            stringId = R.string.audio_mode_speaker;
+        } else {
+            switch (mode) {
+                case CallAudioStateCompat.ROUTE_EARPIECE:
+                    stringId = R.string.audio_mode_earpiece;
+                    break;
+                case CallAudioStateCompat.ROUTE_BLUETOOTH:
+                    stringId = R.string.audio_mode_bluetooth;
+                    break;
+                case CallAudioStateCompat.ROUTE_WIRED_HEADSET:
+                    stringId = R.string.audio_mode_wired_headset;
+                    break;
+                case CallAudioStateCompat.ROUTE_SPEAKER:
+                    stringId = R.string.audio_mode_speaker;
+                    break;
+            }
+        }
+
+        if (stringId != 0) {
+            mAudioButton.setContentDescription(getResources().getString(stringId));
+        }
+    }
+
+    private void showAudioModePopup() {
+        Log.d(this, "showAudioPopup()...");
+
+        final ContextThemeWrapper contextWrapper = new ContextThemeWrapper(getActivity(),
+                R.style.InCallPopupMenuStyle);
+        mAudioModePopup = new PopupMenu(contextWrapper, mAudioButton /* anchorView */);
+        mAudioModePopup.getMenuInflater().inflate(R.menu.incall_audio_mode_menu,
+                mAudioModePopup.getMenu());
+        mAudioModePopup.setOnMenuItemClickListener(this);
+        mAudioModePopup.setOnDismissListener(this);
+
+        final Menu menu = mAudioModePopup.getMenu();
+
+        // TODO: Still need to have the "currently active" audio mode come
+        // up pre-selected (or focused?) with a blue highlight.  Still
+        // need exact visual design, and possibly framework support for this.
+        // See comments below for the exact logic.
+
+        final MenuItem speakerItem = menu.findItem(R.id.audio_mode_speaker);
+        speakerItem.setEnabled(isSupported(CallAudioStateCompat.ROUTE_SPEAKER));
+        // TODO: Show speakerItem as initially "selected" if
+        // speaker is on.
+
+        // We display *either* "earpiece" or "wired headset", never both,
+        // depending on whether a wired headset is physically plugged in.
+        final MenuItem earpieceItem = menu.findItem(R.id.audio_mode_earpiece);
+        final MenuItem wiredHeadsetItem = menu.findItem(R.id.audio_mode_wired_headset);
+
+        final boolean usingHeadset = isSupported(CallAudioStateCompat.ROUTE_WIRED_HEADSET);
+        earpieceItem.setVisible(!usingHeadset);
+        earpieceItem.setEnabled(!usingHeadset);
+        wiredHeadsetItem.setVisible(usingHeadset);
+        wiredHeadsetItem.setEnabled(usingHeadset);
+        // TODO: Show the above item (either earpieceItem or wiredHeadsetItem)
+        // as initially "selected" if speakerOn and
+        // bluetoothIndicatorOn are both false.
+
+        final MenuItem bluetoothItem = menu.findItem(R.id.audio_mode_bluetooth);
+        bluetoothItem.setEnabled(isSupported(CallAudioStateCompat.ROUTE_BLUETOOTH));
+        // TODO: Show bluetoothItem as initially "selected" if
+        // bluetoothIndicatorOn is true.
+
+        mAudioModePopup.show();
+
+        // Unfortunately we need to manually keep track of the popup menu's
+        // visiblity, since PopupMenu doesn't have an isShowing() method like
+        // Dialogs do.
+        mAudioModePopupVisible = true;
+    }
+
+    private boolean isSupported(int mode) {
+        return (mode == (getPresenter().getSupportedAudio() & mode));
+    }
+
+    private boolean isAudio(int mode) {
+        return (mode == getPresenter().getAudioMode());
+    }
+
+    @Override
+    public void displayDialpad(boolean value, boolean animate) {
+        if (getActivity() != null && getActivity() instanceof InCallActivity) {
+            boolean changed = ((InCallActivity) getActivity()).showDialpadFragment(value, animate);
+            if (changed) {
+                mShowDialpadButton.setSelected(value);
+            }
+        }
+    }
+
+    @Override
+    public boolean isDialpadVisible() {
+        if (getActivity() != null && getActivity() instanceof InCallActivity) {
+            return ((InCallActivity) getActivity()).isDialpadVisible();
+        }
+        return false;
+    }
+
+    @Override
+    public Context getContext() {
+        return getActivity();
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/CallButtonPresenter.java b/InCallUI/src/com/android/incallui/CallButtonPresenter.java
new file mode 100644
index 0000000..dde6295
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/CallButtonPresenter.java
@@ -0,0 +1,483 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_ADD_CALL;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_AUDIO;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_DIALPAD;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_DOWNGRADE_TO_AUDIO;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_HOLD;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_MERGE;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_MUTE;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_PAUSE_VIDEO;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_SWAP;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_SWITCH_CAMERA;
+import static com.android.incallui.CallButtonFragment.Buttons.BUTTON_UPGRADE_TO_VIDEO;
+
+import android.content.Context;
+import android.os.Build;
+import android.os.Bundle;
+import android.telecom.InCallService.VideoCall;
+import android.telecom.VideoProfile;
+
+import com.android.contacts.common.compat.CallSdkCompat;
+import com.android.contacts.common.compat.SdkVersionOverride;
+import com.android.dialer.compat.CallAudioStateCompat;
+import com.android.dialer.compat.UserManagerCompat;
+import com.android.incallui.AudioModeProvider.AudioModeListener;
+import com.android.incallui.InCallCameraManager.Listener;
+import com.android.incallui.InCallPresenter.CanAddCallListener;
+import com.android.incallui.InCallPresenter.InCallDetailsListener;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.incallui.InCallPresenter.IncomingCallListener;
+
+/**
+ * Logic for call buttons.
+ */
+public class CallButtonPresenter extends Presenter<CallButtonPresenter.CallButtonUi>
+        implements InCallStateListener, AudioModeListener, IncomingCallListener,
+        InCallDetailsListener, CanAddCallListener, Listener {
+
+    private static final String KEY_AUTOMATICALLY_MUTED = "incall_key_automatically_muted";
+    private static final String KEY_PREVIOUS_MUTE_STATE = "incall_key_previous_mute_state";
+
+    private Call mCall;
+    private boolean mAutomaticallyMuted = false;
+    private boolean mPreviousMuteState = false;
+
+    public CallButtonPresenter() {
+    }
+
+    @Override
+    public void onUiReady(CallButtonUi ui) {
+        super.onUiReady(ui);
+
+        AudioModeProvider.getInstance().addListener(this);
+
+        // register for call state changes last
+        final InCallPresenter inCallPresenter = InCallPresenter.getInstance();
+        inCallPresenter.addListener(this);
+        inCallPresenter.addIncomingCallListener(this);
+        inCallPresenter.addDetailsListener(this);
+        inCallPresenter.addCanAddCallListener(this);
+        inCallPresenter.getInCallCameraManager().addCameraSelectionListener(this);
+
+        // Update the buttons state immediately for the current call
+        onStateChange(InCallState.NO_CALLS, inCallPresenter.getInCallState(),
+                CallList.getInstance());
+    }
+
+    @Override
+    public void onUiUnready(CallButtonUi ui) {
+        super.onUiUnready(ui);
+
+        InCallPresenter.getInstance().removeListener(this);
+        AudioModeProvider.getInstance().removeListener(this);
+        InCallPresenter.getInstance().removeIncomingCallListener(this);
+        InCallPresenter.getInstance().removeDetailsListener(this);
+        InCallPresenter.getInstance().getInCallCameraManager().removeCameraSelectionListener(this);
+        InCallPresenter.getInstance().removeCanAddCallListener(this);
+    }
+
+    @Override
+    public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+        CallButtonUi ui = getUi();
+
+        if (newState == InCallState.OUTGOING) {
+            mCall = callList.getOutgoingCall();
+        } else if (newState == InCallState.INCALL) {
+            mCall = callList.getActiveOrBackgroundCall();
+
+            // When connected to voice mail, automatically shows the dialpad.
+            // (On previous releases we showed it when in-call shows up, before waiting for
+            // OUTGOING.  We may want to do that once we start showing "Voice mail" label on
+            // the dialpad too.)
+            if (ui != null) {
+                if (oldState == InCallState.OUTGOING && mCall != null) {
+                    if (CallerInfoUtils.isVoiceMailNumber(ui.getContext(), mCall)) {
+                        ui.displayDialpad(true /* show */, true /* animate */);
+                    }
+                }
+            }
+        } else if (newState == InCallState.INCOMING) {
+            if (ui != null) {
+                ui.displayDialpad(false /* show */, true /* animate */);
+            }
+            mCall = callList.getIncomingCall();
+        } else {
+            mCall = null;
+        }
+        updateUi(newState, mCall);
+    }
+
+    /**
+     * Updates the user interface in response to a change in the details of a call.
+     * Currently handles changes to the call buttons in response to a change in the details for a
+     * call.  This is important to ensure changes to the active call are reflected in the available
+     * buttons.
+     *
+     * @param call The active call.
+     * @param details The call details.
+     */
+    @Override
+    public void onDetailsChanged(Call call, android.telecom.Call.Details details) {
+        // Only update if the changes are for the currently active call
+        if (getUi() != null && call != null && call.equals(mCall)) {
+            updateButtonsState(call);
+        }
+    }
+
+    @Override
+    public void onIncomingCall(InCallState oldState, InCallState newState, Call call) {
+        onStateChange(oldState, newState, CallList.getInstance());
+    }
+
+    @Override
+    public void onCanAddCallChanged(boolean canAddCall) {
+        if (getUi() != null && mCall != null) {
+            updateButtonsState(mCall);
+        }
+    }
+
+    @Override
+    public void onAudioMode(int mode) {
+        if (getUi() != null) {
+            getUi().setAudio(mode);
+        }
+    }
+
+    @Override
+    public void onSupportedAudioMode(int mask) {
+        if (getUi() != null) {
+            getUi().setSupportedAudio(mask);
+        }
+    }
+
+    @Override
+    public void onMute(boolean muted) {
+        if (getUi() != null && !mAutomaticallyMuted) {
+            getUi().setMute(muted);
+        }
+    }
+
+    public int getAudioMode() {
+        return AudioModeProvider.getInstance().getAudioMode();
+    }
+
+    public int getSupportedAudio() {
+        return AudioModeProvider.getInstance().getSupportedModes();
+    }
+
+    public void setAudioMode(int mode) {
+
+        // TODO: Set a intermediate state in this presenter until we get
+        // an update for onAudioMode().  This will make UI response immediate
+        // if it turns out to be slow
+
+        Log.d(this, "Sending new Audio Mode: " + CallAudioStateCompat.audioRouteToString(mode));
+        TelecomAdapter.getInstance().setAudioRoute(mode);
+    }
+
+    /**
+     * Function assumes that bluetooth is not supported.
+     */
+    public void toggleSpeakerphone() {
+        // this function should not be called if bluetooth is available
+        if (0 != (CallAudioStateCompat.ROUTE_BLUETOOTH & getSupportedAudio())) {
+
+            // It's clear the UI is wrong, so update the supported mode once again.
+            Log.e(this, "toggling speakerphone not allowed when bluetooth supported.");
+            getUi().setSupportedAudio(getSupportedAudio());
+            return;
+        }
+
+        int newMode = CallAudioStateCompat.ROUTE_SPEAKER;
+
+        // if speakerphone is already on, change to wired/earpiece
+        if (getAudioMode() == CallAudioStateCompat.ROUTE_SPEAKER) {
+            newMode = CallAudioStateCompat.ROUTE_WIRED_OR_EARPIECE;
+        }
+
+        setAudioMode(newMode);
+    }
+
+    public void muteClicked(boolean checked) {
+        Log.d(this, "turning on mute: " + checked);
+        TelecomAdapter.getInstance().mute(checked);
+    }
+
+    public void holdClicked(boolean checked) {
+        if (mCall == null) {
+            return;
+        }
+        if (checked) {
+            Log.i(this, "Putting the call on hold: " + mCall);
+            TelecomAdapter.getInstance().holdCall(mCall.getId());
+        } else {
+            Log.i(this, "Removing the call from hold: " + mCall);
+            TelecomAdapter.getInstance().unholdCall(mCall.getId());
+        }
+    }
+
+    public void swapClicked() {
+        if (mCall == null) {
+            return;
+        }
+
+        Log.i(this, "Swapping the call: " + mCall);
+        TelecomAdapter.getInstance().swap(mCall.getId());
+    }
+
+    public void mergeClicked() {
+        TelecomAdapter.getInstance().merge(mCall.getId());
+    }
+
+    public void addCallClicked() {
+        // Automatically mute the current call
+        mAutomaticallyMuted = true;
+        mPreviousMuteState = AudioModeProvider.getInstance().getMute();
+        // Simulate a click on the mute button
+        muteClicked(true);
+        TelecomAdapter.getInstance().addCall();
+    }
+
+    public void changeToVoiceClicked() {
+        VideoCall videoCall = mCall.getVideoCall();
+        if (videoCall == null) {
+            return;
+        }
+
+        VideoProfile videoProfile = new VideoProfile(VideoProfile.STATE_AUDIO_ONLY);
+        videoCall.sendSessionModifyRequest(videoProfile);
+    }
+
+    public void showDialpadClicked(boolean checked) {
+        Log.v(this, "Show dialpad " + String.valueOf(checked));
+        getUi().displayDialpad(checked /* show */, true /* animate */);
+    }
+
+    public void changeToVideoClicked() {
+        VideoCall videoCall = mCall.getVideoCall();
+        if (videoCall == null) {
+            return;
+        }
+        int currVideoState = mCall.getVideoState();
+        int currUnpausedVideoState = VideoUtils.getUnPausedVideoState(currVideoState);
+        currUnpausedVideoState |= VideoProfile.STATE_BIDIRECTIONAL;
+
+        VideoProfile videoProfile = new VideoProfile(currUnpausedVideoState);
+        videoCall.sendSessionModifyRequest(videoProfile);
+        mCall.setSessionModificationState(Call.SessionModificationState.WAITING_FOR_RESPONSE);
+    }
+
+    /**
+     * Switches the camera between the front-facing and back-facing camera.
+     * @param useFrontFacingCamera True if we should switch to using the front-facing camera, or
+     *     false if we should switch to using the back-facing camera.
+     */
+    public void switchCameraClicked(boolean useFrontFacingCamera) {
+        InCallCameraManager cameraManager = InCallPresenter.getInstance().getInCallCameraManager();
+        cameraManager.setUseFrontFacingCamera(useFrontFacingCamera);
+
+        VideoCall videoCall = mCall.getVideoCall();
+        if (videoCall == null) {
+            return;
+        }
+
+        String cameraId = cameraManager.getActiveCameraId();
+        if (cameraId != null) {
+            final int cameraDir = cameraManager.isUsingFrontFacingCamera()
+                    ? Call.VideoSettings.CAMERA_DIRECTION_FRONT_FACING
+                    : Call.VideoSettings.CAMERA_DIRECTION_BACK_FACING;
+            mCall.getVideoSettings().setCameraDir(cameraDir);
+            videoCall.setCamera(cameraId);
+            videoCall.requestCameraCapabilities();
+        }
+    }
+
+
+    /**
+     * Stop or start client's video transmission.
+     * @param pause True if pausing the local user's video, or false if starting the local user's
+     *    video.
+     */
+    public void pauseVideoClicked(boolean pause) {
+        VideoCall videoCall = mCall.getVideoCall();
+        if (videoCall == null) {
+            return;
+        }
+
+        if (pause) {
+            videoCall.setCamera(null);
+            VideoProfile videoProfile = new VideoProfile(
+                    mCall.getVideoState() & ~VideoProfile.STATE_TX_ENABLED);
+            videoCall.sendSessionModifyRequest(videoProfile);
+        } else {
+            InCallCameraManager cameraManager = InCallPresenter.getInstance().
+                    getInCallCameraManager();
+            videoCall.setCamera(cameraManager.getActiveCameraId());
+            VideoProfile videoProfile = new VideoProfile(
+                    mCall.getVideoState() | VideoProfile.STATE_TX_ENABLED);
+            videoCall.sendSessionModifyRequest(videoProfile);
+            mCall.setSessionModificationState(Call.SessionModificationState.WAITING_FOR_RESPONSE);
+        }
+        getUi().setVideoPaused(pause);
+    }
+
+    private void updateUi(InCallState state, Call call) {
+        Log.d(this, "Updating call UI for call: ", call);
+
+        final CallButtonUi ui = getUi();
+        if (ui == null) {
+            return;
+        }
+
+        final boolean isEnabled =
+                state.isConnectingOrConnected() &&!state.isIncoming() && call != null;
+        ui.setEnabled(isEnabled);
+
+        if (call == null) {
+            return;
+        }
+
+        updateButtonsState(call);
+    }
+
+    /**
+     * Updates the buttons applicable for the UI.
+     *
+     * @param call The active call.
+     */
+    private void updateButtonsState(Call call) {
+        Log.v(this, "updateButtonsState");
+        final CallButtonUi ui = getUi();
+
+        final boolean isVideo = VideoUtils.isVideoCall(call);
+
+        // Common functionality (audio, hold, etc).
+        // Show either HOLD or SWAP, but not both. If neither HOLD or SWAP is available:
+        //     (1) If the device normally can hold, show HOLD in a disabled state.
+        //     (2) If the device doesn't have the concept of hold/swap, remove the button.
+        final boolean showSwap = call.can(
+                android.telecom.Call.Details.CAPABILITY_SWAP_CONFERENCE);
+        final boolean showHold = !showSwap
+                && call.can(android.telecom.Call.Details.CAPABILITY_SUPPORT_HOLD)
+                && call.can(android.telecom.Call.Details.CAPABILITY_HOLD);
+        final boolean isCallOnHold = call.getState() == Call.State.ONHOLD;
+
+        final boolean showAddCall = TelecomAdapter.getInstance().canAddCall(call)
+                && UserManagerCompat.isUserUnlocked(ui.getContext());
+        final boolean showMerge = call.can(
+                android.telecom.Call.Details.CAPABILITY_MERGE_CONFERENCE);
+        final boolean showUpgradeToVideo = !isVideo && hasVideoCallCapabilities(call);
+        final boolean showDowngradeToAudio = isVideo && isDowngradeToAudioSupported(call);
+        final boolean showMute = call.can(android.telecom.Call.Details.CAPABILITY_MUTE);
+
+        ui.showButton(BUTTON_AUDIO, true);
+        ui.showButton(BUTTON_SWAP, showSwap);
+        ui.showButton(BUTTON_HOLD, showHold);
+        ui.setHold(isCallOnHold);
+        ui.showButton(BUTTON_MUTE, showMute);
+        ui.showButton(BUTTON_ADD_CALL, showAddCall);
+        ui.showButton(BUTTON_UPGRADE_TO_VIDEO, showUpgradeToVideo);
+        ui.showButton(BUTTON_DOWNGRADE_TO_AUDIO, showDowngradeToAudio);
+        ui.showButton(BUTTON_SWITCH_CAMERA, isVideo);
+        ui.showButton(BUTTON_PAUSE_VIDEO, isVideo);
+        ui.showButton(BUTTON_DIALPAD, true);
+        ui.showButton(BUTTON_MERGE, showMerge);
+
+        ui.updateButtonStates();
+    }
+
+    private boolean hasVideoCallCapabilities(Call call) {
+        if (SdkVersionOverride.getSdkVersion(Build.VERSION_CODES.M) >= Build.VERSION_CODES.M) {
+            return call.can(android.telecom.Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_TX)
+                    && call.can(android.telecom.Call.Details.CAPABILITY_SUPPORTS_VT_REMOTE_RX);
+        }
+        // In L, this single flag represents both video transmitting and receiving capabilities
+        return call.can(android.telecom.Call.Details.CAPABILITY_SUPPORTS_VT_LOCAL_TX);
+    }
+
+    /**
+     * Determines if downgrading from a video call to an audio-only call is supported.  In order to
+     * support downgrade to audio, the SDK version must be >= N and the call should NOT have the
+     * {@link android.telecom.Call.Details#CAPABILITY_CANNOT_DOWNGRADE_VIDEO_TO_AUDIO}.
+     * @param call The call.
+     * @return {@code true} if downgrading to an audio-only call from a video call is supported.
+     */
+    private boolean isDowngradeToAudioSupported(Call call) {
+        return !call.can(CallSdkCompat.Details.CAPABILITY_CANNOT_DOWNGRADE_VIDEO_TO_AUDIO);
+    }
+
+    public void refreshMuteState() {
+        // Restore the previous mute state
+        if (mAutomaticallyMuted &&
+                AudioModeProvider.getInstance().getMute() != mPreviousMuteState) {
+            if (getUi() == null) {
+                return;
+            }
+            muteClicked(mPreviousMuteState);
+        }
+        mAutomaticallyMuted = false;
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putBoolean(KEY_AUTOMATICALLY_MUTED, mAutomaticallyMuted);
+        outState.putBoolean(KEY_PREVIOUS_MUTE_STATE, mPreviousMuteState);
+    }
+
+    @Override
+    public void onRestoreInstanceState(Bundle savedInstanceState) {
+        mAutomaticallyMuted =
+                savedInstanceState.getBoolean(KEY_AUTOMATICALLY_MUTED, mAutomaticallyMuted);
+        mPreviousMuteState =
+                savedInstanceState.getBoolean(KEY_PREVIOUS_MUTE_STATE, mPreviousMuteState);
+        super.onRestoreInstanceState(savedInstanceState);
+    }
+
+    public interface CallButtonUi extends Ui {
+        void showButton(int buttonId, boolean show);
+        void enableButton(int buttonId, boolean enable);
+        void setEnabled(boolean on);
+        void setMute(boolean on);
+        void setHold(boolean on);
+        void setCameraSwitched(boolean isBackFacingCamera);
+        void setVideoPaused(boolean isPaused);
+        void setAudio(int mode);
+        void setSupportedAudio(int mask);
+        void displayDialpad(boolean on, boolean animate);
+        boolean isDialpadVisible();
+
+        /**
+         * Once showButton() has been called on each of the individual buttons in the UI, call
+         * this to configure the overflow menu appropriately.
+         */
+        void updateButtonStates();
+        Context getContext();
+    }
+
+    @Override
+    public void onActiveCameraSelectionChanged(boolean isUsingFrontFacingCamera) {
+        if (getUi() == null) {
+            return;
+        }
+        getUi().setCameraSwitched(!isUsingFrontFacingCamera);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/CallCardFragment.java b/InCallUI/src/com/android/incallui/CallCardFragment.java
new file mode 100644
index 0000000..1a9f283
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/CallCardFragment.java
@@ -0,0 +1,1467 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.drawable.AnimationDrawable;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.GradientDrawable;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Trace;
+import android.support.v4.graphics.drawable.RoundedBitmapDrawable;
+import android.support.v4.graphics.drawable.RoundedBitmapDrawableFactory;
+import android.telecom.DisconnectCause;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+import android.text.format.DateUtils;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnLayoutChangeListener;
+import android.view.ViewGroup;
+import android.view.ViewPropertyAnimator;
+import android.view.ViewTreeObserver;
+import android.view.ViewTreeObserver.OnGlobalLayoutListener;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.ImageButton;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.ListAdapter;
+import android.widget.ListView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import com.android.contacts.common.compat.PhoneNumberUtilsCompat;
+import com.android.contacts.common.util.MaterialColorMapUtils.MaterialPalette;
+import com.android.contacts.common.widget.FloatingActionButtonController;
+import com.android.phone.common.animation.AnimUtils;
+
+import java.util.List;
+
+/**
+ * Fragment for call card.
+ */
+public class CallCardFragment extends BaseFragment<CallCardPresenter, CallCardPresenter.CallCardUi>
+        implements CallCardPresenter.CallCardUi {
+    private static final String TAG = "CallCardFragment";
+
+    /**
+     * Internal class which represents the call state label which is to be applied.
+     */
+    private class CallStateLabel {
+        private CharSequence mCallStateLabel;
+        private boolean mIsAutoDismissing;
+
+        public CallStateLabel(CharSequence callStateLabel, boolean isAutoDismissing) {
+            mCallStateLabel = callStateLabel;
+            mIsAutoDismissing = isAutoDismissing;
+        }
+
+        public CharSequence getCallStateLabel() {
+            return mCallStateLabel;
+        }
+
+        /**
+         * Determines if the call state label should auto-dismiss.
+         *
+         * @return {@code true} if the call state label should auto-dismiss.
+         */
+        public boolean isAutoDismissing() {
+            return mIsAutoDismissing;
+        }
+    };
+
+    private static final String IS_DIALPAD_SHOWING_KEY = "is_dialpad_showing";
+
+    /**
+     * The duration of time (in milliseconds) a call state label should remain visible before
+     * resetting to its previous value.
+     */
+    private static final long CALL_STATE_LABEL_RESET_DELAY_MS = 3000;
+    /**
+     * Amount of time to wait before sending an announcement via the accessibility manager.
+     * When the call state changes to an outgoing or incoming state for the first time, the
+     * UI can often be changing due to call updates or contact lookup. This allows the UI
+     * to settle to a stable state to ensure that the correct information is announced.
+     */
+    private static final long ACCESSIBILITY_ANNOUNCEMENT_DELAY_MS = 500;
+
+    private AnimatorSet mAnimatorSet;
+    private int mShrinkAnimationDuration;
+    private int mFabNormalDiameter;
+    private int mFabSmallDiameter;
+    private boolean mIsLandscape;
+    private boolean mIsDialpadShowing;
+
+    // Primary caller info
+    private TextView mPhoneNumber;
+    private TextView mNumberLabel;
+    private TextView mPrimaryName;
+    private View mCallStateButton;
+    private ImageView mCallStateIcon;
+    private ImageView mCallStateVideoCallIcon;
+    private TextView mCallStateLabel;
+    private TextView mCallTypeLabel;
+    private ImageView mHdAudioIcon;
+    private ImageView mForwardIcon;
+    private View mCallNumberAndLabel;
+    private TextView mElapsedTime;
+    private Drawable mPrimaryPhotoDrawable;
+    private TextView mCallSubject;
+    private ImageView mWorkProfileIcon;
+
+    // Container view that houses the entire primary call card, including the call buttons
+    private View mPrimaryCallCardContainer;
+    // Container view that houses the primary call information
+    private ViewGroup mPrimaryCallInfo;
+    private View mCallButtonsContainer;
+    private ImageView mPhotoSmall;
+
+    // Secondary caller info
+    private View mSecondaryCallInfo;
+    private TextView mSecondaryCallName;
+    private View mSecondaryCallProviderInfo;
+    private TextView mSecondaryCallProviderLabel;
+    private View mSecondaryCallConferenceCallIcon;
+    private View mSecondaryCallVideoCallIcon;
+    private View mProgressSpinner;
+
+    // Call card content
+    private View mCallCardContent;
+    private ImageView mPhotoLarge;
+    private View mContactContext;
+    private TextView mContactContextTitle;
+    private ListView mContactContextListView;
+    private LinearLayout mContactContextListHeaders;
+
+    private View mManageConferenceCallButton;
+
+    // Dark number info bar
+    private TextView mInCallMessageLabel;
+
+    private FloatingActionButtonController mFloatingActionButtonController;
+    private View mFloatingActionButtonContainer;
+    private ImageButton mFloatingActionButton;
+    private int mFloatingActionButtonVerticalOffset;
+
+    private float mTranslationOffset;
+    private Animation mPulseAnimation;
+
+    private int mVideoAnimationDuration;
+    // Whether or not the call card is currently in the process of an animation
+    private boolean mIsAnimating;
+
+    private MaterialPalette mCurrentThemeColors;
+
+    /**
+     * Call state label to set when an auto-dismissing call state label is dismissed.
+     */
+    private CharSequence mPostResetCallStateLabel;
+    private boolean mCallStateLabelResetPending = false;
+    private Handler mHandler;
+
+    /**
+     * Determines if secondary call info is populated in the secondary call info UI.
+     */
+    private boolean mHasSecondaryCallInfo = false;
+
+    @Override
+    public CallCardPresenter.CallCardUi getUi() {
+        return this;
+    }
+
+    @Override
+    public CallCardPresenter createPresenter() {
+        return new CallCardPresenter();
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        mHandler = new Handler(Looper.getMainLooper());
+        mShrinkAnimationDuration = getResources().getInteger(R.integer.shrink_animation_duration);
+        mVideoAnimationDuration = getResources().getInteger(R.integer.video_animation_duration);
+        mFloatingActionButtonVerticalOffset = getResources().getDimensionPixelOffset(
+                R.dimen.floating_action_button_vertical_offset);
+        mFabNormalDiameter = getResources().getDimensionPixelOffset(
+                R.dimen.end_call_floating_action_button_diameter);
+        mFabSmallDiameter = getResources().getDimensionPixelOffset(
+                R.dimen.end_call_floating_action_button_small_diameter);
+
+        if (savedInstanceState != null) {
+            mIsDialpadShowing = savedInstanceState.getBoolean(IS_DIALPAD_SHOWING_KEY, false);
+        }
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+
+        final CallList calls = CallList.getInstance();
+        final Call call = calls.getFirstCall();
+        getPresenter().init(getActivity(), call);
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        outState.putBoolean(IS_DIALPAD_SHOWING_KEY, mIsDialpadShowing);
+        super.onSaveInstanceState(outState);
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        Trace.beginSection(TAG + " onCreate");
+        mTranslationOffset =
+                getResources().getDimensionPixelSize(R.dimen.call_card_anim_translate_y_offset);
+        final View view = inflater.inflate(R.layout.call_card_fragment, container, false);
+        Trace.endSection();
+        return view;
+    }
+
+    @Override
+    public void onViewCreated(View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+        mPulseAnimation =
+                AnimationUtils.loadAnimation(view.getContext(), R.anim.call_status_pulse);
+
+        mPhoneNumber = (TextView) view.findViewById(R.id.phoneNumber);
+        mPrimaryName = (TextView) view.findViewById(R.id.name);
+        mNumberLabel = (TextView) view.findViewById(R.id.label);
+        mSecondaryCallInfo = view.findViewById(R.id.secondary_call_info);
+        mSecondaryCallProviderInfo = view.findViewById(R.id.secondary_call_provider_info);
+        mCallCardContent = view.findViewById(R.id.call_card_content);
+        mPhotoLarge = (ImageView) view.findViewById(R.id.photoLarge);
+        mPhotoLarge.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                getPresenter().onContactPhotoClick();
+            }
+        });
+
+        mContactContext = view.findViewById(R.id.contact_context);
+        mContactContextTitle = (TextView) view.findViewById(R.id.contactContextTitle);
+        mContactContextListView = (ListView) view.findViewById(R.id.contactContextInfo);
+        // This layout stores all the list header layouts so they can be easily removed.
+        mContactContextListHeaders = new LinearLayout(getView().getContext());
+        mContactContextListView.addHeaderView(mContactContextListHeaders);
+
+        mCallStateIcon = (ImageView) view.findViewById(R.id.callStateIcon);
+        mCallStateVideoCallIcon = (ImageView) view.findViewById(R.id.videoCallIcon);
+        mWorkProfileIcon = (ImageView) view.findViewById(R.id.workProfileIcon);
+        mCallStateLabel = (TextView) view.findViewById(R.id.callStateLabel);
+        mHdAudioIcon = (ImageView) view.findViewById(R.id.hdAudioIcon);
+        mForwardIcon = (ImageView) view.findViewById(R.id.forwardIcon);
+        mCallNumberAndLabel = view.findViewById(R.id.labelAndNumber);
+        mCallTypeLabel = (TextView) view.findViewById(R.id.callTypeLabel);
+        mElapsedTime = (TextView) view.findViewById(R.id.elapsedTime);
+        mPrimaryCallCardContainer = view.findViewById(R.id.primary_call_info_container);
+        mPrimaryCallInfo = (ViewGroup) view.findViewById(R.id.primary_call_banner);
+        mCallButtonsContainer = view.findViewById(R.id.callButtonFragment);
+        mPhotoSmall = (ImageView) view.findViewById(R.id.photoSmall);
+        mPhotoSmall.setVisibility(View.GONE);
+        mInCallMessageLabel = (TextView) view.findViewById(R.id.connectionServiceMessage);
+        mProgressSpinner = view.findViewById(R.id.progressSpinner);
+
+        mFloatingActionButtonContainer = view.findViewById(
+                R.id.floating_end_call_action_button_container);
+        mFloatingActionButton = (ImageButton) view.findViewById(
+                R.id.floating_end_call_action_button);
+        mFloatingActionButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                getPresenter().endCallClicked();
+            }
+        });
+        mFloatingActionButtonController = new FloatingActionButtonController(getActivity(),
+                mFloatingActionButtonContainer, mFloatingActionButton);
+
+        mSecondaryCallInfo.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                getPresenter().secondaryInfoClicked();
+                updateFabPositionForSecondaryCallInfo();
+            }
+        });
+
+        mCallStateButton = view.findViewById(R.id.callStateButton);
+        mCallStateButton.setOnLongClickListener(new View.OnLongClickListener() {
+            @Override
+            public boolean onLongClick(View v) {
+                getPresenter().onCallStateButtonTouched();
+                return false;
+            }
+        });
+
+        mManageConferenceCallButton = view.findViewById(R.id.manage_conference_call_button);
+        mManageConferenceCallButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                InCallActivity activity = (InCallActivity) getActivity();
+                activity.showConferenceFragment(true);
+            }
+        });
+
+        mPrimaryName.setElegantTextHeight(false);
+        mCallStateLabel.setElegantTextHeight(false);
+        mCallSubject = (TextView) view.findViewById(R.id.callSubject);
+    }
+
+    @Override
+    public void setVisible(boolean on) {
+        if (on) {
+            getView().setVisibility(View.VISIBLE);
+        } else {
+            getView().setVisibility(View.INVISIBLE);
+        }
+    }
+
+    /**
+     * Hides or shows the progress spinner.
+     *
+     * @param visible {@code True} if the progress spinner should be visible.
+     */
+    @Override
+    public void setProgressSpinnerVisible(boolean visible) {
+        mProgressSpinner.setVisibility(visible ? View.VISIBLE : View.GONE);
+    }
+
+    @Override
+    public void setContactContextTitle(View headerView) {
+        mContactContextListHeaders.removeAllViews();
+        mContactContextListHeaders.addView(headerView);
+    }
+
+    @Override
+    public void setContactContextContent(ListAdapter listAdapter) {
+        mContactContextListView.setAdapter(listAdapter);
+    }
+
+    @Override
+    public void showContactContext(boolean show) {
+        showImageView(mPhotoLarge, !show);
+        showImageView(mPhotoSmall, show);
+        mPrimaryCallCardContainer.setElevation(
+                show ? 0 : getResources().getDimension(R.dimen.primary_call_elevation));
+        mContactContext.setVisibility(show ? View.VISIBLE : View.GONE);
+    }
+
+    /**
+     * Sets the visibility of the primary call card.
+     * Ensures that when the primary call card is hidden, the video surface slides over to fill the
+     * entire screen.
+     *
+     * @param visible {@code True} if the primary call card should be visible.
+     */
+    @Override
+    public void setCallCardVisible(final boolean visible) {
+        Log.v(this, "setCallCardVisible : isVisible = " + visible);
+        // When animating the hide/show of the views in a landscape layout, we need to take into
+        // account whether we are in a left-to-right locale or a right-to-left locale and adjust
+        // the animations accordingly.
+        final boolean isLayoutRtl = InCallPresenter.isRtl();
+
+        // Retrieve here since at fragment creation time the incoming video view is not inflated.
+        final View videoView = getView().findViewById(R.id.incomingVideo);
+        if (videoView == null) {
+            return;
+        }
+
+        // Determine how much space there is below or to the side of the call card.
+        final float spaceBesideCallCard = getSpaceBesideCallCard();
+
+        // We need to translate the video surface, but we need to know its position after the layout
+        // has occurred so use a {@code ViewTreeObserver}.
+        final ViewTreeObserver observer = getView().getViewTreeObserver();
+        observer.addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
+            @Override
+            public boolean onPreDraw() {
+                // We don't want to continue getting called.
+                getView().getViewTreeObserver().removeOnPreDrawListener(this);
+
+                float videoViewTranslation = 0f;
+
+                // Translate the call card to its pre-animation state.
+                if (!mIsLandscape) {
+                    mPrimaryCallCardContainer.setTranslationY(visible ?
+                            -mPrimaryCallCardContainer.getHeight() : 0);
+
+                    ViewGroup.LayoutParams p = videoView.getLayoutParams();
+                    videoViewTranslation = p.height / 2 - spaceBesideCallCard / 2;
+                }
+
+                // Perform animation of video view.
+                ViewPropertyAnimator videoViewAnimator = videoView.animate()
+                        .setInterpolator(AnimUtils.EASE_OUT_EASE_IN)
+                        .setDuration(mVideoAnimationDuration);
+                if (mIsLandscape) {
+                    videoViewAnimator
+                            .translationX(visible ? videoViewTranslation : 0);
+                } else {
+                    videoViewAnimator
+                            .translationY(visible ? videoViewTranslation : 0);
+                }
+                videoViewAnimator.start();
+
+                // Animate the call card sliding.
+                ViewPropertyAnimator callCardAnimator = mPrimaryCallCardContainer.animate()
+                        .setInterpolator(AnimUtils.EASE_OUT_EASE_IN)
+                        .setDuration(mVideoAnimationDuration)
+                        .setListener(new AnimatorListenerAdapter() {
+                            @Override
+                            public void onAnimationEnd(Animator animation) {
+                                super.onAnimationEnd(animation);
+                                if (!visible) {
+                                    mPrimaryCallCardContainer.setVisibility(View.GONE);
+                                }
+                            }
+
+                            @Override
+                            public void onAnimationStart(Animator animation) {
+                                super.onAnimationStart(animation);
+                                if (visible) {
+                                    mPrimaryCallCardContainer.setVisibility(View.VISIBLE);
+                                }
+                            }
+                        });
+
+                if (mIsLandscape) {
+                    float translationX = mPrimaryCallCardContainer.getWidth();
+                    translationX *= isLayoutRtl ? 1 : -1;
+                    callCardAnimator
+                            .translationX(visible ? 0 : translationX)
+                            .start();
+                } else {
+                    callCardAnimator
+                            .translationY(visible ? 0 : -mPrimaryCallCardContainer.getHeight())
+                            .start();
+                }
+
+                return true;
+            }
+        });
+    }
+
+    /**
+     * Determines the amount of space below the call card for portrait layouts), or beside the
+     * call card for landscape layouts.
+     *
+     * @return The amount of space below or beside the call card.
+     */
+    public float getSpaceBesideCallCard() {
+        if (mIsLandscape) {
+            return getView().getWidth() - mPrimaryCallCardContainer.getWidth();
+        } else {
+            final int callCardHeight;
+            // Retrieve the actual height of the call card, independent of whether or not the
+            // outgoing call animation is in progress. The animation does not run in landscape mode
+            // so this only needs to be done for portrait.
+            if (mPrimaryCallCardContainer.getTag(R.id.view_tag_callcard_actual_height) != null) {
+                callCardHeight = (int) mPrimaryCallCardContainer.getTag(
+                        R.id.view_tag_callcard_actual_height);
+            } else {
+                callCardHeight = mPrimaryCallCardContainer.getHeight();
+            }
+            return getView().getHeight() - callCardHeight;
+        }
+    }
+
+    @Override
+    public void setPrimaryName(String name, boolean nameIsNumber) {
+        if (TextUtils.isEmpty(name)) {
+            mPrimaryName.setText(null);
+        } else {
+            mPrimaryName.setText(nameIsNumber
+                    ? PhoneNumberUtilsCompat.createTtsSpannable(name)
+                    : name);
+
+            // Set direction of the name field
+            int nameDirection = View.TEXT_DIRECTION_INHERIT;
+            if (nameIsNumber) {
+                nameDirection = View.TEXT_DIRECTION_LTR;
+            }
+            mPrimaryName.setTextDirection(nameDirection);
+        }
+    }
+
+    /**
+     * Sets the primary image for the contact photo.
+     *
+     * @param image The drawable to set.
+     * @param isVisible Whether the contact photo should be visible after being set.
+     */
+    @Override
+    public void setPrimaryImage(Drawable image, boolean isVisible) {
+        if (image != null) {
+            setDrawableToImageViews(image);
+            showImageView(mPhotoLarge, isVisible);
+        }
+    }
+
+    @Override
+    public void setPrimaryPhoneNumber(String number) {
+        // Set the number
+        if (TextUtils.isEmpty(number)) {
+            mPhoneNumber.setText(null);
+            mPhoneNumber.setVisibility(View.GONE);
+        } else {
+            mPhoneNumber.setText(PhoneNumberUtilsCompat.createTtsSpannable(number));
+            mPhoneNumber.setVisibility(View.VISIBLE);
+            mPhoneNumber.setTextDirection(View.TEXT_DIRECTION_LTR);
+        }
+    }
+
+    @Override
+    public void setPrimaryLabel(String label) {
+        if (!TextUtils.isEmpty(label)) {
+            mNumberLabel.setText(label);
+            mNumberLabel.setVisibility(View.VISIBLE);
+        } else {
+            mNumberLabel.setVisibility(View.GONE);
+        }
+
+    }
+
+    /**
+     * Sets the primary caller information.
+     *
+     * @param number The caller phone number.
+     * @param name The caller name.
+     * @param nameIsNumber {@code true} if the name should be shown in place of the phone number.
+     * @param label The label.
+     * @param photo The contact photo drawable.
+     * @param isSipCall {@code true} if this is a SIP call.
+     * @param isContactPhotoShown {@code true} if the contact photo should be shown (it will be
+     *      updated even if it is not shown).
+     * @param isWorkCall Whether the call is placed through a work phone account or caller is a work
+              contact.
+     */
+    @Override
+    public void setPrimary(String number, String name, boolean nameIsNumber, String label,
+            Drawable photo, boolean isSipCall, boolean isContactPhotoShown, boolean isWorkCall) {
+        Log.d(this, "Setting primary call");
+        // set the name field.
+        setPrimaryName(name, nameIsNumber);
+
+        if (TextUtils.isEmpty(number) && TextUtils.isEmpty(label)) {
+            mCallNumberAndLabel.setVisibility(View.GONE);
+            mElapsedTime.setTextAlignment(View.TEXT_ALIGNMENT_VIEW_START);
+        } else {
+            mCallNumberAndLabel.setVisibility(View.VISIBLE);
+            mElapsedTime.setTextAlignment(View.TEXT_ALIGNMENT_VIEW_END);
+        }
+
+        setPrimaryPhoneNumber(number);
+
+        // Set the label (Mobile, Work, etc)
+        setPrimaryLabel(label);
+
+        showInternetCallLabel(isSipCall);
+
+        setDrawableToImageViews(photo);
+        showImageView(mPhotoLarge, isContactPhotoShown);
+        showImageView(mWorkProfileIcon, isWorkCall);
+    }
+
+    @Override
+    public void setSecondary(boolean show, String name, boolean nameIsNumber, String label,
+            String providerLabel, boolean isConference, boolean isVideoCall, boolean isFullscreen) {
+
+        if (show) {
+            mHasSecondaryCallInfo = true;
+            boolean hasProvider = !TextUtils.isEmpty(providerLabel);
+            initializeSecondaryCallInfo(hasProvider);
+
+            // Do not show the secondary caller info in fullscreen mode, but ensure it is populated
+            // in case fullscreen mode is exited in the future.
+            setSecondaryInfoVisible(!isFullscreen);
+
+            mSecondaryCallConferenceCallIcon.setVisibility(isConference ? View.VISIBLE : View.GONE);
+            mSecondaryCallVideoCallIcon.setVisibility(isVideoCall ? View.VISIBLE : View.GONE);
+
+            mSecondaryCallName.setText(nameIsNumber
+                    ? PhoneNumberUtilsCompat.createTtsSpannable(name)
+                    : name);
+            if (hasProvider) {
+                mSecondaryCallProviderLabel.setText(providerLabel);
+            }
+
+            int nameDirection = View.TEXT_DIRECTION_INHERIT;
+            if (nameIsNumber) {
+                nameDirection = View.TEXT_DIRECTION_LTR;
+            }
+            mSecondaryCallName.setTextDirection(nameDirection);
+        } else {
+            mHasSecondaryCallInfo = false;
+            setSecondaryInfoVisible(false);
+        }
+    }
+
+    /**
+     * Sets the visibility of the secondary caller info box.  Note, if the {@code visible} parameter
+     * is passed in {@code true}, and there is no secondary caller info populated (as determined by
+     * {@code mHasSecondaryCallInfo}, the secondary caller info box will not be shown.
+     *
+     * @param visible {@code true} if the secondary caller info should be shown, {@code false}
+     *      otherwise.
+     */
+    @Override
+    public void setSecondaryInfoVisible(final boolean visible) {
+        boolean wasVisible = mSecondaryCallInfo.isShown();
+        final boolean isVisible = visible && mHasSecondaryCallInfo;
+        Log.v(this, "setSecondaryInfoVisible: wasVisible = " + wasVisible + " isVisible = "
+                + isVisible);
+
+        // If visibility didn't change, nothing to do.
+        if (wasVisible == isVisible) {
+            return;
+        }
+
+        // If we are showing the secondary info, we need to show it before animating so that its
+        // height will be determined on layout.
+        if (isVisible) {
+            mSecondaryCallInfo.setVisibility(View.VISIBLE);
+        }
+
+        updateFabPositionForSecondaryCallInfo();
+        // We need to translate the secondary caller info, but we need to know its position after
+        // the layout has occurred so use a {@code ViewTreeObserver}.
+        final ViewTreeObserver observer = getView().getViewTreeObserver();
+
+        observer.addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
+            @Override
+            public boolean onPreDraw() {
+                // We don't want to continue getting called.
+                getView().getViewTreeObserver().removeOnPreDrawListener(this);
+
+                // Get the height of the secondary call info now, and then re-hide the view prior
+                // to doing the actual animation.
+                int secondaryHeight = mSecondaryCallInfo.getHeight();
+                if (isVisible) {
+                    mSecondaryCallInfo.setVisibility(View.GONE);
+                }
+                Log.v(this, "setSecondaryInfoVisible: secondaryHeight = " + secondaryHeight);
+
+                // Set the position of the secondary call info card to its starting location.
+                mSecondaryCallInfo.setTranslationY(visible ? secondaryHeight : 0);
+
+                // Animate the secondary card info slide up/down as it appears and disappears.
+                ViewPropertyAnimator secondaryInfoAnimator = mSecondaryCallInfo.animate()
+                        .setInterpolator(AnimUtils.EASE_OUT_EASE_IN)
+                        .setDuration(mVideoAnimationDuration)
+                        .translationY(isVisible ? 0 : secondaryHeight)
+                        .setListener(new AnimatorListenerAdapter() {
+                            @Override
+                            public void onAnimationEnd(Animator animation) {
+                                if (!isVisible) {
+                                    mSecondaryCallInfo.setVisibility(View.GONE);
+                                }
+                            }
+
+                            @Override
+                            public void onAnimationStart(Animator animation) {
+                                if (isVisible) {
+                                    mSecondaryCallInfo.setVisibility(View.VISIBLE);
+                                }
+                            }
+                        });
+                secondaryInfoAnimator.start();
+
+                // Notify listeners of a change in the visibility of the secondary info. This is
+                // important when in a video call so that the video call presenter can shift the
+                // video preview up or down to accommodate the secondary caller info.
+                InCallPresenter.getInstance().notifySecondaryCallerInfoVisibilityChanged(visible,
+                        secondaryHeight);
+
+                return true;
+            }
+        });
+    }
+
+    @Override
+    public void setCallState(
+            int state,
+            int videoState,
+            int sessionModificationState,
+            DisconnectCause disconnectCause,
+            String connectionLabel,
+            Drawable callStateIcon,
+            String gatewayNumber,
+            boolean isWifi,
+            boolean isConference,
+            boolean isWorkCall) {
+        boolean isGatewayCall = !TextUtils.isEmpty(gatewayNumber);
+        CallStateLabel callStateLabel = getCallStateLabelFromState(state, videoState,
+                sessionModificationState, disconnectCause, connectionLabel, isGatewayCall, isWifi,
+                isConference, isWorkCall);
+
+        Log.v(this, "setCallState " + callStateLabel.getCallStateLabel());
+        Log.v(this, "AutoDismiss " + callStateLabel.isAutoDismissing());
+        Log.v(this, "DisconnectCause " + disconnectCause.toString());
+        Log.v(this, "gateway " + connectionLabel + gatewayNumber);
+
+        // Check for video state change and update the visibility of the contact photo.  The contact
+        // photo is hidden when the incoming video surface is shown.
+        // The contact photo visibility can also change in setPrimary().
+        boolean showContactPhoto = !VideoCallPresenter.showIncomingVideo(videoState, state);
+        mPhotoLarge.setVisibility(showContactPhoto ? View.VISIBLE : View.GONE);
+
+        // Check if the call subject is showing -- if it is, we want to bypass showing the call
+        // state.
+        boolean isSubjectShowing = mCallSubject.getVisibility() == View.VISIBLE;
+
+        if (TextUtils.equals(callStateLabel.getCallStateLabel(), mCallStateLabel.getText()) &&
+                !isSubjectShowing) {
+            // Nothing to do if the labels are the same
+            if (state == Call.State.ACTIVE || state == Call.State.CONFERENCED) {
+                mCallStateLabel.clearAnimation();
+                mCallStateIcon.clearAnimation();
+            }
+            return;
+        }
+
+        if (isSubjectShowing) {
+            changeCallStateLabel(null);
+            callStateIcon = null;
+        } else {
+            // Update the call state label and icon.
+            setCallStateLabel(callStateLabel);
+        }
+
+        if (!TextUtils.isEmpty(callStateLabel.getCallStateLabel())) {
+            if (state == Call.State.ACTIVE || state == Call.State.CONFERENCED) {
+                mCallStateLabel.clearAnimation();
+            } else {
+                mCallStateLabel.startAnimation(mPulseAnimation);
+            }
+        } else {
+            mCallStateLabel.clearAnimation();
+        }
+
+        if (callStateIcon != null) {
+            mCallStateIcon.setVisibility(View.VISIBLE);
+            // Invoke setAlpha(float) instead of setAlpha(int) to set the view's alpha. This is
+            // needed because the pulse animation operates on the view alpha.
+            mCallStateIcon.setAlpha(1.0f);
+            mCallStateIcon.setImageDrawable(callStateIcon);
+
+            if (state == Call.State.ACTIVE || state == Call.State.CONFERENCED
+                    || TextUtils.isEmpty(callStateLabel.getCallStateLabel())) {
+                mCallStateIcon.clearAnimation();
+            } else {
+                mCallStateIcon.startAnimation(mPulseAnimation);
+            }
+
+            if (callStateIcon instanceof AnimationDrawable) {
+                ((AnimationDrawable) callStateIcon).start();
+            }
+        } else {
+            mCallStateIcon.clearAnimation();
+
+            // Invoke setAlpha(float) instead of setAlpha(int) to set the view's alpha. This is
+            // needed because the pulse animation operates on the view alpha.
+            mCallStateIcon.setAlpha(0.0f);
+            mCallStateIcon.setVisibility(View.GONE);
+        }
+
+        if (VideoUtils.isVideoCall(videoState)
+                || (state == Call.State.ACTIVE && sessionModificationState
+                        == Call.SessionModificationState.WAITING_FOR_RESPONSE)) {
+            mCallStateVideoCallIcon.setVisibility(View.VISIBLE);
+        } else {
+            mCallStateVideoCallIcon.setVisibility(View.GONE);
+        }
+    }
+
+    private void setCallStateLabel(CallStateLabel callStateLabel) {
+        Log.v(this, "setCallStateLabel : label = " + callStateLabel.getCallStateLabel());
+
+        if (callStateLabel.isAutoDismissing()) {
+            mCallStateLabelResetPending = true;
+            mHandler.postDelayed(new Runnable() {
+                @Override
+                public void run() {
+                    Log.v(this, "restoringCallStateLabel : label = " +
+                            mPostResetCallStateLabel);
+                    changeCallStateLabel(mPostResetCallStateLabel);
+                    mCallStateLabelResetPending = false;
+                }
+            }, CALL_STATE_LABEL_RESET_DELAY_MS);
+
+            changeCallStateLabel(callStateLabel.getCallStateLabel());
+        } else {
+            // Keep track of the current call state label; used when resetting auto dismissing
+            // call state labels.
+            mPostResetCallStateLabel = callStateLabel.getCallStateLabel();
+
+            if (!mCallStateLabelResetPending) {
+                changeCallStateLabel(callStateLabel.getCallStateLabel());
+            }
+        }
+    }
+
+    private void changeCallStateLabel(CharSequence callStateLabel) {
+        Log.v(this, "changeCallStateLabel : label = " + callStateLabel);
+        if (!TextUtils.isEmpty(callStateLabel)) {
+            mCallStateLabel.setText(callStateLabel);
+            mCallStateLabel.setAlpha(1);
+            mCallStateLabel.setVisibility(View.VISIBLE);
+        } else {
+            Animation callStateLabelAnimation = mCallStateLabel.getAnimation();
+            if (callStateLabelAnimation != null) {
+                callStateLabelAnimation.cancel();
+            }
+            mCallStateLabel.setText(null);
+            mCallStateLabel.setAlpha(0);
+            mCallStateLabel.setVisibility(View.GONE);
+        }
+    }
+
+    @Override
+    public void setCallbackNumber(String callbackNumber, boolean isEmergencyCall) {
+        if (mInCallMessageLabel == null) {
+            return;
+        }
+
+        if (TextUtils.isEmpty(callbackNumber)) {
+            mInCallMessageLabel.setVisibility(View.GONE);
+            return;
+        }
+
+        // TODO: The new Locale-specific methods don't seem to be working. Revisit this.
+        callbackNumber = PhoneNumberUtils.formatNumber(callbackNumber);
+
+        int stringResourceId = isEmergencyCall ? R.string.card_title_callback_number_emergency
+                : R.string.card_title_callback_number;
+
+        String text = getString(stringResourceId, callbackNumber);
+        mInCallMessageLabel.setText(text);
+
+        mInCallMessageLabel.setVisibility(View.VISIBLE);
+    }
+
+    /**
+     * Sets and shows the call subject if it is not empty.  Hides the call subject otherwise.
+     *
+     * @param callSubject The call subject.
+     */
+    @Override
+    public void setCallSubject(String callSubject) {
+        boolean showSubject = !TextUtils.isEmpty(callSubject);
+
+        mCallSubject.setVisibility(showSubject ? View.VISIBLE : View.GONE);
+        if (showSubject) {
+            mCallSubject.setText(callSubject);
+        } else {
+            mCallSubject.setText(null);
+        }
+    }
+
+    public boolean isAnimating() {
+        return mIsAnimating;
+    }
+
+    private void showInternetCallLabel(boolean show) {
+        if (show) {
+            final String label = getView().getContext().getString(
+                    R.string.incall_call_type_label_sip);
+            mCallTypeLabel.setVisibility(View.VISIBLE);
+            mCallTypeLabel.setText(label);
+        } else {
+            mCallTypeLabel.setVisibility(View.GONE);
+        }
+    }
+
+    @Override
+    public void setPrimaryCallElapsedTime(boolean show, long duration) {
+        if (show) {
+            if (mElapsedTime.getVisibility() != View.VISIBLE) {
+                AnimUtils.fadeIn(mElapsedTime, AnimUtils.DEFAULT_DURATION);
+            }
+            String callTimeElapsed = DateUtils.formatElapsedTime(duration / 1000);
+            mElapsedTime.setText(callTimeElapsed);
+
+            String durationDescription =
+                    InCallDateUtils.formatDuration(getView().getContext(), duration);
+            mElapsedTime.setContentDescription(
+                    !TextUtils.isEmpty(durationDescription) ? durationDescription : null);
+        } else {
+            // hide() animation has no effect if it is already hidden.
+            AnimUtils.fadeOut(mElapsedTime, AnimUtils.DEFAULT_DURATION);
+        }
+    }
+
+    /**
+     * Set all the ImageViews to the same photo. Currently there are 2 photo views: the large one
+     * (which fills about the bottom half of the screen) and the small one, which displays as a
+     * circle next to the primary contact info. This method does not handle whether the ImageView
+     * is shown or not.
+     *
+     * @param photo The photo to set for the image views.
+     */
+    private void setDrawableToImageViews(Drawable photo) {
+        if (photo == null) {
+            photo = ContactInfoCache.getInstance(getView().getContext())
+                            .getDefaultContactPhotoDrawable();
+        }
+
+        if (mPrimaryPhotoDrawable == photo){
+            return;
+        }
+        mPrimaryPhotoDrawable = photo;
+
+        mPhotoLarge.setImageDrawable(photo);
+
+        // Modify the drawable to be round for the smaller ImageView.
+        Bitmap bitmap = drawableToBitmap(photo);
+        if (bitmap != null) {
+            final RoundedBitmapDrawable drawable =
+                    RoundedBitmapDrawableFactory.create(getResources(), bitmap);
+            drawable.setAntiAlias(true);
+            drawable.setCornerRadius(bitmap.getHeight() / 2);
+            photo = drawable;
+        }
+        mPhotoSmall.setImageDrawable(photo);
+    }
+
+    /**
+     * Helper method for image view to handle animations.
+     *
+     * @param view The image view to show or hide.
+     * @param isVisible {@code true} if we want to show the image, {@code false} to hide it.
+     */
+    private void showImageView(ImageView view, boolean isVisible) {
+        if (view.getDrawable() == null) {
+            if (isVisible) {
+                AnimUtils.fadeIn(mElapsedTime, AnimUtils.DEFAULT_DURATION);
+            }
+        } else {
+            // Cross fading is buggy and not noticeable due to the multiple calls to this method
+            // that switch drawables in the middle of the cross-fade animations. Just show the
+            // photo directly instead.
+            view.setVisibility(isVisible ? View.VISIBLE : View.GONE);
+        }
+    }
+
+    /**
+     * Converts a drawable into a bitmap.
+     *
+     * @param drawable the drawable to be converted.
+     */
+    public static Bitmap drawableToBitmap(Drawable drawable) {
+        Bitmap bitmap;
+        if (drawable instanceof BitmapDrawable) {
+            bitmap = ((BitmapDrawable) drawable).getBitmap();
+        } else {
+            if (drawable.getIntrinsicWidth() <= 0 || drawable.getIntrinsicHeight() <= 0) {
+                // Needed for drawables that are just a colour.
+                bitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
+            } else {
+                bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(),
+                        drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+            }
+
+            Log.i(TAG, "Created bitmap with width " + bitmap.getWidth() + ", height "
+                    + bitmap.getHeight());
+
+            Canvas canvas = new Canvas(bitmap);
+            drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
+            drawable.draw(canvas);
+        }
+        return bitmap;
+    }
+
+    /**
+     * Gets the call state label based on the state of the call or cause of disconnect.
+     *
+     * Additional labels are applied as follows:
+     *         1. All outgoing calls with display "Calling via [Provider]".
+     *         2. Ongoing calls will display the name of the provider.
+     *         3. Incoming calls will only display "Incoming via..." for accounts.
+     *         4. Video calls, and session modification states (eg. requesting video).
+     *         5. Incoming and active Wi-Fi calls will show label provided by hint.
+     *
+     * TODO: Move this to the CallCardPresenter.
+     */
+    private CallStateLabel getCallStateLabelFromState(int state, int videoState,
+            int sessionModificationState, DisconnectCause disconnectCause, String label,
+            boolean isGatewayCall, boolean isWifi, boolean isConference, boolean isWorkCall) {
+        final Context context = getView().getContext();
+        CharSequence callStateLabel = null;  // Label to display as part of the call banner
+
+        boolean hasSuggestedLabel = label != null;
+        boolean isAccount = hasSuggestedLabel && !isGatewayCall;
+        boolean isAutoDismissing = false;
+
+        switch  (state) {
+            case Call.State.IDLE:
+                // "Call state" is meaningless in this state.
+                break;
+            case Call.State.ACTIVE:
+                // We normally don't show a "call state label" at all in this state
+                // (but we can use the call state label to display the provider name).
+                if ((isAccount || isWifi || isConference) && hasSuggestedLabel) {
+                    callStateLabel = label;
+                } else if (sessionModificationState
+                        == Call.SessionModificationState.REQUEST_REJECTED) {
+                    callStateLabel = context.getString(R.string.card_title_video_call_rejected);
+                    isAutoDismissing = true;
+                } else if (sessionModificationState
+                        == Call.SessionModificationState.REQUEST_FAILED) {
+                    callStateLabel = context.getString(R.string.card_title_video_call_error);
+                    isAutoDismissing = true;
+                } else if (sessionModificationState
+                        == Call.SessionModificationState.WAITING_FOR_RESPONSE) {
+                    callStateLabel = context.getString(R.string.card_title_video_call_requesting);
+                } else if (sessionModificationState
+                        == Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+                    callStateLabel = context.getString(R.string.card_title_video_call_requesting);
+                } else if (VideoUtils.isVideoCall(videoState)) {
+                    callStateLabel = context.getString(R.string.card_title_video_call);
+                }
+                break;
+            case Call.State.ONHOLD:
+                callStateLabel = context.getString(R.string.card_title_on_hold);
+                break;
+            case Call.State.CONNECTING:
+            case Call.State.DIALING:
+                if (hasSuggestedLabel && !isWifi) {
+                    callStateLabel = context.getString(R.string.calling_via_template, label);
+                } else {
+                    callStateLabel = context.getString(R.string.card_title_dialing);
+                }
+                break;
+            case Call.State.REDIALING:
+                callStateLabel = context.getString(R.string.card_title_redialing);
+                break;
+            case Call.State.INCOMING:
+            case Call.State.CALL_WAITING:
+                if (isWifi && hasSuggestedLabel) {
+                    callStateLabel = label;
+                } else if (isAccount) {
+                    callStateLabel = context.getString(R.string.incoming_via_template, label);
+                } else if (VideoUtils.isVideoCall(videoState)) {
+                    callStateLabel = context.getString(R.string.notification_incoming_video_call);
+                } else {
+                    callStateLabel =
+                            context.getString(isWorkCall ? R.string.card_title_incoming_work_call
+                                    : R.string.card_title_incoming_call);
+                }
+                break;
+            case Call.State.DISCONNECTING:
+                // While in the DISCONNECTING state we display a "Hanging up"
+                // message in order to make the UI feel more responsive.  (In
+                // GSM it's normal to see a delay of a couple of seconds while
+                // negotiating the disconnect with the network, so the "Hanging
+                // up" state at least lets the user know that we're doing
+                // something.  This state is currently not used with CDMA.)
+                callStateLabel = context.getString(R.string.card_title_hanging_up);
+                break;
+            case Call.State.DISCONNECTED:
+                callStateLabel = disconnectCause.getLabel();
+                if (TextUtils.isEmpty(callStateLabel)) {
+                    callStateLabel = context.getString(R.string.card_title_call_ended);
+                }
+                break;
+            case Call.State.CONFERENCED:
+                callStateLabel = context.getString(R.string.card_title_conf_call);
+                break;
+            default:
+                Log.wtf(this, "updateCallStateWidgets: unexpected call: " + state);
+        }
+        return new CallStateLabel(callStateLabel, isAutoDismissing);
+    }
+
+    private void initializeSecondaryCallInfo(boolean hasProvider) {
+        // mSecondaryCallName is initialized here (vs. onViewCreated) because it is inaccessible
+        // until mSecondaryCallInfo is inflated in the call above.
+        if (mSecondaryCallName == null) {
+            mSecondaryCallName = (TextView) getView().findViewById(R.id.secondaryCallName);
+            mSecondaryCallConferenceCallIcon =
+                    getView().findViewById(R.id.secondaryCallConferenceCallIcon);
+            mSecondaryCallVideoCallIcon =
+                    getView().findViewById(R.id.secondaryCallVideoCallIcon);
+        }
+
+        if (mSecondaryCallProviderLabel == null && hasProvider) {
+            mSecondaryCallProviderInfo.setVisibility(View.VISIBLE);
+            mSecondaryCallProviderLabel = (TextView) getView()
+                    .findViewById(R.id.secondaryCallProviderLabel);
+        }
+    }
+
+    public void dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
+        if (event.getEventType() == AccessibilityEvent.TYPE_ANNOUNCEMENT) {
+            dispatchPopulateAccessibilityEvent(event, mCallStateLabel);
+            dispatchPopulateAccessibilityEvent(event, mPrimaryName);
+            dispatchPopulateAccessibilityEvent(event, mCallTypeLabel);
+            dispatchPopulateAccessibilityEvent(event, mPhoneNumber);
+            return;
+        }
+        dispatchPopulateAccessibilityEvent(event, mCallStateLabel);
+        dispatchPopulateAccessibilityEvent(event, mPrimaryName);
+        dispatchPopulateAccessibilityEvent(event, mPhoneNumber);
+        dispatchPopulateAccessibilityEvent(event, mCallTypeLabel);
+        dispatchPopulateAccessibilityEvent(event, mSecondaryCallName);
+        dispatchPopulateAccessibilityEvent(event, mSecondaryCallProviderLabel);
+
+        return;
+    }
+
+    @Override
+    public void sendAccessibilityAnnouncement() {
+        mHandler.postDelayed(new Runnable() {
+            @Override
+            public void run() {
+                if (getView() != null && getView().getParent() != null) {
+                    AccessibilityEvent event = AccessibilityEvent.obtain(
+                            AccessibilityEvent.TYPE_ANNOUNCEMENT);
+                    dispatchPopulateAccessibilityEvent(event);
+                    getView().getParent().requestSendAccessibilityEvent(getView(), event);
+                }
+            }
+        }, ACCESSIBILITY_ANNOUNCEMENT_DELAY_MS);
+    }
+
+    @Override
+    public void setEndCallButtonEnabled(boolean enabled, boolean animate) {
+        if (enabled != mFloatingActionButton.isEnabled()) {
+            if (animate) {
+                if (enabled) {
+                    mFloatingActionButtonController.scaleIn(AnimUtils.NO_DELAY);
+                } else {
+                    mFloatingActionButtonController.scaleOut();
+                }
+            } else {
+                if (enabled) {
+                    mFloatingActionButtonContainer.setScaleX(1);
+                    mFloatingActionButtonContainer.setScaleY(1);
+                    mFloatingActionButtonContainer.setVisibility(View.VISIBLE);
+                } else {
+                    mFloatingActionButtonContainer.setVisibility(View.GONE);
+                }
+            }
+            mFloatingActionButton.setEnabled(enabled);
+            updateFabPosition();
+        }
+    }
+
+    /**
+     * Changes the visibility of the HD audio icon.
+     *
+     * @param visible {@code true} if the UI should show the HD audio icon.
+     */
+    @Override
+    public void showHdAudioIndicator(boolean visible) {
+        mHdAudioIcon.setVisibility(visible ? View.VISIBLE : View.GONE);
+    }
+
+    /**
+     * Changes the visibility of the forward icon.
+     *
+     * @param visible {@code true} if the UI should show the forward icon.
+     */
+    @Override
+    public void showForwardIndicator(boolean visible) {
+        mForwardIcon.setVisibility(visible ? View.VISIBLE : View.GONE);
+    }
+
+
+    /**
+     * Changes the visibility of the "manage conference call" button.
+     *
+     * @param visible Whether to set the button to be visible or not.
+     */
+    @Override
+    public void showManageConferenceCallButton(boolean visible) {
+        mManageConferenceCallButton.setVisibility(visible ? View.VISIBLE : View.GONE);
+    }
+
+    /**
+     * Determines the current visibility of the manage conference button.
+     *
+     * @return {@code true} if the button is visible.
+     */
+    @Override
+    public boolean isManageConferenceVisible() {
+        return mManageConferenceCallButton.getVisibility() == View.VISIBLE;
+    }
+
+    /**
+     * Determines the current visibility of the call subject.
+     *
+     * @return {@code true} if the subject is visible.
+     */
+    @Override
+    public boolean isCallSubjectVisible() {
+        return mCallSubject.getVisibility() == View.VISIBLE;
+    }
+
+    /**
+     * Get the overall InCallUI background colors and apply to call card.
+     */
+    public void updateColors() {
+        MaterialPalette themeColors = InCallPresenter.getInstance().getThemeColors();
+
+        if (mCurrentThemeColors != null && mCurrentThemeColors.equals(themeColors)) {
+            return;
+        }
+
+        if (getResources().getBoolean(R.bool.is_layout_landscape)) {
+            final GradientDrawable drawable =
+                    (GradientDrawable) mPrimaryCallCardContainer.getBackground();
+            drawable.setColor(themeColors.mPrimaryColor);
+        } else {
+            mPrimaryCallCardContainer.setBackgroundColor(themeColors.mPrimaryColor);
+        }
+        mCallButtonsContainer.setBackgroundColor(themeColors.mPrimaryColor);
+        mCallSubject.setTextColor(themeColors.mPrimaryColor);
+        mContactContext.setBackgroundColor(themeColors.mPrimaryColor);
+        //TODO: set color of message text in call context "recent messages" to be the theme color.
+
+        mCurrentThemeColors = themeColors;
+    }
+
+    private void dispatchPopulateAccessibilityEvent(AccessibilityEvent event, View view) {
+        if (view == null) return;
+        final List<CharSequence> eventText = event.getText();
+        int size = eventText.size();
+        view.dispatchPopulateAccessibilityEvent(event);
+        // if no text added write null to keep relative position
+        if (size == eventText.size()) {
+            eventText.add(null);
+        }
+    }
+
+    @Override
+    public void animateForNewOutgoingCall() {
+        final ViewGroup parent = (ViewGroup) mPrimaryCallCardContainer.getParent();
+
+        final ViewTreeObserver observer = getView().getViewTreeObserver();
+
+        mIsAnimating = true;
+
+        observer.addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
+            @Override
+            public void onGlobalLayout() {
+                final ViewTreeObserver observer = getView().getViewTreeObserver();
+                if (!observer.isAlive()) {
+                    return;
+                }
+                observer.removeOnGlobalLayoutListener(this);
+
+                final LayoutIgnoringListener listener = new LayoutIgnoringListener();
+                mPrimaryCallCardContainer.addOnLayoutChangeListener(listener);
+
+                // Prepare the state of views before the slide animation
+                final int originalHeight = mPrimaryCallCardContainer.getHeight();
+                mPrimaryCallCardContainer.setTag(R.id.view_tag_callcard_actual_height,
+                        originalHeight);
+                mPrimaryCallCardContainer.setBottom(parent.getHeight());
+
+                // Set up FAB.
+                mFloatingActionButtonContainer.setVisibility(View.GONE);
+                mFloatingActionButtonController.setScreenWidth(parent.getWidth());
+
+                mCallButtonsContainer.setAlpha(0);
+                mCallStateLabel.setAlpha(0);
+                mPrimaryName.setAlpha(0);
+                mCallTypeLabel.setAlpha(0);
+                mCallNumberAndLabel.setAlpha(0);
+
+                assignTranslateAnimation(mCallStateLabel, 1);
+                assignTranslateAnimation(mCallStateIcon, 1);
+                assignTranslateAnimation(mPrimaryName, 2);
+                assignTranslateAnimation(mCallNumberAndLabel, 3);
+                assignTranslateAnimation(mCallTypeLabel, 4);
+                assignTranslateAnimation(mCallButtonsContainer, 5);
+
+                final Animator animator = getShrinkAnimator(parent.getHeight(), originalHeight);
+
+                animator.addListener(new AnimatorListenerAdapter() {
+                    @Override
+                    public void onAnimationEnd(Animator animation) {
+                        mPrimaryCallCardContainer.setTag(R.id.view_tag_callcard_actual_height,
+                                null);
+                        setViewStatePostAnimation(listener);
+                        mIsAnimating = false;
+                        InCallPresenter.getInstance().onShrinkAnimationComplete();
+                    }
+                });
+                animator.start();
+            }
+        });
+    }
+
+    @Override
+    public void showNoteSentToast() {
+        Toast.makeText(getContext(), R.string.note_sent, Toast.LENGTH_LONG).show();
+    }
+
+    public void onDialpadVisibilityChange(boolean isShown) {
+        mIsDialpadShowing = isShown;
+        updateFabPosition();
+    }
+
+    private void updateFabPosition() {
+        int offsetY = 0;
+        if (!mIsDialpadShowing) {
+            offsetY = mFloatingActionButtonVerticalOffset;
+            if (mSecondaryCallInfo.isShown()) {
+                offsetY -= mSecondaryCallInfo.getHeight();
+            }
+        }
+
+        mFloatingActionButtonController.align(
+                FloatingActionButtonController.ALIGN_MIDDLE,
+                0 /* offsetX */,
+                offsetY,
+                true);
+
+        mFloatingActionButtonController.resize(
+                mIsDialpadShowing ? mFabSmallDiameter : mFabNormalDiameter, true);
+    }
+
+    @Override
+    public Context getContext() {
+        return getActivity();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        // If the previous launch animation is still running, cancel it so that we don't get
+        // stuck in an intermediate animation state.
+        if (mAnimatorSet != null && mAnimatorSet.isRunning()) {
+            mAnimatorSet.cancel();
+        }
+
+        mIsLandscape = getResources().getBoolean(R.bool.is_layout_landscape);
+
+        final ViewGroup parent = ((ViewGroup) mPrimaryCallCardContainer.getParent());
+        final ViewTreeObserver observer = parent.getViewTreeObserver();
+        parent.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
+            @Override
+            public void onGlobalLayout() {
+                ViewTreeObserver viewTreeObserver = observer;
+                if (!viewTreeObserver.isAlive()) {
+                    viewTreeObserver = parent.getViewTreeObserver();
+                }
+                viewTreeObserver.removeOnGlobalLayoutListener(this);
+                mFloatingActionButtonController.setScreenWidth(parent.getWidth());
+                updateFabPosition();
+            }
+        });
+
+        updateColors();
+    }
+
+    /**
+     * Adds a global layout listener to update the FAB's positioning on the next layout. This allows
+     * us to position the FAB after the secondary call info's height has been calculated.
+     */
+    private void updateFabPositionForSecondaryCallInfo() {
+        mSecondaryCallInfo.getViewTreeObserver().addOnGlobalLayoutListener(
+                new ViewTreeObserver.OnGlobalLayoutListener() {
+                    @Override
+                    public void onGlobalLayout() {
+                        final ViewTreeObserver observer = mSecondaryCallInfo.getViewTreeObserver();
+                        if (!observer.isAlive()) {
+                            return;
+                        }
+                        observer.removeOnGlobalLayoutListener(this);
+
+                        onDialpadVisibilityChange(mIsDialpadShowing);
+                    }
+                });
+    }
+
+    /**
+     * Animator that performs the upwards shrinking animation of the blue call card scrim.
+     * At the start of the animation, each child view is moved downwards by a pre-specified amount
+     * and then translated upwards together with the scrim.
+     */
+    private Animator getShrinkAnimator(int startHeight, int endHeight) {
+        final ObjectAnimator shrinkAnimator =
+                ObjectAnimator.ofInt(mPrimaryCallCardContainer, "bottom", startHeight, endHeight);
+        shrinkAnimator.setDuration(mShrinkAnimationDuration);
+        shrinkAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+                mFloatingActionButton.setEnabled(true);
+            }
+        });
+        shrinkAnimator.setInterpolator(AnimUtils.EASE_IN);
+        return shrinkAnimator;
+    }
+
+    private void assignTranslateAnimation(View view, int offset) {
+        view.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+        view.buildLayer();
+        view.setTranslationY(mTranslationOffset * offset);
+        view.animate().translationY(0).alpha(1).withLayer()
+                .setDuration(mShrinkAnimationDuration).setInterpolator(AnimUtils.EASE_IN);
+    }
+
+    private void setViewStatePostAnimation(View view) {
+        view.setTranslationY(0);
+        view.setAlpha(1);
+    }
+
+    private void setViewStatePostAnimation(OnLayoutChangeListener layoutChangeListener) {
+        setViewStatePostAnimation(mCallButtonsContainer);
+        setViewStatePostAnimation(mCallStateLabel);
+        setViewStatePostAnimation(mPrimaryName);
+        setViewStatePostAnimation(mCallTypeLabel);
+        setViewStatePostAnimation(mCallNumberAndLabel);
+        setViewStatePostAnimation(mCallStateIcon);
+
+        mPrimaryCallCardContainer.removeOnLayoutChangeListener(layoutChangeListener);
+
+        mFloatingActionButtonController.scaleIn(AnimUtils.NO_DELAY);
+    }
+
+    private final class LayoutIgnoringListener implements View.OnLayoutChangeListener {
+        @Override
+        public void onLayoutChange(View v,
+                int left,
+                int top,
+                int right,
+                int bottom,
+                int oldLeft,
+                int oldTop,
+                int oldRight,
+                int oldBottom) {
+            v.setLeft(oldLeft);
+            v.setRight(oldRight);
+            v.setTop(oldTop);
+            v.setBottom(oldBottom);
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/CallCardPresenter.java b/InCallUI/src/com/android/incallui/CallCardPresenter.java
new file mode 100644
index 0000000..de2fb58
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/CallCardPresenter.java
@@ -0,0 +1,1154 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import com.google.common.base.Preconditions;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.telecom.Call.Details;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.StatusHints;
+import android.telecom.TelecomManager;
+import android.telecom.VideoProfile;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+import android.view.View;
+import android.view.accessibility.AccessibilityManager;
+import android.widget.ListAdapter;
+
+import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.compat.telecom.TelecomManagerCompat;
+import com.android.contacts.common.preference.ContactsPreferences;
+import com.android.contacts.common.testing.NeededForTesting;
+import com.android.contacts.common.util.ContactDisplayUtils;
+import com.android.incallui.Call.State;
+import com.android.incallui.ContactInfoCache.ContactCacheEntry;
+import com.android.incallui.ContactInfoCache.ContactInfoCacheCallback;
+import com.android.incallui.InCallPresenter.InCallDetailsListener;
+import com.android.incallui.InCallPresenter.InCallEventListener;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.incallui.InCallPresenter.IncomingCallListener;
+import com.android.incallui.compat.telecom.DetailsCompat;
+import com.android.incalluibind.ObjectFactory;
+
+import java.lang.ref.WeakReference;
+
+import static com.android.contacts.common.compat.CallSdkCompat.Details.PROPERTY_WORK_CALL;
+/**
+ * Presenter for the Call Card Fragment.
+ * <p>
+ * This class listens for changes to InCallState and passes it along to the fragment.
+ */
+public class CallCardPresenter extends Presenter<CallCardPresenter.CallCardUi>
+        implements InCallStateListener, IncomingCallListener, InCallDetailsListener,
+        InCallEventListener, CallList.CallUpdateListener, DistanceHelper.Listener {
+
+    public interface EmergencyCallListener {
+        public void onCallUpdated(BaseFragment fragment, boolean isEmergency);
+    }
+
+    private static final String TAG = CallCardPresenter.class.getSimpleName();
+    private static final long CALL_TIME_UPDATE_INTERVAL_MS = 1000;
+
+    private final EmergencyCallListener mEmergencyCallListener =
+            ObjectFactory.newEmergencyCallListener();
+    private DistanceHelper mDistanceHelper;
+
+    private Call mPrimary;
+    private Call mSecondary;
+    private ContactCacheEntry mPrimaryContactInfo;
+    private ContactCacheEntry mSecondaryContactInfo;
+    private CallTimer mCallTimer;
+    private Context mContext;
+    @Nullable private ContactsPreferences mContactsPreferences;
+    private boolean mSpinnerShowing = false;
+    private boolean mHasShownToast = false;
+    private InCallContactInteractions mInCallContactInteractions;
+    private boolean mIsFullscreen = false;
+
+    public static class ContactLookupCallback implements ContactInfoCacheCallback {
+        private final WeakReference<CallCardPresenter> mCallCardPresenter;
+        private final boolean mIsPrimary;
+
+        public ContactLookupCallback(CallCardPresenter callCardPresenter, boolean isPrimary) {
+            mCallCardPresenter = new WeakReference<CallCardPresenter>(callCardPresenter);
+            mIsPrimary = isPrimary;
+        }
+
+        @Override
+        public void onContactInfoComplete(String callId, ContactCacheEntry entry) {
+            CallCardPresenter presenter = mCallCardPresenter.get();
+            if (presenter != null) {
+                presenter.onContactInfoComplete(callId, entry, mIsPrimary);
+            }
+        }
+
+        @Override
+        public void onImageLoadComplete(String callId, ContactCacheEntry entry) {
+            CallCardPresenter presenter = mCallCardPresenter.get();
+            if (presenter != null) {
+                presenter.onImageLoadComplete(callId, entry);
+            }
+        }
+
+        @Override
+        public void onContactInteractionsInfoComplete(String callId, ContactCacheEntry entry) {
+            CallCardPresenter presenter = mCallCardPresenter.get();
+            if (presenter != null) {
+                presenter.onContactInteractionsInfoComplete(callId, entry);
+            }
+        }
+    }
+
+    public CallCardPresenter() {
+        // create the call timer
+        mCallTimer = new CallTimer(new Runnable() {
+            @Override
+            public void run() {
+                updateCallTime();
+            }
+        });
+    }
+
+    public void init(Context context, Call call) {
+        mContext = Preconditions.checkNotNull(context);
+        mDistanceHelper = ObjectFactory.newDistanceHelper(mContext, this);
+        mContactsPreferences = ContactsPreferencesFactory.newContactsPreferences(mContext);
+
+        // Call may be null if disconnect happened already.
+        if (call != null) {
+            mPrimary = call;
+            if (shouldShowNoteSentToast(mPrimary)) {
+                final CallCardUi ui = getUi();
+                if (ui != null) {
+                    ui.showNoteSentToast();
+                }
+            }
+            CallList.getInstance().addCallUpdateListener(call.getId(), this);
+
+            // start processing lookups right away.
+            if (!call.isConferenceCall()) {
+                startContactInfoSearch(call, true, call.getState() == Call.State.INCOMING);
+            } else {
+                updateContactEntry(null, true);
+            }
+        }
+
+        onStateChange(null, InCallPresenter.getInstance().getInCallState(), CallList.getInstance());
+    }
+
+    @Override
+    public void onUiReady(CallCardUi ui) {
+        super.onUiReady(ui);
+
+        if (mContactsPreferences != null) {
+            mContactsPreferences.refreshValue(ContactsPreferences.DISPLAY_ORDER_KEY);
+        }
+
+        // Contact search may have completed before ui is ready.
+        if (mPrimaryContactInfo != null) {
+            updatePrimaryDisplayInfo();
+        }
+
+        // Register for call state changes last
+        InCallPresenter.getInstance().addListener(this);
+        InCallPresenter.getInstance().addIncomingCallListener(this);
+        InCallPresenter.getInstance().addDetailsListener(this);
+        InCallPresenter.getInstance().addInCallEventListener(this);
+    }
+
+    @Override
+    public void onUiUnready(CallCardUi ui) {
+        super.onUiUnready(ui);
+
+        // stop getting call state changes
+        InCallPresenter.getInstance().removeListener(this);
+        InCallPresenter.getInstance().removeIncomingCallListener(this);
+        InCallPresenter.getInstance().removeDetailsListener(this);
+        InCallPresenter.getInstance().removeInCallEventListener(this);
+        if (mPrimary != null) {
+            CallList.getInstance().removeCallUpdateListener(mPrimary.getId(), this);
+        }
+
+        if (mDistanceHelper != null) {
+            mDistanceHelper.cleanUp();
+        }
+
+        mPrimary = null;
+        mPrimaryContactInfo = null;
+        mSecondaryContactInfo = null;
+    }
+
+    @Override
+    public void onIncomingCall(InCallState oldState, InCallState newState, Call call) {
+        // same logic should happen as with onStateChange()
+        onStateChange(oldState, newState, CallList.getInstance());
+    }
+
+    @Override
+    public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+        Log.d(this, "onStateChange() " + newState);
+        final CallCardUi ui = getUi();
+        if (ui == null) {
+            return;
+        }
+
+        Call primary = null;
+        Call secondary = null;
+
+        if (newState == InCallState.INCOMING) {
+            primary = callList.getIncomingCall();
+        } else if (newState == InCallState.PENDING_OUTGOING || newState == InCallState.OUTGOING) {
+            primary = callList.getOutgoingCall();
+            if (primary == null) {
+                primary = callList.getPendingOutgoingCall();
+            }
+
+            // getCallToDisplay doesn't go through outgoing or incoming calls. It will return the
+            // highest priority call to display as the secondary call.
+            secondary = getCallToDisplay(callList, null, true);
+        } else if (newState == InCallState.INCALL) {
+            primary = getCallToDisplay(callList, null, false);
+            secondary = getCallToDisplay(callList, primary, true);
+        }
+
+        if (mInCallContactInteractions != null &&
+                (oldState == InCallState.INCOMING || newState == InCallState.INCOMING)) {
+            ui.showContactContext(newState != InCallState.INCOMING);
+        }
+
+        Log.d(this, "Primary call: " + primary);
+        Log.d(this, "Secondary call: " + secondary);
+
+        final boolean primaryChanged = !(Call.areSame(mPrimary, primary) &&
+                Call.areSameNumber(mPrimary, primary));
+        final boolean secondaryChanged = !(Call.areSame(mSecondary, secondary) &&
+                Call.areSameNumber(mSecondary, secondary));
+
+        mSecondary = secondary;
+        Call previousPrimary = mPrimary;
+        mPrimary = primary;
+
+        if (primaryChanged && shouldShowNoteSentToast(primary)) {
+            ui.showNoteSentToast();
+        }
+
+        // Refresh primary call information if either:
+        // 1. Primary call changed.
+        // 2. The call's ability to manage conference has changed.
+        // 3. The call subject should be shown or hidden.
+        if (shouldRefreshPrimaryInfo(primaryChanged, ui, shouldShowCallSubject(mPrimary))) {
+            // primary call has changed
+            if (previousPrimary != null) {
+                //clear progess spinner (if any) related to previous primary call
+                maybeShowProgressSpinner(previousPrimary.getState(),
+                        Call.SessionModificationState.NO_REQUEST);
+                CallList.getInstance().removeCallUpdateListener(previousPrimary.getId(), this);
+            }
+            CallList.getInstance().addCallUpdateListener(mPrimary.getId(), this);
+
+            mPrimaryContactInfo = ContactInfoCache.buildCacheEntryFromCall(mContext, mPrimary,
+                    mPrimary.getState() == Call.State.INCOMING);
+            updatePrimaryDisplayInfo();
+            maybeStartSearch(mPrimary, true);
+            mPrimary.setSessionModificationState(Call.SessionModificationState.NO_REQUEST);
+        }
+
+        if (previousPrimary != null && mPrimary == null) {
+            //clear progess spinner (if any) related to previous primary call
+            maybeShowProgressSpinner(previousPrimary.getState(),
+                    Call.SessionModificationState.NO_REQUEST);
+            CallList.getInstance().removeCallUpdateListener(previousPrimary.getId(), this);
+        }
+
+        if (mSecondary == null) {
+            // Secondary call may have ended.  Update the ui.
+            mSecondaryContactInfo = null;
+            updateSecondaryDisplayInfo();
+        } else if (secondaryChanged) {
+            // secondary call has changed
+            mSecondaryContactInfo = ContactInfoCache.buildCacheEntryFromCall(mContext, mSecondary,
+                    mSecondary.getState() == Call.State.INCOMING);
+            updateSecondaryDisplayInfo();
+            maybeStartSearch(mSecondary, false);
+            mSecondary.setSessionModificationState(Call.SessionModificationState.NO_REQUEST);
+        }
+
+        // Start/stop timers.
+        if (isPrimaryCallActive()) {
+            Log.d(this, "Starting the calltime timer");
+            mCallTimer.start(CALL_TIME_UPDATE_INTERVAL_MS);
+        } else {
+            Log.d(this, "Canceling the calltime timer");
+            mCallTimer.cancel();
+            ui.setPrimaryCallElapsedTime(false, 0);
+        }
+
+        // Set the call state
+        int callState = Call.State.IDLE;
+        if (mPrimary != null) {
+            callState = mPrimary.getState();
+            updatePrimaryCallState();
+        } else {
+            getUi().setCallState(
+                    callState,
+                    VideoProfile.STATE_AUDIO_ONLY,
+                    Call.SessionModificationState.NO_REQUEST,
+                    new DisconnectCause(DisconnectCause.UNKNOWN),
+                    null,
+                    null,
+                    null,
+                    false /* isWifi */,
+                    false /* isConference */,
+                    false /* isWorkCall */);
+            getUi().showHdAudioIndicator(false);
+        }
+
+        maybeShowManageConferenceCallButton();
+
+        // Hide the end call button instantly if we're receiving an incoming call.
+        getUi().setEndCallButtonEnabled(shouldShowEndCallButton(mPrimary, callState),
+                callState != Call.State.INCOMING /* animate */);
+
+        maybeSendAccessibilityEvent(oldState, newState);
+    }
+
+    @Override
+    public void onDetailsChanged(Call call, Details details) {
+        updatePrimaryCallState();
+
+        if (call.can(Details.CAPABILITY_MANAGE_CONFERENCE) !=
+                DetailsCompat.can(details, Details.CAPABILITY_MANAGE_CONFERENCE)) {
+            maybeShowManageConferenceCallButton();
+        }
+    }
+
+    @Override
+    public void onCallChanged(Call call) {
+        // No-op; specific call updates handled elsewhere.
+    }
+
+    /**
+     * Handles a change to the session modification state for a call.  Triggers showing the progress
+     * spinner, as well as updating the call state label.
+     *
+     * @param sessionModificationState The new session modification state.
+     */
+    @Override
+    public void onSessionModificationStateChange(int sessionModificationState) {
+        Log.d(this, "onSessionModificationStateChange : sessionModificationState = " +
+                sessionModificationState);
+
+        if (mPrimary == null) {
+            return;
+        }
+        maybeShowProgressSpinner(mPrimary.getState(), sessionModificationState);
+        getUi().setEndCallButtonEnabled(sessionModificationState !=
+                        Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST,
+                true /* shouldAnimate */);
+        updatePrimaryCallState();
+    }
+
+    /**
+     * Handles a change to the last forwarding number by refreshing the primary call info.
+     */
+    @Override
+    public void onLastForwardedNumberChange() {
+        Log.v(this, "onLastForwardedNumberChange");
+
+        if (mPrimary == null) {
+            return;
+        }
+        updatePrimaryDisplayInfo();
+    }
+
+    /**
+     * Handles a change to the child number by refreshing the primary call info.
+     */
+    @Override
+    public void onChildNumberChange() {
+        Log.v(this, "onChildNumberChange");
+
+        if (mPrimary == null) {
+            return;
+        }
+        updatePrimaryDisplayInfo();
+    }
+
+    private boolean shouldRefreshPrimaryInfo(boolean primaryChanged, CallCardUi ui,
+            boolean shouldShowCallSubject) {
+        if (mPrimary == null) {
+            return false;
+        }
+        return primaryChanged ||
+                ui.isManageConferenceVisible() != shouldShowManageConference() ||
+                ui.isCallSubjectVisible() != shouldShowCallSubject;
+    }
+
+    private String getSubscriptionNumber() {
+        // If it's an emergency call, and they're not populating the callback number,
+        // then try to fall back to the phone sub info (to hopefully get the SIM's
+        // number directly from the telephony layer).
+        PhoneAccountHandle accountHandle = mPrimary.getAccountHandle();
+        if (accountHandle != null) {
+            TelecomManager mgr = InCallPresenter.getInstance().getTelecomManager();
+            PhoneAccount account = TelecomManagerCompat.getPhoneAccount(mgr, accountHandle);
+            if (account != null) {
+                return getNumberFromHandle(account.getSubscriptionAddress());
+            }
+        }
+        return null;
+    }
+
+    private void updatePrimaryCallState() {
+        if (getUi() != null && mPrimary != null) {
+            boolean isWorkCall = mPrimary.hasProperty(PROPERTY_WORK_CALL)
+                    || (mPrimaryContactInfo == null ? false
+                            : mPrimaryContactInfo.userType == ContactsUtils.USER_TYPE_WORK);
+            getUi().setCallState(
+                    mPrimary.getState(),
+                    mPrimary.getVideoState(),
+                    mPrimary.getSessionModificationState(),
+                    mPrimary.getDisconnectCause(),
+                    getConnectionLabel(),
+                    getCallStateIcon(),
+                    getGatewayNumber(),
+                    mPrimary.hasProperty(Details.PROPERTY_WIFI),
+                    mPrimary.isConferenceCall(),
+                    isWorkCall);
+
+            maybeShowHdAudioIcon();
+            setCallbackNumber();
+        }
+    }
+
+    /**
+     * Show the HD icon if the call is active and has {@link Details#PROPERTY_HIGH_DEF_AUDIO},
+     * except if the call has a last forwarded number (we will show that icon instead).
+     */
+    private void maybeShowHdAudioIcon() {
+        boolean showHdAudioIndicator =
+                isPrimaryCallActive() && mPrimary.hasProperty(Details.PROPERTY_HIGH_DEF_AUDIO) &&
+                TextUtils.isEmpty(mPrimary.getLastForwardedNumber());
+        getUi().showHdAudioIndicator(showHdAudioIndicator);
+    }
+
+    /**
+     * Only show the conference call button if we can manage the conference.
+     */
+    private void maybeShowManageConferenceCallButton() {
+        getUi().showManageConferenceCallButton(shouldShowManageConference());
+    }
+
+    /**
+     * Determines if a pending session modification exists for the current call.  If so, the
+     * progress spinner is shown, and the call state is updated.
+     *
+     * @param callState The call state.
+     * @param sessionModificationState The session modification state.
+     */
+    private void maybeShowProgressSpinner(int callState, int sessionModificationState) {
+        final boolean show = sessionModificationState ==
+                Call.SessionModificationState.WAITING_FOR_RESPONSE
+                && callState == Call.State.ACTIVE;
+        if (show != mSpinnerShowing) {
+            getUi().setProgressSpinnerVisible(show);
+            mSpinnerShowing = show;
+        }
+    }
+
+    /**
+     * Determines if the manage conference button should be visible, based on the current primary
+     * call.
+     *
+     * @return {@code True} if the manage conference button should be visible.
+     */
+    private boolean shouldShowManageConference() {
+        if (mPrimary == null) {
+            return false;
+        }
+
+        return mPrimary.can(android.telecom.Call.Details.CAPABILITY_MANAGE_CONFERENCE)
+                && !mPrimary.isVideoCall(mContext);
+    }
+
+    private void setCallbackNumber() {
+        String callbackNumber = null;
+
+        // Show the emergency callback number if either:
+        // 1. This is an emergency call.
+        // 2. The phone is in Emergency Callback Mode, which means we should show the callback
+        //    number.
+        boolean showCallbackNumber = mPrimary.hasProperty(Details.PROPERTY_EMERGENCY_CALLBACK_MODE);
+
+        if (mPrimary.isEmergencyCall() || showCallbackNumber) {
+            callbackNumber = getSubscriptionNumber();
+        } else {
+            StatusHints statusHints = mPrimary.getTelecomCall().getDetails().getStatusHints();
+            if (statusHints != null) {
+                Bundle extras = statusHints.getExtras();
+                if (extras != null) {
+                    callbackNumber = extras.getString(TelecomManager.EXTRA_CALL_BACK_NUMBER);
+                }
+            }
+        }
+
+        final String simNumber = TelecomManagerCompat.getLine1Number(
+                InCallPresenter.getInstance().getTelecomManager(),
+                InCallPresenter.getInstance().getTelephonyManager(),
+                mPrimary.getAccountHandle());
+        if (!showCallbackNumber && PhoneNumberUtils.compare(callbackNumber, simNumber)) {
+            Log.d(this, "Numbers are the same (and callback number is not being forced to show);" +
+                    " not showing the callback number");
+            callbackNumber = null;
+        }
+
+        getUi().setCallbackNumber(callbackNumber, mPrimary.isEmergencyCall() || showCallbackNumber);
+    }
+
+    public void updateCallTime() {
+        final CallCardUi ui = getUi();
+
+        if (ui == null) {
+            mCallTimer.cancel();
+        } else if (!isPrimaryCallActive()) {
+            ui.setPrimaryCallElapsedTime(false, 0);
+            mCallTimer.cancel();
+        } else {
+            final long callStart = mPrimary.getConnectTimeMillis();
+            final long duration = System.currentTimeMillis() - callStart;
+            ui.setPrimaryCallElapsedTime(true, duration);
+        }
+    }
+
+    public void onCallStateButtonTouched() {
+        Intent broadcastIntent = ObjectFactory.getCallStateButtonBroadcastIntent(mContext);
+        if (broadcastIntent != null) {
+            Log.d(this, "Sending call state button broadcast: ", broadcastIntent);
+            mContext.sendBroadcast(broadcastIntent, Manifest.permission.READ_PHONE_STATE);
+        }
+    }
+
+    /**
+     * Handles click on the contact photo by toggling fullscreen mode if the current call is a video
+     * call.
+     */
+    public void onContactPhotoClick() {
+        if (mPrimary != null && mPrimary.isVideoCall(mContext)) {
+            InCallPresenter.getInstance().toggleFullscreenMode();
+        }
+    }
+
+    private void maybeStartSearch(Call call, boolean isPrimary) {
+        // no need to start search for conference calls which show generic info.
+        if (call != null && !call.isConferenceCall()) {
+            startContactInfoSearch(call, isPrimary, call.getState() == Call.State.INCOMING);
+        }
+    }
+
+    /**
+     * Starts a query for more contact data for the save primary and secondary calls.
+     */
+    private void startContactInfoSearch(final Call call, final boolean isPrimary,
+            boolean isIncoming) {
+        final ContactInfoCache cache = ContactInfoCache.getInstance(mContext);
+
+        cache.findInfo(call, isIncoming, new ContactLookupCallback(this, isPrimary));
+    }
+
+    private void onContactInfoComplete(String callId, ContactCacheEntry entry, boolean isPrimary) {
+        final boolean entryMatchesExistingCall =
+                (isPrimary && mPrimary != null && TextUtils.equals(callId,  mPrimary.getId())) ||
+                (!isPrimary && mSecondary != null && TextUtils.equals(callId, mSecondary.getId()));
+        if (entryMatchesExistingCall) {
+            updateContactEntry(entry, isPrimary);
+        } else {
+            Log.w(this, "Dropping stale contact lookup info for " + callId);
+        }
+
+        final Call call = CallList.getInstance().getCallById(callId);
+        if (call != null) {
+            call.getLogState().contactLookupResult = entry.contactLookupResult;
+        }
+        if (entry.contactUri != null) {
+            CallerInfoUtils.sendViewNotification(mContext, entry.contactUri);
+        }
+    }
+
+    private void onImageLoadComplete(String callId, ContactCacheEntry entry) {
+        if (getUi() == null) {
+            return;
+        }
+
+        if (entry.photo != null) {
+            if (mPrimary != null && callId.equals(mPrimary.getId())) {
+                boolean showContactPhoto = !VideoCallPresenter.showIncomingVideo(
+                        mPrimary.getVideoState(), mPrimary.getState());
+                getUi().setPrimaryImage(entry.photo, showContactPhoto);
+            }
+        }
+    }
+
+    private void onContactInteractionsInfoComplete(String callId, ContactCacheEntry entry) {
+        if (getUi() == null) {
+            return;
+        }
+
+        if (mPrimary != null && callId.equals(mPrimary.getId())) {
+            mPrimaryContactInfo.locationAddress = entry.locationAddress;
+            updateContactInteractions();
+        }
+    }
+
+    @Override
+    public void onLocationReady() {
+        // This will only update the contacts interactions data if the location returns after
+        // the contact information is found.
+        updateContactInteractions();
+    }
+
+    private void updateContactInteractions() {
+        if (mPrimary != null && mPrimaryContactInfo != null
+                && (mPrimaryContactInfo.locationAddress != null
+                        || mPrimaryContactInfo.openingHours != null)) {
+            // TODO: This is hardcoded to "isBusiness" because functionality to differentiate
+            // between business and personal has not yet been added.
+            if (setInCallContactInteractionsType(true /* isBusiness */)) {
+                getUi().setContactContextTitle(
+                        mInCallContactInteractions.getBusinessListHeaderView());
+            }
+
+            mInCallContactInteractions.setBusinessInfo(
+                    mPrimaryContactInfo.locationAddress,
+                    mDistanceHelper.calculateDistance(mPrimaryContactInfo.locationAddress),
+                    mPrimaryContactInfo.openingHours);
+            getUi().setContactContextContent(mInCallContactInteractions.getListAdapter());
+            getUi().showContactContext(mPrimary.getState() != State.INCOMING);
+        } else {
+            getUi().showContactContext(false);
+        }
+    }
+
+    /**
+     * Update the contact interactions type so that the correct UI is shown.
+     *
+     * @param isBusiness {@code true} if the interaction is a business interaction, {@code false} if
+     * it is a personal contact.
+     *
+     * @return {@code true} if this is a new type of contact interaction (business or personal).
+     * {@code false} if it hasn't changed.
+     */
+    private boolean setInCallContactInteractionsType(boolean isBusiness) {
+        if (mInCallContactInteractions == null) {
+            mInCallContactInteractions =
+                    new InCallContactInteractions(mContext, isBusiness);
+            return true;
+        }
+
+        return mInCallContactInteractions.switchContactType(isBusiness);
+    }
+
+    private void updateContactEntry(ContactCacheEntry entry, boolean isPrimary) {
+        if (isPrimary) {
+            mPrimaryContactInfo = entry;
+            updatePrimaryDisplayInfo();
+        } else {
+            mSecondaryContactInfo = entry;
+            updateSecondaryDisplayInfo();
+        }
+    }
+
+    /**
+     * Get the highest priority call to display.
+     * Goes through the calls and chooses which to return based on priority of which type of call
+     * to display to the user. Callers can use the "ignore" feature to get the second best call
+     * by passing a previously found primary call as ignore.
+     *
+     * @param ignore A call to ignore if found.
+     */
+    private Call getCallToDisplay(CallList callList, Call ignore, boolean skipDisconnected) {
+        // Active calls come second.  An active call always gets precedent.
+        Call retval = callList.getActiveCall();
+        if (retval != null && retval != ignore) {
+            return retval;
+        }
+
+        // Disconnected calls get primary position if there are no active calls
+        // to let user know quickly what call has disconnected. Disconnected
+        // calls are very short lived.
+        if (!skipDisconnected) {
+            retval = callList.getDisconnectingCall();
+            if (retval != null && retval != ignore) {
+                return retval;
+            }
+            retval = callList.getDisconnectedCall();
+            if (retval != null && retval != ignore) {
+                return retval;
+            }
+        }
+
+        // Then we go to background call (calls on hold)
+        retval = callList.getBackgroundCall();
+        if (retval != null && retval != ignore) {
+            return retval;
+        }
+
+        // Lastly, we go to a second background call.
+        retval = callList.getSecondBackgroundCall();
+
+        return retval;
+    }
+
+    private void updatePrimaryDisplayInfo() {
+        final CallCardUi ui = getUi();
+        if (ui == null) {
+            // TODO: May also occur if search result comes back after ui is destroyed. Look into
+            // removing that case completely.
+            Log.d(TAG, "updatePrimaryDisplayInfo called but ui is null!");
+            return;
+        }
+
+        if (mPrimary == null) {
+            // Clear the primary display info.
+            ui.setPrimary(null, null, false, null, null, false, false, false);
+            return;
+        }
+
+        // Hide the contact photo if we are in a video call and the incoming video surface is
+        // showing.
+        boolean showContactPhoto = !VideoCallPresenter
+                .showIncomingVideo(mPrimary.getVideoState(), mPrimary.getState());
+
+        // Call placed through a work phone account.
+        boolean hasWorkCallProperty = mPrimary.hasProperty(PROPERTY_WORK_CALL);
+
+        if (mPrimary.isConferenceCall()) {
+            Log.d(TAG, "Update primary display info for conference call.");
+
+            ui.setPrimary(
+                    null /* number */,
+                    getConferenceString(mPrimary),
+                    false /* nameIsNumber */,
+                    null /* label */,
+                    getConferencePhoto(mPrimary),
+                    false /* isSipCall */,
+                    showContactPhoto,
+                    hasWorkCallProperty);
+        } else if (mPrimaryContactInfo != null) {
+            Log.d(TAG, "Update primary display info for " + mPrimaryContactInfo);
+
+            String name = getNameForCall(mPrimaryContactInfo);
+            String number;
+
+            boolean isChildNumberShown = !TextUtils.isEmpty(mPrimary.getChildNumber());
+            boolean isForwardedNumberShown = !TextUtils.isEmpty(mPrimary.getLastForwardedNumber());
+            boolean isCallSubjectShown = shouldShowCallSubject(mPrimary);
+
+            if (isCallSubjectShown) {
+                ui.setCallSubject(mPrimary.getCallSubject());
+            } else {
+                ui.setCallSubject(null);
+            }
+
+            if (isCallSubjectShown) {
+                number = null;
+            } else if (isChildNumberShown) {
+                number = mContext.getString(R.string.child_number, mPrimary.getChildNumber());
+            } else if (isForwardedNumberShown) {
+                // Use last forwarded number instead of second line, if present.
+                number = mPrimary.getLastForwardedNumber();
+            } else {
+                number = getNumberForCall(mPrimaryContactInfo);
+            }
+
+            ui.showForwardIndicator(isForwardedNumberShown);
+            maybeShowHdAudioIcon();
+
+            boolean nameIsNumber = name != null && name.equals(mPrimaryContactInfo.number);
+            // Call with caller that is a work contact.
+            boolean isWorkContact = (mPrimaryContactInfo.userType == ContactsUtils.USER_TYPE_WORK);
+            ui.setPrimary(
+                    number,
+                    name,
+                    nameIsNumber,
+                    isChildNumberShown || isCallSubjectShown ? null : mPrimaryContactInfo.label,
+                    mPrimaryContactInfo.photo,
+                    mPrimaryContactInfo.isSipCall,
+                    showContactPhoto,
+                    hasWorkCallProperty || isWorkContact);
+
+            updateContactInteractions();
+        } else {
+            // Clear the primary display info.
+            ui.setPrimary(null, null, false, null, null, false, false, false);
+        }
+
+        if (mEmergencyCallListener != null) {
+            boolean isEmergencyCall = mPrimary.isEmergencyCall();
+            mEmergencyCallListener.onCallUpdated((BaseFragment) ui, isEmergencyCall);
+        }
+    }
+
+    private void updateSecondaryDisplayInfo() {
+        final CallCardUi ui = getUi();
+        if (ui == null) {
+            return;
+        }
+
+        if (mSecondary == null) {
+            // Clear the secondary display info.
+            ui.setSecondary(false, null, false, null, null, false /* isConference */,
+                    false /* isVideoCall */, mIsFullscreen);
+            return;
+        }
+
+        if (mSecondary.isConferenceCall()) {
+            ui.setSecondary(
+                    true /* show */,
+                    getConferenceString(mSecondary),
+                    false /* nameIsNumber */,
+                    null /* label */,
+                    getCallProviderLabel(mSecondary),
+                    true /* isConference */,
+                    mSecondary.isVideoCall(mContext),
+                    mIsFullscreen);
+        } else if (mSecondaryContactInfo != null) {
+            Log.d(TAG, "updateSecondaryDisplayInfo() " + mSecondaryContactInfo);
+            String name = getNameForCall(mSecondaryContactInfo);
+            boolean nameIsNumber = name != null && name.equals(mSecondaryContactInfo.number);
+            ui.setSecondary(
+                    true /* show */,
+                    name,
+                    nameIsNumber,
+                    mSecondaryContactInfo.label,
+                    getCallProviderLabel(mSecondary),
+                    false /* isConference */,
+                    mSecondary.isVideoCall(mContext),
+                    mIsFullscreen);
+        } else {
+            // Clear the secondary display info.
+            ui.setSecondary(false, null, false, null, null, false /* isConference */,
+                    false /* isVideoCall */, mIsFullscreen);
+        }
+    }
+
+
+    /**
+     * Gets the phone account to display for a call.
+     */
+    private PhoneAccount getAccountForCall(Call call) {
+        PhoneAccountHandle accountHandle = call.getAccountHandle();
+        if (accountHandle == null) {
+            return null;
+        }
+        return TelecomManagerCompat.getPhoneAccount(
+                InCallPresenter.getInstance().getTelecomManager(),
+                accountHandle);
+    }
+
+    /**
+     * Returns the gateway number for any existing outgoing call.
+     */
+    private String getGatewayNumber() {
+        if (hasOutgoingGatewayCall()) {
+            return getNumberFromHandle(mPrimary.getGatewayInfo().getGatewayAddress());
+        }
+        return null;
+    }
+
+    /**
+     * Return the string label to represent the call provider
+     */
+    private String getCallProviderLabel(Call call) {
+        PhoneAccount account = getAccountForCall(call);
+        TelecomManager mgr = InCallPresenter.getInstance().getTelecomManager();
+        if (account != null && !TextUtils.isEmpty(account.getLabel())
+                && TelecomManagerCompat.getCallCapablePhoneAccounts(mgr).size() > 1) {
+            return account.getLabel().toString();
+        }
+        return null;
+    }
+
+    /**
+     * Returns the label (line of text above the number/name) for any given call.
+     * For example, "calling via [Account/Google Voice]" for outgoing calls.
+     */
+    private String getConnectionLabel() {
+        StatusHints statusHints = mPrimary.getTelecomCall().getDetails().getStatusHints();
+        if (statusHints != null && !TextUtils.isEmpty(statusHints.getLabel())) {
+            return statusHints.getLabel().toString();
+        }
+
+        if (hasOutgoingGatewayCall() && getUi() != null) {
+            // Return the label for the gateway app on outgoing calls.
+            final PackageManager pm = mContext.getPackageManager();
+            try {
+                ApplicationInfo info = pm.getApplicationInfo(
+                        mPrimary.getGatewayInfo().getGatewayProviderPackageName(), 0);
+                return pm.getApplicationLabel(info).toString();
+            } catch (PackageManager.NameNotFoundException e) {
+                Log.e(this, "Gateway Application Not Found.", e);
+                return null;
+            }
+        }
+        return getCallProviderLabel(mPrimary);
+    }
+
+    private Drawable getCallStateIcon() {
+        // Return connection icon if one exists.
+        StatusHints statusHints = mPrimary.getTelecomCall().getDetails().getStatusHints();
+        if (statusHints != null && statusHints.getIcon() != null) {
+            Drawable icon = statusHints.getIcon().loadDrawable(mContext);
+            if (icon != null) {
+                return icon;
+            }
+        }
+
+        return null;
+    }
+
+    private boolean hasOutgoingGatewayCall() {
+        // We only display the gateway information while STATE_DIALING so return false for any other
+        // call state.
+        // TODO: mPrimary can be null because this is called from updatePrimaryDisplayInfo which
+        // is also called after a contact search completes (call is not present yet).  Split the
+        // UI update so it can receive independent updates.
+        if (mPrimary == null) {
+            return false;
+        }
+        return Call.State.isDialing(mPrimary.getState()) && mPrimary.getGatewayInfo() != null &&
+                !mPrimary.getGatewayInfo().isEmpty();
+    }
+
+    /**
+     * Gets the name to display for the call.
+     */
+    @NeededForTesting
+    String getNameForCall(ContactCacheEntry contactInfo) {
+        String preferredName = ContactDisplayUtils.getPreferredDisplayName(
+                contactInfo.namePrimary,
+                contactInfo.nameAlternative,
+                mContactsPreferences);
+        if (TextUtils.isEmpty(preferredName)) {
+            return contactInfo.number;
+        }
+        return preferredName;
+    }
+
+    /**
+     * Gets the number to display for a call.
+     */
+    @NeededForTesting
+    String getNumberForCall(ContactCacheEntry contactInfo) {
+        // If the name is empty, we use the number for the name...so don't show a second
+        // number in the number field
+        String preferredName = ContactDisplayUtils.getPreferredDisplayName(
+                    contactInfo.namePrimary,
+                    contactInfo.nameAlternative,
+                    mContactsPreferences);
+        if (TextUtils.isEmpty(preferredName)) {
+            return contactInfo.location;
+        }
+        return contactInfo.number;
+    }
+
+    public void secondaryInfoClicked() {
+        if (mSecondary == null) {
+            Log.w(this, "Secondary info clicked but no secondary call.");
+            return;
+        }
+
+        Log.i(this, "Swapping call to foreground: " + mSecondary);
+        TelecomAdapter.getInstance().unholdCall(mSecondary.getId());
+    }
+
+    public void endCallClicked() {
+        if (mPrimary == null) {
+            return;
+        }
+
+        Log.i(this, "Disconnecting call: " + mPrimary);
+        final String callId = mPrimary.getId();
+        mPrimary.setState(Call.State.DISCONNECTING);
+        CallList.getInstance().onUpdate(mPrimary);
+        TelecomAdapter.getInstance().disconnectCall(callId);
+    }
+
+    private String getNumberFromHandle(Uri handle) {
+        return handle == null ? "" : handle.getSchemeSpecificPart();
+    }
+
+    /**
+     * Handles a change to the fullscreen mode of the in-call UI.
+     *
+     * @param isFullscreenMode {@code True} if the in-call UI is entering full screen mode.
+     */
+    @Override
+    public void onFullscreenModeChanged(boolean isFullscreenMode) {
+        mIsFullscreen = isFullscreenMode;
+        final CallCardUi ui = getUi();
+        if (ui == null) {
+            return;
+        }
+        ui.setCallCardVisible(!isFullscreenMode);
+        ui.setSecondaryInfoVisible(!isFullscreenMode);
+    }
+
+    @Override
+    public void onSecondaryCallerInfoVisibilityChanged(boolean isVisible, int height) {
+        // No-op - the Call Card is the origin of this event.
+    }
+
+    private boolean isPrimaryCallActive() {
+        return mPrimary != null && mPrimary.getState() == Call.State.ACTIVE;
+    }
+
+    private String getConferenceString(Call call) {
+        boolean isGenericConference = call.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE);
+        Log.v(this, "getConferenceString: " + isGenericConference);
+
+        final int resId = isGenericConference
+                ? R.string.card_title_in_call : R.string.card_title_conf_call;
+        return mContext.getResources().getString(resId);
+    }
+
+    private Drawable getConferencePhoto(Call call) {
+        boolean isGenericConference = call.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE);
+        Log.v(this, "getConferencePhoto: " + isGenericConference);
+
+        final int resId = isGenericConference
+                ? R.drawable.img_phone : R.drawable.img_conference;
+        Drawable photo = mContext.getResources().getDrawable(resId);
+        photo.setAutoMirrored(true);
+        return photo;
+    }
+
+    private boolean shouldShowEndCallButton(Call primary, int callState) {
+        if (primary == null) {
+            return false;
+        }
+        if ((!Call.State.isConnectingOrConnected(callState)
+                && callState != Call.State.DISCONNECTING) || callState == Call.State.INCOMING) {
+            return false;
+        }
+        if (mPrimary.getSessionModificationState()
+                == Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+            return false;
+        }
+        return true;
+    }
+
+    private void maybeSendAccessibilityEvent(InCallState oldState, InCallState newState) {
+        if (mContext == null) {
+            return;
+        }
+        final AccessibilityManager am = (AccessibilityManager) mContext.getSystemService(
+                Context.ACCESSIBILITY_SERVICE);
+        if (!am.isEnabled()) {
+            return;
+        }
+        if ((oldState != InCallState.OUTGOING && newState == InCallState.OUTGOING)
+                || (oldState != InCallState.INCOMING && newState == InCallState.INCOMING)) {
+            if (getUi() != null) {
+                getUi().sendAccessibilityAnnouncement();
+            }
+        }
+    }
+
+    /**
+     * Determines whether the call subject should be visible on the UI.  For the call subject to be
+     * visible, the call has to be in an incoming or waiting state, and the subject must not be
+     * empty.
+     *
+     * @param call The call.
+     * @return {@code true} if the subject should be shown, {@code false} otherwise.
+     */
+    private boolean shouldShowCallSubject(Call call) {
+        if (call == null) {
+            return false;
+        }
+
+        boolean isIncomingOrWaiting = mPrimary.getState() == Call.State.INCOMING ||
+                mPrimary.getState() == Call.State.CALL_WAITING;
+        return isIncomingOrWaiting && !TextUtils.isEmpty(call.getCallSubject()) &&
+                call.getNumberPresentation() == TelecomManager.PRESENTATION_ALLOWED &&
+                call.isCallSubjectSupported();
+    }
+
+    /**
+     * Determines whether the "note sent" toast should be shown.  It should be shown for a new
+     * outgoing call with a subject.
+     *
+     * @param call The call
+     * @return {@code true} if the toast should be shown, {@code false} otherwise.
+     */
+    private boolean shouldShowNoteSentToast(Call call) {
+        return call != null && hasCallSubject(call) && (call.getState() == Call.State.DIALING
+                || call.getState() == Call.State.CONNECTING);
+    }
+
+    private static boolean hasCallSubject(Call call) {
+        return !TextUtils.isEmpty(DetailsCompat.getIntentExtras(
+                call.getTelecomCall().getDetails()).getString(TelecomManager.EXTRA_CALL_SUBJECT));
+    }
+
+    public interface CallCardUi extends Ui {
+        void setVisible(boolean on);
+        void setContactContextTitle(View listHeaderView);
+        void setContactContextContent(ListAdapter listAdapter);
+        void showContactContext(boolean show);
+        void setCallCardVisible(boolean visible);
+        void setPrimary(String number, String name, boolean nameIsNumber, String label,
+                Drawable photo, boolean isSipCall, boolean isContactPhotoShown, boolean isWorkCall);
+        void setSecondary(boolean show, String name, boolean nameIsNumber, String label,
+                String providerLabel, boolean isConference, boolean isVideoCall,
+                boolean isFullscreen);
+        void setSecondaryInfoVisible(boolean visible);
+        void setCallState(int state, int videoState, int sessionModificationState,
+                DisconnectCause disconnectCause, String connectionLabel,
+                Drawable connectionIcon, String gatewayNumber, boolean isWifi,
+                boolean isConference, boolean isWorkCall);
+        void setPrimaryCallElapsedTime(boolean show, long duration);
+        void setPrimaryName(String name, boolean nameIsNumber);
+        void setPrimaryImage(Drawable image, boolean isVisible);
+        void setPrimaryPhoneNumber(String phoneNumber);
+        void setPrimaryLabel(String label);
+        void setEndCallButtonEnabled(boolean enabled, boolean animate);
+        void setCallbackNumber(String number, boolean isEmergencyCalls);
+        void setCallSubject(String callSubject);
+        void setProgressSpinnerVisible(boolean visible);
+        void showHdAudioIndicator(boolean visible);
+        void showForwardIndicator(boolean visible);
+        void showManageConferenceCallButton(boolean visible);
+        boolean isManageConferenceVisible();
+        boolean isCallSubjectVisible();
+        void animateForNewOutgoingCall();
+        void sendAccessibilityAnnouncement();
+        void showNoteSentToast();
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/CallList.java b/InCallUI/src/com/android/incallui/CallList.java
new file mode 100644
index 0000000..99def36
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/CallList.java
@@ -0,0 +1,674 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.os.Handler;
+import android.os.Message;
+import android.os.Trace;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccount;
+
+import com.android.contacts.common.testing.NeededForTesting;
+import com.android.dialer.database.FilteredNumberAsyncQueryHandler;
+import com.android.dialer.logging.Logger;
+import com.android.incallui.util.TelecomCallUtil;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Maintains the list of active calls and notifies interested classes of changes to the call list
+ * as they are received from the telephony stack. Primary listener of changes to this class is
+ * InCallPresenter.
+ */
+public class CallList {
+
+    private static final int DISCONNECTED_CALL_SHORT_TIMEOUT_MS = 200;
+    private static final int DISCONNECTED_CALL_MEDIUM_TIMEOUT_MS = 2000;
+    private static final int DISCONNECTED_CALL_LONG_TIMEOUT_MS = 5000;
+
+    private static final int EVENT_DISCONNECTED_TIMEOUT = 1;
+    private static final long BLOCK_QUERY_TIMEOUT_MS = 1000;
+
+    private static CallList sInstance = new CallList();
+
+    private final HashMap<String, Call> mCallById = new HashMap<>();
+    private final HashMap<android.telecom.Call, Call> mCallByTelecomCall = new HashMap<>();
+    private final HashMap<String, List<String>> mCallTextReponsesMap = Maps.newHashMap();
+    /**
+     * ConcurrentHashMap constructor params: 8 is initial table size, 0.9f is
+     * load factor before resizing, 1 means we only expect a single thread to
+     * access the map so make only a single shard
+     */
+    private final Set<Listener> mListeners = Collections.newSetFromMap(
+            new ConcurrentHashMap<Listener, Boolean>(8, 0.9f, 1));
+    private final HashMap<String, List<CallUpdateListener>> mCallUpdateListenerMap = Maps
+            .newHashMap();
+    private final Set<Call> mPendingDisconnectCalls = Collections.newSetFromMap(
+            new ConcurrentHashMap<Call, Boolean>(8, 0.9f, 1));
+    private FilteredNumberAsyncQueryHandler mFilteredQueryHandler;
+
+    /**
+     * Static singleton accessor method.
+     */
+    public static CallList getInstance() {
+        return sInstance;
+    }
+
+    /**
+     * USED ONLY FOR TESTING
+     * Testing-only constructor.  Instance should only be acquired through getInstance().
+     */
+    @NeededForTesting
+    CallList() {
+    }
+
+    public void onCallAdded(final android.telecom.Call telecomCall) {
+        Trace.beginSection("onCallAdded");
+        final Call call = new Call(telecomCall);
+        Log.d(this, "onCallAdded: callState=" + call.getState());
+
+        if (call.getState() == Call.State.INCOMING ||
+                call.getState() == Call.State.CALL_WAITING) {
+            onIncoming(call, call.getCannedSmsResponses());
+        } else {
+            onUpdate(call);
+        }
+
+        call.logCallInitiationType();
+        Trace.endSection();
+    }
+
+    public void onCallRemoved(android.telecom.Call telecomCall) {
+        if (mCallByTelecomCall.containsKey(telecomCall)) {
+            Call call = mCallByTelecomCall.get(telecomCall);
+            Logger.logCall(call);
+            if (updateCallInMap(call)) {
+                Log.w(this, "Removing call not previously disconnected " + call.getId());
+            }
+            updateCallTextMap(call, null);
+        }
+    }
+
+    /**
+     * Called when a single call disconnects.
+     */
+    public void onDisconnect(Call call) {
+        if (updateCallInMap(call)) {
+            Log.i(this, "onDisconnect: " + call);
+            // notify those listening for changes on this specific change
+            notifyCallUpdateListeners(call);
+            // notify those listening for all disconnects
+            notifyListenersOfDisconnect(call);
+        }
+    }
+
+    /**
+     * Called when a single call has changed.
+     */
+    public void onIncoming(Call call, List<String> textMessages) {
+        if (updateCallInMap(call)) {
+            Log.i(this, "onIncoming - " + call);
+        }
+        updateCallTextMap(call, textMessages);
+
+        for (Listener listener : mListeners) {
+            listener.onIncomingCall(call);
+        }
+    }
+
+    public void onUpgradeToVideo(Call call){
+        Log.d(this, "onUpgradeToVideo call=" + call);
+        for (Listener listener : mListeners) {
+            listener.onUpgradeToVideo(call);
+        }
+    }
+    /**
+     * Called when a single call has changed.
+     */
+    public void onUpdate(Call call) {
+        Trace.beginSection("onUpdate");
+        onUpdateCall(call);
+        notifyGenericListeners();
+        Trace.endSection();
+    }
+
+    /**
+     * Called when a single call has changed session modification state.
+     *
+     * @param call The call.
+     * @param sessionModificationState The new session modification state.
+     */
+    public void onSessionModificationStateChange(Call call, int sessionModificationState) {
+        final List<CallUpdateListener> listeners = mCallUpdateListenerMap.get(call.getId());
+        if (listeners != null) {
+            for (CallUpdateListener listener : listeners) {
+                listener.onSessionModificationStateChange(sessionModificationState);
+            }
+        }
+    }
+
+    /**
+     * Called when the last forwarded number changes for a call.  With IMS, the last forwarded
+     * number changes due to a supplemental service notification, so it is not pressent at the
+     * start of the call.
+     *
+     * @param call The call.
+     */
+    public void onLastForwardedNumberChange(Call call) {
+        final List<CallUpdateListener> listeners = mCallUpdateListenerMap.get(call.getId());
+        if (listeners != null) {
+            for (CallUpdateListener listener : listeners) {
+                listener.onLastForwardedNumberChange();
+            }
+        }
+    }
+
+    /**
+     * Called when the child number changes for a call.  The child number can be received after a
+     * call is initially set up, so we need to be able to inform listeners of the change.
+     *
+     * @param call The call.
+     */
+    public void onChildNumberChange(Call call) {
+        final List<CallUpdateListener> listeners = mCallUpdateListenerMap.get(call.getId());
+        if (listeners != null) {
+            for (CallUpdateListener listener : listeners) {
+                listener.onChildNumberChange();
+            }
+        }
+    }
+
+    public void notifyCallUpdateListeners(Call call) {
+        final List<CallUpdateListener> listeners = mCallUpdateListenerMap.get(call.getId());
+        if (listeners != null) {
+            for (CallUpdateListener listener : listeners) {
+                listener.onCallChanged(call);
+            }
+        }
+    }
+
+    /**
+     * Add a call update listener for a call id.
+     *
+     * @param callId The call id to get updates for.
+     * @param listener The listener to add.
+     */
+    public void addCallUpdateListener(String callId, CallUpdateListener listener) {
+        List<CallUpdateListener> listeners = mCallUpdateListenerMap.get(callId);
+        if (listeners == null) {
+            listeners = new CopyOnWriteArrayList<CallUpdateListener>();
+            mCallUpdateListenerMap.put(callId, listeners);
+        }
+        listeners.add(listener);
+    }
+
+    /**
+     * Remove a call update listener for a call id.
+     *
+     * @param callId The call id to remove the listener for.
+     * @param listener The listener to remove.
+     */
+    public void removeCallUpdateListener(String callId, CallUpdateListener listener) {
+        List<CallUpdateListener> listeners = mCallUpdateListenerMap.get(callId);
+        if (listeners != null) {
+            listeners.remove(listener);
+        }
+    }
+
+    public void addListener(Listener listener) {
+        Preconditions.checkNotNull(listener);
+
+        mListeners.add(listener);
+
+        // Let the listener know about the active calls immediately.
+        listener.onCallListChange(this);
+    }
+
+    public void removeListener(Listener listener) {
+        if (listener != null) {
+            mListeners.remove(listener);
+        }
+    }
+
+    /**
+     * TODO: Change so that this function is not needed. Instead of assuming there is an active
+     * call, the code should rely on the status of a specific Call and allow the presenters to
+     * update the Call object when the active call changes.
+     */
+    public Call getIncomingOrActive() {
+        Call retval = getIncomingCall();
+        if (retval == null) {
+            retval = getActiveCall();
+        }
+        return retval;
+    }
+
+    public Call getOutgoingOrActive() {
+        Call retval = getOutgoingCall();
+        if (retval == null) {
+            retval = getActiveCall();
+        }
+        return retval;
+    }
+
+    /**
+     * A call that is waiting for {@link PhoneAccount} selection
+     */
+    public Call getWaitingForAccountCall() {
+        return getFirstCallWithState(Call.State.SELECT_PHONE_ACCOUNT);
+    }
+
+    public Call getPendingOutgoingCall() {
+        return getFirstCallWithState(Call.State.CONNECTING);
+    }
+
+    public Call getOutgoingCall() {
+        Call call = getFirstCallWithState(Call.State.DIALING);
+        if (call == null) {
+            call = getFirstCallWithState(Call.State.REDIALING);
+        }
+        return call;
+    }
+
+    public Call getActiveCall() {
+        return getFirstCallWithState(Call.State.ACTIVE);
+    }
+
+    public Call getBackgroundCall() {
+        return getFirstCallWithState(Call.State.ONHOLD);
+    }
+
+    public Call getDisconnectedCall() {
+        return getFirstCallWithState(Call.State.DISCONNECTED);
+    }
+
+    public Call getDisconnectingCall() {
+        return getFirstCallWithState(Call.State.DISCONNECTING);
+    }
+
+    public Call getSecondBackgroundCall() {
+        return getCallWithState(Call.State.ONHOLD, 1);
+    }
+
+    public Call getActiveOrBackgroundCall() {
+        Call call = getActiveCall();
+        if (call == null) {
+            call = getBackgroundCall();
+        }
+        return call;
+    }
+
+    public Call getIncomingCall() {
+        Call call = getFirstCallWithState(Call.State.INCOMING);
+        if (call == null) {
+            call = getFirstCallWithState(Call.State.CALL_WAITING);
+        }
+
+        return call;
+    }
+
+    public Call getFirstCall() {
+        Call result = getIncomingCall();
+        if (result == null) {
+            result = getPendingOutgoingCall();
+        }
+        if (result == null) {
+            result = getOutgoingCall();
+        }
+        if (result == null) {
+            result = getFirstCallWithState(Call.State.ACTIVE);
+        }
+        if (result == null) {
+            result = getDisconnectingCall();
+        }
+        if (result == null) {
+            result = getDisconnectedCall();
+        }
+        return result;
+    }
+
+    public boolean hasLiveCall() {
+        Call call = getFirstCall();
+        if (call == null) {
+            return false;
+        }
+        return call != getDisconnectingCall() && call != getDisconnectedCall();
+    }
+
+    /**
+     * Returns the first call found in the call map with the specified call modification state.
+     * @param state The session modification state to search for.
+     * @return The first call with the specified state.
+     */
+    public Call getVideoUpgradeRequestCall() {
+        for(Call call : mCallById.values()) {
+            if (call.getSessionModificationState() ==
+                    Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+                return call;
+            }
+        }
+        return null;
+    }
+
+    public Call getCallById(String callId) {
+        return mCallById.get(callId);
+    }
+
+    public Call getCallByTelecomCall(android.telecom.Call telecomCall) {
+        return mCallByTelecomCall.get(telecomCall);
+    }
+
+    public List<String> getTextResponses(String callId) {
+        return mCallTextReponsesMap.get(callId);
+    }
+
+    /**
+     * Returns first call found in the call map with the specified state.
+     */
+    public Call getFirstCallWithState(int state) {
+        return getCallWithState(state, 0);
+    }
+
+    /**
+     * Returns the [position]th call found in the call map with the specified state.
+     * TODO: Improve this logic to sort by call time.
+     */
+    public Call getCallWithState(int state, int positionToFind) {
+        Call retval = null;
+        int position = 0;
+        for (Call call : mCallById.values()) {
+            if (call.getState() == state) {
+                if (position >= positionToFind) {
+                    retval = call;
+                    break;
+                } else {
+                    position++;
+                }
+            }
+        }
+
+        return retval;
+    }
+
+    /**
+     * This is called when the service disconnects, either expectedly or unexpectedly.
+     * For the expected case, it's because we have no calls left.  For the unexpected case,
+     * it is likely a crash of phone and we need to clean up our calls manually.  Without phone,
+     * there can be no active calls, so this is relatively safe thing to do.
+     */
+    public void clearOnDisconnect() {
+        for (Call call : mCallById.values()) {
+            final int state = call.getState();
+            if (state != Call.State.IDLE &&
+                    state != Call.State.INVALID &&
+                    state != Call.State.DISCONNECTED) {
+
+                call.setState(Call.State.DISCONNECTED);
+                call.setDisconnectCause(new DisconnectCause(DisconnectCause.UNKNOWN));
+                updateCallInMap(call);
+            }
+        }
+        notifyGenericListeners();
+    }
+
+    /**
+     * Called when the user has dismissed an error dialog. This indicates acknowledgement of
+     * the disconnect cause, and that any pending disconnects should immediately occur.
+     */
+    public void onErrorDialogDismissed() {
+        final Iterator<Call> iterator = mPendingDisconnectCalls.iterator();
+        while (iterator.hasNext()) {
+            Call call = iterator.next();
+            iterator.remove();
+            finishDisconnectedCall(call);
+        }
+    }
+
+    /**
+     * Processes an update for a single call.
+     *
+     * @param call The call to update.
+     */
+    private void onUpdateCall(Call call) {
+        Log.d(this, "\t" + call);
+        if (updateCallInMap(call)) {
+            Log.i(this, "onUpdate - " + call);
+        }
+        updateCallTextMap(call, call.getCannedSmsResponses());
+        notifyCallUpdateListeners(call);
+    }
+
+    /**
+     * Sends a generic notification to all listeners that something has changed.
+     * It is up to the listeners to call back to determine what changed.
+     */
+    private void notifyGenericListeners() {
+        for (Listener listener : mListeners) {
+            listener.onCallListChange(this);
+        }
+    }
+
+    private void notifyListenersOfDisconnect(Call call) {
+        for (Listener listener : mListeners) {
+            listener.onDisconnect(call);
+        }
+    }
+
+    /**
+     * Updates the call entry in the local map.
+     * @return false if no call previously existed and no call was added, otherwise true.
+     */
+    private boolean updateCallInMap(Call call) {
+        Preconditions.checkNotNull(call);
+
+        boolean updated = false;
+
+        if (call.getState() == Call.State.DISCONNECTED) {
+            // update existing (but do not add!!) disconnected calls
+            if (mCallById.containsKey(call.getId())) {
+                // For disconnected calls, we want to keep them alive for a few seconds so that the
+                // UI has a chance to display anything it needs when a call is disconnected.
+
+                // Set up a timer to destroy the call after X seconds.
+                final Message msg = mHandler.obtainMessage(EVENT_DISCONNECTED_TIMEOUT, call);
+                mHandler.sendMessageDelayed(msg, getDelayForDisconnect(call));
+                mPendingDisconnectCalls.add(call);
+
+                mCallById.put(call.getId(), call);
+                mCallByTelecomCall.put(call.getTelecomCall(), call);
+                updated = true;
+            }
+        } else if (!isCallDead(call)) {
+            mCallById.put(call.getId(), call);
+            mCallByTelecomCall.put(call.getTelecomCall(), call);
+            updated = true;
+        } else if (mCallById.containsKey(call.getId())) {
+            mCallById.remove(call.getId());
+            mCallByTelecomCall.remove(call.getTelecomCall());
+            updated = true;
+        }
+
+        return updated;
+    }
+
+    private int getDelayForDisconnect(Call call) {
+        Preconditions.checkState(call.getState() == Call.State.DISCONNECTED);
+
+
+        final int cause = call.getDisconnectCause().getCode();
+        final int delay;
+        switch (cause) {
+            case DisconnectCause.LOCAL:
+                delay = DISCONNECTED_CALL_SHORT_TIMEOUT_MS;
+                break;
+            case DisconnectCause.REMOTE:
+            case DisconnectCause.ERROR:
+                delay = DISCONNECTED_CALL_MEDIUM_TIMEOUT_MS;
+                break;
+            case DisconnectCause.REJECTED:
+            case DisconnectCause.MISSED:
+            case DisconnectCause.CANCELED:
+                // no delay for missed/rejected incoming calls and canceled outgoing calls.
+                delay = 0;
+                break;
+            default:
+                delay = DISCONNECTED_CALL_LONG_TIMEOUT_MS;
+                break;
+        }
+
+        return delay;
+    }
+
+    private void updateCallTextMap(Call call, List<String> textResponses) {
+        Preconditions.checkNotNull(call);
+
+        if (!isCallDead(call)) {
+            if (textResponses != null) {
+                mCallTextReponsesMap.put(call.getId(), textResponses);
+            }
+        } else if (mCallById.containsKey(call.getId())) {
+            mCallTextReponsesMap.remove(call.getId());
+        }
+    }
+
+    private boolean isCallDead(Call call) {
+        final int state = call.getState();
+        return Call.State.IDLE == state || Call.State.INVALID == state;
+    }
+
+    /**
+     * Sets up a call for deletion and notifies listeners of change.
+     */
+    private void finishDisconnectedCall(Call call) {
+        if (mPendingDisconnectCalls.contains(call)) {
+            mPendingDisconnectCalls.remove(call);
+        }
+        call.setState(Call.State.IDLE);
+        updateCallInMap(call);
+        notifyGenericListeners();
+    }
+
+    /**
+     * Notifies all video calls of a change in device orientation.
+     *
+     * @param rotation The new rotation angle (in degrees).
+     */
+    public void notifyCallsOfDeviceRotation(int rotation) {
+        for (Call call : mCallById.values()) {
+            // First, ensure that the call videoState has video enabled (there is no need to set
+            // device orientation on a voice call which has not yet been upgraded to video).
+            // Second, ensure a VideoCall is set on the call so that the change can be sent to the
+            // provider (a VideoCall can be present for a call that does not currently have video,
+            // but can be upgraded to video).
+
+            // NOTE: is it necessary to use this order because getVideoCall references the class
+            // VideoProfile which is not available on APIs <23 (M).
+            if (VideoUtils.isVideoCall(call) && call.getVideoCall() != null) {
+                call.getVideoCall().setDeviceOrientation(rotation);
+            }
+        }
+    }
+
+    /**
+     * Handles the timeout for destroying disconnected calls.
+     */
+    private Handler mHandler = new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case EVENT_DISCONNECTED_TIMEOUT:
+                    Log.d(this, "EVENT_DISCONNECTED_TIMEOUT ", msg.obj);
+                    finishDisconnectedCall((Call) msg.obj);
+                    break;
+                default:
+                    Log.wtf(this, "Message not expected: " + msg.what);
+                    break;
+            }
+        }
+    };
+
+    public void setFilteredNumberQueryHandler(FilteredNumberAsyncQueryHandler handler) {
+        mFilteredQueryHandler = handler;
+    }
+
+    /**
+     * Listener interface for any class that wants to be notified of changes
+     * to the call list.
+     */
+    public interface Listener {
+        /**
+         * Called when a new incoming call comes in.
+         * This is the only method that gets called for incoming calls. Listeners
+         * that want to perform an action on incoming call should respond in this method
+         * because {@link #onCallListChange} does not automatically get called for
+         * incoming calls.
+         */
+        public void onIncomingCall(Call call);
+        /**
+         * Called when a new modify call request comes in
+         * This is the only method that gets called for modify requests.
+         */
+        public void onUpgradeToVideo(Call call);
+        /**
+         * Called anytime there are changes to the call list.  The change can be switching call
+         * states, updating information, etc. This method will NOT be called for new incoming
+         * calls and for calls that switch to disconnected state. Listeners must add actions
+         * to those method implementations if they want to deal with those actions.
+         */
+        public void onCallListChange(CallList callList);
+
+        /**
+         * Called when a call switches to the disconnected state.  This is the only method
+         * that will get called upon disconnection.
+         */
+        public void onDisconnect(Call call);
+
+
+    }
+
+    public interface CallUpdateListener {
+        // TODO: refactor and limit arg to be call state.  Caller info is not needed.
+        public void onCallChanged(Call call);
+
+        /**
+         * Notifies of a change to the session modification state for a call.
+         *
+         * @param sessionModificationState The new session modification state.
+         */
+        public void onSessionModificationStateChange(int sessionModificationState);
+
+        /**
+         * Notifies of a change to the last forwarded number for a call.
+         */
+        public void onLastForwardedNumberChange();
+
+        /**
+         * Notifies of a change to the child number for a call.
+         */
+        public void onChildNumberChange();
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/CallTimer.java b/InCallUI/src/com/android/incallui/CallTimer.java
new file mode 100644
index 0000000..d65e633
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/CallTimer.java
@@ -0,0 +1,90 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import com.google.common.base.Preconditions;
+
+import android.os.Handler;
+import android.os.SystemClock;
+
+/**
+ * Helper class used to keep track of events requiring regular intervals.
+ */
+public class CallTimer extends Handler {
+    private Runnable mInternalCallback;
+    private Runnable mCallback;
+    private long mLastReportedTime;
+    private long mInterval;
+    private boolean mRunning;
+
+    public CallTimer(Runnable callback) {
+        Preconditions.checkNotNull(callback);
+
+        mInterval = 0;
+        mLastReportedTime = 0;
+        mRunning = false;
+        mCallback = callback;
+        mInternalCallback = new CallTimerCallback();
+    }
+
+    public boolean start(long interval) {
+        if (interval <= 0) {
+            return false;
+        }
+
+        // cancel any previous timer
+        cancel();
+
+        mInterval = interval;
+        mLastReportedTime = SystemClock.uptimeMillis();
+
+        mRunning = true;
+        periodicUpdateTimer();
+
+        return true;
+    }
+
+    public void cancel() {
+        removeCallbacks(mInternalCallback);
+        mRunning = false;
+    }
+
+    private void periodicUpdateTimer() {
+        if (!mRunning) {
+            return;
+        }
+
+        final long now = SystemClock.uptimeMillis();
+        long nextReport = mLastReportedTime + mInterval;
+        while (now >= nextReport) {
+            nextReport += mInterval;
+        }
+
+        postAtTime(mInternalCallback, nextReport);
+        mLastReportedTime = nextReport;
+
+        // Run the callback
+        mCallback.run();
+    }
+
+    private class CallTimerCallback implements Runnable {
+        @Override
+        public void run() {
+            periodicUpdateTimer();
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/CallerInfo.java b/InCallUI/src/com/android/incallui/CallerInfo.java
new file mode 100644
index 0000000..670c3fd
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/CallerInfo.java
@@ -0,0 +1,557 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import com.google.common.primitives.Longs;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.graphics.Bitmap;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Data;
+import android.provider.ContactsContract.PhoneLookup;
+import android.provider.ContactsContract.RawContacts;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+
+import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.ContactsUtils.UserType;
+import com.android.contacts.common.util.PhoneNumberHelper;
+import com.android.contacts.common.util.TelephonyManagerUtils;
+import com.android.dialer.calllog.ContactInfoHelper;
+
+/**
+ * Looks up caller information for the given phone number.
+ */
+public class CallerInfo {
+    private static final String TAG = "CallerInfo";
+
+    public static final String[] DEFAULT_PHONELOOKUP_PROJECTION = new String[] {
+            PhoneLookup._ID,
+            PhoneLookup.DISPLAY_NAME,
+            PhoneLookup.LOOKUP_KEY,
+            PhoneLookup.NUMBER,
+            PhoneLookup.NORMALIZED_NUMBER,
+            PhoneLookup.LABEL,
+            PhoneLookup.TYPE,
+            PhoneLookup.PHOTO_URI,
+            PhoneLookup.CUSTOM_RINGTONE,
+            PhoneLookup.SEND_TO_VOICEMAIL
+    };
+
+    /**
+     * Please note that, any one of these member variables can be null,
+     * and any accesses to them should be prepared to handle such a case.
+     *
+     * Also, it is implied that phoneNumber is more often populated than
+     * name is, (think of calls being dialed/received using numbers where
+     * names are not known to the device), so phoneNumber should serve as
+     * a dependable fallback when name is unavailable.
+     *
+     * One other detail here is that this CallerInfo object reflects
+     * information found on a connection, it is an OUTPUT that serves
+     * mainly to display information to the user.  In no way is this object
+     * used as input to make a connection, so we can choose to display
+     * whatever human-readable text makes sense to the user for a
+     * connection.  This is especially relevant for the phone number field,
+     * since it is the one field that is most likely exposed to the user.
+     *
+     * As an example:
+     *   1. User dials "911"
+     *   2. Device recognizes that this is an emergency number
+     *   3. We use the "Emergency Number" string instead of "911" in the
+     *     phoneNumber field.
+     *
+     * What we're really doing here is treating phoneNumber as an essential
+     * field here, NOT name.  We're NOT always guaranteed to have a name
+     * for a connection, but the number should be displayable.
+     */
+    public String name;
+    public String nameAlternative;
+    public String phoneNumber;
+    public String normalizedNumber;
+    public String forwardingNumber;
+    public String geoDescription;
+
+    public String cnapName;
+    public int numberPresentation;
+    public int namePresentation;
+    public boolean contactExists;
+
+    public String phoneLabel;
+    /* Split up the phoneLabel into number type and label name */
+    public int    numberType;
+    public String numberLabel;
+
+    public int photoResource;
+
+    // Contact ID, which will be 0 if a contact comes from the corp CP2.
+    public long contactIdOrZero;
+    public String lookupKeyOrNull;
+    public boolean needUpdate;
+    public Uri contactRefUri;
+    public @UserType long userType;
+
+    /**
+     * Contact display photo URI.  If a contact has no display photo but a thumbnail, it'll be
+     * the thumbnail URI instead.
+     */
+    public Uri contactDisplayPhotoUri;
+
+    // fields to hold individual contact preference data,
+    // including the send to voicemail flag and the ringtone
+    // uri reference.
+    public Uri contactRingtoneUri;
+    public boolean shouldSendToVoicemail;
+
+    /**
+     * Drawable representing the caller image.  This is essentially
+     * a cache for the image data tied into the connection /
+     * callerinfo object.
+     *
+     * This might be a high resolution picture which is more suitable
+     * for full-screen image view than for smaller icons used in some
+     * kinds of notifications.
+     *
+     * The {@link #isCachedPhotoCurrent} flag indicates if the image
+     * data needs to be reloaded.
+     */
+    public Drawable cachedPhoto;
+    /**
+     * Bitmap representing the caller image which has possibly lower
+     * resolution than {@link #cachedPhoto} and thus more suitable for
+     * icons (like notification icons).
+     *
+     * In usual cases this is just down-scaled image of {@link #cachedPhoto}.
+     * If the down-scaling fails, this will just become null.
+     *
+     * The {@link #isCachedPhotoCurrent} flag indicates if the image
+     * data needs to be reloaded.
+     */
+    public Bitmap cachedPhotoIcon;
+    /**
+     * Boolean which indicates if {@link #cachedPhoto} and
+     * {@link #cachedPhotoIcon} is fresh enough. If it is false,
+     * those images aren't pointing to valid objects.
+     */
+    public boolean isCachedPhotoCurrent;
+
+    /**
+     * String which holds the call subject sent as extra from the lower layers for this call. This
+     * is used to display the no-caller ID reason for restricted/unknown number presentation.
+     */
+    public String callSubject;
+
+    private boolean mIsEmergency;
+    private boolean mIsVoiceMail;
+
+    public CallerInfo() {
+        // TODO: Move all the basic initialization here?
+        mIsEmergency = false;
+        mIsVoiceMail = false;
+        userType = ContactsUtils.USER_TYPE_CURRENT;
+    }
+
+    /**
+     * getCallerInfo given a Cursor.
+     * @param context the context used to retrieve string constants
+     * @param contactRef the URI to attach to this CallerInfo object
+     * @param cursor the first object in the cursor is used to build the CallerInfo object.
+     * @return the CallerInfo which contains the caller id for the given
+     * number. The returned CallerInfo is null if no number is supplied.
+     */
+    public static CallerInfo getCallerInfo(Context context, Uri contactRef, Cursor cursor) {
+        CallerInfo info = new CallerInfo();
+        info.photoResource = 0;
+        info.phoneLabel = null;
+        info.numberType = 0;
+        info.numberLabel = null;
+        info.cachedPhoto = null;
+        info.isCachedPhotoCurrent = false;
+        info.contactExists = false;
+        info.userType = ContactsUtils.USER_TYPE_CURRENT;
+
+        Log.v(TAG, "getCallerInfo() based on cursor...");
+
+        if (cursor != null) {
+            if (cursor.moveToFirst()) {
+                // TODO: photo_id is always available but not taken
+                // care of here. Maybe we should store it in the
+                // CallerInfo object as well.
+
+                long contactId = 0L;
+                int columnIndex;
+
+                // Look for the name
+                columnIndex = cursor.getColumnIndex(PhoneLookup.DISPLAY_NAME);
+                if (columnIndex != -1) {
+                    info.name = cursor.getString(columnIndex);
+                }
+
+                columnIndex = cursor.getColumnIndex(PhoneLookup.LOOKUP_KEY);
+                if (columnIndex != -1) {
+                    info.nameAlternative = ContactInfoHelper.lookUpDisplayNameAlternative(
+                            context, cursor.getString(columnIndex));
+                }
+
+                // Look for the number
+                columnIndex = cursor.getColumnIndex(PhoneLookup.NUMBER);
+                if (columnIndex != -1) {
+                    info.phoneNumber = cursor.getString(columnIndex);
+                }
+
+                // Look for the normalized number
+                columnIndex = cursor.getColumnIndex(PhoneLookup.NORMALIZED_NUMBER);
+                if (columnIndex != -1) {
+                    info.normalizedNumber = cursor.getString(columnIndex);
+                }
+
+                // Look for the label/type combo
+                columnIndex = cursor.getColumnIndex(PhoneLookup.LABEL);
+                if (columnIndex != -1) {
+                    int typeColumnIndex = cursor.getColumnIndex(PhoneLookup.TYPE);
+                    if (typeColumnIndex != -1) {
+                        info.numberType = cursor.getInt(typeColumnIndex);
+                        info.numberLabel = cursor.getString(columnIndex);
+                        info.phoneLabel = Phone.getTypeLabel(context.getResources(),
+                                info.numberType, info.numberLabel)
+                                .toString();
+                    }
+                }
+
+                // Look for the person_id.
+                columnIndex = getColumnIndexForPersonId(contactRef, cursor);
+                if (columnIndex != -1) {
+                    contactId = cursor.getLong(columnIndex);
+                    // QuickContacts in M doesn't support enterprise contact id
+                    if (contactId != 0 && (ContactsUtils.FLAG_N_FEATURE
+                            || !Contacts.isEnterpriseContactId(contactId))) {
+                        info.contactIdOrZero = contactId;
+                        Log.v(TAG, "==> got info.contactIdOrZero: " + info.contactIdOrZero);
+
+                        // cache the lookup key for later use with person_id to create lookup URIs
+                        columnIndex = cursor.getColumnIndex(PhoneLookup.LOOKUP_KEY);
+                        if (columnIndex != -1) {
+                            info.lookupKeyOrNull = cursor.getString(columnIndex);
+                        }
+                    }
+                } else {
+                    // No valid columnIndex, so we can't look up person_id.
+                    Log.v(TAG, "Couldn't find contactId column for " + contactRef);
+                    // Watch out: this means that anything that depends on
+                    // person_id will be broken (like contact photo lookups in
+                    // the in-call UI, for example.)
+                }
+
+                // Display photo URI.
+                columnIndex = cursor.getColumnIndex(PhoneLookup.PHOTO_URI);
+                if ((columnIndex != -1) && (cursor.getString(columnIndex) != null)) {
+                    info.contactDisplayPhotoUri = Uri.parse(cursor.getString(columnIndex));
+                } else {
+                    info.contactDisplayPhotoUri = null;
+                }
+
+                // look for the custom ringtone, create from the string stored
+                // in the database.
+                columnIndex = cursor.getColumnIndex(PhoneLookup.CUSTOM_RINGTONE);
+                if ((columnIndex != -1) && (cursor.getString(columnIndex) != null)) {
+                    if (TextUtils.isEmpty(cursor.getString(columnIndex))) {
+                        // make it consistent with frameworks/base/.../CallerInfo.java
+                        info.contactRingtoneUri = Uri.EMPTY;
+                    } else {
+                        info.contactRingtoneUri = Uri.parse(cursor.getString(columnIndex));
+                    }
+                } else {
+                    info.contactRingtoneUri = null;
+                }
+
+                // look for the send to voicemail flag, set it to true only
+                // under certain circumstances.
+                columnIndex = cursor.getColumnIndex(PhoneLookup.SEND_TO_VOICEMAIL);
+                info.shouldSendToVoicemail = (columnIndex != -1) &&
+                        ((cursor.getInt(columnIndex)) == 1);
+                info.contactExists = true;
+
+                // Determine userType by directoryId and contactId
+                final String directory = contactRef == null ? null
+                        : contactRef.getQueryParameter(ContactsContract.DIRECTORY_PARAM_KEY);
+                final Long directoryId = directory == null ? null : Longs.tryParse(directory);
+                info.userType = ContactsUtils.determineUserType(directoryId, contactId);
+            }
+            cursor.close();
+        }
+
+        info.needUpdate = false;
+        info.name = normalize(info.name);
+        info.contactRefUri = contactRef;
+
+        return info;
+    }
+
+    /**
+     * getCallerInfo given a URI, look up in the call-log database
+     * for the uri unique key.
+     * @param context the context used to get the ContentResolver
+     * @param contactRef the URI used to lookup caller id
+     * @return the CallerInfo which contains the caller id for the given
+     * number. The returned CallerInfo is null if no number is supplied.
+     */
+    private static CallerInfo getCallerInfo(Context context, Uri contactRef) {
+
+        return getCallerInfo(context, contactRef,
+                context.getContentResolver().query(contactRef, null, null, null, null));
+    }
+
+    /**
+     * Performs another lookup if previous lookup fails and it's a SIP call
+     * and the peer's username is all numeric. Look up the username as it
+     * could be a PSTN number in the contact database.
+     *
+     * @param context the query context
+     * @param number the original phone number, could be a SIP URI
+     * @param previousResult the result of previous lookup
+     * @return previousResult if it's not the case
+     */
+    static CallerInfo doSecondaryLookupIfNecessary(Context context,
+            String number, CallerInfo previousResult) {
+        if (!previousResult.contactExists
+                && PhoneNumberHelper.isUriNumber(number)) {
+            String username = PhoneNumberHelper.getUsernameFromUriNumber(number);
+            if (PhoneNumberUtils.isGlobalPhoneNumber(username)) {
+                previousResult = getCallerInfo(context,
+                        Uri.withAppendedPath(PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI,
+                                Uri.encode(username)));
+            }
+        }
+        return previousResult;
+    }
+
+    // Accessors
+
+    /**
+     * @return true if the caller info is an emergency number.
+     */
+    public boolean isEmergencyNumber() {
+        return mIsEmergency;
+    }
+
+    /**
+     * @return true if the caller info is a voicemail number.
+     */
+    public boolean isVoiceMailNumber() {
+        return mIsVoiceMail;
+    }
+
+    /**
+     * Mark this CallerInfo as an emergency call.
+     * @param context To lookup the localized 'Emergency Number' string.
+     * @return this instance.
+     */
+    /* package */ CallerInfo markAsEmergency(Context context) {
+        name = context.getString(R.string.emergency_call_dialog_number_for_display);
+        phoneNumber = null;
+
+        photoResource = R.drawable.img_phone;
+        mIsEmergency = true;
+        return this;
+    }
+
+
+    /**
+     * Mark this CallerInfo as a voicemail call. The voicemail label
+     * is obtained from the telephony manager. Caller must hold the
+     * READ_PHONE_STATE permission otherwise the phoneNumber will be
+     * set to null.
+     * @return this instance.
+     */
+    /* package */ CallerInfo markAsVoiceMail(Context context) {
+        mIsVoiceMail = true;
+
+        try {
+            // For voicemail calls, we display the voice mail tag
+            // instead of the real phone number in the "number"
+            // field.
+            name = TelephonyManagerUtils.getVoiceMailAlphaTag(context);
+            phoneNumber = null;
+        } catch (SecurityException se) {
+            // Should never happen: if this process does not have
+            // permission to retrieve VM tag, it should not have
+            // permission to retrieve VM number and would not call
+            // this method.
+            // Leave phoneNumber untouched.
+            Log.e(TAG, "Cannot access VoiceMail.", se);
+        }
+        // TODO: There is no voicemail picture?
+        // FIXME: FIND ANOTHER ICON
+        // photoResource = android.R.drawable.badge_voicemail;
+        return this;
+    }
+
+    private static String normalize(String s) {
+        if (s == null || s.length() > 0) {
+            return s;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Returns the column index to use to find the "person_id" field in
+     * the specified cursor, based on the contact URI that was originally
+     * queried.
+     *
+     * This is a helper function for the getCallerInfo() method that takes
+     * a Cursor.  Looking up the person_id is nontrivial (compared to all
+     * the other CallerInfo fields) since the column we need to use
+     * depends on what query we originally ran.
+     *
+     * Watch out: be sure to not do any database access in this method, since
+     * it's run from the UI thread (see comments below for more info.)
+     *
+     * @return the columnIndex to use (with cursor.getLong()) to get the
+     * person_id, or -1 if we couldn't figure out what colum to use.
+     *
+     * TODO: Add a unittest for this method.  (This is a little tricky to
+     * test, since we'll need a live contacts database to test against,
+     * preloaded with at least some phone numbers and SIP addresses.  And
+     * we'll probably have to hardcode the column indexes we expect, so
+     * the test might break whenever the contacts schema changes.  But we
+     * can at least make sure we handle all the URI patterns we claim to,
+     * and that the mime types match what we expect...)
+     */
+    private static int getColumnIndexForPersonId(Uri contactRef, Cursor cursor) {
+        // TODO: This is pretty ugly now, see bug 2269240 for
+        // more details. The column to use depends upon the type of URL:
+        // - content://com.android.contacts/data/phones ==> use the "contact_id" column
+        // - content://com.android.contacts/phone_lookup ==> use the "_ID" column
+        // - content://com.android.contacts/data ==> use the "contact_id" column
+        // If it's none of the above, we leave columnIndex=-1 which means
+        // that the person_id field will be left unset.
+        //
+        // The logic here *used* to be based on the mime type of contactRef
+        // (for example Phone.CONTENT_ITEM_TYPE would tell us to use the
+        // RawContacts.CONTACT_ID column).  But looking up the mime type requires
+        // a call to context.getContentResolver().getType(contactRef), which
+        // isn't safe to do from the UI thread since it can cause an ANR if
+        // the contacts provider is slow or blocked (like during a sync.)
+        //
+        // So instead, figure out the column to use for person_id by just
+        // looking at the URI itself.
+
+        Log.v(TAG, "- getColumnIndexForPersonId: contactRef URI = '"
+                + contactRef + "'...");
+        // Warning: Do not enable the following logging (due to ANR risk.)
+        // if (VDBG) Rlog.v(TAG, "- MIME type: "
+        //                 + context.getContentResolver().getType(contactRef));
+
+        String url = contactRef.toString();
+        String columnName = null;
+        if (url.startsWith("content://com.android.contacts/data/phones")) {
+            // Direct lookup in the Phone table.
+            // MIME type: Phone.CONTENT_ITEM_TYPE (= "vnd.android.cursor.item/phone_v2")
+            Log.v(TAG, "'data/phones' URI; using RawContacts.CONTACT_ID");
+            columnName = RawContacts.CONTACT_ID;
+        } else if (url.startsWith("content://com.android.contacts/data")) {
+            // Direct lookup in the Data table.
+            // MIME type: Data.CONTENT_TYPE (= "vnd.android.cursor.dir/data")
+            Log.v(TAG, "'data' URI; using Data.CONTACT_ID");
+            // (Note Data.CONTACT_ID and RawContacts.CONTACT_ID are equivalent.)
+            columnName = Data.CONTACT_ID;
+        } else if (url.startsWith("content://com.android.contacts/phone_lookup")) {
+            // Lookup in the PhoneLookup table, which provides "fuzzy matching"
+            // for phone numbers.
+            // MIME type: PhoneLookup.CONTENT_TYPE (= "vnd.android.cursor.dir/phone_lookup")
+            Log.v(TAG, "'phone_lookup' URI; using PhoneLookup._ID");
+            columnName = PhoneLookup._ID;
+        } else {
+            Log.v(TAG, "Unexpected prefix for contactRef '" + url + "'");
+        }
+        int columnIndex = (columnName != null) ? cursor.getColumnIndex(columnName) : -1;
+        Log.v(TAG, "==> Using column '" + columnName
+                + "' (columnIndex = " + columnIndex + ") for person_id lookup...");
+        return columnIndex;
+    }
+
+    /**
+     * Updates this CallerInfo's geoDescription field, based on the raw
+     * phone number in the phoneNumber field.
+     *
+     * (Note that the various getCallerInfo() methods do *not* set the
+     * geoDescription automatically; you need to call this method
+     * explicitly to get it.)
+     *
+     * @param context the context used to look up the current locale / country
+     * @param fallbackNumber if this CallerInfo's phoneNumber field is empty,
+     *        this specifies a fallback number to use instead.
+     */
+    public void updateGeoDescription(Context context, String fallbackNumber) {
+        String number = TextUtils.isEmpty(phoneNumber) ? fallbackNumber : phoneNumber;
+        geoDescription = com.android.dialer.util.PhoneNumberUtil.getGeoDescription(context, number);
+    }
+
+    /**
+     * @return a string debug representation of this instance.
+     */
+    @Override
+    public String toString() {
+        // Warning: never check in this file with VERBOSE_DEBUG = true
+        // because that will result in PII in the system log.
+        final boolean VERBOSE_DEBUG = false;
+
+        if (VERBOSE_DEBUG) {
+            return new StringBuilder(384)
+                    .append(super.toString() + " { ")
+                    .append("\nname: " + name)
+                    .append("\nphoneNumber: " + phoneNumber)
+                    .append("\nnormalizedNumber: " + normalizedNumber)
+                    .append("\forwardingNumber: " + forwardingNumber)
+                    .append("\ngeoDescription: " + geoDescription)
+                    .append("\ncnapName: " + cnapName)
+                    .append("\nnumberPresentation: " + numberPresentation)
+                    .append("\nnamePresentation: " + namePresentation)
+                    .append("\ncontactExists: " + contactExists)
+                    .append("\nphoneLabel: " + phoneLabel)
+                    .append("\nnumberType: " + numberType)
+                    .append("\nnumberLabel: " + numberLabel)
+                    .append("\nphotoResource: " + photoResource)
+                    .append("\ncontactIdOrZero: " + contactIdOrZero)
+                    .append("\nneedUpdate: " + needUpdate)
+                    .append("\ncontactRefUri: " + contactRefUri)
+                    .append("\ncontactRingtoneUri: " + contactRingtoneUri)
+                    .append("\ncontactDisplayPhotoUri: " + contactDisplayPhotoUri)
+                    .append("\nshouldSendToVoicemail: " + shouldSendToVoicemail)
+                    .append("\ncachedPhoto: " + cachedPhoto)
+                    .append("\nisCachedPhotoCurrent: " + isCachedPhotoCurrent)
+                    .append("\nemergency: " + mIsEmergency)
+                    .append("\nvoicemail: " + mIsVoiceMail)
+                    .append("\nuserType: " + userType)
+                    .append(" }")
+                    .toString();
+        } else {
+            return new StringBuilder(128)
+                    .append(super.toString() + " { ")
+                    .append("name " + ((name == null) ? "null" : "non-null"))
+                    .append(", phoneNumber " + ((phoneNumber == null) ? "null" : "non-null"))
+                    .append(" }")
+                    .toString();
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/CallerInfoAsyncQuery.java b/InCallUI/src/com/android/incallui/CallerInfoAsyncQuery.java
new file mode 100644
index 0000000..bf5e1a3
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/CallerInfoAsyncQuery.java
@@ -0,0 +1,589 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import com.google.common.primitives.Longs;
+
+import android.content.AsyncQueryHandler;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.SQLException;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.Directory;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+
+import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.compat.DirectoryCompat;
+import com.android.contacts.common.util.TelephonyManagerUtils;
+import com.android.dialer.calllog.ContactInfoHelper;
+import com.android.dialer.service.CachedNumberLookupService;
+import com.android.dialer.service.CachedNumberLookupService.CachedContactInfo;
+import com.android.dialerbind.ObjectFactory;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Locale;
+
+/**
+ * Helper class to make it easier to run asynchronous caller-id lookup queries.
+ * @see CallerInfo
+ *
+ */
+public class CallerInfoAsyncQuery {
+    private static final boolean DBG = false;
+    private static final String LOG_TAG = "CallerInfoAsyncQuery";
+
+    private static final int EVENT_NEW_QUERY = 1;
+    private static final int EVENT_ADD_LISTENER = 2;
+    private static final int EVENT_END_OF_QUEUE = 3;
+    private static final int EVENT_EMERGENCY_NUMBER = 4;
+    private static final int EVENT_VOICEMAIL_NUMBER = 5;
+
+    private CallerInfoAsyncQueryHandler mHandler;
+
+    // If the CallerInfo query finds no contacts, should we use the
+    // PhoneNumberOfflineGeocoder to look up a "geo description"?
+    // (TODO: This could become a flag in config.xml if it ever needs to be
+    // configured on a per-product basis.)
+    private static final boolean ENABLE_UNKNOWN_NUMBER_GEO_DESCRIPTION = true;
+
+    /**
+     * Interface for a CallerInfoAsyncQueryHandler result return.
+     */
+    public interface OnQueryCompleteListener {
+        /**
+         * Called when the query is complete.
+         */
+        public void onQueryComplete(int token, Object cookie, CallerInfo ci);
+    }
+
+
+    /**
+     * Wrap the cookie from the WorkerArgs with additional information needed by our
+     * classes.
+     */
+    private static final class CookieWrapper {
+        public OnQueryCompleteListener listener;
+        public Object cookie;
+        public int event;
+        public String number;
+    }
+
+    /**
+     * Simple exception used to communicate problems with the query pool.
+     */
+    public static class QueryPoolException extends SQLException {
+        public QueryPoolException(String error) {
+            super(error);
+        }
+    }
+
+    /**
+     * Our own implementation of the AsyncQueryHandler.
+     */
+    private class CallerInfoAsyncQueryHandler extends AsyncQueryHandler {
+
+        @Override
+        public void startQuery(int token, Object cookie, Uri uri, String[] projection,
+                String selection, String[] selectionArgs, String orderBy) {
+            if (DBG) {
+                // Show stack trace with the arguments.
+                android.util.Log.d(LOG_TAG, "InCall: startQuery: url=" + uri +
+                                " projection=[" + Arrays.toString(projection) + "]" +
+                                " selection=" + selection + " " +
+                                " args=[" + Arrays.toString(selectionArgs) + "]",
+                        new RuntimeException("STACKTRACE"));
+            }
+            super.startQuery(token, cookie, uri, projection, selection, selectionArgs, orderBy);
+        }
+
+        /**
+         * The information relevant to each CallerInfo query.  Each query may have multiple
+         * listeners, so each AsyncCursorInfo is associated with 2 or more CookieWrapper
+         * objects in the queue (one with a new query event, and one with a end event, with
+         * 0 or more additional listeners in between).
+         */
+        private Context mQueryContext;
+        private Uri mQueryUri;
+        private CallerInfo mCallerInfo;
+
+        /**
+         * Our own query worker thread.
+         *
+         * This thread handles the messages enqueued in the looper.  The normal sequence
+         * of events is that a new query shows up in the looper queue, followed by 0 or
+         * more add listener requests, and then an end request.  Of course, these requests
+         * can be interlaced with requests from other tokens, but is irrelevant to this
+         * handler since the handler has no state.
+         *
+         * Note that we depend on the queue to keep things in order; in other words, the
+         * looper queue must be FIFO with respect to input from the synchronous startQuery
+         * calls and output to this handleMessage call.
+         *
+         * This use of the queue is required because CallerInfo objects may be accessed
+         * multiple times before the query is complete.  All accesses (listeners) must be
+         * queued up and informed in order when the query is complete.
+         */
+        protected class CallerInfoWorkerHandler extends WorkerHandler {
+            public CallerInfoWorkerHandler(Looper looper) {
+                super(looper);
+            }
+
+            @Override
+            public void handleMessage(Message msg) {
+                WorkerArgs args = (WorkerArgs) msg.obj;
+                CookieWrapper cw = (CookieWrapper) args.cookie;
+
+                if (cw == null) {
+                    // Normally, this should never be the case for calls originating
+                    // from within this code.
+                    // However, if there is any code that this Handler calls (such as in
+                    // super.handleMessage) that DOES place unexpected messages on the
+                    // queue, then we need pass these messages on.
+                    Log.d(this, "Unexpected command (CookieWrapper is null): " + msg.what +
+                            " ignored by CallerInfoWorkerHandler, passing onto parent.");
+
+                    super.handleMessage(msg);
+                } else {
+                    Log.d(this, "Processing event: " + cw.event + " token (arg1): " + msg.arg1 +
+                            " command: " + msg.what + " query URI: " +
+                            sanitizeUriToString(args.uri));
+
+                    switch (cw.event) {
+                        case EVENT_NEW_QUERY:
+                            //start the sql command.
+                            super.handleMessage(msg);
+                            break;
+
+                        // shortcuts to avoid query for recognized numbers.
+                        case EVENT_EMERGENCY_NUMBER:
+                        case EVENT_VOICEMAIL_NUMBER:
+
+                        case EVENT_ADD_LISTENER:
+                        case EVENT_END_OF_QUEUE:
+                            // query was already completed, so just send the reply.
+                            // passing the original token value back to the caller
+                            // on top of the event values in arg1.
+                            Message reply = args.handler.obtainMessage(msg.what);
+                            reply.obj = args;
+                            reply.arg1 = msg.arg1;
+
+                            reply.sendToTarget();
+
+                            break;
+                        default:
+                    }
+                }
+            }
+        }
+
+
+        /**
+         * Asynchronous query handler class for the contact / callerinfo object.
+         */
+        private CallerInfoAsyncQueryHandler(Context context) {
+            super(context.getContentResolver());
+        }
+
+        @Override
+        protected Handler createHandler(Looper looper) {
+            return new CallerInfoWorkerHandler(looper);
+        }
+
+        /**
+         * Overrides onQueryComplete from AsyncQueryHandler.
+         *
+         * This method takes into account the state of this class; we construct the CallerInfo
+         * object only once for each set of listeners. When the query thread has done its work
+         * and calls this method, we inform the remaining listeners in the queue, until we're
+         * out of listeners.  Once we get the message indicating that we should expect no new
+         * listeners for this CallerInfo object, we release the AsyncCursorInfo back into the
+         * pool.
+         */
+        @Override
+        protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
+            try {
+                Log.d(this, "##### onQueryComplete() #####   query complete for token: " + token);
+
+                //get the cookie and notify the listener.
+                CookieWrapper cw = (CookieWrapper) cookie;
+                if (cw == null) {
+                    // Normally, this should never be the case for calls originating
+                    // from within this code.
+                    // However, if there is any code that calls this method, we should
+                    // check the parameters to make sure they're viable.
+                    Log.d(this, "Cookie is null, ignoring onQueryComplete() request.");
+                    return;
+                }
+
+                if (cw.event == EVENT_END_OF_QUEUE) {
+                    release();
+                    return;
+                }
+
+                // check the token and if needed, create the callerinfo object.
+                if (mCallerInfo == null) {
+                    if ((mQueryContext == null) || (mQueryUri == null)) {
+                        throw new QueryPoolException
+                            ("Bad context or query uri, or CallerInfoAsyncQuery already released.");
+                    }
+
+                    // adjust the callerInfo data as needed, and only if it was set from the
+                    // initial query request.
+                    // Change the callerInfo number ONLY if it is an emergency number or the
+                    // voicemail number, and adjust other data (including photoResource)
+                    // accordingly.
+                    if (cw.event == EVENT_EMERGENCY_NUMBER) {
+                        // Note we're setting the phone number here (refer to javadoc
+                        // comments at the top of CallerInfo class).
+                        mCallerInfo = new CallerInfo().markAsEmergency(mQueryContext);
+                    } else if (cw.event == EVENT_VOICEMAIL_NUMBER) {
+                        mCallerInfo = new CallerInfo().markAsVoiceMail(mQueryContext);
+                    } else {
+                        mCallerInfo = CallerInfo.getCallerInfo(mQueryContext, mQueryUri, cursor);
+                        Log.d(this, "==> Got mCallerInfo: " + mCallerInfo);
+
+                        CallerInfo newCallerInfo = CallerInfo.doSecondaryLookupIfNecessary(
+                                mQueryContext, cw.number, mCallerInfo);
+                        if (newCallerInfo != mCallerInfo) {
+                            mCallerInfo = newCallerInfo;
+                            Log.d(this, "#####async contact look up with numeric username"
+                                    + mCallerInfo);
+                        }
+
+                        // Final step: look up the geocoded description.
+                        if (ENABLE_UNKNOWN_NUMBER_GEO_DESCRIPTION) {
+                            // Note we do this only if we *don't* have a valid name (i.e. if
+                            // no contacts matched the phone number of the incoming call),
+                            // since that's the only case where the incoming-call UI cares
+                            // about this field.
+                            //
+                            // (TODO: But if we ever want the UI to show the geoDescription
+                            // even when we *do* match a contact, we'll need to either call
+                            // updateGeoDescription() unconditionally here, or possibly add a
+                            // new parameter to CallerInfoAsyncQuery.startQuery() to force
+                            // the geoDescription field to be populated.)
+
+                            if (TextUtils.isEmpty(mCallerInfo.name)) {
+                                // Actually when no contacts match the incoming phone number,
+                                // the CallerInfo object is totally blank here (i.e. no name
+                                // *or* phoneNumber).  So we need to pass in cw.number as
+                                // a fallback number.
+                                mCallerInfo.updateGeoDescription(mQueryContext, cw.number);
+                            }
+                        }
+
+                        // Use the number entered by the user for display.
+                        if (!TextUtils.isEmpty(cw.number)) {
+                            mCallerInfo.phoneNumber = PhoneNumberUtils.formatNumber(cw.number,
+                                    mCallerInfo.normalizedNumber,
+                                    TelephonyManagerUtils.getCurrentCountryIso(mQueryContext,
+                                            Locale.getDefault()));
+                        }
+                    }
+
+                    Log.d(this, "constructing CallerInfo object for token: " + token);
+
+                    //notify that we can clean up the queue after this.
+                    CookieWrapper endMarker = new CookieWrapper();
+                    endMarker.event = EVENT_END_OF_QUEUE;
+                    startQuery(token, endMarker, null, null, null, null, null);
+                }
+
+                //notify the listener that the query is complete.
+                if (cw.listener != null) {
+                    Log.d(this, "notifying listener: " + cw.listener.getClass().toString() +
+                            " for token: " + token + mCallerInfo);
+                    cw.listener.onQueryComplete(token, cw.cookie, mCallerInfo);
+                }
+            } finally {
+                // The cursor may have been closed in CallerInfo.getCallerInfo()
+                if (cursor != null && !cursor.isClosed()) {
+                    cursor.close();
+                }
+            }
+        }
+    }
+
+    /**
+     * Private constructor for factory methods.
+     */
+    private CallerInfoAsyncQuery() {
+    }
+
+    public static void startQuery(final int token, final Context context, final CallerInfo info,
+            final OnQueryCompleteListener listener, final Object cookie) {
+        Log.d(LOG_TAG, "##### CallerInfoAsyncQuery startContactProviderQuery()... #####");
+        Log.d(LOG_TAG, "- number: " + info.phoneNumber);
+        Log.d(LOG_TAG, "- cookie: " + cookie);
+        OnQueryCompleteListener contactsProviderQueryCompleteListener =
+                new OnQueryCompleteListener() {
+                    @Override
+                    public void onQueryComplete(int token, Object cookie, CallerInfo ci) {
+                        Log.d(LOG_TAG, "contactsProviderQueryCompleteListener done");
+                        if (ci != null && ci.contactExists) {
+                            if (listener != null) {
+                                listener.onQueryComplete(token, cookie, ci);
+                            }
+                        } else {
+                            startOtherDirectoriesQuery(token, context, info, listener, cookie);
+                        }
+                    }
+                };
+        startDefaultDirectoryQuery(token, context, info, contactsProviderQueryCompleteListener,
+                cookie);
+    }
+
+    // Private methods
+    private static CallerInfoAsyncQuery startDefaultDirectoryQuery(int token, Context context,
+            CallerInfo info, OnQueryCompleteListener listener, Object cookie) {
+        // Construct the URI object and query params, and start the query.
+        Uri uri = ContactInfoHelper.getContactInfoLookupUri(info.phoneNumber);
+        return startQueryInternal(token, context, info, listener, cookie, uri);
+    }
+
+    /**
+     * Factory method to start the query based on a CallerInfo object.
+     *
+     * Note: if the number contains an "@" character we treat it
+     * as a SIP address, and look it up directly in the Data table
+     * rather than using the PhoneLookup table.
+     * TODO: But eventually we should expose two separate methods, one for
+     * numbers and one for SIP addresses, and then have
+     * PhoneUtils.startGetCallerInfo() decide which one to call based on
+     * the phone type of the incoming connection.
+     */
+    private static CallerInfoAsyncQuery startQueryInternal(int token, Context context,
+            CallerInfo info, OnQueryCompleteListener listener, Object cookie, Uri contactRef) {
+        if (DBG) {
+            Log.d(LOG_TAG, "==> contactRef: " + sanitizeUriToString(contactRef));
+        }
+
+        CallerInfoAsyncQuery c = new CallerInfoAsyncQuery();
+        c.allocate(context, contactRef);
+
+        //create cookieWrapper, start query
+        CookieWrapper cw = new CookieWrapper();
+        cw.listener = listener;
+        cw.cookie = cookie;
+        cw.number = info.phoneNumber;
+
+        // check to see if these are recognized numbers, and use shortcuts if we can.
+        if (PhoneNumberUtils.isLocalEmergencyNumber(context, info.phoneNumber)) {
+            cw.event = EVENT_EMERGENCY_NUMBER;
+        } else if (info.isVoiceMailNumber()) {
+            cw.event = EVENT_VOICEMAIL_NUMBER;
+        } else {
+            cw.event = EVENT_NEW_QUERY;
+        }
+
+        c.mHandler.startQuery(token,
+                              cw,  // cookie
+                              contactRef,  // uri
+                              CallerInfo.DEFAULT_PHONELOOKUP_PROJECTION,  // projection
+                              null,  // selection
+                              null,  // selectionArgs
+                              null);  // orderBy
+        return c;
+    }
+
+    private static void startOtherDirectoriesQuery(int token, Context context, CallerInfo info,
+            OnQueryCompleteListener listener, Object cookie) {
+        long[] directoryIds = getDirectoryIds(context);
+        int size = directoryIds.length;
+        if (size == 0) {
+            if (listener != null) {
+                listener.onQueryComplete(token, cookie, info);
+            }
+            return;
+        }
+
+        DirectoryQueryCompleteListenerFactory listenerFactory =
+                new DirectoryQueryCompleteListenerFactory(context, size, listener);
+
+        // The current implementation of multiple async query runs in single handler thread
+        // in AsyncQueryHandler.
+        // intermediateListener.onQueryComplete is also called from the same caller thread.
+        // TODO(b/26019872): use thread pool instead of single thread.
+        for (int i = 0; i < size; i++) {
+            long directoryId = directoryIds[i];
+            Uri uri = ContactInfoHelper.getContactInfoLookupUri(info.phoneNumber, directoryId);
+            if (DBG) {
+                Log.d(LOG_TAG, "directoryId: " + directoryId + " uri: " + uri);
+            }
+            OnQueryCompleteListener intermediateListener =
+                    listenerFactory.newListener(directoryId);
+            startQueryInternal(token, context, info, intermediateListener, cookie, uri);
+        }
+    }
+
+    /* Directory lookup related code - START */
+    private static final String[] DIRECTORY_PROJECTION = new String[] {Directory._ID};
+
+    private static long[] getDirectoryIds(Context context) {
+        ArrayList<Long> results = new ArrayList<>();
+
+        Uri uri = Directory.CONTENT_URI;
+        if (ContactsUtils.FLAG_N_FEATURE) {
+            uri = Uri.withAppendedPath(ContactsContract.AUTHORITY_URI, "directories_enterprise");
+        }
+
+        ContentResolver cr = context.getContentResolver();
+        Cursor cursor = cr.query(uri, DIRECTORY_PROJECTION, null, null, null);
+        addDirectoryIdsFromCursor(cursor, results);
+
+        return Longs.toArray(results);
+    }
+
+    private static void addDirectoryIdsFromCursor(Cursor cursor, ArrayList<Long> results) {
+        if (cursor != null) {
+            int idIndex = cursor.getColumnIndex(Directory._ID);
+            while (cursor.moveToNext()) {
+                long id = cursor.getLong(idIndex);
+                if (DirectoryCompat.isRemoteDirectory(id)) {
+                    results.add(id);
+                }
+            }
+            cursor.close();
+        }
+    }
+
+    private static final class DirectoryQueryCompleteListenerFactory {
+        // Make sure listener to be called once and only once
+        private int mCount;
+        private boolean mIsListenerCalled;
+        private final OnQueryCompleteListener mListener;
+        private final Context mContext;
+        private final CachedNumberLookupService mCachedNumberLookupService =
+                ObjectFactory.newCachedNumberLookupService();
+
+        private class DirectoryQueryCompleteListener implements OnQueryCompleteListener {
+            private final long mDirectoryId;
+
+            DirectoryQueryCompleteListener(long directoryId) {
+                mDirectoryId = directoryId;
+            }
+
+            @Override
+            public void onQueryComplete(int token, Object cookie, CallerInfo ci) {
+                onDirectoryQueryComplete(token, cookie, ci, mDirectoryId);
+            }
+        }
+
+        DirectoryQueryCompleteListenerFactory(Context context, int size,
+                OnQueryCompleteListener listener) {
+            mCount = size;
+            mListener = listener;
+            mIsListenerCalled = false;
+            mContext = context;
+        }
+
+        private void onDirectoryQueryComplete(int token, Object cookie, CallerInfo ci,
+                long directoryId) {
+            boolean shouldCallListener = false;
+            synchronized (this) {
+                mCount = mCount - 1;
+                if (!mIsListenerCalled && (ci.contactExists || mCount == 0)) {
+                    mIsListenerCalled = true;
+                    shouldCallListener = true;
+                }
+            }
+
+            // Don't call callback in synchronized block because mListener.onQueryComplete may
+            // take long time to complete
+            if (shouldCallListener && mListener != null) {
+                addCallerInfoIntoCache(ci, directoryId);
+                mListener.onQueryComplete(token, cookie, ci);
+            }
+        }
+
+        private void addCallerInfoIntoCache(CallerInfo ci, long directoryId) {
+            if (ci.contactExists && mCachedNumberLookupService != null) {
+                // 1. Cache caller info
+                CachedContactInfo cachedContactInfo = CallerInfoUtils
+                        .buildCachedContactInfo(mCachedNumberLookupService, ci);
+                String directoryLabel = mContext.getString(R.string.directory_search_label);
+                cachedContactInfo.setDirectorySource(directoryLabel, directoryId);
+                mCachedNumberLookupService.addContact(mContext, cachedContactInfo);
+
+                // 2. Cache photo
+                if (ci.contactDisplayPhotoUri != null && ci.normalizedNumber != null) {
+                    try (InputStream in = mContext.getContentResolver()
+                            .openInputStream(ci.contactDisplayPhotoUri)) {
+                        if (in != null) {
+                            mCachedNumberLookupService.addPhoto(mContext, ci.normalizedNumber, in);
+                        }
+                    } catch (IOException e) {
+                        Log.e(LOG_TAG, "failed to fetch directory contact photo", e);
+                    }
+
+                }
+            }
+        }
+
+        public OnQueryCompleteListener newListener(long directoryId) {
+            return new DirectoryQueryCompleteListener(directoryId);
+        }
+    }
+    /* Directory lookup related code - END */
+
+    /**
+     * Method to create a new CallerInfoAsyncQueryHandler object, ensuring correct
+     * state of context and uri.
+     */
+    private void allocate(Context context, Uri contactRef) {
+        if ((context == null) || (contactRef == null)){
+            throw new QueryPoolException("Bad context or query uri.");
+        }
+        mHandler = new CallerInfoAsyncQueryHandler(context);
+        mHandler.mQueryContext = context;
+        mHandler.mQueryUri = contactRef;
+    }
+
+    /**
+     * Releases the relevant data.
+     */
+    private void release() {
+        mHandler.mQueryContext = null;
+        mHandler.mQueryUri = null;
+        mHandler.mCallerInfo = null;
+        mHandler = null;
+    }
+
+    private static String sanitizeUriToString(Uri uri) {
+        if (uri != null) {
+            String uriString = uri.toString();
+            int indexOfLastSlash = uriString.lastIndexOf('/');
+            if (indexOfLastSlash > 0) {
+                return uriString.substring(0, indexOfLastSlash) + "/xxxxxxx";
+            } else {
+                return uriString;
+            }
+        } else {
+            return "";
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/CallerInfoUtils.java b/InCallUI/src/com/android/incallui/CallerInfoUtils.java
new file mode 100644
index 0000000..ae59d7d
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/CallerInfoUtils.java
@@ -0,0 +1,234 @@
+package com.android.incallui;
+
+import android.content.Context;
+import android.content.Loader;
+import android.content.Loader.OnLoadCompleteListener;
+import android.net.Uri;
+import android.telecom.PhoneAccount;
+import android.telecom.TelecomManager;
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.android.contacts.common.compat.telecom.TelecomManagerCompat;
+import com.android.contacts.common.model.Contact;
+import com.android.contacts.common.model.ContactLoader;
+import com.android.dialer.calllog.ContactInfo;
+import com.android.dialer.service.CachedNumberLookupService;
+import com.android.dialer.service.CachedNumberLookupService.CachedContactInfo;
+
+import java.util.Arrays;
+
+/**
+ * Utility methods for contact and caller info related functionality
+ */
+public class CallerInfoUtils {
+
+    private static final String TAG = CallerInfoUtils.class.getSimpleName();
+
+    /** Define for not a special CNAP string */
+    private static final int CNAP_SPECIAL_CASE_NO = -1;
+
+    public CallerInfoUtils() {
+    }
+
+    private static final int QUERY_TOKEN = -1;
+
+    /**
+     * This is called to get caller info for a call. This will return a CallerInfo
+     * object immediately based off information in the call, but
+     * more information is returned to the OnQueryCompleteListener (which contains
+     * information about the phone number label, user's name, etc).
+     */
+    public static CallerInfo getCallerInfoForCall(Context context, Call call,
+            CallerInfoAsyncQuery.OnQueryCompleteListener listener) {
+        CallerInfo info = buildCallerInfo(context, call);
+
+        // TODO: Have phoneapp send a Uri when it knows the contact that triggered this call.
+
+        if (info.numberPresentation == TelecomManager.PRESENTATION_ALLOWED) {
+            // Start the query with the number provided from the call.
+            Log.d(TAG, "==> Actually starting CallerInfoAsyncQuery.startQuery()...");
+            CallerInfoAsyncQuery.startQuery(QUERY_TOKEN, context, info, listener, call);
+        }
+        return info;
+    }
+
+    public static CallerInfo buildCallerInfo(Context context, Call call) {
+        CallerInfo info = new CallerInfo();
+
+        // Store CNAP information retrieved from the Connection (we want to do this
+        // here regardless of whether the number is empty or not).
+        info.cnapName = call.getCnapName();
+        info.name = info.cnapName;
+        info.numberPresentation = call.getNumberPresentation();
+        info.namePresentation = call.getCnapNamePresentation();
+        info.callSubject = call.getCallSubject();
+
+        String number = call.getNumber();
+        if (!TextUtils.isEmpty(number)) {
+            final String[] numbers = number.split("&");
+            number = numbers[0];
+            if (numbers.length > 1) {
+                info.forwardingNumber = numbers[1];
+            }
+
+            number = modifyForSpecialCnapCases(context, info, number, info.numberPresentation);
+            info.phoneNumber = number;
+        }
+
+        // Because the InCallUI is immediately launched before the call is connected, occasionally
+        // a voicemail call will be passed to InCallUI as a "voicemail:" URI without a number.
+        // This call should still be handled as a voicemail call.
+        if ((call.getHandle() != null &&
+                PhoneAccount.SCHEME_VOICEMAIL.equals(call.getHandle().getScheme())) ||
+                isVoiceMailNumber(context, call)) {
+            info.markAsVoiceMail(context);
+        }
+
+        ContactInfoCache.getInstance(context).maybeInsertCnapInformationIntoCache(context, call,
+                info);
+
+        return info;
+    }
+
+    /**
+     * Creates a new {@link CachedContactInfo} from a {@link CallerInfo}
+     *
+     * @param lookupService the {@link CachedNumberLookupService} used to build a
+     *        new {@link CachedContactInfo}
+     * @param {@link CallerInfo} object
+     * @return a CachedContactInfo object created from this CallerInfo
+     * @throws NullPointerException if lookupService or ci are null
+     */
+    public static CachedContactInfo buildCachedContactInfo(CachedNumberLookupService lookupService,
+            CallerInfo ci) {
+        ContactInfo info = new ContactInfo();
+        info.name = ci.name;
+        info.type = ci.numberType;
+        info.label = ci.phoneLabel;
+        info.number = ci.phoneNumber;
+        info.normalizedNumber = ci.normalizedNumber;
+        info.photoUri = ci.contactDisplayPhotoUri;
+        info.userType = ci.userType;
+
+        CachedContactInfo cacheInfo = lookupService.buildCachedContactInfo(info);
+        cacheInfo.setLookupKey(ci.lookupKeyOrNull);
+        return cacheInfo;
+    }
+
+    public static boolean isVoiceMailNumber(Context context, Call call) {
+         return TelecomManagerCompat.isVoiceMailNumber(
+                 (TelecomManager) context.getSystemService(Context.TELECOM_SERVICE),
+                 call.getTelecomCall().getDetails().getAccountHandle(),
+                 call.getNumber());
+    }
+
+    /**
+     * Handles certain "corner cases" for CNAP. When we receive weird phone numbers
+     * from the network to indicate different number presentations, convert them to
+     * expected number and presentation values within the CallerInfo object.
+     * @param number number we use to verify if we are in a corner case
+     * @param presentation presentation value used to verify if we are in a corner case
+     * @return the new String that should be used for the phone number
+     */
+    /* package */static String modifyForSpecialCnapCases(Context context, CallerInfo ci,
+            String number, int presentation) {
+        // Obviously we return number if ci == null, but still return number if
+        // number == null, because in these cases the correct string will still be
+        // displayed/logged after this function returns based on the presentation value.
+        if (ci == null || number == null) return number;
+
+        Log.d(TAG, "modifyForSpecialCnapCases: initially, number="
+                + toLogSafePhoneNumber(number)
+                + ", presentation=" + presentation + " ci " + ci);
+
+        // "ABSENT NUMBER" is a possible value we could get from the network as the
+        // phone number, so if this happens, change it to "Unknown" in the CallerInfo
+        // and fix the presentation to be the same.
+        final String[] absentNumberValues =
+                context.getResources().getStringArray(R.array.absent_num);
+        if (Arrays.asList(absentNumberValues).contains(number)
+                && presentation == TelecomManager.PRESENTATION_ALLOWED) {
+            number = context.getString(R.string.unknown);
+            ci.numberPresentation = TelecomManager.PRESENTATION_UNKNOWN;
+        }
+
+        // Check for other special "corner cases" for CNAP and fix them similarly. Corner
+        // cases only apply if we received an allowed presentation from the network, so check
+        // if we think we have an allowed presentation, or if the CallerInfo presentation doesn't
+        // match the presentation passed in for verification (meaning we changed it previously
+        // because it's a corner case and we're being called from a different entry point).
+        if (ci.numberPresentation == TelecomManager.PRESENTATION_ALLOWED
+                || (ci.numberPresentation != presentation
+                        && presentation == TelecomManager.PRESENTATION_ALLOWED)) {
+            // For all special strings, change number & numberPrentation.
+            if (isCnapSpecialCaseRestricted(number)) {
+                number = context.getString(R.string.private_num);
+                ci.numberPresentation = TelecomManager.PRESENTATION_RESTRICTED;
+            } else if (isCnapSpecialCaseUnknown(number)) {
+                number = context.getString(R.string.unknown);
+                ci.numberPresentation = TelecomManager.PRESENTATION_UNKNOWN;
+            }
+            Log.d(TAG, "SpecialCnap: number=" + toLogSafePhoneNumber(number)
+                    + "; presentation now=" + ci.numberPresentation);
+        }
+        Log.d(TAG, "modifyForSpecialCnapCases: returning number string="
+                + toLogSafePhoneNumber(number));
+        return number;
+    }
+
+    private static boolean isCnapSpecialCaseRestricted(String n) {
+        return n.equals("PRIVATE") || n.equals("P") || n.equals("RES");
+    }
+
+    private static boolean isCnapSpecialCaseUnknown(String n) {
+        return n.equals("UNAVAILABLE") || n.equals("UNKNOWN") || n.equals("UNA") || n.equals("U");
+    }
+
+    /* package */static String toLogSafePhoneNumber(String number) {
+        // For unknown number, log empty string.
+        if (number == null) {
+            return "";
+        }
+
+        // Todo: Figure out an equivalent for VDBG
+        if (false) {
+            // When VDBG is true we emit PII.
+            return number;
+        }
+
+        // Do exactly same thing as Uri#toSafeString() does, which will enable us to compare
+        // sanitized phone numbers.
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < number.length(); i++) {
+            char c = number.charAt(i);
+            if (c == '-' || c == '@' || c == '.' || c == '&') {
+                builder.append(c);
+            } else {
+                builder.append('x');
+            }
+        }
+        return builder.toString();
+    }
+
+    /**
+     * Send a notification using a {@link ContactLoader} to inform the sync adapter that we are
+     * viewing a particular contact, so that it can download the high-res photo.
+     */
+    public static void sendViewNotification(Context context, Uri contactUri) {
+        final ContactLoader loader = new ContactLoader(context, contactUri,
+                true /* postViewNotification */);
+        loader.registerListener(0, new OnLoadCompleteListener<Contact>() {
+            @Override
+            public void onLoadComplete(
+                    Loader<Contact> loader, Contact contact) {
+                try {
+                    loader.reset();
+                } catch (RuntimeException e) {
+                    Log.e(TAG, "Error resetting loader", e);
+                }
+            }
+        });
+        loader.startLoading();
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/CircularRevealFragment.java b/InCallUI/src/com/android/incallui/CircularRevealFragment.java
new file mode 100644
index 0000000..f4a2e91
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/CircularRevealFragment.java
@@ -0,0 +1,169 @@
+/*
+ * 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.
+ */
+
+package com.android.incallui;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.app.Activity;
+import android.app.Fragment;
+import android.app.FragmentManager;
+import android.graphics.Outline;
+import android.graphics.Point;
+import android.os.Bundle;
+import android.view.Display;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewAnimationUtils;
+import android.view.ViewGroup;
+import android.view.ViewOutlineProvider;
+import android.view.ViewTreeObserver;
+import android.view.ViewTreeObserver.OnPreDrawListener;
+
+import com.android.contacts.common.util.MaterialColorMapUtils.MaterialPalette;
+
+public class CircularRevealFragment extends Fragment {
+    static final String TAG = "CircularRevealFragment";
+
+    private Point mTouchPoint;
+    private OnCircularRevealCompleteListener mListener;
+    private boolean mAnimationStarted;
+
+    interface OnCircularRevealCompleteListener {
+        public void onCircularRevealComplete(FragmentManager fm);
+    }
+
+    public static void startCircularReveal(FragmentManager fm, Point touchPoint,
+            OnCircularRevealCompleteListener listener) {
+        if (fm.findFragmentByTag(TAG) == null) {
+            fm.beginTransaction().add(R.id.main,
+                    new CircularRevealFragment(touchPoint, listener), TAG)
+                            .commitAllowingStateLoss();
+        } else {
+            Log.w(TAG, "An instance of CircularRevealFragment already exists");
+        }
+    }
+
+    public static void endCircularReveal(FragmentManager fm) {
+        final Fragment fragment = fm.findFragmentByTag(TAG);
+        if (fragment != null) {
+            fm.beginTransaction().remove(fragment).commitAllowingStateLoss();
+        }
+    }
+
+    /**
+     * Empty constructor used only by the {@link FragmentManager}.
+     */
+    public CircularRevealFragment() {}
+
+    public CircularRevealFragment(Point touchPoint, OnCircularRevealCompleteListener listener) {
+        mTouchPoint = touchPoint;
+        mListener = listener;
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        if (!mAnimationStarted) {
+            // Only run the animation once for each instance of the fragment
+            startOutgoingAnimation(InCallPresenter.getInstance().getThemeColors());
+        }
+        mAnimationStarted = true;
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.outgoing_call_animation, container, false);
+    }
+
+    public void startOutgoingAnimation(MaterialPalette palette) {
+        final Activity activity = getActivity();
+        if (activity == null) {
+            Log.w(this, "Asked to do outgoing call animation when not attached");
+            return;
+        }
+
+        final View view  = activity.getWindow().getDecorView();
+
+        // The circle starts from an initial size of 0 so clip it such that it is invisible.
+        // Otherwise the first frame is drawn with a fully opaque screen which causes jank. When
+        // the animation later starts, this clip will be clobbered by the circular reveal clip.
+        // See ViewAnimationUtils.createCircularReveal.
+        view.setOutlineProvider(new ViewOutlineProvider() {
+            @Override
+            public void getOutline(View view, Outline outline) {
+                // Using (0, 0, 0, 0) will not work since the outline will simply be treated as
+                // an empty outline.
+                outline.setOval(-1, -1, 0, 0);
+            }
+        });
+        view.setClipToOutline(true);
+
+        if (palette != null) {
+            view.findViewById(R.id.outgoing_call_animation_circle).setBackgroundColor(
+                    palette.mPrimaryColor);
+            activity.getWindow().setStatusBarColor(palette.mSecondaryColor);
+        }
+
+        view.getViewTreeObserver().addOnPreDrawListener(new OnPreDrawListener() {
+            @Override
+            public boolean onPreDraw() {
+                final ViewTreeObserver vto = view.getViewTreeObserver();
+                if (vto.isAlive()) {
+                    vto.removeOnPreDrawListener(this);
+                }
+                final Animator animator = getRevealAnimator(mTouchPoint);
+                if (animator != null) {
+                    animator.addListener(new AnimatorListenerAdapter() {
+                        @Override
+                        public void onAnimationEnd(Animator animation) {
+                            view.setClipToOutline(false);
+                            if (mListener != null) {
+                                mListener.onCircularRevealComplete(getFragmentManager());
+                            }
+                        }
+                    });
+                    animator.start();
+                }
+                return false;
+            }
+        });
+    }
+
+    private Animator getRevealAnimator(Point touchPoint) {
+        final Activity activity = getActivity();
+        if (activity == null) {
+            return null;
+        }
+        final View view  = activity.getWindow().getDecorView();
+        final Display display = activity.getWindowManager().getDefaultDisplay();
+        final Point size = new Point();
+        display.getSize(size);
+
+        int startX = size.x / 2;
+        int startY = size.y / 2;
+        if (touchPoint != null) {
+            startX = touchPoint.x;
+            startY = touchPoint.y;
+        }
+
+        final Animator valueAnimator = ViewAnimationUtils.createCircularReveal(view,
+                startX, startY, 0, Math.max(size.x, size.y));
+        valueAnimator.setDuration(getResources().getInteger(R.integer.reveal_animation_duration));
+        return valueAnimator;
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/ConferenceManagerFragment.java b/InCallUI/src/com/android/incallui/ConferenceManagerFragment.java
new file mode 100644
index 0000000..f5f52fc
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ConferenceManagerFragment.java
@@ -0,0 +1,138 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.app.ActionBar;
+import android.content.Context;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ListView;
+
+import com.android.contacts.common.ContactPhotoManager;
+
+import java.util.List;
+
+/**
+ * Fragment that allows the user to manage a conference call.
+ */
+public class ConferenceManagerFragment
+        extends BaseFragment<ConferenceManagerPresenter,
+                ConferenceManagerPresenter.ConferenceManagerUi>
+        implements ConferenceManagerPresenter.ConferenceManagerUi {
+
+    private static final String KEY_IS_VISIBLE = "key_conference_is_visible";
+
+    private ListView mConferenceParticipantList;
+    private int mActionBarElevation;
+    private ContactPhotoManager mContactPhotoManager;
+    private LayoutInflater mInflater;
+    private ConferenceParticipantListAdapter mConferenceParticipantListAdapter;
+    private boolean mIsVisible;
+    private boolean mIsRecreating;
+
+    @Override
+    public ConferenceManagerPresenter createPresenter() {
+        return new ConferenceManagerPresenter();
+    }
+
+    @Override
+    public ConferenceManagerPresenter.ConferenceManagerUi getUi() {
+        return this;
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        if (savedInstanceState != null) {
+            mIsRecreating = true;
+            mIsVisible = savedInstanceState.getBoolean(KEY_IS_VISIBLE);
+        }
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        final View parent =
+                inflater.inflate(R.layout.conference_manager_fragment, container, false);
+
+        mConferenceParticipantList = (ListView) parent.findViewById(R.id.participantList);
+        mContactPhotoManager =
+                ContactPhotoManager.getInstance(getActivity().getApplicationContext());
+        mActionBarElevation =
+                (int) getResources().getDimension(R.dimen.incall_action_bar_elevation);
+        mInflater = LayoutInflater.from(getActivity().getApplicationContext());
+
+        return parent;
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        if (mIsRecreating) {
+            onVisibilityChanged(mIsVisible);
+        }
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        outState.putBoolean(KEY_IS_VISIBLE, mIsVisible);
+        super.onSaveInstanceState(outState);
+    }
+
+    public void onVisibilityChanged(boolean isVisible) {
+        mIsVisible = isVisible;
+        ActionBar actionBar = getActivity().getActionBar();
+        if (isVisible) {
+            actionBar.setTitle(R.string.manageConferenceLabel);
+            actionBar.setElevation(mActionBarElevation);
+            actionBar.setHideOffset(0);
+            actionBar.show();
+
+            final CallList calls = CallList.getInstance();
+            getPresenter().init(getActivity(), calls);
+            // Request focus on the list of participants for accessibility purposes.  This ensures
+            // that once the list of participants is shown, the first participant is announced.
+            mConferenceParticipantList.requestFocus();
+        } else {
+            actionBar.setElevation(0);
+            actionBar.setHideOffset(actionBar.getHeight());
+        }
+    }
+
+    @Override
+    public boolean isFragmentVisible() {
+        return isVisible();
+    }
+
+    @Override
+    public void update(Context context, List<Call> participants, boolean parentCanSeparate) {
+        if (mConferenceParticipantListAdapter == null) {
+            mConferenceParticipantListAdapter = new ConferenceParticipantListAdapter(
+                    mConferenceParticipantList, context, mInflater, mContactPhotoManager);
+
+            mConferenceParticipantList.setAdapter(mConferenceParticipantListAdapter);
+        }
+        mConferenceParticipantListAdapter.updateParticipants(participants, parentCanSeparate);
+    }
+
+    @Override
+    public void refreshCall(Call call) {
+        mConferenceParticipantListAdapter.refreshCall(call);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/ConferenceManagerPresenter.java b/InCallUI/src/com/android/incallui/ConferenceManagerPresenter.java
new file mode 100644
index 0000000..6fb6e5d
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ConferenceManagerPresenter.java
@@ -0,0 +1,144 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+
+import com.android.incallui.InCallPresenter.InCallDetailsListener;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.incallui.InCallPresenter.IncomingCallListener;
+
+import com.google.common.base.Preconditions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Logic for call buttons.
+ */
+public class ConferenceManagerPresenter
+        extends Presenter<ConferenceManagerPresenter.ConferenceManagerUi>
+        implements InCallStateListener, InCallDetailsListener, IncomingCallListener {
+
+    private Context mContext;
+
+    @Override
+    public void onUiReady(ConferenceManagerUi ui) {
+        super.onUiReady(ui);
+
+        // register for call state changes last
+        InCallPresenter.getInstance().addListener(this);
+        InCallPresenter.getInstance().addIncomingCallListener(this);
+    }
+
+    @Override
+    public void onUiUnready(ConferenceManagerUi ui) {
+        super.onUiUnready(ui);
+
+        InCallPresenter.getInstance().removeListener(this);
+        InCallPresenter.getInstance().removeIncomingCallListener(this);
+    }
+
+    @Override
+    public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+        if (getUi().isFragmentVisible()) {
+            Log.v(this, "onStateChange" + newState);
+            if (newState == InCallState.INCALL) {
+                final Call call = callList.getActiveOrBackgroundCall();
+                if (call != null && call.isConferenceCall()) {
+                    Log.v(this, "Number of existing calls is " +
+                            String.valueOf(call.getChildCallIds().size()));
+                    update(callList);
+                } else {
+                    InCallPresenter.getInstance().showConferenceCallManager(false);
+                }
+            } else {
+                InCallPresenter.getInstance().showConferenceCallManager(false);
+            }
+        }
+    }
+
+    @Override
+    public void onDetailsChanged(Call call, android.telecom.Call.Details details) {
+        boolean canDisconnect = details.can(
+                android.telecom.Call.Details.CAPABILITY_DISCONNECT_FROM_CONFERENCE);
+        boolean canSeparate = details.can(
+                android.telecom.Call.Details.CAPABILITY_SEPARATE_FROM_CONFERENCE);
+
+        if (call.can(android.telecom.Call.Details.CAPABILITY_DISCONNECT_FROM_CONFERENCE)
+                != canDisconnect
+            || call.can(android.telecom.Call.Details.CAPABILITY_SEPARATE_FROM_CONFERENCE)
+                != canSeparate) {
+            getUi().refreshCall(call);
+        }
+
+        if (!details.can(
+                android.telecom.Call.Details.CAPABILITY_MANAGE_CONFERENCE)) {
+            InCallPresenter.getInstance().showConferenceCallManager(false);
+        }
+    }
+
+    @Override
+    public void onIncomingCall(InCallState oldState, InCallState newState, Call call) {
+        // When incoming call exists, set conference ui invisible.
+        if (getUi().isFragmentVisible()) {
+            Log.d(this, "onIncomingCall()... Conference ui is showing, hide it.");
+            InCallPresenter.getInstance().showConferenceCallManager(false);
+        }
+    }
+
+    public void init(Context context, CallList callList) {
+        mContext = Preconditions.checkNotNull(context);
+        mContext = context;
+        update(callList);
+    }
+
+    /**
+     * Updates the conference participant adapter.
+     *
+     * @param callList The callList.
+     */
+    private void update(CallList callList) {
+        // callList is non null, but getActiveOrBackgroundCall() may return null
+        final Call currentCall = callList.getActiveOrBackgroundCall();
+        if (currentCall == null) {
+            return;
+        }
+
+        ArrayList<Call> calls = new ArrayList<>(currentCall.getChildCallIds().size());
+        for (String callerId : currentCall.getChildCallIds()) {
+            calls.add(callList.getCallById(callerId));
+        }
+
+        Log.d(this, "Number of calls is " + String.valueOf(calls.size()));
+
+        // Users can split out a call from the conference call if either the active call or the
+        // holding call is empty. If both are filled, users can not split out another call.
+        final boolean hasActiveCall = (callList.getActiveCall() != null);
+        final boolean hasHoldingCall = (callList.getBackgroundCall() != null);
+        boolean canSeparate = !(hasActiveCall && hasHoldingCall);
+
+        getUi().update(mContext, calls, canSeparate);
+    }
+
+    public interface ConferenceManagerUi extends Ui {
+        boolean isFragmentVisible();
+        void update(Context context, List<Call> participants, boolean parentCanSeparate);
+        void refreshCall(Call call);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/ConferenceParticipantListAdapter.java b/InCallUI/src/com/android/incallui/ConferenceParticipantListAdapter.java
new file mode 100644
index 0000000..86002b0
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ConferenceParticipantListAdapter.java
@@ -0,0 +1,534 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import com.google.common.base.MoreObjects;
+
+import android.content.Context;
+import android.net.Uri;
+import android.support.annotation.Nullable;
+import android.text.BidiFormatter;
+import android.text.TextDirectionHeuristics;
+import android.text.TextUtils;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ImageView;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import com.android.contacts.common.ContactPhotoManager;
+import com.android.contacts.common.ContactPhotoManager.DefaultImageRequest;
+import com.android.contacts.common.compat.PhoneNumberUtilsCompat;
+import com.android.contacts.common.preference.ContactsPreferences;
+import com.android.contacts.common.util.ContactDisplayUtils;
+import com.android.incallui.ContactInfoCache.ContactCacheEntry;
+import com.android.incallui.compat.telecom.DetailsCompat;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Adapter for a ListView containing conference call participant information.
+ */
+public class ConferenceParticipantListAdapter extends BaseAdapter {
+
+    /**
+     * Internal class which represents a participant.  Includes a reference to the {@link Call} and
+     * the corresponding {@link ContactCacheEntry} for the participant.
+     */
+    private class ParticipantInfo {
+        private Call mCall;
+        private ContactCacheEntry mContactCacheEntry;
+        private boolean mCacheLookupComplete = false;
+
+        public ParticipantInfo(Call call, ContactCacheEntry contactCacheEntry) {
+            mCall = call;
+            mContactCacheEntry = contactCacheEntry;
+        }
+
+        public Call getCall() {
+            return mCall;
+        }
+
+        public void setCall(Call call) {
+            mCall = call;
+        }
+
+        public ContactCacheEntry getContactCacheEntry() {
+            return mContactCacheEntry;
+        }
+
+        public void setContactCacheEntry(ContactCacheEntry entry) {
+            mContactCacheEntry = entry;
+        }
+
+        public boolean isCacheLookupComplete() {
+            return mCacheLookupComplete;
+        }
+
+        public void setCacheLookupComplete(boolean cacheLookupComplete) {
+            mCacheLookupComplete = cacheLookupComplete;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o instanceof ParticipantInfo) {
+                ParticipantInfo p = (ParticipantInfo) o;
+                return
+                        Objects.equals(p.getCall().getId(), mCall.getId());
+            }
+            return false;
+        }
+
+        @Override
+        public int hashCode() {
+            return mCall.getId().hashCode();
+        }
+    }
+
+    /**
+     * Callback class used when making requests to the {@link ContactInfoCache} to resolve contact
+     * info and contact photos for conference participants.
+     */
+    public static class ContactLookupCallback implements ContactInfoCache.ContactInfoCacheCallback {
+        private final WeakReference<ConferenceParticipantListAdapter> mListAdapter;
+
+        public ContactLookupCallback(ConferenceParticipantListAdapter listAdapter) {
+            mListAdapter = new WeakReference<ConferenceParticipantListAdapter>(listAdapter);
+        }
+
+        /**
+         * Called when contact info has been resolved.
+         *
+         * @param callId The call id.
+         * @param entry The new contact information.
+         */
+        @Override
+        public void onContactInfoComplete(String callId, ContactCacheEntry entry) {
+            update(callId, entry);
+        }
+
+        /**
+         * Called when contact photo has been loaded into the cache.
+         *
+         * @param callId The call id.
+         * @param entry The new contact information.
+         */
+        @Override
+        public void onImageLoadComplete(String callId, ContactCacheEntry entry) {
+            update(callId, entry);
+        }
+
+        @Override
+        public void onContactInteractionsInfoComplete(String callId, ContactCacheEntry entry) {}
+
+        /**
+         * Updates the contact information for a participant.
+         *
+         * @param callId The call id.
+         * @param entry The new contact information.
+         */
+        private void update(String callId, ContactCacheEntry entry) {
+            ConferenceParticipantListAdapter listAdapter = mListAdapter.get();
+            if (listAdapter != null) {
+                listAdapter.updateContactInfo(callId, entry);
+            }
+        }
+    }
+
+    /**
+     * Listener used to handle tap of the "disconnect' button for a participant.
+     */
+    private View.OnClickListener mDisconnectListener = new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            View parent = (View) v.getParent();
+            String callId = (String) parent.getTag();
+            TelecomAdapter.getInstance().disconnectCall(callId);
+        }
+    };
+
+    /**
+     * Listener used to handle tap of the "separate' button for a participant.
+     */
+    private View.OnClickListener mSeparateListener = new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+            View parent = (View) v.getParent();
+            String callId = (String) parent.getTag();
+            TelecomAdapter.getInstance().separateCall(callId);
+        }
+    };
+
+    /**
+     * The ListView containing the participant information.
+     */
+    private final ListView mListView;
+
+    /**
+     * The conference participants to show in the ListView.
+     */
+    private List<ParticipantInfo> mConferenceParticipants = new ArrayList<>();
+
+    /**
+     * Hashmap to make accessing participant info by call Id faster.
+     */
+    private final HashMap<String, ParticipantInfo> mParticipantsByCallId = new HashMap<>();
+
+    /**
+     * The context.
+     */
+    private final Context mContext;
+
+    /**
+     * ContactsPreferences used to lookup displayName preferences
+     */
+    @Nullable private final ContactsPreferences mContactsPreferences;
+
+    /**
+     * The layout inflater used to inflate new views.
+     */
+    private final LayoutInflater mLayoutInflater;
+
+    /**
+     * Contact photo manager to retrieve cached contact photo information.
+     */
+    private final ContactPhotoManager mContactPhotoManager;
+
+    /**
+     * {@code True} if the conference parent supports separating calls from the conference.
+     */
+    private boolean mParentCanSeparate;
+
+    /**
+     * Creates an instance of the ConferenceParticipantListAdapter.
+     *
+     * @param listView The listview.
+     * @param context The context.
+     * @param layoutInflater The layout inflater.
+     * @param contactPhotoManager The contact photo manager, used to load contact photos.
+     */
+    public ConferenceParticipantListAdapter(ListView listView, Context context,
+            LayoutInflater layoutInflater, ContactPhotoManager contactPhotoManager) {
+
+        mListView = listView;
+        mContext = context;
+        mContactsPreferences = ContactsPreferencesFactory.newContactsPreferences(mContext);
+        mLayoutInflater = layoutInflater;
+        mContactPhotoManager = contactPhotoManager;
+    }
+
+    /**
+     * Updates the adapter with the new conference participant information provided.
+     *
+     * @param conferenceParticipants The list of conference participants.
+     * @param parentCanSeparate {@code True} if the parent supports separating calls from the
+     *                                      conference.
+     */
+    public void updateParticipants(List<Call> conferenceParticipants, boolean parentCanSeparate) {
+        if (mContactsPreferences != null) {
+            mContactsPreferences.refreshValue(ContactsPreferences.DISPLAY_ORDER_KEY);
+            mContactsPreferences.refreshValue(ContactsPreferences.SORT_ORDER_KEY);
+        }
+        mParentCanSeparate = parentCanSeparate;
+        updateParticipantInfo(conferenceParticipants);
+    }
+
+    /**
+     * Determines the number of participants in the conference.
+     *
+     * @return The number of participants.
+     */
+    @Override
+    public int getCount() {
+        return mConferenceParticipants.size();
+    }
+
+    /**
+     * Retrieves an item from the list of participants.
+     *
+     * @param position Position of the item whose data we want within the adapter's
+     * data set.
+     * @return The {@link ParticipantInfo}.
+     */
+    @Override
+    public Object getItem(int position) {
+        return mConferenceParticipants.get(position);
+    }
+
+    /**
+     * Retreives the adapter-specific item id for an item at a specified position.
+     *
+     * @param position The position of the item within the adapter's data set whose row id we want.
+     * @return The item id.
+     */
+    @Override
+    public long getItemId(int position) {
+        return position;
+    }
+
+    /**
+     * Refreshes call information for the call passed in.
+     *
+     * @param call The new call information.
+     */
+    public void refreshCall(Call call) {
+        String callId = call.getId();
+
+        if (mParticipantsByCallId.containsKey(callId)) {
+            ParticipantInfo participantInfo = mParticipantsByCallId.get(callId);
+            participantInfo.setCall(call);
+            refreshView(callId);
+        }
+    }
+
+    /**
+     * Attempts to refresh the view for the specified call ID.  This ensures the contact info and
+     * photo loaded from cache are updated.
+     *
+     * @param callId The call id.
+     */
+    private void refreshView(String callId) {
+        int first = mListView.getFirstVisiblePosition();
+        int last = mListView.getLastVisiblePosition();
+
+        for (int position = 0; position <= last - first; position++) {
+            View view = mListView.getChildAt(position);
+            String rowCallId = (String) view.getTag();
+            if (rowCallId.equals(callId)) {
+                getView(position+first, view, mListView);
+                break;
+            }
+        }
+    }
+
+    /**
+     * Creates or populates an existing conference participant row.
+     *
+     * @param position The position of the item within the adapter's data set of the item whose view
+     *        we want.
+     * @param convertView The old view to reuse, if possible.
+     * @param parent The parent that this view will eventually be attached to
+     * @return The populated view.
+     */
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+        // Make sure we have a valid convertView to start with
+        final View result = convertView == null
+                        ? mLayoutInflater.inflate(R.layout.caller_in_conference, parent, false)
+                        : convertView;
+
+        ParticipantInfo participantInfo = mConferenceParticipants.get(position);
+        Call call = participantInfo.getCall();
+        ContactCacheEntry contactCache = participantInfo.getContactCacheEntry();
+
+        final ContactInfoCache cache = ContactInfoCache.getInstance(mContext);
+
+        // If a cache lookup has not yet been performed to retrieve the contact information and
+        // photo, do it now.
+        if (!participantInfo.isCacheLookupComplete()) {
+            cache.findInfo(participantInfo.getCall(),
+                    participantInfo.getCall().getState() == Call.State.INCOMING,
+                    new ContactLookupCallback(this));
+        }
+
+        boolean thisRowCanSeparate = mParentCanSeparate && DetailsCompat.can(
+                call.getTelecomCall().getDetails(),
+                android.telecom.Call.Details.CAPABILITY_SEPARATE_FROM_CONFERENCE);
+        boolean thisRowCanDisconnect = DetailsCompat.can(call.getTelecomCall().getDetails(),
+                android.telecom.Call.Details.CAPABILITY_DISCONNECT_FROM_CONFERENCE);
+
+        setCallerInfoForRow(result, contactCache.namePrimary,
+                ContactDisplayUtils.getPreferredDisplayName(contactCache.namePrimary,
+                        contactCache.nameAlternative, mContactsPreferences),
+                contactCache.number, contactCache.label,
+                contactCache.lookupKey, contactCache.displayPhotoUri, thisRowCanSeparate,
+                thisRowCanDisconnect);
+
+        // Tag the row in the conference participant list with the call id to make it easier to
+        // find calls when contact cache information is loaded.
+        result.setTag(call.getId());
+
+        return result;
+    }
+
+    /**
+     * Replaces the contact info for a participant and triggers a refresh of the UI.
+     *
+     * @param callId The call id.
+     * @param entry The new contact info.
+     */
+    /* package */ void updateContactInfo(String callId, ContactCacheEntry entry) {
+        if (mParticipantsByCallId.containsKey(callId)) {
+            ParticipantInfo participantInfo = mParticipantsByCallId.get(callId);
+            participantInfo.setContactCacheEntry(entry);
+            participantInfo.setCacheLookupComplete(true);
+            refreshView(callId);
+        }
+    }
+
+    /**
+     * Sets the caller information for a row in the conference participant list.
+     *
+     * @param view The view to set the details on.
+     * @param callerName The participant's name.
+     * @param callerNumber The participant's phone number.
+     * @param callerNumberType The participant's phone number typ.e
+     * @param lookupKey The lookup key for the participant (for photo lookup).
+     * @param photoUri The URI of the contact photo.
+     * @param thisRowCanSeparate {@code True} if this participant can separate from the conference.
+     * @param thisRowCanDisconnect {@code True} if this participant can be disconnected.
+     */
+    private final void setCallerInfoForRow(View view, String callerName, String preferredName,
+            String callerNumber, String callerNumberType, String lookupKey, Uri photoUri,
+            boolean thisRowCanSeparate, boolean thisRowCanDisconnect) {
+
+        final ImageView photoView = (ImageView) view.findViewById(R.id.callerPhoto);
+        final TextView nameTextView = (TextView) view.findViewById(R.id.conferenceCallerName);
+        final TextView numberTextView = (TextView) view.findViewById(R.id.conferenceCallerNumber);
+        final TextView numberTypeTextView = (TextView) view.findViewById(
+                R.id.conferenceCallerNumberType);
+        final View endButton = view.findViewById(R.id.conferenceCallerDisconnect);
+        final View separateButton = view.findViewById(R.id.conferenceCallerSeparate);
+
+        endButton.setVisibility(thisRowCanDisconnect ? View.VISIBLE : View.GONE);
+        if (thisRowCanDisconnect) {
+            endButton.setOnClickListener(mDisconnectListener);
+        } else {
+            endButton.setOnClickListener(null);
+        }
+
+        separateButton.setVisibility(thisRowCanSeparate ? View.VISIBLE : View.GONE);
+        if (thisRowCanSeparate) {
+            separateButton.setOnClickListener(mSeparateListener);
+        } else {
+            separateButton.setOnClickListener(null);
+        }
+
+        DefaultImageRequest imageRequest = (photoUri != null) ? null :
+                new DefaultImageRequest(callerName, lookupKey, true /* isCircularPhoto */);
+
+        mContactPhotoManager.loadDirectoryPhoto(photoView, photoUri, false, true, imageRequest);
+
+        // set the caller name
+        nameTextView.setText(preferredName);
+
+        // set the caller number in subscript, or make the field disappear.
+        if (TextUtils.isEmpty(callerNumber)) {
+            numberTextView.setVisibility(View.GONE);
+            numberTypeTextView.setVisibility(View.GONE);
+        } else {
+            numberTextView.setVisibility(View.VISIBLE);
+            numberTextView.setText(PhoneNumberUtilsCompat.createTtsSpannable(
+                    BidiFormatter.getInstance().unicodeWrap(
+                            callerNumber, TextDirectionHeuristics.LTR)));
+            numberTypeTextView.setVisibility(View.VISIBLE);
+            numberTypeTextView.setText(callerNumberType);
+        }
+    }
+
+    /**
+     * Updates the participant info list which is bound to the ListView.  Stores the call and
+     * contact info for all entries.  The list is sorted alphabetically by participant name.
+     *
+     * @param conferenceParticipants The calls which make up the conference participants.
+     */
+    private void updateParticipantInfo(List<Call> conferenceParticipants) {
+        final ContactInfoCache cache = ContactInfoCache.getInstance(mContext);
+        boolean newParticipantAdded = false;
+        HashSet<String> newCallIds = new HashSet<>(conferenceParticipants.size());
+
+        // Update or add conference participant info.
+        for (Call call : conferenceParticipants) {
+            String callId = call.getId();
+            newCallIds.add(callId);
+            ContactCacheEntry contactCache = cache.getInfo(callId);
+            if (contactCache == null) {
+                contactCache = ContactInfoCache.buildCacheEntryFromCall(mContext, call,
+                        call.getState() == Call.State.INCOMING);
+            }
+
+            if (mParticipantsByCallId.containsKey(callId)) {
+                ParticipantInfo participantInfo = mParticipantsByCallId.get(callId);
+                participantInfo.setCall(call);
+                participantInfo.setContactCacheEntry(contactCache);
+            } else {
+                newParticipantAdded = true;
+                ParticipantInfo participantInfo = new ParticipantInfo(call, contactCache);
+                mConferenceParticipants.add(participantInfo);
+                mParticipantsByCallId.put(call.getId(), participantInfo);
+            }
+        }
+
+        // Remove any participants that no longer exist.
+        Iterator<Map.Entry<String, ParticipantInfo>> it =
+                mParticipantsByCallId.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry<String, ParticipantInfo> entry = it.next();
+            String existingCallId = entry.getKey();
+            if (!newCallIds.contains(existingCallId)) {
+                ParticipantInfo existingInfo = entry.getValue();
+                mConferenceParticipants.remove(existingInfo);
+                it.remove();
+            }
+        }
+
+        if (newParticipantAdded) {
+            // Sort the list of participants by contact name.
+            sortParticipantList();
+        }
+        notifyDataSetChanged();
+    }
+
+    /**
+     * Sorts the participant list by contact name.
+     */
+    private void sortParticipantList() {
+        Collections.sort(mConferenceParticipants, new Comparator<ParticipantInfo>() {
+            public int compare(ParticipantInfo p1, ParticipantInfo p2) {
+                // Contact names might be null, so replace with empty string.
+                ContactCacheEntry c1 = p1.getContactCacheEntry();
+                String p1Name = MoreObjects.firstNonNull(
+                        ContactDisplayUtils.getPreferredSortName(
+                                c1.namePrimary,
+                                c1.nameAlternative,
+                                mContactsPreferences),
+                        "");
+
+                ContactCacheEntry c2 = p2.getContactCacheEntry();
+                String p2Name = MoreObjects.firstNonNull(
+                        ContactDisplayUtils.getPreferredSortName(
+                                c2.namePrimary,
+                                c2.nameAlternative,
+                                mContactsPreferences),
+                        "");
+
+                return p1Name.compareToIgnoreCase(p2Name);
+            }
+        });
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/ContactInfoCache.java b/InCallUI/src/com/android/incallui/ContactInfoCache.java
new file mode 100644
index 0000000..ab4150b
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ContactInfoCache.java
@@ -0,0 +1,698 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.location.Address;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.Looper;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.DisplayNameSources;
+import android.telecom.TelecomManager;
+import android.text.TextUtils;
+import android.util.Pair;
+
+import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.util.PhoneNumberHelper;
+import com.android.dialer.calllog.ContactInfo;
+import com.android.dialer.service.CachedNumberLookupService;
+import com.android.dialer.service.CachedNumberLookupService.CachedContactInfo;
+import com.android.dialer.util.MoreStrings;
+import com.android.incallui.Call.LogState;
+import com.android.incallui.service.PhoneNumberService;
+import com.android.incalluibind.ObjectFactory;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Class responsible for querying Contact Information for Call objects. Can perform asynchronous
+ * requests to the Contact Provider for information as well as respond synchronously for any data
+ * that it currently has cached from previous queries. This class always gets called from the UI
+ * thread so it does not need thread protection.
+ */
+public class ContactInfoCache implements ContactsAsyncHelper.OnImageLoadCompleteListener {
+
+    private static final String TAG = ContactInfoCache.class.getSimpleName();
+    private static final int TOKEN_UPDATE_PHOTO_FOR_CALL_STATE = 0;
+
+    private final Context mContext;
+    private final PhoneNumberService mPhoneNumberService;
+    private final CachedNumberLookupService mCachedNumberLookupService;
+    private final HashMap<String, ContactCacheEntry> mInfoMap = Maps.newHashMap();
+    private final HashMap<String, Set<ContactInfoCacheCallback>> mCallBacks = Maps.newHashMap();
+
+    private static ContactInfoCache sCache = null;
+
+    private Drawable mDefaultContactPhotoDrawable;
+    private Drawable mConferencePhotoDrawable;
+    private ContactUtils mContactUtils;
+
+    public static synchronized ContactInfoCache getInstance(Context mContext) {
+        if (sCache == null) {
+            sCache = new ContactInfoCache(mContext.getApplicationContext());
+        }
+        return sCache;
+    }
+
+    private ContactInfoCache(Context context) {
+        mContext = context;
+        mPhoneNumberService = ObjectFactory.newPhoneNumberService(context);
+        mCachedNumberLookupService =
+                com.android.dialerbind.ObjectFactory.newCachedNumberLookupService();
+        mContactUtils = ObjectFactory.getContactUtilsInstance(context);
+
+    }
+
+    public ContactCacheEntry getInfo(String callId) {
+        return mInfoMap.get(callId);
+    }
+
+    public static ContactCacheEntry buildCacheEntryFromCall(Context context, Call call,
+            boolean isIncoming) {
+        final ContactCacheEntry entry = new ContactCacheEntry();
+
+        // TODO: get rid of caller info.
+        final CallerInfo info = CallerInfoUtils.buildCallerInfo(context, call);
+        ContactInfoCache.populateCacheEntry(context, info, entry, call.getNumberPresentation(),
+                isIncoming);
+        return entry;
+    }
+
+    public void maybeInsertCnapInformationIntoCache(Context context, final Call call,
+            final CallerInfo info) {
+        if (mCachedNumberLookupService == null || TextUtils.isEmpty(info.cnapName)
+                || mInfoMap.get(call.getId()) != null) {
+            return;
+        }
+        final Context applicationContext = context.getApplicationContext();
+        Log.i(TAG, "Found contact with CNAP name - inserting into cache");
+        new AsyncTask<Void, Void, Void>() {
+            @Override
+            protected Void doInBackground(Void... params) {
+                ContactInfo contactInfo = new ContactInfo();
+                CachedContactInfo cacheInfo = mCachedNumberLookupService.buildCachedContactInfo(
+                        contactInfo);
+                cacheInfo.setSource(CachedContactInfo.SOURCE_TYPE_CNAP, "CNAP", 0);
+                contactInfo.name = info.cnapName;
+                contactInfo.number = call.getNumber();
+                contactInfo.type = ContactsContract.CommonDataKinds.Phone.TYPE_MAIN;
+                try {
+                    final JSONObject contactRows = new JSONObject().put(Phone.CONTENT_ITEM_TYPE,
+                            new JSONObject()
+                                    .put(Phone.NUMBER, contactInfo.number)
+                                    .put(Phone.TYPE, Phone.TYPE_MAIN));
+                    final String jsonString = new JSONObject()
+                            .put(Contacts.DISPLAY_NAME, contactInfo.name)
+                            .put(Contacts.DISPLAY_NAME_SOURCE, DisplayNameSources.STRUCTURED_NAME)
+                            .put(Contacts.CONTENT_ITEM_TYPE, contactRows).toString();
+                    cacheInfo.setLookupKey(jsonString);
+                } catch (JSONException e) {
+                    Log.w(TAG, "Creation of lookup key failed when caching CNAP information");
+                }
+                mCachedNumberLookupService.addContact(applicationContext, cacheInfo);
+                return null;
+            }
+        }.execute();
+    }
+
+    private class FindInfoCallback implements CallerInfoAsyncQuery.OnQueryCompleteListener {
+        private final boolean mIsIncoming;
+
+        public FindInfoCallback(boolean isIncoming) {
+            mIsIncoming = isIncoming;
+        }
+
+        @Override
+        public void onQueryComplete(int token, Object cookie, CallerInfo callerInfo) {
+            findInfoQueryComplete((Call) cookie, callerInfo, mIsIncoming, true);
+        }
+    }
+
+    /**
+     * Requests contact data for the Call object passed in.
+     * Returns the data through callback.  If callback is null, no response is made, however the
+     * query is still performed and cached.
+     *
+     * @param callback The function to call back when the call is found. Can be null.
+     */
+    public void findInfo(final Call call, final boolean isIncoming,
+            ContactInfoCacheCallback callback) {
+        Preconditions.checkState(Looper.getMainLooper().getThread() == Thread.currentThread());
+        Preconditions.checkNotNull(callback);
+
+        final String callId = call.getId();
+        final ContactCacheEntry cacheEntry = mInfoMap.get(callId);
+        Set<ContactInfoCacheCallback> callBacks = mCallBacks.get(callId);
+
+        // If we have a previously obtained intermediate result return that now
+        if (cacheEntry != null) {
+            Log.d(TAG, "Contact lookup. In memory cache hit; lookup "
+                    + (callBacks == null ? "complete" : "still running"));
+            callback.onContactInfoComplete(callId, cacheEntry);
+            // If no other callbacks are in flight, we're done.
+            if (callBacks == null) {
+                return;
+            }
+        }
+
+        // If the entry already exists, add callback
+        if (callBacks != null) {
+            callBacks.add(callback);
+            return;
+        }
+        Log.d(TAG, "Contact lookup. In memory cache miss; searching provider.");
+        // New lookup
+        callBacks = Sets.newHashSet();
+        callBacks.add(callback);
+        mCallBacks.put(callId, callBacks);
+
+        /**
+         * Performs a query for caller information.
+         * Save any immediate data we get from the query. An asynchronous query may also be made
+         * for any data that we do not already have. Some queries, such as those for voicemail and
+         * emergency call information, will not perform an additional asynchronous query.
+         */
+        final CallerInfo callerInfo = CallerInfoUtils.getCallerInfoForCall(
+                mContext, call, new FindInfoCallback(isIncoming));
+
+        findInfoQueryComplete(call, callerInfo, isIncoming, false);
+    }
+
+    private void findInfoQueryComplete(Call call, CallerInfo callerInfo, boolean isIncoming,
+            boolean didLocalLookup) {
+        final String callId = call.getId();
+        int presentationMode = call.getNumberPresentation();
+        if (callerInfo.contactExists || callerInfo.isEmergencyNumber() ||
+                callerInfo.isVoiceMailNumber()) {
+            presentationMode = TelecomManager.PRESENTATION_ALLOWED;
+        }
+
+        ContactCacheEntry cacheEntry = mInfoMap.get(callId);
+        // Ensure we always have a cacheEntry. Replace the existing entry if
+        // it has no name or if we found a local contact.
+        if (cacheEntry == null || TextUtils.isEmpty(cacheEntry.namePrimary) ||
+                callerInfo.contactExists) {
+            cacheEntry = buildEntry(mContext, callId, callerInfo, presentationMode, isIncoming);
+            mInfoMap.put(callId, cacheEntry);
+        }
+
+        sendInfoNotifications(callId, cacheEntry);
+
+        if (didLocalLookup) {
+            // Before issuing a request for more data from other services, we only check that the
+            // contact wasn't found in the local DB.  We don't check the if the cache entry already
+            // has a name because we allow overriding cnap data with data from other services.
+            if (!callerInfo.contactExists && mPhoneNumberService != null) {
+                Log.d(TAG, "Contact lookup. Local contacts miss, checking remote");
+                final PhoneNumberServiceListener listener = new PhoneNumberServiceListener(callId);
+                mPhoneNumberService.getPhoneNumberInfo(cacheEntry.number, listener, listener,
+                        isIncoming);
+            } else if (cacheEntry.displayPhotoUri != null) {
+                Log.d(TAG, "Contact lookup. Local contact found, starting image load");
+                // Load the image with a callback to update the image state.
+                // When the load is finished, onImageLoadComplete() will be called.
+                cacheEntry.isLoadingPhoto = true;
+                ContactsAsyncHelper.startObtainPhotoAsync(TOKEN_UPDATE_PHOTO_FOR_CALL_STATE,
+                        mContext, cacheEntry.displayPhotoUri, ContactInfoCache.this, callId);
+            } else {
+                if (callerInfo.contactExists) {
+                    Log.d(TAG, "Contact lookup done. Local contact found, no image.");
+                } else {
+                    Log.d(TAG, "Contact lookup done. Local contact not found and"
+                            + " no remote lookup service available.");
+                }
+                clearCallbacks(callId);
+            }
+        }
+    }
+
+    class PhoneNumberServiceListener implements PhoneNumberService.NumberLookupListener,
+                                     PhoneNumberService.ImageLookupListener, ContactUtils.Listener {
+        private final String mCallId;
+
+        PhoneNumberServiceListener(String callId) {
+            mCallId = callId;
+        }
+
+        @Override
+        public void onPhoneNumberInfoComplete(
+                final PhoneNumberService.PhoneNumberInfo info) {
+            // If we got a miss, this is the end of the lookup pipeline,
+            // so clear the callbacks and return.
+            if (info == null) {
+                Log.d(TAG, "Contact lookup done. Remote contact not found.");
+                clearCallbacks(mCallId);
+                return;
+            }
+
+            ContactCacheEntry entry = new ContactCacheEntry();
+            entry.namePrimary = info.getDisplayName();
+            entry.number = info.getNumber();
+            entry.contactLookupResult = info.getLookupSource();
+            final int type = info.getPhoneType();
+            final String label = info.getPhoneLabel();
+            if (type == Phone.TYPE_CUSTOM) {
+                entry.label = label;
+            } else {
+                final CharSequence typeStr = Phone.getTypeLabel(
+                        mContext.getResources(), type, label);
+                entry.label = typeStr == null ? null : typeStr.toString();
+            }
+            final ContactCacheEntry oldEntry = mInfoMap.get(mCallId);
+            if (oldEntry != null) {
+                // Location is only obtained from local lookup so persist
+                // the value for remote lookups. Once we have a name this
+                // field is no longer used; it is persisted here in case
+                // the UI is ever changed to use it.
+                entry.location = oldEntry.location;
+                // Contact specific ringtone is obtained from local lookup.
+                entry.contactRingtoneUri = oldEntry.contactRingtoneUri;
+            }
+
+            // If no image and it's a business, switch to using the default business avatar.
+            if (info.getImageUrl() == null && info.isBusiness()) {
+                Log.d(TAG, "Business has no image. Using default.");
+                entry.photo = mContext.getResources().getDrawable(R.drawable.img_business);
+            }
+
+            mInfoMap.put(mCallId, entry);
+            sendInfoNotifications(mCallId, entry);
+
+            if (mContactUtils != null) {
+                // This method will callback "onContactInteractionsFound".
+                entry.isLoadingContactInteractions =
+                        mContactUtils.retrieveContactInteractionsFromLookupKey(
+                                info.getLookupKey(), this);
+            }
+
+            entry.isLoadingPhoto = info.getImageUrl() != null;
+
+            // If there is no image or contact interactions then we should not expect another
+            // callback.
+            if (!entry.isLoadingPhoto && !entry.isLoadingContactInteractions) {
+                // We're done, so clear callbacks
+                clearCallbacks(mCallId);
+            }
+        }
+
+        @Override
+        public void onImageFetchComplete(Bitmap bitmap) {
+            onImageLoadComplete(TOKEN_UPDATE_PHOTO_FOR_CALL_STATE, null, bitmap, mCallId);
+        }
+
+        @Override
+        public void onContactInteractionsFound(Address address,
+                List<Pair<Calendar, Calendar>> openingHours) {
+            final ContactCacheEntry entry = mInfoMap.get(mCallId);
+            if (entry == null) {
+                Log.e(this, "Contact context received for empty search entry.");
+                clearCallbacks(mCallId);
+                return;
+            }
+
+            entry.isLoadingContactInteractions = false;
+
+            Log.v(ContactInfoCache.this, "Setting contact interactions for entry: ", entry);
+
+            entry.locationAddress = address;
+            entry.openingHours = openingHours;
+            sendContactInteractionsNotifications(mCallId, entry);
+
+            if (!entry.isLoadingPhoto) {
+                clearCallbacks(mCallId);
+            }
+        }
+    }
+
+    /**
+     * Implemented for ContactsAsyncHelper.OnImageLoadCompleteListener interface.
+     * make sure that the call state is reflected after the image is loaded.
+     */
+    @Override
+    public void onImageLoadComplete(int token, Drawable photo, Bitmap photoIcon, Object cookie) {
+        Log.d(this, "Image load complete with context: ", mContext);
+        // TODO: may be nice to update the image view again once the newer one
+        // is available on contacts database.
+
+        final String callId = (String) cookie;
+        final ContactCacheEntry entry = mInfoMap.get(callId);
+
+        if (entry == null) {
+            Log.e(this, "Image Load received for empty search entry.");
+            clearCallbacks(callId);
+            return;
+        }
+
+        entry.isLoadingPhoto = false;
+
+        Log.d(this, "setting photo for entry: ", entry);
+
+        // Conference call icons are being handled in CallCardPresenter.
+        if (photo != null) {
+            Log.v(this, "direct drawable: ", photo);
+            entry.photo = photo;
+        } else if (photoIcon != null) {
+            Log.v(this, "photo icon: ", photoIcon);
+            entry.photo = new BitmapDrawable(mContext.getResources(), photoIcon);
+        } else {
+            Log.v(this, "unknown photo");
+            entry.photo = null;
+        }
+
+        sendImageNotifications(callId, entry);
+
+        if (!entry.isLoadingContactInteractions) {
+            clearCallbacks(callId);
+        }
+    }
+
+    /**
+     * Blows away the stored cache values.
+     */
+    public void clearCache() {
+        mInfoMap.clear();
+        mCallBacks.clear();
+    }
+
+    private ContactCacheEntry buildEntry(Context context, String callId,
+            CallerInfo info, int presentation, boolean isIncoming) {
+        // The actual strings we're going to display onscreen:
+        Drawable photo = null;
+
+        final ContactCacheEntry cce = new ContactCacheEntry();
+        populateCacheEntry(context, info, cce, presentation, isIncoming);
+
+        // This will only be true for emergency numbers
+        if (info.photoResource != 0) {
+            photo = context.getResources().getDrawable(info.photoResource);
+        } else if (info.isCachedPhotoCurrent) {
+            if (info.cachedPhoto != null) {
+                photo = info.cachedPhoto;
+            } else {
+                photo = getDefaultContactPhotoDrawable();
+            }
+        } else if (info.contactDisplayPhotoUri == null) {
+            photo = getDefaultContactPhotoDrawable();
+        } else {
+            cce.displayPhotoUri = info.contactDisplayPhotoUri;
+        }
+
+        // Support any contact id in N because QuickContacts in N starts supporting enterprise
+        // contact id
+        if (info.lookupKeyOrNull != null
+                && (ContactsUtils.FLAG_N_FEATURE || info.contactIdOrZero != 0)) {
+            cce.lookupUri = Contacts.getLookupUri(info.contactIdOrZero, info.lookupKeyOrNull);
+        } else {
+            Log.v(TAG, "lookup key is null or contact ID is 0 on M. Don't create a lookup uri.");
+            cce.lookupUri = null;
+        }
+
+        cce.photo = photo;
+        cce.lookupKey = info.lookupKeyOrNull;
+        cce.contactRingtoneUri = info.contactRingtoneUri;
+        if (cce.contactRingtoneUri == null || cce.contactRingtoneUri == Uri.EMPTY) {
+            cce.contactRingtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE);
+        }
+
+        return cce;
+    }
+
+    /**
+     * Populate a cache entry from a call (which got converted into a caller info).
+     */
+    public static void populateCacheEntry(Context context, CallerInfo info, ContactCacheEntry cce,
+            int presentation, boolean isIncoming) {
+        Preconditions.checkNotNull(info);
+        String displayName = null;
+        String displayNumber = null;
+        String displayLocation = null;
+        String label = null;
+        boolean isSipCall = false;
+
+            // It appears that there is a small change in behaviour with the
+            // PhoneUtils' startGetCallerInfo whereby if we query with an
+            // empty number, we will get a valid CallerInfo object, but with
+            // fields that are all null, and the isTemporary boolean input
+            // parameter as true.
+
+            // In the past, we would see a NULL callerinfo object, but this
+            // ends up causing null pointer exceptions elsewhere down the
+            // line in other cases, so we need to make this fix instead. It
+            // appears that this was the ONLY call to PhoneUtils
+            // .getCallerInfo() that relied on a NULL CallerInfo to indicate
+            // an unknown contact.
+
+            // Currently, infi.phoneNumber may actually be a SIP address, and
+            // if so, it might sometimes include the "sip:" prefix. That
+            // prefix isn't really useful to the user, though, so strip it off
+            // if present. (For any other URI scheme, though, leave the
+            // prefix alone.)
+            // TODO: It would be cleaner for CallerInfo to explicitly support
+            // SIP addresses instead of overloading the "phoneNumber" field.
+            // Then we could remove this hack, and instead ask the CallerInfo
+            // for a "user visible" form of the SIP address.
+            String number = info.phoneNumber;
+
+            if (!TextUtils.isEmpty(number)) {
+                isSipCall = PhoneNumberHelper.isUriNumber(number);
+                if (number.startsWith("sip:")) {
+                    number = number.substring(4);
+                }
+            }
+
+            if (TextUtils.isEmpty(info.name)) {
+                // No valid "name" in the CallerInfo, so fall back to
+                // something else.
+                // (Typically, we promote the phone number up to the "name" slot
+                // onscreen, and possibly display a descriptive string in the
+                // "number" slot.)
+                if (TextUtils.isEmpty(number)) {
+                    // No name *or* number! Display a generic "unknown" string
+                    // (or potentially some other default based on the presentation.)
+                    displayName = getPresentationString(context, presentation, info.callSubject);
+                    Log.d(TAG, "  ==> no name *or* number! displayName = " + displayName);
+                } else if (presentation != TelecomManager.PRESENTATION_ALLOWED) {
+                    // This case should never happen since the network should never send a phone #
+                    // AND a restricted presentation. However we leave it here in case of weird
+                    // network behavior
+                    displayName = getPresentationString(context, presentation, info.callSubject);
+                    Log.d(TAG, "  ==> presentation not allowed! displayName = " + displayName);
+                } else if (!TextUtils.isEmpty(info.cnapName)) {
+                    // No name, but we do have a valid CNAP name, so use that.
+                    displayName = info.cnapName;
+                    info.name = info.cnapName;
+                    displayNumber = number;
+                    Log.d(TAG, "  ==> cnapName available: displayName '" + displayName +
+                            "', displayNumber '" + displayNumber + "'");
+                } else {
+                    // No name; all we have is a number. This is the typical
+                    // case when an incoming call doesn't match any contact,
+                    // or if you manually dial an outgoing number using the
+                    // dialpad.
+                    displayNumber = number;
+
+                    // Display a geographical description string if available
+                    // (but only for incoming calls.)
+                    if (isIncoming) {
+                        // TODO (CallerInfoAsyncQuery cleanup): Fix the CallerInfo
+                        // query to only do the geoDescription lookup in the first
+                        // place for incoming calls.
+                        displayLocation = info.geoDescription; // may be null
+                        Log.d(TAG, "Geodescrption: " + info.geoDescription);
+                    }
+
+                    Log.d(TAG, "  ==>  no name; falling back to number:"
+                            + " displayNumber '" + Log.pii(displayNumber)
+                            + "', displayLocation '" + displayLocation + "'");
+                }
+            } else {
+                // We do have a valid "name" in the CallerInfo. Display that
+                // in the "name" slot, and the phone number in the "number" slot.
+                if (presentation != TelecomManager.PRESENTATION_ALLOWED) {
+                    // This case should never happen since the network should never send a name
+                    // AND a restricted presentation. However we leave it here in case of weird
+                    // network behavior
+                    displayName = getPresentationString(context, presentation, info.callSubject);
+                    Log.d(TAG, "  ==> valid name, but presentation not allowed!" +
+                            " displayName = " + displayName);
+                } else {
+                    // Causes cce.namePrimary to be set as info.name below. CallCardPresenter will
+                    // later determine whether to use the name or nameAlternative when presenting
+                    displayName = info.name;
+                    cce.nameAlternative = info.nameAlternative;
+                    displayNumber = number;
+                    label = info.phoneLabel;
+                    Log.d(TAG, "  ==>  name is present in CallerInfo: displayName '" + displayName
+                            + "', displayNumber '" + displayNumber + "'");
+                }
+            }
+
+        cce.namePrimary = displayName;
+        cce.number = displayNumber;
+        cce.location = displayLocation;
+        cce.label = label;
+        cce.isSipCall = isSipCall;
+        cce.userType = info.userType;
+
+        if (info.contactExists) {
+            cce.contactLookupResult = LogState.LOOKUP_LOCAL_CONTACT;
+        }
+    }
+
+    /**
+     * Sends the updated information to call the callbacks for the entry.
+     */
+    private void sendInfoNotifications(String callId, ContactCacheEntry entry) {
+        final Set<ContactInfoCacheCallback> callBacks = mCallBacks.get(callId);
+        if (callBacks != null) {
+            for (ContactInfoCacheCallback callBack : callBacks) {
+                callBack.onContactInfoComplete(callId, entry);
+            }
+        }
+    }
+
+    private void sendImageNotifications(String callId, ContactCacheEntry entry) {
+        final Set<ContactInfoCacheCallback> callBacks = mCallBacks.get(callId);
+        if (callBacks != null && entry.photo != null) {
+            for (ContactInfoCacheCallback callBack : callBacks) {
+                callBack.onImageLoadComplete(callId, entry);
+            }
+        }
+    }
+
+    private void sendContactInteractionsNotifications(String callId, ContactCacheEntry entry) {
+        final Set<ContactInfoCacheCallback> callBacks = mCallBacks.get(callId);
+        if (callBacks != null) {
+            for (ContactInfoCacheCallback callBack : callBacks) {
+                callBack.onContactInteractionsInfoComplete(callId, entry);
+            }
+        }
+    }
+
+    private void clearCallbacks(String callId) {
+        mCallBacks.remove(callId);
+    }
+
+    /**
+     * Gets name strings based on some special presentation modes and the associated custom label.
+     */
+    private static String getPresentationString(Context context, int presentation,
+             String customLabel) {
+        String name = context.getString(R.string.unknown);
+        if (!TextUtils.isEmpty(customLabel) &&
+                ((presentation == TelecomManager.PRESENTATION_UNKNOWN) ||
+                 (presentation == TelecomManager.PRESENTATION_RESTRICTED))) {
+            name = customLabel;
+            return name;
+        } else {
+            if (presentation == TelecomManager.PRESENTATION_RESTRICTED) {
+                name = context.getString(R.string.private_num);
+            } else if (presentation == TelecomManager.PRESENTATION_PAYPHONE) {
+                name = context.getString(R.string.payphone);
+            }
+        }
+        return name;
+    }
+
+    public Drawable getDefaultContactPhotoDrawable() {
+        if (mDefaultContactPhotoDrawable == null) {
+            mDefaultContactPhotoDrawable =
+                    mContext.getResources().getDrawable(R.drawable.img_no_image_automirrored);
+        }
+        return mDefaultContactPhotoDrawable;
+    }
+
+    public Drawable getConferenceDrawable() {
+        if (mConferencePhotoDrawable == null) {
+            mConferencePhotoDrawable =
+                    mContext.getResources().getDrawable(R.drawable.img_conference_automirrored);
+        }
+        return mConferencePhotoDrawable;
+    }
+
+    /**
+     * Callback interface for the contact query.
+     */
+    public interface ContactInfoCacheCallback {
+        public void onContactInfoComplete(String callId, ContactCacheEntry entry);
+        public void onImageLoadComplete(String callId, ContactCacheEntry entry);
+        public void onContactInteractionsInfoComplete(String callId, ContactCacheEntry entry);
+    }
+
+    public static class ContactCacheEntry {
+        public String namePrimary;
+        public String nameAlternative;
+        public String number;
+        public String location;
+        public String label;
+        public Drawable photo;
+        public boolean isSipCall;
+        // Note in cache entry whether this is a pending async loading action to know whether to
+        // wait for its callback or not.
+        public boolean isLoadingPhoto;
+        public boolean isLoadingContactInteractions;
+        /** This will be used for the "view" notification. */
+        public Uri contactUri;
+        /** Either a display photo or a thumbnail URI. */
+        public Uri displayPhotoUri;
+        public Uri lookupUri; // Sent to NotificationMananger
+        public String lookupKey;
+        public Address locationAddress;
+        public List<Pair<Calendar, Calendar>> openingHours;
+        public int contactLookupResult = LogState.LOOKUP_NOT_FOUND;
+        public long userType = ContactsUtils.USER_TYPE_CURRENT;
+        public Uri contactRingtoneUri;
+
+        @Override
+        public String toString() {
+            return MoreObjects.toStringHelper(this)
+                    .add("name", MoreStrings.toSafeString(namePrimary))
+                    .add("nameAlternative", MoreStrings.toSafeString(nameAlternative))
+                    .add("number", MoreStrings.toSafeString(number))
+                    .add("location", MoreStrings.toSafeString(location))
+                    .add("label", label)
+                    .add("photo", photo)
+                    .add("isSipCall", isSipCall)
+                    .add("contactUri", contactUri)
+                    .add("displayPhotoUri", displayPhotoUri)
+                    .add("locationAddress", locationAddress)
+                    .add("openingHours", openingHours)
+                    .add("contactLookupResult", contactLookupResult)
+                    .add("userType", userType)
+                    .add("contactRingtoneUri", contactRingtoneUri)
+                    .toString();
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/ContactUtils.java b/InCallUI/src/com/android/incallui/ContactUtils.java
new file mode 100644
index 0000000..0750af7
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ContactUtils.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+package com.android.incallui;
+
+import android.content.Context;
+import android.location.Address;
+import android.util.Pair;
+
+import com.android.incalluibind.ObjectFactory;
+
+import java.util.Calendar;
+import java.util.List;
+
+/**
+ * Utility functions to help manipulate contact data.
+ */
+public abstract class ContactUtils {
+    protected Context mContext;
+
+    public static ContactUtils getInstance(Context context) {
+        return ObjectFactory.getContactUtilsInstance(context);
+    }
+
+    protected ContactUtils(Context context) {
+        mContext = context;
+    }
+
+    public interface Listener {
+        public void onContactInteractionsFound(Address address,
+                List<Pair<Calendar, Calendar>> openingHours);
+    }
+
+    public abstract boolean retrieveContactInteractionsFromLookupKey(String lookupKey,
+            Listener listener);
+}
diff --git a/InCallUI/src/com/android/incallui/ContactsAsyncHelper.java b/InCallUI/src/com/android/incallui/ContactsAsyncHelper.java
new file mode 100644
index 0000000..011eef2
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ContactsAsyncHelper.java
@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.app.Notification;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.res.AssetFileDescriptor;
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Message;
+import android.provider.ContactsContract.Contacts;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Helper class for loading contacts photo asynchronously.
+ */
+public class ContactsAsyncHelper {
+
+    /**
+     * Interface for a WorkerHandler result return.
+     */
+    public interface OnImageLoadCompleteListener {
+        /**
+         * Called when the image load is complete.
+         *
+         * @param token Integer passed in {@link ContactsAsyncHelper#startObtainPhotoAsync(int,
+         * Context, Uri, OnImageLoadCompleteListener, Object)}.
+         * @param photo Drawable object obtained by the async load.
+         * @param photoIcon Bitmap object obtained by the async load.
+         * @param cookie Object passed in {@link ContactsAsyncHelper#startObtainPhotoAsync(int,
+         * Context, Uri, OnImageLoadCompleteListener, Object)}. Can be null iff. the original
+         * cookie is null.
+         */
+        public void onImageLoadComplete(int token, Drawable photo, Bitmap photoIcon,
+                Object cookie);
+    }
+
+    // constants
+    private static final int EVENT_LOAD_IMAGE = 1;
+
+    private final Handler mResultHandler = new Handler() {
+        /** Called when loading is done. */
+        @Override
+        public void handleMessage(Message msg) {
+            WorkerArgs args = (WorkerArgs) msg.obj;
+            switch (msg.arg1) {
+                case EVENT_LOAD_IMAGE:
+                    if (args.listener != null) {
+                        Log.d(this, "Notifying listener: " + args.listener.toString() +
+                                " image: " + args.displayPhotoUri + " completed");
+                        args.listener.onImageLoadComplete(msg.what, args.photo, args.photoIcon,
+                                args.cookie);
+                    }
+                    break;
+                default:
+            }
+        }
+    };
+
+    /** Handler run on a worker thread to load photo asynchronously. */
+    private static Handler sThreadHandler;
+
+    /** For forcing the system to call its constructor */
+    @SuppressWarnings("unused")
+    private static ContactsAsyncHelper sInstance;
+
+    static {
+        sInstance = new ContactsAsyncHelper();
+    }
+
+    private static final class WorkerArgs {
+        public Context context;
+        public Uri displayPhotoUri;
+        public Drawable photo;
+        public Bitmap photoIcon;
+        public Object cookie;
+        public OnImageLoadCompleteListener listener;
+    }
+
+    /**
+     * Thread worker class that handles the task of opening the stream and loading
+     * the images.
+     */
+    private class WorkerHandler extends Handler {
+        public WorkerHandler(Looper looper) {
+            super(looper);
+        }
+
+        @Override
+        public void handleMessage(Message msg) {
+            WorkerArgs args = (WorkerArgs) msg.obj;
+
+            switch (msg.arg1) {
+                case EVENT_LOAD_IMAGE:
+                    InputStream inputStream = null;
+                    try {
+                        try {
+                            inputStream = args.context.getContentResolver()
+                                    .openInputStream(args.displayPhotoUri);
+                        } catch (Exception e) {
+                            Log.e(this, "Error opening photo input stream", e);
+                        }
+
+                        if (inputStream != null) {
+                            args.photo = Drawable.createFromStream(inputStream,
+                                    args.displayPhotoUri.toString());
+
+                            // This assumes Drawable coming from contact database is usually
+                            // BitmapDrawable and thus we can have (down)scaled version of it.
+                            args.photoIcon = getPhotoIconWhenAppropriate(args.context, args.photo);
+
+                            Log.d(ContactsAsyncHelper.this, "Loading image: " + msg.arg1 +
+                                    " token: " + msg.what + " image URI: " + args.displayPhotoUri);
+                        } else {
+                            args.photo = null;
+                            args.photoIcon = null;
+                            Log.d(ContactsAsyncHelper.this, "Problem with image: " + msg.arg1 +
+                                    " token: " + msg.what + " image URI: " + args.displayPhotoUri +
+                                    ", using default image.");
+                        }
+                    } finally {
+                        if (inputStream != null) {
+                            try {
+                                inputStream.close();
+                            } catch (IOException e) {
+                                Log.e(this, "Unable to close input stream.", e);
+                            }
+                        }
+                    }
+                    break;
+                default:
+            }
+
+            // send the reply to the enclosing class.
+            Message reply = ContactsAsyncHelper.this.mResultHandler.obtainMessage(msg.what);
+            reply.arg1 = msg.arg1;
+            reply.obj = msg.obj;
+            reply.sendToTarget();
+        }
+
+        /**
+         * Returns a Bitmap object suitable for {@link Notification}'s large icon. This might
+         * return null when the given Drawable isn't BitmapDrawable, or if the system fails to
+         * create a scaled Bitmap for the Drawable.
+         */
+        private Bitmap getPhotoIconWhenAppropriate(Context context, Drawable photo) {
+            if (!(photo instanceof BitmapDrawable)) {
+                return null;
+            }
+            int iconSize = context.getResources()
+                    .getDimensionPixelSize(R.dimen.notification_icon_size);
+            Bitmap orgBitmap = ((BitmapDrawable) photo).getBitmap();
+            int orgWidth = orgBitmap.getWidth();
+            int orgHeight = orgBitmap.getHeight();
+            int longerEdge = orgWidth > orgHeight ? orgWidth : orgHeight;
+            // We want downscaled one only when the original icon is too big.
+            if (longerEdge > iconSize) {
+                float ratio = ((float) longerEdge) / iconSize;
+                int newWidth = (int) (orgWidth / ratio);
+                int newHeight = (int) (orgHeight / ratio);
+                // If the longer edge is much longer than the shorter edge, the latter may
+                // become 0 which will cause a crash.
+                if (newWidth <= 0 || newHeight <= 0) {
+                    Log.w(this, "Photo icon's width or height become 0.");
+                    return null;
+                }
+
+                // It is sure ratio >= 1.0f in any case and thus the newly created Bitmap
+                // should be smaller than the original.
+                return Bitmap.createScaledBitmap(orgBitmap, newWidth, newHeight, true);
+            } else {
+                return orgBitmap;
+            }
+        }
+    }
+
+    /**
+     * Private constructor for static class
+     */
+    private ContactsAsyncHelper() {
+        HandlerThread thread = new HandlerThread("ContactsAsyncWorker");
+        thread.start();
+        sThreadHandler = new WorkerHandler(thread.getLooper());
+    }
+
+    /**
+     * Starts an asynchronous image load. After finishing the load,
+     * {@link OnImageLoadCompleteListener#onImageLoadComplete(int, Drawable, Bitmap, Object)}
+     * will be called.
+     *
+     * @param token Arbitrary integer which will be returned as the first argument of
+     * {@link OnImageLoadCompleteListener#onImageLoadComplete(int, Drawable, Bitmap, Object)}
+     * @param context Context object used to do the time-consuming operation.
+     * @param displayPhotoUri Uri to be used to fetch the photo
+     * @param listener Callback object which will be used when the asynchronous load is done.
+     * Can be null, which means only the asynchronous load is done while there's no way to
+     * obtain the loaded photos.
+     * @param cookie Arbitrary object the caller wants to remember, which will become the
+     * fourth argument of {@link OnImageLoadCompleteListener#onImageLoadComplete(int, Drawable,
+     * Bitmap, Object)}. Can be null, at which the callback will also has null for the argument.
+     */
+    public static final void startObtainPhotoAsync(int token, Context context, Uri displayPhotoUri,
+            OnImageLoadCompleteListener listener, Object cookie) {
+        // in case the source caller info is null, the URI will be null as well.
+        // just update using the placeholder image in this case.
+        if (displayPhotoUri == null) {
+            Log.wtf("startObjectPhotoAsync", "Uri is missing");
+            return;
+        }
+
+        // Added additional Cookie field in the callee to handle arguments
+        // sent to the callback function.
+
+        // setup arguments
+        WorkerArgs args = new WorkerArgs();
+        args.cookie = cookie;
+        args.context = context;
+        args.displayPhotoUri = displayPhotoUri;
+        args.listener = listener;
+
+        // setup message arguments
+        Message msg = sThreadHandler.obtainMessage(token);
+        msg.arg1 = EVENT_LOAD_IMAGE;
+        msg.obj = args;
+
+        Log.d("startObjectPhotoAsync", "Begin loading image: " + args.displayPhotoUri +
+                ", displaying default image for now.");
+
+        // notify the thread to begin working
+        sThreadHandler.sendMessage(msg);
+    }
+
+
+}
diff --git a/InCallUI/src/com/android/incallui/ContactsPreferencesFactory.java b/InCallUI/src/com/android/incallui/ContactsPreferencesFactory.java
new file mode 100644
index 0000000..a9cc93b
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ContactsPreferencesFactory.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.support.annotation.Nullable;
+import com.android.dialer.compat.UserManagerCompat;
+
+import com.android.contacts.common.preference.ContactsPreferences;
+import com.android.contacts.common.testing.NeededForTesting;
+
+/**
+ * Factory class for {@link ContactsPreferences}.
+ */
+public class ContactsPreferencesFactory {
+
+    private static boolean sUseTestInstance;
+    private static ContactsPreferences sTestInstance;
+
+    /**
+     * Creates a new {@link ContactsPreferences} object if possible.
+     *
+     * @param context the context to use when creating the ContactsPreferences.
+     * @return a new ContactsPreferences object or {@code null} if the user is locked.
+     */
+    @Nullable
+    public static ContactsPreferences newContactsPreferences(Context context) {
+        if (sUseTestInstance) {
+            return sTestInstance;
+        }
+        if (UserManagerCompat.isUserUnlocked(context)) {
+            return new ContactsPreferences(context);
+        }
+        return null;
+    }
+
+    /**
+     * Sets the instance to be returned by all calls to {@link #newContactsPreferences(Context)}.
+     *
+     * @param testInstance the instance to return.
+     */
+    @NeededForTesting
+    static void setTestInstance(ContactsPreferences testInstance) {
+        sUseTestInstance = true;
+        sTestInstance = testInstance;
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/DialpadFragment.java b/InCallUI/src/com/android/incallui/DialpadFragment.java
new file mode 100644
index 0000000..ab44cf2
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/DialpadFragment.java
@@ -0,0 +1,556 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.text.Editable;
+import android.text.method.DialerKeyListener;
+import android.util.AttributeSet;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityManager;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import com.android.contacts.common.compat.PhoneNumberUtilsCompat;
+import com.android.phone.common.dialpad.DialpadKeyButton;
+import com.android.phone.common.dialpad.DialpadView;
+
+import java.util.HashMap;
+
+/**
+ * Fragment for call control buttons
+ */
+public class DialpadFragment extends BaseFragment<DialpadPresenter, DialpadPresenter.DialpadUi>
+        implements DialpadPresenter.DialpadUi, View.OnTouchListener, View.OnKeyListener,
+        View.OnHoverListener, View.OnClickListener {
+
+    private static final int ACCESSIBILITY_DTMF_STOP_DELAY_MILLIS = 50;
+
+    private final int[] mButtonIds = new int[] {R.id.zero, R.id.one, R.id.two, R.id.three,
+            R.id.four, R.id.five, R.id.six, R.id.seven, R.id.eight, R.id.nine, R.id.star,
+            R.id.pound};
+
+    /**
+     * LinearLayout with getter and setter methods for the translationY property using floats,
+     * for animation purposes.
+     */
+    public static class DialpadSlidingLinearLayout extends LinearLayout {
+
+        public DialpadSlidingLinearLayout(Context context) {
+            super(context);
+        }
+
+        public DialpadSlidingLinearLayout(Context context, AttributeSet attrs) {
+            super(context, attrs);
+        }
+
+        public DialpadSlidingLinearLayout(Context context, AttributeSet attrs, int defStyle) {
+            super(context, attrs, defStyle);
+        }
+
+        public float getYFraction() {
+            final int height = getHeight();
+            if (height == 0) return 0;
+            return getTranslationY() / height;
+        }
+
+        public void setYFraction(float yFraction) {
+            setTranslationY(yFraction * getHeight());
+        }
+    }
+
+    private EditText mDtmfDialerField;
+
+    /** Hash Map to map a view id to a character*/
+    private static final HashMap<Integer, Character> mDisplayMap =
+        new HashMap<Integer, Character>();
+
+    private static final Handler sHandler = new Handler(Looper.getMainLooper());
+
+
+    /** Set up the static maps*/
+    static {
+        // Map the buttons to the display characters
+        mDisplayMap.put(R.id.one, '1');
+        mDisplayMap.put(R.id.two, '2');
+        mDisplayMap.put(R.id.three, '3');
+        mDisplayMap.put(R.id.four, '4');
+        mDisplayMap.put(R.id.five, '5');
+        mDisplayMap.put(R.id.six, '6');
+        mDisplayMap.put(R.id.seven, '7');
+        mDisplayMap.put(R.id.eight, '8');
+        mDisplayMap.put(R.id.nine, '9');
+        mDisplayMap.put(R.id.zero, '0');
+        mDisplayMap.put(R.id.pound, '#');
+        mDisplayMap.put(R.id.star, '*');
+    }
+
+    // KeyListener used with the "dialpad digits" EditText widget.
+    private DTMFKeyListener mDialerKeyListener;
+
+    private DialpadView mDialpadView;
+
+    private int mCurrentTextColor;
+
+    /**
+     * Our own key listener, specialized for dealing with DTMF codes.
+     *   1. Ignore the backspace since it is irrelevant.
+     *   2. Allow ONLY valid DTMF characters to generate a tone and be
+     *      sent as a DTMF code.
+     *   3. All other remaining characters are handled by the superclass.
+     *
+     * This code is purely here to handle events from the hardware keyboard
+     * while the DTMF dialpad is up.
+     */
+    private class DTMFKeyListener extends DialerKeyListener {
+
+        private DTMFKeyListener() {
+            super();
+        }
+
+        /**
+         * Overriden to return correct DTMF-dialable characters.
+         */
+        @Override
+        protected char[] getAcceptedChars(){
+            return DTMF_CHARACTERS;
+        }
+
+        /** special key listener ignores backspace. */
+        @Override
+        public boolean backspace(View view, Editable content, int keyCode,
+                KeyEvent event) {
+            return false;
+        }
+
+        /**
+         * Return true if the keyCode is an accepted modifier key for the
+         * dialer (ALT or SHIFT).
+         */
+        private boolean isAcceptableModifierKey(int keyCode) {
+            switch (keyCode) {
+                case KeyEvent.KEYCODE_ALT_LEFT:
+                case KeyEvent.KEYCODE_ALT_RIGHT:
+                case KeyEvent.KEYCODE_SHIFT_LEFT:
+                case KeyEvent.KEYCODE_SHIFT_RIGHT:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        /**
+         * Overriden so that with each valid button press, we start sending
+         * a dtmf code and play a local dtmf tone.
+         */
+        @Override
+        public boolean onKeyDown(View view, Editable content,
+                                 int keyCode, KeyEvent event) {
+            // if (DBG) log("DTMFKeyListener.onKeyDown, keyCode " + keyCode + ", view " + view);
+
+            // find the character
+            char c = (char) lookup(event, content);
+
+            // if not a long press, and parent onKeyDown accepts the input
+            if (event.getRepeatCount() == 0 && super.onKeyDown(view, content, keyCode, event)) {
+
+                boolean keyOK = ok(getAcceptedChars(), c);
+
+                // if the character is a valid dtmf code, start playing the tone and send the
+                // code.
+                if (keyOK) {
+                    Log.d(this, "DTMFKeyListener reading '" + c + "' from input.");
+                    getPresenter().processDtmf(c);
+                } else {
+                    Log.d(this, "DTMFKeyListener rejecting '" + c + "' from input.");
+                }
+                return true;
+            }
+            return false;
+        }
+
+        /**
+         * Overriden so that with each valid button up, we stop sending
+         * a dtmf code and the dtmf tone.
+         */
+        @Override
+        public boolean onKeyUp(View view, Editable content,
+                                 int keyCode, KeyEvent event) {
+            // if (DBG) log("DTMFKeyListener.onKeyUp, keyCode " + keyCode + ", view " + view);
+
+            super.onKeyUp(view, content, keyCode, event);
+
+            // find the character
+            char c = (char) lookup(event, content);
+
+            boolean keyOK = ok(getAcceptedChars(), c);
+
+            if (keyOK) {
+                Log.d(this, "Stopping the tone for '" + c + "'");
+                getPresenter().stopDtmf();
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+         * Handle individual keydown events when we DO NOT have an Editable handy.
+         */
+        public boolean onKeyDown(KeyEvent event) {
+            char c = lookup(event);
+            Log.d(this, "DTMFKeyListener.onKeyDown: event '" + c + "'");
+
+            // if not a long press, and parent onKeyDown accepts the input
+            if (event.getRepeatCount() == 0 && c != 0) {
+                // if the character is a valid dtmf code, start playing the tone and send the
+                // code.
+                if (ok(getAcceptedChars(), c)) {
+                    Log.d(this, "DTMFKeyListener reading '" + c + "' from input.");
+                    getPresenter().processDtmf(c);
+                    return true;
+                } else {
+                    Log.d(this, "DTMFKeyListener rejecting '" + c + "' from input.");
+                }
+            }
+            return false;
+        }
+
+        /**
+         * Handle individual keyup events.
+         *
+         * @param event is the event we are trying to stop.  If this is null,
+         * then we just force-stop the last tone without checking if the event
+         * is an acceptable dialer event.
+         */
+        public boolean onKeyUp(KeyEvent event) {
+            if (event == null) {
+                //the below piece of code sends stopDTMF event unnecessarily even when a null event
+                //is received, hence commenting it.
+                /*if (DBG) log("Stopping the last played tone.");
+                stopTone();*/
+                return true;
+            }
+
+            char c = lookup(event);
+            Log.d(this, "DTMFKeyListener.onKeyUp: event '" + c + "'");
+
+            // TODO: stopTone does not take in character input, we may want to
+            // consider checking for this ourselves.
+            if (ok(getAcceptedChars(), c)) {
+                Log.d(this, "Stopping the tone for '" + c + "'");
+                getPresenter().stopDtmf();
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+         * Find the Dialer Key mapped to this event.
+         *
+         * @return The char value of the input event, otherwise
+         * 0 if no matching character was found.
+         */
+        private char lookup(KeyEvent event) {
+            // This code is similar to {@link DialerKeyListener#lookup(KeyEvent, Spannable) lookup}
+            int meta = event.getMetaState();
+            int number = event.getNumber();
+
+            if (!((meta & (KeyEvent.META_ALT_ON | KeyEvent.META_SHIFT_ON)) == 0) || (number == 0)) {
+                int match = event.getMatch(getAcceptedChars(), meta);
+                number = (match != 0) ? match : number;
+            }
+
+            return (char) number;
+        }
+
+        /**
+         * Check to see if the keyEvent is dialable.
+         */
+        boolean isKeyEventAcceptable (KeyEvent event) {
+            return (ok(getAcceptedChars(), lookup(event)));
+        }
+
+        /**
+         * Overrides the characters used in {@link DialerKeyListener#CHARACTERS}
+         * These are the valid dtmf characters.
+         */
+        public final char[] DTMF_CHARACTERS = new char[] {
+            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '#', '*'
+        };
+    }
+
+    @Override
+    public void onClick(View v) {
+        final AccessibilityManager accessibilityManager = (AccessibilityManager)
+            v.getContext().getSystemService(Context.ACCESSIBILITY_SERVICE);
+        // When accessibility is on, simulate press and release to preserve the
+        // semantic meaning of performClick(). Required for Braille support.
+        if (accessibilityManager.isEnabled()) {
+            final int id = v.getId();
+            // Checking the press state prevents double activation.
+            if (!v.isPressed() && mDisplayMap.containsKey(id)) {
+                getPresenter().processDtmf(mDisplayMap.get(id));
+                sHandler.postDelayed(new Runnable() {
+                    @Override
+                    public void run() {
+                        getPresenter().stopDtmf();
+                    }
+                }, ACCESSIBILITY_DTMF_STOP_DELAY_MILLIS);
+            }
+        }
+    }
+
+    @Override
+    public boolean onHover(View v, MotionEvent event) {
+        // When touch exploration is turned on, lifting a finger while inside
+        // the button's hover target bounds should perform a click action.
+        final AccessibilityManager accessibilityManager = (AccessibilityManager)
+            v.getContext().getSystemService(Context.ACCESSIBILITY_SERVICE);
+
+        if (accessibilityManager.isEnabled()
+                && accessibilityManager.isTouchExplorationEnabled()) {
+            final int left = v.getPaddingLeft();
+            final int right = (v.getWidth() - v.getPaddingRight());
+            final int top = v.getPaddingTop();
+            final int bottom = (v.getHeight() - v.getPaddingBottom());
+
+            switch (event.getActionMasked()) {
+                case MotionEvent.ACTION_HOVER_ENTER:
+                    // Lift-to-type temporarily disables double-tap activation.
+                    v.setClickable(false);
+                    break;
+                case MotionEvent.ACTION_HOVER_EXIT:
+                    final int x = (int) event.getX();
+                    final int y = (int) event.getY();
+                    if ((x > left) && (x < right) && (y > top) && (y < bottom)) {
+                        v.performClick();
+                    }
+                    v.setClickable(true);
+                    break;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean onKey(View v, int keyCode, KeyEvent event) {
+        Log.d(this, "onKey:  keyCode " + keyCode + ", view " + v);
+
+        if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER || keyCode == KeyEvent.KEYCODE_ENTER) {
+            int viewId = v.getId();
+            if (mDisplayMap.containsKey(viewId)) {
+                switch (event.getAction()) {
+                case KeyEvent.ACTION_DOWN:
+                    if (event.getRepeatCount() == 0) {
+                        getPresenter().processDtmf(mDisplayMap.get(viewId));
+                    }
+                    break;
+                case KeyEvent.ACTION_UP:
+                    getPresenter().stopDtmf();
+                    break;
+                }
+                // do not return true [handled] here, since we want the
+                // press / click animation to be handled by the framework.
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean onTouch(View v, MotionEvent event) {
+        Log.d(this, "onTouch");
+        int viewId = v.getId();
+
+        // if the button is recognized
+        if (mDisplayMap.containsKey(viewId)) {
+            switch (event.getAction()) {
+                case MotionEvent.ACTION_DOWN:
+                    // Append the character mapped to this button, to the display.
+                    // start the tone
+                    getPresenter().processDtmf(mDisplayMap.get(viewId));
+                    break;
+                case MotionEvent.ACTION_UP:
+                case MotionEvent.ACTION_CANCEL:
+                    // stop the tone on ANY other event, except for MOVE.
+                    getPresenter().stopDtmf();
+                    break;
+            }
+            // do not return true [handled] here, since we want the
+            // press / click animation to be handled by the framework.
+        }
+        return false;
+    }
+
+    // TODO(klp) Adds hardware keyboard listener
+
+    @Override
+    public DialpadPresenter createPresenter() {
+        return new DialpadPresenter();
+    }
+
+    @Override
+    public DialpadPresenter.DialpadUi getUi() {
+        return this;
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        final View parent = inflater.inflate(
+                R.layout.incall_dialpad_fragment, container, false);
+        mDialpadView = (DialpadView) parent.findViewById(R.id.dialpad_view);
+        mDialpadView.setCanDigitsBeEdited(false);
+        mDialpadView.setBackgroundResource(R.color.incall_dialpad_background);
+        mDtmfDialerField = (EditText) parent.findViewById(R.id.digits);
+        if (mDtmfDialerField != null) {
+            mDialerKeyListener = new DTMFKeyListener();
+            mDtmfDialerField.setKeyListener(mDialerKeyListener);
+            // remove the long-press context menus that support
+            // the edit (copy / paste / select) functions.
+            mDtmfDialerField.setLongClickable(false);
+            mDtmfDialerField.setElegantTextHeight(false);
+            configureKeypadListeners();
+        }
+
+        return parent;
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        updateColors();
+    }
+
+    public void updateColors() {
+        int textColor = InCallPresenter.getInstance().getThemeColors().mPrimaryColor;
+
+        if (mCurrentTextColor == textColor) {
+            return;
+        }
+
+        DialpadKeyButton dialpadKey;
+        for (int i = 0; i < mButtonIds.length; i++) {
+            dialpadKey = (DialpadKeyButton) mDialpadView.findViewById(mButtonIds[i]);
+            ((TextView) dialpadKey.findViewById(R.id.dialpad_key_number)).setTextColor(textColor);
+        }
+
+        mCurrentTextColor = textColor;
+    }
+
+    @Override
+    public void onDestroyView() {
+        mDialerKeyListener = null;
+        super.onDestroyView();
+    }
+
+    /**
+     * Getter for Dialpad text.
+     *
+     * @return String containing current Dialpad EditText text.
+     */
+    public String getDtmfText() {
+        return mDtmfDialerField.getText().toString();
+    }
+
+    /**
+     * Sets the Dialpad text field with some text.
+     *
+     * @param text Text to set Dialpad EditText to.
+     */
+    public void setDtmfText(String text) {
+        mDtmfDialerField.setText(PhoneNumberUtilsCompat.createTtsSpannable(text));
+    }
+
+    @Override
+    public void setVisible(boolean on) {
+        if (on) {
+            getView().setVisibility(View.VISIBLE);
+        } else {
+            getView().setVisibility(View.INVISIBLE);
+        }
+    }
+
+    /**
+     * Starts the slide up animation for the Dialpad keys when the Dialpad is revealed.
+     */
+    public void animateShowDialpad() {
+        final DialpadView dialpadView = (DialpadView) getView().findViewById(R.id.dialpad_view);
+        dialpadView.animateShow();
+    }
+
+    @Override
+    public void appendDigitsToField(char digit) {
+        if (mDtmfDialerField != null) {
+            // TODO: maybe *don't* manually append this digit if
+            // mDialpadDigits is focused and this key came from the HW
+            // keyboard, since in that case the EditText field will
+            // get the key event directly and automatically appends
+            // whetever the user types.
+            // (Or, a cleaner fix would be to just make mDialpadDigits
+            // *not* handle HW key presses.  That seems to be more
+            // complicated than just setting focusable="false" on it,
+            // though.)
+            mDtmfDialerField.getText().append(digit);
+        }
+    }
+
+    /**
+     * Called externally (from InCallScreen) to play a DTMF Tone.
+     */
+    /* package */ boolean onDialerKeyDown(KeyEvent event) {
+        Log.d(this, "Notifying dtmf key down.");
+        if (mDialerKeyListener != null) {
+            return mDialerKeyListener.onKeyDown(event);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Called externally (from InCallScreen) to cancel the last DTMF Tone played.
+     */
+    public boolean onDialerKeyUp(KeyEvent event) {
+        Log.d(this, "Notifying dtmf key up.");
+        if (mDialerKeyListener != null) {
+            return mDialerKeyListener.onKeyUp(event);
+        } else {
+            return false;
+        }
+    }
+
+    private void configureKeypadListeners() {
+        DialpadKeyButton dialpadKey;
+        for (int i = 0; i < mButtonIds.length; i++) {
+            dialpadKey = (DialpadKeyButton) mDialpadView.findViewById(mButtonIds[i]);
+            dialpadKey.setOnTouchListener(this);
+            dialpadKey.setOnKeyListener(this);
+            dialpadKey.setOnHoverListener(this);
+            dialpadKey.setOnClickListener(this);
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/DialpadPresenter.java b/InCallUI/src/com/android/incallui/DialpadPresenter.java
new file mode 100644
index 0000000..5e24bed
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/DialpadPresenter.java
@@ -0,0 +1,84 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.telephony.PhoneNumberUtils;
+
+/**
+ * Logic for call buttons.
+ */
+public class DialpadPresenter extends Presenter<DialpadPresenter.DialpadUi>
+        implements InCallPresenter.InCallStateListener {
+
+    private Call mCall;
+
+    @Override
+    public void onUiReady(DialpadUi ui) {
+        super.onUiReady(ui);
+        InCallPresenter.getInstance().addListener(this);
+        mCall = CallList.getInstance().getOutgoingOrActive();
+    }
+
+    @Override
+    public void onUiUnready(DialpadUi ui) {
+        super.onUiUnready(ui);
+        InCallPresenter.getInstance().removeListener(this);
+    }
+
+    @Override
+    public void onStateChange(InCallPresenter.InCallState oldState,
+            InCallPresenter.InCallState newState, CallList callList) {
+        mCall = callList.getOutgoingOrActive();
+        Log.d(this, "DialpadPresenter mCall = " + mCall);
+    }
+
+    /**
+     * Processes the specified digit as a DTMF key, by playing the
+     * appropriate DTMF tone, and appending the digit to the EditText
+     * field that displays the DTMF digits sent so far.
+     *
+     */
+    public final void processDtmf(char c) {
+        Log.d(this, "Processing dtmf key " + c);
+        // if it is a valid key, then update the display and send the dtmf tone.
+        if (PhoneNumberUtils.is12Key(c) && mCall != null) {
+            Log.d(this, "updating display and sending dtmf tone for '" + c + "'");
+
+            // Append this key to the "digits" widget.
+            getUi().appendDigitsToField(c);
+            // Plays the tone through Telecom.
+            TelecomAdapter.getInstance().playDtmfTone(mCall.getId(), c);
+        } else {
+            Log.d(this, "ignoring dtmf request for '" + c + "'");
+        }
+    }
+
+    /**
+     * Stops the local tone based on the phone type.
+     */
+    public void stopDtmf() {
+        if (mCall != null) {
+            Log.d(this, "stopping remote tone");
+            TelecomAdapter.getInstance().stopDtmfTone(mCall.getId());
+        }
+    }
+
+    public interface DialpadUi extends Ui {
+        void setVisible(boolean on);
+        void appendDigitsToField(char digit);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/DistanceHelper.java b/InCallUI/src/com/android/incallui/DistanceHelper.java
new file mode 100644
index 0000000..a4db5fe
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/DistanceHelper.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.incallui;
+
+import android.location.Address;
+
+/**
+ * Superclass for a helper class to get the current location and distance to other locations.
+ */
+public abstract class DistanceHelper {
+    public static final float DISTANCE_NOT_FOUND = -1;
+    public static final float MILES_PER_METER = (float) 0.000621371192;
+    public static final float KILOMETERS_PER_METER = (float) 0.001;
+
+    public interface Listener {
+        public void onLocationReady();
+    }
+
+    public void cleanUp() {}
+
+    public float calculateDistance(Address address) {
+        return DISTANCE_NOT_FOUND;
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/FragmentDisplayManager.java b/InCallUI/src/com/android/incallui/FragmentDisplayManager.java
new file mode 100644
index 0000000..045d999
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/FragmentDisplayManager.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.app.Fragment;
+
+interface FragmentDisplayManager {
+    public void onFragmentAttached(Fragment fragment);
+}
diff --git a/InCallUI/src/com/android/incallui/GlowPadAnswerFragment.java b/InCallUI/src/com/android/incallui/GlowPadAnswerFragment.java
new file mode 100644
index 0000000..62a8e78
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/GlowPadAnswerFragment.java
@@ -0,0 +1,155 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.os.Bundle;
+import android.telecom.VideoProfile;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.android.dialer.R;
+
+public class GlowPadAnswerFragment extends AnswerFragment {
+
+    private GlowPadWrapper mGlowpad;
+
+    public GlowPadAnswerFragment() {
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        mGlowpad = (GlowPadWrapper) inflater.inflate(R.layout.answer_fragment,
+                container, false);
+
+        Log.d(this, "Creating view for answer fragment ", this);
+        Log.d(this, "Created from activity", getActivity());
+        mGlowpad.setAnswerFragment(this);
+
+        return mGlowpad;
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        mGlowpad.requestFocus();
+    }
+
+    @Override
+    public void onDestroyView() {
+        Log.d(this, "onDestroyView");
+        if (mGlowpad != null) {
+            mGlowpad.stopPing();
+            mGlowpad = null;
+        }
+        super.onDestroyView();
+    }
+
+    @Override
+    public void onShowAnswerUi(boolean shown) {
+        Log.d(this, "Show answer UI: " + shown);
+        if (shown) {
+            mGlowpad.startPing();
+        } else {
+            mGlowpad.stopPing();
+        }
+    }
+
+    /**
+     * Sets targets on the glowpad according to target set identified by the parameter.
+     *
+     * @param targetSet Integer identifying the set of targets to use.
+     */
+    public void showTargets(int targetSet) {
+        showTargets(targetSet, VideoProfile.STATE_BIDIRECTIONAL);
+    }
+
+    /**
+     * Sets targets on the glowpad according to target set identified by the parameter.
+     *
+     * @param targetSet Integer identifying the set of targets to use.
+     */
+    @Override
+    public void showTargets(int targetSet, int videoState) {
+        final int targetResourceId;
+        final int targetDescriptionsResourceId;
+        final int directionDescriptionsResourceId;
+        final int handleDrawableResourceId;
+        mGlowpad.setVideoState(videoState);
+
+        switch (targetSet) {
+            case TARGET_SET_FOR_AUDIO_WITH_SMS:
+                targetResourceId = R.array.incoming_call_widget_audio_with_sms_targets;
+                targetDescriptionsResourceId =
+                        R.array.incoming_call_widget_audio_with_sms_target_descriptions;
+                directionDescriptionsResourceId =
+                        R.array.incoming_call_widget_audio_with_sms_direction_descriptions;
+                handleDrawableResourceId = R.drawable.ic_incall_audio_handle;
+                break;
+            case TARGET_SET_FOR_VIDEO_WITHOUT_SMS:
+                targetResourceId = R.array.incoming_call_widget_video_without_sms_targets;
+                targetDescriptionsResourceId =
+                        R.array.incoming_call_widget_video_without_sms_target_descriptions;
+                directionDescriptionsResourceId =
+                        R.array.incoming_call_widget_video_without_sms_direction_descriptions;
+                handleDrawableResourceId = R.drawable.ic_incall_video_handle;
+                break;
+            case TARGET_SET_FOR_VIDEO_WITH_SMS:
+                targetResourceId = R.array.incoming_call_widget_video_with_sms_targets;
+                targetDescriptionsResourceId =
+                        R.array.incoming_call_widget_video_with_sms_target_descriptions;
+                directionDescriptionsResourceId =
+                        R.array.incoming_call_widget_video_with_sms_direction_descriptions;
+                handleDrawableResourceId = R.drawable.ic_incall_video_handle;
+                break;
+            case TARGET_SET_FOR_VIDEO_ACCEPT_REJECT_REQUEST:
+                targetResourceId =
+                        R.array.incoming_call_widget_video_request_targets;
+                targetDescriptionsResourceId =
+                        R.array.incoming_call_widget_video_request_target_descriptions;
+                directionDescriptionsResourceId = R.array
+                        .incoming_call_widget_video_request_target_direction_descriptions;
+                handleDrawableResourceId = R.drawable.ic_incall_video_handle;
+                break;
+            case TARGET_SET_FOR_AUDIO_WITHOUT_SMS:
+            default:
+                targetResourceId = R.array.incoming_call_widget_audio_without_sms_targets;
+                targetDescriptionsResourceId =
+                        R.array.incoming_call_widget_audio_without_sms_target_descriptions;
+                directionDescriptionsResourceId =
+                        R.array.incoming_call_widget_audio_without_sms_direction_descriptions;
+                handleDrawableResourceId = R.drawable.ic_incall_audio_handle;
+                break;
+        }
+
+        if (targetResourceId != mGlowpad.getTargetResourceId()) {
+            mGlowpad.setTargetResources(targetResourceId);
+            mGlowpad.setTargetDescriptionsResourceId(targetDescriptionsResourceId);
+            mGlowpad.setDirectionDescriptionsResourceId(directionDescriptionsResourceId);
+            mGlowpad.setHandleDrawable(handleDrawableResourceId);
+            mGlowpad.reset(false);
+        }
+    }
+
+    @Override
+    protected void onMessageDialogCancel() {
+        if (mGlowpad != null) {
+            mGlowpad.startPing();
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/GlowPadWrapper.java b/InCallUI/src/com/android/incallui/GlowPadWrapper.java
new file mode 100644
index 0000000..1bd6d39
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/GlowPadWrapper.java
@@ -0,0 +1,164 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Message;
+import android.telecom.VideoProfile;
+import android.util.AttributeSet;
+import android.view.View;
+
+import com.android.incallui.widget.multiwaveview.GlowPadView;
+
+/**
+ *
+ */
+public class GlowPadWrapper extends GlowPadView implements GlowPadView.OnTriggerListener {
+
+    // Parameters for the GlowPadView "ping" animation; see triggerPing().
+    private static final int PING_MESSAGE_WHAT = 101;
+    private static final boolean ENABLE_PING_AUTO_REPEAT = true;
+    private static final long PING_REPEAT_DELAY_MS = 1200;
+
+    private final Handler mPingHandler = new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case PING_MESSAGE_WHAT:
+                    triggerPing();
+                    break;
+            }
+        }
+    };
+
+    private AnswerFragment mAnswerFragment;
+    private boolean mPingEnabled = true;
+    private boolean mTargetTriggered = false;
+    private int mVideoState = VideoProfile.STATE_BIDIRECTIONAL;
+
+    public GlowPadWrapper(Context context) {
+        super(context);
+        Log.d(this, "class created " + this + " ");
+    }
+
+    public GlowPadWrapper(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        Log.d(this, "class created " + this);
+    }
+
+    @Override
+    protected void onFinishInflate() {
+        Log.d(this, "onFinishInflate()");
+        super.onFinishInflate();
+        setOnTriggerListener(this);
+    }
+
+    public void startPing() {
+        Log.d(this, "startPing");
+        mPingEnabled = true;
+        triggerPing();
+    }
+
+    public void stopPing() {
+        Log.d(this, "stopPing");
+        mPingEnabled = false;
+        mPingHandler.removeMessages(PING_MESSAGE_WHAT);
+    }
+
+    private void triggerPing() {
+        Log.d(this, "triggerPing(): " + mPingEnabled + " " + this);
+        if (mPingEnabled && !mPingHandler.hasMessages(PING_MESSAGE_WHAT)) {
+            ping();
+
+            if (ENABLE_PING_AUTO_REPEAT) {
+                mPingHandler.sendEmptyMessageDelayed(PING_MESSAGE_WHAT, PING_REPEAT_DELAY_MS);
+            }
+        }
+    }
+
+    @Override
+    public void onGrabbed(View v, int handle) {
+        Log.d(this, "onGrabbed()");
+        stopPing();
+    }
+
+    @Override
+    public void onReleased(View v, int handle) {
+        Log.d(this, "onReleased()");
+        if (mTargetTriggered) {
+            mTargetTriggered = false;
+        } else {
+            startPing();
+        }
+    }
+
+    @Override
+    public void onTrigger(View v, int target) {
+        Log.d(this, "onTrigger() view=" + v + " target=" + target);
+        final int resId = getResourceIdForTarget(target);
+        switch (resId) {
+            case R.drawable.ic_lockscreen_answer:
+                mAnswerFragment.onAnswer(VideoProfile.STATE_AUDIO_ONLY, getContext());
+                mTargetTriggered = true;
+                break;
+            case R.drawable.ic_lockscreen_decline:
+                mAnswerFragment.onDecline(getContext());
+                mTargetTriggered = true;
+                break;
+            case R.drawable.ic_lockscreen_text:
+                mAnswerFragment.onText();
+                mTargetTriggered = true;
+                break;
+            case R.drawable.ic_videocam:
+            case R.drawable.ic_lockscreen_answer_video:
+                mAnswerFragment.onAnswer(mVideoState, getContext());
+                mTargetTriggered = true;
+                break;
+            case R.drawable.ic_lockscreen_decline_video:
+                mAnswerFragment.onDeclineUpgradeRequest(getContext());
+                mTargetTriggered = true;
+                break;
+            default:
+                // Code should never reach here.
+                Log.e(this, "Trigger detected on unhandled resource. Skipping.");
+        }
+    }
+
+    @Override
+    public void onGrabbedStateChange(View v, int handle) {
+
+    }
+
+    @Override
+    public void onFinishFinalAnimation() {
+
+    }
+
+    public void setAnswerFragment(AnswerFragment fragment) {
+        mAnswerFragment = fragment;
+    }
+
+    /**
+     * Sets the video state represented by the "video" icon on the glow pad.
+     *
+     * @param videoState The new video state.
+     */
+    public void setVideoState(int videoState) {
+        mVideoState = videoState;
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/InCallActivity.java b/InCallUI/src/com/android/incallui/InCallActivity.java
new file mode 100644
index 0000000..dff2747
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallActivity.java
@@ -0,0 +1,935 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.app.ActionBar;
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.AlertDialog;
+import android.app.DialogFragment;
+import android.app.Fragment;
+import android.app.FragmentManager;
+import android.app.FragmentTransaction;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnCancelListener;
+import android.content.DialogInterface.OnClickListener;
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.graphics.Point;
+import android.hardware.SensorManager;
+import android.os.Bundle;
+import android.os.Trace;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccountHandle;
+import android.text.TextUtils;
+import android.view.KeyEvent;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.OrientationEventListener;
+import android.view.Surface;
+import android.view.View;
+import android.view.View.OnTouchListener;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+
+import com.android.contacts.common.activity.TransactionSafeActivity;
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.contacts.common.interactions.TouchPointManager;
+import com.android.contacts.common.widget.SelectPhoneAccountDialogFragment;
+import com.android.contacts.common.widget.SelectPhoneAccountDialogFragment.SelectPhoneAccountListener;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.logging.ScreenEvent;
+import com.android.incallui.Call.State;
+import com.android.incallui.compat.telecom.DetailsCompat;
+import com.android.incallui.util.AccessibilityUtil;
+import com.android.phone.common.animation.AnimUtils;
+import com.android.phone.common.animation.AnimationListenerAdapter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Main activity that the user interacts with while in a live call.
+ */
+public class InCallActivity extends TransactionSafeActivity implements FragmentDisplayManager {
+
+    public static final String TAG = InCallActivity.class.getSimpleName();
+
+    public static final String SHOW_DIALPAD_EXTRA = "InCallActivity.show_dialpad";
+    public static final String DIALPAD_TEXT_EXTRA = "InCallActivity.dialpad_text";
+    public static final String NEW_OUTGOING_CALL_EXTRA = "InCallActivity.new_outgoing_call";
+
+    private static final String TAG_DIALPAD_FRAGMENT = "tag_dialpad_fragment";
+    private static final String TAG_CONFERENCE_FRAGMENT = "tag_conference_manager_fragment";
+    private static final String TAG_CALLCARD_FRAGMENT = "tag_callcard_fragment";
+    private static final String TAG_ANSWER_FRAGMENT = "tag_answer_fragment";
+    private static final String TAG_SELECT_ACCT_FRAGMENT = "tag_select_acct_fragment";
+
+    private static final int DIALPAD_REQUEST_NONE = 1;
+    private static final int DIALPAD_REQUEST_SHOW = 2;
+    private static final int DIALPAD_REQUEST_HIDE = 3;
+
+    private CallButtonFragment mCallButtonFragment;
+    private CallCardFragment mCallCardFragment;
+    private AnswerFragment mAnswerFragment;
+    private DialpadFragment mDialpadFragment;
+    private ConferenceManagerFragment mConferenceManagerFragment;
+    private FragmentManager mChildFragmentManager;
+
+    private AlertDialog mDialog;
+    private InCallOrientationEventListener mInCallOrientationEventListener;
+
+    /**
+     * Used to indicate whether the dialpad should be hidden or shown {@link #onResume}.
+     * {@code #DIALPAD_REQUEST_SHOW} indicates that the dialpad should be shown.
+     * {@code #DIALPAD_REQUEST_HIDE} indicates that the dialpad should be hidden.
+     * {@code #DIALPAD_REQUEST_NONE} indicates no change should be made to dialpad visibility.
+     */
+    private int mShowDialpadRequest = DIALPAD_REQUEST_NONE;
+
+    /**
+     * Use to determine if the dialpad should be animated on show.
+     */
+    private boolean mAnimateDialpadOnShow;
+
+    /**
+     * Use to determine the DTMF Text which should be pre-populated in the dialpad.
+     */
+    private String mDtmfText;
+
+    /**
+     * Use to pass parameters for showing the PostCharDialog to {@link #onResume}
+     */
+    private boolean mShowPostCharWaitDialogOnResume;
+    private String mShowPostCharWaitDialogCallId;
+    private String mShowPostCharWaitDialogChars;
+
+    private boolean mIsLandscape;
+    private Animation mSlideIn;
+    private Animation mSlideOut;
+    private boolean mDismissKeyguard = false;
+
+    AnimationListenerAdapter mSlideOutListener = new AnimationListenerAdapter() {
+        @Override
+        public void onAnimationEnd(Animation animation) {
+            showFragment(TAG_DIALPAD_FRAGMENT, false, true);
+        }
+    };
+
+    private OnTouchListener mDispatchTouchEventListener;
+
+    private SelectPhoneAccountListener mSelectAcctListener = new SelectPhoneAccountListener() {
+        @Override
+        public void onPhoneAccountSelected(PhoneAccountHandle selectedAccountHandle,
+                boolean setDefault) {
+            InCallPresenter.getInstance().handleAccountSelection(selectedAccountHandle,
+                    setDefault);
+        }
+
+        @Override
+        public void onDialogDismissed() {
+            InCallPresenter.getInstance().cancelAccountSelection();
+        }
+    };
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        Log.d(this, "onCreate()...  this = " + this);
+
+        super.onCreate(icicle);
+
+        // set this flag so this activity will stay in front of the keyguard
+        // Have the WindowManager filter out touch events that are "too fat".
+        int flags = WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
+                | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
+                | WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES;
+
+        getWindow().addFlags(flags);
+
+        // Setup action bar for the conference call manager.
+        requestWindowFeature(Window.FEATURE_ACTION_BAR_OVERLAY);
+        ActionBar actionBar = getActionBar();
+        if (actionBar != null) {
+            actionBar.setDisplayHomeAsUpEnabled(true);
+            actionBar.setDisplayShowTitleEnabled(true);
+            actionBar.hide();
+        }
+
+        // TODO(klp): Do we need to add this back when prox sensor is not available?
+        // lp.inputFeatures |= WindowManager.LayoutParams.INPUT_FEATURE_DISABLE_USER_ACTIVITY;
+
+        setContentView(R.layout.incall_screen);
+
+        internalResolveIntent(getIntent());
+
+        mIsLandscape = getResources().getConfiguration().orientation ==
+                Configuration.ORIENTATION_LANDSCAPE;
+
+        final boolean isRtl = TextUtils.getLayoutDirectionFromLocale(Locale.getDefault()) ==
+                View.LAYOUT_DIRECTION_RTL;
+
+        if (mIsLandscape) {
+            mSlideIn = AnimationUtils.loadAnimation(this,
+                    isRtl ? R.anim.dialpad_slide_in_left : R.anim.dialpad_slide_in_right);
+            mSlideOut = AnimationUtils.loadAnimation(this,
+                    isRtl ? R.anim.dialpad_slide_out_left : R.anim.dialpad_slide_out_right);
+        } else {
+            mSlideIn = AnimationUtils.loadAnimation(this, R.anim.dialpad_slide_in_bottom);
+            mSlideOut = AnimationUtils.loadAnimation(this, R.anim.dialpad_slide_out_bottom);
+        }
+
+        mSlideIn.setInterpolator(AnimUtils.EASE_IN);
+        mSlideOut.setInterpolator(AnimUtils.EASE_OUT);
+
+        mSlideOut.setAnimationListener(mSlideOutListener);
+
+        // If the dialpad fragment already exists, retrieve it.  This is important when rotating as
+        // we will not be able to hide or show the dialpad after the rotation otherwise.
+        Fragment existingFragment =
+                getFragmentManager().findFragmentByTag(DialpadFragment.class.getName());
+        if (existingFragment != null) {
+            mDialpadFragment = (DialpadFragment) existingFragment;
+        }
+
+        if (icicle != null) {
+            // If the dialpad was shown before, set variables indicating it should be shown and
+            // populated with the previous DTMF text.  The dialpad is actually shown and populated
+            // in onResume() to ensure the hosting CallCardFragment has been inflated and is ready
+            // to receive it.
+            if (icicle.containsKey(SHOW_DIALPAD_EXTRA)) {
+                boolean showDialpad = icicle.getBoolean(SHOW_DIALPAD_EXTRA);
+                mShowDialpadRequest = showDialpad ? DIALPAD_REQUEST_SHOW : DIALPAD_REQUEST_HIDE;
+                mAnimateDialpadOnShow = false;
+            }
+            mDtmfText = icicle.getString(DIALPAD_TEXT_EXTRA);
+
+            SelectPhoneAccountDialogFragment dialogFragment = (SelectPhoneAccountDialogFragment)
+                    getFragmentManager().findFragmentByTag(TAG_SELECT_ACCT_FRAGMENT);
+            if (dialogFragment != null) {
+                dialogFragment.setListener(mSelectAcctListener);
+            }
+        }
+        mInCallOrientationEventListener = new InCallOrientationEventListener(this);
+
+        Log.d(this, "onCreate(): exit");
+    }
+
+    @Override
+    protected void onSaveInstanceState(Bundle out) {
+        // TODO: The dialpad fragment should handle this as part of its own state
+        out.putBoolean(SHOW_DIALPAD_EXTRA,
+                mCallButtonFragment != null && mCallButtonFragment.isDialpadVisible());
+        if (mDialpadFragment != null) {
+            out.putString(DIALPAD_TEXT_EXTRA, mDialpadFragment.getDtmfText());
+        }
+        super.onSaveInstanceState(out);
+    }
+
+    @Override
+    protected void onStart() {
+        Log.d(this, "onStart()...");
+        super.onStart();
+
+        // setting activity should be last thing in setup process
+        InCallPresenter.getInstance().setActivity(this);
+        enableInCallOrientationEventListener(getRequestedOrientation() ==
+               InCallOrientationEventListener.FULL_SENSOR_SCREEN_ORIENTATION);
+
+        InCallPresenter.getInstance().onActivityStarted();
+    }
+
+    @Override
+    protected void onResume() {
+        Log.i(this, "onResume()...");
+        super.onResume();
+
+        InCallPresenter.getInstance().setThemeColors();
+        InCallPresenter.getInstance().onUiShowing(true);
+
+        // Clear fullscreen state onResume; the stored value may not match reality.
+        InCallPresenter.getInstance().clearFullscreen();
+
+        // If there is a pending request to show or hide the dialpad, handle that now.
+        if (mShowDialpadRequest != DIALPAD_REQUEST_NONE) {
+            if (mShowDialpadRequest == DIALPAD_REQUEST_SHOW) {
+                // Exit fullscreen so that the user has access to the dialpad hide/show button and
+                // can hide the dialpad.  Important when showing the dialpad from within dialer.
+                InCallPresenter.getInstance().setFullScreen(false, true /* force */);
+
+                mCallButtonFragment.displayDialpad(true /* show */,
+                        mAnimateDialpadOnShow /* animate */);
+                mAnimateDialpadOnShow = false;
+
+                if (mDialpadFragment != null) {
+                    mDialpadFragment.setDtmfText(mDtmfText);
+                    mDtmfText = null;
+                }
+            } else {
+                Log.v(this, "onResume : force hide dialpad");
+                if (mDialpadFragment != null) {
+                    mCallButtonFragment.displayDialpad(false /* show */, false /* animate */);
+                }
+            }
+            mShowDialpadRequest = DIALPAD_REQUEST_NONE;
+        }
+
+        if (mShowPostCharWaitDialogOnResume) {
+            showPostCharWaitDialog(mShowPostCharWaitDialogCallId, mShowPostCharWaitDialogChars);
+        }
+    }
+
+    // onPause is guaranteed to be called when the InCallActivity goes
+    // in the background.
+    @Override
+    protected void onPause() {
+        Log.d(this, "onPause()...");
+        if (mDialpadFragment != null) {
+            mDialpadFragment.onDialerKeyUp(null);
+        }
+
+        InCallPresenter.getInstance().onUiShowing(false);
+        if (isFinishing()) {
+            InCallPresenter.getInstance().unsetActivity(this);
+        }
+        super.onPause();
+    }
+
+    @Override
+    protected void onStop() {
+        Log.d(this, "onStop()...");
+        enableInCallOrientationEventListener(false);
+        InCallPresenter.getInstance().updateIsChangingConfigurations();
+        InCallPresenter.getInstance().onActivityStopped();
+        super.onStop();
+    }
+
+    @Override
+    protected void onDestroy() {
+        Log.d(this, "onDestroy()...  this = " + this);
+        InCallPresenter.getInstance().unsetActivity(this);
+        InCallPresenter.getInstance().updateIsChangingConfigurations();
+        super.onDestroy();
+    }
+
+    /**
+     * When fragments have a parent fragment, onAttachFragment is not called on the parent
+     * activity. To fix this, register our own callback instead that is always called for
+     * all fragments.
+     *
+     * @see {@link BaseFragment#onAttach(Activity)}
+     */
+    @Override
+    public void onFragmentAttached(Fragment fragment) {
+        if (fragment instanceof DialpadFragment) {
+            mDialpadFragment = (DialpadFragment) fragment;
+        } else if (fragment instanceof AnswerFragment) {
+            mAnswerFragment = (AnswerFragment) fragment;
+        } else if (fragment instanceof CallCardFragment) {
+            mCallCardFragment = (CallCardFragment) fragment;
+            mChildFragmentManager = mCallCardFragment.getChildFragmentManager();
+        } else if (fragment instanceof ConferenceManagerFragment) {
+            mConferenceManagerFragment = (ConferenceManagerFragment) fragment;
+        } else if (fragment instanceof CallButtonFragment) {
+            mCallButtonFragment = (CallButtonFragment) fragment;
+        }
+    }
+
+    /**
+     * Returns true when the Activity is currently visible.
+     */
+    /* package */ boolean isVisible() {
+        return isSafeToCommitTransactions();
+    }
+
+    private boolean hasPendingDialogs() {
+        return mDialog != null || (mAnswerFragment != null && mAnswerFragment.hasPendingDialogs());
+    }
+
+    @Override
+    public void finish() {
+        Log.i(this, "finish().  Dialog showing: " + (mDialog != null));
+
+        // skip finish if we are still showing a dialog.
+        if (!hasPendingDialogs()) {
+            super.finish();
+        }
+    }
+
+    @Override
+    protected void onNewIntent(Intent intent) {
+        Log.d(this, "onNewIntent: intent = " + intent);
+
+        // We're being re-launched with a new Intent.  Since it's possible for a
+        // single InCallActivity instance to persist indefinitely (even if we
+        // finish() ourselves), this sequence can potentially happen any time
+        // the InCallActivity needs to be displayed.
+
+        // Stash away the new intent so that we can get it in the future
+        // by calling getIntent().  (Otherwise getIntent() will return the
+        // original Intent from when we first got created!)
+        setIntent(intent);
+
+        // Activities are always paused before receiving a new intent, so
+        // we can count on our onResume() method being called next.
+
+        // Just like in onCreate(), handle the intent.
+        internalResolveIntent(intent);
+    }
+
+    @Override
+    public void onBackPressed() {
+        Log.i(this, "onBackPressed");
+
+        // BACK is also used to exit out of any "special modes" of the
+        // in-call UI:
+        if (!isVisible()) {
+            return;
+        }
+
+        if ((mConferenceManagerFragment == null || !mConferenceManagerFragment.isVisible())
+                && (mCallCardFragment == null || !mCallCardFragment.isVisible())) {
+            return;
+        }
+
+        if (mDialpadFragment != null && mDialpadFragment.isVisible()) {
+            mCallButtonFragment.displayDialpad(false /* show */, true /* animate */);
+            return;
+        } else if (mConferenceManagerFragment != null && mConferenceManagerFragment.isVisible()) {
+            showConferenceFragment(false);
+            return;
+        }
+
+        // Always disable the Back key while an incoming call is ringing
+        final Call call = CallList.getInstance().getIncomingCall();
+        if (call != null) {
+            Log.i(this, "Consume Back press for an incoming call");
+            return;
+        }
+
+        // Nothing special to do.  Fall back to the default behavior.
+        super.onBackPressed();
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        final int itemId = item.getItemId();
+        if (itemId == android.R.id.home) {
+            onBackPressed();
+            return true;
+        }
+        return super.onOptionsItemSelected(item);
+    }
+
+    @Override
+    public boolean onKeyUp(int keyCode, KeyEvent event) {
+        // push input to the dialer.
+        if (mDialpadFragment != null && (mDialpadFragment.isVisible()) &&
+                (mDialpadFragment.onDialerKeyUp(event))) {
+            return true;
+        } else if (keyCode == KeyEvent.KEYCODE_CALL) {
+            // Always consume CALL to be sure the PhoneWindow won't do anything with it
+            return true;
+        }
+        return super.onKeyUp(keyCode, event);
+    }
+
+    @Override
+    public boolean dispatchTouchEvent(MotionEvent ev) {
+        if (mDispatchTouchEventListener != null) {
+            boolean handled = mDispatchTouchEventListener.onTouch(null, ev);
+            if (handled) {
+                return true;
+            }
+        }
+        return super.dispatchTouchEvent(ev);
+    }
+
+    @Override
+    public boolean onKeyDown(int keyCode, KeyEvent event) {
+        switch (keyCode) {
+            case KeyEvent.KEYCODE_CALL:
+                boolean handled = InCallPresenter.getInstance().handleCallKey();
+                if (!handled) {
+                    Log.w(this, "InCallActivity should always handle KEYCODE_CALL in onKeyDown");
+                }
+                // Always consume CALL to be sure the PhoneWindow won't do anything with it
+                return true;
+
+            // Note there's no KeyEvent.KEYCODE_ENDCALL case here.
+            // The standard system-wide handling of the ENDCALL key
+            // (see PhoneWindowManager's handling of KEYCODE_ENDCALL)
+            // already implements exactly what the UI spec wants,
+            // namely (1) "hang up" if there's a current active call,
+            // or (2) "don't answer" if there's a current ringing call.
+
+            case KeyEvent.KEYCODE_CAMERA:
+                // Disable the CAMERA button while in-call since it's too
+                // easy to press accidentally.
+                return true;
+
+            case KeyEvent.KEYCODE_VOLUME_UP:
+            case KeyEvent.KEYCODE_VOLUME_DOWN:
+            case KeyEvent.KEYCODE_VOLUME_MUTE:
+                // Ringer silencing handled by PhoneWindowManager.
+                break;
+
+            case KeyEvent.KEYCODE_MUTE:
+                // toggle mute
+                TelecomAdapter.getInstance().mute(!AudioModeProvider.getInstance().getMute());
+                return true;
+
+            // Various testing/debugging features, enabled ONLY when VERBOSE == true.
+            case KeyEvent.KEYCODE_SLASH:
+                if (Log.VERBOSE) {
+                    Log.v(this, "----------- InCallActivity View dump --------------");
+                    // Dump starting from the top-level view of the entire activity:
+                    Window w = this.getWindow();
+                    View decorView = w.getDecorView();
+                    Log.d(this, "View dump:" + decorView);
+                    return true;
+                }
+                break;
+            case KeyEvent.KEYCODE_EQUALS:
+                // TODO: Dump phone state?
+                break;
+        }
+
+        if (event.getRepeatCount() == 0 && handleDialerKeyDown(keyCode, event)) {
+            return true;
+        }
+        return super.onKeyDown(keyCode, event);
+    }
+
+    private boolean handleDialerKeyDown(int keyCode, KeyEvent event) {
+        Log.v(this, "handleDialerKeyDown: keyCode " + keyCode + ", event " + event + "...");
+
+        // As soon as the user starts typing valid dialable keys on the
+        // keyboard (presumably to type DTMF tones) we start passing the
+        // key events to the DTMFDialer's onDialerKeyDown.
+        if (mDialpadFragment != null && mDialpadFragment.isVisible()) {
+            return mDialpadFragment.onDialerKeyDown(event);
+        }
+
+        return false;
+    }
+
+    public CallButtonFragment getCallButtonFragment() {
+        return mCallButtonFragment;
+    }
+
+    public CallCardFragment getCallCardFragment() {
+        return mCallCardFragment;
+    }
+
+    public AnswerFragment getAnswerFragment() {
+        return mAnswerFragment;
+    }
+
+    private void internalResolveIntent(Intent intent) {
+        final String action = intent.getAction();
+        if (action.equals(Intent.ACTION_MAIN)) {
+            // This action is the normal way to bring up the in-call UI.
+            //
+            // But we do check here for one extra that can come along with the
+            // ACTION_MAIN intent:
+
+            if (intent.hasExtra(SHOW_DIALPAD_EXTRA)) {
+                // SHOW_DIALPAD_EXTRA can be used here to specify whether the DTMF
+                // dialpad should be initially visible.  If the extra isn't
+                // present at all, we just leave the dialpad in its previous state.
+
+                final boolean showDialpad = intent.getBooleanExtra(SHOW_DIALPAD_EXTRA, false);
+                Log.d(this, "- internalResolveIntent: SHOW_DIALPAD_EXTRA: " + showDialpad);
+
+                relaunchedFromDialer(showDialpad);
+            }
+
+            boolean newOutgoingCall = false;
+            if (intent.getBooleanExtra(NEW_OUTGOING_CALL_EXTRA, false)) {
+                intent.removeExtra(NEW_OUTGOING_CALL_EXTRA);
+                Call call = CallList.getInstance().getOutgoingCall();
+                if (call == null) {
+                    call = CallList.getInstance().getPendingOutgoingCall();
+                }
+
+                Bundle extras = null;
+                if (call != null) {
+                    extras = DetailsCompat.getIntentExtras(call.getTelecomCall().getDetails());
+                }
+                if (extras == null) {
+                    // Initialize the extras bundle to avoid NPE
+                    extras = new Bundle();
+                }
+
+                Point touchPoint = null;
+                if (TouchPointManager.getInstance().hasValidPoint()) {
+                    // Use the most immediate touch point in the InCallUi if available
+                    touchPoint = TouchPointManager.getInstance().getPoint();
+                } else {
+                    // Otherwise retrieve the touch point from the call intent
+                    if (call != null) {
+                        touchPoint = (Point) extras.getParcelable(TouchPointManager.TOUCH_POINT);
+                    }
+                }
+
+                // Start animation for new outgoing call
+                CircularRevealFragment.startCircularReveal(getFragmentManager(), touchPoint,
+                        InCallPresenter.getInstance());
+
+                // InCallActivity is responsible for disconnecting a new outgoing call if there
+                // is no way of making it (i.e. no valid call capable accounts).
+                // If the version is not MSIM compatible, then ignore this code.
+                if (CompatUtils.isMSIMCompatible()
+                        && InCallPresenter.isCallWithNoValidAccounts(call)) {
+                    TelecomAdapter.getInstance().disconnectCall(call.getId());
+                }
+
+                dismissKeyguard(true);
+                newOutgoingCall = true;
+            }
+
+            Call pendingAccountSelectionCall = CallList.getInstance().getWaitingForAccountCall();
+            if (pendingAccountSelectionCall != null) {
+                showCallCardFragment(false);
+                Bundle extras = DetailsCompat.getIntentExtras(pendingAccountSelectionCall
+                        .getTelecomCall().getDetails());
+
+                final List<PhoneAccountHandle> phoneAccountHandles;
+                if (extras != null) {
+                    phoneAccountHandles = extras.getParcelableArrayList(
+                            android.telecom.Call.AVAILABLE_PHONE_ACCOUNTS);
+                } else {
+                    phoneAccountHandles = new ArrayList<>();
+                }
+
+                DialogFragment dialogFragment = SelectPhoneAccountDialogFragment.newInstance(
+                        R.string.select_phone_account_for_calls, true, phoneAccountHandles,
+                        mSelectAcctListener);
+                dialogFragment.show(getFragmentManager(), TAG_SELECT_ACCT_FRAGMENT);
+            } else if (!newOutgoingCall) {
+                showCallCardFragment(true);
+            }
+            return;
+        }
+    }
+
+    /**
+     * When relaunching from the dialer app, {@code showDialpad} indicates whether the dialpad
+     * should be shown on launch.
+     *
+     * @param showDialpad {@code true} to indicate the dialpad should be shown on launch, and
+     *                                {@code false} to indicate no change should be made to the
+     *                                dialpad visibility.
+     */
+    private void relaunchedFromDialer(boolean showDialpad) {
+        mShowDialpadRequest = showDialpad ? DIALPAD_REQUEST_SHOW : DIALPAD_REQUEST_NONE;
+        mAnimateDialpadOnShow = true;
+
+        if (mShowDialpadRequest == DIALPAD_REQUEST_SHOW) {
+            // If there's only one line in use, AND it's on hold, then we're sure the user
+            // wants to use the dialpad toward the exact line, so un-hold the holding line.
+            final Call call = CallList.getInstance().getActiveOrBackgroundCall();
+            if (call != null && call.getState() == State.ONHOLD) {
+                TelecomAdapter.getInstance().unholdCall(call.getId());
+            }
+        }
+    }
+
+    public void dismissKeyguard(boolean dismiss) {
+        if (mDismissKeyguard == dismiss) {
+            return;
+        }
+        mDismissKeyguard = dismiss;
+        if (dismiss) {
+            getWindow().addFlags(WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD);
+        } else {
+            getWindow().clearFlags(WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD);
+        }
+    }
+
+    private void showFragment(String tag, boolean show, boolean executeImmediately) {
+        Trace.beginSection("showFragment - " + tag);
+        final FragmentManager fm = getFragmentManagerForTag(tag);
+
+        if (fm == null) {
+            Log.w(TAG, "Fragment manager is null for : " + tag);
+            return;
+        }
+
+        Fragment fragment = fm.findFragmentByTag(tag);
+        if (!show && fragment == null) {
+            // Nothing to show, so bail early.
+            return;
+        }
+
+        final FragmentTransaction transaction = fm.beginTransaction();
+        if (show) {
+            if (fragment == null) {
+                fragment = createNewFragmentForTag(tag);
+                transaction.add(getContainerIdForFragment(tag), fragment, tag);
+            } else {
+                transaction.show(fragment);
+            }
+            Logger.logScreenView(getScreenTypeForTag(tag), this);
+        } else {
+            transaction.hide(fragment);
+        }
+
+        transaction.commitAllowingStateLoss();
+        if (executeImmediately) {
+            fm.executePendingTransactions();
+        }
+        Trace.endSection();
+    }
+
+    private Fragment createNewFragmentForTag(String tag) {
+        if (TAG_DIALPAD_FRAGMENT.equals(tag)) {
+            mDialpadFragment = new DialpadFragment();
+            return mDialpadFragment;
+        } else if (TAG_ANSWER_FRAGMENT.equals(tag)) {
+            if (AccessibilityUtil.isTalkBackEnabled(this)) {
+                mAnswerFragment = new AccessibleAnswerFragment();
+            } else {
+                mAnswerFragment = new GlowPadAnswerFragment();
+            }
+            return mAnswerFragment;
+        } else if (TAG_CONFERENCE_FRAGMENT.equals(tag)) {
+            mConferenceManagerFragment = new ConferenceManagerFragment();
+            return mConferenceManagerFragment;
+        } else if (TAG_CALLCARD_FRAGMENT.equals(tag)) {
+            mCallCardFragment = new CallCardFragment();
+            return mCallCardFragment;
+        }
+        throw new IllegalStateException("Unexpected fragment: " + tag);
+    }
+
+    private FragmentManager getFragmentManagerForTag(String tag) {
+        if (TAG_DIALPAD_FRAGMENT.equals(tag)) {
+            return mChildFragmentManager;
+        } else if (TAG_ANSWER_FRAGMENT.equals(tag)) {
+            return mChildFragmentManager;
+        } else if (TAG_CONFERENCE_FRAGMENT.equals(tag)) {
+            return getFragmentManager();
+        } else if (TAG_CALLCARD_FRAGMENT.equals(tag)) {
+            return getFragmentManager();
+        }
+        throw new IllegalStateException("Unexpected fragment: " + tag);
+    }
+
+    private int getScreenTypeForTag(String tag) {
+        switch (tag) {
+            case TAG_DIALPAD_FRAGMENT:
+                return ScreenEvent.INCALL_DIALPAD;
+            case TAG_CALLCARD_FRAGMENT:
+                return ScreenEvent.INCALL;
+            case TAG_CONFERENCE_FRAGMENT:
+                return ScreenEvent.CONFERENCE_MANAGEMENT;
+            case TAG_ANSWER_FRAGMENT:
+                return ScreenEvent.INCOMING_CALL;
+            default:
+                return ScreenEvent.UNKNOWN;
+        }
+    }
+
+    private int getContainerIdForFragment(String tag) {
+        if (TAG_DIALPAD_FRAGMENT.equals(tag)) {
+            return R.id.answer_and_dialpad_container;
+        } else if (TAG_ANSWER_FRAGMENT.equals(tag)) {
+            return R.id.answer_and_dialpad_container;
+        } else if (TAG_CONFERENCE_FRAGMENT.equals(tag)) {
+            return R.id.main;
+        } else if (TAG_CALLCARD_FRAGMENT.equals(tag)) {
+            return R.id.main;
+        }
+        throw new IllegalStateException("Unexpected fragment: " + tag);
+    }
+
+    /**
+     * @return {@code true} while the visibility of the dialpad has actually changed.
+     */
+    public boolean showDialpadFragment(boolean show, boolean animate) {
+        // If the dialpad is already visible, don't animate in. If it's gone, don't animate out.
+        if ((show && isDialpadVisible()) || (!show && !isDialpadVisible())) {
+            return false;
+        }
+        // We don't do a FragmentTransaction on the hide case because it will be dealt with when
+        // the listener is fired after an animation finishes.
+        if (!animate) {
+            showFragment(TAG_DIALPAD_FRAGMENT, show, true);
+        } else {
+            if (show) {
+                showFragment(TAG_DIALPAD_FRAGMENT, true, true);
+                mDialpadFragment.animateShowDialpad();
+            }
+            mCallCardFragment.onDialpadVisibilityChange(show);
+            mDialpadFragment.getView().startAnimation(show ? mSlideIn : mSlideOut);
+        }
+
+        final ProximitySensor sensor = InCallPresenter.getInstance().getProximitySensor();
+        if (sensor != null) {
+            sensor.onDialpadVisible(show);
+        }
+        return true;
+    }
+
+    public boolean isDialpadVisible() {
+        return mDialpadFragment != null && mDialpadFragment.isVisible();
+    }
+
+    public void showCallCardFragment(boolean show) {
+        showFragment(TAG_CALLCARD_FRAGMENT, show, true);
+    }
+
+    /**
+     * Hides or shows the conference manager fragment.
+     *
+     * @param show {@code true} if the conference manager should be shown, {@code false} if it
+     * should be hidden.
+     */
+    public void showConferenceFragment(boolean show) {
+        showFragment(TAG_CONFERENCE_FRAGMENT, show, true);
+        mConferenceManagerFragment.onVisibilityChanged(show);
+
+        // Need to hide the call card fragment to ensure that accessibility service does not try to
+        // give focus to the call card when the conference manager is visible.
+        mCallCardFragment.getView().setVisibility(show ? View.GONE : View.VISIBLE);
+    }
+
+    public void showAnswerFragment(boolean show) {
+        showFragment(TAG_ANSWER_FRAGMENT, show, true);
+    }
+
+    public void showPostCharWaitDialog(String callId, String chars) {
+        if (isVisible()) {
+            final PostCharDialogFragment fragment = new PostCharDialogFragment(callId, chars);
+            fragment.show(getFragmentManager(), "postCharWait");
+
+            mShowPostCharWaitDialogOnResume = false;
+            mShowPostCharWaitDialogCallId = null;
+            mShowPostCharWaitDialogChars = null;
+        } else {
+            mShowPostCharWaitDialogOnResume = true;
+            mShowPostCharWaitDialogCallId = callId;
+            mShowPostCharWaitDialogChars = chars;
+        }
+    }
+
+    @Override
+    public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
+        if (mCallCardFragment != null) {
+            mCallCardFragment.dispatchPopulateAccessibilityEvent(event);
+        }
+        return super.dispatchPopulateAccessibilityEvent(event);
+    }
+
+    public void maybeShowErrorDialogOnDisconnect(DisconnectCause disconnectCause) {
+        Log.d(this, "maybeShowErrorDialogOnDisconnect");
+
+        if (!isFinishing() && !TextUtils.isEmpty(disconnectCause.getDescription())
+                && (disconnectCause.getCode() == DisconnectCause.ERROR ||
+                disconnectCause.getCode() == DisconnectCause.RESTRICTED)) {
+            showErrorDialog(disconnectCause.getDescription());
+        }
+    }
+
+    public void dismissPendingDialogs() {
+        if (mDialog != null) {
+            mDialog.dismiss();
+            mDialog = null;
+        }
+        if (mAnswerFragment != null) {
+            mAnswerFragment.dismissPendingDialogs();
+        }
+    }
+
+    /**
+     * Utility function to bring up a generic "error" dialog.
+     */
+    private void showErrorDialog(CharSequence msg) {
+        Log.i(this, "Show Dialog: " + msg);
+
+        dismissPendingDialogs();
+
+        mDialog = new AlertDialog.Builder(this)
+                .setMessage(msg)
+                .setPositiveButton(android.R.string.ok, new OnClickListener() {
+                    @Override
+                    public void onClick(DialogInterface dialog, int which) {
+                        onDialogDismissed();
+                    }
+                })
+                .setOnCancelListener(new OnCancelListener() {
+                    @Override
+                    public void onCancel(DialogInterface dialog) {
+                        onDialogDismissed();
+                    }
+                })
+                .create();
+
+        mDialog.getWindow().addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
+        mDialog.show();
+    }
+
+    private void onDialogDismissed() {
+        mDialog = null;
+        CallList.getInstance().onErrorDialogDismissed();
+        InCallPresenter.getInstance().onDismissDialog();
+    }
+
+    public void setExcludeFromRecents(boolean exclude) {
+        ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
+        List<ActivityManager.AppTask> tasks = am.getAppTasks();
+        int taskId = getTaskId();
+        for (int i = 0; i < tasks.size(); i++) {
+            ActivityManager.AppTask task = tasks.get(i);
+            if (task.getTaskInfo().id == taskId) {
+                try {
+                    task.setExcludeFromRecents(exclude);
+                } catch (RuntimeException e) {
+                    Log.e(TAG, "RuntimeException when excluding task from recents.", e);
+                }
+            }
+        }
+    }
+
+
+    public OnTouchListener getDispatchTouchEventListener() {
+        return mDispatchTouchEventListener;
+    }
+
+    public void setDispatchTouchEventListener(OnTouchListener mDispatchTouchEventListener) {
+        this.mDispatchTouchEventListener = mDispatchTouchEventListener;
+    }
+
+    /**
+     * Enables the OrientationEventListener if enable flag is true. Disables it if enable is
+     * false
+     * @param enable true or false.
+     */
+    public void enableInCallOrientationEventListener(boolean enable) {
+        if (enable) {
+            mInCallOrientationEventListener.enable(enable);
+        } else {
+            mInCallOrientationEventListener.disable();
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/InCallAnimationUtils.java b/InCallUI/src/com/android/incallui/InCallAnimationUtils.java
new file mode 100644
index 0000000..44bb369
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallAnimationUtils.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.graphics.Canvas;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.LayerDrawable;
+import android.view.ViewPropertyAnimator;
+import android.widget.ImageView;
+
+/**
+ * Utilities for Animation.
+ */
+public class InCallAnimationUtils {
+    private static final String LOG_TAG = InCallAnimationUtils.class.getSimpleName();
+    /**
+     * Turn on when you're interested in fading animation. Intentionally untied from other debug
+     * settings.
+     */
+    private static final boolean FADE_DBG = false;
+
+    /**
+     * Duration for animations in msec, which can be used with
+     * {@link ViewPropertyAnimator#setDuration(long)} for example.
+     */
+    public static final int ANIMATION_DURATION = 250;
+
+    private InCallAnimationUtils() {
+    }
+
+    /**
+     * Drawable achieving cross-fade, just like TransitionDrawable. We can have
+     * call-backs via animator object (see also {@link CrossFadeDrawable#getAnimator()}).
+     */
+    private static class CrossFadeDrawable extends LayerDrawable {
+        private final ObjectAnimator mAnimator;
+
+        public CrossFadeDrawable(Drawable[] layers) {
+            super(layers);
+            mAnimator = ObjectAnimator.ofInt(this, "crossFadeAlpha", 0xff, 0);
+        }
+
+        private int mCrossFadeAlpha;
+
+        /**
+         * This will be used from ObjectAnimator.
+         * Note: this method is protected by proguard.flags so that it won't be removed
+         * automatically.
+         */
+        @SuppressWarnings("unused")
+        public void setCrossFadeAlpha(int alpha) {
+            mCrossFadeAlpha = alpha;
+            invalidateSelf();
+        }
+
+        public ObjectAnimator getAnimator() {
+            return mAnimator;
+        }
+
+        @Override
+        public void draw(Canvas canvas) {
+            Drawable first = getDrawable(0);
+            Drawable second = getDrawable(1);
+
+            if (mCrossFadeAlpha > 0) {
+                first.setAlpha(mCrossFadeAlpha);
+                first.draw(canvas);
+                first.setAlpha(255);
+            }
+
+            if (mCrossFadeAlpha < 0xff) {
+                second.setAlpha(0xff - mCrossFadeAlpha);
+                second.draw(canvas);
+                second.setAlpha(0xff);
+            }
+        }
+    }
+
+    private static CrossFadeDrawable newCrossFadeDrawable(Drawable first, Drawable second) {
+        Drawable[] layers = new Drawable[2];
+        layers[0] = first;
+        layers[1] = second;
+        return new CrossFadeDrawable(layers);
+    }
+
+    /**
+     * Starts cross-fade animation using TransitionDrawable. Nothing will happen if "from" and "to"
+     * are the same.
+     */
+    public static void startCrossFade(
+            final ImageView imageView, final Drawable from, final Drawable to) {
+        // We skip the cross-fade when those two Drawables are equal, or they are BitmapDrawables
+        // pointing to the same Bitmap.
+        final boolean drawableIsEqual = (from != null && to != null && from.equals(to));
+        final boolean hasFromImage = ((from instanceof BitmapDrawable) &&
+                ((BitmapDrawable) from).getBitmap() != null);
+        final boolean hasToImage = ((to instanceof BitmapDrawable) &&
+                ((BitmapDrawable) to).getBitmap() != null);
+        final boolean areSameImage = drawableIsEqual || (hasFromImage && hasToImage &&
+                ((BitmapDrawable) from).getBitmap().equals(((BitmapDrawable) to).getBitmap()));
+
+        if (!areSameImage) {
+            if (FADE_DBG) {
+                log("Start cross-fade animation for " + imageView
+                        + "(" + Integer.toHexString(from.hashCode()) + " -> "
+                        + Integer.toHexString(to.hashCode()) + ")");
+            }
+
+            CrossFadeDrawable crossFadeDrawable = newCrossFadeDrawable(from, to);
+            ObjectAnimator animator = crossFadeDrawable.getAnimator();
+            imageView.setImageDrawable(crossFadeDrawable);
+            animator.setDuration(ANIMATION_DURATION);
+            animator.addListener(new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationStart(Animator animation) {
+                    if (FADE_DBG) {
+                        log("cross-fade animation start ("
+                                + Integer.toHexString(from.hashCode()) + " -> "
+                                + Integer.toHexString(to.hashCode()) + ")");
+                    }
+                }
+
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    if (FADE_DBG) {
+                        log("cross-fade animation ended ("
+                                + Integer.toHexString(from.hashCode()) + " -> "
+                                + Integer.toHexString(to.hashCode()) + ")");
+                    }
+                    animation.removeAllListeners();
+                    // Workaround for issue 6300562; this will force the drawable to the
+                    // resultant one regardless of animation glitch.
+                    imageView.setImageDrawable(to);
+                }
+            });
+            animator.start();
+
+            /* We could use TransitionDrawable here, but it may cause some weird animation in
+             * some corner cases. See issue 6300562
+             * TODO: decide which to be used in the long run. TransitionDrawable is old but system
+             * one. Ours uses new animation framework and thus have callback (great for testing),
+             * while no framework support for the exact class.
+
+            Drawable[] layers = new Drawable[2];
+            layers[0] = from;
+            layers[1] = to;
+            TransitionDrawable transitionDrawable = new TransitionDrawable(layers);
+            imageView.setImageDrawable(transitionDrawable);
+            transitionDrawable.startTransition(ANIMATION_DURATION); */
+            imageView.setTag(to);
+        } else if (!hasFromImage && hasToImage) {
+            imageView.setImageDrawable(to);
+            imageView.setTag(to);
+        } else {
+            if (FADE_DBG) {
+                log("*Not* start cross-fade. " + imageView);
+            }
+        }
+    }
+
+    // Debugging / testing code
+
+    private static void log(String msg) {
+        Log.d(LOG_TAG, msg);
+    }
+}
\ No newline at end of file
diff --git a/InCallUI/src/com/android/incallui/InCallCameraManager.java b/InCallUI/src/com/android/incallui/InCallCameraManager.java
new file mode 100644
index 0000000..53000f1
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallCameraManager.java
@@ -0,0 +1,184 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.graphics.SurfaceTexture;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.params.StreamConfigurationMap;
+import android.util.Size;
+
+import java.lang.String;
+import java.util.Collections;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.Set;
+
+/**
+ * Used to track which camera is used for outgoing video.
+ */
+public class InCallCameraManager {
+
+    public interface Listener {
+        void onActiveCameraSelectionChanged(boolean isUsingFrontFacingCamera);
+    }
+
+    private final Set<Listener> mCameraSelectionListeners = Collections.
+        newSetFromMap(new ConcurrentHashMap<Listener, Boolean>(8,0.9f,1));
+
+    /**
+     * The camera ID for the front facing camera.
+     */
+    private String mFrontFacingCameraId;
+
+    /**
+     * The camera ID for the rear facing camera.
+     */
+    private String mRearFacingCameraId;
+
+    /**
+     * The currently active camera.
+     */
+    private boolean mUseFrontFacingCamera;
+
+    /**
+     * Indicates whether the list of cameras has been initialized yet.  Initialization is delayed
+     * until a video call is present.
+     */
+    private boolean mIsInitialized = false;
+
+    /**
+     * The context.
+     */
+    private Context mContext;
+
+    /**
+     * Initializes the InCall CameraManager.
+     *
+     * @param context The current context.
+     */
+    public InCallCameraManager(Context context) {
+        mUseFrontFacingCamera = true;
+        mContext = context;
+    }
+
+    /**
+     * Sets whether the front facing camera should be used or not.
+     *
+     * @param useFrontFacingCamera {@code True} if the front facing camera is to be used.
+     */
+    public void setUseFrontFacingCamera(boolean useFrontFacingCamera) {
+        mUseFrontFacingCamera = useFrontFacingCamera;
+        for (Listener listener : mCameraSelectionListeners) {
+            listener.onActiveCameraSelectionChanged(mUseFrontFacingCamera);
+        }
+    }
+
+    /**
+     * Determines whether the front facing camera is currently in use.
+     *
+     * @return {@code True} if the front facing camera is in use.
+     */
+    public boolean isUsingFrontFacingCamera() {
+        return mUseFrontFacingCamera;
+    }
+
+    /**
+     * Determines the active camera ID.
+     *
+     * @return The active camera ID.
+     */
+    public String getActiveCameraId() {
+        maybeInitializeCameraList(mContext);
+
+        if (mUseFrontFacingCamera) {
+            return mFrontFacingCameraId;
+        } else {
+            return mRearFacingCameraId;
+        }
+    }
+
+    /**
+     * Get the list of cameras available for use.
+     *
+     * @param context The context.
+     */
+    private void maybeInitializeCameraList(Context context) {
+        if (mIsInitialized || context == null) {
+            return;
+        }
+
+        Log.v(this, "initializeCameraList");
+
+        CameraManager cameraManager = null;
+        try {
+            cameraManager = (CameraManager) context.getSystemService(
+                    Context.CAMERA_SERVICE);
+        } catch (Exception e) {
+            Log.e(this, "Could not get camera service.");
+            return;
+        }
+
+        if (cameraManager == null) {
+            return;
+        }
+
+        String[] cameraIds = {};
+        try {
+            cameraIds = cameraManager.getCameraIdList();
+        } catch (CameraAccessException e) {
+            Log.d(this, "Could not access camera: "+e);
+            // Camera disabled by device policy.
+            return;
+        }
+
+        for (int i = 0; i < cameraIds.length; i++) {
+            CameraCharacteristics c = null;
+            try {
+                c = cameraManager.getCameraCharacteristics(cameraIds[i]);
+            } catch (IllegalArgumentException e) {
+                // Device Id is unknown.
+            } catch (CameraAccessException e) {
+                // Camera disabled by device policy.
+            }
+            if (c != null) {
+                int facingCharacteristic = c.get(CameraCharacteristics.LENS_FACING);
+                if (facingCharacteristic == CameraCharacteristics.LENS_FACING_FRONT) {
+                    mFrontFacingCameraId = cameraIds[i];
+                } else if (facingCharacteristic == CameraCharacteristics.LENS_FACING_BACK) {
+                    mRearFacingCameraId = cameraIds[i];
+                }
+            }
+        }
+
+        mIsInitialized = true;
+        Log.v(this, "initializeCameraList : done");
+    }
+
+    public void addCameraSelectionListener(Listener listener) {
+        if (listener != null) {
+            mCameraSelectionListeners.add(listener);
+        }
+    }
+
+    public void removeCameraSelectionListener(Listener listener) {
+        if (listener != null) {
+            mCameraSelectionListeners.remove(listener);
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/InCallContactInteractions.java b/InCallUI/src/com/android/incallui/InCallContactInteractions.java
new file mode 100644
index 0000000..e627668
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallContactInteractions.java
@@ -0,0 +1,397 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import com.google.common.annotations.VisibleForTesting;
+
+import android.content.Context;
+import android.location.Address;
+import android.text.TextUtils;
+import android.text.format.DateFormat;
+import android.util.Pair;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ArrayAdapter;
+import android.widget.ImageView;
+import android.widget.ListAdapter;
+import android.widget.RelativeLayout;
+import android.widget.RelativeLayout.LayoutParams;
+import android.widget.TextView;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Wrapper class for objects that are used in generating the context about the contact in the InCall
+ * screen.
+ *
+ * This handles generating the appropriate resource for the ListAdapter based on whether the contact
+ * is a business contact or not and logic for the manipulation of data for the call context.
+ */
+public class InCallContactInteractions {
+    private static final String TAG = InCallContactInteractions.class.getSimpleName();
+
+    private Context mContext;
+    private InCallContactInteractionsListAdapter mListAdapter;
+    private boolean mIsBusiness;
+    private View mBusinessHeaderView;
+    private LayoutInflater mInflater;
+
+    public InCallContactInteractions(Context context, boolean isBusiness) {
+        mContext = context;
+        mInflater = (LayoutInflater)
+                context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+        switchContactType(isBusiness);
+    }
+
+    public InCallContactInteractionsListAdapter getListAdapter() {
+        return mListAdapter;
+    }
+
+    /**
+     * Switches the "isBusiness" value, if applicable. Recreates the list adapter with the resource
+     * corresponding to the new isBusiness value if the "isBusiness" value is switched.
+     *
+     * @param isBusiness Whether or not the contact is a business.
+     *
+     * @return {@code true} if a new list adapter was created, {@code} otherwise.
+     */
+    public boolean switchContactType(boolean isBusiness) {
+        if (mIsBusiness != isBusiness || mListAdapter == null) {
+            mIsBusiness = isBusiness;
+            mListAdapter = new InCallContactInteractionsListAdapter(mContext,
+                    mIsBusiness ? R.layout.business_context_info_list_item
+                            : R.layout.person_context_info_list_item);
+            return true;
+        }
+        return false;
+    }
+
+    public View getBusinessListHeaderView() {
+        if (mBusinessHeaderView == null) {
+            mBusinessHeaderView = mInflater.inflate(
+                    R.layout.business_contact_context_list_header, null);
+        }
+        return mBusinessHeaderView;
+    }
+
+    public void setBusinessInfo(Address address, float distance,
+            List<Pair<Calendar, Calendar>> openingHours) {
+        mListAdapter.clear();
+        List<ContactContextInfo> info = new ArrayList<ContactContextInfo>();
+
+        // Hours of operation
+        if (openingHours != null) {
+            BusinessContextInfo hoursInfo = constructHoursInfo(openingHours);
+            if (hoursInfo != null) {
+                info.add(hoursInfo);
+            }
+        }
+
+        // Location information
+        if (address != null) {
+            BusinessContextInfo locationInfo = constructLocationInfo(address, distance);
+            info.add(locationInfo);
+        }
+
+        mListAdapter.addAll(info);
+    }
+
+    /**
+     * Construct a BusinessContextInfo object containing hours of operation information.
+     * The format is:
+     *      [Open now/Closed now]
+     *      [Hours]
+     *
+     * @param openingHours
+     * @return BusinessContextInfo object with the schedule icon, the heading set to whether the
+     * business is open or not and the details set to the hours of operation.
+     */
+    private BusinessContextInfo constructHoursInfo(List<Pair<Calendar, Calendar>> openingHours) {
+        try {
+            return constructHoursInfo(Calendar.getInstance(), openingHours);
+        } catch (Exception e) {
+            // Catch all exceptions here because we don't want any crashes if something goes wrong.
+            Log.e(TAG, "Error constructing hours info: ", e);
+        }
+        return null;
+    }
+
+    /**
+     * Pass in arbitrary current calendar time.
+     */
+    @VisibleForTesting
+    BusinessContextInfo constructHoursInfo(Calendar currentTime,
+            List<Pair<Calendar, Calendar>> openingHours) {
+        if (currentTime == null || openingHours == null || openingHours.size() == 0) {
+            return null;
+        }
+
+        BusinessContextInfo hoursInfo = new BusinessContextInfo();
+        hoursInfo.iconId = R.drawable.ic_schedule_white_24dp;
+
+        boolean isOpenNow = false;
+        // This variable records which interval the current time is after. 0 denotes none of the
+        // intervals, 1 after the first interval, etc. It is also the index of the interval the
+        // current time is in (if open) or the next interval (if closed).
+        int afterInterval = 0;
+        // This variable counts the number of time intervals in today's opening hours.
+        int todaysIntervalCount = 0;
+
+        for (Pair<Calendar, Calendar> hours : openingHours) {
+            if (hours.first.compareTo(currentTime) <= 0
+                    && currentTime.compareTo(hours.second) < 0) {
+                // If the current time is on or after the opening time and strictly before the
+                // closing time, then this business is open.
+                isOpenNow = true;
+            }
+
+            if (currentTime.get(Calendar.DAY_OF_YEAR) == hours.first.get(Calendar.DAY_OF_YEAR)) {
+                todaysIntervalCount += 1;
+            }
+
+            if (currentTime.compareTo(hours.second) > 0) {
+                // This assumes that the list of intervals is sorted by time.
+                afterInterval += 1;
+            }
+        }
+
+        hoursInfo.heading = isOpenNow ? mContext.getString(R.string.open_now)
+                : mContext.getString(R.string.closed_now);
+
+        /*
+         * The following logic determines what to display in various cases for hours of operation.
+         *
+         * - Display all intervals if open now and number of intervals is <=2.
+         * - Display next closing time if open now and number of intervals is >2.
+         * - Display next opening time if currently closed but opens later today.
+         * - Display last time it closed today if closed now and tomorrow's hours are unknown.
+         * - Display tomorrow's first open time if closed today and tomorrow's hours are known.
+         *
+         * NOTE: The logic below assumes that the intervals are sorted by ascending time. Possible
+         * TODO to modify the logic above and ensure this is true.
+         */
+        if (isOpenNow) {
+            if (todaysIntervalCount == 1) {
+                hoursInfo.detail = getTimeSpanStringForHours(openingHours.get(0));
+            } else if (todaysIntervalCount == 2) {
+                hoursInfo.detail = mContext.getString(
+                        R.string.opening_hours,
+                        getTimeSpanStringForHours(openingHours.get(0)),
+                        getTimeSpanStringForHours(openingHours.get(1)));
+            } else if (afterInterval < openingHours.size()) {
+                // This check should not be necessary since if it is currently open, we should not
+                // be after the last interval, but just in case, we don't want to crash.
+                hoursInfo.detail = mContext.getString(
+                        R.string.closes_today_at,
+                        getFormattedTimeForCalendar(openingHours.get(afterInterval).second));
+            }
+        } else { // Currently closed
+            final int lastIntervalToday = todaysIntervalCount - 1;
+            if (todaysIntervalCount == 0) { // closed today
+                hoursInfo.detail = mContext.getString(
+                        R.string.opens_tomorrow_at,
+                        getFormattedTimeForCalendar(openingHours.get(0).first));
+            } else if (currentTime.after(openingHours.get(lastIntervalToday).second)) {
+                // Passed hours for today
+                if (todaysIntervalCount < openingHours.size()) {
+                    // If all of today's intervals are exhausted, assume the next are tomorrow's.
+                    hoursInfo.detail = mContext.getString(
+                            R.string.opens_tomorrow_at,
+                            getFormattedTimeForCalendar(
+                                    openingHours.get(todaysIntervalCount).first));
+                } else {
+                    // Grab the last time it was open today.
+                    hoursInfo.detail = mContext.getString(
+                            R.string.closed_today_at,
+                            getFormattedTimeForCalendar(
+                                    openingHours.get(lastIntervalToday).second));
+                }
+            } else if (afterInterval < openingHours.size()) {
+                // This check should not be necessary since if it is currently before the last
+                // interval, afterInterval should be less than the count of intervals, but just in
+                // case, we don't want to crash.
+                hoursInfo.detail = mContext.getString(
+                        R.string.opens_today_at,
+                        getFormattedTimeForCalendar(openingHours.get(afterInterval).first));
+            }
+        }
+
+        return hoursInfo;
+    }
+
+    String getFormattedTimeForCalendar(Calendar calendar) {
+        return DateFormat.getTimeFormat(mContext).format(calendar.getTime());
+    }
+
+    String getTimeSpanStringForHours(Pair<Calendar, Calendar> hours) {
+        return mContext.getString(R.string.open_time_span,
+                getFormattedTimeForCalendar(hours.first),
+                getFormattedTimeForCalendar(hours.second));
+    }
+
+    /**
+     * Construct a BusinessContextInfo object with the location information of the business.
+     * The format is:
+     *      [Straight line distance in miles or kilometers]
+     *      [Address without state/country/etc.]
+     *
+     * @param address An Address object containing address details of the business
+     * @param distance The distance to the location in meters
+     * @return A BusinessContextInfo object with the location icon, the heading as the distance to
+     * the business and the details containing the address.
+     */
+    private BusinessContextInfo constructLocationInfo(Address address, float distance) {
+        return constructLocationInfo(Locale.getDefault(), address, distance);
+    }
+
+    @VisibleForTesting
+    BusinessContextInfo constructLocationInfo(Locale locale, Address address,
+            float distance) {
+        if (address == null) {
+            return null;
+        }
+
+        BusinessContextInfo locationInfo = new BusinessContextInfo();
+        locationInfo.iconId = R.drawable.ic_location_on_white_24dp;
+        if (distance != DistanceHelper.DISTANCE_NOT_FOUND) {
+            //TODO: add a setting to allow the user to select "KM" or "MI" as their distance units.
+            if (Locale.US.equals(locale)) {
+                locationInfo.heading = mContext.getString(R.string.distance_imperial_away,
+                        distance * DistanceHelper.MILES_PER_METER);
+            } else {
+                locationInfo.heading = mContext.getString(R.string.distance_metric_away,
+                        distance * DistanceHelper.KILOMETERS_PER_METER);
+            }
+        }
+        if (address.getLocality() != null) {
+            locationInfo.detail = mContext.getString(
+                    R.string.display_address,
+                    address.getAddressLine(0),
+                    address.getLocality());
+        } else {
+            locationInfo.detail = address.getAddressLine(0);
+        }
+        return locationInfo;
+    }
+
+    /**
+     * Get the appropriate title for the context.
+     * @return The "Business info" title for a business contact and the "Recent messages" title for
+     *         personal contacts.
+     */
+    public String getContactContextTitle() {
+        return mIsBusiness
+                ? mContext.getResources().getString(R.string.business_contact_context_title)
+                : mContext.getResources().getString(R.string.person_contact_context_title);
+    }
+
+    public static abstract class ContactContextInfo {
+        public abstract void bindView(View listItem);
+    }
+
+    public static class BusinessContextInfo extends ContactContextInfo {
+        int iconId;
+        String heading;
+        String detail;
+
+        @Override
+        public void bindView(View listItem) {
+            ImageView imageView = (ImageView) listItem.findViewById(R.id.icon);
+            TextView headingTextView = (TextView) listItem.findViewById(R.id.heading);
+            TextView detailTextView = (TextView) listItem.findViewById(R.id.detail);
+
+            if (this.iconId == 0 || (this.heading == null && this.detail == null)) {
+                return;
+            }
+
+            imageView.setImageDrawable(listItem.getContext().getDrawable(this.iconId));
+
+            headingTextView.setText(this.heading);
+            headingTextView.setVisibility(TextUtils.isEmpty(this.heading)
+                    ? View.GONE : View.VISIBLE);
+
+            detailTextView.setText(this.detail);
+            detailTextView.setVisibility(TextUtils.isEmpty(this.detail)
+                    ? View.GONE : View.VISIBLE);
+
+        }
+    }
+
+    public static class PersonContextInfo extends ContactContextInfo {
+        boolean isIncoming;
+        String message;
+        String detail;
+
+        @Override
+        public void bindView(View listItem) {
+            TextView messageTextView = (TextView) listItem.findViewById(R.id.message);
+            TextView detailTextView = (TextView) listItem.findViewById(R.id.detail);
+
+            if (this.message == null || this.detail == null) {
+                return;
+            }
+
+            messageTextView.setBackgroundResource(this.isIncoming ?
+                    R.drawable.incoming_sms_background : R.drawable.outgoing_sms_background);
+            messageTextView.setText(this.message);
+            LayoutParams messageLayoutParams = (LayoutParams) messageTextView.getLayoutParams();
+            messageLayoutParams.addRule(this.isIncoming?
+                    RelativeLayout.ALIGN_PARENT_START : RelativeLayout.ALIGN_PARENT_END);
+            messageTextView.setLayoutParams(messageLayoutParams);
+
+            LayoutParams detailLayoutParams = (LayoutParams) detailTextView.getLayoutParams();
+            detailLayoutParams.addRule(this.isIncoming ?
+                    RelativeLayout.ALIGN_PARENT_START : RelativeLayout.ALIGN_PARENT_END);
+            detailTextView.setLayoutParams(detailLayoutParams);
+            detailTextView.setText(this.detail);
+        }
+    }
+
+    /**
+     * A list adapter for call context information. We use the same adapter for both business and
+     * contact context.
+     */
+    private class InCallContactInteractionsListAdapter extends ArrayAdapter<ContactContextInfo> {
+        // The resource id of the list item layout.
+        int mResId;
+
+        public InCallContactInteractionsListAdapter(Context context, int resource) {
+            super(context, resource);
+            mResId = resource;
+        }
+
+        @Override
+        public View getView(int position, View convertView, ViewGroup parent) {
+            View listItem = mInflater.inflate(mResId, null);
+            ContactContextInfo item = getItem(position);
+
+            if (item == null) {
+                return listItem;
+            }
+
+            item.bindView(listItem);
+            return listItem;
+        }
+    }
+}
\ No newline at end of file
diff --git a/InCallUI/src/com/android/incallui/InCallDateUtils.java b/InCallUI/src/com/android/incallui/InCallDateUtils.java
new file mode 100644
index 0000000..da3bb6b
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallDateUtils.java
@@ -0,0 +1,54 @@
+package com.android.incallui;
+
+import android.content.Context;
+import android.content.res.Resources;
+
+/**
+ * Methods to parse time and date information in the InCallUi
+ */
+public class InCallDateUtils {
+
+    /**
+     * Return given duration in a human-friendly format. For example, "4 minutes 3 seconds" or
+     * "3 hours 1 second". Returns the hours, minutes and seconds in that order if they exist.
+     */
+    public static String formatDuration(Context context, long millis) {
+        int hours = 0;
+        int minutes = 0;
+        int seconds = 0;
+        int elapsedSeconds = (int) (millis / 1000);
+        if (elapsedSeconds >= 3600) {
+            hours = elapsedSeconds / 3600;
+            elapsedSeconds -= hours * 3600;
+        }
+        if (elapsedSeconds >= 60) {
+            minutes = elapsedSeconds / 60;
+            elapsedSeconds -= minutes * 60;
+        }
+        seconds = elapsedSeconds;
+
+        final Resources res = context.getResources();
+        StringBuilder duration = new StringBuilder();
+        try {
+            if (hours > 0) {
+                duration.append(res.getQuantityString(R.plurals.duration_hours, hours, hours));
+            }
+            if (minutes > 0) {
+                if (hours > 0) {
+                    duration.append(' ');
+                }
+                duration.append(res.getQuantityString(R.plurals.duration_minutes, minutes, minutes));
+            }
+            if (seconds > 0) {
+                if (hours > 0 || minutes > 0) {
+                    duration.append(' ');
+                }
+                duration.append(res.getQuantityString(R.plurals.duration_seconds, seconds, seconds));
+            }
+        } catch (Resources.NotFoundException e) {
+            // Ignore; plurals throws an exception for an untranslated quantity for a given locale.
+            return null;
+        }
+        return duration.toString();
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/InCallOrientationEventListener.java b/InCallUI/src/com/android/incallui/InCallOrientationEventListener.java
new file mode 100644
index 0000000..d3334a3
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallOrientationEventListener.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.content.res.Configuration;
+import android.view.OrientationEventListener;
+import android.hardware.SensorManager;
+import android.view.Surface;
+import android.content.pm.ActivityInfo;
+
+/**
+ * This class listens to Orientation events and overrides onOrientationChanged which gets
+ * invoked when an orientation change occurs. When that happens, we notify InCallUI registrants
+ * of the change.
+ */
+public class InCallOrientationEventListener extends OrientationEventListener {
+
+    /**
+     * Screen orientation angles one of 0, 90, 180, 270, 360 in degrees.
+     */
+    public static int SCREEN_ORIENTATION_0 = 0;
+    public static int SCREEN_ORIENTATION_90 = 90;
+    public static int SCREEN_ORIENTATION_180 = 180;
+    public static int SCREEN_ORIENTATION_270 = 270;
+    public static int SCREEN_ORIENTATION_360 = 360;
+
+    public static int FULL_SENSOR_SCREEN_ORIENTATION =
+            ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR;
+
+    public static int NO_SENSOR_SCREEN_ORIENTATION =
+            ActivityInfo.SCREEN_ORIENTATION_NOSENSOR;
+
+    /**
+     * This is to identify dead zones where we won't notify others of orientation changed.
+     * Say for e.g our threshold is x degrees. We will only notify UI when our current rotation is
+     * within x degrees right or left of the screen orientation angles. If it's not within those
+     * ranges, we return SCREEN_ORIENTATION_UNKNOWN and ignore it.
+     */
+    private static int SCREEN_ORIENTATION_UNKNOWN = -1;
+
+    // Rotation threshold is 10 degrees. So if the rotation angle is within 10 degrees of any of
+    // the above angles, we will notify orientation changed.
+    private static int ROTATION_THRESHOLD = 10;
+
+
+    /**
+     * Cache the current rotation of the device.
+     */
+    private static int sCurrentOrientation = SCREEN_ORIENTATION_0;
+
+    public InCallOrientationEventListener(Context context) {
+        super(context);
+    }
+
+    /**
+     * Handles changes in device orientation. Notifies InCallPresenter of orientation changes.
+     *
+     * Note that this API receives sensor rotation in degrees as a param and we convert that to
+     * one of our screen orientation constants - (one of: {@link SCREEN_ORIENTATION_0},
+     * {@link SCREEN_ORIENTATION_90}, {@link SCREEN_ORIENTATION_180},
+     * {@link SCREEN_ORIENTATION_270}).
+     *
+     * @param rotation The new device sensor rotation in degrees
+     */
+    @Override
+    public void onOrientationChanged(int rotation) {
+        if (rotation == OrientationEventListener.ORIENTATION_UNKNOWN) {
+            return;
+        }
+
+        final int orientation = toScreenOrientation(rotation);
+
+        if (orientation != SCREEN_ORIENTATION_UNKNOWN && sCurrentOrientation != orientation) {
+            sCurrentOrientation = orientation;
+            InCallPresenter.getInstance().onDeviceOrientationChange(sCurrentOrientation);
+        }
+    }
+
+    /**
+     * Enables the OrientationEventListener and notifies listeners of current orientation if
+     * notify flag is true
+     * @param notify true or false. Notify device orientation changed if true.
+     */
+    public void enable(boolean notify) {
+        super.enable();
+        if (notify) {
+            InCallPresenter.getInstance().onDeviceOrientationChange(sCurrentOrientation);
+        }
+    }
+
+    /**
+     * Enables the OrientationEventListener with notify flag defaulting to false.
+     */
+    public void enable() {
+        enable(false);
+    }
+
+    /**
+     * Converts sensor rotation in degrees to screen orientation constants.
+     * @param rotation sensor rotation angle in degrees
+     * @return Screen orientation angle in degrees (0, 90, 180, 270). Returns -1 for degrees not
+     * within threshold to identify zones where orientation change should not be trigerred.
+     */
+    private int toScreenOrientation(int rotation) {
+        // Sensor orientation 90 is equivalent to screen orientation 270 and vice versa. This
+        // function returns the screen orientation. So we convert sensor rotation 90 to 270 and
+        // vice versa here.
+        if (isInLeftRange(rotation, SCREEN_ORIENTATION_360, ROTATION_THRESHOLD) ||
+                isInRightRange(rotation, SCREEN_ORIENTATION_0, ROTATION_THRESHOLD)) {
+            return SCREEN_ORIENTATION_0;
+        } else if (isWithinThreshold(rotation, SCREEN_ORIENTATION_90, ROTATION_THRESHOLD)) {
+            return SCREEN_ORIENTATION_270;
+        } else if (isWithinThreshold(rotation, SCREEN_ORIENTATION_180, ROTATION_THRESHOLD)) {
+            return SCREEN_ORIENTATION_180;
+        } else if (isWithinThreshold(rotation, SCREEN_ORIENTATION_270, ROTATION_THRESHOLD)) {
+            return SCREEN_ORIENTATION_90;
+        }
+        return SCREEN_ORIENTATION_UNKNOWN;
+    }
+
+    private static boolean isWithinRange(int value, int begin, int end) {
+        return value >= begin && value < end;
+    }
+
+    private static boolean isWithinThreshold(int value, int center, int threshold) {
+        return isWithinRange(value, center - threshold, center + threshold);
+    }
+
+    private static boolean isInLeftRange(int value, int center, int threshold) {
+        return isWithinRange(value, center - threshold, center);
+    }
+
+    private static boolean isInRightRange(int value, int center, int threshold) {
+        return isWithinRange(value, center, center + threshold);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/InCallPresenter.java b/InCallUI/src/com/android/incallui/InCallPresenter.java
new file mode 100644
index 0000000..f50da8d
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallPresenter.java
@@ -0,0 +1,1910 @@
+/*
+ * 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.
+ */
+
+package com.android.incallui;
+
+import com.google.common.base.Preconditions;
+
+import android.app.ActivityManager.TaskDescription;
+import android.app.FragmentManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.database.ContentObserver;
+import android.graphics.Point;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.provider.CallLog;
+import android.telecom.DisconnectCause;
+import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
+import android.telecom.TelecomManager;
+import android.telecom.VideoProfile;
+import android.telephony.PhoneStateListener;
+import android.telephony.TelephonyManager;
+import android.text.TextUtils;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+
+import com.android.contacts.common.GeoUtil;
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.contacts.common.compat.SdkVersionOverride;
+import com.android.contacts.common.compat.telecom.TelecomManagerCompat;
+import com.android.contacts.common.interactions.TouchPointManager;
+import com.android.contacts.common.testing.NeededForTesting;
+import com.android.contacts.common.util.MaterialColorMapUtils.MaterialPalette;
+import com.android.dialer.calllog.CallLogAsyncTaskUtil;
+import com.android.dialer.calllog.CallLogAsyncTaskUtil.OnCallLogQueryFinishedListener;
+import com.android.dialer.database.FilteredNumberAsyncQueryHandler;
+import com.android.dialer.database.FilteredNumberAsyncQueryHandler.OnCheckBlockedListener;
+import com.android.dialer.filterednumber.FilteredNumbersUtil;
+import com.android.dialer.logging.InteractionEvent;
+import com.android.dialer.logging.Logger;
+import com.android.dialer.util.TelecomUtil;
+import com.android.incallui.compat.telecom.DetailsCompat;
+import com.android.incallui.util.TelecomCallUtil;
+import com.android.incalluibind.ObjectFactory;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Takes updates from the CallList and notifies the InCallActivity (UI)
+ * of the changes.
+ * Responsible for starting the activity for a new call and finishing the activity when all calls
+ * are disconnected.
+ * Creates and manages the in-call state and provides a listener pattern for the presenters
+ * that want to listen in on the in-call state changes.
+ * TODO: This class has become more of a state machine at this point.  Consider renaming.
+ */
+public class InCallPresenter implements CallList.Listener,
+        CircularRevealFragment.OnCircularRevealCompleteListener {
+
+    private static final String EXTRA_FIRST_TIME_SHOWN =
+            "com.android.incallui.intent.extra.FIRST_TIME_SHOWN";
+
+    private static final long BLOCK_QUERY_TIMEOUT_MS = 1000;
+
+    private static final Bundle EMPTY_EXTRAS = new Bundle();
+
+    private static InCallPresenter sInCallPresenter;
+
+    /**
+     * ConcurrentHashMap constructor params: 8 is initial table size, 0.9f is
+     * load factor before resizing, 1 means we only expect a single thread to
+     * access the map so make only a single shard
+     */
+    private final Set<InCallStateListener> mListeners = Collections.newSetFromMap(
+            new ConcurrentHashMap<InCallStateListener, Boolean>(8, 0.9f, 1));
+    private final List<IncomingCallListener> mIncomingCallListeners = new CopyOnWriteArrayList<>();
+    private final Set<InCallDetailsListener> mDetailsListeners = Collections.newSetFromMap(
+            new ConcurrentHashMap<InCallDetailsListener, Boolean>(8, 0.9f, 1));
+    private final Set<CanAddCallListener> mCanAddCallListeners = Collections.newSetFromMap(
+            new ConcurrentHashMap<CanAddCallListener, Boolean>(8, 0.9f, 1));
+    private final Set<InCallUiListener> mInCallUiListeners = Collections.newSetFromMap(
+            new ConcurrentHashMap<InCallUiListener, Boolean>(8, 0.9f, 1));
+    private final Set<InCallOrientationListener> mOrientationListeners = Collections.newSetFromMap(
+            new ConcurrentHashMap<InCallOrientationListener, Boolean>(8, 0.9f, 1));
+    private final Set<InCallEventListener> mInCallEventListeners = Collections.newSetFromMap(
+            new ConcurrentHashMap<InCallEventListener, Boolean>(8, 0.9f, 1));
+
+    private AudioModeProvider mAudioModeProvider;
+    private StatusBarNotifier mStatusBarNotifier;
+    private ContactInfoCache mContactInfoCache;
+    private Context mContext;
+    private CallList mCallList;
+    private InCallActivity mInCallActivity;
+    private InCallState mInCallState = InCallState.NO_CALLS;
+    private ProximitySensor mProximitySensor;
+    private boolean mServiceConnected = false;
+    private boolean mAccountSelectionCancelled = false;
+    private InCallCameraManager mInCallCameraManager = null;
+    private AnswerPresenter mAnswerPresenter = new AnswerPresenter();
+    private FilteredNumberAsyncQueryHandler mFilteredQueryHandler;
+
+    /**
+     * Whether or not we are currently bound and waiting for Telecom to send us a new call.
+     */
+    private boolean mBoundAndWaitingForOutgoingCall;
+
+    /**
+     * If there is no actual call currently in the call list, this will be used as a fallback
+     * to determine the theme color for InCallUI.
+     */
+    private PhoneAccountHandle mPendingPhoneAccountHandle;
+
+    /**
+     * Determines if the InCall UI is in fullscreen mode or not.
+     */
+    private boolean mIsFullScreen = false;
+
+    private final Object mCallCallback = newTelecomCallCallback();
+
+    private Object newTelecomCallCallback() {
+        if (SdkVersionOverride.getSdkVersion(Build.VERSION_CODES.M) >= Build.VERSION_CODES.M) {
+            return newMarshmallowTelecomCallCallback();
+        }
+        return newLollipopTelecomCallCallback();
+    }
+
+    private Object newMarshmallowTelecomCallCallback() {
+        Log.i(this, "Using android.telecom.Call.Callback");
+        return new android.telecom.Call.Callback() {
+            @Override
+            public void onPostDialWait(android.telecom.Call telecomCall,
+                    String remainingPostDialSequence) {
+                final Call call = mCallList.getCallByTelecomCall(telecomCall);
+                if (call == null) {
+                    Log.w(this, "Call not found in call list: " + telecomCall);
+                    return;
+                }
+                onPostDialCharWait(call.getId(), remainingPostDialSequence);
+            }
+
+            @Override
+            public void onDetailsChanged(android.telecom.Call telecomCall,
+                    android.telecom.Call.Details details) {
+                final Call call = mCallList.getCallByTelecomCall(telecomCall);
+                if (call == null) {
+                    Log.w(this, "Call not found in call list: " + telecomCall);
+                    return;
+                }
+                for (InCallDetailsListener listener : mDetailsListeners) {
+                    listener.onDetailsChanged(call, details);
+                }
+            }
+
+            @Override
+            public void onConferenceableCallsChanged(android.telecom.Call telecomCall,
+                    List<android.telecom.Call> conferenceableCalls) {
+                Log.i(this, "onConferenceableCallsChanged: " + telecomCall);
+                onDetailsChanged(telecomCall, telecomCall.getDetails());
+            }
+        };
+    }
+
+    private Object newLollipopTelecomCallCallback() {
+        // This code only runs for Google Experience phones on the pre-M sdk since only the system
+        // dialer can invoke the InCallUI code. This allows us to safely use the
+        // android.telecom.Call.Listener interface
+        Log.i(this, "Using android.telecom.Call.Listener");
+        return new android.telecom.Call.Listener() {
+            @Override
+            public void onPostDialWait(android.telecom.Call telecomCall,
+                    String remainingPostDialSequence) {
+                final Call call = mCallList.getCallByTelecomCall(telecomCall);
+                if (call == null) {
+                    Log.w(this, "Call not found in call list: " + telecomCall);
+                    return;
+                }
+                onPostDialCharWait(call.getId(), remainingPostDialSequence);
+            }
+
+            @Override
+            public void onDetailsChanged(android.telecom.Call telecomCall,
+                    android.telecom.Call.Details details) {
+                final Call call = mCallList.getCallByTelecomCall(telecomCall);
+                if (call == null) {
+                    Log.w(this, "Call not found in call list: " + telecomCall);
+                    return;
+                }
+                for (InCallDetailsListener listener : mDetailsListeners) {
+                    listener.onDetailsChanged(call, details);
+                }
+            }
+
+            @Override
+            public void onConferenceableCallsChanged(android.telecom.Call telecomCall,
+                    List<android.telecom.Call> conferenceableCalls) {
+                Log.i(this, "onConferenceableCallsChanged: " + telecomCall);
+                onDetailsChanged(telecomCall, telecomCall.getDetails());
+            }
+        };
+    }
+
+    private PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
+        public void onCallStateChanged(int state, String incomingNumber) {
+            if (state == TelephonyManager.CALL_STATE_RINGING) {
+                // Check if the number is blocked, to silence the ringer.
+                String countryIso = GeoUtil.getCurrentCountryIso(mContext);
+                mFilteredQueryHandler.isBlockedNumber(
+                        mOnCheckBlockedListener, incomingNumber, countryIso);
+            }
+        }
+    };
+
+    private final OnCheckBlockedListener mOnCheckBlockedListener = new OnCheckBlockedListener() {
+        @Override
+        public void onCheckComplete(final Integer id) {
+            if (id != null) {
+                // Silence the ringer now to prevent ringing and vibration before the call is
+                // terminated when Telecom attempts to add it.
+                TelecomUtil.silenceRinger(mContext);
+            }
+        }
+    };
+
+    /**
+     * Observes the CallLog to delete the call log entry for the blocked call after it is added.
+     * Times out if too much time has passed.
+     */
+    private class BlockedNumberContentObserver extends ContentObserver {
+        private static final int TIMEOUT_MS = 5000;
+
+        private Handler mHandler;
+        private String mNumber;
+        private long mTimeAddedMs;
+
+        private Runnable mTimeoutRunnable = new Runnable() {
+            @Override
+            public void run() {
+                unregister();
+            }
+        };
+
+        public BlockedNumberContentObserver(Handler handler, String number, long timeAddedMs) {
+            super(handler);
+
+            mHandler = handler;
+            mNumber = number;
+            mTimeAddedMs = timeAddedMs;
+        }
+
+        @Override
+        public void onChange(boolean selfChange) {
+            CallLogAsyncTaskUtil.deleteBlockedCall(mContext, mNumber, mTimeAddedMs,
+                    new OnCallLogQueryFinishedListener() {
+                        @Override
+                        public void onQueryFinished(boolean hasEntry) {
+                            if (mContext != null && hasEntry) {
+                                unregister();
+                            }
+                        }
+                    });
+        }
+
+        public void register() {
+            if (mContext != null) {
+                mContext.getContentResolver().registerContentObserver(
+                        CallLog.CONTENT_URI, true, this);
+                mHandler.postDelayed(mTimeoutRunnable, TIMEOUT_MS);
+            }
+        }
+
+        private void unregister() {
+            if (mContext != null) {
+                mHandler.removeCallbacks(mTimeoutRunnable);
+                mContext.getContentResolver().unregisterContentObserver(this);
+            }
+        }
+    };
+
+    /**
+     * Is true when the activity has been previously started. Some code needs to know not just if
+     * the activity is currently up, but if it had been previously shown in foreground for this
+     * in-call session (e.g., StatusBarNotifier). This gets reset when the session ends in the
+     * tear-down method.
+     */
+    private boolean mIsActivityPreviouslyStarted = false;
+
+    /**
+     * Whether or not InCallService is bound to Telecom.
+     */
+    private boolean mServiceBound = false;
+
+    /**
+     * When configuration changes Android kills the current activity and starts a new one.
+     * The flag is used to check if full clean up is necessary (activity is stopped and new
+     * activity won't be started), or if a new activity will be started right after the current one
+     * is destroyed, and therefore no need in release all resources.
+     */
+    private boolean mIsChangingConfigurations = false;
+
+    /** Display colors for the UI. Consists of a primary color and secondary (darker) color */
+    private MaterialPalette mThemeColors;
+
+    private TelecomManager mTelecomManager;
+    private TelephonyManager mTelephonyManager;
+
+    public static synchronized InCallPresenter getInstance() {
+        if (sInCallPresenter == null) {
+            sInCallPresenter = new InCallPresenter();
+        }
+        return sInCallPresenter;
+    }
+
+    @NeededForTesting
+    static synchronized void setInstance(InCallPresenter inCallPresenter) {
+        sInCallPresenter = inCallPresenter;
+    }
+
+    public InCallState getInCallState() {
+        return mInCallState;
+    }
+
+    public CallList getCallList() {
+        return mCallList;
+    }
+
+    public void setUp(Context context,
+            CallList callList,
+            AudioModeProvider audioModeProvider,
+            StatusBarNotifier statusBarNotifier,
+            ContactInfoCache contactInfoCache,
+            ProximitySensor proximitySensor) {
+        if (mServiceConnected) {
+            Log.i(this, "New service connection replacing existing one.");
+            // retain the current resources, no need to create new ones.
+            Preconditions.checkState(context == mContext);
+            Preconditions.checkState(callList == mCallList);
+            Preconditions.checkState(audioModeProvider == mAudioModeProvider);
+            return;
+        }
+
+        Preconditions.checkNotNull(context);
+        mContext = context;
+
+        mContactInfoCache = contactInfoCache;
+
+        mStatusBarNotifier = statusBarNotifier;
+        addListener(mStatusBarNotifier);
+
+        mAudioModeProvider = audioModeProvider;
+
+        mProximitySensor = proximitySensor;
+        addListener(mProximitySensor);
+
+        addIncomingCallListener(mAnswerPresenter);
+        addInCallUiListener(mAnswerPresenter);
+
+        mCallList = callList;
+
+        // This only gets called by the service so this is okay.
+        mServiceConnected = true;
+
+        // The final thing we do in this set up is add ourselves as a listener to CallList.  This
+        // will kick off an update and the whole process can start.
+        mCallList.addListener(this);
+
+        VideoPauseController.getInstance().setUp(this);
+
+        mFilteredQueryHandler = new FilteredNumberAsyncQueryHandler(context.getContentResolver());
+        mTelephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
+        mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
+        mCallList.setFilteredNumberQueryHandler(mFilteredQueryHandler);
+
+        Log.d(this, "Finished InCallPresenter.setUp");
+    }
+
+    /**
+     * Called when the telephony service has disconnected from us.  This will happen when there are
+     * no more active calls. However, we may still want to continue showing the UI for
+     * certain cases like showing "Call Ended".
+     * What we really want is to wait for the activity and the service to both disconnect before we
+     * tear things down. This method sets a serviceConnected boolean and calls a secondary method
+     * that performs the aforementioned logic.
+     */
+    public void tearDown() {
+        Log.d(this, "tearDown");
+        mCallList.clearOnDisconnect();
+
+        mServiceConnected = false;
+        attemptCleanup();
+
+        mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
+        VideoPauseController.getInstance().tearDown();
+    }
+
+    private void attemptFinishActivity() {
+        final boolean doFinish = (mInCallActivity != null && isActivityStarted());
+        Log.i(this, "Hide in call UI: " + doFinish);
+        if (doFinish) {
+            mInCallActivity.setExcludeFromRecents(true);
+            mInCallActivity.finish();
+
+            if (mAccountSelectionCancelled) {
+                // This finish is a result of account selection cancellation
+                // do not include activity ending transition
+                mInCallActivity.overridePendingTransition(0, 0);
+            }
+        }
+    }
+
+    /**
+     * Called when the UI begins, and starts the callstate callbacks if necessary.
+     */
+    public void setActivity(InCallActivity inCallActivity) {
+        if (inCallActivity == null) {
+            throw new IllegalArgumentException("registerActivity cannot be called with null");
+        }
+        if (mInCallActivity != null && mInCallActivity != inCallActivity) {
+            Log.w(this, "Setting a second activity before destroying the first.");
+        }
+        updateActivity(inCallActivity);
+    }
+
+    /**
+     * Called when the UI ends. Attempts to tear down everything if necessary. See
+     * {@link #tearDown()} for more insight on the tear-down process.
+     */
+    public void unsetActivity(InCallActivity inCallActivity) {
+        if (inCallActivity == null) {
+            throw new IllegalArgumentException("unregisterActivity cannot be called with null");
+        }
+        if (mInCallActivity == null) {
+            Log.i(this, "No InCallActivity currently set, no need to unset.");
+            return;
+        }
+        if (mInCallActivity != inCallActivity) {
+            Log.w(this, "Second instance of InCallActivity is trying to unregister when another"
+                    + " instance is active. Ignoring.");
+            return;
+        }
+        updateActivity(null);
+    }
+
+    /**
+     * Updates the current instance of {@link InCallActivity} with the provided one. If a
+     * {@code null} activity is provided, it means that the activity was finished and we should
+     * attempt to cleanup.
+     */
+    private void updateActivity(InCallActivity inCallActivity) {
+        boolean updateListeners = false;
+        boolean doAttemptCleanup = false;
+
+        if (inCallActivity != null) {
+            if (mInCallActivity == null) {
+                updateListeners = true;
+                Log.i(this, "UI Initialized");
+            } else {
+                // since setActivity is called onStart(), it can be called multiple times.
+                // This is fine and ignorable, but we do not want to update the world every time
+                // this happens (like going to/from background) so we do not set updateListeners.
+            }
+
+            mInCallActivity = inCallActivity;
+            mInCallActivity.setExcludeFromRecents(false);
+
+            // By the time the UI finally comes up, the call may already be disconnected.
+            // If that's the case, we may need to show an error dialog.
+            if (mCallList != null && mCallList.getDisconnectedCall() != null) {
+                maybeShowErrorDialogOnDisconnect(mCallList.getDisconnectedCall());
+            }
+
+            // When the UI comes up, we need to first check the in-call state.
+            // If we are showing NO_CALLS, that means that a call probably connected and
+            // then immediately disconnected before the UI was able to come up.
+            // If we dont have any calls, start tearing down the UI instead.
+            // NOTE: This code relies on {@link #mInCallActivity} being set so we run it after
+            // it has been set.
+            if (mInCallState == InCallState.NO_CALLS) {
+                Log.i(this, "UI Initialized, but no calls left.  shut down.");
+                attemptFinishActivity();
+                return;
+            }
+        } else {
+            Log.i(this, "UI Destroyed");
+            updateListeners = true;
+            mInCallActivity = null;
+
+            // We attempt cleanup for the destroy case but only after we recalculate the state
+            // to see if we need to come back up or stay shut down. This is why we do the
+            // cleanup after the call to onCallListChange() instead of directly here.
+            doAttemptCleanup = true;
+        }
+
+        // Messages can come from the telephony layer while the activity is coming up
+        // and while the activity is going down.  So in both cases we need to recalculate what
+        // state we should be in after they complete.
+        // Examples: (1) A new incoming call could come in and then get disconnected before
+        //               the activity is created.
+        //           (2) All calls could disconnect and then get a new incoming call before the
+        //               activity is destroyed.
+        //
+        // b/1122139 - We previously had a check for mServiceConnected here as well, but there are
+        // cases where we need to recalculate the current state even if the service in not
+        // connected.  In particular the case where startOrFinish() is called while the app is
+        // already finish()ing. In that case, we skip updating the state with the knowledge that
+        // we will check again once the activity has finished. That means we have to recalculate the
+        // state here even if the service is disconnected since we may not have finished a state
+        // transition while finish()ing.
+        if (updateListeners) {
+            onCallListChange(mCallList);
+        }
+
+        if (doAttemptCleanup) {
+            attemptCleanup();
+        }
+    }
+
+    private boolean mAwaitingCallListUpdate = false;
+
+    public void onBringToForeground(boolean showDialpad) {
+        Log.i(this, "Bringing UI to foreground.");
+        bringToForeground(showDialpad);
+    }
+
+    public void onCallAdded(final android.telecom.Call call) {
+        // Check if call should be blocked.
+        if (!TelecomCallUtil.isEmergencyCall(call)
+                && !FilteredNumbersUtil.hasRecentEmergencyCall(mContext)
+                && call.getState() == android.telecom.Call.STATE_RINGING) {
+            maybeBlockCall(call);
+        } else {
+            mCallList.onCallAdded(call);
+        }
+
+        // Since a call has been added we are no longer waiting for Telecom to send us a call.
+        setBoundAndWaitingForOutgoingCall(false, null);
+        if (SdkVersionOverride.getSdkVersion(Build.VERSION_CODES.M) >= Build.VERSION_CODES.M) {
+            call.registerCallback((android.telecom.Call.Callback) mCallCallback);
+        } else {
+            call.addListener((android.telecom.Call.Listener) mCallCallback);
+        }
+    }
+
+    /**
+     * Checks whether a call should be blocked, and blocks it if so. Otherwise, it adds the call
+     * to the CallList so it can proceed as normal. There is a timeout, so if the function for
+     * checking whether a function is blocked does not return in a reasonable time, we proceed
+     * with adding the call anyways.
+     */
+    private void maybeBlockCall(final android.telecom.Call call) {
+        final String countryIso = GeoUtil.getCurrentCountryIso(mContext);
+        final String number = TelecomCallUtil.getNumber(call);
+        final long timeAdded = System.currentTimeMillis();
+
+        // Though AtomicBoolean's can be scary, don't fear, as in this case it is only used on the
+        // main UI thread. It is needed so we can change its value within different scopes, since
+        // that cannot be done with a final boolean.
+        final AtomicBoolean hasTimedOut = new AtomicBoolean(false);
+
+        final Handler handler = new Handler();
+
+        // Proceed if the query is slow; the call may still be blocked after the query returns.
+        final Runnable runnable = new Runnable() {
+            public void run() {
+                hasTimedOut.set(true);
+                mCallList.onCallAdded(call);
+            }
+        };
+        handler.postDelayed(runnable, BLOCK_QUERY_TIMEOUT_MS);
+
+        OnCheckBlockedListener onCheckBlockedListener = new OnCheckBlockedListener() {
+            @Override
+            public void onCheckComplete(final Integer id) {
+                if (!hasTimedOut.get()) {
+                    handler.removeCallbacks(runnable);
+                }
+                if (id == null) {
+                    if (!hasTimedOut.get()) {
+                        mCallList.onCallAdded(call);
+                    }
+                } else {
+                    call.reject(false, null);
+                    Log.d(this, "checkForBlockedCall: " + Log.pii(number) + " blocked.");
+                    Logger.logInteraction(InteractionEvent.CALL_BLOCKED);
+
+                    mFilteredQueryHandler.incrementFilteredCount(id);
+
+                    // Register observer to update the call log.
+                    // BlockedNumberContentObserver will unregister after successful log or timeout.
+                    BlockedNumberContentObserver contentObserver =
+                            new BlockedNumberContentObserver(new Handler(), number, timeAdded);
+                    contentObserver.register();
+                }
+            }
+        };
+
+        final boolean success = mFilteredQueryHandler.isBlockedNumber(
+                onCheckBlockedListener, number, countryIso);
+        if (!success) {
+            Log.d(this, "checkForBlockedCall: invalid number, skipping block checking");
+            if (!hasTimedOut.get()) {
+                handler.removeCallbacks(runnable);
+                mCallList.onCallAdded(call);
+            }
+        }
+    }
+
+    public void onCallRemoved(android.telecom.Call call) {
+        mCallList.onCallRemoved(call);
+        if (SdkVersionOverride.getSdkVersion(Build.VERSION_CODES.M) >= Build.VERSION_CODES.M) {
+            call.unregisterCallback((android.telecom.Call.Callback) mCallCallback);
+        } else {
+            call.removeListener((android.telecom.Call.Listener) mCallCallback);
+        }
+    }
+
+    public void onCanAddCallChanged(boolean canAddCall) {
+        for (CanAddCallListener listener : mCanAddCallListeners) {
+            listener.onCanAddCallChanged(canAddCall);
+        }
+    }
+
+    /**
+     * Called when there is a change to the call list.
+     * Sets the In-Call state for the entire in-call app based on the information it gets from
+     * CallList. Dispatches the in-call state to all listeners. Can trigger the creation or
+     * destruction of the UI based on the states that is calculates.
+     */
+    @Override
+    public void onCallListChange(CallList callList) {
+        if (mInCallActivity != null && mInCallActivity.getCallCardFragment() != null &&
+                mInCallActivity.getCallCardFragment().isAnimating()) {
+            mAwaitingCallListUpdate = true;
+            return;
+        }
+        if (callList == null) {
+            return;
+        }
+
+        mAwaitingCallListUpdate = false;
+
+        InCallState newState = getPotentialStateFromCallList(callList);
+        InCallState oldState = mInCallState;
+        Log.d(this, "onCallListChange oldState= " + oldState + " newState=" + newState);
+        newState = startOrFinishUi(newState);
+        Log.d(this, "onCallListChange newState changed to " + newState);
+
+        // Set the new state before announcing it to the world
+        Log.i(this, "Phone switching state: " + oldState + " -> " + newState);
+        mInCallState = newState;
+
+        // notify listeners of new state
+        for (InCallStateListener listener : mListeners) {
+            Log.d(this, "Notify " + listener + " of state " + mInCallState.toString());
+            listener.onStateChange(oldState, mInCallState, callList);
+        }
+
+        if (isActivityStarted()) {
+            final boolean hasCall = callList.getActiveOrBackgroundCall() != null ||
+                    callList.getOutgoingCall() != null;
+            mInCallActivity.dismissKeyguard(hasCall);
+        }
+    }
+
+    /**
+     * Called when there is a new incoming call.
+     *
+     * @param call
+     */
+    @Override
+    public void onIncomingCall(Call call) {
+        InCallState newState = startOrFinishUi(InCallState.INCOMING);
+        InCallState oldState = mInCallState;
+
+        Log.i(this, "Phone switching state: " + oldState + " -> " + newState);
+        mInCallState = newState;
+
+        for (IncomingCallListener listener : mIncomingCallListeners) {
+            listener.onIncomingCall(oldState, mInCallState, call);
+        }
+    }
+
+    @Override
+    public void onUpgradeToVideo(Call call) {
+        //NO-OP
+    }
+    /**
+     * Called when a call becomes disconnected. Called everytime an existing call
+     * changes from being connected (incoming/outgoing/active) to disconnected.
+     */
+    @Override
+    public void onDisconnect(Call call) {
+        maybeShowErrorDialogOnDisconnect(call);
+
+        // We need to do the run the same code as onCallListChange.
+        onCallListChange(mCallList);
+
+        if (isActivityStarted()) {
+            mInCallActivity.dismissKeyguard(false);
+        }
+
+        if (call.isEmergencyCall()) {
+            FilteredNumbersUtil.recordLastEmergencyCallTime(mContext);
+        }
+    }
+
+    /**
+     * Given the call list, return the state in which the in-call screen should be.
+     */
+    public InCallState getPotentialStateFromCallList(CallList callList) {
+
+        InCallState newState = InCallState.NO_CALLS;
+
+        if (callList == null) {
+            return newState;
+        }
+        if (callList.getIncomingCall() != null) {
+            newState = InCallState.INCOMING;
+        } else if (callList.getWaitingForAccountCall() != null) {
+            newState = InCallState.WAITING_FOR_ACCOUNT;
+        } else if (callList.getPendingOutgoingCall() != null) {
+            newState = InCallState.PENDING_OUTGOING;
+        } else if (callList.getOutgoingCall() != null) {
+            newState = InCallState.OUTGOING;
+        } else if (callList.getActiveCall() != null ||
+                callList.getBackgroundCall() != null ||
+                callList.getDisconnectedCall() != null ||
+                callList.getDisconnectingCall() != null) {
+            newState = InCallState.INCALL;
+        }
+
+        if (newState == InCallState.NO_CALLS) {
+            if (mBoundAndWaitingForOutgoingCall) {
+                return InCallState.OUTGOING;
+            }
+        }
+
+        return newState;
+    }
+
+    public boolean isBoundAndWaitingForOutgoingCall() {
+        return mBoundAndWaitingForOutgoingCall;
+    }
+
+    public void setBoundAndWaitingForOutgoingCall(boolean isBound, PhoneAccountHandle handle) {
+        // NOTE: It is possible for there to be a race and have handle become null before
+        // the circular reveal starts. This should not cause any problems because CallCardFragment
+        // should fallback to the actual call in the CallList at that point in time to determine
+        // the theme color.
+        Log.i(this, "setBoundAndWaitingForOutgoingCall: " + isBound);
+        mBoundAndWaitingForOutgoingCall = isBound;
+        mPendingPhoneAccountHandle = handle;
+        if (isBound && mInCallState == InCallState.NO_CALLS) {
+            mInCallState = InCallState.OUTGOING;
+        }
+    }
+
+    @Override
+    public void onCircularRevealComplete(FragmentManager fm) {
+        if (mInCallActivity != null) {
+            mInCallActivity.showCallCardFragment(true);
+            mInCallActivity.getCallCardFragment().animateForNewOutgoingCall();
+            CircularRevealFragment.endCircularReveal(mInCallActivity.getFragmentManager());
+        }
+    }
+
+    public void onShrinkAnimationComplete() {
+        if (mAwaitingCallListUpdate) {
+            onCallListChange(mCallList);
+        }
+    }
+
+    public void addIncomingCallListener(IncomingCallListener listener) {
+        Preconditions.checkNotNull(listener);
+        mIncomingCallListeners.add(listener);
+    }
+
+    public void removeIncomingCallListener(IncomingCallListener listener) {
+        if (listener != null) {
+            mIncomingCallListeners.remove(listener);
+        }
+    }
+
+    public void addListener(InCallStateListener listener) {
+        Preconditions.checkNotNull(listener);
+        mListeners.add(listener);
+    }
+
+    public void removeListener(InCallStateListener listener) {
+        if (listener != null) {
+            mListeners.remove(listener);
+        }
+    }
+
+    public void addDetailsListener(InCallDetailsListener listener) {
+        Preconditions.checkNotNull(listener);
+        mDetailsListeners.add(listener);
+    }
+
+    public void removeDetailsListener(InCallDetailsListener listener) {
+        if (listener != null) {
+            mDetailsListeners.remove(listener);
+        }
+    }
+
+    public void addCanAddCallListener(CanAddCallListener listener) {
+        Preconditions.checkNotNull(listener);
+        mCanAddCallListeners.add(listener);
+    }
+
+    public void removeCanAddCallListener(CanAddCallListener listener) {
+        if (listener != null) {
+            mCanAddCallListeners.remove(listener);
+        }
+    }
+
+    public void addOrientationListener(InCallOrientationListener listener) {
+        Preconditions.checkNotNull(listener);
+        mOrientationListeners.add(listener);
+    }
+
+    public void removeOrientationListener(InCallOrientationListener listener) {
+        if (listener != null) {
+            mOrientationListeners.remove(listener);
+        }
+    }
+
+    public void addInCallEventListener(InCallEventListener listener) {
+        Preconditions.checkNotNull(listener);
+        mInCallEventListeners.add(listener);
+    }
+
+    public void removeInCallEventListener(InCallEventListener listener) {
+        if (listener != null) {
+            mInCallEventListeners.remove(listener);
+        }
+    }
+
+    public ProximitySensor getProximitySensor() {
+        return mProximitySensor;
+    }
+
+    public void handleAccountSelection(PhoneAccountHandle accountHandle, boolean setDefault) {
+        if (mCallList != null) {
+            Call call = mCallList.getWaitingForAccountCall();
+            if (call != null) {
+                String callId = call.getId();
+                TelecomAdapter.getInstance().phoneAccountSelected(callId, accountHandle, setDefault);
+            }
+        }
+    }
+
+    public void cancelAccountSelection() {
+        mAccountSelectionCancelled = true;
+        if (mCallList != null) {
+            Call call = mCallList.getWaitingForAccountCall();
+            if (call != null) {
+                String callId = call.getId();
+                TelecomAdapter.getInstance().disconnectCall(callId);
+            }
+        }
+    }
+
+    /**
+     * Hangs up any active or outgoing calls.
+     */
+    public void hangUpOngoingCall(Context context) {
+        // By the time we receive this intent, we could be shut down and call list
+        // could be null.  Bail in those cases.
+        if (mCallList == null) {
+            if (mStatusBarNotifier == null) {
+                // The In Call UI has crashed but the notification still stayed up. We should not
+                // come to this stage.
+                StatusBarNotifier.clearAllCallNotifications(context);
+            }
+            return;
+        }
+
+        Call call = mCallList.getOutgoingCall();
+        if (call == null) {
+            call = mCallList.getActiveOrBackgroundCall();
+        }
+
+        if (call != null) {
+            TelecomAdapter.getInstance().disconnectCall(call.getId());
+            call.setState(Call.State.DISCONNECTING);
+            mCallList.onUpdate(call);
+        }
+    }
+
+    /**
+     * Answers any incoming call.
+     */
+    public void answerIncomingCall(Context context, int videoState) {
+        // By the time we receive this intent, we could be shut down and call list
+        // could be null.  Bail in those cases.
+        if (mCallList == null) {
+            StatusBarNotifier.clearAllCallNotifications(context);
+            return;
+        }
+
+        Call call = mCallList.getIncomingCall();
+        if (call != null) {
+            TelecomAdapter.getInstance().answerCall(call.getId(), videoState);
+            showInCall(false, false/* newOutgoingCall */);
+        }
+    }
+
+    /**
+     * Declines any incoming call.
+     */
+    public void declineIncomingCall(Context context) {
+        // By the time we receive this intent, we could be shut down and call list
+        // could be null.  Bail in those cases.
+        if (mCallList == null) {
+            StatusBarNotifier.clearAllCallNotifications(context);
+            return;
+        }
+
+        Call call = mCallList.getIncomingCall();
+        if (call != null) {
+            TelecomAdapter.getInstance().rejectCall(call.getId(), false, null);
+        }
+    }
+
+    public void acceptUpgradeRequest(int videoState, Context context) {
+        Log.d(this, " acceptUpgradeRequest videoState " + videoState);
+        // Bail if we have been shut down and the call list is null.
+        if (mCallList == null) {
+            StatusBarNotifier.clearAllCallNotifications(context);
+            Log.e(this, " acceptUpgradeRequest mCallList is empty so returning");
+            return;
+        }
+
+        Call call = mCallList.getVideoUpgradeRequestCall();
+        if (call != null) {
+            VideoProfile videoProfile = new VideoProfile(videoState);
+            call.getVideoCall().sendSessionModifyResponse(videoProfile);
+            call.setSessionModificationState(Call.SessionModificationState.NO_REQUEST);
+        }
+    }
+
+    public void declineUpgradeRequest(Context context) {
+        Log.d(this, " declineUpgradeRequest");
+        // Bail if we have been shut down and the call list is null.
+        if (mCallList == null) {
+            StatusBarNotifier.clearAllCallNotifications(context);
+            Log.e(this, " declineUpgradeRequest mCallList is empty so returning");
+            return;
+        }
+
+        Call call = mCallList.getVideoUpgradeRequestCall();
+        if (call != null) {
+            VideoProfile videoProfile =
+                    new VideoProfile(call.getVideoState());
+            call.getVideoCall().sendSessionModifyResponse(videoProfile);
+            call.setSessionModificationState(Call.SessionModificationState.NO_REQUEST);
+        }
+    }
+
+    /**
+     * Returns true if the incall app is the foreground application.
+     */
+    public boolean isShowingInCallUi() {
+        return (isActivityStarted() && mInCallActivity.isVisible());
+    }
+
+    /**
+     * Returns true if the activity has been created and is running.
+     * Returns true as long as activity is not destroyed or finishing.  This ensures that we return
+     * true even if the activity is paused (not in foreground).
+     */
+    public boolean isActivityStarted() {
+        return (mInCallActivity != null &&
+                !mInCallActivity.isDestroyed() &&
+                !mInCallActivity.isFinishing());
+    }
+
+    public boolean isActivityPreviouslyStarted() {
+        return mIsActivityPreviouslyStarted;
+    }
+
+    /**
+     * Determines if the In-Call app is currently changing configuration.
+     *
+     * @return {@code true} if the In-Call app is changing configuration.
+     */
+    public boolean isChangingConfigurations() {
+        return mIsChangingConfigurations;
+    }
+
+    /**
+     * Tracks whether the In-Call app is currently in the process of changing configuration (i.e.
+     * screen orientation).
+     */
+    /*package*/
+    void updateIsChangingConfigurations() {
+        mIsChangingConfigurations = false;
+        if (mInCallActivity != null) {
+            mIsChangingConfigurations = mInCallActivity.isChangingConfigurations();
+        }
+        Log.v(this, "updateIsChangingConfigurations = " + mIsChangingConfigurations);
+    }
+
+
+    /**
+     * Called when the activity goes in/out of the foreground.
+     */
+    public void onUiShowing(boolean showing) {
+        // We need to update the notification bar when we leave the UI because that
+        // could trigger it to show again.
+        if (mStatusBarNotifier != null) {
+            mStatusBarNotifier.updateNotification(mInCallState, mCallList);
+        }
+
+        if (mProximitySensor != null) {
+            mProximitySensor.onInCallShowing(showing);
+        }
+
+        Intent broadcastIntent = ObjectFactory.getUiReadyBroadcastIntent(mContext);
+        if (broadcastIntent != null) {
+            broadcastIntent.putExtra(EXTRA_FIRST_TIME_SHOWN, !mIsActivityPreviouslyStarted);
+
+            if (showing) {
+                Log.d(this, "Sending sticky broadcast: ", broadcastIntent);
+                mContext.sendStickyBroadcast(broadcastIntent);
+            } else {
+                Log.d(this, "Removing sticky broadcast: ", broadcastIntent);
+                mContext.removeStickyBroadcast(broadcastIntent);
+            }
+        }
+
+        if (showing) {
+            mIsActivityPreviouslyStarted = true;
+        } else {
+            updateIsChangingConfigurations();
+        }
+
+        for (InCallUiListener listener : mInCallUiListeners) {
+            listener.onUiShowing(showing);
+        }
+    }
+
+    public void addInCallUiListener(InCallUiListener listener) {
+        mInCallUiListeners.add(listener);
+    }
+
+    public boolean removeInCallUiListener(InCallUiListener listener) {
+        return mInCallUiListeners.remove(listener);
+    }
+
+    /*package*/
+    void onActivityStarted() {
+        Log.d(this, "onActivityStarted");
+        notifyVideoPauseController(true);
+    }
+
+    /*package*/
+    void onActivityStopped() {
+        Log.d(this, "onActivityStopped");
+        notifyVideoPauseController(false);
+    }
+
+    private void notifyVideoPauseController(boolean showing) {
+        Log.d(this, "notifyVideoPauseController: mIsChangingConfigurations=" +
+                mIsChangingConfigurations);
+        if (!mIsChangingConfigurations) {
+            VideoPauseController.getInstance().onUiShowing(showing);
+        }
+    }
+
+    /**
+     * Brings the app into the foreground if possible.
+     */
+    public void bringToForeground(boolean showDialpad) {
+        // Before we bring the incall UI to the foreground, we check to see if:
+        // 1. It is not currently in the foreground
+        // 2. We are in a state where we want to show the incall ui (i.e. there are calls to
+        // be displayed)
+        // If the activity hadn't actually been started previously, yet there are still calls
+        // present (e.g. a call was accepted by a bluetooth or wired headset), we want to
+        // bring it up the UI regardless.
+        if (!isShowingInCallUi() && mInCallState != InCallState.NO_CALLS) {
+            showInCall(showDialpad, false /* newOutgoingCall */);
+        }
+    }
+
+    public void onPostDialCharWait(String callId, String chars) {
+        if (isActivityStarted()) {
+            mInCallActivity.showPostCharWaitDialog(callId, chars);
+        }
+    }
+
+    /**
+     * Handles the green CALL key while in-call.
+     * @return true if we consumed the event.
+     */
+    public boolean handleCallKey() {
+        Log.v(this, "handleCallKey");
+
+        // The green CALL button means either "Answer", "Unhold", or
+        // "Swap calls", or can be a no-op, depending on the current state
+        // of the Phone.
+
+        /**
+         * INCOMING CALL
+         */
+        final CallList calls = mCallList;
+        final Call incomingCall = calls.getIncomingCall();
+        Log.v(this, "incomingCall: " + incomingCall);
+
+        // (1) Attempt to answer a call
+        if (incomingCall != null) {
+            TelecomAdapter.getInstance().answerCall(
+                    incomingCall.getId(), VideoProfile.STATE_AUDIO_ONLY);
+            return true;
+        }
+
+        /**
+         * STATE_ACTIVE CALL
+         */
+        final Call activeCall = calls.getActiveCall();
+        if (activeCall != null) {
+            // TODO: This logic is repeated from CallButtonPresenter.java. We should
+            // consolidate this logic.
+            final boolean canMerge = activeCall.can(
+                    android.telecom.Call.Details.CAPABILITY_MERGE_CONFERENCE);
+            final boolean canSwap = activeCall.can(
+                    android.telecom.Call.Details.CAPABILITY_SWAP_CONFERENCE);
+
+            Log.v(this, "activeCall: " + activeCall + ", canMerge: " + canMerge +
+                    ", canSwap: " + canSwap);
+
+            // (2) Attempt actions on conference calls
+            if (canMerge) {
+                TelecomAdapter.getInstance().merge(activeCall.getId());
+                return true;
+            } else if (canSwap) {
+                TelecomAdapter.getInstance().swap(activeCall.getId());
+                return true;
+            }
+        }
+
+        /**
+         * BACKGROUND CALL
+         */
+        final Call heldCall = calls.getBackgroundCall();
+        if (heldCall != null) {
+            // We have a hold call so presumeable it will always support HOLD...but
+            // there is no harm in double checking.
+            final boolean canHold = heldCall.can(android.telecom.Call.Details.CAPABILITY_HOLD);
+
+            Log.v(this, "heldCall: " + heldCall + ", canHold: " + canHold);
+
+            // (4) unhold call
+            if (heldCall.getState() == Call.State.ONHOLD && canHold) {
+                TelecomAdapter.getInstance().unholdCall(heldCall.getId());
+                return true;
+            }
+        }
+
+        // Always consume hard keys
+        return true;
+    }
+
+    /**
+     * A dialog could have prevented in-call screen from being previously finished.
+     * This function checks to see if there should be any UI left and if not attempts
+     * to tear down the UI.
+     */
+    public void onDismissDialog() {
+        Log.i(this, "Dialog dismissed");
+        if (mInCallState == InCallState.NO_CALLS) {
+            attemptFinishActivity();
+            attemptCleanup();
+        }
+    }
+
+    /**
+     * Toggles whether the application is in fullscreen mode or not.
+     *
+     * @return {@code true} if in-call is now in fullscreen mode.
+     */
+    public boolean toggleFullscreenMode() {
+        boolean isFullScreen = !mIsFullScreen;
+        Log.v(this, "toggleFullscreenMode = " + isFullScreen);
+        setFullScreen(isFullScreen);
+        return mIsFullScreen;
+    }
+
+    /**
+     * Clears the previous fullscreen state.
+     */
+    public void clearFullscreen() {
+        mIsFullScreen = false;
+    }
+
+    /**
+     * Changes the fullscreen mode of the in-call UI.
+     *
+     * @param isFullScreen {@code true} if in-call should be in fullscreen mode, {@code false}
+     *                                 otherwise.
+     */
+    public void setFullScreen(boolean isFullScreen) {
+        setFullScreen(isFullScreen, false /* force */);
+    }
+
+    /**
+     * Changes the fullscreen mode of the in-call UI.
+     *
+     * @param isFullScreen {@code true} if in-call should be in fullscreen mode, {@code false}
+     *                                 otherwise.
+     * @param force {@code true} if fullscreen mode should be set regardless of its current state.
+     */
+    public void setFullScreen(boolean isFullScreen, boolean force) {
+        Log.v(this, "setFullScreen = " + isFullScreen);
+
+        // As a safeguard, ensure we cannot enter fullscreen if the dialpad is shown.
+        if (isDialpadVisible()) {
+            isFullScreen = false;
+            Log.v(this, "setFullScreen overridden as dialpad is shown = " + isFullScreen);
+        }
+
+        if (mIsFullScreen == isFullScreen && !force) {
+            Log.v(this, "setFullScreen ignored as already in that state.");
+            return;
+        }
+        mIsFullScreen = isFullScreen;
+        notifyFullscreenModeChange(mIsFullScreen);
+    }
+
+    /**
+     * @return {@code true} if the in-call ui is currently in fullscreen mode, {@code false}
+     * otherwise.
+     */
+    public boolean isFullscreen() {
+        return mIsFullScreen;
+    }
+
+
+    /**
+     * Called by the {@link VideoCallPresenter} to inform of a change in full screen video status.
+     *
+     * @param isFullscreenMode {@code True} if entering full screen mode.
+     */
+    public void notifyFullscreenModeChange(boolean isFullscreenMode) {
+        for (InCallEventListener listener : mInCallEventListeners) {
+            listener.onFullscreenModeChanged(isFullscreenMode);
+        }
+    }
+
+    /**
+     * Called by the {@link CallCardPresenter} to inform of a change in visibility of the secondary
+     * caller info bar.
+     *
+     * @param isVisible {@code true} if the secondary caller info is visible, {@code false}
+     *      otherwise.
+     * @param height the height of the secondary caller info bar.
+     */
+    public void notifySecondaryCallerInfoVisibilityChanged(boolean isVisible, int height) {
+        for (InCallEventListener listener : mInCallEventListeners) {
+            listener.onSecondaryCallerInfoVisibilityChanged(isVisible, height);
+        }
+    }
+
+
+    /**
+     * For some disconnected causes, we show a dialog.  This calls into the activity to show
+     * the dialog if appropriate for the call.
+     */
+    private void maybeShowErrorDialogOnDisconnect(Call call) {
+        // For newly disconnected calls, we may want to show a dialog on specific error conditions
+        if (isActivityStarted() && call.getState() == Call.State.DISCONNECTED) {
+            if (call.getAccountHandle() == null && !call.isConferenceCall()) {
+                setDisconnectCauseForMissingAccounts(call);
+            }
+            mInCallActivity.maybeShowErrorDialogOnDisconnect(call.getDisconnectCause());
+        }
+    }
+
+    /**
+     * When the state of in-call changes, this is the first method to get called. It determines if
+     * the UI needs to be started or finished depending on the new state and does it.
+     */
+    private InCallState startOrFinishUi(InCallState newState) {
+        Log.d(this, "startOrFinishUi: " + mInCallState + " -> " + newState);
+
+        // TODO: Consider a proper state machine implementation
+
+        // If the state isn't changing we have already done any starting/stopping of activities in
+        // a previous pass...so lets cut out early
+        if (newState == mInCallState) {
+            return newState;
+        }
+
+        // A new Incoming call means that the user needs to be notified of the the call (since
+        // it wasn't them who initiated it).  We do this through full screen notifications and
+        // happens indirectly through {@link StatusBarNotifier}.
+        //
+        // The process for incoming calls is as follows:
+        //
+        // 1) CallList          - Announces existence of new INCOMING call
+        // 2) InCallPresenter   - Gets announcement and calculates that the new InCallState
+        //                      - should be set to INCOMING.
+        // 3) InCallPresenter   - This method is called to see if we need to start or finish
+        //                        the app given the new state.
+        // 4) StatusBarNotifier - Listens to InCallState changes. InCallPresenter calls
+        //                        StatusBarNotifier explicitly to issue a FullScreen Notification
+        //                        that will either start the InCallActivity or show the user a
+        //                        top-level notification dialog if the user is in an immersive app.
+        //                        That notification can also start the InCallActivity.
+        // 5) InCallActivity    - Main activity starts up and at the end of its onCreate will
+        //                        call InCallPresenter::setActivity() to let the presenter
+        //                        know that start-up is complete.
+        //
+        //          [ AND NOW YOU'RE IN THE CALL. voila! ]
+        //
+        // Our app is started using a fullScreen notification.  We need to do this whenever
+        // we get an incoming call. Depending on the current context of the device, either a
+        // incoming call HUN or the actual InCallActivity will be shown.
+        final boolean startIncomingCallSequence = (InCallState.INCOMING == newState);
+
+        // A dialog to show on top of the InCallUI to select a PhoneAccount
+        final boolean showAccountPicker = (InCallState.WAITING_FOR_ACCOUNT == newState);
+
+        // A new outgoing call indicates that the user just now dialed a number and when that
+        // happens we need to display the screen immediately or show an account picker dialog if
+        // no default is set. However, if the main InCallUI is already visible, we do not want to
+        // re-initiate the start-up animation, so we do not need to do anything here.
+        //
+        // It is also possible to go into an intermediate state where the call has been initiated
+        // but Telecom has not yet returned with the details of the call (handle, gateway, etc.).
+        // This pending outgoing state can also launch the call screen.
+        //
+        // This is different from the incoming call sequence because we do not need to shock the
+        // user with a top-level notification.  Just show the call UI normally.
+        final boolean mainUiNotVisible = !isShowingInCallUi() || !getCallCardFragmentVisible();
+        boolean showCallUi = InCallState.OUTGOING == newState && mainUiNotVisible;
+
+        // Direct transition from PENDING_OUTGOING -> INCALL means that there was an error in the
+        // outgoing call process, so the UI should be brought up to show an error dialog.
+        showCallUi |= (InCallState.PENDING_OUTGOING == mInCallState
+                && InCallState.INCALL == newState && !isShowingInCallUi());
+
+        // Another exception - InCallActivity is in charge of disconnecting a call with no
+        // valid accounts set. Bring the UI up if this is true for the current pending outgoing
+        // call so that:
+        // 1) The call can be disconnected correctly
+        // 2) The UI comes up and correctly displays the error dialog.
+        // TODO: Remove these special case conditions by making InCallPresenter a true state
+        // machine. Telecom should also be the component responsible for disconnecting a call
+        // with no valid accounts.
+        showCallUi |= InCallState.PENDING_OUTGOING == newState && mainUiNotVisible
+                && isCallWithNoValidAccounts(mCallList.getPendingOutgoingCall());
+
+        // The only time that we have an instance of mInCallActivity and it isn't started is
+        // when it is being destroyed.  In that case, lets avoid bringing up another instance of
+        // the activity.  When it is finally destroyed, we double check if we should bring it back
+        // up so we aren't going to lose anything by avoiding a second startup here.
+        boolean activityIsFinishing = mInCallActivity != null && !isActivityStarted();
+        if (activityIsFinishing) {
+            Log.i(this, "Undo the state change: " + newState + " -> " + mInCallState);
+            return mInCallState;
+        }
+
+        if (showCallUi || showAccountPicker) {
+            Log.i(this, "Start in call UI");
+            showInCall(false /* showDialpad */, !showAccountPicker /* newOutgoingCall */);
+        } else if (startIncomingCallSequence) {
+            Log.i(this, "Start Full Screen in call UI");
+
+            // We're about the bring up the in-call UI for an incoming call. If we still have
+            // dialogs up, we need to clear them out before showing incoming screen.
+            if (isActivityStarted()) {
+                mInCallActivity.dismissPendingDialogs();
+            }
+            if (!startUi(newState)) {
+                // startUI refused to start the UI. This indicates that it needed to restart the
+                // activity.  When it finally restarts, it will call us back, so we do not actually
+                // change the state yet (we return mInCallState instead of newState).
+                return mInCallState;
+            }
+        } else if (newState == InCallState.NO_CALLS) {
+            // The new state is the no calls state.  Tear everything down.
+            attemptFinishActivity();
+            attemptCleanup();
+        }
+
+        return newState;
+    }
+
+    /**
+     * Determines whether or not a call has no valid phone accounts that can be used to make the
+     * call with. Emergency calls do not require a phone account.
+     *
+     * @param call to check accounts for.
+     * @return {@code true} if the call has no call capable phone accounts set, {@code false} if
+     * the call contains a phone account that could be used to initiate it with, or is an emergency
+     * call.
+     */
+    public static boolean isCallWithNoValidAccounts(Call call) {
+        if (call != null && !call.isEmergencyCall()) {
+            Bundle extras = call.getIntentExtras();
+
+            if (extras == null) {
+                extras = EMPTY_EXTRAS;
+            }
+
+            final List<PhoneAccountHandle> phoneAccountHandles = extras
+                    .getParcelableArrayList(android.telecom.Call.AVAILABLE_PHONE_ACCOUNTS);
+
+            if ((call.getAccountHandle() == null &&
+                    (phoneAccountHandles == null || phoneAccountHandles.isEmpty()))) {
+                Log.i(InCallPresenter.getInstance(), "No valid accounts for call " + call);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Sets the DisconnectCause for a call that was disconnected because it was missing a
+     * PhoneAccount or PhoneAccounts to select from.
+     * @param call
+     */
+    private void setDisconnectCauseForMissingAccounts(Call call) {
+        android.telecom.Call telecomCall = call.getTelecomCall();
+
+        Bundle extras = DetailsCompat.getIntentExtras(telecomCall.getDetails());
+        // Initialize the extras bundle to avoid NPE
+        if (extras == null) {
+            extras = new Bundle();
+        }
+
+        final List<PhoneAccountHandle> phoneAccountHandles = extras.getParcelableArrayList(
+                android.telecom.Call.AVAILABLE_PHONE_ACCOUNTS);
+
+        if (phoneAccountHandles == null || phoneAccountHandles.isEmpty()) {
+            String scheme = telecomCall.getDetails().getHandle().getScheme();
+            final String errorMsg = PhoneAccount.SCHEME_TEL.equals(scheme) ?
+                    mContext.getString(R.string.callFailed_simError) :
+                        mContext.getString(R.string.incall_error_supp_service_unknown);
+            DisconnectCause disconnectCause =
+                    new DisconnectCause(DisconnectCause.ERROR, null, errorMsg, errorMsg);
+            call.setDisconnectCause(disconnectCause);
+        }
+    }
+
+    private boolean startUi(InCallState inCallState) {
+        boolean isCallWaiting = mCallList.getActiveCall() != null &&
+                mCallList.getIncomingCall() != null;
+
+        // If the screen is off, we need to make sure it gets turned on for incoming calls.
+        // This normally works just fine thanks to FLAG_TURN_SCREEN_ON but that only works
+        // when the activity is first created. Therefore, to ensure the screen is turned on
+        // for the call waiting case, we finish() the current activity and start a new one.
+        // There should be no jank from this since the screen is already off and will remain so
+        // until our new activity is up.
+
+        if (isCallWaiting) {
+            if (mProximitySensor.isScreenReallyOff() && isActivityStarted()) {
+                Log.i(this, "Restarting InCallActivity to turn screen on for call waiting");
+                mInCallActivity.finish();
+                // When the activity actually finishes, we will start it again if there are
+                // any active calls, so we do not need to start it explicitly here. Note, we
+                // actually get called back on this function to restart it.
+
+                // We return false to indicate that we did not actually start the UI.
+                return false;
+            } else {
+                showInCall(false, false);
+            }
+        } else {
+            mStatusBarNotifier.updateNotification(inCallState, mCallList);
+        }
+        return true;
+    }
+
+    /**
+     * Checks to see if both the UI is gone and the service is disconnected. If so, tear it all
+     * down.
+     */
+    private void attemptCleanup() {
+        boolean shouldCleanup = (mInCallActivity == null && !mServiceConnected &&
+                mInCallState == InCallState.NO_CALLS);
+        Log.i(this, "attemptCleanup? " + shouldCleanup);
+
+        if (shouldCleanup) {
+            mIsActivityPreviouslyStarted = false;
+            mIsChangingConfigurations = false;
+
+            // blow away stale contact info so that we get fresh data on
+            // the next set of calls
+            if (mContactInfoCache != null) {
+                mContactInfoCache.clearCache();
+            }
+            mContactInfoCache = null;
+
+            if (mProximitySensor != null) {
+                removeListener(mProximitySensor);
+                mProximitySensor.tearDown();
+            }
+            mProximitySensor = null;
+
+            mAudioModeProvider = null;
+
+            if (mStatusBarNotifier != null) {
+                removeListener(mStatusBarNotifier);
+            }
+            mStatusBarNotifier = null;
+
+            if (mCallList != null) {
+                mCallList.removeListener(this);
+            }
+            mCallList = null;
+
+            mContext = null;
+            mInCallActivity = null;
+
+            mListeners.clear();
+            mIncomingCallListeners.clear();
+            mDetailsListeners.clear();
+            mCanAddCallListeners.clear();
+            mOrientationListeners.clear();
+            mInCallEventListeners.clear();
+
+            Log.d(this, "Finished InCallPresenter.CleanUp");
+        }
+    }
+
+    public void showInCall(final boolean showDialpad, final boolean newOutgoingCall) {
+        Log.i(this, "Showing InCallActivity");
+        mContext.startActivity(getInCallIntent(showDialpad, newOutgoingCall));
+    }
+
+    public void onServiceBind() {
+        mServiceBound = true;
+    }
+
+    public void onServiceUnbind() {
+        InCallPresenter.getInstance().setBoundAndWaitingForOutgoingCall(false, null);
+        mServiceBound = false;
+    }
+
+    public boolean isServiceBound() {
+        return mServiceBound;
+    }
+
+    public void maybeStartRevealAnimation(Intent intent) {
+        if (intent == null || mInCallActivity != null) {
+            return;
+        }
+        final Bundle extras = intent.getBundleExtra(TelecomManager.EXTRA_OUTGOING_CALL_EXTRAS);
+        if (extras == null) {
+            // Incoming call, just show the in-call UI directly.
+            return;
+        }
+
+        if (extras.containsKey(android.telecom.Call.AVAILABLE_PHONE_ACCOUNTS)) {
+            // Account selection dialog will show up so don't show the animation.
+            return;
+        }
+
+        final PhoneAccountHandle accountHandle =
+                intent.getParcelableExtra(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE);
+        final Point touchPoint = extras.getParcelable(TouchPointManager.TOUCH_POINT);
+
+        InCallPresenter.getInstance().setBoundAndWaitingForOutgoingCall(true, accountHandle);
+
+        final Intent incallIntent = getInCallIntent(false, true);
+        incallIntent.putExtra(TouchPointManager.TOUCH_POINT, touchPoint);
+        mContext.startActivity(incallIntent);
+    }
+
+    public Intent getInCallIntent(boolean showDialpad, boolean newOutgoingCall) {
+        final Intent intent = new Intent(Intent.ACTION_MAIN, null);
+        intent.setFlags(Intent.FLAG_ACTIVITY_NO_USER_ACTION | Intent.FLAG_ACTIVITY_NEW_TASK);
+
+        intent.setClass(mContext, InCallActivity.class);
+        if (showDialpad) {
+            intent.putExtra(InCallActivity.SHOW_DIALPAD_EXTRA, true);
+        }
+        intent.putExtra(InCallActivity.NEW_OUTGOING_CALL_EXTRA, newOutgoingCall);
+        return intent;
+    }
+
+    /**
+     * Retrieves the current in-call camera manager instance, creating if necessary.
+     *
+     * @return The {@link InCallCameraManager}.
+     */
+    public InCallCameraManager getInCallCameraManager() {
+        synchronized(this) {
+            if (mInCallCameraManager == null) {
+                mInCallCameraManager = new InCallCameraManager(mContext);
+            }
+
+            return mInCallCameraManager;
+        }
+    }
+
+    /**
+     * Notifies listeners of changes in orientation and notify calls of rotation angle change.
+     *
+     * @param orientation The screen orientation of the device (one of:
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_0},
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_90},
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_180},
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_270}).
+     */
+    public void onDeviceOrientationChange(int orientation) {
+        Log.d(this, "onDeviceOrientationChange: orientation= " + orientation);
+
+        if (mCallList != null) {
+            mCallList.notifyCallsOfDeviceRotation(orientation);
+        } else {
+            Log.w(this, "onDeviceOrientationChange: CallList is null.");
+        }
+
+        // Notify listeners of device orientation changed.
+        for (InCallOrientationListener listener : mOrientationListeners) {
+            listener.onDeviceOrientationChanged(orientation);
+        }
+    }
+
+    /**
+     * Configures the in-call UI activity so it can change orientations or not. Enables the
+     * orientation event listener if allowOrientationChange is true, disables it if false.
+     *
+     * @param allowOrientationChange {@code True} if the in-call UI can change between portrait
+     *      and landscape.  {@Code False} if the in-call UI should be locked in portrait.
+     */
+    public void setInCallAllowsOrientationChange(boolean allowOrientationChange) {
+        if (mInCallActivity == null) {
+            Log.e(this, "InCallActivity is null. Can't set requested orientation.");
+            return;
+        }
+
+        if (!allowOrientationChange) {
+            mInCallActivity.setRequestedOrientation(
+                    InCallOrientationEventListener.NO_SENSOR_SCREEN_ORIENTATION);
+        } else {
+            // Using SCREEN_ORIENTATION_FULL_SENSOR allows for reverse-portrait orientation, where
+            // SCREEN_ORIENTATION_SENSOR does not.
+            mInCallActivity.setRequestedOrientation(
+                    InCallOrientationEventListener.FULL_SENSOR_SCREEN_ORIENTATION);
+        }
+        mInCallActivity.enableInCallOrientationEventListener(allowOrientationChange);
+    }
+
+    public void enableScreenTimeout(boolean enable) {
+        Log.v(this, "enableScreenTimeout: value=" + enable);
+        if (mInCallActivity == null) {
+            Log.e(this, "enableScreenTimeout: InCallActivity is null.");
+            return;
+        }
+
+        final Window window = mInCallActivity.getWindow();
+        if (enable) {
+            window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+        } else {
+            window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+        }
+    }
+
+    /**
+     * Returns the space available beside the call card.
+     *
+     * @return The space beside the call card.
+     */
+    public float getSpaceBesideCallCard() {
+        if (mInCallActivity != null && mInCallActivity.getCallCardFragment() != null) {
+            return mInCallActivity.getCallCardFragment().getSpaceBesideCallCard();
+        }
+        return 0;
+    }
+
+    /**
+     * Returns whether the call card fragment is currently visible.
+     *
+     * @return True if the call card fragment is visible.
+     */
+    public boolean getCallCardFragmentVisible() {
+        if (mInCallActivity != null && mInCallActivity.getCallCardFragment() != null) {
+            return mInCallActivity.getCallCardFragment().isVisible();
+        }
+        return false;
+    }
+
+    /**
+     * Hides or shows the conference manager fragment.
+     *
+     * @param show {@code true} if the conference manager should be shown, {@code false} if it
+     *                         should be hidden.
+     */
+    public void showConferenceCallManager(boolean show) {
+        if (mInCallActivity == null) {
+            return;
+        }
+
+        mInCallActivity.showConferenceFragment(show);
+    }
+
+    /**
+     * Determines if the dialpad is visible.
+     *
+     * @return {@code true} if the dialpad is visible, {@code false} otherwise.
+     */
+    public boolean isDialpadVisible() {
+        if (mInCallActivity == null) {
+            return false;
+        }
+        return mInCallActivity.isDialpadVisible();
+    }
+
+    /**
+     * @return True if the application is currently running in a right-to-left locale.
+     */
+    public static boolean isRtl() {
+        return TextUtils.getLayoutDirectionFromLocale(Locale.getDefault()) ==
+                View.LAYOUT_DIRECTION_RTL;
+    }
+
+    /**
+     * Extract background color from call object. The theme colors will include a primary color
+     * and a secondary color.
+     */
+    public void setThemeColors() {
+        // This method will set the background to default if the color is PhoneAccount.NO_COLOR.
+        mThemeColors = getColorsFromCall(mCallList.getFirstCall());
+
+        if (mInCallActivity == null) {
+            return;
+        }
+
+        final Resources resources = mInCallActivity.getResources();
+        final int color;
+        if (resources.getBoolean(R.bool.is_layout_landscape)) {
+            // TODO use ResourcesCompat.getColor(Resources, int, Resources.Theme) when available
+            // {@link Resources#getColor(int)} used for compatibility
+            color = resources.getColor(R.color.statusbar_background_color);
+        } else {
+            color = mThemeColors.mSecondaryColor;
+        }
+
+        mInCallActivity.getWindow().setStatusBarColor(color);
+        final TaskDescription td = new TaskDescription(
+                resources.getString(R.string.notification_ongoing_call), null, color);
+        mInCallActivity.setTaskDescription(td);
+    }
+
+    /**
+     * @return A palette for colors to display in the UI.
+     */
+    public MaterialPalette getThemeColors() {
+        return mThemeColors;
+    }
+
+    private MaterialPalette getColorsFromCall(Call call) {
+        if (call == null) {
+            return getColorsFromPhoneAccountHandle(mPendingPhoneAccountHandle);
+        } else {
+            return getColorsFromPhoneAccountHandle(call.getAccountHandle());
+        }
+    }
+
+    private MaterialPalette getColorsFromPhoneAccountHandle(PhoneAccountHandle phoneAccountHandle) {
+        int highlightColor = PhoneAccount.NO_HIGHLIGHT_COLOR;
+        if (phoneAccountHandle != null) {
+            final TelecomManager tm = getTelecomManager();
+
+            if (tm != null) {
+                final PhoneAccount account =
+                        TelecomManagerCompat.getPhoneAccount(tm, phoneAccountHandle);
+                // For single-sim devices, there will be no selected highlight color, so the phone
+                // account will default to NO_HIGHLIGHT_COLOR.
+                if (account != null && CompatUtils.isLollipopMr1Compatible()) {
+                    highlightColor = account.getHighlightColor();
+                }
+            }
+        }
+        return new InCallUIMaterialColorMapUtils(
+                mContext.getResources()).calculatePrimaryAndSecondaryColor(highlightColor);
+    }
+
+    /**
+     * @return An instance of TelecomManager.
+     */
+    public TelecomManager getTelecomManager() {
+        if (mTelecomManager == null) {
+            mTelecomManager = (TelecomManager)
+                    mContext.getSystemService(Context.TELECOM_SERVICE);
+        }
+        return mTelecomManager;
+    }
+
+    /**
+     * @return An instance of TelephonyManager
+     */
+    public TelephonyManager getTelephonyManager() {
+        return mTelephonyManager;
+    }
+
+    InCallActivity getActivity() {
+        return mInCallActivity;
+    }
+
+    AnswerPresenter getAnswerPresenter() {
+        return mAnswerPresenter;
+    }
+
+    /**
+     * Private constructor. Must use getInstance() to get this singleton.
+     */
+    private InCallPresenter() {
+    }
+
+    /**
+     * All the main states of InCallActivity.
+     */
+    public enum InCallState {
+        // InCall Screen is off and there are no calls
+        NO_CALLS,
+
+        // Incoming-call screen is up
+        INCOMING,
+
+        // In-call experience is showing
+        INCALL,
+
+        // Waiting for user input before placing outgoing call
+        WAITING_FOR_ACCOUNT,
+
+        // UI is starting up but no call has been initiated yet.
+        // The UI is waiting for Telecom to respond.
+        PENDING_OUTGOING,
+
+        // User is dialing out
+        OUTGOING;
+
+        public boolean isIncoming() {
+            return (this == INCOMING);
+        }
+
+        public boolean isConnectingOrConnected() {
+            return (this == INCOMING ||
+                    this == OUTGOING ||
+                    this == INCALL);
+        }
+    }
+
+    /**
+     * Interface implemented by classes that need to know about the InCall State.
+     */
+    public interface InCallStateListener {
+        // TODO: Enhance state to contain the call objects instead of passing CallList
+        public void onStateChange(InCallState oldState, InCallState newState, CallList callList);
+    }
+
+    public interface IncomingCallListener {
+        public void onIncomingCall(InCallState oldState, InCallState newState, Call call);
+    }
+
+    public interface CanAddCallListener {
+        public void onCanAddCallChanged(boolean canAddCall);
+    }
+
+    public interface InCallDetailsListener {
+        public void onDetailsChanged(Call call, android.telecom.Call.Details details);
+    }
+
+    public interface InCallOrientationListener {
+        public void onDeviceOrientationChanged(int orientation);
+    }
+
+    /**
+     * Interface implemented by classes that need to know about events which occur within the
+     * In-Call UI.  Used as a means of communicating between fragments that make up the UI.
+     */
+    public interface InCallEventListener {
+        public void onFullscreenModeChanged(boolean isFullscreenMode);
+        public void onSecondaryCallerInfoVisibilityChanged(boolean isVisible, int height);
+    }
+
+    public interface InCallUiListener {
+        void onUiShowing(boolean showing);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/InCallServiceImpl.java b/InCallUI/src/com/android/incallui/InCallServiceImpl.java
new file mode 100644
index 0000000..31d6efb
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallServiceImpl.java
@@ -0,0 +1,184 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.IBinder;
+import android.telecom.AudioState;
+import android.telecom.Call;
+import android.telecom.CallAudioState;
+import android.telecom.InCallService;
+import android.telecom.Phone;
+
+import com.android.contacts.common.compat.SdkVersionOverride;
+
+/**
+ * Used to receive updates about calls from the Telecom component.  This service is bound to
+ * Telecom while there exist calls which potentially require UI. This includes ringing (incoming),
+ * dialing (outgoing), and active calls. When the last call is disconnected, Telecom will unbind to
+ * the service triggering InCallActivity (via CallList) to finish soon after.
+ */
+public class InCallServiceImpl extends InCallService {
+
+    @Override
+    public void onCallAudioStateChanged(CallAudioState audioState) {
+        AudioModeProvider.getInstance().onAudioStateChanged(audioState.isMuted(),
+                audioState.getRoute(), audioState.getSupportedRouteMask());
+    }
+
+    @Override
+    public void onBringToForeground(boolean showDialpad) {
+        InCallPresenter.getInstance().onBringToForeground(showDialpad);
+    }
+
+    @Override
+    public void onCallAdded(Call call) {
+        InCallPresenter.getInstance().onCallAdded(call);
+    }
+
+    @Override
+    public void onCallRemoved(Call call) {
+        InCallPresenter.getInstance().onCallRemoved(call);
+    }
+
+    @Override
+    public void onCanAddCallChanged(boolean canAddCall) {
+        InCallPresenter.getInstance().onCanAddCallChanged(canAddCall);
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        final Context context = getApplicationContext();
+        final ContactInfoCache contactInfoCache = ContactInfoCache.getInstance(context);
+        InCallPresenter.getInstance().setUp(
+                getApplicationContext(),
+                CallList.getInstance(),
+                AudioModeProvider.getInstance(),
+                new StatusBarNotifier(context, contactInfoCache),
+                contactInfoCache,
+                new ProximitySensor(
+                        context,
+                        AudioModeProvider.getInstance(),
+                        new AccelerometerListener(context))
+                );
+        InCallPresenter.getInstance().onServiceBind();
+        InCallPresenter.getInstance().maybeStartRevealAnimation(intent);
+        TelecomAdapter.getInstance().setInCallService(this);
+
+        return super.onBind(intent);
+    }
+
+    @Override
+    public boolean onUnbind(Intent intent) {
+        super.onUnbind(intent);
+
+        InCallPresenter.getInstance().onServiceUnbind();
+        tearDown();
+
+        return false;
+    }
+
+    private void tearDown() {
+        Log.v(this, "tearDown");
+        // Tear down the InCall system
+        TelecomAdapter.getInstance().clearInCallService();
+        InCallPresenter.getInstance().tearDown();
+    }
+
+    /*
+     * Compatibility code for devices running the L sdk. In that version of the sdk, InCallService
+     * callbacks were registered via a android.telecom.Phone$Listener. These callbacks typically
+     * correspond 1:1 to callbacks now found in android.telecom.InCallService so the compatibility
+     * code forwards to those methods.
+     */
+    private Phone.Listener mPhoneListener = new Phone.Listener() {
+        @Override
+        public void onAudioStateChanged(Phone phone, AudioState audioState) {
+            /*
+             * Need to use reflection here; in M these are private fields retrieved through getters,
+             * but in L they are public fields without getters.
+             */
+            try {
+                boolean isMuted = AudioState.class.getField("isMuted").getBoolean(audioState);
+                int route = AudioState.class.getField("route").getInt(audioState);
+                int supportedRouteMask = AudioState.class.getField("supportedRouteMask")
+                        .getInt(audioState);
+                AudioModeProvider.getInstance()
+                        .onAudioStateChanged(isMuted, route, supportedRouteMask);
+            } catch (ReflectiveOperationException e) {
+                Log.e(this, "Unable to use reflection to retrieve AudioState fields", e);
+            }
+        }
+
+        @Override
+        public void onBringToForeground(Phone phone, boolean showDialpad) {
+            InCallServiceImpl.this.onBringToForeground(showDialpad);
+        }
+
+        @Override
+        public void onCallAdded(Phone phone, Call call) {
+            InCallServiceImpl.this.onCallAdded(call);
+        }
+
+        @Override
+        public void onCallRemoved(Phone phone, Call call) {
+            InCallServiceImpl.this.onCallRemoved(call);
+        }
+    };
+
+    private Phone mPhone;
+
+    @Override
+    public void onPhoneCreated(Phone phone) {
+        if (SdkVersionOverride.getSdkVersion(Build.VERSION_CODES.M) >= Build.VERSION_CODES.M) {
+            return;
+        }
+        mPhone = phone;
+        mPhone.addListener(mPhoneListener);
+    }
+
+    @Override
+    public void onPhoneDestroyed(Phone phone) {
+        if (SdkVersionOverride.getSdkVersion(Build.VERSION_CODES.M) >= Build.VERSION_CODES.M) {
+            return;
+        }
+        mPhone.removeListener(mPhoneListener);
+        mPhone = null;
+    }
+
+    /*
+     * setMuted and setAudioRoute are final in InCallService so compat methods are
+     * used to perform the needed branching logic based on sdk version
+     */
+    public void setMutedCompat(boolean state) {
+        if (SdkVersionOverride.getSdkVersion(Build.VERSION_CODES.M) >= Build.VERSION_CODES.M) {
+            super.setMuted(state);
+            return;
+        }
+        mPhone.setMuted(state);
+    }
+
+    public void setAudioRouteCompat(int route) {
+        if (SdkVersionOverride.getSdkVersion(Build.VERSION_CODES.M) >= Build.VERSION_CODES.M) {
+            super.setAudioRoute(route);
+            return;
+        }
+        mPhone.setAudioRoute(route);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/InCallServiceListener.java b/InCallUI/src/com/android/incallui/InCallServiceListener.java
new file mode 100644
index 0000000..11a5b08
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallServiceListener.java
@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+
+package com.android.incallui;
+
+import android.telecom.InCallService;
+
+/**
+ * Interface implemented by In-Call components that maintain a reference to the Telecom API
+ * {@code InCallService} object. Clarifies the expectations associated with the relevant method
+ * calls.
+ */
+public interface InCallServiceListener {
+
+    /**
+     * Called once at {@code InCallService} startup time with a valid instance. At
+     * that time, there will be no existing {@code Call}s.
+     *
+     * @param inCallService The {@code InCallService} object.
+     */
+    void setInCallService(InCallService inCallService);
+
+    /**
+     * Called once at {@code InCallService} shutdown time. At that time, any {@code Call}s
+     * will have transitioned through the disconnected state and will no longer exist.
+     */
+    void clearInCallService();
+}
diff --git a/InCallUI/src/com/android/incallui/InCallUIMaterialColorMapUtils.java b/InCallUI/src/com/android/incallui/InCallUIMaterialColorMapUtils.java
new file mode 100644
index 0000000..44b035f
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallUIMaterialColorMapUtils.java
@@ -0,0 +1,56 @@
+package com.android.incallui;
+
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.telecom.PhoneAccount;
+
+import com.android.contacts.common.util.MaterialColorMapUtils;
+import com.android.contacts.common.util.MaterialColorMapUtils.MaterialPalette;
+
+public class InCallUIMaterialColorMapUtils extends MaterialColorMapUtils {
+    private final TypedArray sPrimaryColors;
+    private final TypedArray sSecondaryColors;
+    private final Resources mResources;
+
+    public InCallUIMaterialColorMapUtils(Resources resources) {
+        super(resources);
+        sPrimaryColors = resources.obtainTypedArray(
+                com.android.incallui.R.array.background_colors);
+        sSecondaryColors = resources.obtainTypedArray(
+                com.android.incallui.R.array.background_colors_dark);
+        mResources = resources;
+    }
+
+    /**
+     * Currently the InCallUI color will only vary by SIM color which is a list of colors
+     * defined in the background_colors array, so first search the list for the matching color and
+     * fall back to the closest matching color if an exact match does not exist.
+     */
+    @Override
+    public MaterialPalette calculatePrimaryAndSecondaryColor(int color) {
+        if (color == PhoneAccount.NO_HIGHLIGHT_COLOR) {
+            return getDefaultPrimaryAndSecondaryColors(mResources);
+        }
+
+        for (int i = 0; i < sPrimaryColors.length(); i++) {
+            if (sPrimaryColors.getColor(i, 0) == color) {
+                return new MaterialPalette(
+                        sPrimaryColors.getColor(i, 0),
+                        sSecondaryColors.getColor(i, 0));
+            }
+        }
+
+        // The color isn't in the list, so use the superclass to find an approximate color.
+        return super.calculatePrimaryAndSecondaryColor(color);
+    }
+
+    /**
+     * {@link Resources#getColor(int) used for compatibility
+     */
+    @SuppressWarnings("deprecation")
+    public static MaterialPalette getDefaultPrimaryAndSecondaryColors(Resources resources) {
+        final int primaryColor = resources.getColor(R.color.dialer_theme_color);
+        final int secondaryColor = resources.getColor(R.color.dialer_theme_color_dark);
+        return new MaterialPalette(primaryColor, secondaryColor);
+    }
+}
\ No newline at end of file
diff --git a/InCallUI/src/com/android/incallui/InCallVideoCallCallback.java b/InCallUI/src/com/android/incallui/InCallVideoCallCallback.java
new file mode 100644
index 0000000..76f8c09
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallVideoCallCallback.java
@@ -0,0 +1,171 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.telecom.Connection;
+import android.telecom.Connection.VideoProvider;
+import android.telecom.InCallService.VideoCall;
+import android.telecom.VideoProfile;
+import android.telecom.VideoProfile.CameraCapabilities;
+
+/**
+ * Implements the InCallUI VideoCall Callback.
+ */
+public class InCallVideoCallCallback extends VideoCall.Callback {
+
+    /**
+     * The call associated with this {@link InCallVideoCallCallback}.
+     */
+    private Call mCall;
+
+    /**
+     * Creates an instance of the call video client, specifying the call it is related to.
+     *
+     * @param call The call.
+     */
+    public InCallVideoCallCallback(Call call) {
+        mCall = call;
+    }
+
+    /**
+     * Handles an incoming session modification request.
+     *
+     * @param videoProfile The requested video call profile.
+     */
+    @Override
+    public void onSessionModifyRequestReceived(VideoProfile videoProfile) {
+        Log.d(this, " onSessionModifyRequestReceived videoProfile=" + videoProfile);
+        int previousVideoState = VideoUtils.getUnPausedVideoState(mCall.getVideoState());
+        int newVideoState = VideoUtils.getUnPausedVideoState(videoProfile.getVideoState());
+
+        boolean wasVideoCall = VideoUtils.isVideoCall(previousVideoState);
+        boolean isVideoCall = VideoUtils.isVideoCall(newVideoState);
+
+        // Check for upgrades to video and downgrades to audio.
+        if (wasVideoCall && !isVideoCall) {
+            InCallVideoCallCallbackNotifier.getInstance().downgradeToAudio(mCall);
+        } else if (previousVideoState != newVideoState) {
+            InCallVideoCallCallbackNotifier.getInstance().upgradeToVideoRequest(mCall,
+                newVideoState);
+        }
+    }
+
+    /**
+     * Handles a session modification response.
+     *
+     * @param status Status of the session modify request. Valid values are
+     *            {@link Connection.VideoProvider#SESSION_MODIFY_REQUEST_SUCCESS},
+     *            {@link Connection.VideoProvider#SESSION_MODIFY_REQUEST_FAIL},
+     *            {@link Connection.VideoProvider#SESSION_MODIFY_REQUEST_INVALID}
+     * @param requestedProfile
+     * @param responseProfile The actual profile changes made by the peer device.
+     */
+    @Override
+    public void onSessionModifyResponseReceived(int status, VideoProfile requestedProfile,
+            VideoProfile responseProfile) {
+        Log.d(this, "onSessionModifyResponseReceived status=" + status + " requestedProfile="
+                + requestedProfile + " responseProfile=" + responseProfile);
+        if (status != VideoProvider.SESSION_MODIFY_REQUEST_SUCCESS) {
+            // Report the reason the upgrade failed as the new session modification state.
+            if (status == VideoProvider.SESSION_MODIFY_REQUEST_TIMED_OUT) {
+                mCall.setSessionModificationState(
+                        Call.SessionModificationState.UPGRADE_TO_VIDEO_REQUEST_TIMED_OUT);
+            } else {
+                if (status == VideoProvider.SESSION_MODIFY_REQUEST_REJECTED_BY_REMOTE) {
+                    mCall.setSessionModificationState(
+                            Call.SessionModificationState.REQUEST_REJECTED);
+                } else {
+                    mCall.setSessionModificationState(
+                            Call.SessionModificationState.REQUEST_FAILED);
+                }
+            }
+            InCallVideoCallCallbackNotifier.getInstance().upgradeToVideoFail(status, mCall);
+        } else if (requestedProfile != null && responseProfile != null) {
+            boolean modifySucceeded = requestedProfile.getVideoState() ==
+                    responseProfile.getVideoState();
+            boolean isVideoCall = VideoUtils.isVideoCall(responseProfile.getVideoState());
+            if (modifySucceeded && isVideoCall) {
+                InCallVideoCallCallbackNotifier.getInstance().upgradeToVideoSuccess(mCall);
+            } else if (!modifySucceeded && isVideoCall) {
+                InCallVideoCallCallbackNotifier.getInstance().upgradeToVideoFail(status, mCall);
+            } else if (modifySucceeded && !isVideoCall) {
+                InCallVideoCallCallbackNotifier.getInstance().downgradeToAudio(mCall);
+            }
+        } else {
+            Log.d(this, "onSessionModifyResponseReceived request and response Profiles are null");
+        }
+        // Finally clear the outstanding request.
+        mCall.setSessionModificationState(Call.SessionModificationState.NO_REQUEST);
+    }
+
+    /**
+     * Handles a call session event.
+     *
+     * @param event The event.
+     */
+    @Override
+    public void onCallSessionEvent(int event) {
+        InCallVideoCallCallbackNotifier.getInstance().callSessionEvent(event);
+    }
+
+    /**
+     * Handles a change to the peer video dimensions.
+     *
+     * @param width  The updated peer video width.
+     * @param height The updated peer video height.
+     */
+    @Override
+    public void onPeerDimensionsChanged(int width, int height) {
+        InCallVideoCallCallbackNotifier.getInstance().peerDimensionsChanged(mCall, width, height);
+    }
+
+    /**
+     * Handles a change to the video quality of the call.
+     *
+     * @param videoQuality The updated video call quality.
+     */
+    @Override
+    public void onVideoQualityChanged(int videoQuality) {
+        InCallVideoCallCallbackNotifier.getInstance().videoQualityChanged(mCall, videoQuality);
+    }
+
+    /**
+     * Handles a change to the call data usage.  No implementation as the in-call UI does not
+     * display data usage.
+     *
+     * @param dataUsage The updated data usage.
+     */
+    @Override
+    public void onCallDataUsageChanged(long dataUsage) {
+        Log.d(this, "onCallDataUsageChanged: dataUsage = " + dataUsage);
+        InCallVideoCallCallbackNotifier.getInstance().callDataUsageChanged(dataUsage);
+    }
+
+    /**
+     * Handles changes to the camera capabilities.  No implementation as the in-call UI does not
+     * make use of camera capabilities.
+     *
+     * @param cameraCapabilities The changed camera capabilities.
+     */
+    @Override
+    public void onCameraCapabilitiesChanged(CameraCapabilities cameraCapabilities) {
+        if (cameraCapabilities != null) {
+            InCallVideoCallCallbackNotifier.getInstance().cameraDimensionsChanged(
+                    mCall, cameraCapabilities.getWidth(), cameraCapabilities.getHeight());
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/InCallVideoCallCallbackNotifier.java b/InCallUI/src/com/android/incallui/InCallVideoCallCallbackNotifier.java
new file mode 100644
index 0000000..dfb645b
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/InCallVideoCallCallbackNotifier.java
@@ -0,0 +1,342 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import com.google.common.base.Preconditions;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Class used by {@link InCallService.VideoCallCallback} to notify interested parties of incoming
+ * events.
+ */
+public class InCallVideoCallCallbackNotifier {
+    /**
+     * Singleton instance of this class.
+     */
+    private static InCallVideoCallCallbackNotifier sInstance =
+            new InCallVideoCallCallbackNotifier();
+
+    /**
+     * ConcurrentHashMap constructor params: 8 is initial table size, 0.9f is
+     * load factor before resizing, 1 means we only expect a single thread to
+     * access the map so make only a single shard
+     */
+    private final Set<SessionModificationListener> mSessionModificationListeners =
+            Collections.newSetFromMap(new ConcurrentHashMap<SessionModificationListener, Boolean>
+                    (8, 0.9f, 1));
+    private final Set<VideoEventListener> mVideoEventListeners = Collections.newSetFromMap(
+            new ConcurrentHashMap<VideoEventListener, Boolean>(8, 0.9f, 1));
+    private final Set<SurfaceChangeListener> mSurfaceChangeListeners = Collections.newSetFromMap(
+            new ConcurrentHashMap<SurfaceChangeListener, Boolean>(8, 0.9f, 1));
+
+    /**
+     * Static singleton accessor method.
+     */
+    public static InCallVideoCallCallbackNotifier getInstance() {
+        return sInstance;
+    }
+
+    /**
+     * Private constructor.  Instance should only be acquired through getInstance().
+     */
+    private InCallVideoCallCallbackNotifier() {
+    }
+
+    /**
+     * Adds a new {@link SessionModificationListener}.
+     *
+     * @param listener The listener.
+     */
+    public void addSessionModificationListener(SessionModificationListener listener) {
+        Preconditions.checkNotNull(listener);
+        mSessionModificationListeners.add(listener);
+    }
+
+    /**
+     * Remove a {@link SessionModificationListener}.
+     *
+     * @param listener The listener.
+     */
+    public void removeSessionModificationListener(SessionModificationListener listener) {
+        if (listener != null) {
+            mSessionModificationListeners.remove(listener);
+        }
+    }
+
+    /**
+     * Adds a new {@link VideoEventListener}.
+     *
+     * @param listener The listener.
+     */
+    public void addVideoEventListener(VideoEventListener listener) {
+        Preconditions.checkNotNull(listener);
+        mVideoEventListeners.add(listener);
+    }
+
+    /**
+     * Remove a {@link VideoEventListener}.
+     *
+     * @param listener The listener.
+     */
+    public void removeVideoEventListener(VideoEventListener listener) {
+        if (listener != null) {
+            mVideoEventListeners.remove(listener);
+        }
+    }
+
+    /**
+     * Adds a new {@link SurfaceChangeListener}.
+     *
+     * @param listener The listener.
+     */
+    public void addSurfaceChangeListener(SurfaceChangeListener listener) {
+        Preconditions.checkNotNull(listener);
+        mSurfaceChangeListeners.add(listener);
+    }
+
+    /**
+     * Remove a {@link SurfaceChangeListener}.
+     *
+     * @param listener The listener.
+     */
+    public void removeSurfaceChangeListener(SurfaceChangeListener listener) {
+        if (listener != null) {
+            mSurfaceChangeListeners.remove(listener);
+        }
+    }
+
+    /**
+     * Inform listeners of an upgrade to video request for a call.
+     * @param call The call.
+     * @param videoState The video state we want to upgrade to.
+     */
+    public void upgradeToVideoRequest(Call call, int videoState) {
+        Log.d(this, "upgradeToVideoRequest call = " + call + " new video state = " + videoState);
+        for (SessionModificationListener listener : mSessionModificationListeners) {
+            listener.onUpgradeToVideoRequest(call, videoState);
+        }
+    }
+
+    /**
+     * Inform listeners of a successful response to a video request for a call.
+     *
+     * @param call The call.
+     */
+    public void upgradeToVideoSuccess(Call call) {
+        for (SessionModificationListener listener : mSessionModificationListeners) {
+            listener.onUpgradeToVideoSuccess(call);
+        }
+    }
+
+    /**
+     * Inform listeners of an unsuccessful response to a video request for a call.
+     *
+     * @param call The call.
+     */
+    public void upgradeToVideoFail(int status, Call call) {
+        for (SessionModificationListener listener : mSessionModificationListeners) {
+            listener.onUpgradeToVideoFail(status, call);
+        }
+    }
+
+    /**
+     * Inform listeners of a downgrade to audio.
+     *
+     * @param call The call.
+     */
+    public void downgradeToAudio(Call call) {
+        for (SessionModificationListener listener : mSessionModificationListeners) {
+            listener.onDowngradeToAudio(call);
+        }
+    }
+
+    /**
+     * Inform listeners of a call session event.
+     *
+     * @param event The call session event.
+     */
+    public void callSessionEvent(int event) {
+        for (VideoEventListener listener : mVideoEventListeners) {
+            listener.onCallSessionEvent(event);
+        }
+    }
+
+    /**
+     * Inform listeners of a downgrade to audio.
+     *
+     * @param call The call.
+     * @param paused The paused state.
+     */
+    public void peerPausedStateChanged(Call call, boolean paused) {
+        for (VideoEventListener listener : mVideoEventListeners) {
+            listener.onPeerPauseStateChanged(call, paused);
+        }
+    }
+
+    /**
+     * Inform listeners of any change in the video quality of the call
+     *
+     * @param call The call.
+     * @param videoQuality The updated video quality of the call.
+     */
+    public void videoQualityChanged(Call call, int videoQuality) {
+        for (VideoEventListener listener : mVideoEventListeners) {
+            listener.onVideoQualityChanged(call, videoQuality);
+        }
+    }
+
+    /**
+     * Inform listeners of a change to peer dimensions.
+     *
+     * @param call The call.
+     * @param width New peer width.
+     * @param height New peer height.
+     */
+    public void peerDimensionsChanged(Call call, int width, int height) {
+        for (SurfaceChangeListener listener : mSurfaceChangeListeners) {
+            listener.onUpdatePeerDimensions(call, width, height);
+        }
+    }
+
+    /**
+     * Inform listeners of a change to camera dimensions.
+     *
+     * @param call The call.
+     * @param width The new camera video width.
+     * @param height The new camera video height.
+     */
+    public void cameraDimensionsChanged(Call call, int width, int height) {
+        for (SurfaceChangeListener listener : mSurfaceChangeListeners) {
+            listener.onCameraDimensionsChange(call, width, height);
+        }
+    }
+
+    /**
+     * Inform listeners of a change to call data usage.
+     *
+     * @param dataUsage data usage value
+     */
+    public void callDataUsageChanged(long dataUsage) {
+        for (VideoEventListener listener : mVideoEventListeners) {
+            listener.onCallDataUsageChange(dataUsage);
+        }
+    }
+
+    /**
+     * Listener interface for any class that wants to be notified of upgrade to video and downgrade
+     * to audio session modification requests.
+     */
+    public interface SessionModificationListener {
+        /**
+         * Called when a peer request is received to upgrade an audio-only call to a video call.
+         *
+         * @param call The call the request was received for.
+         * @param videoState The video state that the request wants to upgrade to.
+         */
+        public void onUpgradeToVideoRequest(Call call, int videoState);
+
+        /**
+         * Called when a request to a peer to upgrade an audio-only call to a video call is
+         * successful.
+         *
+         * @param call The call the request was successful for.
+         */
+        public void onUpgradeToVideoSuccess(Call call);
+
+        /**
+         * Called when a request to a peer to upgrade an audio-only call to a video call is
+         * NOT successful. This can be if the peer chooses rejects the the video call, or if the
+         * peer does not support video calling, or if there is some error in sending the request.
+         *
+         * @param call The call the request was successful for.
+         */
+        public void onUpgradeToVideoFail(int status, Call call);
+
+        /**
+         * Called when a call has been downgraded to audio-only.
+         *
+         * @param call The call which was downgraded to audio-only.
+         */
+        public void onDowngradeToAudio(Call call);
+    }
+
+    /**
+     * Listener interface for any class that wants to be notified of video events, including pause
+     * and un-pause of peer video, video quality changes.
+     */
+    public interface VideoEventListener {
+        /**
+         * Called when the peer pauses or un-pauses video transmission.
+         *
+         * @param call   The call which paused or un-paused video transmission.
+         * @param paused {@code True} when the video transmission is paused, {@code false}
+         *               otherwise.
+         */
+        public void onPeerPauseStateChanged(Call call, boolean paused);
+
+        /**
+         * Called when the video quality changes.
+         *
+         * @param call   The call whose video quality changes.
+         * @param videoCallQuality - values are QUALITY_HIGH, MEDIUM, LOW and UNKNOWN.
+         */
+        public void onVideoQualityChanged(Call call, int videoCallQuality);
+
+        /*
+         * Called when call data usage value is requested or when call data usage value is updated
+         * because of a call state change
+         *
+         * @param dataUsage call data usage value
+         */
+        public void onCallDataUsageChange(long dataUsage);
+
+        /**
+         * Called when call session event is raised.
+         *
+         * @param event The call session event.
+         */
+        public void onCallSessionEvent(int event);
+    }
+
+    /**
+     * Listener interface for any class that wants to be notified of changes to the video surfaces.
+     */
+    public interface SurfaceChangeListener {
+        /**
+         * Called when the peer video feed changes dimensions. This can occur when the peer rotates
+         * their device, changing the aspect ratio of the video signal.
+         *
+         * @param call The call which experienced a peer video
+         * @param width
+         * @param height
+         */
+        public void onUpdatePeerDimensions(Call call, int width, int height);
+
+        /**
+         * Called when the local camera changes dimensions.  This occurs when a change in camera
+         * occurs.
+         *
+         * @param call The call which experienced the camera dimension change.
+         * @param width The new camera video width.
+         * @param height The new camera video height.
+         */
+        public void onCameraDimensionsChange(Call call, int width, int height);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/Log.java b/InCallUI/src/com/android/incallui/Log.java
new file mode 100644
index 0000000..07a0e61
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/Log.java
@@ -0,0 +1,176 @@
+/*
+ * 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.
+ */
+
+package com.android.incallui;
+
+import android.net.Uri;
+import android.telecom.PhoneAccount;
+import android.telephony.PhoneNumberUtils;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+/**
+ * Manages logging for the entire class.
+ */
+public class Log {
+
+    // Generic tag for all In Call logging
+    public static final String TAG = "InCall";
+
+    public static final boolean FORCE_DEBUG = false; /* STOPSHIP if true */
+    public static final boolean DEBUG = FORCE_DEBUG ||
+            android.util.Log.isLoggable(TAG, android.util.Log.DEBUG);
+    public static final boolean VERBOSE = FORCE_DEBUG ||
+            android.util.Log.isLoggable(TAG, android.util.Log.VERBOSE);
+    public static final String TAG_DELIMETER = " - ";
+
+    public static void d(String tag, String msg) {
+        if (DEBUG) {
+            android.util.Log.d(TAG, delimit(tag) + msg);
+        }
+    }
+
+    public static void d(Object obj, String msg) {
+        if (DEBUG) {
+            android.util.Log.d(TAG, getPrefix(obj) + msg);
+        }
+    }
+
+    public static void d(Object obj, String str1, Object str2) {
+        if (DEBUG) {
+            android.util.Log.d(TAG, getPrefix(obj) + str1 + str2);
+        }
+    }
+
+    public static void v(Object obj, String msg) {
+        if (VERBOSE) {
+            android.util.Log.v(TAG, getPrefix(obj) + msg);
+        }
+    }
+
+    public static void v(Object obj, String str1, Object str2) {
+        if (VERBOSE) {
+            android.util.Log.d(TAG, getPrefix(obj) + str1 + str2);
+        }
+    }
+
+    public static void e(String tag, String msg, Exception e) {
+        android.util.Log.e(TAG, delimit(tag) + msg, e);
+    }
+
+    public static void e(String tag, String msg) {
+        android.util.Log.e(TAG, delimit(tag) + msg);
+    }
+
+    public static void e(Object obj, String msg, Exception e) {
+        android.util.Log.e(TAG, getPrefix(obj) + msg, e);
+    }
+
+    public static void e(Object obj, String msg) {
+        android.util.Log.e(TAG, getPrefix(obj) + msg);
+    }
+
+    public static void i(String tag, String msg) {
+        android.util.Log.i(TAG, delimit(tag) + msg);
+    }
+
+    public static void i(Object obj, String msg) {
+        android.util.Log.i(TAG, getPrefix(obj) + msg);
+    }
+
+    public static void w(Object obj, String msg) {
+        android.util.Log.w(TAG, getPrefix(obj) + msg);
+    }
+
+    public static void wtf(Object obj, String msg) {
+        android.util.Log.wtf(TAG, getPrefix(obj) + msg);
+    }
+
+    public static String piiHandle(Object pii) {
+        if (pii == null || VERBOSE) {
+            return String.valueOf(pii);
+        }
+
+        if (pii instanceof Uri) {
+            Uri uri = (Uri) pii;
+
+            // All Uri's which are not "tel" go through normal pii() method.
+            if (!PhoneAccount.SCHEME_TEL.equals(uri.getScheme())) {
+                return pii(pii);
+            } else {
+                pii = uri.getSchemeSpecificPart();
+            }
+        }
+
+        String originalString = String.valueOf(pii);
+        StringBuilder stringBuilder = new StringBuilder(originalString.length());
+        for (char c : originalString.toCharArray()) {
+            if (PhoneNumberUtils.isDialable(c)) {
+                stringBuilder.append('*');
+            } else {
+                stringBuilder.append(c);
+            }
+        }
+        return stringBuilder.toString();
+    }
+
+    /**
+     * Redact personally identifiable information for production users.
+     * If we are running in verbose mode, return the original string, otherwise
+     * return a SHA-1 hash of the input string.
+     */
+    public static String pii(Object pii) {
+        if (pii == null || VERBOSE) {
+            return String.valueOf(pii);
+        }
+        return "[" + secureHash(String.valueOf(pii).getBytes()) + "]";
+    }
+
+    private static String secureHash(byte[] input) {
+        MessageDigest messageDigest;
+        try {
+            messageDigest = MessageDigest.getInstance("SHA-1");
+        } catch (NoSuchAlgorithmException e) {
+            return null;
+        }
+        messageDigest.update(input);
+        byte[] result = messageDigest.digest();
+        return encodeHex(result);
+    }
+
+    private static String encodeHex(byte[] bytes) {
+        StringBuffer hex = new StringBuffer(bytes.length * 2);
+
+        for (int i = 0; i < bytes.length; i++) {
+            int byteIntValue = bytes[i] & 0xff;
+            if (byteIntValue < 0x10) {
+                hex.append("0");
+            }
+            hex.append(Integer.toString(byteIntValue, 16));
+        }
+
+        return hex.toString();
+    }
+
+    private static String getPrefix(Object obj) {
+        return (obj == null ? "" : (obj.getClass().getSimpleName() + TAG_DELIMETER));
+    }
+
+    private static String delimit(String tag) {
+        return tag + TAG_DELIMETER;
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/NeededForReflection.java b/InCallUI/src/com/android/incallui/NeededForReflection.java
new file mode 100644
index 0000000..363a0a5
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/NeededForReflection.java
@@ -0,0 +1,30 @@
+/*
+ * 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.
+ */
+
+package com.android.incallui;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Denotes that the class, constructor, method or field is used for reflection and therefore cannot
+ * be removed by tools like ProGuard.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.TYPE, ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.FIELD})
+public @interface NeededForReflection {}
diff --git a/InCallUI/src/com/android/incallui/NotificationBroadcastReceiver.java b/InCallUI/src/com/android/incallui/NotificationBroadcastReceiver.java
new file mode 100644
index 0000000..2543b78
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/NotificationBroadcastReceiver.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.telecom.VideoProfile;
+
+/**
+ * Accepts broadcast Intents which will be prepared by {@link StatusBarNotifier} and thus
+ * sent from the notification manager.
+ * This should be visible from outside, but shouldn't be exported.
+ */
+public class NotificationBroadcastReceiver extends BroadcastReceiver {
+
+    /**
+     * Intent Action used for hanging up the current call from Notification bar. This will
+     * choose first ringing call, first active call, or first background call (typically in
+     * STATE_HOLDING state).
+     */
+    public static final String ACTION_DECLINE_INCOMING_CALL =
+            "com.android.incallui.ACTION_DECLINE_INCOMING_CALL";
+    public static final String ACTION_HANG_UP_ONGOING_CALL =
+            "com.android.incallui.ACTION_HANG_UP_ONGOING_CALL";
+    public static final String ACTION_ANSWER_VIDEO_INCOMING_CALL =
+            "com.android.incallui.ACTION_ANSWER_VIDEO_INCOMING_CALL";
+    public static final String ACTION_ANSWER_VOICE_INCOMING_CALL =
+            "com.android.incallui.ACTION_ANSWER_VOICE_INCOMING_CALL";
+    public static final String ACTION_ACCEPT_VIDEO_UPGRADE_REQUEST =
+            "com.android.incallui.ACTION_ACCEPT_VIDEO_UPGRADE_REQUEST";
+    public static final String ACTION_DECLINE_VIDEO_UPGRADE_REQUEST =
+            "com.android.incallui.ACTION_DECLINE_VIDEO_UPGRADE_REQUEST";
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        final String action = intent.getAction();
+        Log.i(this, "Broadcast from Notification: " + action);
+
+        // TODO: Commands of this nature should exist in the CallList.
+        if (action.equals(ACTION_ANSWER_VIDEO_INCOMING_CALL)) {
+            InCallPresenter.getInstance().answerIncomingCall(
+                    context, VideoProfile.STATE_BIDIRECTIONAL);
+        } else if (action.equals(ACTION_ANSWER_VOICE_INCOMING_CALL)) {
+            InCallPresenter.getInstance().answerIncomingCall(
+                    context, VideoProfile.STATE_AUDIO_ONLY);
+        } else if (action.equals(ACTION_DECLINE_INCOMING_CALL)) {
+            InCallPresenter.getInstance().declineIncomingCall(context);
+        } else if (action.equals(ACTION_HANG_UP_ONGOING_CALL)) {
+            InCallPresenter.getInstance().hangUpOngoingCall(context);
+        } else if (action.equals(ACTION_ACCEPT_VIDEO_UPGRADE_REQUEST)) {
+            //TODO: Change calltype after adding support for TX and RX
+            InCallPresenter.getInstance().acceptUpgradeRequest(
+                    VideoProfile.STATE_BIDIRECTIONAL, context);
+        } else if (action.equals(ACTION_DECLINE_VIDEO_UPGRADE_REQUEST)) {
+            InCallPresenter.getInstance().declineUpgradeRequest(context);
+        }
+    }
+
+}
diff --git a/InCallUI/src/com/android/incallui/PostCharDialogFragment.java b/InCallUI/src/com/android/incallui/PostCharDialogFragment.java
new file mode 100644
index 0000000..400e8d7
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/PostCharDialogFragment.java
@@ -0,0 +1,93 @@
+/*
+ * 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.
+ */
+
+package com.android.incallui;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.DialogFragment;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.view.WindowManager;
+
+/**
+ * Pop up an alert dialog with OK and Cancel buttons to allow user to Accept or Reject the WAIT
+ * inserted as part of the Dial string.
+ */
+public class PostCharDialogFragment extends DialogFragment {
+
+    private static final String STATE_CALL_ID = "CALL_ID";
+    private static final String STATE_POST_CHARS = "POST_CHARS";
+
+    private String mCallId;
+    private String mPostDialStr;
+
+    public PostCharDialogFragment() {
+    }
+
+    public PostCharDialogFragment(String callId, String postDialStr) {
+        mCallId = callId;
+        mPostDialStr = postDialStr;
+    }
+
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        super.onCreateDialog(savedInstanceState);
+
+        if (mPostDialStr == null && savedInstanceState != null) {
+            mCallId = savedInstanceState.getString(STATE_CALL_ID);
+            mPostDialStr = savedInstanceState.getString(STATE_POST_CHARS);
+        }
+
+        final StringBuilder buf = new StringBuilder();
+        buf.append(getResources().getText(R.string.wait_prompt_str));
+        buf.append(mPostDialStr);
+
+        final AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+        builder.setMessage(buf.toString());
+
+        builder.setPositiveButton(R.string.pause_prompt_yes, new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(DialogInterface dialog, int whichButton) {
+                TelecomAdapter.getInstance().postDialContinue(mCallId, true);
+            }
+        });
+        builder.setNegativeButton(R.string.pause_prompt_no, new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(DialogInterface dialog, int whichButton) {
+                dialog.cancel();
+            }
+        });
+
+        final AlertDialog dialog = builder.create();
+        return dialog;
+    }
+
+    @Override
+    public void onCancel(DialogInterface dialog) {
+        super.onCancel(dialog);
+
+        TelecomAdapter.getInstance().postDialContinue(mCallId, false);
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+
+        outState.putString(STATE_CALL_ID, mCallId);
+        outState.putString(STATE_POST_CHARS, mPostDialStr);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/Presenter.java b/InCallUI/src/com/android/incallui/Presenter.java
new file mode 100644
index 0000000..4e1fa97
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/Presenter.java
@@ -0,0 +1,59 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.os.Bundle;
+
+/**
+ * Base class for Presenters.
+ */
+public abstract class Presenter<U extends Ui> {
+
+    private U mUi;
+
+    /**
+     * Called after the UI view has been created.  That is when fragment.onViewCreated() is called.
+     *
+     * @param ui The Ui implementation that is now ready to be used.
+     */
+    public void onUiReady(U ui) {
+        mUi = ui;
+    }
+
+    /**
+     * Called when the UI view is destroyed in Fragment.onDestroyView().
+     */
+    public final void onUiDestroy(U ui) {
+        onUiUnready(ui);
+        mUi = null;
+    }
+
+    /**
+     * To be overriden by Presenter implementations.  Called when the fragment is being
+     * destroyed but before ui is set to null.
+     */
+    public void onUiUnready(U ui) {
+    }
+
+    public void onSaveInstanceState(Bundle outState) {}
+
+    public void onRestoreInstanceState(Bundle savedInstanceState) {}
+
+    public U getUi() {
+        return mUi;
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/ProximitySensor.java b/InCallUI/src/com/android/incallui/ProximitySensor.java
new file mode 100644
index 0000000..733a67d
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ProximitySensor.java
@@ -0,0 +1,317 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import com.google.common.base.Objects;
+
+import android.content.Context;
+import android.content.res.Configuration;
+import android.hardware.display.DisplayManager;
+import android.hardware.display.DisplayManager.DisplayListener;
+import android.os.PowerManager;
+import android.view.Display;
+
+import com.android.dialer.compat.CallAudioStateCompat;
+import com.android.incallui.AudioModeProvider.AudioModeListener;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+
+/**
+ * Class manages the proximity sensor for the in-call UI.
+ * We enable the proximity sensor while the user in a phone call. The Proximity sensor turns off
+ * the touchscreen and display when the user is close to the screen to prevent user's cheek from
+ * causing touch events.
+ * The class requires special knowledge of the activity and device state to know when the proximity
+ * sensor should be enabled and disabled. Most of that state is fed into this class through
+ * public methods.
+ */
+public class ProximitySensor implements AccelerometerListener.OrientationListener,
+        InCallStateListener, AudioModeListener {
+    private static final String TAG = ProximitySensor.class.getSimpleName();
+
+    private final PowerManager mPowerManager;
+    private final PowerManager.WakeLock mProximityWakeLock;
+    private final AudioModeProvider mAudioModeProvider;
+    private final AccelerometerListener mAccelerometerListener;
+    private final ProximityDisplayListener mDisplayListener;
+    private int mOrientation = AccelerometerListener.ORIENTATION_UNKNOWN;
+    private boolean mUiShowing = false;
+    private boolean mIsPhoneOffhook = false;
+    private boolean mDialpadVisible;
+
+    // True if the keyboard is currently *not* hidden
+    // Gets updated whenever there is a Configuration change
+    private boolean mIsHardKeyboardOpen;
+
+    public ProximitySensor(Context context, AudioModeProvider audioModeProvider,
+            AccelerometerListener accelerometerListener) {
+        mPowerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+        if (mPowerManager.isWakeLockLevelSupported(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK)) {
+            mProximityWakeLock = mPowerManager.newWakeLock(
+                    PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK, TAG);
+        } else {
+            Log.w(TAG, "Device does not support proximity wake lock.");
+            mProximityWakeLock = null;
+        }
+        mAccelerometerListener = accelerometerListener;
+        mAccelerometerListener.setListener(this);
+
+        mDisplayListener = new ProximityDisplayListener(
+                (DisplayManager) context.getSystemService(Context.DISPLAY_SERVICE));
+        mDisplayListener.register();
+
+        mAudioModeProvider = audioModeProvider;
+        mAudioModeProvider.addListener(this);
+    }
+
+    public void tearDown() {
+        mAudioModeProvider.removeListener(this);
+
+        mAccelerometerListener.enable(false);
+        mDisplayListener.unregister();
+
+        turnOffProximitySensor(true);
+    }
+
+    /**
+     * Called to identify when the device is laid down flat.
+     */
+    @Override
+    public void orientationChanged(int orientation) {
+        mOrientation = orientation;
+        updateProximitySensorMode();
+    }
+
+    /**
+     * Called to keep track of the overall UI state.
+     */
+    @Override
+    public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+        // We ignore incoming state because we do not want to enable proximity
+        // sensor during incoming call screen. We check hasLiveCall() because a disconnected call
+        // can also put the in-call screen in the INCALL state.
+        boolean hasOngoingCall = InCallState.INCALL == newState && callList.hasLiveCall();
+        boolean isOffhook = (InCallState.OUTGOING == newState) || hasOngoingCall;
+
+        if (isOffhook != mIsPhoneOffhook) {
+            mIsPhoneOffhook = isOffhook;
+
+            mOrientation = AccelerometerListener.ORIENTATION_UNKNOWN;
+            mAccelerometerListener.enable(mIsPhoneOffhook);
+
+            updateProximitySensorMode();
+        }
+    }
+
+    @Override
+    public void onSupportedAudioMode(int modeMask) {
+    }
+
+    @Override
+    public void onMute(boolean muted) {
+    }
+
+    /**
+     * Called when the audio mode changes during a call.
+     */
+    @Override
+    public void onAudioMode(int mode) {
+        updateProximitySensorMode();
+    }
+
+    public void onDialpadVisible(boolean visible) {
+        mDialpadVisible = visible;
+        updateProximitySensorMode();
+    }
+
+    /**
+     * Called by InCallActivity to listen for hard keyboard events.
+     */
+    public void onConfigurationChanged(Configuration newConfig) {
+        mIsHardKeyboardOpen = newConfig.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_NO;
+
+        // Update the Proximity sensor based on keyboard state
+        updateProximitySensorMode();
+    }
+
+    /**
+     * Used to save when the UI goes in and out of the foreground.
+     */
+    public void onInCallShowing(boolean showing) {
+        if (showing) {
+            mUiShowing = true;
+
+        // We only consider the UI not showing for instances where another app took the foreground.
+        // If we stopped showing because the screen is off, we still consider that showing.
+        } else if (mPowerManager.isScreenOn()) {
+            mUiShowing = false;
+        }
+        updateProximitySensorMode();
+    }
+
+    void onDisplayStateChanged(boolean isDisplayOn) {
+        Log.i(this, "isDisplayOn: " + isDisplayOn);
+        mAccelerometerListener.enable(isDisplayOn);
+    }
+
+    /**
+     * TODO: There is no way to determine if a screen is off due to proximity or if it is
+     * legitimately off, but if ever we can do that in the future, it would be useful here.
+     * Until then, this function will simply return true of the screen is off.
+     * TODO: Investigate whether this can be replaced with the ProximityDisplayListener.
+     */
+    public boolean isScreenReallyOff() {
+        return !mPowerManager.isScreenOn();
+    }
+
+    private void turnOnProximitySensor() {
+        if (mProximityWakeLock != null) {
+            if (!mProximityWakeLock.isHeld()) {
+                Log.i(this, "Acquiring proximity wake lock");
+                mProximityWakeLock.acquire();
+            } else {
+                Log.i(this, "Proximity wake lock already acquired");
+            }
+        }
+    }
+
+    private void turnOffProximitySensor(boolean screenOnImmediately) {
+        if (mProximityWakeLock != null) {
+            if (mProximityWakeLock.isHeld()) {
+                Log.i(this, "Releasing proximity wake lock");
+                int flags =
+                    (screenOnImmediately ? 0 : PowerManager.RELEASE_FLAG_WAIT_FOR_NO_PROXIMITY);
+                mProximityWakeLock.release(flags);
+            } else {
+                Log.i(this, "Proximity wake lock already released");
+            }
+        }
+    }
+
+    /**
+     * Updates the wake lock used to control proximity sensor behavior,
+     * based on the current state of the phone.
+     *
+     * On devices that have a proximity sensor, to avoid false touches
+     * during a call, we hold a PROXIMITY_SCREEN_OFF_WAKE_LOCK wake lock
+     * whenever the phone is off hook.  (When held, that wake lock causes
+     * the screen to turn off automatically when the sensor detects an
+     * object close to the screen.)
+     *
+     * This method is a no-op for devices that don't have a proximity
+     * sensor.
+     *
+     * Proximity wake lock will *not* be held if any one of the
+     * conditions is true while on a call:
+     * 1) If the audio is routed via Bluetooth
+     * 2) If a wired headset is connected
+     * 3) if the speaker is ON
+     * 4) If the slider is open(i.e. the hardkeyboard is *not* hidden)
+     */
+    private synchronized void updateProximitySensorMode() {
+        final int audioMode = mAudioModeProvider.getAudioMode();
+
+        // turn proximity sensor off and turn screen on immediately if
+        // we are using a headset, the keyboard is open, or the device
+        // is being held in a horizontal position.
+            boolean screenOnImmediately = (CallAudioStateCompat.ROUTE_WIRED_HEADSET == audioMode
+                    || CallAudioStateCompat.ROUTE_SPEAKER == audioMode
+                    || CallAudioStateCompat.ROUTE_BLUETOOTH == audioMode
+                    || mIsHardKeyboardOpen);
+
+            // We do not keep the screen off when the user is outside in-call screen and we are
+            // horizontal, but we do not force it on when we become horizontal until the
+            // proximity sensor goes negative.
+            final boolean horizontal =
+                    (mOrientation == AccelerometerListener.ORIENTATION_HORIZONTAL);
+            screenOnImmediately |= !mUiShowing && horizontal;
+
+            // We do not keep the screen off when dialpad is visible, we are horizontal, and
+            // the in-call screen is being shown.
+            // At that moment we're pretty sure users want to use it, instead of letting the
+            // proximity sensor turn off the screen by their hands.
+            screenOnImmediately |= mDialpadVisible && horizontal;
+
+            Log.v(this, "screenonImmediately: ", screenOnImmediately);
+
+            Log.i(this, Objects.toStringHelper(this)
+                    .add("keybrd", mIsHardKeyboardOpen ? 1 : 0)
+                    .add("dpad", mDialpadVisible ? 1 : 0)
+                    .add("offhook", mIsPhoneOffhook ? 1 : 0)
+                    .add("hor", horizontal ? 1 : 0)
+                    .add("ui", mUiShowing ? 1 : 0)
+                    .add("aud", CallAudioStateCompat.audioRouteToString(audioMode))
+                    .toString());
+
+            if (mIsPhoneOffhook && !screenOnImmediately) {
+                Log.d(this, "Turning on proximity sensor");
+                // Phone is in use!  Arrange for the screen to turn off
+                // automatically when the sensor detects a close object.
+                turnOnProximitySensor();
+            } else {
+                Log.d(this, "Turning off proximity sensor");
+                // Phone is either idle, or ringing.  We don't want any special proximity sensor
+                // behavior in either case.
+                turnOffProximitySensor(screenOnImmediately);
+            }
+        }
+
+    /**
+     * Implementation of a {@link DisplayListener} that maintains a binary state:
+     * Screen on vs screen off. Used by the proximity sensor manager to decide whether or not
+     * it needs to listen to accelerometer events.
+     */
+    public class ProximityDisplayListener implements DisplayListener {
+        private DisplayManager mDisplayManager;
+        private boolean mIsDisplayOn = true;
+
+        ProximityDisplayListener(DisplayManager displayManager) {
+            mDisplayManager = displayManager;
+        }
+
+        void register() {
+            mDisplayManager.registerDisplayListener(this, null);
+        }
+
+        void unregister() {
+            mDisplayManager.unregisterDisplayListener(this);
+        }
+
+        @Override
+        public void onDisplayRemoved(int displayId) {
+        }
+
+        @Override
+        public void onDisplayChanged(int displayId) {
+            if (displayId == Display.DEFAULT_DISPLAY) {
+                final Display display = mDisplayManager.getDisplay(displayId);
+
+                final boolean isDisplayOn = display.getState() != Display.STATE_OFF;
+                // For call purposes, we assume that as long as the screen is not truly off, it is
+                // considered on, even if it is in an unknown or low power idle state.
+                if (isDisplayOn != mIsDisplayOn) {
+                    mIsDisplayOn = isDisplayOn;
+                    onDisplayStateChanged(mIsDisplayOn);
+                }
+            }
+        }
+
+        @Override
+        public void onDisplayAdded(int displayId) {
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/StatusBarNotifier.java b/InCallUI/src/com/android/incallui/StatusBarNotifier.java
new file mode 100644
index 0000000..6c00164
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/StatusBarNotifier.java
@@ -0,0 +1,743 @@
+/*
+ * 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.
+ */
+
+package com.android.incallui;
+
+import static com.android.contacts.common.compat.CallSdkCompat.Details.PROPERTY_WORK_CALL;
+import static com.android.incallui.NotificationBroadcastReceiver.ACTION_ACCEPT_VIDEO_UPGRADE_REQUEST;
+import static com.android.incallui.NotificationBroadcastReceiver.ACTION_ANSWER_VIDEO_INCOMING_CALL;
+import static com.android.incallui.NotificationBroadcastReceiver.ACTION_ANSWER_VOICE_INCOMING_CALL;
+import static com.android.incallui.NotificationBroadcastReceiver.ACTION_DECLINE_INCOMING_CALL;
+import static com.android.incallui.NotificationBroadcastReceiver.ACTION_DECLINE_VIDEO_UPGRADE_REQUEST;
+import static com.android.incallui.NotificationBroadcastReceiver.ACTION_HANG_UP_ONGOING_CALL;
+
+import com.google.common.base.Preconditions;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.BitmapDrawable;
+import android.media.AudioAttributes;
+import android.net.Uri;
+import android.support.annotation.Nullable;
+import android.telecom.Call.Details;
+import android.telecom.PhoneAccount;
+import android.telecom.TelecomManager;
+import android.text.BidiFormatter;
+import android.text.TextDirectionHeuristics;
+import android.text.TextUtils;
+
+import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.ContactsUtils.UserType;
+import com.android.contacts.common.preference.ContactsPreferences;
+import com.android.contacts.common.testing.NeededForTesting;
+import com.android.contacts.common.util.BitmapUtil;
+import com.android.contacts.common.util.ContactDisplayUtils;
+import com.android.incallui.Call.State;
+import com.android.incallui.ContactInfoCache.ContactCacheEntry;
+import com.android.incallui.ContactInfoCache.ContactInfoCacheCallback;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.async.PausableExecutorImpl;
+import com.android.incallui.ringtone.DialerRingtoneManager;
+import com.android.incallui.ringtone.InCallTonePlayer;
+import com.android.incallui.ringtone.ToneGeneratorFactory;
+
+import java.util.Objects;
+
+/**
+ * This class adds Notifications to the status bar for the in-call experience.
+ */
+public class StatusBarNotifier implements InCallPresenter.InCallStateListener,
+        CallList.CallUpdateListener {
+
+    // Notification types
+    // Indicates that no notification is currently showing.
+    private static final int NOTIFICATION_NONE = 0;
+    // Notification for an active call. This is non-interruptive, but cannot be dismissed.
+    private static final int NOTIFICATION_IN_CALL = 1;
+    // Notification for incoming calls. This is interruptive and will show up as a HUN.
+    private static final int NOTIFICATION_INCOMING_CALL = 2;
+
+    private static final long[] VIBRATE_PATTERN = new long[] {0, 1000, 1000};
+
+    private final Context mContext;
+    @Nullable private ContactsPreferences mContactsPreferences;
+    private final ContactInfoCache mContactInfoCache;
+    private final NotificationManager mNotificationManager;
+    private final DialerRingtoneManager mDialerRingtoneManager;
+    private int mCurrentNotification = NOTIFICATION_NONE;
+    private int mCallState = Call.State.INVALID;
+    private int mSavedIcon = 0;
+    private String mSavedContent = null;
+    private Bitmap mSavedLargeIcon;
+    private String mSavedContentTitle;
+    private String mCallId = null;
+    private InCallState mInCallState;
+    private Uri mRingtone;
+
+    public StatusBarNotifier(Context context, ContactInfoCache contactInfoCache) {
+        Preconditions.checkNotNull(context);
+        mContext = context;
+        mContactsPreferences = ContactsPreferencesFactory.newContactsPreferences(mContext);
+        mContactInfoCache = contactInfoCache;
+        mNotificationManager =
+                (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
+        mDialerRingtoneManager = new DialerRingtoneManager(
+                new InCallTonePlayer(
+                        AudioModeProvider.getInstance(),
+                        new ToneGeneratorFactory(),
+                        new PausableExecutorImpl()),
+                CallList.getInstance());
+        mCurrentNotification = NOTIFICATION_NONE;
+    }
+
+    /**
+     * Creates notifications according to the state we receive from {@link InCallPresenter}.
+     */
+    @Override
+    public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+        Log.d(this, "onStateChange");
+        mInCallState = newState;
+        updateNotification(newState, callList);
+    }
+
+    /**
+     * Updates the phone app's status bar notification *and* launches the
+     * incoming call UI in response to a new incoming call.
+     *
+     * If an incoming call is ringing (or call-waiting), the notification
+     * will also include a "fullScreenIntent" that will cause the
+     * InCallScreen to be launched, unless the current foreground activity
+     * is marked as "immersive".
+     *
+     * (This is the mechanism that actually brings up the incoming call UI
+     * when we receive a "new ringing connection" event from the telephony
+     * layer.)
+     *
+     * Also note that this method is safe to call even if the phone isn't
+     * actually ringing (or, more likely, if an incoming call *was*
+     * ringing briefly but then disconnected).  In that case, we'll simply
+     * update or cancel the in-call notification based on the current
+     * phone state.
+     *
+     * @see #updateInCallNotification(InCallState,CallList)
+     */
+    public void updateNotification(InCallState state, CallList callList) {
+        updateInCallNotification(state, callList);
+    }
+
+    /**
+     * Take down the in-call notification.
+     * @see #updateInCallNotification(InCallState,CallList)
+     */
+    private void cancelNotification() {
+        if (!TextUtils.isEmpty(mCallId)) {
+            CallList.getInstance().removeCallUpdateListener(mCallId, this);
+            mCallId = null;
+        }
+        if (mCurrentNotification != NOTIFICATION_NONE) {
+            Log.d(this, "cancelInCall()...");
+            mNotificationManager.cancel(mCurrentNotification);
+        }
+        mCurrentNotification = NOTIFICATION_NONE;
+    }
+
+    /**
+     * Should only be called from a irrecoverable state where it is necessary to dismiss all
+     * notifications.
+     */
+    static void clearAllCallNotifications(Context backupContext) {
+        Log.i(StatusBarNotifier.class.getSimpleName(),
+                "Something terrible happened. Clear all InCall notifications");
+
+        NotificationManager notificationManager =
+                (NotificationManager) backupContext.getSystemService(Context.NOTIFICATION_SERVICE);
+        notificationManager.cancel(NOTIFICATION_IN_CALL);
+        notificationManager.cancel(NOTIFICATION_INCOMING_CALL);
+    }
+
+    /**
+     * Helper method for updateInCallNotification() and
+     * updateNotification(): Update the phone app's
+     * status bar notification based on the current telephony state, or
+     * cancels the notification if the phone is totally idle.
+     */
+    private void updateInCallNotification(final InCallState state, CallList callList) {
+        Log.d(this, "updateInCallNotification...");
+
+        final Call call = getCallToShow(callList);
+
+        if (call != null) {
+            showNotification(call);
+        } else {
+            cancelNotification();
+        }
+    }
+
+    private void showNotification(final Call call) {
+        final boolean isIncoming = (call.getState() == Call.State.INCOMING ||
+                call.getState() == Call.State.CALL_WAITING);
+        if (!TextUtils.isEmpty(mCallId)) {
+            CallList.getInstance().removeCallUpdateListener(mCallId, this);
+        }
+        mCallId = call.getId();
+        CallList.getInstance().addCallUpdateListener(call.getId(), this);
+
+        // we make a call to the contact info cache to query for supplemental data to what the
+        // call provides.  This includes the contact name and photo.
+        // This callback will always get called immediately and synchronously with whatever data
+        // it has available, and may make a subsequent call later (same thread) if it had to
+        // call into the contacts provider for more data.
+        mContactInfoCache.findInfo(call, isIncoming, new ContactInfoCacheCallback() {
+            @Override
+            public void onContactInfoComplete(String callId, ContactCacheEntry entry) {
+                Call call = CallList.getInstance().getCallById(callId);
+                if (call != null) {
+                    call.getLogState().contactLookupResult = entry.contactLookupResult;
+                    buildAndSendNotification(call, entry);
+                }
+            }
+
+            @Override
+            public void onImageLoadComplete(String callId, ContactCacheEntry entry) {
+                Call call = CallList.getInstance().getCallById(callId);
+                if (call != null) {
+                    buildAndSendNotification(call, entry);
+                }
+            }
+
+            @Override
+            public void onContactInteractionsInfoComplete(String callId, ContactCacheEntry entry) {}
+        });
+    }
+
+    /**
+     * Sets up the main Ui for the notification
+     */
+    private void buildAndSendNotification(Call originalCall, ContactCacheEntry contactInfo) {
+
+        // This can get called to update an existing notification after contact information has come
+        // back. However, it can happen much later. Before we continue, we need to make sure that
+        // the call being passed in is still the one we want to show in the notification.
+        final Call call = getCallToShow(CallList.getInstance());
+        if (call == null || !call.getId().equals(originalCall.getId())) {
+            return;
+        }
+
+        final int callState = call.getState();
+
+        // Check if data has changed; if nothing is different, don't issue another notification.
+        final int iconResId = getIconToDisplay(call);
+        Bitmap largeIcon = getLargeIconToDisplay(contactInfo, call);
+        final String content =
+                getContentString(call, contactInfo.userType);
+        final String contentTitle = getContentTitle(contactInfo, call);
+
+        final int notificationType;
+        if (callState == Call.State.INCOMING || callState == Call.State.CALL_WAITING) {
+            notificationType = NOTIFICATION_INCOMING_CALL;
+        } else {
+            notificationType = NOTIFICATION_IN_CALL;
+        }
+
+        if (!checkForChangeAndSaveData(iconResId, content, largeIcon, contentTitle, callState,
+                notificationType, contactInfo.contactRingtoneUri)) {
+            return;
+        }
+
+        if (largeIcon != null) {
+            largeIcon = getRoundedIcon(largeIcon);
+        }
+
+        /*
+         * Nothing more to check...build and send it.
+         */
+        final Notification.Builder builder = getNotificationBuilder();
+
+        // Set up the main intent to send the user to the in-call screen
+        final PendingIntent inCallPendingIntent = createLaunchPendingIntent();
+        builder.setContentIntent(inCallPendingIntent);
+
+        // Set the intent as a full screen intent as well if a call is incoming
+        if (notificationType == NOTIFICATION_INCOMING_CALL
+                && !InCallPresenter.getInstance().isShowingInCallUi()) {
+            configureFullScreenIntent(builder, inCallPendingIntent, call);
+            // Set the notification category for incoming calls
+            builder.setCategory(Notification.CATEGORY_CALL);
+        }
+
+        // Set the content
+        builder.setContentText(content);
+        builder.setSmallIcon(iconResId);
+        builder.setContentTitle(contentTitle);
+        builder.setLargeIcon(largeIcon);
+        builder.setColor(mContext.getResources().getColor(R.color.dialer_theme_color));
+
+        final boolean isVideoUpgradeRequest = call.getSessionModificationState()
+                == Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST;
+        if (isVideoUpgradeRequest) {
+            builder.setUsesChronometer(false);
+            addDismissUpgradeRequestAction(builder);
+            addAcceptUpgradeRequestAction(builder);
+        } else {
+            createIncomingCallNotification(call, callState, builder);
+        }
+
+        addPersonReference(builder, contactInfo, call);
+
+        /*
+         * Fire off the notification
+         */
+        Notification notification = builder.build();
+
+        if (mDialerRingtoneManager.shouldPlayRingtone(callState, contactInfo.contactRingtoneUri)) {
+            notification.flags |= Notification.FLAG_INSISTENT;
+            notification.sound = contactInfo.contactRingtoneUri;
+            AudioAttributes.Builder audioAttributes = new AudioAttributes.Builder();
+            audioAttributes.setContentType(AudioAttributes.CONTENT_TYPE_MUSIC);
+            audioAttributes.setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE);
+            notification.audioAttributes = audioAttributes.build();
+            notification.vibrate = VIBRATE_PATTERN;
+        }
+        if (mDialerRingtoneManager.shouldPlayCallWaitingTone(callState)) {
+            Log.v(this, "Playing call waiting tone");
+            mDialerRingtoneManager.playCallWaitingTone();
+        }
+        if (mCurrentNotification != notificationType && mCurrentNotification != NOTIFICATION_NONE) {
+            Log.i(this, "Previous notification already showing - cancelling "
+                    + mCurrentNotification);
+            mNotificationManager.cancel(mCurrentNotification);
+        }
+        Log.i(this, "Displaying notification for " + notificationType);
+        mNotificationManager.notify(notificationType, notification);
+        mCurrentNotification = notificationType;
+    }
+
+    private void createIncomingCallNotification(
+            Call call, int state, Notification.Builder builder) {
+        if (state == Call.State.ACTIVE) {
+            builder.setUsesChronometer(true);
+            builder.setWhen(call.getConnectTimeMillis());
+        } else {
+            builder.setUsesChronometer(false);
+        }
+
+        // Add hang up option for any active calls (active | onhold), outgoing calls (dialing).
+        if (state == Call.State.ACTIVE ||
+                state == Call.State.ONHOLD ||
+                Call.State.isDialing(state)) {
+            addHangupAction(builder);
+        } else if (state == Call.State.INCOMING || state == Call.State.CALL_WAITING) {
+            addDismissAction(builder);
+            if (call.isVideoCall(mContext)) {
+                addVoiceAction(builder);
+                addVideoCallAction(builder);
+            } else {
+                addAnswerAction(builder);
+            }
+        }
+    }
+
+    /**
+     * Checks the new notification data and compares it against any notification that we
+     * are already displaying. If the data is exactly the same, we return false so that
+     * we do not issue a new notification for the exact same data.
+     */
+    private boolean checkForChangeAndSaveData(int icon, String content, Bitmap largeIcon,
+            String contentTitle, int state, int notificationType, Uri ringtone) {
+
+        // The two are different:
+        // if new title is not null, it should be different from saved version OR
+        // if new title is null, the saved version should not be null
+        final boolean contentTitleChanged =
+                (contentTitle != null && !contentTitle.equals(mSavedContentTitle)) ||
+                (contentTitle == null && mSavedContentTitle != null);
+
+        // any change means we are definitely updating
+        boolean retval = (mSavedIcon != icon) || !Objects.equals(mSavedContent, content)
+                || (mCallState != state) || (mSavedLargeIcon != largeIcon)
+                || contentTitleChanged || !Objects.equals(mRingtone, ringtone);
+
+        // If we aren't showing a notification right now or the notification type is changing,
+        // definitely do an update.
+        if (mCurrentNotification != notificationType) {
+            if (mCurrentNotification == NOTIFICATION_NONE) {
+                Log.d(this, "Showing notification for first time.");
+            }
+            retval = true;
+        }
+
+        mSavedIcon = icon;
+        mSavedContent = content;
+        mCallState = state;
+        mSavedLargeIcon = largeIcon;
+        mSavedContentTitle = contentTitle;
+        mRingtone = ringtone;
+
+        if (retval) {
+            Log.d(this, "Data changed.  Showing notification");
+        }
+
+        return retval;
+    }
+
+    /**
+     * Returns the main string to use in the notification.
+     */
+    @NeededForTesting
+    String getContentTitle(ContactCacheEntry contactInfo, Call call) {
+        if (call.isConferenceCall() && !call.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE)) {
+            return mContext.getResources().getString(R.string.card_title_conf_call);
+        }
+
+        String preferredName = ContactDisplayUtils.getPreferredDisplayName(contactInfo.namePrimary,
+                    contactInfo.nameAlternative, mContactsPreferences);
+        if (TextUtils.isEmpty(preferredName)) {
+            return TextUtils.isEmpty(contactInfo.number) ? null : BidiFormatter.getInstance()
+                    .unicodeWrap(contactInfo.number, TextDirectionHeuristics.LTR);
+        }
+        return preferredName;
+    }
+
+    private void addPersonReference(Notification.Builder builder, ContactCacheEntry contactInfo,
+            Call call) {
+        if (contactInfo.lookupUri != null) {
+            builder.addPerson(contactInfo.lookupUri.toString());
+        } else if (!TextUtils.isEmpty(call.getNumber())) {
+            builder.addPerson(Uri.fromParts(PhoneAccount.SCHEME_TEL,
+                            call.getNumber(), null).toString());
+        }
+    }
+
+    /**
+     * Gets a large icon from the contact info object to display in the notification.
+     */
+    private Bitmap getLargeIconToDisplay(ContactCacheEntry contactInfo, Call call) {
+        Bitmap largeIcon = null;
+        if (call.isConferenceCall() && !call.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE)) {
+            largeIcon = BitmapFactory.decodeResource(mContext.getResources(),
+                    R.drawable.img_conference);
+        }
+        if (contactInfo.photo != null && (contactInfo.photo instanceof BitmapDrawable)) {
+            largeIcon = ((BitmapDrawable) contactInfo.photo).getBitmap();
+        }
+        return largeIcon;
+    }
+
+    private Bitmap getRoundedIcon(Bitmap bitmap) {
+        if (bitmap == null) {
+            return null;
+        }
+        final int height = (int) mContext.getResources().getDimension(
+                android.R.dimen.notification_large_icon_height);
+        final int width = (int) mContext.getResources().getDimension(
+                android.R.dimen.notification_large_icon_width);
+        return BitmapUtil.getRoundedBitmap(bitmap, width, height);
+    }
+
+    /**
+     * Returns the appropriate icon res Id to display based on the call for which
+     * we want to display information.
+     */
+    private int getIconToDisplay(Call call) {
+        // Even if both lines are in use, we only show a single item in
+        // the expanded Notifications UI.  It's labeled "Ongoing call"
+        // (or "On hold" if there's only one call, and it's on hold.)
+        // Also, we don't have room to display caller-id info from two
+        // different calls.  So if both lines are in use, display info
+        // from the foreground call.  And if there's a ringing call,
+        // display that regardless of the state of the other calls.
+        if (call.getState() == Call.State.ONHOLD) {
+            return R.drawable.ic_phone_paused_white_24dp;
+        } else if (call.getSessionModificationState()
+                == Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+            return R.drawable.ic_videocam;
+        }
+        return R.drawable.ic_call_white_24dp;
+    }
+
+    /**
+     * Returns the message to use with the notification.
+     */
+    private String getContentString(Call call, @UserType long userType) {
+        boolean isIncomingOrWaiting = call.getState() == Call.State.INCOMING ||
+                call.getState() == Call.State.CALL_WAITING;
+
+        if (isIncomingOrWaiting &&
+                call.getNumberPresentation() == TelecomManager.PRESENTATION_ALLOWED) {
+
+            if (!TextUtils.isEmpty(call.getChildNumber())) {
+                return mContext.getString(R.string.child_number, call.getChildNumber());
+            } else if (!TextUtils.isEmpty(call.getCallSubject()) && call.isCallSubjectSupported()) {
+                return call.getCallSubject();
+            }
+        }
+
+        int resId = R.string.notification_ongoing_call;
+        if (call.hasProperty(Details.PROPERTY_WIFI)) {
+            resId = R.string.notification_ongoing_call_wifi;
+        }
+
+        if (isIncomingOrWaiting) {
+            if (call.hasProperty(Details.PROPERTY_WIFI)) {
+                resId = R.string.notification_incoming_call_wifi;
+            } else {
+                resId = R.string.notification_incoming_call;
+            }
+        } else if (call.getState() == Call.State.ONHOLD) {
+            resId = R.string.notification_on_hold;
+        } else if (Call.State.isDialing(call.getState())) {
+            resId = R.string.notification_dialing;
+        } else if (call.getSessionModificationState()
+                == Call.SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST) {
+            resId = R.string.notification_requesting_video_call;
+        }
+
+        // Is the call placed through work connection service.
+        boolean isWorkCall = call.hasProperty(PROPERTY_WORK_CALL);
+        if(userType == ContactsUtils.USER_TYPE_WORK || isWorkCall) {
+            resId = getWorkStringFromPersonalString(resId);
+        }
+
+        return mContext.getString(resId);
+    }
+
+    private static int getWorkStringFromPersonalString(int resId) {
+        switch(resId) {
+            case R.string.notification_ongoing_call:
+                return R.string.notification_ongoing_work_call;
+            case R.string.notification_ongoing_call_wifi:
+                return R.string.notification_ongoing_work_call_wifi;
+            case R.string.notification_incoming_call_wifi:
+                return R.string.notification_incoming_work_call_wifi;
+            case R.string.notification_incoming_call:
+                return R.string.notification_incoming_work_call;
+            default:
+                return resId;
+        }
+    }
+
+    /**
+     * Gets the most relevant call to display in the notification.
+     */
+    private Call getCallToShow(CallList callList) {
+        if (callList == null) {
+            return null;
+        }
+        Call call = callList.getIncomingCall();
+        if (call == null) {
+            call = callList.getOutgoingCall();
+        }
+        if (call == null) {
+            call = callList.getVideoUpgradeRequestCall();
+        }
+        if (call == null) {
+            call = callList.getActiveOrBackgroundCall();
+        }
+        return call;
+    }
+
+    private void addAnswerAction(Notification.Builder builder) {
+        Log.d(this, "Will show \"answer\" action in the incoming call Notification");
+
+        PendingIntent answerVoicePendingIntent = createNotificationPendingIntent(
+                mContext, ACTION_ANSWER_VOICE_INCOMING_CALL);
+        builder.addAction(R.drawable.ic_call_white_24dp,
+                mContext.getText(R.string.notification_action_answer),
+                answerVoicePendingIntent);
+    }
+
+    private void addDismissAction(Notification.Builder builder) {
+        Log.d(this, "Will show \"dismiss\" action in the incoming call Notification");
+
+        PendingIntent declinePendingIntent =
+                createNotificationPendingIntent(mContext, ACTION_DECLINE_INCOMING_CALL);
+        builder.addAction(R.drawable.ic_close_dk,
+                mContext.getText(R.string.notification_action_dismiss),
+                declinePendingIntent);
+    }
+
+    private void addHangupAction(Notification.Builder builder) {
+        Log.d(this, "Will show \"hang-up\" action in the ongoing active call Notification");
+
+        PendingIntent hangupPendingIntent =
+                createNotificationPendingIntent(mContext, ACTION_HANG_UP_ONGOING_CALL);
+        builder.addAction(R.drawable.ic_call_end_white_24dp,
+                mContext.getText(R.string.notification_action_end_call),
+                hangupPendingIntent);
+    }
+
+    private void addVideoCallAction(Notification.Builder builder) {
+        Log.i(this, "Will show \"video\" action in the incoming call Notification");
+
+        PendingIntent answerVideoPendingIntent = createNotificationPendingIntent(
+                mContext, ACTION_ANSWER_VIDEO_INCOMING_CALL);
+        builder.addAction(R.drawable.ic_videocam,
+                mContext.getText(R.string.notification_action_answer_video),
+                answerVideoPendingIntent);
+    }
+
+    private void addVoiceAction(Notification.Builder builder) {
+        Log.d(this, "Will show \"voice\" action in the incoming call Notification");
+
+        PendingIntent answerVoicePendingIntent = createNotificationPendingIntent(
+                mContext, ACTION_ANSWER_VOICE_INCOMING_CALL);
+        builder.addAction(R.drawable.ic_call_white_24dp,
+                mContext.getText(R.string.notification_action_answer_voice),
+                answerVoicePendingIntent);
+    }
+
+    private void addAcceptUpgradeRequestAction(Notification.Builder builder) {
+        Log.i(this, "Will show \"accept upgrade\" action in the incoming call Notification");
+
+        PendingIntent acceptVideoPendingIntent = createNotificationPendingIntent(
+                mContext, ACTION_ACCEPT_VIDEO_UPGRADE_REQUEST);
+        builder.addAction(0, mContext.getText(R.string.notification_action_accept),
+                acceptVideoPendingIntent);
+    }
+
+    private void addDismissUpgradeRequestAction(Notification.Builder builder) {
+        Log.i(this, "Will show \"dismiss upgrade\" action in the incoming call Notification");
+
+        PendingIntent declineVideoPendingIntent = createNotificationPendingIntent(
+                mContext, ACTION_DECLINE_VIDEO_UPGRADE_REQUEST);
+        builder.addAction(0, mContext.getText(R.string.notification_action_dismiss),
+                declineVideoPendingIntent);
+    }
+
+    /**
+     * Adds fullscreen intent to the builder.
+     */
+    private void configureFullScreenIntent(Notification.Builder builder, PendingIntent intent,
+            Call call) {
+        // Ok, we actually want to launch the incoming call
+        // UI at this point (in addition to simply posting a notification
+        // to the status bar).  Setting fullScreenIntent will cause
+        // the InCallScreen to be launched immediately *unless* the
+        // current foreground activity is marked as "immersive".
+        Log.d(this, "- Setting fullScreenIntent: " + intent);
+        builder.setFullScreenIntent(intent, true);
+
+        // Ugly hack alert:
+        //
+        // The NotificationManager has the (undocumented) behavior
+        // that it will *ignore* the fullScreenIntent field if you
+        // post a new Notification that matches the ID of one that's
+        // already active.  Unfortunately this is exactly what happens
+        // when you get an incoming call-waiting call:  the
+        // "ongoing call" notification is already visible, so the
+        // InCallScreen won't get launched in this case!
+        // (The result: if you bail out of the in-call UI while on a
+        // call and then get a call-waiting call, the incoming call UI
+        // won't come up automatically.)
+        //
+        // The workaround is to just notice this exact case (this is a
+        // call-waiting call *and* the InCallScreen is not in the
+        // foreground) and manually cancel the in-call notification
+        // before (re)posting it.
+        //
+        // TODO: there should be a cleaner way of avoiding this
+        // problem (see discussion in bug 3184149.)
+
+        // If a call is onhold during an incoming call, the call actually comes in as
+        // INCOMING.  For that case *and* traditional call-waiting, we want to
+        // cancel the notification.
+        boolean isCallWaiting = (call.getState() == Call.State.CALL_WAITING ||
+                (call.getState() == Call.State.INCOMING &&
+                        CallList.getInstance().getBackgroundCall() != null));
+
+        if (isCallWaiting) {
+            Log.i(this, "updateInCallNotification: call-waiting! force relaunch...");
+            // Cancel the IN_CALL_NOTIFICATION immediately before
+            // (re)posting it; this seems to force the
+            // NotificationManager to launch the fullScreenIntent.
+            mNotificationManager.cancel(NOTIFICATION_IN_CALL);
+        }
+    }
+
+    private Notification.Builder getNotificationBuilder() {
+        final Notification.Builder builder = new Notification.Builder(mContext);
+        builder.setOngoing(true);
+
+        // Make the notification prioritized over the other normal notifications.
+        builder.setPriority(Notification.PRIORITY_HIGH);
+
+        return builder;
+    }
+
+    private PendingIntent createLaunchPendingIntent() {
+
+        final Intent intent = InCallPresenter.getInstance().getInCallIntent(
+                false /* showDialpad */, false /* newOutgoingCall */);
+
+        // PendingIntent that can be used to launch the InCallActivity.  The
+        // system fires off this intent if the user pulls down the windowshade
+        // and clicks the notification's expanded view.  It's also used to
+        // launch the InCallActivity immediately when when there's an incoming
+        // call (see the "fullScreenIntent" field below).
+        PendingIntent inCallPendingIntent = PendingIntent.getActivity(mContext, 0, intent, 0);
+
+        return inCallPendingIntent;
+    }
+
+    /**
+     * Returns PendingIntent for answering a phone call. This will typically be used from
+     * Notification context.
+     */
+    private static PendingIntent createNotificationPendingIntent(Context context, String action) {
+        final Intent intent = new Intent(action, null,
+                context, NotificationBroadcastReceiver.class);
+        return PendingIntent.getBroadcast(context, 0, intent, 0);
+    }
+
+    @Override
+    public void onCallChanged(Call call) {
+        if (CallList.getInstance().getIncomingCall() == null) {
+            mDialerRingtoneManager.stopCallWaitingTone();
+        }
+    }
+
+    /**
+     * Responds to changes in the session modification state for the call by dismissing the
+     * status bar notification as required.
+     *
+     * @param sessionModificationState The new session modification state.
+     */
+    @Override
+    public void onSessionModificationStateChange(int sessionModificationState) {
+        if (sessionModificationState == Call.SessionModificationState.NO_REQUEST) {
+            if (mCallId != null) {
+                CallList.getInstance().removeCallUpdateListener(mCallId, this);
+            }
+
+            updateNotification(mInCallState, CallList.getInstance());
+        }
+    }
+
+    @Override
+    public void onLastForwardedNumberChange() {
+        // no-op
+    }
+
+    @Override
+    public void onChildNumberChange() {
+        // no-op
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/TelecomAdapter.java b/InCallUI/src/com/android/incallui/TelecomAdapter.java
new file mode 100644
index 0000000..0fc2e28
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/TelecomAdapter.java
@@ -0,0 +1,228 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import com.google.common.base.Preconditions;
+
+import android.content.ActivityNotFoundException;
+import android.content.Intent;
+import android.os.Looper;
+import android.telecom.InCallService;
+import android.telecom.PhoneAccountHandle;
+
+import com.android.incallui.compat.telecom.DetailsCompat;
+import com.android.incallui.compat.telecom.InCallServiceCompat;
+
+import java.util.List;
+
+final class TelecomAdapter implements InCallServiceListener {
+    private static final String ADD_CALL_MODE_KEY = "add_call_mode";
+
+    private static TelecomAdapter sInstance;
+    private InCallService mInCallService;
+
+    static TelecomAdapter getInstance() {
+        Preconditions.checkState(Looper.getMainLooper().getThread() == Thread.currentThread());
+        if (sInstance == null) {
+            sInstance = new TelecomAdapter();
+        }
+        return sInstance;
+    }
+
+    private TelecomAdapter() {
+    }
+
+    @Override
+    public void setInCallService(InCallService inCallService) {
+        mInCallService = inCallService;
+    }
+
+    @Override
+    public void clearInCallService() {
+        mInCallService = null;
+    }
+
+    private android.telecom.Call getTelecomCallById(String callId) {
+        Call call = CallList.getInstance().getCallById(callId);
+        return call == null ? null : call.getTelecomCall();
+    }
+
+    void answerCall(String callId, int videoState) {
+        android.telecom.Call call = getTelecomCallById(callId);
+        if (call != null) {
+            call.answer(videoState);
+        } else {
+            Log.e(this, "error answerCall, call not in call list: " + callId);
+        }
+    }
+
+    void rejectCall(String callId, boolean rejectWithMessage, String message) {
+        android.telecom.Call call = getTelecomCallById(callId);
+        if (call != null) {
+            call.reject(rejectWithMessage, message);
+        } else {
+            Log.e(this, "error rejectCall, call not in call list: " + callId);
+        }
+    }
+
+    void disconnectCall(String callId) {
+        android.telecom.Call call = getTelecomCallById(callId);
+        if (call != null) {
+            call.disconnect();
+        } else {
+            Log.e(this, "error disconnectCall, call not in call list " + callId);
+        }
+    }
+
+    void holdCall(String callId) {
+        android.telecom.Call call = getTelecomCallById(callId);
+        if (call != null) {
+            call.hold();
+        } else {
+            Log.e(this, "error holdCall, call not in call list " + callId);
+        }
+    }
+
+    void unholdCall(String callId) {
+        android.telecom.Call call = getTelecomCallById(callId);
+        if (call != null) {
+            call.unhold();
+        } else {
+            Log.e(this, "error unholdCall, call not in call list " + callId);
+        }
+    }
+
+    void mute(boolean shouldMute) {
+        if (mInCallService != null) {
+            InCallServiceCompat.setMuted(mInCallService, shouldMute);
+        } else {
+            Log.e(this, "error mute, mInCallService is null");
+        }
+    }
+
+    void setAudioRoute(int route) {
+        if (mInCallService != null) {
+            InCallServiceCompat.setAudioRoute(mInCallService, route);
+        } else {
+            Log.e(this, "error setAudioRoute, mInCallService is null");
+        }
+    }
+
+    void separateCall(String callId) {
+        android.telecom.Call call = getTelecomCallById(callId);
+        if (call != null) {
+            call.splitFromConference();
+        } else {
+            Log.e(this, "error separateCall, call not in call list " + callId);
+        }
+    }
+
+    void merge(String callId) {
+        android.telecom.Call call = getTelecomCallById(callId);
+        if (call != null) {
+            List<android.telecom.Call> conferenceable = call.getConferenceableCalls();
+            if (!conferenceable.isEmpty()) {
+                call.conference(conferenceable.get(0));
+            } else {
+                if (DetailsCompat.can(call.getDetails(),
+                        android.telecom.Call.Details.CAPABILITY_MERGE_CONFERENCE)) {
+                    call.mergeConference();
+                }
+            }
+        } else {
+            Log.e(this, "error merge, call not in call list " + callId);
+        }
+    }
+
+    void swap(String callId) {
+        android.telecom.Call call = getTelecomCallById(callId);
+        if (call != null) {
+            if (DetailsCompat.can(call.getDetails(),
+                    android.telecom.Call.Details.CAPABILITY_SWAP_CONFERENCE)) {
+                call.swapConference();
+            }
+        } else {
+            Log.e(this, "error swap, call not in call list " + callId);
+        }
+    }
+
+    void addCall() {
+        if (mInCallService != null) {
+            Intent intent = new Intent(Intent.ACTION_DIAL);
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+            // when we request the dialer come up, we also want to inform
+            // it that we're going through the "add call" option from the
+            // InCallScreen / PhoneUtils.
+            intent.putExtra(ADD_CALL_MODE_KEY, true);
+            try {
+                Log.d(this, "Sending the add Call intent");
+                mInCallService.startActivity(intent);
+            } catch (ActivityNotFoundException e) {
+                // This is rather rare but possible.
+                // Note: this method is used even when the phone is encrypted. At that moment
+                // the system may not find any Activity which can accept this Intent.
+                Log.e(this, "Activity for adding calls isn't found.", e);
+            }
+        }
+    }
+
+    void playDtmfTone(String callId, char digit) {
+        android.telecom.Call call = getTelecomCallById(callId);
+        if (call != null) {
+            call.playDtmfTone(digit);
+        } else {
+            Log.e(this, "error playDtmfTone, call not in call list " + callId);
+        }
+    }
+
+    void stopDtmfTone(String callId) {
+        android.telecom.Call call = getTelecomCallById(callId);
+        if (call != null) {
+            call.stopDtmfTone();
+        } else {
+            Log.e(this, "error stopDtmfTone, call not in call list " + callId);
+        }
+    }
+
+    void postDialContinue(String callId, boolean proceed) {
+        android.telecom.Call call = getTelecomCallById(callId);
+        if (call != null) {
+            call.postDialContinue(proceed);
+        } else {
+            Log.e(this, "error postDialContinue, call not in call list " + callId);
+        }
+    }
+
+    void phoneAccountSelected(String callId, PhoneAccountHandle accountHandle, boolean setDefault) {
+        if (accountHandle == null) {
+            Log.e(this, "error phoneAccountSelected, accountHandle is null");
+            // TODO: Do we really want to send null accountHandle?
+        }
+
+        android.telecom.Call call = getTelecomCallById(callId);
+        if (call != null) {
+            call.phoneAccountSelected(accountHandle, setDefault);
+        } else {
+            Log.e(this, "error phoneAccountSelected, call not in call list " + callId);
+        }
+    }
+
+    boolean canAddCall(Call call) {
+        return InCallServiceCompat.canAddCall(mInCallService, call);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/Ui.java b/InCallUI/src/com/android/incallui/Ui.java
new file mode 100644
index 0000000..e453ccb
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/Ui.java
@@ -0,0 +1,24 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+/**
+ * Base class for all presenter ui.
+ */
+public interface Ui {
+
+}
diff --git a/InCallUI/src/com/android/incallui/VideoCallFragment.java b/InCallUI/src/com/android/incallui/VideoCallFragment.java
new file mode 100644
index 0000000..2c06303
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/VideoCallFragment.java
@@ -0,0 +1,897 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.graphics.Matrix;
+import android.graphics.Point;
+import android.graphics.SurfaceTexture;
+import android.os.Bundle;
+import android.view.Display;
+import android.view.LayoutInflater;
+import android.view.Surface;
+import android.view.TextureView;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewStub;
+import android.view.ViewTreeObserver;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+
+import com.android.phone.common.animation.AnimUtils;
+import com.google.common.base.Objects;
+
+/**
+ * Fragment containing video calling surfaces.
+ */
+public class VideoCallFragment extends BaseFragment<VideoCallPresenter,
+        VideoCallPresenter.VideoCallUi> implements VideoCallPresenter.VideoCallUi {
+    private static final String TAG = VideoCallFragment.class.getSimpleName();
+    private static final boolean DEBUG = false;
+
+    /**
+     * Used to indicate that the surface dimensions are not set.
+     */
+    private static final int DIMENSIONS_NOT_SET = -1;
+
+    /**
+     * Surface ID for the display surface.
+     */
+    public static final int SURFACE_DISPLAY = 1;
+
+    /**
+     * Surface ID for the preview surface.
+     */
+    public static final int SURFACE_PREVIEW = 2;
+
+    /**
+     * Used to indicate that the UI rotation is unknown.
+     */
+    public static final int ORIENTATION_UNKNOWN = -1;
+
+    // Static storage used to retain the video surfaces across Activity restart.
+    // TextureViews are not parcelable, so it is not possible to store them in the saved state.
+    private static boolean sVideoSurfacesInUse = false;
+    private static VideoCallSurface sPreviewSurface = null;
+    private static VideoCallSurface sDisplaySurface = null;
+    private static Point sDisplaySize = null;
+
+    /**
+     * {@link ViewStub} holding the video call surfaces.  This is the parent for the
+     * {@link VideoCallFragment}.  Used to ensure that the video surfaces are only inflated when
+     * required.
+     */
+    private ViewStub mVideoViewsStub;
+
+    /**
+     * Inflated view containing the video call surfaces represented by the {@link ViewStub}.
+     */
+    private View mVideoViews;
+
+    /**
+     * The {@link FrameLayout} containing the preview surface.
+     */
+    private View mPreviewVideoContainer;
+
+    /**
+     * Icon shown to indicate that the outgoing camera has been turned off.
+     */
+    private View mCameraOff;
+
+    /**
+     * {@link ImageView} containing the user's profile photo.
+     */
+    private ImageView mPreviewPhoto;
+
+    /**
+     * {@code True} when the layout of the activity has been completed.
+     */
+    private boolean mIsLayoutComplete = false;
+
+    /**
+     * {@code True} if in landscape mode.
+     */
+    private boolean mIsLandscape;
+
+    private int mAnimationDuration;
+
+    /**
+     * Inner-class representing a {@link TextureView} and its associated {@link SurfaceTexture} and
+     * {@link Surface}.  Used to manage the lifecycle of these objects across device orientation
+     * changes.
+     */
+    private static class VideoCallSurface implements TextureView.SurfaceTextureListener,
+            View.OnClickListener, View.OnAttachStateChangeListener {
+        private int mSurfaceId;
+        private VideoCallPresenter mPresenter;
+        private TextureView mTextureView;
+        private SurfaceTexture mSavedSurfaceTexture;
+        private Surface mSavedSurface;
+        private boolean mIsDoneWithSurface;
+        private int mWidth = DIMENSIONS_NOT_SET;
+        private int mHeight = DIMENSIONS_NOT_SET;
+
+        /**
+         * Creates an instance of a {@link VideoCallSurface}.
+         *
+         * @param surfaceId The surface ID of the surface.
+         * @param textureView The {@link TextureView} for the surface.
+         */
+        public VideoCallSurface(VideoCallPresenter presenter, int surfaceId,
+                TextureView textureView) {
+            this(presenter, surfaceId, textureView, DIMENSIONS_NOT_SET, DIMENSIONS_NOT_SET);
+        }
+
+        /**
+         * Creates an instance of a {@link VideoCallSurface}.
+         *
+         * @param surfaceId The surface ID of the surface.
+         * @param textureView The {@link TextureView} for the surface.
+         * @param width The width of the surface.
+         * @param height The height of the surface.
+         */
+        public VideoCallSurface(VideoCallPresenter presenter,int surfaceId, TextureView textureView,
+                int width, int height) {
+            Log.d(this, "VideoCallSurface: surfaceId=" + surfaceId +
+                    " width=" + width + " height=" + height);
+            mPresenter = presenter;
+            mWidth = width;
+            mHeight = height;
+            mSurfaceId = surfaceId;
+
+            recreateView(textureView);
+        }
+
+        /**
+         * Recreates a {@link VideoCallSurface} after a device orientation change.  Re-applies the
+         * saved {@link SurfaceTexture} to the
+         *
+         * @param view The {@link TextureView}.
+         */
+        public void recreateView(TextureView view) {
+            if (DEBUG) {
+                Log.i(TAG, "recreateView: " + view);
+            }
+
+            if (mTextureView == view) {
+                return;
+            }
+
+            mTextureView = view;
+            mTextureView.setSurfaceTextureListener(this);
+            mTextureView.setOnClickListener(this);
+
+            final boolean areSameSurfaces =
+                    Objects.equal(mSavedSurfaceTexture, mTextureView.getSurfaceTexture());
+            Log.d(this, "recreateView: SavedSurfaceTexture=" + mSavedSurfaceTexture
+                    + " areSameSurfaces=" + areSameSurfaces);
+            if (mSavedSurfaceTexture != null && !areSameSurfaces) {
+                mTextureView.setSurfaceTexture(mSavedSurfaceTexture);
+                if (createSurface(mWidth, mHeight)) {
+                    onSurfaceCreated();
+                }
+            }
+            mIsDoneWithSurface = false;
+        }
+
+        public void resetPresenter(VideoCallPresenter presenter) {
+            Log.d(this, "resetPresenter: CurrentPresenter=" + mPresenter + " NewPresenter="
+                    + presenter);
+            mPresenter = presenter;
+        }
+
+        /**
+         * Handles {@link SurfaceTexture} callback to indicate that a {@link SurfaceTexture} has
+         * been successfully created.
+         *
+         * @param surfaceTexture The {@link SurfaceTexture} which has been created.
+         * @param width The width of the {@link SurfaceTexture}.
+         * @param height The height of the {@link SurfaceTexture}.
+         */
+        @Override
+        public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width,
+                int height) {
+            boolean surfaceCreated;
+            if (DEBUG) {
+                Log.i(TAG, "onSurfaceTextureAvailable: " + surfaceTexture);
+            }
+            // Where there is no saved {@link SurfaceTexture} available, use the newly created one.
+            // If a saved {@link SurfaceTexture} is available, we are re-creating after an
+            // orientation change.
+            Log.d(this, " onSurfaceTextureAvailable mSurfaceId=" + mSurfaceId + " surfaceTexture="
+                    + surfaceTexture + " width=" + width
+                    + " height=" + height + " mSavedSurfaceTexture=" + mSavedSurfaceTexture);
+            Log.d(this, " onSurfaceTextureAvailable VideoCallPresenter=" + mPresenter);
+            if (mSavedSurfaceTexture == null) {
+                mSavedSurfaceTexture = surfaceTexture;
+                surfaceCreated = createSurface(width, height);
+            } else {
+                // A saved SurfaceTexture was found.
+                Log.d(this, " onSurfaceTextureAvailable: Replacing with cached surface...");
+                mTextureView.setSurfaceTexture(mSavedSurfaceTexture);
+                surfaceCreated = true;
+            }
+
+            // Inform presenter that the surface is available.
+            if (surfaceCreated) {
+                onSurfaceCreated();
+            }
+        }
+
+        private void onSurfaceCreated() {
+            if (mPresenter != null) {
+                mPresenter.onSurfaceCreated(mSurfaceId);
+            } else {
+                Log.e(this, "onSurfaceTextureAvailable: Presenter is null");
+            }
+        }
+
+        /**
+         * Handles a change in the {@link SurfaceTexture}'s size.
+         *
+         * @param surfaceTexture The {@link SurfaceTexture}.
+         * @param width The new width.
+         * @param height The new height.
+         */
+        @Override
+        public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int width,
+                int height) {
+            // Not handled
+        }
+
+        /**
+         * Handles {@link SurfaceTexture} destruct callback, indicating that it has been destroyed.
+         *
+         * @param surfaceTexture The {@link SurfaceTexture}.
+         * @return {@code True} if the {@link TextureView} can release the {@link SurfaceTexture}.
+         */
+        @Override
+        public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) {
+            /**
+             * Destroying the surface texture; inform the presenter so it can null the surfaces.
+             */
+            Log.d(this, " onSurfaceTextureDestroyed mSurfaceId=" + mSurfaceId + " surfaceTexture="
+                    + surfaceTexture + " SavedSurfaceTexture=" + mSavedSurfaceTexture
+                    + " SavedSurface=" + mSavedSurface);
+            Log.d(this, " onSurfaceTextureDestroyed VideoCallPresenter=" + mPresenter);
+
+            // Notify presenter if it is not null.
+            onSurfaceDestroyed();
+
+            if (mIsDoneWithSurface) {
+                onSurfaceReleased();
+                if (mSavedSurface != null) {
+                    mSavedSurface.release();
+                    mSavedSurface = null;
+                }
+            }
+            return mIsDoneWithSurface;
+        }
+
+        private void onSurfaceDestroyed() {
+            if (mPresenter != null) {
+                mPresenter.onSurfaceDestroyed(mSurfaceId);
+            } else {
+                Log.e(this, "onSurfaceTextureDestroyed: Presenter is null.");
+            }
+        }
+
+        /**
+         * Handles {@link SurfaceTexture} update callback.
+         * @param surface
+         */
+        @Override
+        public void onSurfaceTextureUpdated(SurfaceTexture surface) {
+            // Not Handled
+        }
+
+        @Override
+        public void onViewAttachedToWindow(View v) {
+            if (DEBUG) {
+                Log.i(TAG, "OnViewAttachedToWindow");
+            }
+            if (mSavedSurfaceTexture != null) {
+                mTextureView.setSurfaceTexture(mSavedSurfaceTexture);
+            }
+        }
+
+        @Override
+        public void onViewDetachedFromWindow(View v) {}
+
+        /**
+         * Retrieves the current {@link TextureView}.
+         *
+         * @return The {@link TextureView}.
+         */
+        public TextureView getTextureView() {
+            return mTextureView;
+        }
+
+        /**
+         * Called by the user presenter to indicate that the surface is no longer required due to a
+         * change in video state.  Releases and clears out the saved surface and surface textures.
+         */
+        public void setDoneWithSurface() {
+            Log.d(this, "setDoneWithSurface: SavedSurface=" + mSavedSurface
+                    + " SavedSurfaceTexture=" + mSavedSurfaceTexture);
+            mIsDoneWithSurface = true;
+            if (mTextureView != null && mTextureView.isAvailable()) {
+                return;
+            }
+
+            if (mSavedSurface != null) {
+                onSurfaceReleased();
+                mSavedSurface.release();
+                mSavedSurface = null;
+            }
+            if (mSavedSurfaceTexture != null) {
+                mSavedSurfaceTexture.release();
+                mSavedSurfaceTexture = null;
+            }
+        }
+
+        private void onSurfaceReleased() {
+            if (mPresenter != null) {
+                mPresenter.onSurfaceReleased(mSurfaceId);
+            } else {
+                Log.d(this, "setDoneWithSurface: Presenter is null.");
+            }
+        }
+
+        /**
+         * Retrieves the saved surface instance.
+         *
+         * @return The surface.
+         */
+        public Surface getSurface() {
+            return mSavedSurface;
+        }
+
+        /**
+         * Sets the dimensions of the surface.
+         *
+         * @param width The width of the surface, in pixels.
+         * @param height The height of the surface, in pixels.
+         */
+        public void setSurfaceDimensions(int width, int height) {
+            Log.d(this, "setSurfaceDimensions, width=" + width + " height=" + height);
+            mWidth = width;
+            mHeight = height;
+
+            if (mSavedSurfaceTexture != null) {
+                Log.d(this, "setSurfaceDimensions, mSavedSurfaceTexture is NOT equal to null.");
+                createSurface(width, height);
+            }
+        }
+
+        /**
+         * Creates the {@link Surface}, adjusting the {@link SurfaceTexture} buffer size.
+         * @param width The width of the surface to create.
+         * @param height The height of the surface to create.
+         */
+        private boolean createSurface(int width, int height) {
+            Log.d(this, "createSurface mSavedSurfaceTexture=" + mSavedSurfaceTexture
+                    + " mSurfaceId =" + mSurfaceId + " mWidth " + width + " mHeight=" + height);
+            if (width != DIMENSIONS_NOT_SET && height != DIMENSIONS_NOT_SET
+                    && mSavedSurfaceTexture != null) {
+                mSavedSurfaceTexture.setDefaultBufferSize(width, height);
+                mSavedSurface = new Surface(mSavedSurfaceTexture);
+                return true;
+            }
+            return false;
+        }
+
+        /**
+         * Handles a user clicking the surface, which is the trigger to toggle the full screen
+         * Video UI.
+         *
+         * @param view The view receiving the click.
+         */
+        @Override
+        public void onClick(View view) {
+            if (mPresenter != null) {
+                mPresenter.onSurfaceClick(mSurfaceId);
+            } else {
+                Log.e(this, "onClick: Presenter is null.");
+            }
+        }
+
+        /**
+         * Returns the dimensions of the surface.
+         *
+         * @return The dimensions of the surface.
+         */
+        public Point getSurfaceDimensions() {
+            return new Point(mWidth, mHeight);
+        }
+    };
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        mAnimationDuration = getResources().getInteger(R.integer.video_animation_duration);
+    }
+
+    /**
+     * Handles creation of the activity and initialization of the presenter.
+     *
+     * @param savedInstanceState The saved instance state.
+     */
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+
+        mIsLandscape = getResources().getBoolean(R.bool.is_layout_landscape);
+
+        Log.d(this, "onActivityCreated: IsLandscape=" + mIsLandscape);
+        getPresenter().init(getActivity());
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        super.onCreateView(inflater, container, savedInstanceState);
+
+        final View view = inflater.inflate(R.layout.video_call_fragment, container, false);
+
+        return view;
+    }
+
+    /**
+     * Centers the display view vertically for portrait orientations. The view is centered within
+     * the available space not occupied by the call card. This is a no-op for landscape mode.
+     *
+     * @param displayVideo The video view to center.
+     */
+    private void centerDisplayView(View displayVideo) {
+        if (!mIsLandscape) {
+            ViewGroup.LayoutParams p = displayVideo.getLayoutParams();
+            int height = p.height;
+
+            float spaceBesideCallCard = InCallPresenter.getInstance().getSpaceBesideCallCard();
+            // If space beside call card is zeo, layout hasn't happened yet so there is no point
+            // in attempting to center the view.
+            if (Math.abs(spaceBesideCallCard - 0.0f) < 0.0001) {
+                return;
+            }
+            float videoViewTranslation = height / 2  - spaceBesideCallCard / 2;
+            displayVideo.setTranslationY(videoViewTranslation);
+        }
+    }
+
+    /**
+     * After creation of the fragment view, retrieves the required views.
+     *
+     * @param view The fragment view.
+     * @param savedInstanceState The saved instance state.
+     */
+    @Override
+    public void onViewCreated(View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+        Log.d(this, "onViewCreated: VideoSurfacesInUse=" + sVideoSurfacesInUse);
+
+        mVideoViewsStub = (ViewStub) view.findViewById(R.id.videoCallViewsStub);
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+        Log.d(this, "onStop:");
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        Log.d(this, "onPause:");
+    }
+
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+        Log.d(this, "onDestroyView:");
+    }
+
+    /**
+     * Creates the presenter for the {@link VideoCallFragment}.
+     * @return The presenter instance.
+     */
+    @Override
+    public VideoCallPresenter createPresenter() {
+        Log.d(this, "createPresenter");
+        VideoCallPresenter presenter = new VideoCallPresenter();
+        onPresenterChanged(presenter);
+        return presenter;
+    }
+
+    /**
+     * @return The user interface for the presenter, which is this fragment.
+     */
+    @Override
+    public VideoCallPresenter.VideoCallUi getUi() {
+        return this;
+    }
+
+    /**
+     * Inflate video surfaces.
+     *
+     * @param show {@code True} if the video surfaces should be shown.
+     */
+    private void inflateVideoUi(boolean show) {
+        int visibility = show ? View.VISIBLE : View.GONE;
+        getView().setVisibility(visibility);
+
+        if (show) {
+            inflateVideoCallViews();
+        }
+
+        if (mVideoViews != null) {
+            mVideoViews.setVisibility(visibility);
+        }
+    }
+
+    /**
+     * Hides and shows the incoming video view and changes the outgoing video view's state based on
+     * whether outgoing view is enabled or not.
+     */
+    public void showVideoViews(boolean previewPaused, boolean showIncoming) {
+        inflateVideoUi(true);
+
+        View incomingVideoView = mVideoViews.findViewById(R.id.incomingVideo);
+        if (incomingVideoView != null) {
+            incomingVideoView.setVisibility(showIncoming ? View.VISIBLE : View.INVISIBLE);
+        }
+        if (mCameraOff != null) {
+            mCameraOff.setVisibility(!previewPaused ? View.VISIBLE : View.INVISIBLE);
+        }
+        if (mPreviewPhoto != null) {
+            mPreviewPhoto.setVisibility(!previewPaused ? View.VISIBLE : View.INVISIBLE);
+        }
+    }
+
+    /**
+     * Hide all video views.
+     */
+    public void hideVideoUi() {
+        inflateVideoUi(false);
+    }
+
+    /**
+     * Cleans up the video telephony surfaces.  Used when the presenter indicates a change to an
+     * audio-only state.  Since the surfaces are static, it is important to ensure they are cleaned
+     * up promptly.
+     */
+    @Override
+    public void cleanupSurfaces() {
+        Log.d(this, "cleanupSurfaces");
+        if (sDisplaySurface != null) {
+            sDisplaySurface.setDoneWithSurface();
+            sDisplaySurface = null;
+        }
+        if (sPreviewSurface != null) {
+            sPreviewSurface.setDoneWithSurface();
+            sPreviewSurface = null;
+        }
+        sVideoSurfacesInUse = false;
+    }
+
+    @Override
+    public ImageView getPreviewPhotoView() {
+        return mPreviewPhoto;
+    }
+
+    /**
+     * Adjusts the location of the video preview view by the specified offset.
+     *
+     * @param shiftUp {@code true} if the preview should shift up, {@code false} if it should shift
+     *      down.
+     * @param offset The offset.
+     */
+    @Override
+    public void adjustPreviewLocation(boolean shiftUp, int offset) {
+        if (sPreviewSurface == null || mPreviewVideoContainer == null) {
+            return;
+        }
+
+        // Set the position of the secondary call info card to its starting location.
+        mPreviewVideoContainer.setTranslationY(shiftUp ? 0 : -offset);
+
+        // Animate the secondary card info slide up/down as it appears and disappears.
+        mPreviewVideoContainer.animate()
+                .setInterpolator(AnimUtils.EASE_OUT_EASE_IN)
+                .setDuration(mAnimationDuration)
+                .translationY(shiftUp ? -offset : 0)
+                .start();
+    }
+
+    private void onPresenterChanged(VideoCallPresenter presenter) {
+        Log.d(this, "onPresenterChanged: Presenter=" + presenter);
+        if (sDisplaySurface != null) {
+            sDisplaySurface.resetPresenter(presenter);;
+        }
+        if (sPreviewSurface != null) {
+            sPreviewSurface.resetPresenter(presenter);
+        }
+    }
+
+    /**
+     * @return {@code True} if the display video surface has been created.
+     */
+    @Override
+    public boolean isDisplayVideoSurfaceCreated() {
+        boolean ret = sDisplaySurface != null && sDisplaySurface.getSurface() != null;
+        Log.d(this, " isDisplayVideoSurfaceCreated returns " + ret);
+        return ret;
+    }
+
+    /**
+     * @return {@code True} if the preview video surface has been created.
+     */
+    @Override
+    public boolean isPreviewVideoSurfaceCreated() {
+        boolean ret = sPreviewSurface != null && sPreviewSurface.getSurface() != null;
+        Log.d(this, " isPreviewVideoSurfaceCreated returns " + ret);
+        return ret;
+    }
+
+    /**
+     * {@link android.view.Surface} on which incoming video for a video call is displayed.
+     * {@code Null} until the video views {@link android.view.ViewStub} is inflated.
+     */
+    @Override
+    public Surface getDisplayVideoSurface() {
+        return sDisplaySurface == null ? null : sDisplaySurface.getSurface();
+    }
+
+    /**
+     * {@link android.view.Surface} on which a preview of the outgoing video for a video call is
+     * displayed.  {@code Null} until the video views {@link android.view.ViewStub} is inflated.
+     */
+    @Override
+    public Surface getPreviewVideoSurface() {
+        return sPreviewSurface == null ? null : sPreviewSurface.getSurface();
+    }
+
+    /**
+     * Changes the dimensions of the preview surface.  Called when the dimensions change due to a
+     * device orientation change.
+     *
+     * @param width The new width.
+     * @param height The new height.
+     */
+    @Override
+    public void setPreviewSize(int width, int height) {
+        Log.d(this, "setPreviewSize: width=" + width + " height=" + height);
+        if (sPreviewSurface != null) {
+            TextureView preview = sPreviewSurface.getTextureView();
+
+            if (preview == null ) {
+                return;
+            }
+
+            // Set the dimensions of both the video surface and the FrameLayout containing it.
+            ViewGroup.LayoutParams params = preview.getLayoutParams();
+            params.width = width;
+            params.height = height;
+            preview.setLayoutParams(params);
+
+            if (mPreviewVideoContainer != null) {
+                ViewGroup.LayoutParams containerParams = mPreviewVideoContainer.getLayoutParams();
+                containerParams.width = width;
+                containerParams.height = height;
+                mPreviewVideoContainer.setLayoutParams(containerParams);
+            }
+
+            // The width and height are interchanged outside of this method based on the current
+            // orientation, so we can transform using "width", which will be either the width or
+            // the height.
+            Matrix transform = new Matrix();
+            transform.setScale(-1, 1, width/2, 0);
+            preview.setTransform(transform);
+        }
+    }
+
+    /**
+     * Sets the rotation of the preview surface.  Called when the dimensions change due to a
+     * device orientation change.
+     *
+     * Please note that the screen orientation passed in is subtracted from 360 to get the actual
+     * preview rotation values.
+     *
+     * @param rotation The screen orientation. One of -
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_0},
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_90},
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_180},
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_270}).
+     */
+    @Override
+    public void setPreviewRotation(int orientation) {
+        Log.d(this, "setPreviewRotation: orientation=" + orientation);
+        if (sPreviewSurface != null) {
+            TextureView preview = sPreviewSurface.getTextureView();
+
+            if (preview == null ) {
+                return;
+            }
+
+            preview.setRotation(orientation);
+        }
+    }
+
+    @Override
+    public void setPreviewSurfaceSize(int width, int height) {
+        final boolean isPreviewSurfaceAvailable = sPreviewSurface != null;
+        Log.d(this, "setPreviewSurfaceSize: width=" + width + " height=" + height +
+                " isPreviewSurfaceAvailable=" + isPreviewSurfaceAvailable);
+        if (isPreviewSurfaceAvailable) {
+            sPreviewSurface.setSurfaceDimensions(width, height);
+        }
+    }
+
+    /**
+     * returns UI's current orientation.
+     */
+    @Override
+    public int getCurrentRotation() {
+        try {
+            return getActivity().getWindowManager().getDefaultDisplay().getRotation();
+        } catch (Exception e) {
+            Log.e(this, "getCurrentRotation: Retrieving current rotation failed. Ex=" + e);
+        }
+        return ORIENTATION_UNKNOWN;
+    }
+
+    /**
+     * Changes the dimensions of the display video surface. Called when the dimensions change due to
+     * a peer resolution update
+     *
+     * @param width The new width.
+     * @param height The new height.
+     */
+    @Override
+    public void setDisplayVideoSize(int width, int height) {
+        Log.v(this, "setDisplayVideoSize: width=" + width + " height=" + height);
+        if (sDisplaySurface != null) {
+            TextureView displayVideo = sDisplaySurface.getTextureView();
+            if (displayVideo == null) {
+                Log.e(this, "Display Video texture view is null. Bail out");
+                return;
+            }
+            sDisplaySize = new Point(width, height);
+            setSurfaceSizeAndTranslation(displayVideo, sDisplaySize);
+        } else {
+            Log.e(this, "Display Video Surface is null. Bail out");
+        }
+    }
+
+    /**
+     * Determines the size of the device screen.
+     *
+     * @return {@link Point} specifying the width and height of the screen.
+     */
+    @Override
+    public Point getScreenSize() {
+        // Get current screen size.
+        Display display = getActivity().getWindowManager().getDefaultDisplay();
+        Point size = new Point();
+        display.getSize(size);
+
+        return size;
+    }
+
+    /**
+     * Determines the size of the preview surface.
+     *
+     * @return {@link Point} specifying the width and height of the preview surface.
+     */
+    @Override
+    public Point getPreviewSize() {
+        if (sPreviewSurface == null) {
+            return null;
+        }
+        return sPreviewSurface.getSurfaceDimensions();
+    }
+
+    /**
+     * Inflates the {@link ViewStub} containing the incoming and outgoing surfaces, if necessary,
+     * and creates {@link VideoCallSurface} instances to track the surfaces.
+     */
+    private void inflateVideoCallViews() {
+        Log.d(this, "inflateVideoCallViews");
+        if (mVideoViews == null ) {
+            mVideoViews = mVideoViewsStub.inflate();
+        }
+
+        if (mVideoViews != null) {
+            mPreviewVideoContainer = mVideoViews.findViewById(R.id.previewVideoContainer);
+            mCameraOff = mVideoViews.findViewById(R.id.previewCameraOff);
+            mPreviewPhoto = (ImageView) mVideoViews.findViewById(R.id.previewProfilePhoto);
+
+            TextureView displaySurface = (TextureView) mVideoViews.findViewById(R.id.incomingVideo);
+
+            Log.d(this, "inflateVideoCallViews: sVideoSurfacesInUse=" + sVideoSurfacesInUse);
+            //If peer adjusted screen size is not available, set screen size to default display size
+            Point screenSize = sDisplaySize == null ? getScreenSize() : sDisplaySize;
+            setSurfaceSizeAndTranslation(displaySurface, screenSize);
+
+            if (!sVideoSurfacesInUse) {
+                // Where the video surfaces are not already in use (first time creating them),
+                // setup new VideoCallSurface instances to track them.
+                Log.d(this, " inflateVideoCallViews screenSize" + screenSize);
+
+                sDisplaySurface = new VideoCallSurface(getPresenter(), SURFACE_DISPLAY,
+                        (TextureView) mVideoViews.findViewById(R.id.incomingVideo), screenSize.x,
+                        screenSize.y);
+                sPreviewSurface = new VideoCallSurface(getPresenter(), SURFACE_PREVIEW,
+                        (TextureView) mVideoViews.findViewById(R.id.previewVideo));
+                sVideoSurfacesInUse = true;
+            } else {
+                // In this case, the video surfaces are already in use (we are recreating the
+                // Fragment after a destroy/create cycle resulting from a rotation.
+                sDisplaySurface.recreateView((TextureView) mVideoViews.findViewById(
+                        R.id.incomingVideo));
+                sPreviewSurface.recreateView((TextureView) mVideoViews.findViewById(
+                        R.id.previewVideo));
+            }
+
+            // Attempt to center the incoming video view, if it is in the layout.
+            final ViewTreeObserver observer = mVideoViews.getViewTreeObserver();
+            observer.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
+                @Override
+                public void onGlobalLayout() {
+                    // Check if the layout includes the incoming video surface -- this will only be the
+                    // case for a video call.
+                    View displayVideo = mVideoViews.findViewById(R.id.incomingVideo);
+                    if (displayVideo != null) {
+                        centerDisplayView(displayVideo);
+                    }
+                    mIsLayoutComplete = true;
+
+                    // Remove the listener so we don't continually re-layout.
+                    ViewTreeObserver observer = mVideoViews.getViewTreeObserver();
+                    if (observer.isAlive()) {
+                        observer.removeOnGlobalLayoutListener(this);
+                    }
+                }
+            });
+        }
+    }
+
+    /**
+     * Resizes a surface so that it has the same size as the full screen and so that it is
+     * centered vertically below the call card.
+     *
+     * @param textureView The {@link TextureView} to resize and position.
+     * @param size The size of the screen.
+     */
+    private void setSurfaceSizeAndTranslation(TextureView textureView, Point size) {
+        // Set the surface to have that size.
+        ViewGroup.LayoutParams params = textureView.getLayoutParams();
+        params.width = size.x;
+        params.height = size.y;
+        textureView.setLayoutParams(params);
+        Log.d(this, "setSurfaceSizeAndTranslation: Size=" + size + "IsLayoutComplete=" +
+                mIsLayoutComplete + "IsLandscape=" + mIsLandscape);
+
+        // It is only possible to center the display view if layout of the views has completed.
+        // It is only after layout is complete that the dimensions of the Call Card has been
+        // established, which is a prerequisite to centering the view.
+        // Incoming video calls will center the view
+        if (mIsLayoutComplete) {
+            centerDisplayView(textureView);
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/VideoCallPresenter.java b/InCallUI/src/com/android/incallui/VideoCallPresenter.java
new file mode 100644
index 0000000..ebdf820
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/VideoCallPresenter.java
@@ -0,0 +1,1351 @@
+/*
+ * 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
+ */
+
+package com.android.incallui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.graphics.Point;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.Handler;
+import android.os.Looper;
+import android.provider.ContactsContract;
+import android.telecom.Connection;
+import android.telecom.InCallService.VideoCall;
+import android.telecom.VideoProfile;
+import android.telecom.VideoProfile.CameraCapabilities;
+import android.view.Surface;
+import android.widget.ImageView;
+
+import com.android.contacts.common.ContactPhotoManager;
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.incallui.InCallPresenter.InCallDetailsListener;
+import com.android.incallui.InCallPresenter.InCallOrientationListener;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.incallui.InCallPresenter.IncomingCallListener;
+import com.android.incallui.InCallVideoCallCallbackNotifier.SurfaceChangeListener;
+import com.android.incallui.InCallVideoCallCallbackNotifier.VideoEventListener;
+import com.android.incallui.compat.telecom.VideoProfileCompat;
+
+import java.util.Objects;
+
+/**
+ * Logic related to the {@link VideoCallFragment} and for managing changes to the video calling
+ * surfaces based on other user interface events and incoming events from the
+ * {@class VideoCallListener}.
+ * <p>
+ * When a call's video state changes to bi-directional video, the
+ * {@link com.android.incallui.VideoCallPresenter} performs the following negotiation with the
+ * telephony layer:
+ * <ul>
+ *     <li>{@code VideoCallPresenter} creates and informs telephony of the display surface.</li>
+ *     <li>{@code VideoCallPresenter} creates the preview surface.</li>
+ *     <li>{@code VideoCallPresenter} informs telephony of the currently selected camera.</li>
+ *     <li>Telephony layer sends {@link CameraCapabilities}, including the
+ *     dimensions of the video for the current camera.</li>
+ *     <li>{@code VideoCallPresenter} adjusts size of the preview surface to match the aspect
+ *     ratio of the camera.</li>
+ *     <li>{@code VideoCallPresenter} informs telephony of the new preview surface.</li>
+ * </ul>
+ * <p>
+ * When downgrading to an audio-only video state, the {@code VideoCallPresenter} nulls both
+ * surfaces.
+ */
+public class VideoCallPresenter extends Presenter<VideoCallPresenter.VideoCallUi> implements
+        IncomingCallListener, InCallOrientationListener, InCallStateListener,
+        InCallDetailsListener, SurfaceChangeListener, VideoEventListener,
+        InCallVideoCallCallbackNotifier.SessionModificationListener,
+        InCallPresenter.InCallEventListener {
+    public static final String TAG = "VideoCallPresenter";
+
+    public static final boolean DEBUG = false;
+
+    /**
+     * Runnable which is posted to schedule automatically entering fullscreen mode.  Will not auto
+     * enter fullscreen mode if the dialpad is visible (doing so would make it impossible to exit
+     * the dialpad).
+     */
+    private Runnable mAutoFullscreenRunnable =  new Runnable() {
+        @Override
+        public void run() {
+            if (mAutoFullScreenPending && !InCallPresenter.getInstance().isDialpadVisible()) {
+                Log.v(this, "Automatically entering fullscreen mode.");
+                InCallPresenter.getInstance().setFullScreen(true);
+                mAutoFullScreenPending = false;
+            } else {
+                Log.v(this, "Skipping scheduled fullscreen mode.");
+            }
+        }
+    };
+
+    /**
+     * Defines the state of the preview surface negotiation with the telephony layer.
+     */
+    private class PreviewSurfaceState {
+        /**
+         * The camera has not yet been set on the {@link VideoCall}; negotiation has not yet
+         * started.
+         */
+        private static final int NONE = 0;
+
+        /**
+         * The camera has been set on the {@link VideoCall}, but camera capabilities have not yet
+         * been received.
+         */
+        private static final int CAMERA_SET = 1;
+
+        /**
+         * The camera capabilties have been received from telephony, but the surface has not yet
+         * been set on the {@link VideoCall}.
+         */
+        private static final int CAPABILITIES_RECEIVED = 2;
+
+        /**
+         * The surface has been set on the {@link VideoCall}.
+         */
+        private static final int SURFACE_SET = 3;
+    }
+
+    /**
+     * The minimum width or height of the preview surface.  Used when re-sizing the preview surface
+     * to match the aspect ratio of the currently selected camera.
+     */
+    private float mMinimumVideoDimension;
+
+    /**
+     * The current context.
+     */
+    private Context mContext;
+
+    /**
+     * The call the video surfaces are currently related to
+     */
+    private Call mPrimaryCall;
+
+    /**
+     * The {@link VideoCall} used to inform the video telephony layer of changes to the video
+     * surfaces.
+     */
+    private VideoCall mVideoCall;
+
+    /**
+     * Determines if the current UI state represents a video call.
+     */
+    private int mCurrentVideoState;
+
+    /**
+     * Call's current state
+     */
+    private int mCurrentCallState = Call.State.INVALID;
+
+    /**
+     * Determines the device orientation (portrait/lanscape).
+     */
+    private int mDeviceOrientation = InCallOrientationEventListener.SCREEN_ORIENTATION_0;
+
+    /**
+     * Tracks the state of the preview surface negotiation with the telephony layer.
+     */
+    private int mPreviewSurfaceState = PreviewSurfaceState.NONE;
+
+    private static boolean mIsVideoMode = false;
+
+    /**
+     * Contact photo manager to retrieve cached contact photo information.
+     */
+    private ContactPhotoManager mContactPhotoManager = null;
+
+    /**
+     * The URI for the user's profile photo, or {@code null} if not specified.
+     */
+    private ContactInfoCache.ContactCacheEntry mProfileInfo = null;
+
+    /**
+     * UI thread handler used for delayed task execution.
+     */
+    private Handler mHandler;
+
+    /**
+     * Determines whether video calls should automatically enter full screen mode after
+     * {@link #mAutoFullscreenTimeoutMillis} milliseconds.
+     */
+    private boolean mIsAutoFullscreenEnabled = false;
+
+    /**
+     * Determines the number of milliseconds after which a video call will automatically enter
+     * fullscreen mode.  Requires {@link #mIsAutoFullscreenEnabled} to be {@code true}.
+     */
+    private int mAutoFullscreenTimeoutMillis = 0;
+
+    /**
+     * Determines if the countdown is currently running to automatically enter full screen video
+     * mode.
+     */
+    private boolean mAutoFullScreenPending = false;
+
+    /**
+     * Initializes the presenter.
+     *
+     * @param context The current context.
+     */
+    public void init(Context context) {
+        mContext = context;
+        mMinimumVideoDimension = mContext.getResources().getDimension(
+                R.dimen.video_preview_small_dimension);
+        mHandler = new Handler(Looper.getMainLooper());
+        mIsAutoFullscreenEnabled = mContext.getResources()
+                .getBoolean(R.bool.video_call_auto_fullscreen);
+        mAutoFullscreenTimeoutMillis = mContext.getResources().getInteger(
+                R.integer.video_call_auto_fullscreen_timeout);
+    }
+
+    /**
+     * Called when the user interface is ready to be used.
+     *
+     * @param ui The Ui implementation that is now ready to be used.
+     */
+    @Override
+    public void onUiReady(VideoCallUi ui) {
+        super.onUiReady(ui);
+        Log.d(this, "onUiReady:");
+
+        // Do not register any listeners if video calling is not compatible to safeguard against
+        // any accidental calls of video calling code.
+        if (!CompatUtils.isVideoCompatible()) {
+            return;
+        }
+
+        // Register for call state changes last
+        InCallPresenter.getInstance().addListener(this);
+        InCallPresenter.getInstance().addDetailsListener(this);
+        InCallPresenter.getInstance().addIncomingCallListener(this);
+        InCallPresenter.getInstance().addOrientationListener(this);
+        // To get updates of video call details changes
+        InCallPresenter.getInstance().addDetailsListener(this);
+        InCallPresenter.getInstance().addInCallEventListener(this);
+
+        // Register for surface and video events from {@link InCallVideoCallListener}s.
+        InCallVideoCallCallbackNotifier.getInstance().addSurfaceChangeListener(this);
+        InCallVideoCallCallbackNotifier.getInstance().addVideoEventListener(this);
+        InCallVideoCallCallbackNotifier.getInstance().addSessionModificationListener(this);
+        mCurrentVideoState = VideoProfile.STATE_AUDIO_ONLY;
+        mCurrentCallState = Call.State.INVALID;
+    }
+
+    /**
+     * Called when the user interface is no longer ready to be used.
+     *
+     * @param ui The Ui implementation that is no longer ready to be used.
+     */
+    @Override
+    public void onUiUnready(VideoCallUi ui) {
+        super.onUiUnready(ui);
+        Log.d(this, "onUiUnready:");
+
+        if (!CompatUtils.isVideoCompatible()) {
+            return;
+        }
+
+        InCallPresenter.getInstance().removeListener(this);
+        InCallPresenter.getInstance().removeDetailsListener(this);
+        InCallPresenter.getInstance().removeIncomingCallListener(this);
+        InCallPresenter.getInstance().removeOrientationListener(this);
+        InCallPresenter.getInstance().removeInCallEventListener(this);
+
+        InCallVideoCallCallbackNotifier.getInstance().removeSurfaceChangeListener(this);
+        InCallVideoCallCallbackNotifier.getInstance().removeVideoEventListener(this);
+        InCallVideoCallCallbackNotifier.getInstance().removeSessionModificationListener(this);
+    }
+
+    /**
+     * Handles the creation of a surface in the {@link VideoCallFragment}.
+     *
+     * @param surface The surface which was created.
+     */
+    public void onSurfaceCreated(int surface) {
+        Log.d(this, "onSurfaceCreated surface=" + surface + " mVideoCall=" + mVideoCall);
+        Log.d(this, "onSurfaceCreated PreviewSurfaceState=" + mPreviewSurfaceState);
+        Log.d(this, "onSurfaceCreated presenter=" + this);
+
+        final VideoCallUi ui = getUi();
+        if (ui == null || mVideoCall == null) {
+            Log.w(this, "onSurfaceCreated: Error bad state VideoCallUi=" + ui + " mVideoCall="
+                    + mVideoCall);
+            return;
+        }
+
+        // If the preview surface has just been created and we have already received camera
+        // capabilities, but not yet set the surface, we will set the surface now.
+        if (surface == VideoCallFragment.SURFACE_PREVIEW ) {
+            if (mPreviewSurfaceState == PreviewSurfaceState.CAPABILITIES_RECEIVED) {
+                mPreviewSurfaceState = PreviewSurfaceState.SURFACE_SET;
+                mVideoCall.setPreviewSurface(ui.getPreviewVideoSurface());
+            } else if (mPreviewSurfaceState == PreviewSurfaceState.NONE && isCameraRequired()){
+                enableCamera(mVideoCall, true);
+            }
+        } else if (surface == VideoCallFragment.SURFACE_DISPLAY) {
+            mVideoCall.setDisplaySurface(ui.getDisplayVideoSurface());
+        }
+    }
+
+    /**
+     * Handles structural changes (format or size) to a surface.
+     *
+     * @param surface The surface which changed.
+     * @param format The new PixelFormat of the surface.
+     * @param width The new width of the surface.
+     * @param height The new height of the surface.
+     */
+    public void onSurfaceChanged(int surface, int format, int width, int height) {
+        //Do stuff
+    }
+
+    /**
+     * Handles the destruction of a surface in the {@link VideoCallFragment}.
+     * Note: The surface is being released, that is, it is no longer valid.
+     *
+     * @param surface The surface which was destroyed.
+     */
+    public void onSurfaceReleased(int surface) {
+        Log.d(this, "onSurfaceReleased: mSurfaceId=" + surface);
+        if ( mVideoCall == null) {
+            Log.w(this, "onSurfaceReleased: VideoCall is null. mSurfaceId=" +
+                    surface);
+            return;
+        }
+
+        if (surface == VideoCallFragment.SURFACE_DISPLAY) {
+            mVideoCall.setDisplaySurface(null);
+        } else if (surface == VideoCallFragment.SURFACE_PREVIEW) {
+            mVideoCall.setPreviewSurface(null);
+            enableCamera(mVideoCall, false);
+        }
+    }
+
+    /**
+     * Called by {@link VideoCallFragment} when the surface is detached from UI (TextureView).
+     * Note: The surface will be cached by {@link VideoCallFragment}, so we don't immediately
+     * null out incoming video surface.
+     * @see VideoCallPresenter#onSurfaceReleased(int)
+     *
+     * @param surface The surface which was detached.
+     */
+    public void onSurfaceDestroyed(int surface) {
+        Log.d(this, "onSurfaceDestroyed: mSurfaceId=" + surface);
+        if (mVideoCall == null) {
+            return;
+        }
+
+        final boolean isChangingConfigurations =
+                InCallPresenter.getInstance().isChangingConfigurations();
+        Log.d(this, "onSurfaceDestroyed: isChangingConfigurations=" + isChangingConfigurations);
+
+        if (surface == VideoCallFragment.SURFACE_PREVIEW) {
+            if (!isChangingConfigurations) {
+                enableCamera(mVideoCall, false);
+            } else {
+                Log.w(this, "onSurfaceDestroyed: Activity is being destroyed due "
+                        + "to configuration changes. Not closing the camera.");
+            }
+        }
+    }
+
+    /**
+     * Handles clicks on the video surfaces by toggling full screen state.
+     * Informs the {@link InCallPresenter} of the change so that it can inform the
+     * {@link CallCardPresenter} of the change.
+     *
+     * @param surfaceId The video surface receiving the click.
+     */
+    public void onSurfaceClick(int surfaceId) {
+        boolean isFullscreen = InCallPresenter.getInstance().toggleFullscreenMode();
+        Log.v(this, "toggleFullScreen = " + isFullscreen);
+    }
+
+    /**
+     * Handles incoming calls.
+     *
+     * @param oldState The old in call state.
+     * @param newState The new in call state.
+     * @param call The call.
+     */
+    @Override
+    public void onIncomingCall(InCallPresenter.InCallState oldState,
+            InCallPresenter.InCallState newState, Call call) {
+        // same logic should happen as with onStateChange()
+        onStateChange(oldState, newState, CallList.getInstance());
+    }
+
+    /**
+     * Handles state changes (including incoming calls)
+     *
+     * @param newState The in call state.
+     * @param callList The call list.
+     */
+    @Override
+    public void onStateChange(InCallPresenter.InCallState oldState,
+            InCallPresenter.InCallState newState, CallList callList) {
+        Log.d(this, "onStateChange oldState" + oldState + " newState=" + newState +
+                " isVideoMode=" + isVideoMode());
+
+        if (newState == InCallPresenter.InCallState.NO_CALLS) {
+            if (isVideoMode()) {
+                exitVideoMode();
+            }
+
+            cleanupSurfaces();
+        }
+
+        // Determine the primary active call).
+        Call primary = null;
+
+        // Determine the call which is the focus of the user's attention.  In the case of an
+        // incoming call waiting call, the primary call is still the active video call, however
+        // the determination of whether we should be in fullscreen mode is based on the type of the
+        // incoming call, not the active video call.
+        Call currentCall = null;
+
+        if (newState == InCallPresenter.InCallState.INCOMING) {
+            // We don't want to replace active video call (primary call)
+            // with a waiting call, since user may choose to ignore/decline the waiting call and
+            // this should have no impact on current active video call, that is, we should not
+            // change the camera or UI unless the waiting VT call becomes active.
+            primary = callList.getActiveCall();
+            currentCall = callList.getIncomingCall();
+            if (!VideoUtils.isActiveVideoCall(primary)) {
+                primary = callList.getIncomingCall();
+            }
+        } else if (newState == InCallPresenter.InCallState.OUTGOING) {
+            currentCall = primary = callList.getOutgoingCall();
+        } else if (newState == InCallPresenter.InCallState.PENDING_OUTGOING) {
+            currentCall = primary = callList.getPendingOutgoingCall();
+        } else if (newState == InCallPresenter.InCallState.INCALL) {
+            currentCall = primary = callList.getActiveCall();
+        }
+
+        final boolean primaryChanged = !Objects.equals(mPrimaryCall, primary);
+        Log.d(this, "onStateChange primaryChanged=" + primaryChanged);
+        Log.d(this, "onStateChange primary= " + primary);
+        Log.d(this, "onStateChange mPrimaryCall = " + mPrimaryCall);
+        if (primaryChanged) {
+            onPrimaryCallChanged(primary);
+        } else if (mPrimaryCall != null) {
+            updateVideoCall(primary);
+        }
+        updateCallCache(primary);
+
+        // If the call context changed, potentially exit fullscreen or schedule auto enter of
+        // fullscreen mode.
+        // If the current call context is no longer a video call, exit fullscreen mode.
+        maybeExitFullscreen(currentCall);
+        // Schedule auto-enter of fullscreen mode if the current call context is a video call
+        maybeAutoEnterFullscreen(currentCall);
+    }
+
+    /**
+     * Handles a change to the fullscreen mode of the app.
+     *
+     * @param isFullscreenMode {@code true} if the app is now fullscreen, {@code false} otherwise.
+     */
+    @Override
+    public void onFullscreenModeChanged(boolean isFullscreenMode) {
+        cancelAutoFullScreen();
+    }
+
+    /**
+     * Handles changes to the visibility of the secondary caller info bar.
+     *
+     * @param isVisible {@code true} if the secondary caller info is showing, {@code false}
+     *      otherwise.
+     * @param height the height of the secondary caller info bar.
+     */
+    @Override
+    public void onSecondaryCallerInfoVisibilityChanged(boolean isVisible, int height) {
+        Log.d(this,
+                "onSecondaryCallerInfoVisibilityChanged : isVisible = " + isVisible + " height = "
+                        + height);
+        getUi().adjustPreviewLocation(isVisible /* shiftUp */, height);
+    }
+
+    private void checkForVideoStateChange(Call call) {
+        final boolean isVideoCall = VideoUtils.isVideoCall(call);
+        final boolean hasVideoStateChanged = mCurrentVideoState != call.getVideoState();
+
+        Log.d(this, "checkForVideoStateChange: isVideoCall= " + isVideoCall
+                + " hasVideoStateChanged=" + hasVideoStateChanged + " isVideoMode="
+                + isVideoMode() + " previousVideoState: " +
+                VideoProfileCompat.videoStateToString(mCurrentVideoState) + " newVideoState: "
+                + VideoProfileCompat.videoStateToString(call.getVideoState()));
+
+        if (!hasVideoStateChanged) {
+            return;
+        }
+
+        updateCameraSelection(call);
+
+        if (isVideoCall) {
+            enterVideoMode(call);
+        } else if (isVideoMode()) {
+            exitVideoMode();
+        }
+    }
+
+    private void checkForCallStateChange(Call call) {
+        final boolean isVideoCall = VideoUtils.isVideoCall(call);
+        final boolean hasCallStateChanged = mCurrentCallState != call.getState();
+
+        Log.d(this, "checkForCallStateChange: isVideoCall= " + isVideoCall
+                + " hasCallStateChanged=" +
+                hasCallStateChanged + " isVideoMode=" + isVideoMode());
+
+        if (!hasCallStateChanged) {
+            return;
+        }
+
+        if (isVideoCall) {
+            final InCallCameraManager cameraManager = InCallPresenter.getInstance().
+                    getInCallCameraManager();
+
+            String prevCameraId = cameraManager.getActiveCameraId();
+            updateCameraSelection(call);
+            String newCameraId = cameraManager.getActiveCameraId();
+
+            if (!Objects.equals(prevCameraId, newCameraId) && VideoUtils.isActiveVideoCall(call)) {
+                enableCamera(call.getVideoCall(), true);
+            }
+        }
+
+        // Make sure we hide or show the video UI if needed.
+        showVideoUi(call.getVideoState(), call.getState());
+    }
+
+    private void cleanupSurfaces() {
+        final VideoCallUi ui = getUi();
+        if (ui == null) {
+            Log.w(this, "cleanupSurfaces");
+            return;
+        }
+        ui.cleanupSurfaces();
+    }
+
+    private void onPrimaryCallChanged(Call newPrimaryCall) {
+        final boolean isVideoCall = VideoUtils.isVideoCall(newPrimaryCall);
+        final boolean isVideoMode = isVideoMode();
+
+        Log.d(this, "onPrimaryCallChanged: isVideoCall=" + isVideoCall + " isVideoMode="
+                + isVideoMode);
+
+        if (!isVideoCall && isVideoMode) {
+            // Terminate video mode if new primary call is not a video call
+            // and we are currently in video mode.
+            Log.d(this, "onPrimaryCallChanged: Exiting video mode...");
+            exitVideoMode();
+        } else if (isVideoCall) {
+            Log.d(this, "onPrimaryCallChanged: Entering video mode...");
+
+            updateCameraSelection(newPrimaryCall);
+            enterVideoMode(newPrimaryCall);
+        }
+    }
+
+    private boolean isVideoMode() {
+        return mIsVideoMode;
+    }
+
+    private void updateCallCache(Call call) {
+        if (call == null) {
+            mCurrentVideoState = VideoProfile.STATE_AUDIO_ONLY;
+            mCurrentCallState = Call.State.INVALID;
+            mVideoCall = null;
+            mPrimaryCall = null;
+        } else {
+            mCurrentVideoState = call.getVideoState();
+            mVideoCall = call.getVideoCall();
+            mCurrentCallState = call.getState();
+            mPrimaryCall = call;
+        }
+    }
+
+    /**
+     * Handles changes to the details of the call.  The {@link VideoCallPresenter} is interested in
+     * changes to the video state.
+     *
+     * @param call The call for which the details changed.
+     * @param details The new call details.
+     */
+    @Override
+    public void onDetailsChanged(Call call, android.telecom.Call.Details details) {
+        Log.d(this, " onDetailsChanged call=" + call + " details=" + details + " mPrimaryCall="
+                + mPrimaryCall);
+        if (call == null) {
+            return;
+        }
+        // If the details change is not for the currently active call no update is required.
+        if (!call.equals(mPrimaryCall)) {
+            Log.d(this, " onDetailsChanged: Details not for current active call so returning. ");
+            return;
+        }
+
+        updateVideoCall(call);
+
+        updateCallCache(call);
+    }
+
+    private void updateVideoCall(Call call) {
+        checkForVideoCallChange(call);
+        checkForVideoStateChange(call);
+        checkForCallStateChange(call);
+        checkForOrientationAllowedChange(call);
+    }
+
+    private void checkForOrientationAllowedChange(Call call) {
+        InCallPresenter.getInstance().setInCallAllowsOrientationChange(
+                VideoUtils.isVideoCall(call));
+    }
+
+    /**
+     * Checks for a change to the video call and changes it if required.
+     */
+    private void checkForVideoCallChange(Call call) {
+        final VideoCall videoCall = call.getTelecomCall().getVideoCall();
+        Log.d(this, "checkForVideoCallChange: videoCall=" + videoCall + " mVideoCall="
+                + mVideoCall);
+        if (!Objects.equals(videoCall, mVideoCall)) {
+            changeVideoCall(call);
+        }
+    }
+
+    /**
+     * Handles a change to the video call. Sets the surfaces on the previous call to null and sets
+     * the surfaces on the new video call accordingly.
+     *
+     * @param videoCall The new video call.
+     */
+    private void changeVideoCall(Call call) {
+        final VideoCall videoCall = call.getTelecomCall().getVideoCall();
+        Log.d(this, "changeVideoCall to videoCall=" + videoCall + " mVideoCall=" + mVideoCall);
+        // Null out the surfaces on the previous video call.
+        if (mVideoCall != null) {
+            // Log.d(this, "Null out the surfaces on the previous video call.");
+            // mVideoCall.setDisplaySurface(null);
+            // mVideoCall.setPreviewSurface(null);
+        }
+
+        final boolean hasChanged = mVideoCall == null && videoCall != null;
+
+        mVideoCall = videoCall;
+        if (mVideoCall == null || call == null) {
+            Log.d(this, "Video call or primary call is null. Return");
+            return;
+        }
+
+        if (VideoUtils.isVideoCall(call) && hasChanged) {
+            enterVideoMode(call);
+        }
+    }
+
+    private static boolean isCameraRequired(int videoState) {
+        return VideoProfileCompat.isBidirectional(videoState) ||
+                VideoProfileCompat.isTransmissionEnabled(videoState);
+    }
+
+    private boolean isCameraRequired() {
+        return mPrimaryCall != null && isCameraRequired(mPrimaryCall.getVideoState());
+    }
+
+    /**
+     * Enters video mode by showing the video surfaces and making other adjustments (eg. audio).
+     * TODO(vt): Need to adjust size and orientation of preview surface here.
+     */
+    private void enterVideoMode(Call call) {
+        VideoCall videoCall = call.getVideoCall();
+        int newVideoState = call.getVideoState();
+
+        Log.d(this, "enterVideoMode videoCall= " + videoCall + " videoState: " + newVideoState);
+        VideoCallUi ui = getUi();
+        if (ui == null) {
+            Log.e(this, "Error VideoCallUi is null so returning");
+            return;
+        }
+
+        showVideoUi(newVideoState, call.getState());
+
+        // Communicate the current camera to telephony and make a request for the camera
+        // capabilities.
+        if (videoCall != null) {
+            if (ui.isDisplayVideoSurfaceCreated()) {
+                Log.d(this, "Calling setDisplaySurface with " + ui.getDisplayVideoSurface());
+                videoCall.setDisplaySurface(ui.getDisplayVideoSurface());
+            }
+
+            videoCall.setDeviceOrientation(mDeviceOrientation);
+            enableCamera(videoCall, isCameraRequired(newVideoState));
+        }
+        mCurrentVideoState = newVideoState;
+
+        mIsVideoMode = true;
+
+        maybeAutoEnterFullscreen(call);
+    }
+
+    private static boolean isSpeakerEnabledForVideoCalls() {
+        // TODO: Make this a carrier configurable setting. For now this is always true. b/20090407
+        return true;
+    }
+
+    private void enableCamera(VideoCall videoCall, boolean isCameraRequired) {
+        Log.d(this, "enableCamera: VideoCall=" + videoCall + " enabling=" + isCameraRequired);
+        if (videoCall == null) {
+            Log.w(this, "enableCamera: VideoCall is null.");
+            return;
+        }
+
+        if (isCameraRequired) {
+            InCallCameraManager cameraManager = InCallPresenter.getInstance().
+                    getInCallCameraManager();
+            videoCall.setCamera(cameraManager.getActiveCameraId());
+            mPreviewSurfaceState = PreviewSurfaceState.CAMERA_SET;
+
+            videoCall.requestCameraCapabilities();
+        } else {
+            mPreviewSurfaceState = PreviewSurfaceState.NONE;
+            videoCall.setCamera(null);
+        }
+    }
+
+    /**
+     * Exits video mode by hiding the video surfaces and making other adjustments (eg. audio).
+     */
+    private void exitVideoMode() {
+        Log.d(this, "exitVideoMode");
+
+        showVideoUi(VideoProfile.STATE_AUDIO_ONLY, Call.State.ACTIVE);
+        enableCamera(mVideoCall, false);
+        InCallPresenter.getInstance().setFullScreen(false);
+
+        mIsVideoMode = false;
+    }
+
+    /**
+     * Based on the current video state and call state, show or hide the incoming and
+     * outgoing video surfaces.  The outgoing video surface is shown any time video is transmitting.
+     * The incoming video surface is shown whenever the video is un-paused and active.
+     *
+     * @param videoState The video state.
+     * @param callState The call state.
+     */
+    private void showVideoUi(int videoState, int callState) {
+        VideoCallUi ui = getUi();
+        if (ui == null) {
+            Log.e(this, "showVideoUi, VideoCallUi is null returning");
+            return;
+        }
+        boolean showIncomingVideo = showIncomingVideo(videoState, callState);
+        boolean showOutgoingVideo = showOutgoingVideo(videoState);
+        Log.v(this, "showVideoUi : showIncoming = " + showIncomingVideo + " showOutgoing = "
+                + showOutgoingVideo);
+        if (showIncomingVideo || showOutgoingVideo) {
+            ui.showVideoViews(showOutgoingVideo, showIncomingVideo);
+
+            if (VideoProfileCompat.isReceptionEnabled(videoState)) {
+                loadProfilePhotoAsync();
+            }
+        } else {
+            ui.hideVideoUi();
+        }
+
+        InCallPresenter.getInstance().enableScreenTimeout(
+                VideoProfileCompat.isAudioOnly(videoState));
+    }
+
+    /**
+     * Determines if the incoming video surface should be shown based on the current videoState and
+     * callState.  The video surface is shown when incoming video is not paused, the call is active,
+     * and video reception is enabled.
+     *
+     * @param videoState The current video state.
+     * @param callState The current call state.
+     * @return {@code true} if the incoming video surface should be shown, {@code false} otherwise.
+     */
+    public static boolean showIncomingVideo(int videoState, int callState) {
+        if (!CompatUtils.isVideoCompatible()) {
+            return false;
+        }
+
+        boolean isPaused = VideoProfileCompat.isPaused(videoState);
+        boolean isCallActive = callState == Call.State.ACTIVE;
+
+        return !isPaused && isCallActive && VideoProfileCompat.isReceptionEnabled(videoState);
+    }
+
+    /**
+     * Determines if the outgoing video surface should be shown based on the current videoState.
+     * The video surface is shown if video transmission is enabled.
+     *
+     * @param videoState The current video state.
+     * @return {@code true} if the the outgoing video surface should be shown, {@code false}
+     *      otherwise.
+     */
+    public static boolean showOutgoingVideo(int videoState) {
+        if (!CompatUtils.isVideoCompatible()) {
+            return false;
+        }
+
+        return VideoProfileCompat.isTransmissionEnabled(videoState);
+    }
+
+    /**
+     * Handles peer video pause state changes.
+     *
+     * @param call The call which paused or un-pausedvideo transmission.
+     * @param paused {@code True} when the video transmission is paused, {@code false} when video
+     *               transmission resumes.
+     */
+    @Override
+    public void onPeerPauseStateChanged(Call call, boolean paused) {
+        if (!call.equals(mPrimaryCall)) {
+            return;
+        }
+
+        // TODO(vt): Show/hide the peer contact photo.
+    }
+
+    /**
+     * Handles peer video dimension changes.
+     *
+     * @param call The call which experienced a peer video dimension change.
+     * @param width The new peer video width .
+     * @param height The new peer video height.
+     */
+    @Override
+    public void onUpdatePeerDimensions(Call call, int width, int height) {
+        Log.d(this, "onUpdatePeerDimensions: width= " + width + " height= " + height);
+        VideoCallUi ui = getUi();
+        if (ui == null) {
+            Log.e(this, "VideoCallUi is null. Bail out");
+            return;
+        }
+        if (!call.equals(mPrimaryCall)) {
+            Log.e(this, "Current call is not equal to primary call. Bail out");
+            return;
+        }
+
+        // Change size of display surface to match the peer aspect ratio
+        if (width > 0 && height > 0) {
+            setDisplayVideoSize(width, height);
+        }
+    }
+
+    /**
+     * Handles any video quality changes in the call.
+     *
+     * @param call The call which experienced a video quality change.
+     * @param videoQuality The new video call quality.
+     */
+    @Override
+    public void onVideoQualityChanged(Call call, int videoQuality) {
+        // No-op
+    }
+
+    /**
+     * Handles a change to the dimensions of the local camera.  Receiving the camera capabilities
+     * triggers the creation of the video
+     *
+     * @param call The call which experienced the camera dimension change.
+     * @param width The new camera video width.
+     * @param height The new camera video height.
+     */
+    @Override
+    public void onCameraDimensionsChange(Call call, int width, int height) {
+        Log.d(this, "onCameraDimensionsChange call=" + call + " width=" + width + " height="
+                + height);
+        VideoCallUi ui = getUi();
+        if (ui == null) {
+            Log.e(this, "onCameraDimensionsChange ui is null");
+            return;
+        }
+
+        if (!call.equals(mPrimaryCall)) {
+            Log.e(this, "Call is not primary call");
+            return;
+        }
+
+        mPreviewSurfaceState = PreviewSurfaceState.CAPABILITIES_RECEIVED;
+        changePreviewDimensions(width, height);
+
+        // Check if the preview surface is ready yet; if it is, set it on the {@code VideoCall}.
+        // If it not yet ready, it will be set when when creation completes.
+        if (ui.isPreviewVideoSurfaceCreated()) {
+            mPreviewSurfaceState = PreviewSurfaceState.SURFACE_SET;
+            mVideoCall.setPreviewSurface(ui.getPreviewVideoSurface());
+        }
+    }
+
+    /**
+     * Changes the dimensions of the preview surface.
+     *
+     * @param width The new width.
+     * @param height The new height.
+     */
+    private void changePreviewDimensions(int width, int height) {
+        VideoCallUi ui = getUi();
+        if (ui == null) {
+            return;
+        }
+
+        // Resize the surface used to display the preview video
+        ui.setPreviewSurfaceSize(width, height);
+
+        // Configure the preview surface to the correct aspect ratio.
+        float aspectRatio = 1.0f;
+        if (width > 0 && height > 0) {
+            aspectRatio = (float) width / (float) height;
+        }
+
+        // Resize the textureview housing the preview video and rotate it appropriately based on
+        // the device orientation
+        setPreviewSize(mDeviceOrientation, aspectRatio);
+    }
+
+    /**
+     * Called when call session event is raised.
+     *
+     * @param event The call session event.
+     */
+    @Override
+    public void onCallSessionEvent(int event) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("onCallSessionEvent = ");
+
+        switch (event) {
+            case Connection.VideoProvider.SESSION_EVENT_RX_PAUSE:
+                sb.append("rx_pause");
+                break;
+            case Connection.VideoProvider.SESSION_EVENT_RX_RESUME:
+                sb.append("rx_resume");
+                break;
+            case Connection.VideoProvider.SESSION_EVENT_CAMERA_FAILURE:
+                sb.append("camera_failure");
+                break;
+            case Connection.VideoProvider.SESSION_EVENT_CAMERA_READY:
+                sb.append("camera_ready");
+                break;
+            default:
+                sb.append("unknown event = ");
+                sb.append(event);
+                break;
+        }
+        Log.d(this, sb.toString());
+    }
+
+    /**
+     * Handles a change to the call data usage
+     *
+     * @param dataUsage call data usage value
+     */
+    @Override
+    public void onCallDataUsageChange(long dataUsage) {
+        Log.d(this, "onCallDataUsageChange dataUsage=" + dataUsage);
+    }
+
+    /**
+     * Handles changes to the device orientation.
+     * @param orientation The screen orientation of the device (one of:
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_0},
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_90},
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_180},
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_270}).
+     */
+    @Override
+    public void onDeviceOrientationChanged(int orientation) {
+        mDeviceOrientation = orientation;
+
+        VideoCallUi ui = getUi();
+        if (ui == null) {
+            Log.e(this, "onDeviceOrientationChanged: VideoCallUi is null");
+            return;
+        }
+
+        Point previewDimensions = ui.getPreviewSize();
+        if (previewDimensions == null) {
+            return;
+        }
+        Log.d(this, "onDeviceOrientationChanged: orientation=" + orientation + " size: "
+                + previewDimensions);
+        changePreviewDimensions(previewDimensions.x, previewDimensions.y);
+
+        ui.setPreviewRotation(mDeviceOrientation);
+    }
+
+    /**
+     * Handles an incoming upgrade to video request.
+     *
+     * @param call The call the request was received for.
+     * @param videoState The video state that the request wants to upgrade to.
+     */
+    @Override
+    public void onUpgradeToVideoRequest(Call call, int videoState) {
+        Log.d(this, "onUpgradeToVideoRequest call = " + call + " new video state = " + videoState);
+        if (mPrimaryCall == null || !Call.areSame(mPrimaryCall, call)) {
+            Log.w(this, "UpgradeToVideoRequest received for non-primary call");
+        }
+
+        if (call == null) {
+            return;
+        }
+
+        call.setRequestedVideoState(videoState);
+    }
+
+    @Override
+    public void onUpgradeToVideoSuccess(Call call) {
+        Log.d(this, "onUpgradeToVideoSuccess call=" + call);
+        if (mPrimaryCall == null || !Call.areSame(mPrimaryCall, call)) {
+            Log.w(this, "UpgradeToVideoSuccess received for non-primary call");
+        }
+
+        if (call == null) {
+            return;
+        }
+    }
+
+    @Override
+    public void onUpgradeToVideoFail(int status, Call call) {
+        Log.d(this, "onUpgradeToVideoFail call=" + call);
+        if (mPrimaryCall == null || !Call.areSame(mPrimaryCall, call)) {
+            Log.w(this, "UpgradeToVideoFail received for non-primary call");
+        }
+
+        if (call == null) {
+            return;
+        }
+    }
+
+    @Override
+    public void onDowngradeToAudio(Call call) {
+        call.setSessionModificationState(Call.SessionModificationState.NO_REQUEST);
+        // exit video mode
+        exitVideoMode();
+    }
+
+    /**
+     * Sets the preview surface size based on the current device orientation.
+     * See: {@link InCallOrientationEventListener#SCREEN_ORIENTATION_0},
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_90},
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_180},
+     * {@link InCallOrientationEventListener#SCREEN_ORIENTATION_270}).
+     *
+     * @param orientation The device orientation
+     * @param aspectRatio The aspect ratio of the camera (width / height).
+     */
+    private void setPreviewSize(int orientation, float aspectRatio) {
+        VideoCallUi ui = getUi();
+        if (ui == null) {
+            return;
+        }
+
+        int height;
+        int width;
+
+        if (orientation == InCallOrientationEventListener.SCREEN_ORIENTATION_90 ||
+                orientation == InCallOrientationEventListener.SCREEN_ORIENTATION_270) {
+            width = (int) (mMinimumVideoDimension * aspectRatio);
+            height = (int) mMinimumVideoDimension;
+        } else {
+            // Portrait or reverse portrait orientation.
+            width = (int) mMinimumVideoDimension;
+            height = (int) (mMinimumVideoDimension * aspectRatio);
+        }
+        ui.setPreviewSize(width, height);
+    }
+
+    /**
+     * Sets the display video surface size based on peer width and height
+     *
+     * @param width peer width
+     * @param height peer height
+     */
+    private void setDisplayVideoSize(int width, int height) {
+        Log.v(this, "setDisplayVideoSize: Received peer width=" + width + " height=" + height);
+        VideoCallUi ui = getUi();
+        if (ui == null) {
+            return;
+        }
+
+        // Get current display size
+        Point size = ui.getScreenSize();
+        Log.v(this, "setDisplayVideoSize: windowmgr width=" + size.x
+                + " windowmgr height=" + size.y);
+        if (size.y * width > size.x * height) {
+            // current display height is too much. Correct it
+            size.y = (int) (size.x * height / width);
+        } else if (size.y * width < size.x * height) {
+            // current display width is too much. Correct it
+            size.x = (int) (size.y * width / height);
+        }
+        ui.setDisplayVideoSize(size.x, size.y);
+    }
+
+    /**
+     * Exits fullscreen mode if the current call context has changed to a non-video call.
+     *
+     * @param call The call.
+     */
+    protected void maybeExitFullscreen(Call call) {
+        if (call == null) {
+            return;
+        }
+
+        if (!VideoUtils.isVideoCall(call) || call.getState() == Call.State.INCOMING) {
+            InCallPresenter.getInstance().setFullScreen(false);
+        }
+    }
+
+    /**
+     * Schedules auto-entering of fullscreen mode.
+     * Will not enter full screen mode if any of the following conditions are met:
+     * 1. No call
+     * 2. Call is not active
+     * 3. Call is not video call
+     * 4. Already in fullscreen mode
+     *
+     * @param call The current call.
+     */
+    protected void maybeAutoEnterFullscreen(Call call) {
+        if (!mIsAutoFullscreenEnabled) {
+            return;
+        }
+
+        if (call == null || (
+                call != null && (call.getState() != Call.State.ACTIVE ||
+                        !VideoUtils.isVideoCall(call)) ||
+                        InCallPresenter.getInstance().isFullscreen())) {
+            // Ensure any previously scheduled attempt to enter fullscreen is cancelled.
+            cancelAutoFullScreen();
+            return;
+        }
+
+        if (mAutoFullScreenPending) {
+            Log.v(this, "maybeAutoEnterFullscreen : already pending.");
+            return;
+        }
+        Log.v(this, "maybeAutoEnterFullscreen : scheduled");
+        mAutoFullScreenPending = true;
+        mHandler.postDelayed(mAutoFullscreenRunnable, mAutoFullscreenTimeoutMillis);
+    }
+
+    /**
+     * Cancels pending auto fullscreen mode.
+     */
+    public void cancelAutoFullScreen() {
+        if (!mAutoFullScreenPending) {
+            Log.v(this, "cancelAutoFullScreen : none pending.");
+            return;
+        }
+        Log.v(this, "cancelAutoFullScreen : cancelling pending");
+        mAutoFullScreenPending = false;
+    }
+
+    private static boolean isAudioRouteEnabled(int audioRoute, int audioRouteMask) {
+        return ((audioRoute & audioRouteMask) != 0);
+    }
+
+    private static void updateCameraSelection(Call call) {
+        Log.d(TAG, "updateCameraSelection: call=" + call);
+        Log.d(TAG, "updateCameraSelection: call=" + toSimpleString(call));
+
+        final Call activeCall = CallList.getInstance().getActiveCall();
+        int cameraDir = Call.VideoSettings.CAMERA_DIRECTION_UNKNOWN;
+
+        // this function should never be called with null call object, however if it happens we
+        // should handle it gracefully.
+        if (call == null) {
+            cameraDir = Call.VideoSettings.CAMERA_DIRECTION_UNKNOWN;
+            com.android.incallui.Log.e(TAG, "updateCameraSelection: Call object is null."
+                    + " Setting camera direction to default value (CAMERA_DIRECTION_UNKNOWN)");
+        }
+
+        // Clear camera direction if this is not a video call.
+        else if (VideoUtils.isAudioCall(call)) {
+            cameraDir = Call.VideoSettings.CAMERA_DIRECTION_UNKNOWN;
+            call.getVideoSettings().setCameraDir(cameraDir);
+        }
+
+        // If this is a waiting video call, default to active call's camera,
+        // since we don't want to change the current camera for waiting call
+        // without user's permission.
+        else if (VideoUtils.isVideoCall(activeCall) && VideoUtils.isIncomingVideoCall(call)) {
+            cameraDir = activeCall.getVideoSettings().getCameraDir();
+        }
+
+        // Infer the camera direction from the video state and store it,
+        // if this is an outgoing video call.
+        else if (VideoUtils.isOutgoingVideoCall(call) && !isCameraDirectionSet(call) ) {
+            cameraDir = toCameraDirection(call.getVideoState());
+            call.getVideoSettings().setCameraDir(cameraDir);
+        }
+
+        // Use the stored camera dir if this is an outgoing video call for which camera direction
+        // is set.
+        else if (VideoUtils.isOutgoingVideoCall(call)) {
+            cameraDir = call.getVideoSettings().getCameraDir();
+        }
+
+        // Infer the camera direction from the video state and store it,
+        // if this is an active video call and camera direction is not set.
+        else if (VideoUtils.isActiveVideoCall(call) && !isCameraDirectionSet(call)) {
+            cameraDir = toCameraDirection(call.getVideoState());
+            call.getVideoSettings().setCameraDir(cameraDir);
+        }
+
+        // Use the stored camera dir if this is an active video call for which camera direction
+        // is set.
+        else if (VideoUtils.isActiveVideoCall(call)) {
+            cameraDir = call.getVideoSettings().getCameraDir();
+        }
+
+        // For all other cases infer the camera direction but don't store it in the call object.
+        else {
+            cameraDir = toCameraDirection(call.getVideoState());
+        }
+
+        com.android.incallui.Log.d(TAG, "updateCameraSelection: Setting camera direction to " +
+                cameraDir + " Call=" + call);
+        final InCallCameraManager cameraManager = InCallPresenter.getInstance().
+                getInCallCameraManager();
+        cameraManager.setUseFrontFacingCamera(cameraDir ==
+                Call.VideoSettings.CAMERA_DIRECTION_FRONT_FACING);
+    }
+
+    private static int toCameraDirection(int videoState) {
+        return VideoProfileCompat.isTransmissionEnabled(videoState) &&
+                !VideoProfileCompat.isBidirectional(videoState)
+                ? Call.VideoSettings.CAMERA_DIRECTION_BACK_FACING
+                : Call.VideoSettings.CAMERA_DIRECTION_FRONT_FACING;
+    }
+
+    private static boolean isCameraDirectionSet(Call call) {
+        return VideoUtils.isVideoCall(call) && call.getVideoSettings().getCameraDir()
+                    != Call.VideoSettings.CAMERA_DIRECTION_UNKNOWN;
+    }
+
+    private static String toSimpleString(Call call) {
+        return call == null ? null : call.toSimpleString();
+    }
+
+    /**
+     * Starts an asynchronous load of the user's profile photo.
+     */
+    public void loadProfilePhotoAsync() {
+        final VideoCallUi ui = getUi();
+        if (ui == null) {
+            return;
+        }
+
+        final AsyncTask<Void, Void, Void> task = new AsyncTask<Void, Void, Void>() {
+            /**
+             * Performs asynchronous load of the user profile information.
+             *
+             * @param params The parameters of the task.
+             *
+             * @return {@code null}.
+             */
+            @Override
+            protected Void doInBackground(Void... params) {
+                if (mProfileInfo == null) {
+                    // Try and read the photo URI from the local profile.
+                    mProfileInfo = new ContactInfoCache.ContactCacheEntry();
+                    final Cursor cursor = mContext.getContentResolver().query(
+                            ContactsContract.Profile.CONTENT_URI, new String[]{
+                                    ContactsContract.CommonDataKinds.Phone._ID,
+                                    ContactsContract.CommonDataKinds.Phone.PHOTO_URI,
+                                    ContactsContract.CommonDataKinds.Phone.LOOKUP_KEY,
+                                    ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME,
+                                    ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME_ALTERNATIVE
+                            }, null, null, null);
+                    if (cursor != null) {
+                        try {
+                            if (cursor.moveToFirst()) {
+                                mProfileInfo.lookupKey = cursor.getString(cursor.getColumnIndex(
+                                        ContactsContract.CommonDataKinds.Phone.LOOKUP_KEY));
+                                String photoUri = cursor.getString(cursor.getColumnIndex(
+                                        ContactsContract.CommonDataKinds.Phone.PHOTO_URI));
+                                mProfileInfo.displayPhotoUri = photoUri == null ? null
+                                        : Uri.parse(photoUri);
+                                mProfileInfo.namePrimary = cursor.getString(cursor.getColumnIndex(
+                                        ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME));
+                                mProfileInfo.nameAlternative = cursor.getString(
+                                        cursor.getColumnIndex(ContactsContract.CommonDataKinds
+                                                        .Phone.DISPLAY_NAME_ALTERNATIVE));
+                            }
+                        } finally {
+                            cursor.close();
+                        }
+                    }
+                }
+                return null;
+            }
+
+            @Override
+            protected void onPostExecute(Void result) {
+                // If user profile information was found, issue an async request to load the user's
+                // profile photo.
+                if (mProfileInfo != null) {
+                    if (mContactPhotoManager == null) {
+                        mContactPhotoManager = ContactPhotoManager.getInstance(mContext);
+                    }
+                    ContactPhotoManager.DefaultImageRequest imageRequest = (mProfileInfo != null)
+                            ? null :
+                            new ContactPhotoManager.DefaultImageRequest(mProfileInfo.namePrimary,
+                                    mProfileInfo.lookupKey, false /* isCircularPhoto */);
+
+                    ImageView photoView = ui.getPreviewPhotoView();
+                    if (photoView == null) {
+                        return;
+                    }
+                    mContactPhotoManager.loadDirectoryPhoto(photoView,
+                                    mProfileInfo.displayPhotoUri,
+                                    false /* darkTheme */, false /* isCircular */, imageRequest);
+                }
+            }
+        };
+
+        task.execute();
+    }
+
+    /**
+     * Defines the VideoCallUI interactions.
+     */
+    public interface VideoCallUi extends Ui {
+        void showVideoViews(boolean showPreview, boolean showIncoming);
+        void hideVideoUi();
+        boolean isDisplayVideoSurfaceCreated();
+        boolean isPreviewVideoSurfaceCreated();
+        Surface getDisplayVideoSurface();
+        Surface getPreviewVideoSurface();
+        int getCurrentRotation();
+        void setPreviewSize(int width, int height);
+        void setPreviewSurfaceSize(int width, int height);
+        void setDisplayVideoSize(int width, int height);
+        Point getScreenSize();
+        Point getPreviewSize();
+        void cleanupSurfaces();
+        ImageView getPreviewPhotoView();
+        void adjustPreviewLocation(boolean shiftUp, int offset);
+        void setPreviewRotation(int orientation);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/VideoPauseController.java b/InCallUI/src/com/android/incallui/VideoPauseController.java
new file mode 100644
index 0000000..070448e
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/VideoPauseController.java
@@ -0,0 +1,458 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import com.android.incallui.Call.State;
+import com.android.incallui.InCallPresenter.InCallState;
+import com.android.incallui.InCallPresenter.InCallStateListener;
+import com.android.incallui.InCallPresenter.IncomingCallListener;
+import com.android.incallui.InCallVideoCallCallbackNotifier.SessionModificationListener;
+import com.google.common.base.Preconditions;
+
+/**
+ * This class is responsible for generating video pause/resume requests when the InCall UI is sent
+ * to the background and subsequently brought back to the foreground.
+ */
+class VideoPauseController implements InCallStateListener, IncomingCallListener,
+        SessionModificationListener {
+    private static final String TAG = "VideoPauseController";
+
+    /**
+     * Keeps track of the current active/foreground call.
+     */
+    private class CallContext {
+        public CallContext(Call call) {
+            Preconditions.checkNotNull(call);
+            update(call);
+        }
+
+        public void update(Call call) {
+            mCall = Preconditions.checkNotNull(call);
+            mState = call.getState();
+            mVideoState = call.getVideoState();
+        }
+
+        public int getState() {
+            return mState;
+        }
+
+        public int getVideoState() {
+            return mVideoState;
+        }
+
+        public String toString() {
+            return String.format("CallContext {CallId=%s, State=%s, VideoState=%d}",
+                    mCall.getId(), mState, mVideoState);
+        }
+
+        public Call getCall() {
+            return mCall;
+        }
+
+        private int mState = State.INVALID;
+        private int mVideoState;
+        private Call mCall;
+    }
+
+    private InCallPresenter mInCallPresenter;
+    private static VideoPauseController sVideoPauseController;
+
+    /**
+     * The current call context, if applicable.
+     */
+    private CallContext mPrimaryCallContext = null;
+
+    /**
+     * Tracks whether the application is in the background. {@code True} if the application is in
+     * the background, {@code false} otherwise.
+     */
+    private boolean mIsInBackground = false;
+
+    /**
+     * Singleton accessor for the {@link VideoPauseController}.
+     * @return Singleton instance of the {@link VideoPauseController}.
+     */
+    /*package*/
+    static synchronized VideoPauseController getInstance() {
+        if (sVideoPauseController == null) {
+            sVideoPauseController = new VideoPauseController();
+        }
+        return sVideoPauseController;
+    }
+
+    /**
+     * Configures the {@link VideoPauseController} to listen to call events.  Configured via the
+     * {@link com.android.incallui.InCallPresenter}.
+     *
+     * @param inCallPresenter The {@link com.android.incallui.InCallPresenter}.
+     */
+    public void setUp(InCallPresenter inCallPresenter) {
+        log("setUp");
+        mInCallPresenter = Preconditions.checkNotNull(inCallPresenter);
+        mInCallPresenter.addListener(this);
+        mInCallPresenter.addIncomingCallListener(this);
+        InCallVideoCallCallbackNotifier.getInstance().addSessionModificationListener(this);
+    }
+
+    /**
+     * Cleans up the {@link VideoPauseController} by removing all listeners and clearing its
+     * internal state.  Called from {@link com.android.incallui.InCallPresenter}.
+     */
+    public void tearDown() {
+        log("tearDown...");
+        InCallVideoCallCallbackNotifier.getInstance().removeSessionModificationListener(this);
+        mInCallPresenter.removeListener(this);
+        mInCallPresenter.removeIncomingCallListener(this);
+        clear();
+    }
+
+    /**
+     * Clears the internal state for the {@link VideoPauseController}.
+     */
+    private void clear() {
+        mInCallPresenter = null;
+        mPrimaryCallContext = null;
+        mIsInBackground = false;
+    }
+
+    /**
+     * Handles changes in the {@link InCallState}.  Triggers pause and resumption of video for the
+     * current foreground call.
+     *
+     * @param oldState The previous {@link InCallState}.
+     * @param newState The current {@link InCallState}.
+     * @param callList List of current call.
+     */
+    @Override
+    public void onStateChange(InCallState oldState, InCallState newState, CallList callList) {
+        log("onStateChange, OldState=" + oldState + " NewState=" + newState);
+
+        Call call = null;
+        if (newState == InCallState.INCOMING) {
+            call = callList.getIncomingCall();
+        } else if (newState == InCallState.WAITING_FOR_ACCOUNT) {
+            call = callList.getWaitingForAccountCall();
+        } else if (newState == InCallState.PENDING_OUTGOING) {
+            call = callList.getPendingOutgoingCall();
+        } else if (newState == InCallState.OUTGOING) {
+            call = callList.getOutgoingCall();
+        } else {
+            call = callList.getActiveCall();
+        }
+
+        boolean hasPrimaryCallChanged = !areSame(call, mPrimaryCallContext);
+        boolean canVideoPause = VideoUtils.canVideoPause(call);
+        log("onStateChange, hasPrimaryCallChanged=" + hasPrimaryCallChanged);
+        log("onStateChange, canVideoPause=" + canVideoPause);
+        log("onStateChange, IsInBackground=" + mIsInBackground);
+
+        if (hasPrimaryCallChanged) {
+            onPrimaryCallChanged(call);
+            return;
+        }
+
+        if (isDialing(mPrimaryCallContext) && canVideoPause && mIsInBackground) {
+            // Bring UI to foreground if outgoing request becomes active while UI is in
+            // background.
+            bringToForeground();
+        } else if (!isVideoCall(mPrimaryCallContext) && canVideoPause && mIsInBackground) {
+            // Bring UI to foreground if VoLTE call becomes active while UI is in
+            // background.
+            bringToForeground();
+        }
+
+        updatePrimaryCallContext(call);
+    }
+
+    /**
+     * Handles a change to the primary call.
+     * <p>
+     * Reject incoming or hangup dialing call: Where the previous call was an incoming call or a
+     * call in dialing state, resume the new primary call.
+     * Call swap: Where the new primary call is incoming, pause video on the previous primary call.
+     *
+     * @param call The new primary call.
+     */
+    private void onPrimaryCallChanged(Call call) {
+        log("onPrimaryCallChanged: New call = " + call);
+        log("onPrimaryCallChanged: Old call = " + mPrimaryCallContext);
+        log("onPrimaryCallChanged, IsInBackground=" + mIsInBackground);
+
+        Preconditions.checkState(!areSame(call, mPrimaryCallContext));
+        final boolean canVideoPause = VideoUtils.canVideoPause(call);
+
+        if ((isIncomingCall(mPrimaryCallContext) || isDialing(mPrimaryCallContext))
+                && canVideoPause && !mIsInBackground) {
+            // Send resume request for the active call, if user rejects incoming call or ends
+            // dialing call and UI is in the foreground.
+            sendRequest(call, true);
+        } else if (isIncomingCall(call) && canVideoPause(mPrimaryCallContext)) {
+            // Send pause request if there is an active video call, and we just received a new
+            // incoming call.
+            sendRequest(mPrimaryCallContext.getCall(), false);
+        }
+
+        updatePrimaryCallContext(call);
+    }
+
+    /**
+     * Handles new incoming calls by triggering a change in the primary call.
+     *
+     * @param oldState the old {@link InCallState}.
+     * @param newState the new {@link InCallState}.
+     * @param call the incoming call.
+     */
+    @Override
+    public void onIncomingCall(InCallState oldState, InCallState newState, Call call) {
+        log("onIncomingCall, OldState=" + oldState + " NewState=" + newState + " Call=" + call);
+
+        if (areSame(call, mPrimaryCallContext)) {
+            return;
+        }
+
+        onPrimaryCallChanged(call);
+    }
+
+    /**
+     * Caches a reference to the primary call and stores its previous state.
+     *
+     * @param call The new primary call.
+     */
+    private void updatePrimaryCallContext(Call call) {
+        if (call == null) {
+            mPrimaryCallContext = null;
+        } else if (mPrimaryCallContext != null) {
+            mPrimaryCallContext.update(call);
+        } else {
+            mPrimaryCallContext = new CallContext(call);
+        }
+    }
+
+    /**
+     * Called when UI goes in/out of the foreground.
+     * @param showing true if UI is in the foreground, false otherwise.
+     */
+    public void onUiShowing(boolean showing) {
+        // Only send pause/unpause requests if we are in the INCALL state.
+        if (mInCallPresenter == null || mInCallPresenter.getInCallState() != InCallState.INCALL) {
+            return;
+        }
+
+        if (showing) {
+            onResume();
+        } else {
+            onPause();
+        }
+    }
+
+    /**
+     * Handles requests to upgrade to video.
+     *
+     * @param call The call the request was received for.
+     * @param videoState The video state that the request wants to upgrade to.
+     */
+    @Override
+    public void onUpgradeToVideoRequest(Call call, int videoState) {
+        // Not used.
+    }
+
+    /**
+     * Handles successful upgrades to video.
+     * @param call The call the request was successful for.
+     */
+    @Override
+    public void onUpgradeToVideoSuccess(Call call) {
+        // Not used.
+    }
+
+    /**
+     * Handles a failure to upgrade a call to video.
+     *
+     * @param status The failure status.
+     * @param call The call the request was successful for.
+     */
+    @Override
+    public void onUpgradeToVideoFail(int status, Call call) {
+        // TODO (ims-vt) Automatically bring in call ui to foreground.
+    }
+
+    /**
+     * Handles a downgrade of a call to audio-only.
+     *
+     * @param call The call which was downgraded to audio-only.
+     */
+    @Override
+    public void onDowngradeToAudio(Call call) {
+    }
+
+    /**
+     * Called when UI is brought to the foreground.  Sends a session modification request to resume
+     * the outgoing video.
+     */
+    private void onResume() {
+        log("onResume");
+
+        mIsInBackground = false;
+        if (canVideoPause(mPrimaryCallContext)) {
+            sendRequest(mPrimaryCallContext.getCall(), true);
+        } else {
+            log("onResume. Ignoring...");
+        }
+    }
+
+    /**
+     * Called when UI is sent to the background.  Sends a session modification request to pause the
+     * outgoing video.
+     */
+    private void onPause() {
+        log("onPause");
+
+        mIsInBackground = true;
+        if (canVideoPause(mPrimaryCallContext)) {
+            sendRequest(mPrimaryCallContext.getCall(), false);
+        } else {
+            log("onPause, Ignoring...");
+        }
+    }
+
+    private void bringToForeground() {
+        if (mInCallPresenter != null) {
+            log("Bringing UI to foreground");
+            mInCallPresenter.bringToForeground(false);
+        } else {
+            loge("InCallPresenter is null. Cannot bring UI to foreground");
+        }
+    }
+
+    /**
+     * Sends Pause/Resume request.
+     *
+     * @param call Call to be paused/resumed.
+     * @param resume If true resume request will be sent, otherwise pause request.
+     */
+    private void sendRequest(Call call, boolean resume) {
+        // Check if this call supports pause/un-pause.
+        if (!call.can(android.telecom.Call.Details.CAPABILITY_CAN_PAUSE_VIDEO)) {
+            return;
+        }
+
+        if (resume) {
+            log("sending resume request, call=" + call);
+            call.getVideoCall()
+                    .sendSessionModifyRequest(VideoUtils.makeVideoUnPauseProfile(call));
+        } else {
+            log("sending pause request, call=" + call);
+            call.getVideoCall().sendSessionModifyRequest(VideoUtils.makeVideoPauseProfile(call));
+        }
+    }
+
+    /**
+     * Determines if a given call is the same one stored in a {@link CallContext}.
+     *
+     * @param call The call.
+     * @param callContext The call context.
+     * @return {@code true} if the {@link Call} is the same as the one referenced in the
+     *      {@link CallContext}.
+     */
+    private static boolean areSame(Call call, CallContext callContext) {
+        if (call == null && callContext == null) {
+            return true;
+        } else if (call == null || callContext == null) {
+            return false;
+        }
+        return call.equals(callContext.getCall());
+    }
+
+    /**
+     * Determines if a video call can be paused.  Only a video call which is active can be paused.
+     *
+     * @param callContext The call context to check.
+     * @return {@code true} if the call is an active video call.
+     */
+    private static boolean canVideoPause(CallContext callContext) {
+        return isVideoCall(callContext) && callContext.getState() == Call.State.ACTIVE;
+    }
+
+    /**
+     * Determines if a call referenced by a {@link CallContext} is a video call.
+     *
+     * @param callContext The call context.
+     * @return {@code true} if the call is a video call, {@code false} otherwise.
+     */
+    private static boolean isVideoCall(CallContext callContext) {
+        return callContext != null && VideoUtils.isVideoCall(callContext.getVideoState());
+    }
+
+    /**
+     * Determines if call is in incoming/waiting state.
+     *
+     * @param call The call context.
+     * @return {@code true} if the call is in incoming or waiting state, {@code false} otherwise.
+     */
+    private static boolean isIncomingCall(CallContext call) {
+        return call != null && isIncomingCall(call.getCall());
+    }
+
+    /**
+     * Determines if a call is in incoming/waiting state.
+     *
+     * @param call The call.
+     * @return {@code true} if the call is in incoming or waiting state, {@code false} otherwise.
+     */
+    private static boolean isIncomingCall(Call call) {
+        return call != null && (call.getState() == Call.State.CALL_WAITING
+                || call.getState() == Call.State.INCOMING);
+    }
+
+    /**
+     * Determines if a call is dialing.
+     *
+     * @param call The call context.
+     * @return {@code true} if the call is dialing, {@code false} otherwise.
+     */
+    private static boolean isDialing(CallContext call) {
+        return call != null && Call.State.isDialing(call.getState());
+    }
+
+    /**
+     * Determines if a call is holding.
+     *
+     * @param call The call context.
+     * @return {@code true} if the call is holding, {@code false} otherwise.
+     */
+    private static boolean isHolding(CallContext call) {
+        return call != null && call.getState() == Call.State.ONHOLD;
+    }
+
+    /**
+     * Logs a debug message.
+     *
+     * @param msg The message.
+     */
+    private void log(String msg) {
+        Log.d(this, TAG + msg);
+    }
+
+    /**
+     * Logs an error message.
+     *
+     * @param msg The message.
+     */
+    private void loge(String msg) {
+        Log.e(this, TAG + msg);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/VideoUtils.java b/InCallUI/src/com/android/incallui/VideoUtils.java
new file mode 100644
index 0000000..7e0926b
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/VideoUtils.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.telecom.VideoProfile;
+
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.incallui.compat.telecom.VideoProfileCompat;
+
+import com.google.common.base.Preconditions;
+
+public class VideoUtils {
+
+    public static boolean isVideoCall(Call call) {
+        return call != null && isVideoCall(call.getVideoState());
+    }
+
+    public static boolean isVideoCall(int videoState) {
+        if (!CompatUtils.isVideoCompatible()) {
+            return false;
+        }
+
+        return VideoProfileCompat.isTransmissionEnabled(videoState)
+                || VideoProfileCompat.isReceptionEnabled(videoState);
+    }
+
+    public static boolean isBidirectionalVideoCall(Call call) {
+        if (!CompatUtils.isVideoCompatible()) {
+            return false;
+        }
+
+        return VideoProfileCompat.isBidirectional(call.getVideoState());
+    }
+
+    public static boolean isIncomingVideoCall(Call call) {
+        if (!VideoUtils.isVideoCall(call)) {
+            return false;
+        }
+        final int state = call.getState();
+        return (state == Call.State.INCOMING) || (state == Call.State.CALL_WAITING);
+    }
+
+    public static boolean isActiveVideoCall(Call call) {
+        return VideoUtils.isVideoCall(call) && call.getState() == Call.State.ACTIVE;
+    }
+
+    public static boolean isOutgoingVideoCall(Call call) {
+        if (!VideoUtils.isVideoCall(call)) {
+            return false;
+        }
+        final int state = call.getState();
+        return Call.State.isDialing(state) || state == Call.State.CONNECTING
+                || state == Call.State.SELECT_PHONE_ACCOUNT;
+    }
+
+    public static boolean isAudioCall(Call call) {
+        if (!CompatUtils.isVideoCompatible()) {
+            return true;
+        }
+
+        return call != null && VideoProfileCompat.isAudioOnly(call.getVideoState());
+    }
+
+    // TODO (ims-vt) Check if special handling is needed for CONF calls.
+    public static boolean canVideoPause(Call call) {
+        return isVideoCall(call) && call.getState() == Call.State.ACTIVE;
+    }
+
+    public static VideoProfile makeVideoPauseProfile(Call call) {
+        Preconditions.checkNotNull(call);
+        Preconditions.checkState(!VideoProfileCompat.isAudioOnly(call.getVideoState()));
+        return new VideoProfile(getPausedVideoState(call.getVideoState()));
+    }
+
+    public static VideoProfile makeVideoUnPauseProfile(Call call) {
+        Preconditions.checkNotNull(call);
+        return new VideoProfile(getUnPausedVideoState(call.getVideoState()));
+    }
+
+    public static int getUnPausedVideoState(int videoState) {
+        return videoState & (~VideoProfile.STATE_PAUSED);
+    }
+
+    public static int getPausedVideoState(int videoState) {
+        return videoState | VideoProfile.STATE_PAUSED;
+    }
+
+}
diff --git a/InCallUI/src/com/android/incallui/async/PausableExecutor.java b/InCallUI/src/com/android/incallui/async/PausableExecutor.java
new file mode 100644
index 0000000..1b8201a
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/async/PausableExecutor.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.async;
+
+import com.android.contacts.common.testing.NeededForTesting;
+
+import java.util.concurrent.Executor;
+
+/**
+ * Executor that can be used to easily synchronize testing and production code. Production code
+ * should call {@link #milestone()} at points in the code where the state of the system is worthy of
+ * testing. In a test scenario, this method will pause execution until the test acknowledges the
+ * milestone through the use of {@link #ackMilestoneForTesting()}.
+ */
+public interface PausableExecutor extends Executor {
+
+    /**
+     * Method called from asynchronous production code to inform this executor that it has
+     * reached a point that puts the system into a state worth testing. TestableExecutors intended
+     * for use in a testing environment should cause the calling thread to block. In the production
+     * environment this should be a no-op.
+     */
+    void milestone();
+
+    /**
+     * Method called from the test code to inform this executor that the state of the production
+     * system at the current milestone has been sufficiently tested. Every milestone must be
+     * acknowledged.
+     */
+    @NeededForTesting
+    void ackMilestoneForTesting();
+
+    /**
+     * Method called from the test code to inform this executor that the tests are finished with all
+     * milestones. Future calls to {@link #milestone()} or {@link #awaitMilestoneForTesting()}
+     * should return immediately.
+     */
+    @NeededForTesting
+    void ackAllMilestonesForTesting();
+
+    /**
+     * Method called from the test code to block until a milestone has been reached in the
+     * production code.
+     */
+    @NeededForTesting
+    void awaitMilestoneForTesting() throws InterruptedException;
+}
diff --git a/InCallUI/src/com/android/incallui/async/PausableExecutorImpl.java b/InCallUI/src/com/android/incallui/async/PausableExecutorImpl.java
new file mode 100644
index 0000000..15900e5
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/async/PausableExecutorImpl.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.async;
+
+import java.util.concurrent.Executors;
+
+/**
+ * {@link PausableExecutor} intended for use in production environments.
+ */
+public class PausableExecutorImpl implements PausableExecutor {
+
+    @Override
+    public void milestone() {}
+
+    @Override
+    public void ackMilestoneForTesting() {}
+
+    @Override
+    public void ackAllMilestonesForTesting() {}
+
+    @Override
+    public void awaitMilestoneForTesting() {}
+
+    @Override
+    public void execute(Runnable command) {
+        Executors.newSingleThreadExecutor().execute(command);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/compat/telecom/DetailsCompat.java b/InCallUI/src/com/android/incallui/compat/telecom/DetailsCompat.java
new file mode 100644
index 0000000..b9f82a9
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/compat/telecom/DetailsCompat.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.incallui.compat.telecom;
+
+import android.os.Build;
+import android.os.Bundle;
+import android.telecom.Call.Details;
+
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.incallui.Log;
+
+/**
+ * Compatibility class for {@link Details}
+ */
+public class DetailsCompat {
+
+    /**
+     * Constant formerly in L as PhoneCapabilities#ADD_CALL. It was transferred to
+     * {@link Details#CAPABILITY_UNUSED_1} and hidden
+     */
+    public static final int CAPABILITY_UNUSED_1 = 0x00000010;
+
+    /**
+     * Returns the intent extras from the given {@link Details}
+     * For Sdk version L and earlier, this will return {@link Details#getExtras()}
+     *
+     * @param details The details whose intent extras should be returned
+     * @return The given details' intent extras
+     */
+    public static Bundle getIntentExtras(Details details) {
+        if (CompatUtils.isMarshmallowCompatible()) {
+            return details.getIntentExtras();
+        }
+        return details.getExtras();
+    }
+
+    /**
+     * Compatibility method to check whether the supplied properties includes the
+     * specified property.
+     *
+     * @param details The details whose properties should be checked.
+     * @param property The property to check properties for.
+     * @return Whether the specified property is supported.
+     */
+    public static boolean hasProperty(Details details, int property) {
+        if (CompatUtils.isMarshmallowCompatible()) {
+            return details.hasProperty(property);
+        }
+        return (details.getCallProperties() & property) != 0;
+    }
+
+    /**
+     * Compatibility method to check whether the capabilities of the given {@code Details}
+     * supports the specified capability.
+     *
+     * @param details The details whose capabilities should be checked.
+     * @param capability The capability to check capabilities for.
+     * @return Whether the specified capability is supported.
+     */
+    public static boolean can(Details details, int capability) {
+        if (CompatUtils.isLollipopMr1Compatible()) {
+            return details.can(capability);
+        }
+        return (details.getCallCapabilities() & capability) != 0;
+    }
+
+    /**
+     * Render a set of capability bits ({@code CAPABILITY_*}) as a human readable string.
+     *
+     * @param capabilities A capability bit field.
+     * @return A human readable string representation.
+     */
+    public static String capabilitiesToString(int capabilities) {
+        if (CompatUtils.isLollipopMr1Compatible()) {
+            return Details.capabilitiesToString(capabilities);
+        }
+        return capabilitiesToStringLollipop(capabilities);
+    }
+
+    /*
+     * Use reflection to call PhoneCapabilities.toString. InCallUI code is only run on Google
+     * Experience phones, so we will be the system Dialer and the method will exist
+     */
+    private static String capabilitiesToStringLollipop(int capabilities) {
+        try {
+            return (String) Class.forName("android.telecom.PhoneCapabilities")
+                    .getMethod("toString", Integer.TYPE)
+                    .invoke(null, capabilities);
+        } catch (ReflectiveOperationException e) {
+            Log.e(DetailsCompat.class, "Unable to use reflection to call "
+                    + "android.telecom.PhoneCapabilities.toString(int)", e);
+            return String.valueOf(capabilities);
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/compat/telecom/InCallServiceCompat.java b/InCallUI/src/com/android/incallui/compat/telecom/InCallServiceCompat.java
new file mode 100644
index 0000000..0a3cb26
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/compat/telecom/InCallServiceCompat.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.incallui.compat.telecom;
+
+import android.support.annotation.Nullable;
+import android.telecom.InCallService;
+
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.incallui.Call;
+import com.android.incallui.InCallServiceImpl;
+
+/**
+ * Compatibility class for {@link android.telecom.InCallService}
+ */
+public class InCallServiceCompat {
+
+    /**
+     * Sets the microphone mute state. When this request is honored, there
+     * will be a change to the {@link android.telecom.CallAudioState}.
+     *
+     * Note: Noop for Sdk versions less than M where inCallService is not of type
+     * {@link InCallServiceImpl}
+     *
+     * @param inCallService the {@link InCallService} to act on
+     * @param shouldMute {@code true} if the microphone should be muted; {@code false} otherwise.
+     */
+    public static void setMuted(@Nullable InCallService inCallService, boolean shouldMute) {
+        if (inCallService == null) {
+            return;
+        }
+        if (CompatUtils.isMarshmallowCompatible()) {
+            inCallService.setMuted(shouldMute);
+            return;
+        }
+
+        if (inCallService instanceof InCallServiceImpl) {
+            ((InCallServiceImpl) inCallService).setMutedCompat(shouldMute);
+        }
+    }
+
+    /**
+     * Sets the audio route (speaker, bluetooth, etc...).  When this request is honored, there will
+     * be change to the {@link android.telecom.CallAudioState}.
+     *
+     * Note: Noop for Sdk versions less than M where inCallService is not of type
+     * {@link InCallServiceImpl}
+     *
+     * @param inCallService the {@link InCallService} to act on
+     * @param route The audio route to use.
+     */
+    public static void setAudioRoute(@Nullable InCallService inCallService, int route) {
+        if (inCallService == null) {
+            return;
+        }
+        if (CompatUtils.isMarshmallowCompatible()) {
+            inCallService.setAudioRoute(route);
+            return;
+        }
+
+        if (inCallService instanceof InCallServiceImpl) {
+            ((InCallServiceImpl) inCallService).setAudioRouteCompat(route);
+        }
+    }
+
+    /**
+     * Returns if the device can support additional calls.
+     *
+     * @param inCallService the {@link InCallService} to act on
+     * @param call a {@link Call} to use if needed due to compatibility reasons
+     * @return Whether the phone supports adding more calls, defaulting to true if inCallService
+     *    is null
+     */
+    public static boolean canAddCall(@Nullable InCallService inCallService, Call call) {
+        if (inCallService == null) {
+            return true;
+        }
+
+        if (CompatUtils.isMarshmallowCompatible()) {
+            // Default to true if we are not connected to telecom.
+            return inCallService.canAddCall();
+        }
+        return call.can(DetailsCompat.CAPABILITY_UNUSED_1);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/compat/telecom/VideoProfileCompat.java b/InCallUI/src/com/android/incallui/compat/telecom/VideoProfileCompat.java
new file mode 100644
index 0000000..6e81bd7
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/compat/telecom/VideoProfileCompat.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.incallui.compat.telecom;
+
+import android.telecom.VideoProfile;
+
+import com.android.contacts.common.compat.CompatUtils;
+
+/**
+ * Compatibility class for {@link android.telecom.VideoProfile}
+ */
+public class VideoProfileCompat {
+
+    /**
+     * Generates a string representation of a video state.
+     *
+     * @param videoState The video state.
+     * @return String representation of the video state.
+     */
+    public static String videoStateToString(int videoState) {
+        if (CompatUtils.isMarshmallowCompatible()) {
+            return VideoProfile.videoStateToString(videoState);
+        }
+        return videoStateToStringLollipop(videoState);
+    }
+
+    /**
+     * Copied from {@link android.telecom.VideoProfile#videoStateToString}
+     */
+    private static String videoStateToStringLollipop(int videoState) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Audio");
+        if (isAudioOnly(videoState)) {
+            sb.append(" Only");
+        } else {
+            if (isTransmissionEnabled(videoState)) {
+                sb.append(" Tx");
+            }
+            if (isReceptionEnabled(videoState)) {
+                sb.append(" Rx");
+            }
+            if (isPaused(videoState)) {
+                sb.append(" Pause");
+            }
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Indicates whether the video state is audio only.
+     *
+     * @param videoState The video state.
+     * @return {@code true} if the video state is audio only, {@code false} otherwise.
+     */
+    public static boolean isAudioOnly(int videoState) {
+        if (CompatUtils.isMarshmallowCompatible()) {
+            return VideoProfile.isAudioOnly(videoState);
+        }
+        return !hasState(videoState, VideoProfile.STATE_TX_ENABLED)
+                && !hasState(videoState, VideoProfile.STATE_RX_ENABLED);
+    }
+
+    /**
+     * Indicates whether the video state has video transmission enabled.
+     *
+     * @param videoState The video state.
+     * @return {@code true} if video transmission is enabled, {@code false} otherwise.
+     */
+    public static boolean isTransmissionEnabled(int videoState) {
+        if (CompatUtils.isMarshmallowCompatible()) {
+            return VideoProfile.isTransmissionEnabled(videoState);
+        }
+        return hasState(videoState, VideoProfile.STATE_TX_ENABLED);
+    }
+
+    /**
+     * Indicates whether the video state has video reception enabled.
+     *
+     * @param videoState The video state.
+     * @return {@code true} if video reception is enabled, {@code false} otherwise.
+     */
+    public static boolean isReceptionEnabled(int videoState) {
+        if (CompatUtils.isMarshmallowCompatible()) {
+            return VideoProfile.isReceptionEnabled(videoState);
+        }
+        return hasState(videoState, VideoProfile.STATE_RX_ENABLED);
+    }
+
+    /**
+     * Indicates whether the video state is paused.
+     *
+     * @param videoState The video state.
+     * @return {@code true} if the video is paused, {@code false} otherwise.
+     */
+    public static boolean isPaused(int videoState) {
+        if (CompatUtils.isMarshmallowCompatible()) {
+            return VideoProfile.isPaused(videoState);
+        }
+        return hasState(videoState, VideoProfile.STATE_PAUSED);
+    }
+
+    /**
+     * Copied from {@link android.telecom.VideoProfile}
+     *
+     * Determines if a specified state is set in a videoState bit-mask.
+     *
+     * @param videoState The video state bit-mask.
+     * @param state The state to check.
+     * @return {@code true} if the state is set.
+     */
+    private static boolean hasState(int videoState, int state) {
+        return (videoState & state) == state;
+    }
+
+    /**
+     * Indicates whether the video state is bi-directional.
+     *
+     * @param videoState The video state.
+     * @return {@code True} if the video is bi-directional, {@code false} otherwise.
+     */
+    public static boolean isBidirectional(int videoState) {
+        if (CompatUtils.isMarshmallowCompatible()) {
+            return VideoProfile.isBidirectional(videoState);
+        }
+        return hasState(videoState, VideoProfile.STATE_BIDIRECTIONAL);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/ringtone/DialerRingtoneManager.java b/InCallUI/src/com/android/incallui/ringtone/DialerRingtoneManager.java
new file mode 100644
index 0000000..29d3d9d
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ringtone/DialerRingtoneManager.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.ringtone;
+
+import com.google.common.base.Preconditions;
+
+import android.net.Uri;
+import android.support.annotation.Nullable;
+
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.contacts.common.testing.NeededForTesting;
+import com.android.incallui.Call;
+import com.android.incallui.Call.State;
+import com.android.incallui.CallList;
+
+/**
+ * Class that determines when ringtones should be played and can play the call waiting tone when
+ * necessary.
+ */
+public class DialerRingtoneManager {
+
+    /*
+     * Flag used to determine if the Dialer is responsible for playing ringtones for incoming calls.
+     * Once we're ready to enable Dialer Ringing, these flags should be removed.
+     */
+    private static final boolean IS_DIALER_RINGING_ENABLED = false;
+    private Boolean mIsDialerRingingEnabledForTesting;
+
+    private final InCallTonePlayer mInCallTonePlayer;
+    private final CallList mCallList;
+
+    /**
+     * Creates the DialerRingtoneManager with the given {@link InCallTonePlayer}.
+     *
+     * @param inCallTonePlayer the tone player used to play in-call tones.
+     * @param callList the CallList used to check for {@link State#CALL_WAITING}
+     * @throws NullPointerException if inCallTonePlayer or callList are null
+     */
+    public DialerRingtoneManager(InCallTonePlayer inCallTonePlayer, CallList callList) {
+        mInCallTonePlayer = Preconditions.checkNotNull(inCallTonePlayer);
+        mCallList = Preconditions.checkNotNull(callList);
+    }
+
+    /**
+     * Determines if a ringtone should be played for the given call state (see {@link State}) and
+     * {@link Uri}.
+     *
+     * @param callState the call state for the call being checked.
+     * @param ringtoneUri the ringtone to potentially play.
+     * @return {@code true} if the ringtone should be played, {@code false} otherwise.
+     */
+    public boolean shouldPlayRingtone(int callState, @Nullable Uri ringtoneUri) {
+        return isDialerRingingEnabled()
+                && translateCallStateForCallWaiting(callState) == State.INCOMING
+                && ringtoneUri != null;
+    }
+
+    /**
+     * The incoming callState is never set as {@link State#CALL_WAITING} because
+     * {@link Call#translateState(int)} doesn't account for that case, check for it here
+     */
+    private int translateCallStateForCallWaiting(int callState) {
+        if (callState != State.INCOMING) {
+            return callState;
+        }
+        return mCallList.getActiveCall() == null ? State.INCOMING : State.CALL_WAITING;
+    }
+
+    private boolean isDialerRingingEnabled() {
+        if (mIsDialerRingingEnabledForTesting != null) {
+            return mIsDialerRingingEnabledForTesting;
+        }
+        return CompatUtils.isNCompatible() && IS_DIALER_RINGING_ENABLED;
+    }
+
+    /**
+     * Determines if a call waiting tone should be played for the the given call state
+     * (see {@link State}).
+     *
+     * @param callState the call state for the call being checked.
+     * @return {@code true} if the call waiting tone should be played, {@code false} otherwise.
+     */
+    public boolean shouldPlayCallWaitingTone(int callState) {
+        return isDialerRingingEnabled()
+                && translateCallStateForCallWaiting(callState) == State.CALL_WAITING
+                && !mInCallTonePlayer.isPlayingTone();
+    }
+
+    /**
+     * Plays the call waiting tone.
+     */
+    public void playCallWaitingTone() {
+        if (!isDialerRingingEnabled()) {
+            return;
+        }
+        mInCallTonePlayer.play(InCallTonePlayer.TONE_CALL_WAITING);
+    }
+
+    /**
+     * Stops playing the call waiting tone.
+     */
+    public void stopCallWaitingTone() {
+        if (!isDialerRingingEnabled()) {
+            return;
+        }
+        mInCallTonePlayer.stop();
+    }
+
+    @NeededForTesting
+    void setDialerRingingEnabledForTesting(boolean status) {
+        mIsDialerRingingEnabledForTesting = status;
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/ringtone/InCallTonePlayer.java b/InCallUI/src/com/android/incallui/ringtone/InCallTonePlayer.java
new file mode 100644
index 0000000..be7fffb
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ringtone/InCallTonePlayer.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.ringtone;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+
+import android.media.AudioManager;
+import android.media.ToneGenerator;
+import android.provider.MediaStore.Audio;
+import android.support.annotation.Nullable;
+
+import com.android.contacts.common.testing.NeededForTesting;
+import com.android.dialer.compat.CallAudioStateCompat;
+import com.android.incallui.AudioModeProvider;
+import com.android.incallui.Log;
+import com.android.incallui.async.PausableExecutor;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import javax.annotation.concurrent.NotThreadSafe;
+
+/**
+ * Class responsible for playing in-call related tones in a background thread. This class only
+ * allows one tone to be played at a time.
+ */
+public class InCallTonePlayer {
+
+    public static final int TONE_CALL_WAITING = 4;
+
+    public static final int VOLUME_RELATIVE_HIGH_PRIORITY = 80;
+
+    private final AudioModeProvider mAudioModeProvider;
+    private final ToneGeneratorFactory mToneGeneratorFactory;
+    private final PausableExecutor mExecutor;
+    private @Nullable CountDownLatch mNumPlayingTones;
+
+    /**
+     * Creates a new InCallTonePlayer.
+     *
+     * @param audioModeProvider the {@link AudioModeProvider} used to determine through which stream
+     * to play tones.
+     * @param toneGeneratorFactory the {@link ToneGeneratorFactory} used to create
+     * {@link ToneGenerator}s.
+     * @param executor the {@link PausableExecutor} used to play tones in a background thread.
+     * @throws NullPointerException if audioModeProvider, toneGeneratorFactory, or executor are
+     * {@code null}.
+     */
+    public InCallTonePlayer(AudioModeProvider audioModeProvider,
+            ToneGeneratorFactory toneGeneratorFactory, PausableExecutor executor) {
+        mAudioModeProvider = Preconditions.checkNotNull(audioModeProvider);
+        mToneGeneratorFactory = Preconditions.checkNotNull(toneGeneratorFactory);
+        mExecutor = Preconditions.checkNotNull(executor);
+    }
+
+    /**
+     * @return {@code true} if a tone is currently playing, {@code false} otherwise
+     */
+    public boolean isPlayingTone() {
+        return mNumPlayingTones != null && mNumPlayingTones.getCount() > 0;
+    }
+
+    /**
+     * Plays the given tone in a background thread.
+     *
+     * @param tone the tone to play.
+     * @throws IllegalStateException if a tone is already playing
+     * @throws IllegalArgumentException if the tone is invalid
+     */
+    public void play(int tone) {
+        if (isPlayingTone()) {
+            throw new IllegalStateException("Tone already playing");
+        }
+        final ToneGeneratorInfo info = getToneGeneratorInfo(tone);
+        mNumPlayingTones = new CountDownLatch(1);
+        mExecutor.execute(new Runnable() {
+            @Override
+            public void run() {
+                playOnBackgroundThread(info);
+            }
+        });
+    }
+
+    private ToneGeneratorInfo getToneGeneratorInfo(int tone) {
+        int stream = getPlaybackStream();
+        switch (tone) {
+            case TONE_CALL_WAITING:
+                return new ToneGeneratorInfo(ToneGenerator.TONE_SUP_CALL_WAITING,
+                        VOLUME_RELATIVE_HIGH_PRIORITY,
+                        Integer.MAX_VALUE,
+                        stream);
+            default:
+                throw new IllegalArgumentException("Bad tone: " + tone);
+        }
+    }
+
+    private int getPlaybackStream() {
+        if (mAudioModeProvider.getAudioMode() == CallAudioStateCompat.ROUTE_BLUETOOTH) {
+            // TODO (maxwelb): b/26932998 play through bluetooth
+            // return AudioManager.STREAM_BLUETOOTH_SCO;
+        }
+        return AudioManager.STREAM_VOICE_CALL;
+    }
+
+    private void playOnBackgroundThread(ToneGeneratorInfo info) {
+        // TODO (maxwelb): b/26936902 respect Do Not Disturb setting
+        ToneGenerator toneGenerator = null;
+        try {
+            Log.v(this, "Starting tone " + info);
+            toneGenerator = mToneGeneratorFactory.newInCallToneGenerator(info.stream, info.volume);
+            toneGenerator.startTone(info.tone);
+            /*
+             * During tests, this will block until the tests call mExecutor.ackMilestone. This call
+             * allows for synchronization to the point where the tone has started playing.
+             */
+            mExecutor.milestone();
+            if (mNumPlayingTones != null) {
+                mNumPlayingTones.await(info.toneLengthMillis, TimeUnit.MILLISECONDS);
+                // Allows for synchronization to the point where the tone has completed playing.
+                mExecutor.milestone();
+            }
+        } catch (InterruptedException e) {
+            Log.w(this, "Interrupted while playing in-call tone.");
+        } finally {
+            if (toneGenerator != null) {
+                toneGenerator.release();
+            }
+            if (mNumPlayingTones != null) {
+                mNumPlayingTones.countDown();
+            }
+            // Allows for synchronization to the point where this background thread has cleaned up.
+            mExecutor.milestone();
+        }
+    }
+
+    /**
+     * Stops playback of the current tone.
+     */
+    public void stop() {
+        if (mNumPlayingTones != null) {
+            mNumPlayingTones.countDown();
+        }
+    }
+
+    private static class ToneGeneratorInfo {
+        public final int tone;
+        public final int volume;
+        public final int toneLengthMillis;
+        public final int stream;
+
+        public ToneGeneratorInfo(int toneGeneratorType, int volume, int toneLengthMillis,
+                int stream) {
+            this.tone = toneGeneratorType;
+            this.volume = volume;
+            this.toneLengthMillis = toneLengthMillis;
+            this.stream = stream;
+        }
+
+        @Override
+        public String toString() {
+            return MoreObjects.toStringHelper(this)
+                    .add("tone", tone)
+                    .add("volume", volume)
+                    .add("toneLengthMillis", toneLengthMillis).toString();
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/ringtone/ToneGeneratorFactory.java b/InCallUI/src/com/android/incallui/ringtone/ToneGeneratorFactory.java
new file mode 100644
index 0000000..ac47c8a
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/ringtone/ToneGeneratorFactory.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.ringtone;
+
+import android.media.ToneGenerator;
+
+/**
+ * Factory used to create {@link ToneGenerator}s.
+ */
+public class ToneGeneratorFactory {
+
+    /**
+     * Creates a new {@link ToneGenerator} to use while in a call.
+     *
+     * @param stream the stream through which to play tones.
+     * @param volume the volume at which to play tones.
+     * @return a new ToneGenerator.
+     */
+    public ToneGenerator newInCallToneGenerator(int stream, int volume) {
+        return new ToneGenerator(stream, volume);
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/service/PhoneNumberService.java b/InCallUI/src/com/android/incallui/service/PhoneNumberService.java
new file mode 100644
index 0000000..70da4ef
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/service/PhoneNumberService.java
@@ -0,0 +1,67 @@
+/*
+ * 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
+ */
+
+package com.android.incallui.service;
+
+import android.graphics.Bitmap;
+
+/**
+ * Provides phone number lookup services.
+ */
+public interface PhoneNumberService {
+
+    /**
+     * Get a phone number number asynchronously.
+     *
+     * @param phoneNumber The phone number to lookup.
+     * @param listener The listener to notify when the phone number lookup is complete.
+     * @param imageListener The listener to notify when the image lookup is complete.
+     */
+    public void getPhoneNumberInfo(String phoneNumber, NumberLookupListener listener,
+            ImageLookupListener imageListener, boolean isIncoming);
+
+    public interface NumberLookupListener {
+
+        /**
+         * Callback when a phone number has been looked up.
+         *
+         * @param info The looked up information.  Or (@literal null} if there are no results.
+         */
+        public void onPhoneNumberInfoComplete(PhoneNumberInfo info);
+    }
+
+    public interface ImageLookupListener {
+
+        /**
+         * Callback when a image has been fetched.
+         *
+         * @param bitmap The fetched image.
+         */
+        public void onImageFetchComplete(Bitmap bitmap);
+    }
+
+    public interface PhoneNumberInfo {
+        public String getDisplayName();
+        public String getNumber();
+        public int getPhoneType();
+        public String getPhoneLabel();
+        public String getNormalizedNumber();
+        public String getImageUrl();
+        public String getLookupKey();
+        public boolean isBusiness();
+        public int getLookupSource();
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/util/AccessibilityUtil.java b/InCallUI/src/com/android/incallui/util/AccessibilityUtil.java
new file mode 100644
index 0000000..1fdd2ba
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/util/AccessibilityUtil.java
@@ -0,0 +1,30 @@
+/*
+ * 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
+ */
+
+package com.android.incallui.util;
+
+import android.content.Context;
+import android.view.accessibility.AccessibilityManager;
+
+public class AccessibilityUtil {
+    public static boolean isTalkBackEnabled(Context context) {
+        AccessibilityManager accessibilityManager = (AccessibilityManager) context
+                .getSystemService(Context.ACCESSIBILITY_SERVICE);
+        return accessibilityManager != null
+                && accessibilityManager.isEnabled()
+                && accessibilityManager.isTouchExplorationEnabled();
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/util/TelecomCallUtil.java b/InCallUI/src/com/android/incallui/util/TelecomCallUtil.java
new file mode 100644
index 0000000..53ecc29
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/util/TelecomCallUtil.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.util;
+
+import android.net.Uri;
+import android.telecom.Call;
+import android.telephony.PhoneNumberUtils;
+
+/**
+ * Class to provide a standard interface for obtaining information from the underlying
+ * android.telecom.Call. Much of this should be obtained through the incall.Call, but
+ * on occasion we need to interact with the telecom.Call directly (eg. call blocking,
+ * before the incall.Call has been created).
+ */
+public class TelecomCallUtil {
+
+    // Whether the call handle is an emergency number.
+    public static boolean isEmergencyCall(Call call) {
+        Uri handle = call.getDetails().getHandle();
+        return PhoneNumberUtils.isEmergencyNumber(
+                handle == null ? "" : handle.getSchemeSpecificPart());
+    }
+
+    public static String getNumber(Call call) {
+        if (call == null) {
+            return null;
+        }
+        if (call.getDetails().getGatewayInfo() != null) {
+            return call.getDetails().getGatewayInfo()
+                    .getOriginalAddress().getSchemeSpecificPart();
+        }
+        Uri handle = getHandle(call);
+        return handle == null ? null : handle.getSchemeSpecificPart();
+    }
+
+    public static Uri getHandle(Call call) {
+        return call == null ? null : call.getDetails().getHandle();
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/widget/multiwaveview/Ease.java b/InCallUI/src/com/android/incallui/widget/multiwaveview/Ease.java
new file mode 100644
index 0000000..5ef6897
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/widget/multiwaveview/Ease.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.widget.multiwaveview;
+
+import android.animation.TimeInterpolator;
+
+class Ease {
+    private static final float DOMAIN = 1.0f;
+    private static final float DURATION = 1.0f;
+    private static final float START = 0.0f;
+
+    static class Linear {
+        public static final TimeInterpolator easeNone = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return input;
+            }
+        };
+    }
+
+    static class Cubic {
+        public static final TimeInterpolator easeIn = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return DOMAIN*(input/=DURATION)*input*input + START;
+            }
+        };
+        public static final TimeInterpolator easeOut = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return DOMAIN*((input=input/DURATION-1)*input*input + 1) + START;
+            }
+        };
+        public static final TimeInterpolator easeInOut = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return ((input/=DURATION/2) < 1.0f) ?
+                        (DOMAIN/2*input*input*input + START)
+                            : (DOMAIN/2*((input-=2)*input*input + 2) + START);
+            }
+        };
+    }
+
+    static class Quad {
+        public static final TimeInterpolator easeIn = new TimeInterpolator() {
+            public float getInterpolation (float input) {
+                return DOMAIN*(input/=DURATION)*input + START;
+            }
+        };
+        public static final TimeInterpolator easeOut = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return -DOMAIN *(input/=DURATION)*(input-2) + START;
+            }
+        };
+        public static final TimeInterpolator easeInOut = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return ((input/=DURATION/2) < 1) ?
+                        (DOMAIN/2*input*input + START)
+                            : (-DOMAIN/2 * ((--input)*(input-2) - 1) + START);
+            }
+        };
+    }
+
+    static class Quart {
+        public static final TimeInterpolator easeIn = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return DOMAIN*(input/=DURATION)*input*input*input + START;
+            }
+        };
+        public static final TimeInterpolator easeOut = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return -DOMAIN * ((input=input/DURATION-1)*input*input*input - 1) + START;
+            }
+        };
+        public static final TimeInterpolator easeInOut = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return ((input/=DURATION/2) < 1) ?
+                        (DOMAIN/2*input*input*input*input + START)
+                            : (-DOMAIN/2 * ((input-=2)*input*input*input - 2) + START);
+            }
+        };
+    }
+
+    static class Quint {
+        public static final TimeInterpolator easeIn = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return DOMAIN*(input/=DURATION)*input*input*input*input + START;
+            }
+        };
+        public static final TimeInterpolator easeOut = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return DOMAIN*((input=input/DURATION-1)*input*input*input*input + 1) + START;
+            }
+        };
+        public static final TimeInterpolator easeInOut = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return ((input/=DURATION/2) < 1) ?
+                        (DOMAIN/2*input*input*input*input*input + START)
+                            : (DOMAIN/2*((input-=2)*input*input*input*input + 2) + START);
+            }
+        };
+    }
+
+    static class Sine {
+        public static final TimeInterpolator easeIn = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return -DOMAIN * (float) Math.cos(input/DURATION * (Math.PI/2)) + DOMAIN + START;
+            }
+        };
+        public static final TimeInterpolator easeOut = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return DOMAIN * (float) Math.sin(input/DURATION * (Math.PI/2)) + START;
+            }
+        };
+        public static final TimeInterpolator easeInOut = new TimeInterpolator() {
+            public float getInterpolation(float input) {
+                return -DOMAIN/2 * ((float)Math.cos(Math.PI*input/DURATION) - 1.0f) + START;
+            }
+        };
+    }
+
+}
diff --git a/InCallUI/src/com/android/incallui/widget/multiwaveview/GlowPadView.java b/InCallUI/src/com/android/incallui/widget/multiwaveview/GlowPadView.java
new file mode 100644
index 0000000..2320027
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/widget/multiwaveview/GlowPadView.java
@@ -0,0 +1,1473 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.widget.multiwaveview;
+
+import android.animation.Animator;
+import android.animation.Animator.AnimatorListener;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.TimeInterpolator;
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.os.Vibrator;
+import android.support.v4.view.ViewCompat;
+import android.support.v4.view.accessibility.AccessibilityEventCompat;
+import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
+import android.support.v4.widget.ExploreByTouchHelper;
+import android.text.TextUtils;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.util.TypedValue;
+import android.view.Gravity;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityManager;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction;
+import android.view.accessibility.AccessibilityNodeProvider;
+
+import com.android.incallui.R;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This is a copy of com.android.internal.widget.multiwaveview.GlowPadView with minor changes
+ * to remove dependencies on private api's.
+ *
+ * Incoporated the scaling functionality.
+ *
+ * A re-usable widget containing a center, outer ring and wave animation.
+ */
+public class GlowPadView extends View {
+    private static final String TAG = "GlowPadView";
+    private static final boolean DEBUG = false;
+
+    // Wave state machine
+    private static final int STATE_IDLE = 0;
+    private static final int STATE_START = 1;
+    private static final int STATE_FIRST_TOUCH = 2;
+    private static final int STATE_TRACKING = 3;
+    private static final int STATE_SNAP = 4;
+    private static final int STATE_FINISH = 5;
+
+    // Animation properties.
+    private static final float SNAP_MARGIN_DEFAULT = 20.0f; // distance to ring before we snap to it
+
+    public interface OnTriggerListener {
+        int NO_HANDLE = 0;
+        int CENTER_HANDLE = 1;
+        public void onGrabbed(View v, int handle);
+        public void onReleased(View v, int handle);
+        public void onTrigger(View v, int target);
+        public void onGrabbedStateChange(View v, int handle);
+        public void onFinishFinalAnimation();
+    }
+
+    // Tuneable parameters for animation
+    private static final int WAVE_ANIMATION_DURATION = 1350;
+    private static final int RETURN_TO_HOME_DELAY = 1200;
+    private static final int RETURN_TO_HOME_DURATION = 200;
+    private static final int HIDE_ANIMATION_DELAY = 200;
+    private static final int HIDE_ANIMATION_DURATION = 200;
+    private static final int SHOW_ANIMATION_DURATION = 200;
+    private static final int SHOW_ANIMATION_DELAY = 50;
+    private static final int INITIAL_SHOW_HANDLE_DURATION = 200;
+    private static final int REVEAL_GLOW_DELAY = 0;
+    private static final int REVEAL_GLOW_DURATION = 0;
+
+    private static final float TAP_RADIUS_SCALE_ACCESSIBILITY_ENABLED = 1.3f;
+    private static final float TARGET_SCALE_EXPANDED = 1.0f;
+    private static final float TARGET_SCALE_COLLAPSED = 0.8f;
+    private static final float RING_SCALE_EXPANDED = 1.0f;
+    private static final float RING_SCALE_COLLAPSED = 0.5f;
+
+    private ArrayList<TargetDrawable> mTargetDrawables = new ArrayList<TargetDrawable>();
+    private AnimationBundle mWaveAnimations = new AnimationBundle();
+    private AnimationBundle mTargetAnimations = new AnimationBundle();
+    private AnimationBundle mGlowAnimations = new AnimationBundle();
+    private ArrayList<String> mTargetDescriptions;
+    private ArrayList<String> mDirectionDescriptions;
+    private OnTriggerListener mOnTriggerListener;
+    private TargetDrawable mHandleDrawable;
+    private TargetDrawable mOuterRing;
+    private Vibrator mVibrator;
+
+    private int mFeedbackCount = 3;
+    private int mVibrationDuration = 0;
+    private int mGrabbedState;
+    private int mActiveTarget = -1;
+    private float mGlowRadius;
+    private float mWaveCenterX;
+    private float mWaveCenterY;
+    private int mMaxTargetHeight;
+    private int mMaxTargetWidth;
+    private float mRingScaleFactor = 1f;
+    private boolean mAllowScaling;
+
+    private float mOuterRadius = 0.0f;
+    private float mSnapMargin = 0.0f;
+    private boolean mDragging;
+    private int mNewTargetResources;
+
+    private AccessibilityNodeProvider mAccessibilityNodeProvider;
+    private GlowpadExploreByTouchHelper mExploreByTouchHelper;
+
+    private class AnimationBundle extends ArrayList<Tweener> {
+        private static final long serialVersionUID = 0xA84D78726F127468L;
+        private boolean mSuspended;
+
+        public void start() {
+            if (mSuspended) return; // ignore attempts to start animations
+            final int count = size();
+            for (int i = 0; i < count; i++) {
+                Tweener anim = get(i);
+                anim.animator.start();
+            }
+        }
+
+        public void cancel() {
+            final int count = size();
+            for (int i = 0; i < count; i++) {
+                Tweener anim = get(i);
+                anim.animator.cancel();
+            }
+            clear();
+        }
+
+        public void stop() {
+            final int count = size();
+            for (int i = 0; i < count; i++) {
+                Tweener anim = get(i);
+                anim.animator.end();
+            }
+            clear();
+        }
+
+        public void setSuspended(boolean suspend) {
+            mSuspended = suspend;
+        }
+    };
+
+    private AnimatorListener mResetListener = new AnimatorListenerAdapter() {
+        public void onAnimationEnd(Animator animator) {
+            switchToState(STATE_IDLE, mWaveCenterX, mWaveCenterY);
+            dispatchOnFinishFinalAnimation();
+        }
+    };
+
+    private AnimatorListener mResetListenerWithPing = new AnimatorListenerAdapter() {
+        public void onAnimationEnd(Animator animator) {
+            ping();
+            switchToState(STATE_IDLE, mWaveCenterX, mWaveCenterY);
+            dispatchOnFinishFinalAnimation();
+        }
+    };
+
+    private AnimatorUpdateListener mUpdateListener = new AnimatorUpdateListener() {
+        public void onAnimationUpdate(ValueAnimator animation) {
+            invalidate();
+        }
+    };
+
+    private boolean mAnimatingTargets;
+    private AnimatorListener mTargetUpdateListener = new AnimatorListenerAdapter() {
+        public void onAnimationEnd(Animator animator) {
+            if (mNewTargetResources != 0) {
+                internalSetTargetResources(mNewTargetResources);
+                mNewTargetResources = 0;
+                hideTargets(false, false);
+            }
+            mAnimatingTargets = false;
+        }
+    };
+    private int mTargetResourceId;
+    private int mTargetDescriptionsResourceId;
+    private int mDirectionDescriptionsResourceId;
+    private boolean mAlwaysTrackFinger;
+    private int mHorizontalInset;
+    private int mVerticalInset;
+    private int mGravity = Gravity.TOP;
+    private boolean mInitialLayout = true;
+    private Tweener mBackgroundAnimator;
+    private PointCloud mPointCloud;
+    private float mInnerRadius;
+    private int mPointerId;
+
+    public GlowPadView(Context context) {
+        this(context, null);
+    }
+
+    public GlowPadView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        Resources res = context.getResources();
+
+        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.GlowPadView);
+        mInnerRadius = a.getDimension(R.styleable.GlowPadView_innerRadius, mInnerRadius);
+        mOuterRadius = a.getDimension(R.styleable.GlowPadView_outerRadius, mOuterRadius);
+        mSnapMargin = a.getDimension(R.styleable.GlowPadView_snapMargin, mSnapMargin);
+        mVibrationDuration = a.getInt(R.styleable.GlowPadView_vibrationDuration,
+                mVibrationDuration);
+        mFeedbackCount = a.getInt(R.styleable.GlowPadView_feedbackCount,
+                mFeedbackCount);
+        mAllowScaling = a.getBoolean(R.styleable.GlowPadView_allowScaling, false);
+        TypedValue handle = a.peekValue(R.styleable.GlowPadView_handleDrawable);
+        setHandleDrawable(handle != null ? handle.resourceId : R.drawable.ic_incall_audio_handle);
+        mOuterRing = new TargetDrawable(res,
+                getResourceId(a, R.styleable.GlowPadView_outerRingDrawable), 1);
+
+        mAlwaysTrackFinger = a.getBoolean(R.styleable.GlowPadView_alwaysTrackFinger, false);
+
+        int pointId = getResourceId(a, R.styleable.GlowPadView_pointDrawable);
+        Drawable pointDrawable = pointId != 0 ? res.getDrawable(pointId) : null;
+        mGlowRadius = a.getDimension(R.styleable.GlowPadView_glowRadius, 0.0f);
+
+        TypedValue outValue = new TypedValue();
+
+        // Read array of target drawables
+        if (a.getValue(R.styleable.GlowPadView_targetDrawables, outValue)) {
+            internalSetTargetResources(outValue.resourceId);
+        }
+        if (mTargetDrawables == null || mTargetDrawables.size() == 0) {
+            throw new IllegalStateException("Must specify at least one target drawable");
+        }
+
+        // Read array of target descriptions
+        if (a.getValue(R.styleable.GlowPadView_targetDescriptions, outValue)) {
+            final int resourceId = outValue.resourceId;
+            if (resourceId == 0) {
+                throw new IllegalStateException("Must specify target descriptions");
+            }
+            setTargetDescriptionsResourceId(resourceId);
+        }
+
+        // Read array of direction descriptions
+        if (a.getValue(R.styleable.GlowPadView_directionDescriptions, outValue)) {
+            final int resourceId = outValue.resourceId;
+            if (resourceId == 0) {
+                throw new IllegalStateException("Must specify direction descriptions");
+            }
+            setDirectionDescriptionsResourceId(resourceId);
+        }
+
+        // Use gravity attribute from LinearLayout
+        //a = context.obtainStyledAttributes(attrs, R.styleable.LinearLayout);
+        mGravity = a.getInt(R.styleable.GlowPadView_android_gravity, Gravity.TOP);
+        a.recycle();
+
+
+        setVibrateEnabled(mVibrationDuration > 0);
+
+        assignDefaultsIfNeeded();
+
+        mPointCloud = new PointCloud(pointDrawable);
+        mPointCloud.makePointCloud(mInnerRadius, mOuterRadius);
+        mPointCloud.glowManager.setRadius(mGlowRadius);
+
+        mExploreByTouchHelper = new GlowpadExploreByTouchHelper(this);
+        ViewCompat.setAccessibilityDelegate(this, mExploreByTouchHelper);
+    }
+
+    private int getResourceId(TypedArray a, int id) {
+        TypedValue tv = a.peekValue(id);
+        return tv == null ? 0 : tv.resourceId;
+    }
+
+    private void dump() {
+        Log.v(TAG, "Outer Radius = " + mOuterRadius);
+        Log.v(TAG, "SnapMargin = " + mSnapMargin);
+        Log.v(TAG, "FeedbackCount = " + mFeedbackCount);
+        Log.v(TAG, "VibrationDuration = " + mVibrationDuration);
+        Log.v(TAG, "GlowRadius = " + mGlowRadius);
+        Log.v(TAG, "WaveCenterX = " + mWaveCenterX);
+        Log.v(TAG, "WaveCenterY = " + mWaveCenterY);
+    }
+
+    public void suspendAnimations() {
+        mWaveAnimations.setSuspended(true);
+        mTargetAnimations.setSuspended(true);
+        mGlowAnimations.setSuspended(true);
+    }
+
+    public void resumeAnimations() {
+        mWaveAnimations.setSuspended(false);
+        mTargetAnimations.setSuspended(false);
+        mGlowAnimations.setSuspended(false);
+        mWaveAnimations.start();
+        mTargetAnimations.start();
+        mGlowAnimations.start();
+    }
+
+    @Override
+    protected int getSuggestedMinimumWidth() {
+        // View should be large enough to contain the background + handle and
+        // target drawable on either edge.
+        return (int) (Math.max(mOuterRing.getWidth(), 2 * mOuterRadius) + mMaxTargetWidth);
+    }
+
+    @Override
+    protected int getSuggestedMinimumHeight() {
+        // View should be large enough to contain the unlock ring + target and
+        // target drawable on either edge
+        return (int) (Math.max(mOuterRing.getHeight(), 2 * mOuterRadius) + mMaxTargetHeight);
+    }
+
+    /**
+     * This gets the suggested width accounting for the ring's scale factor.
+     */
+    protected int getScaledSuggestedMinimumWidth() {
+        return (int) (mRingScaleFactor * Math.max(mOuterRing.getWidth(), 2 * mOuterRadius)
+                + mMaxTargetWidth);
+    }
+
+    /**
+     * This gets the suggested height accounting for the ring's scale factor.
+     */
+    protected int getScaledSuggestedMinimumHeight() {
+        return (int) (mRingScaleFactor * Math.max(mOuterRing.getHeight(), 2 * mOuterRadius)
+                + mMaxTargetHeight);
+    }
+
+    private int resolveMeasured(int measureSpec, int desired)
+    {
+        int result = 0;
+        int specSize = MeasureSpec.getSize(measureSpec);
+        switch (MeasureSpec.getMode(measureSpec)) {
+            case MeasureSpec.UNSPECIFIED:
+                result = desired;
+                break;
+            case MeasureSpec.AT_MOST:
+                result = Math.min(specSize, desired);
+                break;
+            case MeasureSpec.EXACTLY:
+            default:
+                result = specSize;
+        }
+        return result;
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        final int minimumWidth = getSuggestedMinimumWidth();
+        final int minimumHeight = getSuggestedMinimumHeight();
+        int computedWidth = resolveMeasured(widthMeasureSpec, minimumWidth);
+        int computedHeight = resolveMeasured(heightMeasureSpec, minimumHeight);
+
+        mRingScaleFactor = computeScaleFactor(minimumWidth, minimumHeight,
+                computedWidth, computedHeight);
+
+        int scaledWidth = getScaledSuggestedMinimumWidth();
+        int scaledHeight = getScaledSuggestedMinimumHeight();
+
+        computeInsets(computedWidth - scaledWidth, computedHeight - scaledHeight);
+        setMeasuredDimension(computedWidth, computedHeight);
+    }
+
+    private void switchToState(int state, float x, float y) {
+        switch (state) {
+            case STATE_IDLE:
+                deactivateTargets();
+                hideGlow(0, 0, 0.0f, null);
+                startBackgroundAnimation(0, 0.0f);
+                mHandleDrawable.setState(TargetDrawable.STATE_INACTIVE);
+                mHandleDrawable.setAlpha(1.0f);
+                break;
+
+            case STATE_START:
+                startBackgroundAnimation(0, 0.0f);
+                break;
+
+            case STATE_FIRST_TOUCH:
+                mHandleDrawable.setAlpha(0.0f);
+                deactivateTargets();
+                showTargets(true);
+                startBackgroundAnimation(INITIAL_SHOW_HANDLE_DURATION, 1.0f);
+                setGrabbedState(OnTriggerListener.CENTER_HANDLE);
+
+                final AccessibilityManager accessibilityManager =
+                    (AccessibilityManager) getContext().getSystemService(
+                            Context.ACCESSIBILITY_SERVICE);
+                if (accessibilityManager.isEnabled()) {
+                    announceTargets();
+                }
+                break;
+
+            case STATE_TRACKING:
+                mHandleDrawable.setAlpha(0.0f);
+                break;
+
+            case STATE_SNAP:
+                // TODO: Add transition states (see list_selector_background_transition.xml)
+                mHandleDrawable.setAlpha(0.0f);
+                showGlow(REVEAL_GLOW_DURATION , REVEAL_GLOW_DELAY, 0.0f, null);
+                break;
+
+            case STATE_FINISH:
+                doFinish();
+                break;
+        }
+    }
+
+    private void showGlow(int duration, int delay, float finalAlpha,
+            AnimatorListener finishListener) {
+        mGlowAnimations.cancel();
+        mGlowAnimations.add(Tweener.to(mPointCloud.glowManager, duration,
+                "ease", Ease.Cubic.easeIn,
+                "delay", delay,
+                "alpha", finalAlpha,
+                "onUpdate", mUpdateListener,
+                "onComplete", finishListener));
+        mGlowAnimations.start();
+    }
+
+    private void hideGlow(int duration, int delay, float finalAlpha,
+            AnimatorListener finishListener) {
+        mGlowAnimations.cancel();
+        mGlowAnimations.add(Tweener.to(mPointCloud.glowManager, duration,
+                "ease", Ease.Quart.easeOut,
+                "delay", delay,
+                "alpha", finalAlpha,
+                "x", 0.0f,
+                "y", 0.0f,
+                "onUpdate", mUpdateListener,
+                "onComplete", finishListener));
+        mGlowAnimations.start();
+    }
+
+    private void deactivateTargets() {
+        final int count = mTargetDrawables.size();
+        for (int i = 0; i < count; i++) {
+            TargetDrawable target = mTargetDrawables.get(i);
+            target.setState(TargetDrawable.STATE_INACTIVE);
+        }
+        mActiveTarget = -1;
+    }
+
+    /**
+     * Dispatches a trigger event to listener. Ignored if a listener is not set.
+     * @param whichTarget the target that was triggered.
+     */
+    private void dispatchTriggerEvent(int whichTarget) {
+        vibrate();
+        if (mOnTriggerListener != null) {
+            mOnTriggerListener.onTrigger(this, whichTarget);
+        }
+    }
+
+    private void dispatchOnFinishFinalAnimation() {
+        if (mOnTriggerListener != null) {
+            mOnTriggerListener.onFinishFinalAnimation();
+        }
+    }
+
+    private void doFinish() {
+        final int activeTarget = mActiveTarget;
+        final boolean targetHit =  activeTarget != -1;
+
+        if (targetHit) {
+            if (DEBUG) Log.v(TAG, "Finish with target hit = " + targetHit);
+
+            highlightSelected(activeTarget);
+
+            // Inform listener of any active targets.  Typically only one will be active.
+            hideGlow(RETURN_TO_HOME_DURATION, RETURN_TO_HOME_DELAY, 0.0f, mResetListener);
+            dispatchTriggerEvent(activeTarget);
+            if (!mAlwaysTrackFinger) {
+                // Force ring and targets to finish animation to final expanded state
+                mTargetAnimations.stop();
+            }
+        } else {
+            // Animate handle back to the center based on current state.
+            hideGlow(HIDE_ANIMATION_DURATION, 0, 0.0f, mResetListenerWithPing);
+            hideTargets(true, false);
+        }
+
+        setGrabbedState(OnTriggerListener.NO_HANDLE);
+    }
+
+    private void highlightSelected(int activeTarget) {
+        // Highlight the given target and fade others
+        mTargetDrawables.get(activeTarget).setState(TargetDrawable.STATE_ACTIVE);
+        hideUnselected(activeTarget);
+    }
+
+    private void hideUnselected(int active) {
+        for (int i = 0; i < mTargetDrawables.size(); i++) {
+            if (i != active) {
+                mTargetDrawables.get(i).setAlpha(0.0f);
+            }
+        }
+    }
+
+    private void hideTargets(boolean animate, boolean expanded) {
+        mTargetAnimations.cancel();
+        // Note: these animations should complete at the same time so that we can swap out
+        // the target assets asynchronously from the setTargetResources() call.
+        mAnimatingTargets = animate;
+        final int duration = animate ? HIDE_ANIMATION_DURATION : 0;
+        final int delay = animate ? HIDE_ANIMATION_DELAY : 0;
+
+        final float targetScale = expanded ?
+                TARGET_SCALE_EXPANDED : TARGET_SCALE_COLLAPSED;
+        final int length = mTargetDrawables.size();
+        final TimeInterpolator interpolator = Ease.Cubic.easeOut;
+        for (int i = 0; i < length; i++) {
+            TargetDrawable target = mTargetDrawables.get(i);
+            target.setState(TargetDrawable.STATE_INACTIVE);
+            mTargetAnimations.add(Tweener.to(target, duration,
+                    "ease", interpolator,
+                    "alpha", 0.0f,
+                    "scaleX", targetScale,
+                    "scaleY", targetScale,
+                    "delay", delay,
+                    "onUpdate", mUpdateListener));
+        }
+
+        float ringScaleTarget = expanded ?
+                RING_SCALE_EXPANDED : RING_SCALE_COLLAPSED;
+        ringScaleTarget *= mRingScaleFactor;
+        mTargetAnimations.add(Tweener.to(mOuterRing, duration,
+                "ease", interpolator,
+                "alpha", 0.0f,
+                "scaleX", ringScaleTarget,
+                "scaleY", ringScaleTarget,
+                "delay", delay,
+                "onUpdate", mUpdateListener,
+                "onComplete", mTargetUpdateListener));
+
+        mTargetAnimations.start();
+    }
+
+    private void showTargets(boolean animate) {
+        mTargetAnimations.stop();
+        mAnimatingTargets = animate;
+        final int delay = animate ? SHOW_ANIMATION_DELAY : 0;
+        final int duration = animate ? SHOW_ANIMATION_DURATION : 0;
+        final int length = mTargetDrawables.size();
+        for (int i = 0; i < length; i++) {
+            TargetDrawable target = mTargetDrawables.get(i);
+            target.setState(TargetDrawable.STATE_INACTIVE);
+            mTargetAnimations.add(Tweener.to(target, duration,
+                    "ease", Ease.Cubic.easeOut,
+                    "alpha", 1.0f,
+                    "scaleX", 1.0f,
+                    "scaleY", 1.0f,
+                    "delay", delay,
+                    "onUpdate", mUpdateListener));
+        }
+        float ringScale = mRingScaleFactor * RING_SCALE_EXPANDED;
+        mTargetAnimations.add(Tweener.to(mOuterRing, duration,
+                "ease", Ease.Cubic.easeOut,
+                "alpha", 1.0f,
+                "scaleX", ringScale,
+                "scaleY", ringScale,
+                "delay", delay,
+                "onUpdate", mUpdateListener,
+                "onComplete", mTargetUpdateListener));
+
+        mTargetAnimations.start();
+    }
+
+    private void vibrate() {
+        if (mVibrator != null) {
+            mVibrator.vibrate(mVibrationDuration);
+        }
+    }
+
+    private ArrayList<TargetDrawable> loadDrawableArray(int resourceId) {
+        Resources res = getContext().getResources();
+        TypedArray array = res.obtainTypedArray(resourceId);
+        final int count = array.length();
+        ArrayList<TargetDrawable> drawables = new ArrayList<TargetDrawable>(count);
+        for (int i = 0; i < count; i++) {
+            TypedValue value = array.peekValue(i);
+            TargetDrawable target = new TargetDrawable(res, value != null ? value.resourceId : 0, 3);
+            drawables.add(target);
+        }
+        array.recycle();
+        return drawables;
+    }
+
+    private void internalSetTargetResources(int resourceId) {
+        final ArrayList<TargetDrawable> targets = loadDrawableArray(resourceId);
+        mTargetDrawables = targets;
+        mTargetResourceId = resourceId;
+
+        int maxWidth = mHandleDrawable.getWidth();
+        int maxHeight = mHandleDrawable.getHeight();
+        final int count = targets.size();
+        for (int i = 0; i < count; i++) {
+            TargetDrawable target = targets.get(i);
+            maxWidth = Math.max(maxWidth, target.getWidth());
+            maxHeight = Math.max(maxHeight, target.getHeight());
+        }
+        if (mMaxTargetWidth != maxWidth || mMaxTargetHeight != maxHeight) {
+            mMaxTargetWidth = maxWidth;
+            mMaxTargetHeight = maxHeight;
+            requestLayout(); // required to resize layout and call updateTargetPositions()
+        } else {
+            updateTargetPositions(mWaveCenterX, mWaveCenterY);
+            updatePointCloudPosition(mWaveCenterX, mWaveCenterY);
+        }
+    }
+    /**
+     * Loads an array of drawables from the given resourceId.
+     *
+     * @param resourceId
+     */
+    public void setTargetResources(int resourceId) {
+        if (mAnimatingTargets) {
+            // postpone this change until we return to the initial state
+            mNewTargetResources = resourceId;
+        } else {
+            internalSetTargetResources(resourceId);
+        }
+    }
+
+    public int getTargetResourceId() {
+        return mTargetResourceId;
+    }
+
+    /**
+     * Sets the handle drawable to the drawable specified by the resource ID.
+     * @param resourceId
+     */
+    public void setHandleDrawable(int resourceId) {
+        if (mHandleDrawable != null) {
+            mHandleDrawable.setDrawable(getResources(), resourceId);
+        } else {
+            mHandleDrawable = new TargetDrawable(getResources(), resourceId, 1);
+        }
+        mHandleDrawable.setState(TargetDrawable.STATE_INACTIVE);
+    }
+
+    /**
+     * Sets the resource id specifying the target descriptions for accessibility.
+     *
+     * @param resourceId The resource id.
+     */
+    public void setTargetDescriptionsResourceId(int resourceId) {
+        mTargetDescriptionsResourceId = resourceId;
+        if (mTargetDescriptions != null) {
+            mTargetDescriptions.clear();
+        }
+    }
+
+    /**
+     * Gets the resource id specifying the target descriptions for accessibility.
+     *
+     * @return The resource id.
+     */
+    public int getTargetDescriptionsResourceId() {
+        return mTargetDescriptionsResourceId;
+    }
+
+    /**
+     * Sets the resource id specifying the target direction descriptions for accessibility.
+     *
+     * @param resourceId The resource id.
+     */
+    public void setDirectionDescriptionsResourceId(int resourceId) {
+        mDirectionDescriptionsResourceId = resourceId;
+        if (mDirectionDescriptions != null) {
+            mDirectionDescriptions.clear();
+        }
+    }
+
+    /**
+     * Gets the resource id specifying the target direction descriptions.
+     *
+     * @return The resource id.
+     */
+    public int getDirectionDescriptionsResourceId() {
+        return mDirectionDescriptionsResourceId;
+    }
+
+    /**
+     * Enable or disable vibrate on touch.
+     *
+     * @param enabled
+     */
+    public void setVibrateEnabled(boolean enabled) {
+        if (enabled && mVibrator == null) {
+            mVibrator = (Vibrator) getContext().getSystemService(Context.VIBRATOR_SERVICE);
+        } else {
+            mVibrator = null;
+        }
+    }
+
+    /**
+     * Starts wave animation.
+     *
+     */
+    public void ping() {
+        if (mFeedbackCount > 0) {
+            boolean doWaveAnimation = true;
+            final AnimationBundle waveAnimations = mWaveAnimations;
+
+            // Don't do a wave if there's already one in progress
+            if (waveAnimations.size() > 0 && waveAnimations.get(0).animator.isRunning()) {
+                long t = waveAnimations.get(0).animator.getCurrentPlayTime();
+                if (t < WAVE_ANIMATION_DURATION/2) {
+                    doWaveAnimation = false;
+                }
+            }
+
+            if (doWaveAnimation) {
+                startWaveAnimation();
+            }
+        }
+    }
+
+    private void stopAndHideWaveAnimation() {
+        mWaveAnimations.cancel();
+        mPointCloud.waveManager.setAlpha(0.0f);
+    }
+
+    private void startWaveAnimation() {
+        mWaveAnimations.cancel();
+        mPointCloud.waveManager.setAlpha(1.0f);
+        mPointCloud.waveManager.setRadius(mHandleDrawable.getWidth()/2.0f);
+        mWaveAnimations.add(Tweener.to(mPointCloud.waveManager, WAVE_ANIMATION_DURATION,
+                "ease", Ease.Quad.easeOut,
+                "delay", 0,
+                "radius", 2.0f * mOuterRadius,
+                "onUpdate", mUpdateListener,
+                "onComplete",
+                new AnimatorListenerAdapter() {
+                    public void onAnimationEnd(Animator animator) {
+                        mPointCloud.waveManager.setRadius(0.0f);
+                        mPointCloud.waveManager.setAlpha(0.0f);
+                    }
+                }));
+        mWaveAnimations.start();
+    }
+
+    /**
+     * Resets the widget to default state and cancels all animation. If animate is 'true', will
+     * animate objects into place. Otherwise, objects will snap back to place.
+     *
+     * @param animate
+     */
+    public void reset(boolean animate) {
+        mGlowAnimations.stop();
+        mTargetAnimations.stop();
+        startBackgroundAnimation(0, 0.0f);
+        stopAndHideWaveAnimation();
+        hideTargets(animate, false);
+        hideGlow(0, 0, 0.0f, null);
+        Tweener.reset();
+    }
+
+    private void startBackgroundAnimation(int duration, float alpha) {
+        final Drawable background = getBackground();
+        if (mAlwaysTrackFinger && background != null) {
+            if (mBackgroundAnimator != null) {
+                mBackgroundAnimator.animator.cancel();
+            }
+            mBackgroundAnimator = Tweener.to(background, duration,
+                    "ease", Ease.Cubic.easeIn,
+                    "alpha", (int)(255.0f * alpha),
+                    "delay", SHOW_ANIMATION_DELAY);
+            mBackgroundAnimator.animator.start();
+        }
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        final int action = event.getActionMasked();
+        boolean handled = false;
+        switch (action) {
+            case MotionEvent.ACTION_POINTER_DOWN:
+            case MotionEvent.ACTION_DOWN:
+                if (DEBUG) Log.v(TAG, "*** DOWN ***");
+                handleDown(event);
+                handleMove(event);
+                handled = true;
+                break;
+
+            case MotionEvent.ACTION_MOVE:
+                if (DEBUG) Log.v(TAG, "*** MOVE ***");
+                handleMove(event);
+                handled = true;
+                break;
+
+            case MotionEvent.ACTION_POINTER_UP:
+            case MotionEvent.ACTION_UP:
+                if (DEBUG) Log.v(TAG, "*** UP ***");
+                handleMove(event);
+                handleUp(event);
+                handled = true;
+                break;
+
+            case MotionEvent.ACTION_CANCEL:
+                if (DEBUG) Log.v(TAG, "*** CANCEL ***");
+                handleMove(event);
+                handleCancel(event);
+                handled = true;
+                break;
+        }
+        invalidate();
+        return handled ? true : super.onTouchEvent(event);
+    }
+
+    private void updateGlowPosition(float x, float y) {
+        float dx = x - mOuterRing.getX();
+        float dy = y - mOuterRing.getY();
+        dx *= 1f / mRingScaleFactor;
+        dy *= 1f / mRingScaleFactor;
+        mPointCloud.glowManager.setX(mOuterRing.getX() + dx);
+        mPointCloud.glowManager.setY(mOuterRing.getY() + dy);
+    }
+
+    private void handleDown(MotionEvent event) {
+        int actionIndex = event.getActionIndex();
+        float eventX = event.getX(actionIndex);
+        float eventY = event.getY(actionIndex);
+        switchToState(STATE_START, eventX, eventY);
+        if (!trySwitchToFirstTouchState(eventX, eventY)) {
+            mDragging = false;
+        } else {
+            mPointerId = event.getPointerId(actionIndex);
+            updateGlowPosition(eventX, eventY);
+        }
+    }
+
+    private void handleUp(MotionEvent event) {
+        if (DEBUG && mDragging) Log.v(TAG, "** Handle RELEASE");
+        int actionIndex = event.getActionIndex();
+        if (event.getPointerId(actionIndex) == mPointerId) {
+            switchToState(STATE_FINISH, event.getX(actionIndex), event.getY(actionIndex));
+        }
+    }
+
+    private void handleCancel(MotionEvent event) {
+        if (DEBUG && mDragging) Log.v(TAG, "** Handle CANCEL");
+
+        // We should drop the active target here but it interferes with
+        // moving off the screen in the direction of the navigation bar. At some point we may
+        // want to revisit how we handle this. For now we'll allow a canceled event to
+        // activate the current target.
+
+        // mActiveTarget = -1; // Drop the active target if canceled.
+
+        int actionIndex = event.findPointerIndex(mPointerId);
+        actionIndex = actionIndex == -1 ? 0 : actionIndex;
+        switchToState(STATE_FINISH, event.getX(actionIndex), event.getY(actionIndex));
+    }
+
+    private void handleMove(MotionEvent event) {
+        int activeTarget = -1;
+        final int historySize = event.getHistorySize();
+        ArrayList<TargetDrawable> targets = mTargetDrawables;
+        int ntargets = targets.size();
+        float x = 0.0f;
+        float y = 0.0f;
+        int actionIndex = event.findPointerIndex(mPointerId);
+
+        if (actionIndex == -1) {
+            return;  // no data for this pointer
+        }
+
+        for (int k = 0; k < historySize + 1; k++) {
+            float eventX = k < historySize ? event.getHistoricalX(actionIndex, k)
+                    : event.getX(actionIndex);
+            float eventY = k < historySize ? event.getHistoricalY(actionIndex, k)
+                    :event.getY(actionIndex);
+            // tx and ty are relative to wave center
+            float tx = eventX - mWaveCenterX;
+            float ty = eventY - mWaveCenterY;
+            float touchRadius = (float) Math.hypot(tx, ty);
+            final float scale = touchRadius > mOuterRadius ? mOuterRadius / touchRadius : 1.0f;
+            float limitX = tx * scale;
+            float limitY = ty * scale;
+            double angleRad = Math.atan2(-ty, tx);
+
+            if (!mDragging) {
+                trySwitchToFirstTouchState(eventX, eventY);
+            }
+
+            if (mDragging) {
+                // For multiple targets, snap to the one that matches
+                final float snapRadius = mRingScaleFactor * mOuterRadius - mSnapMargin;
+                final float snapDistance2 = snapRadius * snapRadius;
+                // Find first target in range
+                for (int i = 0; i < ntargets; i++) {
+                    TargetDrawable target = targets.get(i);
+
+                    double targetMinRad = (i - 0.5) * 2 * Math.PI / ntargets;
+                    double targetMaxRad = (i + 0.5) * 2 * Math.PI / ntargets;
+                    if (target.isEnabled()) {
+                        boolean angleMatches =
+                            (angleRad > targetMinRad && angleRad <= targetMaxRad) ||
+                            (angleRad + 2 * Math.PI > targetMinRad &&
+                             angleRad + 2 * Math.PI <= targetMaxRad);
+                        if (angleMatches && (dist2(tx, ty) > snapDistance2)) {
+                            activeTarget = i;
+                        }
+                    }
+                }
+            }
+            x = limitX;
+            y = limitY;
+        }
+
+        if (!mDragging) {
+            return;
+        }
+
+        if (activeTarget != -1) {
+            switchToState(STATE_SNAP, x,y);
+            updateGlowPosition(x, y);
+        } else {
+            switchToState(STATE_TRACKING, x, y);
+            updateGlowPosition(x, y);
+        }
+
+        if (mActiveTarget != activeTarget) {
+            // Defocus the old target
+            if (mActiveTarget != -1) {
+                TargetDrawable target = targets.get(mActiveTarget);
+                target.setState(TargetDrawable.STATE_INACTIVE);
+            }
+            // Focus the new target
+            if (activeTarget != -1) {
+                TargetDrawable target = targets.get(activeTarget);
+                target.setState(TargetDrawable.STATE_FOCUSED);
+                final AccessibilityManager accessibilityManager =
+                        (AccessibilityManager) getContext().getSystemService(
+                                Context.ACCESSIBILITY_SERVICE);
+                if (accessibilityManager.isEnabled()) {
+                    String targetContentDescription = getTargetDescription(activeTarget);
+                    announceForAccessibility(targetContentDescription);
+                }
+            }
+        }
+        mActiveTarget = activeTarget;
+    }
+
+    @Override
+    public boolean onHoverEvent(MotionEvent event) {
+        final AccessibilityManager accessibilityManager =
+                (AccessibilityManager) getContext().getSystemService(
+                        Context.ACCESSIBILITY_SERVICE);
+        if (accessibilityManager.isTouchExplorationEnabled()) {
+            final int action = event.getAction();
+            switch (action) {
+                case MotionEvent.ACTION_HOVER_ENTER:
+                    event.setAction(MotionEvent.ACTION_DOWN);
+                    break;
+                case MotionEvent.ACTION_HOVER_MOVE:
+                    event.setAction(MotionEvent.ACTION_MOVE);
+                    break;
+                case MotionEvent.ACTION_HOVER_EXIT:
+                    event.setAction(MotionEvent.ACTION_UP);
+                    break;
+            }
+            onTouchEvent(event);
+            event.setAction(action);
+        }
+        super.onHoverEvent(event);
+        return true;
+    }
+
+    /**
+     * Sets the current grabbed state, and dispatches a grabbed state change
+     * event to our listener.
+     */
+    private void setGrabbedState(int newState) {
+        if (newState != mGrabbedState) {
+            if (newState != OnTriggerListener.NO_HANDLE) {
+                vibrate();
+            }
+            mGrabbedState = newState;
+            if (mOnTriggerListener != null) {
+                if (newState == OnTriggerListener.NO_HANDLE) {
+                    mOnTriggerListener.onReleased(this, OnTriggerListener.CENTER_HANDLE);
+                } else {
+                    mOnTriggerListener.onGrabbed(this, OnTriggerListener.CENTER_HANDLE);
+                }
+                mOnTriggerListener.onGrabbedStateChange(this, newState);
+            }
+        }
+    }
+
+    private boolean trySwitchToFirstTouchState(float x, float y) {
+        final float tx = x - mWaveCenterX;
+        final float ty = y - mWaveCenterY;
+        if (mAlwaysTrackFinger || dist2(tx,ty) <= getScaledGlowRadiusSquared()) {
+            if (DEBUG) Log.v(TAG, "** Handle HIT");
+            switchToState(STATE_FIRST_TOUCH, x, y);
+            updateGlowPosition(tx, ty);
+            mDragging = true;
+            return true;
+        }
+        return false;
+    }
+
+    private void assignDefaultsIfNeeded() {
+        if (mOuterRadius == 0.0f) {
+            mOuterRadius = Math.max(mOuterRing.getWidth(), mOuterRing.getHeight())/2.0f;
+        }
+        if (mSnapMargin == 0.0f) {
+            mSnapMargin = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
+                    SNAP_MARGIN_DEFAULT, getContext().getResources().getDisplayMetrics());
+        }
+        if (mInnerRadius == 0.0f) {
+            mInnerRadius = mHandleDrawable.getWidth() / 10.0f;
+        }
+    }
+
+    private void computeInsets(int dx, int dy) {
+        final int layoutDirection = getLayoutDirection();
+        final int absoluteGravity = Gravity.getAbsoluteGravity(mGravity, layoutDirection);
+
+        switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
+            case Gravity.LEFT:
+                mHorizontalInset = 0;
+                break;
+            case Gravity.RIGHT:
+                mHorizontalInset = dx;
+                break;
+            case Gravity.CENTER_HORIZONTAL:
+            default:
+                mHorizontalInset = dx / 2;
+                break;
+        }
+        switch (absoluteGravity & Gravity.VERTICAL_GRAVITY_MASK) {
+            case Gravity.TOP:
+                mVerticalInset = 0;
+                break;
+            case Gravity.BOTTOM:
+                mVerticalInset = dy;
+                break;
+            case Gravity.CENTER_VERTICAL:
+            default:
+                mVerticalInset = dy / 2;
+                break;
+        }
+    }
+
+    /**
+     * Given the desired width and height of the ring and the allocated width and height, compute
+     * how much we need to scale the ring.
+     */
+    private float computeScaleFactor(int desiredWidth, int desiredHeight,
+            int actualWidth, int actualHeight) {
+
+        // Return unity if scaling is not allowed.
+        if (!mAllowScaling) return 1f;
+
+        final int layoutDirection = getLayoutDirection();
+        final int absoluteGravity = Gravity.getAbsoluteGravity(mGravity, layoutDirection);
+
+        float scaleX = 1f;
+        float scaleY = 1f;
+
+        // We use the gravity as a cue for whether we want to scale on a particular axis.
+        // We only scale to fit horizontally if we're not pinned to the left or right. Likewise,
+        // we only scale to fit vertically if we're not pinned to the top or bottom. In these
+        // cases, we want the ring to hang off the side or top/bottom, respectively.
+        switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
+            case Gravity.LEFT:
+            case Gravity.RIGHT:
+                break;
+            case Gravity.CENTER_HORIZONTAL:
+            default:
+                if (desiredWidth > actualWidth) {
+                    scaleX = (1f * actualWidth - mMaxTargetWidth) /
+                            (desiredWidth - mMaxTargetWidth);
+                }
+                break;
+        }
+        switch (absoluteGravity & Gravity.VERTICAL_GRAVITY_MASK) {
+            case Gravity.TOP:
+            case Gravity.BOTTOM:
+                break;
+            case Gravity.CENTER_VERTICAL:
+            default:
+                if (desiredHeight > actualHeight) {
+                    scaleY = (1f * actualHeight - mMaxTargetHeight) /
+                            (desiredHeight - mMaxTargetHeight);
+                }
+                break;
+        }
+        return Math.min(scaleX, scaleY);
+    }
+
+    private float getRingWidth() {
+        return mRingScaleFactor * Math.max(mOuterRing.getWidth(), 2 * mOuterRadius);
+    }
+
+    private float getRingHeight() {
+        return mRingScaleFactor * Math.max(mOuterRing.getHeight(), 2 * mOuterRadius);
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        super.onLayout(changed, left, top, right, bottom);
+        final int width = right - left;
+        final int height = bottom - top;
+
+        // Target placement width/height. This puts the targets on the greater of the ring
+        // width or the specified outer radius.
+        final float placementWidth = getRingWidth();
+        final float placementHeight = getRingHeight();
+        float newWaveCenterX = mHorizontalInset
+                + (mMaxTargetWidth + placementWidth) / 2;
+        float newWaveCenterY = mVerticalInset
+                + (mMaxTargetHeight + placementHeight) / 2;
+
+        if (mInitialLayout) {
+            stopAndHideWaveAnimation();
+            hideTargets(false, false);
+            mInitialLayout = false;
+        }
+
+        mOuterRing.setPositionX(newWaveCenterX);
+        mOuterRing.setPositionY(newWaveCenterY);
+
+        mPointCloud.setScale(mRingScaleFactor);
+
+        mHandleDrawable.setPositionX(newWaveCenterX);
+        mHandleDrawable.setPositionY(newWaveCenterY);
+
+        updateTargetPositions(newWaveCenterX, newWaveCenterY);
+        updatePointCloudPosition(newWaveCenterX, newWaveCenterY);
+        updateGlowPosition(newWaveCenterX, newWaveCenterY);
+
+        mWaveCenterX = newWaveCenterX;
+        mWaveCenterY = newWaveCenterY;
+
+        if (DEBUG) dump();
+    }
+
+    private void updateTargetPositions(float centerX, float centerY) {
+        // Reposition the target drawables if the view changed.
+        ArrayList<TargetDrawable> targets = mTargetDrawables;
+        final int size = targets.size();
+        final float alpha = (float) (-2.0f * Math.PI / size);
+        for (int i = 0; i < size; i++) {
+            final TargetDrawable targetIcon = targets.get(i);
+            final float angle = alpha * i;
+            targetIcon.setPositionX(centerX);
+            targetIcon.setPositionY(centerY);
+            targetIcon.setX(getRingWidth() / 2 * (float) Math.cos(angle));
+            targetIcon.setY(getRingHeight() / 2 * (float) Math.sin(angle));
+        }
+    }
+
+    private void updatePointCloudPosition(float centerX, float centerY) {
+        mPointCloud.setCenter(centerX, centerY);
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        mPointCloud.draw(canvas);
+        mOuterRing.draw(canvas);
+        final int ntargets = mTargetDrawables.size();
+        for (int i = 0; i < ntargets; i++) {
+            TargetDrawable target = mTargetDrawables.get(i);
+            if (target != null) {
+                target.draw(canvas);
+            }
+        }
+        mHandleDrawable.draw(canvas);
+    }
+
+    public void setOnTriggerListener(OnTriggerListener listener) {
+        mOnTriggerListener = listener;
+    }
+
+    private float square(float d) {
+        return d * d;
+    }
+
+    private float dist2(float dx, float dy) {
+        return dx*dx + dy*dy;
+    }
+
+    private float getScaledGlowRadiusSquared() {
+        final float scaledTapRadius;
+        final AccessibilityManager accessibilityManager =
+                (AccessibilityManager) getContext().getSystemService(
+                        Context.ACCESSIBILITY_SERVICE);
+        if (accessibilityManager.isEnabled()) {
+            scaledTapRadius = TAP_RADIUS_SCALE_ACCESSIBILITY_ENABLED * mGlowRadius;
+        } else {
+            scaledTapRadius = mGlowRadius;
+        }
+        return square(scaledTapRadius);
+    }
+
+    private void announceTargets() {
+        StringBuilder utterance = new StringBuilder();
+        final int targetCount = mTargetDrawables.size();
+        for (int i = 0; i < targetCount; i++) {
+            String targetDescription = getTargetDescription(i);
+            String directionDescription = getDirectionDescription(i);
+            if (!TextUtils.isEmpty(targetDescription)
+                    && !TextUtils.isEmpty(directionDescription)) {
+                String text = String.format(directionDescription, targetDescription);
+                utterance.append(text);
+            }
+        }
+        if (utterance.length() > 0) {
+            announceForAccessibility(utterance.toString());
+        }
+    }
+
+    private String getTargetDescription(int index) {
+        if (mTargetDescriptions == null || mTargetDescriptions.isEmpty()) {
+            mTargetDescriptions = loadDescriptions(mTargetDescriptionsResourceId);
+            if (mTargetDrawables.size() != mTargetDescriptions.size()) {
+                Log.w(TAG, "The number of target drawables must be"
+                        + " equal to the number of target descriptions.");
+                return null;
+            }
+        }
+        return mTargetDescriptions.get(index);
+    }
+
+    private String getDirectionDescription(int index) {
+        if (mDirectionDescriptions == null || mDirectionDescriptions.isEmpty()) {
+            mDirectionDescriptions = loadDescriptions(mDirectionDescriptionsResourceId);
+            if (mTargetDrawables.size() != mDirectionDescriptions.size()) {
+                Log.w(TAG, "The number of target drawables must be"
+                        + " equal to the number of direction descriptions.");
+                return null;
+            }
+        }
+        return mDirectionDescriptions.get(index);
+    }
+
+    private ArrayList<String> loadDescriptions(int resourceId) {
+        TypedArray array = getContext().getResources().obtainTypedArray(resourceId);
+        final int count = array.length();
+        ArrayList<String> targetContentDescriptions = new ArrayList<String>(count);
+        for (int i = 0; i < count; i++) {
+            String contentDescription = array.getString(i);
+            targetContentDescriptions.add(contentDescription);
+        }
+        array.recycle();
+        return targetContentDescriptions;
+    }
+
+    public int getResourceIdForTarget(int index) {
+        final TargetDrawable drawable = mTargetDrawables.get(index);
+        return drawable == null ? 0 : drawable.getResourceId();
+    }
+
+    public void setEnableTarget(int resourceId, boolean enabled) {
+        for (int i = 0; i < mTargetDrawables.size(); i++) {
+            final TargetDrawable target = mTargetDrawables.get(i);
+            if (target.getResourceId() == resourceId) {
+                target.setEnabled(enabled);
+                break; // should never be more than one match
+            }
+        }
+    }
+
+    /**
+     * Gets the position of a target in the array that matches the given resource.
+     * @param resourceId
+     * @return the index or -1 if not found
+     */
+    public int getTargetPosition(int resourceId) {
+        for (int i = 0; i < mTargetDrawables.size(); i++) {
+            final TargetDrawable target = mTargetDrawables.get(i);
+            if (target.getResourceId() == resourceId) {
+                return i; // should never be more than one match
+            }
+        }
+        return -1;
+    }
+
+    private boolean replaceTargetDrawables(Resources res, int existingResourceId,
+            int newResourceId) {
+        if (existingResourceId == 0 || newResourceId == 0) {
+            return false;
+        }
+
+        boolean result = false;
+        final ArrayList<TargetDrawable> drawables = mTargetDrawables;
+        final int size = drawables.size();
+        for (int i = 0; i < size; i++) {
+            final TargetDrawable target = drawables.get(i);
+            if (target != null && target.getResourceId() == existingResourceId) {
+                target.setDrawable(res, newResourceId);
+                result = true;
+            }
+        }
+
+        if (result) {
+            requestLayout(); // in case any given drawable's size changes
+        }
+
+        return result;
+    }
+
+    /**
+     * Searches the given package for a resource to use to replace the Drawable on the
+     * target with the given resource id
+     * @param component of the .apk that contains the resource
+     * @param name of the metadata in the .apk
+     * @param existingResId the resource id of the target to search for
+     * @return true if found in the given package and replaced at least one target Drawables
+     */
+    public boolean replaceTargetDrawablesIfPresent(ComponentName component, String name,
+                int existingResId) {
+        if (existingResId == 0) return false;
+
+        boolean replaced = false;
+        if (component != null) {
+            try {
+                PackageManager packageManager = getContext().getPackageManager();
+                // Look for the search icon specified in the activity meta-data
+                Bundle metaData = packageManager.getActivityInfo(
+                        component, PackageManager.GET_META_DATA).metaData;
+                if (metaData != null) {
+                    int iconResId = metaData.getInt(name);
+                    if (iconResId != 0) {
+                        Resources res = packageManager.getResourcesForActivity(component);
+                        replaced = replaceTargetDrawables(res, existingResId, iconResId);
+                    }
+                }
+            } catch (NameNotFoundException e) {
+                Log.w(TAG, "Failed to swap drawable; "
+                        + component.flattenToShortString() + " not found", e);
+            } catch (Resources.NotFoundException nfe) {
+                Log.w(TAG, "Failed to swap drawable from "
+                        + component.flattenToShortString(), nfe);
+            }
+        }
+        if (!replaced) {
+            // Restore the original drawable
+            replaceTargetDrawables(getContext().getResources(), existingResId, existingResId);
+        }
+        return replaced;
+    }
+
+    public class GlowpadExploreByTouchHelper extends ExploreByTouchHelper {
+
+        private Rect mBounds = new Rect();
+
+        public GlowpadExploreByTouchHelper(View forView) {
+            super(forView);
+        }
+
+        @Override
+        protected int getVirtualViewAt(float x, float y) {
+            if (mGrabbedState == OnTriggerListener.CENTER_HANDLE) {
+                for (int i = 0; i < mTargetDrawables.size(); i++) {
+                    final TargetDrawable target = mTargetDrawables.get(i);
+                    if (target.isEnabled() && target.getBounds().contains((int) x, (int) y)) {
+                        return i;
+                    }
+                }
+                return INVALID_ID;
+            } else {
+                return HOST_ID;
+            }
+        }
+
+        @Override
+        protected void getVisibleVirtualViews(List<Integer> virtualViewIds) {
+            if (mGrabbedState == OnTriggerListener.CENTER_HANDLE) {
+                // Add virtual views backwards so that accessibility services like switch
+                // access traverse them in the correct order
+                for (int i = mTargetDrawables.size() - 1; i >= 0; i--) {
+                    if (mTargetDrawables.get(i).isEnabled()) {
+                        virtualViewIds.add(i);
+                    }
+                }
+            }
+        }
+
+        @Override
+        protected void onPopulateEventForVirtualView(int virtualViewId, AccessibilityEvent event) {
+            if (virtualViewId >= 0 && virtualViewId < mTargetDescriptions.size()) {
+                event.setContentDescription(mTargetDescriptions.get(virtualViewId));
+            }
+        }
+
+        @Override
+        public void onInitializeAccessibilityEvent(View host, AccessibilityEvent event) {
+            if (host == GlowPadView.this && event.getEventType()
+                    == AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED) {
+                event.setContentChangeTypes(AccessibilityEvent.CONTENT_CHANGE_TYPE_SUBTREE);
+            }
+            super.onInitializeAccessibilityEvent(host, event);
+        }
+
+        @Override
+        public void onPopulateNodeForHost(AccessibilityNodeInfoCompat node) {
+            if (mGrabbedState == OnTriggerListener.NO_HANDLE) {
+                node.setClickable(true);
+                node.addAction(AccessibilityNodeInfoCompat.ACTION_CLICK);
+            }
+            mBounds.set(0, 0, GlowPadView.this.getWidth(), GlowPadView.this.getHeight());
+            node.setBoundsInParent(mBounds);
+        }
+
+        @Override
+        public boolean performAccessibilityAction(View host, int action, Bundle args) {
+            if (mGrabbedState == OnTriggerListener.NO_HANDLE) {
+                // Simulate handle being grabbed to expose targets.
+                trySwitchToFirstTouchState(mWaveCenterX, mWaveCenterY);
+                invalidateRoot();
+                return true;
+            }
+            return super.performAccessibilityAction(host, action, args);
+        }
+
+        @Override
+        protected void onPopulateNodeForVirtualView(int virtualViewId,
+                AccessibilityNodeInfoCompat node) {
+            if (virtualViewId < mTargetDrawables.size()) {
+                final TargetDrawable target = mTargetDrawables.get(virtualViewId);
+                node.setBoundsInParent(target.getBounds());
+                node.setClickable(true);
+                node.addAction(AccessibilityNodeInfoCompat.ACTION_CLICK);
+                node.setContentDescription(getTargetDescription(virtualViewId));
+            }
+        }
+
+        @Override
+        protected boolean onPerformActionForVirtualView(int virtualViewId, int action,
+                Bundle arguments) {
+            if (action == AccessibilityNodeInfo.ACTION_CLICK) {
+                if (virtualViewId >= 0 && virtualViewId < mTargetDrawables.size()) {
+                    dispatchTriggerEvent(virtualViewId);
+                    return true;
+                }
+            }
+            return false;
+        }
+
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/widget/multiwaveview/PointCloud.java b/InCallUI/src/com/android/incallui/widget/multiwaveview/PointCloud.java
new file mode 100644
index 0000000..07a2cb9
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/widget/multiwaveview/PointCloud.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.widget.multiwaveview;
+
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.drawable.Drawable;
+import android.util.Log;
+
+import java.util.ArrayList;
+
+public class PointCloud {
+    private static final float MIN_POINT_SIZE = 2.0f;
+    private static final float MAX_POINT_SIZE = 4.0f;
+    private static final int INNER_POINTS = 8;
+    private static final String TAG = "PointCloud";
+    private ArrayList<Point> mPointCloud = new ArrayList<Point>();
+    private Drawable mDrawable;
+    private float mCenterX;
+    private float mCenterY;
+    private Paint mPaint;
+    private float mScale = 1.0f;
+    private static final float PI = (float) Math.PI;
+
+    // These allow us to have multiple concurrent animations.
+    WaveManager waveManager = new WaveManager();
+    GlowManager glowManager = new GlowManager();
+    private float mOuterRadius;
+
+    public class WaveManager {
+        private float radius = 50;
+        private float width = 200.0f; // TODO: Make configurable
+        private float alpha = 0.0f;
+        public void setRadius(float r) {
+            radius = r;
+        }
+
+        public float getRadius() {
+            return radius;
+        }
+
+        public void setAlpha(float a) {
+            alpha = a;
+        }
+
+        public float getAlpha() {
+            return alpha;
+        }
+    };
+
+    public class GlowManager {
+        private float x;
+        private float y;
+        private float radius = 0.0f;
+        private float alpha = 0.0f;
+
+        public void setX(float x1) {
+            x = x1;
+        }
+
+        public float getX() {
+            return x;
+        }
+
+        public void setY(float y1) {
+            y = y1;
+        }
+
+        public float getY() {
+            return y;
+        }
+
+        public void setAlpha(float a) {
+            alpha = a;
+        }
+
+        public float getAlpha() {
+            return alpha;
+        }
+
+        public void setRadius(float r) {
+            radius = r;
+        }
+
+        public float getRadius() {
+            return radius;
+        }
+    }
+
+    class Point {
+        float x;
+        float y;
+        float radius;
+
+        public Point(float x2, float y2, float r) {
+            x = (float) x2;
+            y = (float) y2;
+            radius = r;
+        }
+    }
+
+    public PointCloud(Drawable drawable) {
+        mPaint = new Paint();
+        mPaint.setFilterBitmap(true);
+        mPaint.setColor(Color.rgb(255, 255, 255)); // TODO: make configurable
+        mPaint.setAntiAlias(true);
+        mPaint.setDither(true);
+
+        mDrawable = drawable;
+        if (mDrawable != null) {
+            drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
+        }
+    }
+
+    public void setCenter(float x, float y) {
+        mCenterX = x;
+        mCenterY = y;
+    }
+
+    public void makePointCloud(float innerRadius, float outerRadius) {
+        if (innerRadius == 0) {
+            Log.w(TAG, "Must specify an inner radius");
+            return;
+        }
+        mOuterRadius = outerRadius;
+        mPointCloud.clear();
+        final float pointAreaRadius =  (outerRadius - innerRadius);
+        final float ds = (2.0f * PI * innerRadius / INNER_POINTS);
+        final int bands = (int) Math.round(pointAreaRadius / ds);
+        final float dr = pointAreaRadius / bands;
+        float r = innerRadius;
+        for (int b = 0; b <= bands; b++, r += dr) {
+            float circumference = 2.0f * PI * r;
+            final int pointsInBand = (int) (circumference / ds);
+            float eta = PI/2.0f;
+            float dEta = 2.0f * PI / pointsInBand;
+            for (int i = 0; i < pointsInBand; i++) {
+                float x = r * (float) Math.cos(eta);
+                float y = r * (float) Math.sin(eta);
+                eta += dEta;
+                mPointCloud.add(new Point(x, y, r));
+            }
+        }
+    }
+
+    public void setScale(float scale) {
+        mScale  = scale;
+    }
+
+    public float getScale() {
+        return mScale;
+    }
+
+    private static float hypot(float x, float y) {
+        return (float) Math.hypot(x, y);
+    }
+
+    private static float max(float a, float b) {
+        return a > b ? a : b;
+    }
+
+    public int getAlphaForPoint(Point point) {
+        // Contribution from positional glow
+        float glowDistance = hypot(glowManager.x - point.x, glowManager.y - point.y);
+        float glowAlpha = 0.0f;
+
+        if (glowDistance < glowManager.radius) {
+            double cos = Math.cos(Math.PI * 0.25d * glowDistance / glowManager.radius);
+            glowAlpha = glowManager.alpha * max(0.0f, (float) Math.pow(cos, 10.0d));
+        }
+
+        // Compute contribution from Wave
+        float radius = hypot(point.x, point.y);
+        float distanceToWaveRing = (radius - waveManager.radius);
+        float waveAlpha = 0.0f;
+        if (distanceToWaveRing < waveManager.width * 0.5f && distanceToWaveRing < 0.0f) {
+            double cos = Math.cos(Math.PI * 0.25d * distanceToWaveRing / waveManager.width);
+            waveAlpha = waveManager.alpha * max(0.0f, (float) Math.pow(cos, 20.0d));
+        }
+
+        return (int) (max(glowAlpha, waveAlpha) * 255);
+    }
+
+    private float interp(float min, float max, float f) {
+        return min + (max - min) * f;
+    }
+
+    public void draw(Canvas canvas) {
+        ArrayList<Point> points = mPointCloud;
+        canvas.save(Canvas.MATRIX_SAVE_FLAG);
+        canvas.scale(mScale, mScale, mCenterX, mCenterY);
+        for (int i = 0; i < points.size(); i++) {
+            Point point = points.get(i);
+            final float pointSize = interp(MAX_POINT_SIZE, MIN_POINT_SIZE,
+                    point.radius / mOuterRadius);
+            final float px = point.x + mCenterX;
+            final float py = point.y + mCenterY;
+            int alpha = getAlphaForPoint(point);
+
+            if (alpha == 0) continue;
+
+            if (mDrawable != null) {
+                canvas.save(Canvas.MATRIX_SAVE_FLAG);
+                final float cx = mDrawable.getIntrinsicWidth() * 0.5f;
+                final float cy = mDrawable.getIntrinsicHeight() * 0.5f;
+                final float s = pointSize / MAX_POINT_SIZE;
+                canvas.scale(s, s, px, py);
+                canvas.translate(px - cx, py - cy);
+                mDrawable.setAlpha(alpha);
+                mDrawable.draw(canvas);
+                canvas.restore();
+            } else {
+                mPaint.setAlpha(alpha);
+                canvas.drawCircle(px, py, pointSize, mPaint);
+            }
+        }
+        canvas.restore();
+    }
+
+}
diff --git a/InCallUI/src/com/android/incallui/widget/multiwaveview/TargetDrawable.java b/InCallUI/src/com/android/incallui/widget/multiwaveview/TargetDrawable.java
new file mode 100644
index 0000000..adc5324
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/widget/multiwaveview/TargetDrawable.java
@@ -0,0 +1,250 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.widget.multiwaveview;
+
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.StateListDrawable;
+import android.util.Log;
+
+public class TargetDrawable {
+    private static final String TAG = "TargetDrawable";
+    private static final boolean DEBUG = false;
+
+    public static final int[] STATE_ACTIVE =
+            { android.R.attr.state_enabled, android.R.attr.state_active };
+    public static final int[] STATE_INACTIVE =
+            { android.R.attr.state_enabled, -android.R.attr.state_active };
+    public static final int[] STATE_FOCUSED =
+            { android.R.attr.state_enabled, -android.R.attr.state_active,
+                android.R.attr.state_focused };
+
+    private float mTranslationX = 0.0f;
+    private float mTranslationY = 0.0f;
+    private float mPositionX = 0.0f;
+    private float mPositionY = 0.0f;
+    private float mScaleX = 1.0f;
+    private float mScaleY = 1.0f;
+    private float mAlpha = 1.0f;
+    private Drawable mDrawable;
+    private boolean mEnabled = true;
+    private final int mResourceId;
+    private int mNumDrawables = 1;
+    private Rect mBounds;
+
+    /**
+     * This is changed from the framework version to pass in the number of drawables in the
+     * container. The framework version relies on private api's to get the count from
+     * StateListDrawable.
+     *
+     * @param res
+     * @param resId
+     * @param count The number of drawables in the resource.
+     */
+    public TargetDrawable(Resources res, int resId, int count) {
+        mResourceId = resId;
+        setDrawable(res, resId);
+        mNumDrawables = count;
+    }
+
+    public void setDrawable(Resources res, int resId) {
+        // Note we explicitly don't set mResourceId to resId since we allow the drawable to be
+        // swapped at runtime and want to re-use the existing resource id for identification.
+        Drawable drawable = resId == 0 ? null : res.getDrawable(resId);
+        // Mutate the drawable so we can animate shared drawable properties.
+        mDrawable = drawable != null ? drawable.mutate() : null;
+        resizeDrawables();
+        setState(STATE_INACTIVE);
+    }
+
+    public TargetDrawable(TargetDrawable other) {
+        mResourceId = other.mResourceId;
+        // Mutate the drawable so we can animate shared drawable properties.
+        mDrawable = other.mDrawable != null ? other.mDrawable.mutate() : null;
+        resizeDrawables();
+        setState(STATE_INACTIVE);
+    }
+
+    public void setState(int [] state) {
+        if (mDrawable instanceof StateListDrawable) {
+            StateListDrawable d = (StateListDrawable) mDrawable;
+            d.setState(state);
+        }
+    }
+
+    /**
+     * Returns true if the drawable is a StateListDrawable and is in the focused state.
+     *
+     * @return
+     */
+    public boolean isActive() {
+        if (mDrawable instanceof StateListDrawable) {
+            StateListDrawable d = (StateListDrawable) mDrawable;
+            int[] states = d.getState();
+            for (int i = 0; i < states.length; i++) {
+                if (states[i] == android.R.attr.state_focused) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Returns true if this target is enabled. Typically an enabled target contains a valid
+     * drawable in a valid state. Currently all targets with valid drawables are valid.
+     *
+     * @return
+     */
+    public boolean isEnabled() {
+        return mDrawable != null && mEnabled;
+    }
+
+    /**
+     * Makes drawables in a StateListDrawable all the same dimensions.
+     * If not a StateListDrawable, then justs sets the bounds to the intrinsic size of the
+     * drawable.
+     */
+    private void resizeDrawables() {
+        if (mDrawable instanceof StateListDrawable) {
+            StateListDrawable d = (StateListDrawable) mDrawable;
+            int maxWidth = 0;
+            int maxHeight = 0;
+
+            for (int i = 0; i < mNumDrawables; i++) {
+                d.selectDrawable(i);
+                Drawable childDrawable = d.getCurrent();
+                maxWidth = Math.max(maxWidth, childDrawable.getIntrinsicWidth());
+                maxHeight = Math.max(maxHeight, childDrawable.getIntrinsicHeight());
+            }
+
+            if (DEBUG) Log.v(TAG, "union of childDrawable rects " + d + " to: "
+                    + maxWidth + "x" + maxHeight);
+            d.setBounds(0, 0, maxWidth, maxHeight);
+
+            for (int i = 0; i < mNumDrawables; i++) {
+                d.selectDrawable(i);
+                Drawable childDrawable = d.getCurrent();
+                if (DEBUG) Log.v(TAG, "sizing drawable " + childDrawable + " to: "
+                            + maxWidth + "x" + maxHeight);
+                childDrawable.setBounds(0, 0, maxWidth, maxHeight);
+            }
+        } else if (mDrawable != null) {
+            mDrawable.setBounds(0, 0,
+                    mDrawable.getIntrinsicWidth(), mDrawable.getIntrinsicHeight());
+        }
+    }
+
+    public void setX(float x) {
+        mTranslationX = x;
+    }
+
+    public void setY(float y) {
+        mTranslationY = y;
+    }
+
+    public void setScaleX(float x) {
+        mScaleX = x;
+    }
+
+    public void setScaleY(float y) {
+        mScaleY = y;
+    }
+
+    public void setAlpha(float alpha) {
+        mAlpha = alpha;
+    }
+
+    public float getX() {
+        return mTranslationX;
+    }
+
+    public float getY() {
+        return mTranslationY;
+    }
+
+    public float getScaleX() {
+        return mScaleX;
+    }
+
+    public float getScaleY() {
+        return mScaleY;
+    }
+
+    public float getAlpha() {
+        return mAlpha;
+    }
+
+    public void setPositionX(float x) {
+        mPositionX = x;
+    }
+
+    public void setPositionY(float y) {
+        mPositionY = y;
+    }
+
+    public float getPositionX() {
+        return mPositionX;
+    }
+
+    public float getPositionY() {
+        return mPositionY;
+    }
+
+    public int getWidth() {
+        return mDrawable != null ? mDrawable.getIntrinsicWidth() : 0;
+    }
+
+    public int getHeight() {
+        return mDrawable != null ? mDrawable.getIntrinsicHeight() : 0;
+    }
+
+    public Rect getBounds() {
+        if (mBounds == null) {
+            mBounds = new Rect();
+        }
+        mBounds.set((int) (mTranslationX + mPositionX - getWidth() * 0.5),
+                (int) (mTranslationY + mPositionY - getHeight() * 0.5),
+                (int) (mTranslationX + mPositionX + getWidth() * 0.5),
+                (int) (mTranslationY + mPositionY + getHeight() * 0.5));
+        return mBounds;
+    }
+
+    public void draw(Canvas canvas) {
+        if (mDrawable == null || !mEnabled) {
+            return;
+        }
+        canvas.save(Canvas.MATRIX_SAVE_FLAG);
+        canvas.scale(mScaleX, mScaleY, mPositionX, mPositionY);
+        canvas.translate(mTranslationX + mPositionX, mTranslationY + mPositionY);
+        canvas.translate(-0.5f * getWidth(), -0.5f * getHeight());
+        mDrawable.setAlpha((int) Math.round(mAlpha * 255f));
+        mDrawable.draw(canvas);
+        canvas.restore();
+    }
+
+    public void setEnabled(boolean enabled) {
+        mEnabled  = enabled;
+    }
+
+    public int getResourceId() {
+        return mResourceId;
+    }
+}
diff --git a/InCallUI/src/com/android/incallui/widget/multiwaveview/Tweener.java b/InCallUI/src/com/android/incallui/widget/multiwaveview/Tweener.java
new file mode 100644
index 0000000..7222442
--- /dev/null
+++ b/InCallUI/src/com/android/incallui/widget/multiwaveview/Tweener.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.widget.multiwaveview;
+
+import android.animation.Animator;
+import android.animation.Animator.AnimatorListener;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.animation.PropertyValuesHolder;
+import android.animation.TimeInterpolator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map.Entry;
+
+class Tweener {
+    private static final String TAG = "Tweener";
+    private static final boolean DEBUG = false;
+
+    ObjectAnimator animator;
+    private static HashMap<Object, Tweener> sTweens = new HashMap<Object, Tweener>();
+
+    public Tweener(ObjectAnimator anim) {
+        animator = anim;
+    }
+
+    private static void remove(Animator animator) {
+        Iterator<Entry<Object, Tweener>> iter = sTweens.entrySet().iterator();
+        while (iter.hasNext()) {
+            Entry<Object, Tweener> entry = iter.next();
+            if (entry.getValue().animator == animator) {
+                if (DEBUG) Log.v(TAG, "Removing tweener " + sTweens.get(entry.getKey())
+                        + " sTweens.size() = " + sTweens.size());
+                iter.remove();
+                break; // an animator can only be attached to one object
+            }
+        }
+    }
+
+    public static Tweener to(Object object, long duration, Object... vars) {
+        long delay = 0;
+        AnimatorUpdateListener updateListener = null;
+        AnimatorListener listener = null;
+        TimeInterpolator interpolator = null;
+
+        // Iterate through arguments and discover properties to animate
+        ArrayList<PropertyValuesHolder> props = new ArrayList<PropertyValuesHolder>(vars.length/2);
+        for (int i = 0; i < vars.length; i+=2) {
+            if (!(vars[i] instanceof String)) {
+                throw new IllegalArgumentException("Key must be a string: " + vars[i]);
+            }
+            String key = (String) vars[i];
+            Object value = vars[i+1];
+
+            if ("simultaneousTween".equals(key)) {
+                // TODO
+            } else if ("ease".equals(key)) {
+                interpolator = (TimeInterpolator) value; // TODO: multiple interpolators?
+            } else if ("onUpdate".equals(key) || "onUpdateListener".equals(key)) {
+                updateListener = (AnimatorUpdateListener) value;
+            } else if ("onComplete".equals(key) || "onCompleteListener".equals(key)) {
+                listener = (AnimatorListener) value;
+            } else if ("delay".equals(key)) {
+                delay = ((Number) value).longValue();
+            } else if ("syncWith".equals(key)) {
+                // TODO
+            } else if (value instanceof float[]) {
+                props.add(PropertyValuesHolder.ofFloat(key,
+                        ((float[])value)[0], ((float[])value)[1]));
+            } else if (value instanceof int[]) {
+                props.add(PropertyValuesHolder.ofInt(key,
+                        ((int[])value)[0], ((int[])value)[1]));
+            } else if (value instanceof Number) {
+                float floatValue = ((Number)value).floatValue();
+                props.add(PropertyValuesHolder.ofFloat(key, floatValue));
+            } else {
+                throw new IllegalArgumentException(
+                        "Bad argument for key \"" + key + "\" with value " + value.getClass());
+            }
+        }
+
+        // Re-use existing tween, if present
+        Tweener tween = sTweens.get(object);
+        ObjectAnimator anim = null;
+        if (tween == null) {
+            anim = ObjectAnimator.ofPropertyValuesHolder(object,
+                    props.toArray(new PropertyValuesHolder[props.size()]));
+            tween = new Tweener(anim);
+            sTweens.put(object, tween);
+            if (DEBUG) Log.v(TAG, "Added new Tweener " + tween);
+        } else {
+            anim = sTweens.get(object).animator;
+            replace(props, object); // Cancel all animators for given object
+        }
+
+        if (interpolator != null) {
+            anim.setInterpolator(interpolator);
+        }
+
+        // Update animation with properties discovered in loop above
+        anim.setStartDelay(delay);
+        anim.setDuration(duration);
+        if (updateListener != null) {
+            anim.removeAllUpdateListeners(); // There should be only one
+            anim.addUpdateListener(updateListener);
+        }
+        if (listener != null) {
+            anim.removeAllListeners(); // There should be only one.
+            anim.addListener(listener);
+        }
+        anim.addListener(mCleanupListener);
+
+        return tween;
+    }
+
+    Tweener from(Object object, long duration, Object... vars) {
+        // TODO:  for v of vars
+        //            toVars[v] = object[v]
+        //            object[v] = vars[v]
+        return Tweener.to(object, duration, vars);
+    }
+
+    // Listener to watch for completed animations and remove them.
+    private static AnimatorListener mCleanupListener = new AnimatorListenerAdapter() {
+
+        @Override
+        public void onAnimationEnd(Animator animation) {
+            remove(animation);
+        }
+
+        @Override
+        public void onAnimationCancel(Animator animation) {
+            remove(animation);
+        }
+    };
+
+    public static void reset() {
+        if (DEBUG) {
+            Log.v(TAG, "Reset()");
+            if (sTweens.size() > 0) {
+                Log.v(TAG, "Cleaning up " + sTweens.size() + " animations");
+            }
+        }
+        sTweens.clear();
+    }
+
+    private static void replace(ArrayList<PropertyValuesHolder> props, Object... args) {
+        for (final Object killobject : args) {
+            Tweener tween = sTweens.get(killobject);
+            if (tween != null) {
+                tween.animator.cancel();
+                if (props != null) {
+                    tween.animator.setValues(
+                            props.toArray(new PropertyValuesHolder[props.size()]));
+                } else {
+                    sTweens.remove(tween);
+                }
+            }
+        }
+    }
+}
diff --git a/InCallUI/src/com/android/incalluibind/ObjectFactory.java b/InCallUI/src/com/android/incalluibind/ObjectFactory.java
new file mode 100644
index 0000000..7e9423a
--- /dev/null
+++ b/InCallUI/src/com/android/incalluibind/ObjectFactory.java
@@ -0,0 +1,59 @@
+/*
+ * 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.
+ */
+
+package com.android.incalluibind;
+
+import android.content.Context;
+import android.content.Intent;
+
+import com.android.incallui.CallCardPresenter.EmergencyCallListener;
+import com.android.incallui.ContactUtils;
+import com.android.incallui.DistanceHelper;
+import com.android.incallui.service.PhoneNumberService;
+
+public class ObjectFactory {
+
+    public static PhoneNumberService newPhoneNumberService(Context context) {
+        // no phone number service.
+        return null;
+    }
+
+    public static EmergencyCallListener newEmergencyCallListener() {
+        return null;
+    }
+
+    /** @return An {@link Intent} to be broadcast when the InCallUI is visible. */
+    public static Intent getUiReadyBroadcastIntent(Context context) {
+        return null;
+    }
+
+    /**
+     * @return An {@link Intent} to be broadcast when the call state button in the InCallUI is
+     * touched while in a call.
+     */
+    public static Intent getCallStateButtonBroadcastIntent(Context context) {
+        return null;
+    }
+
+    public static DistanceHelper newDistanceHelper(Context context,
+            DistanceHelper.Listener listener) {
+        return null;
+    }
+
+    public static ContactUtils getContactUtilsInstance(Context context) {
+        return null;
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/CallCardPresenterTest.java b/InCallUI/tests/src/com/android/incallui/CallCardPresenterTest.java
new file mode 100644
index 0000000..79545ce
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/CallCardPresenterTest.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.MediumTest;
+
+import com.android.contacts.common.preference.ContactsPreferences;
+import com.android.incallui.ContactInfoCache.ContactCacheEntry;
+
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+@MediumTest
+public class CallCardPresenterTest extends AndroidTestCase {
+
+    private static final String NAME_PRIMARY = "Full Name";
+    private static final String NAME_ALTERNATIVE = "Name, Full";
+    private static final String LOCATION = "US";
+    private static final String NUMBER = "8006459001";
+
+    @Mock private ContactsPreferences mContactsPreferences;
+    private ContactCacheEntry mUnlockedContactInfo;
+    private ContactCacheEntry mLockedContactInfo;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+
+        Mockito.when(mContactsPreferences.getDisplayOrder())
+                .thenReturn(ContactsPreferences.DISPLAY_ORDER_PRIMARY);
+
+        // Unlocked all contact info is available
+        mUnlockedContactInfo = new ContactCacheEntry();
+        mUnlockedContactInfo.namePrimary = NAME_PRIMARY;
+        mUnlockedContactInfo.nameAlternative = NAME_ALTERNATIVE;
+        mUnlockedContactInfo.location = LOCATION;
+        mUnlockedContactInfo.number = NUMBER;
+
+        // Locked only number and location are available
+        mLockedContactInfo = new ContactCacheEntry();
+        mLockedContactInfo .location = LOCATION;
+        mLockedContactInfo .number = NUMBER;
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        ContactsPreferencesFactory.setTestInstance(null);
+    }
+
+    public void testGetNameForCall_Unlocked() {
+        ContactsPreferencesFactory.setTestInstance(mContactsPreferences);
+        CallCardPresenter presenter = new CallCardPresenter();
+        presenter.init(getContext(), null);
+
+        assertEquals(NAME_PRIMARY, presenter.getNameForCall(mUnlockedContactInfo));
+    }
+
+    public void testGetNameForCall_Locked() {
+        ContactsPreferencesFactory.setTestInstance(null);
+        CallCardPresenter presenter = new CallCardPresenter();
+        presenter.init(getContext(), null);
+
+        assertEquals(NUMBER, presenter.getNameForCall(mLockedContactInfo));
+    }
+
+    public void testGetNameForCall_EmptyPreferredName() {
+        ContactCacheEntry contactInfo = new ContactCacheEntry();
+        contactInfo.number = NUMBER;
+
+        ContactsPreferencesFactory.setTestInstance(null);
+        CallCardPresenter presenter = new CallCardPresenter();
+        presenter.init(getContext(), null);
+
+        assertEquals(NUMBER, presenter.getNameForCall(contactInfo));
+    }
+
+    public void testGetNumberForCall_Unlocked() {
+        ContactsPreferencesFactory.setTestInstance(mContactsPreferences);
+        CallCardPresenter presenter = new CallCardPresenter();
+        presenter.init(getContext(), null);
+
+        assertEquals(NUMBER, presenter.getNumberForCall(mUnlockedContactInfo));
+    }
+
+    public void testGetNumberForCall_Locked() {
+        ContactsPreferencesFactory.setTestInstance(null);
+        CallCardPresenter presenter = new CallCardPresenter();
+        presenter.init(getContext(), null);
+
+        assertEquals(LOCATION, presenter.getNumberForCall(mLockedContactInfo));
+    }
+
+    public void testGetNumberForCall_EmptyPreferredName() {
+        ContactCacheEntry contactInfo = new ContactCacheEntry();
+        contactInfo.location = LOCATION;
+
+        ContactsPreferencesFactory.setTestInstance(null);
+        CallCardPresenter presenter = new CallCardPresenter();
+        presenter.init(getContext(), null);
+
+        assertEquals(LOCATION, presenter.getNumberForCall(contactInfo));
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/CallTest.java b/InCallUI/tests/src/com/android/incallui/CallTest.java
new file mode 100644
index 0000000..118ec38
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/CallTest.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.os.Bundle;
+import android.telecom.Connection;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+// @formatter:off
+/**
+ * Run test with
+ * adb shell am instrument -e class com.android.incallui.CallTest -w com.google.android.dialer.tests/android.test.InstrumentationTestRunner
+ */
+// @formatter:on
+
+@SmallTest
+public class CallTest extends AndroidTestCase {
+
+    private TestCall mCall;
+
+    private final static String CHILD_NUMBER = "123";
+    private final static ArrayList<String> LAST_FORWARDED_NUMBER_LIST =
+            new ArrayList(Arrays.asList("456", "789"));
+    private final static String LAST_FORWARDED_NUMBER = "789";
+    private final static String CALL_SUBJECT = "foo";
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+
+        mCall = new TestCall();
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+    }
+
+    public void testUpdateFromCallExtras() {
+        mCall.updateFromCallExtras(getTestBundle());
+        verifyTestBundleResult();
+    }
+
+    public void testUpdateFromCallExtras_corruptedBundle() {
+        mCall.setBundleCorrupted(true);
+        mCall.updateFromCallExtras(getTestBundle());
+
+        assertEquals(mCall.getChildNumber(), null);
+        assertEquals(mCall.getLastForwardedNumber(), null);
+        assertEquals(mCall.getCallSubject(), null);
+    }
+
+    public void testUpdateFromCallExtras_corruptedBundleOverwrite() {
+
+        mCall.updateFromCallExtras(getTestBundle());
+        mCall.setBundleCorrupted(true);
+        Bundle bundle = new Bundle();
+        bundle.putString(Connection.EXTRA_CHILD_ADDRESS, "321");
+        bundle.putStringArrayList(Connection.EXTRA_LAST_FORWARDED_NUMBER,
+                new ArrayList(Arrays.asList("654", "987")));
+        bundle.putString(Connection.EXTRA_CALL_SUBJECT, "bar");
+        mCall.updateFromCallExtras(bundle);
+        //corrupted bundle should not overwrite existing values.
+        verifyTestBundleResult();
+    }
+
+    private Bundle getTestBundle() {
+        Bundle bundle = new Bundle();
+        bundle.putString(Connection.EXTRA_CHILD_ADDRESS, CHILD_NUMBER);
+        bundle.putStringArrayList(Connection.EXTRA_LAST_FORWARDED_NUMBER,
+                LAST_FORWARDED_NUMBER_LIST);
+        bundle.putString(Connection.EXTRA_CALL_SUBJECT, CALL_SUBJECT);
+        return bundle;
+    }
+
+    private void verifyTestBundleResult() {
+        assertEquals(CHILD_NUMBER, mCall.getChildNumber());
+        assertEquals(LAST_FORWARDED_NUMBER, mCall.getLastForwardedNumber());
+        assertEquals(CALL_SUBJECT, mCall.getCallSubject());
+    }
+
+    private class TestCall extends Call {
+
+        private boolean mBundleCorrupted = false;
+
+        public TestCall() {
+            super(Call.State.NEW);
+        }
+
+        @Override
+        public void updateFromCallExtras(Bundle bundle) {
+            super.updateFromCallExtras(bundle);
+        }
+
+        public void setBundleCorrupted(boolean value) {
+            this.mBundleCorrupted = value;
+        }
+
+        @Override
+        protected boolean areCallExtrasCorrupted(Bundle callExtras) {
+            if (mBundleCorrupted) {
+                return true;
+            }
+            return super.areCallExtrasCorrupted(callExtras);
+        }
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/CallerInfoUtilsTest.java b/InCallUI/tests/src/com/android/incallui/CallerInfoUtilsTest.java
new file mode 100644
index 0000000..de5a023
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/CallerInfoUtilsTest.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+@SmallTest
+public class CallerInfoUtilsTest extends AndroidTestCase {
+    public void testToLogSafeNumber_email() {
+        assertEquals("xxx@xxx.xxx", CallerInfoUtils.toLogSafePhoneNumber("foo@foo.com"));
+    }
+
+    public void testToLogSafeNumber_phoneNumber() {
+        assertEquals("xxx-xxx-xxxx", CallerInfoUtils.toLogSafePhoneNumber("123-456-6789"));
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/ContactsPreferencesFactoryTest.java b/InCallUI/tests/src/com/android/incallui/ContactsPreferencesFactoryTest.java
new file mode 100644
index 0000000..bf91555
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/ContactsPreferencesFactoryTest.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import com.android.dialer.compat.UserManagerCompat;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import com.android.contacts.common.preference.ContactsPreferences;
+
+import org.mockito.Mockito;
+
+@SmallTest
+public class ContactsPreferencesFactoryTest extends AndroidTestCase {
+
+    public void testNewContactsPreferences_Unlocked() {
+        if (!UserManagerCompat.isUserUnlocked(getContext())) {
+            return;
+        }
+        assertNotNull(ContactsPreferencesFactory.newContactsPreferences(getContext()));
+    }
+
+    public void testNewContactsPreferences_Locked() {
+        if (UserManagerCompat.isUserUnlocked(getContext())) {
+            return;
+        }
+        assertNull(ContactsPreferencesFactory.newContactsPreferences(getContext()));
+    }
+
+    public void testNewContactsPreferences_TestInstance() {
+        ContactsPreferences testInstance = Mockito.mock(ContactsPreferences.class);
+        ContactsPreferencesFactory.setTestInstance(testInstance);
+        // Assert that it returns the same object always
+        assertSame(testInstance, ContactsPreferencesFactory.newContactsPreferences(getContext()));
+        assertSame(testInstance, ContactsPreferencesFactory.newContactsPreferences(getContext()));
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/InCallContactInteractionsTest.java b/InCallUI/tests/src/com/android/incallui/InCallContactInteractionsTest.java
new file mode 100644
index 0000000..625cda4
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/InCallContactInteractionsTest.java
@@ -0,0 +1,325 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.location.Address;
+import android.test.AndroidTestCase;
+import android.util.Pair;
+
+import com.android.incallui.InCallContactInteractions.BusinessContextInfo;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * Tests for InCallContactInteractions class methods for formatting info for display.
+ *
+ * NOTE: tests assume system settings are set to 12hr time format and US locale. This means that
+ * the output of InCallContactInteractions methods are compared against strings in 12hr time format
+ * and US locale address formatting unless otherwise specified.
+ */
+public class InCallContactInteractionsTest extends AndroidTestCase {
+    private InCallContactInteractions mInCallContactInteractions;
+    private static final float TEST_DISTANCE = (float) 1234.56;
+
+    @Override
+    protected void setUp() {
+        mInCallContactInteractions = new InCallContactInteractions(mContext, true /* isBusiness */);
+    }
+
+    public void testIsOpenNow_NowMatchesOpenTime() {
+        assertEquals(mContext.getString(R.string.open_now),
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(8),
+                        Arrays.asList(
+                                Pair.create(
+                                        getTestCalendarWithHour(8),
+                                        getTestCalendarWithHour(20))))
+                .heading);
+    }
+
+    public void testIsOpenNow_ClosingAfterMidnight() {
+        assertEquals(mContext.getString(R.string.open_now),
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(10),
+                        Arrays.asList(
+                                Pair.create(
+                                        getTestCalendarWithHour(8),
+                                        getTestCalendarWithHourAndDaysFromToday(1, 1))))
+                .heading);
+    }
+
+    public void testIsOpenNow_Open24Hours() {
+        assertEquals(mContext.getString(R.string.open_now),
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(10),
+                        Arrays.asList(
+                                Pair.create(
+                                        getTestCalendarWithHour(8),
+                                        getTestCalendarWithHourAndDaysFromToday(8, 1))))
+                .heading);
+    }
+
+    public void testIsOpenNow_AfterMiddayBreak() {
+        assertEquals(mContext.getString(R.string.open_now),
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(13),
+                        Arrays.asList(
+                                Pair.create(
+                                        getTestCalendarWithHour(8),
+                                        getTestCalendarWithHour(10)),
+                                Pair.create(
+                                        getTestCalendarWithHour(12),
+                                        getTestCalendarWithHour(15))))
+                .heading);
+    }
+
+    public void testIsClosedNow_DuringMiddayBreak() {
+        assertEquals(mContext.getString(R.string.closed_now),
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(11),
+                        Arrays.asList(
+                                Pair.create(
+                                        getTestCalendarWithHour(8),
+                                        getTestCalendarWithHour(10)),
+                                Pair.create(
+                                        getTestCalendarWithHour(12),
+                                        getTestCalendarWithHour(15))))
+                .heading);
+    }
+
+    public void testIsClosedNow_BeforeOpen() {
+        assertEquals(mContext.getString(R.string.closed_now),
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(6),
+                        Arrays.asList(
+                                Pair.create(
+                                        getTestCalendarWithHour(8),
+                                        getTestCalendarWithHour(20))))
+                .heading);
+    }
+
+    public void testIsClosedNow_NowMatchesClosedTime() {
+        assertEquals(mContext.getString(R.string.closed_now),
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(20),
+                        Arrays.asList(
+                                Pair.create(
+                                        getTestCalendarWithHour(8),
+                                        getTestCalendarWithHour(20))))
+                .heading);
+    }
+
+    public void testIsClosedNow_AfterClosed() {
+        assertEquals(mContext.getString(R.string.closed_now),
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(21),
+                        Arrays.asList(
+                                Pair.create(
+                                        getTestCalendarWithHour(8),
+                                        getTestCalendarWithHour(20))))
+                .heading);
+    }
+
+    public void testOpeningHours_SingleOpenRangeWhileOpen() {
+        assertEquals("8:00 AM - 8:00 PM",
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(12),
+                        Arrays.asList(
+                                Pair.create(
+                                        getTestCalendarWithHour(8),
+                                        getTestCalendarWithHour(20))))
+                .detail);
+    }
+
+    public void testOpeningHours_TwoOpenRangesWhileOpen() {
+        assertEquals("8:00 AM - 10:00 AM, 12:00 PM - 3:00 PM",
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(12),
+                        Arrays.asList(
+                                Pair.create(
+                                    getTestCalendarWithHour(8),
+                                    getTestCalendarWithHour(10)),
+                                Pair.create(
+                                        getTestCalendarWithHour(12),
+                                        getTestCalendarWithHour(15))))
+                .detail);
+    }
+
+    public void testOpeningHours_AfterClosedNoTomorrow() {
+        assertEquals("Closed today at 8:00 PM",
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(21),
+                        Arrays.asList(
+                                Pair.create(
+                                        getTestCalendarWithHour(8),
+                                        getTestCalendarWithHour(20))))
+                .detail);
+    }
+
+    public void testOpeningHours_NotOpenTodayOpenTomorrow() {
+        assertEquals("Opens tomorrow at 8:00 AM",
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(21),
+                        Arrays.asList(
+                                Pair.create(
+                                        getTestCalendarWithHourAndDaysFromToday(8, 1),
+                                        getTestCalendarWithHourAndDaysFromToday(10, 1))))
+                .detail);
+    }
+
+    public void testMultipleOpenRanges_BeforeOpen() {
+        assertEquals("Opens today at 8:00 AM",
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(7),
+                        getMultipleOpeningHours())
+                .detail);
+    }
+
+    public void testMultipleOpenRanges_DuringFirstRange() {
+        assertEquals("Closes at 10:00 AM",
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(9),
+                        getMultipleOpeningHours())
+                .detail);
+    }
+
+    public void testMultipleOpenRanges_BeforeMiddleRange() {
+        assertEquals("Opens today at 12:00 PM",
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(11),
+                        getMultipleOpeningHours())
+                .detail);
+    }
+
+    public void testMultipleOpeningHours_DuringLastRange() {
+        assertEquals("Closes at 9:00 PM",
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(19),
+                        getMultipleOpeningHours())
+                .detail);
+    }
+
+    public void testMultipleOpeningHours_AfterClose() {
+        assertEquals("Opens tomorrow at 8:00 AM",
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(22),
+                        getMultipleOpeningHours())
+                .detail);
+    }
+
+    public void testNotOpenTodayOrTomorrow() {
+        assertEquals(null,
+                mInCallContactInteractions.constructHoursInfo(
+                        getTestCalendarWithHour(21),
+                        new ArrayList<Pair<Calendar, Calendar>>()));
+    }
+
+    public void testLocationInfo_ForUS() {
+        BusinessContextInfo info =
+                mInCallContactInteractions.constructLocationInfo(
+                        Locale.US,
+                        getAddressForTest(),
+                        TEST_DISTANCE);
+        assertEquals("0.8 mi away", info.heading);
+        assertEquals("Test address, Test locality", info.detail);
+    }
+
+    public void testLocationInfo_ForNotUS() {
+        BusinessContextInfo info =
+                mInCallContactInteractions.constructLocationInfo(
+                        Locale.CANADA,
+                        getAddressForTest(),
+                        TEST_DISTANCE);
+        assertEquals("1.2 km away", info.heading);
+        assertEquals("Test address, Test locality", info.detail);
+    }
+
+    public void testLocationInfo_NoLocality() {
+        Address address = getAddressForTest();
+        address.setLocality(null);
+        BusinessContextInfo info =
+                mInCallContactInteractions.constructLocationInfo(
+                        Locale.CANADA,
+                        address,
+                        TEST_DISTANCE);
+        assertEquals("1.2 km away", info.heading);
+        assertEquals("Test address", info.detail);
+    }
+
+    public void testLocationInfo_NoAddress() {
+        BusinessContextInfo info =
+                mInCallContactInteractions.constructLocationInfo(
+                        Locale.CANADA,
+                        null,
+                        TEST_DISTANCE);
+        assertEquals(null, info);
+    }
+
+    public void testLocationInfo_NoDistance() {
+        BusinessContextInfo info =
+                mInCallContactInteractions.constructLocationInfo(
+                        Locale.US,
+                        getAddressForTest(),
+                        DistanceHelper.DISTANCE_NOT_FOUND);
+        assertEquals(null, info.heading);
+    }
+
+    private Address getAddressForTest() {
+        Address address = new Address(Locale.US);
+        address.setAddressLine(0, "Test address");
+        address.setLocality("Test locality");
+        return address;
+    }
+
+    private Calendar getTestCalendarWithHour(int hour) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(Calendar.HOUR_OF_DAY, hour);
+        calendar.set(Calendar.MINUTE, 0);
+        calendar.set(Calendar.SECOND, 0);
+        calendar.set(Calendar.MILLISECOND, 0);
+        return calendar;
+    }
+
+    private Calendar getTestCalendarWithHourAndDaysFromToday(int hour, int daysFromToday) {
+        Calendar calendar = getTestCalendarWithHour(hour);
+        calendar.add(Calendar.DATE, daysFromToday);
+        return calendar;
+    }
+
+    private List<Pair<Calendar, Calendar>> getMultipleOpeningHours() {
+        return Arrays.asList(
+                Pair.create(
+                    getTestCalendarWithHour(8),
+                    getTestCalendarWithHour(10)),
+                Pair.create(
+                        getTestCalendarWithHour(12),
+                        getTestCalendarWithHour(15)),
+                Pair.create(
+                        getTestCalendarWithHour(17),
+                        getTestCalendarWithHour(21)),
+                Pair.create(
+                        getTestCalendarWithHourAndDaysFromToday(8, 1),
+                        getTestCalendarWithHourAndDaysFromToday(10, 1)),
+                Pair.create(
+                        getTestCalendarWithHourAndDaysFromToday(12, 1),
+                        getTestCalendarWithHourAndDaysFromToday(8, 1)));
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/InCallPresenterTest.java b/InCallUI/tests/src/com/android/incallui/InCallPresenterTest.java
new file mode 100644
index 0000000..ed8d622
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/InCallPresenterTest.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.Intent;
+import android.telecom.PhoneAccountHandle;
+import android.telephony.TelephonyManager;
+import android.test.InstrumentationTestCase;
+import android.test.suitebuilder.annotation.MediumTest;
+
+import com.android.incallui.InCallPresenter.InCallState;
+
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+@MediumTest
+public class InCallPresenterTest extends InstrumentationTestCase {
+    private MockCallListWrapper mCallList;
+    @Mock private InCallActivity mInCallActivity;
+    @Mock private AudioModeProvider mAudioModeProvider;
+    @Mock private StatusBarNotifier mStatusBarNotifier;
+    @Mock private ContactInfoCache mContactInfoCache;
+    @Mock private ProximitySensor mProximitySensor;
+
+    InCallPresenter mInCallPresenter;
+    @Mock private Context mContext;
+    @Mock private TelephonyManager mTelephonyManager;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        System.setProperty("dexmaker.dexcache",
+                getInstrumentation().getTargetContext().getCacheDir().getPath());
+        MockitoAnnotations.initMocks(this);
+        mCallList = new MockCallListWrapper();
+
+        when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager);
+
+        mInCallPresenter = InCallPresenter.getInstance();
+        mInCallPresenter.setUp(mContext, mCallList.getCallList(), mAudioModeProvider,
+                mStatusBarNotifier, mContactInfoCache, mProximitySensor);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        // The tear down method needs to run in the main thread since there is an explicit check
+        // inside TelecomAdapter.getInstance().
+        getInstrumentation().runOnMainSync(new Runnable() {
+            @Override
+            public void run() {
+                mInCallPresenter.unsetActivity(mInCallActivity);
+                mInCallPresenter.tearDown();
+                InCallPresenter.setInstance(null);
+            }
+        });
+    }
+
+    public void testOnActivitySet_finishesActivityWhenNoCalls() {
+        mInCallPresenter.setActivity(mInCallActivity);
+
+        verify(mInCallActivity).finish();
+    }
+
+    public void testOnCallListChange_sendsNotificationWhenInCall() {
+        mCallList.setHasCall(Call.State.INCOMING, true);
+
+        mInCallPresenter.onCallListChange(mCallList.getCallList());
+
+        verify(mStatusBarNotifier).updateNotification(InCallState.INCOMING,
+                mCallList.getCallList());
+        verifyInCallActivityNotStarted();
+    }
+
+    /**
+     * This behavior is required to ensure that the screen is turned on again by the restarting
+     * activity.
+     */
+    public void testOnCallListChange_handlesCallWaitingWhenScreenOffShouldRestartActivity() {
+        mCallList.setHasCall(Call.State.ACTIVE, true);
+
+        mInCallPresenter.onCallListChange(mCallList.getCallList());
+        mInCallPresenter.setActivity(mInCallActivity);
+
+        // Pretend that there is a call waiting and the screen is off
+        when(mInCallActivity.isDestroyed()).thenReturn(false);
+        when(mInCallActivity.isFinishing()).thenReturn(false);
+        when(mProximitySensor.isScreenReallyOff()).thenReturn(true);
+        mCallList.setHasCall(Call.State.INCOMING, true);
+
+        mInCallPresenter.onCallListChange(mCallList.getCallList());
+        verify(mInCallActivity).finish();
+    }
+
+    /**
+     * Verifies that the PENDING_OUTGOING -> IN_CALL transition brings up InCallActivity so
+     * that it can display an error dialog.
+     */
+    public void testOnCallListChange_pendingOutgoingToInCallTransitionShowsUiForErrorDialog() {
+        mCallList.setHasCall(Call.State.CONNECTING, true);
+
+        mInCallPresenter.onCallListChange(mCallList.getCallList());
+
+        mCallList.setHasCall(Call.State.CONNECTING, false);
+        mCallList.setHasCall(Call.State.ACTIVE, true);
+
+        mInCallPresenter.onCallListChange(mCallList.getCallList());
+
+        verify(mContext).startActivity(InCallPresenter.getInstance().getInCallIntent(false, false));
+        verifyIncomingCallNotificationNotSent();
+    }
+
+    /**
+     * Verifies that if there is a call in the SELECT_PHONE_ACCOUNT state, InCallActivity is displayed
+     * to display the account picker.
+     */
+    public void testOnCallListChange_noAccountProvidedForCallShowsUiForAccountPicker() {
+        mCallList.setHasCall(Call.State.SELECT_PHONE_ACCOUNT, true);
+        mInCallPresenter.onCallListChange(mCallList.getCallList());
+
+        verify(mContext).startActivity(InCallPresenter.getInstance().getInCallIntent(false, false));
+        verifyIncomingCallNotificationNotSent();
+    }
+
+    /**
+     * Verifies that for an expected call state change (e.g. NO_CALLS -> PENDING_OUTGOING),
+     * InCallActivity is not displayed.
+     */
+    public void testOnCallListChange_noCallsToPendingOutgoingDoesNotShowUi() {
+        mCallList.setHasCall(Call.State.CONNECTING, true);
+        mInCallPresenter.onCallListChange(mCallList.getCallList());
+
+        verifyInCallActivityNotStarted();
+        verifyIncomingCallNotificationNotSent();
+    }
+
+    public void testOnCallListChange_LastCallDisconnectedNoCallsLeftFinishesUi() {
+        mCallList.setHasCall(Call.State.DISCONNECTED, true);
+        mInCallPresenter.onCallListChange(mCallList.getCallList());
+
+        mInCallPresenter.setActivity(mInCallActivity);
+
+        verify(mInCallActivity, never()).finish();
+
+        // Last remaining disconnected call is removed from CallList, activity should shut down.
+        mCallList.setHasCall(Call.State.DISCONNECTED, false);
+        mInCallPresenter.onCallListChange(mCallList.getCallList());
+        verify(mInCallActivity).finish();
+    }
+
+
+    //TODO
+    public void testCircularReveal_startsCircularRevealForOutgoingCalls() {
+
+    }
+
+    public void testCircularReveal_waitTillCircularRevealSentBeforeShowingCallCard() {
+    }
+
+    public void testHangupOngoingCall_disconnectsCallCorrectly() {
+    }
+
+    public void testAnswerIncomingCall() {
+    }
+
+    public void testDeclineIncomingCall() {
+    }
+
+    private void verifyInCallActivityNotStarted() {
+        verify(mContext, never()).startActivity(Mockito.any(Intent.class));
+    }
+
+    private void verifyIncomingCallNotificationNotSent() {
+        verify(mStatusBarNotifier, never()).updateNotification(Mockito.any(InCallState.class),
+                Mockito.any(CallList.class));
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/MockCallListWrapper.java b/InCallUI/tests/src/com/android/incallui/MockCallListWrapper.java
new file mode 100644
index 0000000..369c430
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/MockCallListWrapper.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import static org.mockito.Mockito.anyInt;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.telecom.PhoneAccountHandle;
+
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.util.HashSet;
+
+/**
+ * Provides an instance of a mock CallList, and provides utility methods to put the CallList into
+ * various states (e.g. incoming call, active call, call waiting).
+ */
+public class MockCallListWrapper {
+    private CallList mCallList;
+    private HashSet<Integer> mCallSet = new HashSet<>();
+
+    public MockCallListWrapper() {
+        mCallList = Mockito.mock(CallList.class);
+        mCallList = spy(new CallList());
+        when(mCallList.getFirstCallWithState(anyInt())).thenAnswer(new Answer<Call>() {
+            @Override
+            public Call answer(InvocationOnMock i) throws Throwable {
+                Object[] args = i.getArguments();
+                final int state = (int) args[0];
+                if (mCallSet.contains(state)) {
+                    return getMockCall(state);
+                } else {
+                    return null;
+                }
+            }
+        });
+    }
+
+    public CallList getCallList() {
+        return mCallList;
+    }
+
+    public void setHasCall(int state, boolean hasCall) {
+        if (hasCall) {
+            mCallSet.add(state);
+        } else {
+            mCallSet.remove(state);
+        }
+    }
+
+    private static Call getMockCall(int state) {
+        return getMockCall(state, state != Call.State.SELECT_PHONE_ACCOUNT);
+    }
+
+    private static Call getMockCall(int state, boolean hasAccountHandle) {
+        final Call call = Mockito.mock(Call.class);
+        when(call.getState()).thenReturn(Integer.valueOf(state));
+        if (hasAccountHandle) {
+            when(call.getAccountHandle()).thenReturn(new PhoneAccountHandle(null, null));
+        }
+        return call;
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/ProximitySensorTest.java b/InCallUI/tests/src/com/android/incallui/ProximitySensorTest.java
new file mode 100644
index 0000000..1c8f347
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/ProximitySensorTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import static org.mockito.Mockito.anyBoolean;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import android.test.InstrumentationTestCase;
+import android.test.suitebuilder.annotation.MediumTest;
+
+import com.android.incallui.InCallPresenter.InCallState;
+
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+@MediumTest
+public class ProximitySensorTest extends InstrumentationTestCase {
+    @Mock private AccelerometerListener mAccelerometerListener;
+    private MockCallListWrapper mCallList;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        System.setProperty("dexmaker.dexcache",
+                getInstrumentation().getTargetContext().getCacheDir().getPath());
+        MockitoAnnotations.initMocks(this);
+        mCallList = new MockCallListWrapper();
+    }
+
+    public void testAccelerometerBehaviorOnDisplayChange() {
+        final ProximitySensor proximitySensor =
+                new ProximitySensor(
+                        getInstrumentation().getContext(),
+                        new AudioModeProvider(),
+                        mAccelerometerListener);
+        verify(mAccelerometerListener, never()).enable(anyBoolean());
+        proximitySensor.onStateChange(null, InCallState.OUTGOING, mCallList.getCallList());
+        verify(mAccelerometerListener).enable(true);
+        verify(mAccelerometerListener, never()).enable(false);
+
+        proximitySensor.onDisplayStateChanged(false);
+        verify(mAccelerometerListener).enable(true);
+        verify(mAccelerometerListener).enable(false);
+
+        proximitySensor.onDisplayStateChanged(true);
+        verify(mAccelerometerListener, times(2)).enable(true);
+        verify(mAccelerometerListener).enable(false);
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/StatusBarNotifierTest.java b/InCallUI/tests/src/com/android/incallui/StatusBarNotifierTest.java
new file mode 100644
index 0000000..4c55ddc
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/StatusBarNotifierTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui;
+
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.MediumTest;
+
+import com.android.contacts.common.preference.ContactsPreferences;
+import com.android.incallui.ContactInfoCache.ContactCacheEntry;
+
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+@MediumTest
+public class StatusBarNotifierTest extends AndroidTestCase {
+
+    private static final String NAME_PRIMARY = "Full Name";
+    private static final String NAME_ALTERNATIVE = "Name, Full";
+    private static final String LOCATION = "US";
+    private static final String NUMBER = "8006459001";
+
+    @Mock private Call mCall;
+    @Mock private ContactsPreferences mContactsPreferences;
+    private ContactCacheEntry mUnlockedContactInfo;
+    private ContactCacheEntry mLockedContactInfo;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+
+        Mockito.when(mContactsPreferences.getDisplayOrder())
+                .thenReturn(ContactsPreferences.DISPLAY_ORDER_PRIMARY);
+
+        // Unlocked all contact info is available
+        mUnlockedContactInfo = new ContactCacheEntry();
+        mUnlockedContactInfo.namePrimary = NAME_PRIMARY;
+        mUnlockedContactInfo.nameAlternative = NAME_ALTERNATIVE;
+        mUnlockedContactInfo.location = LOCATION;
+        mUnlockedContactInfo.number = NUMBER;
+
+        // Locked only number and location are available
+        mLockedContactInfo = new ContactCacheEntry();
+        mLockedContactInfo .location = LOCATION;
+        mLockedContactInfo .number = NUMBER;
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        ContactsPreferencesFactory.setTestInstance(null);
+    }
+
+    public void testGetContentTitle_ConferenceCall() {
+        ContactsPreferencesFactory.setTestInstance(null);
+        StatusBarNotifier statusBarNotifier = new StatusBarNotifier(mContext, null);
+
+        Mockito.when(mCall.isConferenceCall()).thenReturn(true);
+        Mockito.when(mCall.hasProperty(Mockito.anyInt())).thenReturn(false);
+
+        assertEquals(mContext.getResources().getString(R.string.card_title_conf_call),
+                statusBarNotifier.getContentTitle(null, mCall));
+    }
+
+    public void testGetContentTitle_Unlocked() {
+        ContactsPreferencesFactory.setTestInstance(mContactsPreferences);
+        StatusBarNotifier statusBarNotifier = new StatusBarNotifier(mContext, null);
+        assertEquals(NAME_PRIMARY, statusBarNotifier.getContentTitle(mUnlockedContactInfo, mCall));
+    }
+
+    public void testGetContentTitle_Locked() {
+        ContactsPreferencesFactory.setTestInstance(null);
+        StatusBarNotifier statusBarNotifier = new StatusBarNotifier(mContext, null);
+        assertEquals(NUMBER, statusBarNotifier.getContentTitle(mLockedContactInfo, mCall));
+    }
+
+    public void testGetContentTitle_EmptyPreferredName() {
+        ContactCacheEntry contactCacheEntry = new ContactCacheEntry();
+        contactCacheEntry.number = NUMBER;
+        StatusBarNotifier statusBarNotifier = new StatusBarNotifier(mContext, null);
+        assertEquals(NUMBER, statusBarNotifier.getContentTitle(contactCacheEntry, mCall));
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/async/SingleProdThreadExecutor.java b/InCallUI/tests/src/com/android/incallui/async/SingleProdThreadExecutor.java
new file mode 100644
index 0000000..5717c94
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/async/SingleProdThreadExecutor.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.async;
+
+import java.util.concurrent.Executors;
+
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * {@link PausableExecutor} for use in tests. It is intended to be used between one test thread
+ * and one prod thread. See {@link com.android.incallui.ringtone.InCallTonePlayerTest} for example
+ * usage.
+ */
+@ThreadSafe
+public final class SingleProdThreadExecutor implements PausableExecutor {
+
+    private int mMilestonesReached;
+    private int mMilestonesAcked;
+    private boolean mHasAckedAllMilestones;
+
+    @Override
+    public synchronized void milestone() {
+        ++mMilestonesReached;
+        notify();
+        while (!mHasAckedAllMilestones && mMilestonesReached > mMilestonesAcked) {
+            try {
+                wait();
+            } catch (InterruptedException e) {}
+        }
+    }
+
+    @Override
+    public synchronized void ackMilestoneForTesting() {
+        ++mMilestonesAcked;
+        notify();
+    }
+
+    @Override
+    public synchronized void ackAllMilestonesForTesting() {
+        mHasAckedAllMilestones = true;
+        notify();
+    }
+
+    @Override
+    public synchronized void awaitMilestoneForTesting() throws InterruptedException {
+        while (!mHasAckedAllMilestones && mMilestonesReached <= mMilestonesAcked) {
+            wait();
+        }
+    }
+
+    @Override
+    public synchronized void execute(Runnable command) {
+        Executors.newSingleThreadExecutor().execute(command);
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/ringtone/DialerRingtoneManagerTest.java b/InCallUI/tests/src/com/android/incallui/ringtone/DialerRingtoneManagerTest.java
new file mode 100644
index 0000000..01db202
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/ringtone/DialerRingtoneManagerTest.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.incallui.ringtone;
+
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.incallui.Call;
+import com.android.incallui.Call.State;
+import com.android.incallui.CallList;
+
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+@SmallTest
+public class DialerRingtoneManagerTest extends AndroidTestCase {
+
+    private static final Uri RINGTONE_URI = RingtoneManager
+            .getDefaultUri(RingtoneManager.TYPE_RINGTONE);
+
+    @Mock private InCallTonePlayer mInCallTonePlayer;
+    @Mock private CallList mCallList;
+    @Mock private Call mCall;
+    private DialerRingtoneManager mRingtoneManagerEnabled;
+    private DialerRingtoneManager mRingtoneManagerDisabled;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+        mRingtoneManagerEnabled = new DialerRingtoneManager(mInCallTonePlayer, mCallList);
+        mRingtoneManagerEnabled.setDialerRingingEnabledForTesting(true);
+        mRingtoneManagerDisabled = new DialerRingtoneManager(mInCallTonePlayer, mCallList);
+        mRingtoneManagerDisabled.setDialerRingingEnabledForTesting(false);
+    }
+
+    public void testNullInCallTonePlayer() {
+        try {
+            new DialerRingtoneManager(null, mCallList);
+            fail();
+        } catch (NullPointerException e) {}
+    }
+
+    public void testNullCallList() {
+        try {
+            new DialerRingtoneManager(mInCallTonePlayer, null);
+            fail();
+        } catch (NullPointerException e) {}
+    }
+
+    public void testShouldPlayRingtone_M() {
+        if (CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManagerEnabled.shouldPlayRingtone(0, RINGTONE_URI));
+    }
+
+    public void testShouldPlayRingtone_N_NullUri() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManagerEnabled.shouldPlayRingtone(State.INCOMING, null));
+    }
+
+    public void testShouldPlayRingtone_N_Disabled() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManagerDisabled.shouldPlayRingtone(State.INCOMING, RINGTONE_URI));
+    }
+
+    public void testShouldPlayRingtone_N_NotIncoming() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManagerEnabled.shouldPlayRingtone(State.ACTIVE, RINGTONE_URI));
+    }
+
+    // Specific case for call waiting since that needs its own sound
+    public void testShouldPlayRingtone_N_CallWaitingByState() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManagerEnabled.shouldPlayRingtone(State.CALL_WAITING, RINGTONE_URI));
+    }
+
+    public void testShouldPlayRingtone_N_CallWaitingByActiveCall() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        Mockito.when(mCallList.getActiveCall()).thenReturn(mCall);
+        assertFalse(mRingtoneManagerEnabled.shouldPlayRingtone(State.INCOMING, RINGTONE_URI));
+    }
+
+    public void testShouldPlayRingtone_N() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertTrue(mRingtoneManagerEnabled.shouldPlayRingtone(State.INCOMING, RINGTONE_URI));
+    }
+
+    public void testShouldPlayCallWaitingTone_M() {
+        if (CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManagerEnabled.shouldPlayCallWaitingTone(0));
+    }
+
+    public void testShouldPlayCallWaitingTone_N_Disabled() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManagerDisabled.shouldPlayCallWaitingTone(State.CALL_WAITING));
+    }
+
+    public void testShouldPlayCallWaitingTone_N_NotCallWaiting() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManagerEnabled.shouldPlayCallWaitingTone(State.ACTIVE));
+    }
+
+    // Specific case for incoming since it plays its own sound
+    public void testShouldPlayCallWaitingTone_N_Incoming() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertFalse(mRingtoneManagerEnabled.shouldPlayCallWaitingTone(State.INCOMING));
+    }
+
+    public void testShouldPlayCallWaitingTone_N_AlreadyPlaying() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        Mockito.when(mInCallTonePlayer.isPlayingTone()).thenReturn(true);
+        assertFalse(mRingtoneManagerEnabled.shouldPlayCallWaitingTone(State.CALL_WAITING));
+    }
+
+    public void testShouldPlayCallWaitingTone_N_ByState() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        assertTrue(mRingtoneManagerEnabled.shouldPlayCallWaitingTone(State.CALL_WAITING));
+    }
+
+    public void testShouldPlayCallWaitingTone_N_ByActiveCall() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        Mockito.when(mCallList.getActiveCall()).thenReturn(mCall);
+        assertTrue(mRingtoneManagerEnabled.shouldPlayCallWaitingTone(State.INCOMING));
+    }
+
+    public void testPlayCallWaitingTone_M() {
+        if (CompatUtils.isNCompatible()) {
+            return;
+        }
+        mRingtoneManagerEnabled.playCallWaitingTone();
+        Mockito.verify(mInCallTonePlayer, Mockito.never()).play(Mockito.anyInt());
+    }
+
+    public void testPlayCallWaitingTone_N_NotEnabled() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        mRingtoneManagerDisabled.playCallWaitingTone();
+        Mockito.verify(mInCallTonePlayer, Mockito.never()).play(Mockito.anyInt());
+    }
+
+    public void testPlayCallWaitingTone_N() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        mRingtoneManagerEnabled.playCallWaitingTone();
+        Mockito.verify(mInCallTonePlayer).play(Mockito.anyInt());
+    }
+
+    public void testStopCallWaitingTone_M() {
+        if (CompatUtils.isNCompatible()) {
+            return;
+        }
+        mRingtoneManagerEnabled.stopCallWaitingTone();
+        Mockito.verify(mInCallTonePlayer, Mockito.never()).stop();
+    }
+
+    public void testStopCallWaitingTone_N_NotEnabled() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        mRingtoneManagerDisabled.stopCallWaitingTone();
+        Mockito.verify(mInCallTonePlayer, Mockito.never()).stop();
+    }
+
+    public void testStopCallWaitingTone_N() {
+        if (!CompatUtils.isNCompatible()) {
+            return;
+        }
+        mRingtoneManagerEnabled.stopCallWaitingTone();
+        Mockito.verify(mInCallTonePlayer).stop();
+    }
+}
diff --git a/InCallUI/tests/src/com/android/incallui/ringtone/InCallTonePlayerTest.java b/InCallUI/tests/src/com/android/incallui/ringtone/InCallTonePlayerTest.java
new file mode 100644
index 0000000..59611f7
--- /dev/null
+++ b/InCallUI/tests/src/com/android/incallui/ringtone/InCallTonePlayerTest.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.incallui.ringtone;
+
+import android.media.AudioManager;
+import android.media.ToneGenerator;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import com.android.incallui.AudioModeProvider;
+import com.android.incallui.async.PausableExecutor;
+import com.android.incallui.async.SingleProdThreadExecutor;
+
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+@SmallTest
+public class InCallTonePlayerTest extends AndroidTestCase {
+
+    @Mock private AudioModeProvider mAudioModeProvider;
+    @Mock private ToneGeneratorFactory mToneGeneratorFactory;
+    @Mock private ToneGenerator mToneGenerator;
+    private InCallTonePlayer mInCallTonePlayer;
+
+    /*
+     * InCallTonePlayer milestones:
+     * 1) After tone starts playing
+     * 2) After tone finishes waiting (could have timed out)
+     * 3) After cleaning up state to allow new tone to play
+     */
+    private PausableExecutor mExecutor;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        MockitoAnnotations.initMocks(this);
+        Mockito.when(mToneGeneratorFactory.newInCallToneGenerator(Mockito.anyInt(),
+                Mockito.anyInt())).thenReturn(mToneGenerator);
+        mExecutor = new SingleProdThreadExecutor();
+        mInCallTonePlayer = new InCallTonePlayer(mAudioModeProvider, mToneGeneratorFactory,
+                mExecutor);
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        // Stop any playing so the InCallTonePlayer isn't stuck waiting for the tone to complete
+        mInCallTonePlayer.stop();
+        // Ack all milestones to ensure that the prod thread doesn't block forever
+        mExecutor.ackAllMilestonesForTesting();
+    }
+
+    public void testIsPlayingTone_False() {
+        assertFalse(mInCallTonePlayer.isPlayingTone());
+    }
+
+    public void testIsPlayingTone_True() throws InterruptedException {
+        mInCallTonePlayer.play(InCallTonePlayer.TONE_CALL_WAITING);
+        mExecutor.awaitMilestoneForTesting();
+
+        assertTrue(mInCallTonePlayer.isPlayingTone());
+    }
+
+    public void testPlay_InvalidTone() {
+        try {
+            mInCallTonePlayer.play(Integer.MIN_VALUE);
+            fail();
+        } catch (IllegalArgumentException e) {}
+    }
+
+    public void testPlay_CurrentlyPlaying() throws InterruptedException {
+        mInCallTonePlayer.play(InCallTonePlayer.TONE_CALL_WAITING);
+        mExecutor.awaitMilestoneForTesting();
+        try {
+            mInCallTonePlayer.play(InCallTonePlayer.TONE_CALL_WAITING);
+            fail();
+        } catch (IllegalStateException e) {}
+    }
+
+    public void testPlay_BlueToothStream() {
+        // TODO (maxwelb): b/26932998 play through bluetooth
+    }
+
+    public void testPlay_VoiceCallStream() throws InterruptedException {
+        mInCallTonePlayer.play(InCallTonePlayer.TONE_CALL_WAITING);
+        mExecutor.awaitMilestoneForTesting();
+        Mockito.verify(mToneGeneratorFactory).newInCallToneGenerator(AudioManager.STREAM_VOICE_CALL,
+                InCallTonePlayer.VOLUME_RELATIVE_HIGH_PRIORITY);
+    }
+
+    public void testPlay_Single() throws InterruptedException {
+        mInCallTonePlayer.play(InCallTonePlayer.TONE_CALL_WAITING);
+        mExecutor.awaitMilestoneForTesting();
+        mExecutor.ackMilestoneForTesting();
+        mInCallTonePlayer.stop();
+        mExecutor.ackMilestoneForTesting();
+        mExecutor.awaitMilestoneForTesting();
+        mExecutor.ackMilestoneForTesting();
+
+        Mockito.verify(mToneGenerator).startTone(ToneGenerator.TONE_SUP_CALL_WAITING);
+    }
+
+    public void testPlay_Consecutive() throws InterruptedException {
+        mInCallTonePlayer.play(InCallTonePlayer.TONE_CALL_WAITING);
+        mExecutor.awaitMilestoneForTesting();
+        mExecutor.ackMilestoneForTesting();
+        // Prevent waiting forever
+        mInCallTonePlayer.stop();
+        mExecutor.ackMilestoneForTesting();
+        mExecutor.awaitMilestoneForTesting();
+        mExecutor.ackMilestoneForTesting();
+
+        mInCallTonePlayer.play(InCallTonePlayer.TONE_CALL_WAITING);
+        mExecutor.awaitMilestoneForTesting();
+        mExecutor.ackMilestoneForTesting();
+        mInCallTonePlayer.stop();
+        mExecutor.ackMilestoneForTesting();
+        mExecutor.awaitMilestoneForTesting();
+        mExecutor.ackMilestoneForTesting();
+
+        Mockito.verify(mToneGenerator, Mockito.times(2))
+                .startTone(ToneGenerator.TONE_SUP_CALL_WAITING);
+    }
+
+    public void testStop_NotPlaying() {
+        // No crash
+        mInCallTonePlayer.stop();
+    }
+
+    public void testStop() throws InterruptedException {
+        mInCallTonePlayer.play(InCallTonePlayer.TONE_CALL_WAITING);
+        mExecutor.awaitMilestoneForTesting();
+
+        mInCallTonePlayer.stop();
+        mExecutor.ackMilestoneForTesting();
+        mExecutor.awaitMilestoneForTesting();
+
+        assertFalse(mInCallTonePlayer.isPlayingTone());
+    }
+}
diff --git a/res/layout/call_log_list_item_actions.xml b/res/layout/call_log_list_item_actions.xml
index 63385ee..78203b7 100644
--- a/res/layout/call_log_list_item_actions.xml
+++ b/res/layout/call_log_list_item_actions.xml
@@ -130,7 +130,7 @@
     </LinearLayout>
 
     <ViewStub
-        android:id="@+id/spam_actions_container"
+        android:id="@+id/extended_blocking_actions_container"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"/>
 
diff --git a/res/values-af/strings.xml b/res/values-af/strings.xml
index 42def84..467be50 100644
--- a/res/values-af/strings.xml
+++ b/res/values-af/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Vee tans oproepgeskiedenis uit …"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Foon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Gemiste oproep"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Gemiste werkoproep"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Gemiste oproepe"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> gemiste oproepe"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Bel terug"</string>
diff --git a/res/values-am/strings.xml b/res/values-am/strings.xml
index f16ee25..e4b3b47 100644
--- a/res/values-am/strings.xml
+++ b/res/values-am/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"የጥሪ ታሪክን በማጽዳት ላይ…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"ስልክ"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"ያመለጠ ጥሪ"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"ያመለጠ የሥራ ጥሪ"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"ያመለጡ ጥሪዎች"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ያመለጡ ጥሪዎች"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"የኋላ ጥሪ"</string>
diff --git a/res/values-ar/strings.xml b/res/values-ar/strings.xml
index ebce9e8..c233bfe 100644
--- a/res/values-ar/strings.xml
+++ b/res/values-ar/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"جارٍ محو سجل المكالمات…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"الهاتف"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"مكالمة فائتة"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"مكالمة عمل فائتة"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"المكالمات الفائتة"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> من المكالمات الفائتة"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"معاودة الاتصال"</string>
diff --git a/res/values-az-rAZ/strings.xml b/res/values-az-rAZ/strings.xml
index 1ba23a2..4e3f247 100644
--- a/res/values-az-rAZ/strings.xml
+++ b/res/values-az-rAZ/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Zəng tarixçəsi silinir…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Buraxılmış zəng"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Buraxılmış iş çağrısı"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Buraxılmış zənglər"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> buraxılmış zənglər"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Geriyə zəng"</string>
diff --git a/res/values-b+sr+Latn/strings.xml b/res/values-b+sr+Latn/strings.xml
new file mode 100644
index 0000000..53bb7d7
--- /dev/null
+++ b/res/values-b+sr+Latn/strings.xml
@@ -0,0 +1,259 @@
+<?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");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="applicationLabel" msgid="7762561155467201526">"Telefon"</string>
+    <string name="launcherActivityLabel" msgid="1129729740601172692">"Telefon"</string>
+    <string name="launcherDialpadActivityLabel" msgid="3959809805046059167">"Numerička tastatura telefona"</string>
+    <string name="dialerIconLabel" msgid="6500826552823403796">"Telefon"</string>
+    <string name="callHistoryIconLabel" msgid="3734413397291301223">"Istorija poziva"</string>
+    <string name="action_report_number" msgid="4635403959812186162">"Prijavi netačan broj"</string>
+    <string name="action_copy_number_text" msgid="588249522108594155">"Kopiraj broj"</string>
+    <string name="copy_transcript_text" msgid="5652787482893879382">"Kopiraj transkripciju"</string>
+    <string name="action_block_number" msgid="1482657602262262134">"Blokiraj broj"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> je blokiran"</string>
+    <string name="action_unblock_number" msgid="3043777622269776127">"Deblokiraj broj"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> je deblokiran"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"OPOZOVI"</string>
+    <string name="call_details_delete" msgid="1833359621896346955">"Izbriši"</string>
+    <string name="action_edit_number_before_call" msgid="3100221149873436485">"Izmeni broj pre poziva"</string>
+    <string name="call_log_delete_all" msgid="4677609108288680411">"Obriši istoriju poziva"</string>
+    <string name="call_log_trash_voicemail" msgid="1283948488625129019">"Izbriši govornu poruku"</string>
+    <string name="snackbar_voicemail_deleted" msgid="5098542835986188582">"Gov. pošta je izbrisana"</string>
+    <string name="snackbar_voicemail_deleted_undo" msgid="3741811385891289167">"OPOZOVI"</string>
+    <string name="clearCallLogConfirmation_title" msgid="801753155679372984">"Želite da obrišete istoriju poziva?"</string>
+    <string name="clearCallLogConfirmation" msgid="7899552396101432827">"Ovo će izbrisati sve pozive iz istorije"</string>
+    <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Briše se istorija poziva…"</string>
+    <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
+    <string name="notification_missedCallTitle" msgid="2078223183024451723">"Propušten poziv"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Propušten poziv za Work"</string>
+    <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Propušteni pozivi"</string>
+    <string name="notification_missedCallsMsg" msgid="158790423221579961">"Broj propuštenih poziva: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Uzvrati poziv"</string>
+    <string name="notification_missedCall_message" msgid="3042123733754151052">"Pošalji SMS"</string>
+    <plurals name="notification_voicemail_title" formatted="false" msgid="9088953961148324851">
+      <item quantity="one"> <xliff:g id="COUNT">%1$d</xliff:g> govorna poruka </item>
+      <item quantity="few"> <xliff:g id="COUNT">%1$d</xliff:g> govorne poruke </item>
+      <item quantity="other"> <xliff:g id="COUNT">%1$d</xliff:g> govornih poruka </item>
+    </plurals>
+    <string name="notification_action_voicemail_play" msgid="6113133136977996863">"Pusti"</string>
+    <string name="notification_voicemail_callers_list" msgid="1153954809339404149">"<xliff:g id="NEWER_CALLERS">%1$s</xliff:g>, <xliff:g id="OLDER_CALLER">%2$s</xliff:g>"</string>
+    <string name="notification_new_voicemail_ticker" msgid="895342132049452081">"Nova govorna poruka od <xliff:g id="CALLER">%1$s</xliff:g>"</string>
+    <string name="voicemail_playback_error" msgid="3356071912353297599">"Puštanje govorne pošte nije uspelo"</string>
+    <string name="voicemail_fetching_content" msgid="1287895365599580842">"Govorna pošta se učitava…"</string>
+    <string name="voicemail_fetching_timout" msgid="3959428065511972176">"Učitavanje govorne pošte nije uspelo"</string>
+    <string name="call_log_voicemail_header" msgid="3945407886667089173">"Samo pozivi sa govornom poštom"</string>
+    <string name="call_log_incoming_header" msgid="2787722299753674684">"Samo dolazni pozivi"</string>
+    <string name="call_log_outgoing_header" msgid="761009180766735769">"Samo odlazni pozivi"</string>
+    <string name="call_log_missed_header" msgid="8017148056610855956">"Samo propušteni pozivi"</string>
+    <string name="visual_voicemail_title" msgid="4574199312906348905">"Vizuelna govorna pošta"</string>
+    <string name="visual_voicemail_text" msgid="164967285234132509">"Pregledajte i slušajte govornu poštu bez pozivanja broja. Možda će biti naplaćeni troškovi za prenos podataka."</string>
+    <string name="visual_voicemail_settings" msgid="8090338793118794741">"Podešavanja"</string>
+    <string name="voicemail_status_voicemail_not_available" msgid="5222480147701456390">"Ažuriranja govorne pošte nisu dostupna"</string>
+    <string name="voicemail_status_messages_waiting" msgid="6329544650250068650">"Imate novu govornu poštu. Trenutno ne može da se učita."</string>
+    <string name="voicemail_status_configure_voicemail" msgid="8300808991932816153">"Podesite govornu poštu"</string>
+    <string name="voicemail_status_audio_not_available" msgid="2449801102560158082">"Audio nije dostupan"</string>
+    <string name="voicemail_status_action_configure" msgid="8671796489912239589">"Podesi"</string>
+    <string name="voicemail_status_action_call_server" msgid="1824816252288551794">"Zovi govornu poštu"</string>
+    <string name="call_log_item_count_and_date" msgid="7641933305703520787">"(<xliff:g id="COUNT">%1$d</xliff:g>) <xliff:g id="DATE">%2$s</xliff:g>"</string>
+    <string name="sms_disambig_title" msgid="5846266399240630846">"Izbor broja"</string>
+    <string name="call_disambig_title" msgid="4392886850104795739">"Izbor broja"</string>
+    <string name="make_primary" msgid="5829291915305113983">"Zapamti ovaj izbor"</string>
+    <string name="description_search_button" msgid="3660807558587384889">"pretraži"</string>
+    <string name="description_dial_button" msgid="1274091017188142646">"biranje"</string>
+    <string name="description_digits_edittext" msgid="8760207516497016437">"broj za biranje"</string>
+    <string name="description_playback_start_stop" msgid="5060732345522492292">"Pokretanje ili zaustavljanje reprodukcije"</string>
+    <string name="description_playback_speakerphone" msgid="6008323900245707504">"Uključivanje ili isključivanje spikerfona"</string>
+    <string name="description_playback_seek" msgid="4509404274968530055">"Traženje pozicije u reprodukciji"</string>
+    <string name="description_rate_decrease" msgid="3161652589401708284">"Smanjivanje brzine reprodukcije"</string>
+    <string name="description_rate_increase" msgid="6324606574127052385">"Povećavanje brzine reprodukcije"</string>
+    <string name="action_menu_call_history_description" msgid="9018442816219748968">"Istorija poziva"</string>
+    <string name="action_menu_overflow_description" msgid="2303272250613084574">"Još opcija"</string>
+    <string name="action_menu_dialpad_button" msgid="1425910318049008136">"numerička tastatura"</string>
+    <string name="menu_show_outgoing_only" msgid="1965570298133301970">"Prikaži samo odlazne"</string>
+    <string name="menu_show_incoming_only" msgid="7534206815238877417">"Prikaži samo dolazne"</string>
+    <string name="menu_show_missed_only" msgid="154473166059743996">"Prikaži samo propuštene"</string>
+    <string name="menu_show_voicemails_only" msgid="1898421289561435703">"Prikaži samo govorne poruke"</string>
+    <string name="menu_show_all_calls" msgid="7560347482073345885">"Prikaži sve pozive"</string>
+    <string name="add_2sec_pause" msgid="9214012315201040129">"Dodaj pauzu od 2 sekunde"</string>
+    <string name="add_wait" msgid="3360818652790319634">"Dodaj čekanje"</string>
+    <string name="dialer_settings_label" msgid="4305043242594150479">"Podešavanja"</string>
+    <string name="menu_newContact" msgid="1209922412763274638">"Novi kontakt"</string>
+    <string name="menu_allContacts" msgid="6948308384034051670">"Svi kontakti"</string>
+    <string name="callDetailTitle" msgid="5340227785196217938">"Detalji poziva"</string>
+    <string name="toast_call_detail_error" msgid="6947041258280380832">"Detalji nisu dostupni"</string>
+    <string name="dialer_useDtmfDialpad" msgid="1707548397435075040">"Upotrebite brojčanik za tonsko biranje"</string>
+    <string name="dialer_returnToInCallScreen" msgid="3719386377550913067">"Vrati se na poziv koji je u toku"</string>
+    <string name="dialer_addAnotherCall" msgid="4205688819890074468">"Dodaj poziv"</string>
+    <string name="type_incoming" msgid="6502076603836088532">"Dolazni poziv"</string>
+    <string name="type_outgoing" msgid="343108709599392641">"Odlazni poziv"</string>
+    <string name="type_missed" msgid="2720502601640509542">"Propušten poziv"</string>
+    <string name="type_incoming_video" msgid="82323391702796181">"Dolazni video poziv"</string>
+    <string name="type_outgoing_video" msgid="2858140021680755266">"Odlazni video poziv"</string>
+    <string name="type_missed_video" msgid="954396897034220545">"Propušten video poziv"</string>
+    <string name="type_voicemail" msgid="5153139450668549908">"Govorna pošta"</string>
+    <string name="type_rejected" msgid="7783201828312472691">"Odbijen poziv"</string>
+    <string name="type_blocked" msgid="3521686227115330015">"Blokiran poziv"</string>
+    <string name="actionIncomingCall" msgid="6028930669817038600">"Dolazni pozivi"</string>
+    <string name="description_call_log_play_button" msgid="651182125650429846">"Puštanje govorne pošte"</string>
+    <string name="description_view_contact" msgid="5205669345700598415">"Prikaži kontakt <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="description_call" msgid="3443678121983852666">"Pozovi korisnika <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Detalji o kontaktu za <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="description_num_calls" msgid="1601505153694540074">"<xliff:g id="NUMBEROFCALLS">%1$s</xliff:g> poziva."</string>
+    <string name="description_video_call" msgid="2933838090743214204">"Video poziv."</string>
+    <string name="description_send_text_message" msgid="3118485319691414221">"Slanje SMS-a za <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Nepreslušana govorna pošta"</string>
+    <string name="description_start_voice_search" msgid="520539488194946012">"Pokretanje glasovne pretrage"</string>
+    <string name="menu_callNumber" msgid="997146291983360266">"Pozovi <xliff:g id="NUMBER">%s</xliff:g>"</string>
+    <string name="unknown" msgid="740067747858270469">"Nepoznato"</string>
+    <string name="voicemail" msgid="3851469869202611441">"Govorna pošta"</string>
+    <string name="private_num" msgid="6374339738119166953">"Privatan broj"</string>
+    <string name="payphone" msgid="7726415831153618726">"Telefonska govornica"</string>
+    <string name="callDetailsShortDurationFormat" msgid="3988146235579303592">"<xliff:g id="SECONDS">%s</xliff:g> sek"</string>
+    <string name="callDetailsDurationFormat" msgid="6061406028764382234">"<xliff:g id="MINUTES">%s</xliff:g> min <xliff:g id="SECONDS">%s</xliff:g> sek"</string>
+    <!-- no translation found for voicemailCallLogToday (682363079840402849) -->
+    <skip />
+    <string name="voicemailCallLogDateTimeFormat" msgid="4388070029056487713">"<xliff:g id="DATE">%1$s</xliff:g> u <xliff:g id="TIME">%2$s</xliff:g>"</string>
+    <string name="voicemailDurationFormat" msgid="228211252076289564">"<xliff:g id="MINUTES">%1$02d</xliff:g>:<xliff:g id="SECONDS">%2$02d</xliff:g>"</string>
+    <string name="voicemailCallLogDateTimeFormatWithDuration" msgid="5118563814451588397">"<xliff:g id="DATEANDTIME">%1$s</xliff:g> • <xliff:g id="DURATION">%2$s</xliff:g>"</string>
+    <string name="dialog_phone_call_prohibited_message" msgid="5730565540182492608">"Nije moguće pozvati ovaj broj"</string>
+    <string name="dialog_voicemail_not_ready_message" msgid="4384716252789515378">"Da biste podesili govornu poštu, idite u Meni &gt; Podešavanja."</string>
+    <string name="dialog_voicemail_airplane_mode_message" msgid="530922773669546093">"Da biste pozvali govornu poštu, prvo isključite režim aviona."</string>
+    <string name="contact_list_loading" msgid="5488620820563977329">"Učitava se…"</string>
+    <string name="imei" msgid="3045126336951684285">"IMEI"</string>
+    <string name="meid" msgid="6210568493746275750">"MEID"</string>
+    <string name="simContacts_emptyLoading" msgid="6700035985448642408">"Učitava se sa SIM kartice…"</string>
+    <string name="simContacts_title" msgid="27341688347689769">"Kontakti na SIM kartici"</string>
+    <string name="add_contact_not_available" msgid="5547311613368004859">"Nema dostupne aplikacije za kontakte"</string>
+    <string name="voice_search_not_available" msgid="2977719040254285301">"Glasovna pretraga nije dostupna"</string>
+    <string name="call_not_available" msgid="8941576511946492225">"Nije moguće uputiti telefonski poziv jer je aplikacija Telefon onemogućena."</string>
+    <string name="activity_not_available" msgid="2287665636817987623">"Na ovom uređaju nema aplikacija za to"</string>
+    <string name="dialer_hint_find_contact" msgid="3574350254520035364">"Pretražite kontakte"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Dodajte broj ili pretražite kontakte"</string>
+    <string name="call_log_all_empty" msgid="8357417710416340920">"Istorija poziva je prazna"</string>
+    <string name="call_log_all_empty_action" msgid="9093210119068366147">"Pozovi"</string>
+    <string name="call_log_missed_empty" msgid="3927274175205520135">"Nemate nijedan propušten poziv."</string>
+    <string name="call_log_voicemail_empty" msgid="8383585074222277550">"Prijemno sanduče govorne pošte je prazno."</string>
+    <string name="show_favorites_only" msgid="5520072531022614595">"Prikaži samo omiljene"</string>
+    <string name="call_log_activity_title" msgid="7949633151371183580">"Istorija poziva"</string>
+    <string name="call_log_all_title" msgid="3566738938889333307">"Svi"</string>
+    <string name="call_log_missed_title" msgid="4541142293870638971">"Propušteni"</string>
+    <string name="call_log_voicemail_title" msgid="940422274047025948">"Govorna pošta"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Želite li da blokirate <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_confirmation_message_vvm" msgid="5655646611437082611">"Pozivi sa ovog broja će biti blokirani i poruke govorne pošte će se automatski brisati."</string>
+    <string name="block_number_confirmation_message_no_vvm" msgid="4511900601491718173">"Pozivi sa ovog broja će biti blokirani, ali pozivalac i dalje može da vam ostavlja poruke govorne pošte."</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKIRAJ"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Želite li da deblokirate <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_confirmation_message" msgid="8521058345002166692">"Deblokiraćemo ovaj broj i moći će da vam upućuje pozive."</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DEBLOKIRAJ"</string>
+    <string name="tab_speed_dial" msgid="7552166276545648893">"Brzo biranje"</string>
+    <string name="tab_history" msgid="2563144697322434940">"Istorija poziva"</string>
+    <string name="tab_all_contacts" msgid="1410922767166533690">"Kontakti"</string>
+    <string name="tab_voicemail" msgid="155024725947496746">"Govorna pošta"</string>
+    <string name="favorite_hidden" msgid="5011234945140912047">"Uklonjeno je iz omiljenih"</string>
+    <string name="favorite_hidden_undo" msgid="2508998611039406474">"Opozovi"</string>
+    <string name="search_shortcut_call_number" msgid="7277194656832895870">"Pozovi <xliff:g id="NUMBER">%s</xliff:g>"</string>
+    <string name="search_shortcut_create_new_contact" msgid="1679917465521554093">"Napravi novi kontakt"</string>
+    <string name="search_shortcut_add_to_contact" msgid="4327842393369915751">"Dodaj u kontakt"</string>
+    <string name="search_shortcut_send_sms_message" msgid="2569304043345025525">"Pošalji SMS"</string>
+    <string name="search_shortcut_make_video_call" msgid="1265971685034465166">"Uputi video poziv"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blokiraj broj"</string>
+    <string name="num_missed_calls" msgid="8081736535604293886">"Novih propuštenih poziva: <xliff:g id="NUMBER">%s</xliff:g>"</string>
+    <string name="speed_dial_empty" msgid="8838921693673366129">"Nemate nijedan kontakt na brzom biranju"</string>
+    <string name="speed_dial_empty_add_favorite_action" msgid="7944893641496695770">"Dodaj omiljen kontakt"</string>
+    <string name="all_contacts_empty" msgid="471370638298229686">"Još uvek nemate nijedan kontakt"</string>
+    <string name="all_contacts_empty_add_contact_action" msgid="1515782853819374618">"Dodaj kontakt"</string>
+    <string name="contact_tooltip" msgid="2019777545923635266">"Dodirnite sliku da biste videli sve brojeve ili dodirnite i zadržite da biste promenili raspored"</string>
+    <string name="remove_contact" msgid="1080555335283662961">"Ukloni"</string>
+    <string name="call_log_action_video_call" msgid="7724301709041128296">"Video poziv"</string>
+    <string name="call_log_action_send_message" msgid="5679719296905285131">"Pošalji poruku"</string>
+    <string name="call_log_action_details" msgid="701345508704970622">"Detalji poziva"</string>
+    <string name="call_log_action_call" msgid="463690849042459842">"Pozovi <xliff:g id="NAMEORNUMBER">^1</xliff:g>"</string>
+    <string name="description_incoming_missed_call" msgid="2381085098795943627">"Propušteni poziv: <xliff:g id="NAMEORNUMBER">^1</xliff:g>, <xliff:g id="TYPEORLOCATION">^2</xliff:g>, <xliff:g id="TIMEOFCALL">^3</xliff:g>, <xliff:g id="PHONEACCOUNT">^4</xliff:g>."</string>
+    <string name="description_incoming_answered_call" msgid="7117665748428816544">"Primljeni poziv: <xliff:g id="NAMEORNUMBER">^1</xliff:g>, <xliff:g id="TYPEORLOCATION">^2</xliff:g>, <xliff:g id="TIMEOFCALL">^3</xliff:g>, <xliff:g id="PHONEACCOUNT">^4</xliff:g>."</string>
+    <string name="description_unread_voicemail" msgid="5826351827625665597">"Nepročitana govorna poruka od <xliff:g id="NAMEORNUMBER">^1</xliff:g>, <xliff:g id="TYPEORLOCATION">^2</xliff:g>, <xliff:g id="TIMEOFCALL">^3</xliff:g>, <xliff:g id="PHONEACCOUNT">^4</xliff:g>."</string>
+    <string name="description_read_voicemail" msgid="133974208364152610">"Govorna poruka od <xliff:g id="NAMEORNUMBER">^1</xliff:g>, <xliff:g id="TYPEORLOCATION">^2</xliff:g>, <xliff:g id="TIMEOFCALL">^3</xliff:g>, <xliff:g id="PHONEACCOUNT">^4</xliff:g>."</string>
+    <string name="description_outgoing_call" msgid="6386364390619734734">"Pozvali ste: <xliff:g id="NAMEORNUMBER">^1</xliff:g>, <xliff:g id="TYPEORLOCATION">^2</xliff:g>, <xliff:g id="TIMEOFCALL">^3</xliff:g>, <xliff:g id="PHONEACCOUNT">^4</xliff:g>."</string>
+    <string name="description_phone_account" msgid="1767072759541443861">"na nalogu <xliff:g id="PHONEACCOUNT">^1</xliff:g>"</string>
+    <string name="description_call_log_call_action" msgid="3682561657090693134">"Pozovi"</string>
+    <string name="description_call_action" msgid="4000549004089776147">"Pozovi <xliff:g id="NAMEORNUMBER">^1</xliff:g>"</string>
+    <string name="description_video_call_action" msgid="7386922428155062213">"Uputite video poziv kontaktu <xliff:g id="NAMEORNUMBER">^1</xliff:g>."</string>
+    <string name="description_voicemail_action" msgid="8054891873788903063">"Pusti govornu poštu od <xliff:g id="NAMEORNUMBER">^1</xliff:g>"</string>
+    <string name="description_voicemail_play" msgid="2689369874037785439">"Reprodukuj govornu poštu kontakta <xliff:g id="NAMEORNUMBER">^1</xliff:g>"</string>
+    <string name="description_voicemail_pause" msgid="3905259748756919693">"Pauziraj govornu poštu kontakta <xliff:g id="NAMEORNUMBER">^1</xliff:g>"</string>
+    <string name="description_voicemail_delete" msgid="2025472770630153436">"Izbriši govornu poštu kontakta <xliff:g id="NAMEORNUMBER">^1</xliff:g>"</string>
+    <plurals name="description_voicemail_unread" formatted="false" msgid="8708346053055570332">
+      <item quantity="one"><xliff:g id="COUNT_1">%d</xliff:g> nova poruka govorne pošte</item>
+      <item quantity="few"><xliff:g id="COUNT_1">%d</xliff:g> nove poruke govorne pošte</item>
+      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> novih poruka govorne pošte</item>
+    </plurals>
+    <string name="description_create_new_contact_action" msgid="818755978791008167">"Napravite kontakt za <xliff:g id="NAMEORNUMBER">^1</xliff:g>"</string>
+    <string name="description_add_to_existing_contact_action" msgid="6081200053494414351">"Dodajte <xliff:g id="NAMEORNUMBER">^1</xliff:g> postojećem kontaktu"</string>
+    <string name="description_details_action" msgid="2433827152749491785">"Detalji poziva za <xliff:g id="NAMEORNUMBER">^1</xliff:g>"</string>
+    <string name="toast_entry_removed" msgid="8010830299576311534">"Izbrisano iz istorije poziva"</string>
+    <string name="call_log_header_today" msgid="3225248682434212981">"Danas"</string>
+    <string name="call_log_header_yesterday" msgid="9139172458834033092">"Juče"</string>
+    <string name="call_log_header_other" msgid="5769921959940709084">"Stariji"</string>
+    <string name="call_detail_list_header" msgid="3752717059699600861">"Lista poziva"</string>
+    <string name="voicemail_speaker_on" msgid="209154030283487068">"Uključite zvučnik."</string>
+    <string name="voicemail_speaker_off" msgid="7390530056413093958">"Isključite zvučnik."</string>
+    <string name="voicemail_play_faster" msgid="3444751008615323006">"Brža reprodukcija."</string>
+    <string name="voicemail_play_slower" msgid="4544796503902818832">"Sporija reprodukcija."</string>
+    <string name="voicemail_play_start_pause" msgid="3687447935787768983">"Započnite ili pauzirajte reprodukciju."</string>
+    <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">"Zvuci i vibracija"</string>
+    <string name="accessibility_settings_title" msgid="6068141142874046249">"Pristupačnost"</string>
+    <string name="ringtone_title" msgid="760362035635084653">"Zvuk zvona telefona"</string>
+    <string name="vibrate_on_ring_title" msgid="3362916460327555241">"Vibriraj i za pozive"</string>
+    <string name="dtmf_tone_enable_title" msgid="6571449695997521615">"Zvuci numeričke tastature"</string>
+    <string name="dtmf_tone_length_title" msgid="8581125689808919460">"Trajanje tonova numeričke tastature"</string>
+  <string-array name="dtmf_tone_length_entries">
+    <item msgid="1036113889050195575">"Normalno"</item>
+    <item msgid="6177579030803486015">"Dugačko"</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="manage_blocked_numbers_label" msgid="5959801428936629196">"Blokiranje poziva"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blokiranje poziva je privremeno isključeno"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Blokiranje poziva je onemogućeno zato što ste kontaktirali službe za pomoć u hitnim slučajevima sa ovog telefona u poslednjih 48 sati. Automatski će biti ponovo omogućeno kada istekne period od 48 sati."</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Uvezi brojeve"</string>
+    <string name="blocked_call_settings_import_description" msgid="8640906226815125906">"Ranije ste označili neke pozivaoce koje automatski treba preusmeriti na govornu poštu preko drugih aplikacija."</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Prikaži brojeve"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Uvezi"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Uvoz nije uspeo"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Deblokiraj broj"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Dodaj broj"</string>
+    <string name="block_number_footer_message_vvm" msgid="5387302253765439712">"Pozivi sa ovih brojeva će biti blokirani i poruke govorne pošte će se automatski brisati."</string>
+    <string name="block_number_footer_message_no_vvm" msgid="223238617533822381">"Pozivi sa ovih brojeva će biti blokirani, ali pozivaoci sa ovih brojeva će i dalje moći da vam ostavljaju poruke govorne pošte."</string>
+    <string name="block_list" msgid="7760188925338078011">"Blokirani brojevi"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> je nevažeći."</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> je već blokiran."</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Blokiranje poziva je onemogućeno na 48 sati"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Onemogućeno je zato što je upućen hitan poziv."</string>
+    <string name="phone_account_settings_label" msgid="5864322009841175294">"Nalozi za pozivanje"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Uključi"</string>
+    <string name="permission_multiple_turn_on" msgid="2426278457455950554">"Podesi dozvole"</string>
+    <string name="permission_no_speeddial" msgid="6882563445996184051">"Da biste omogućili brzo biranje, uključite dozvolu za Kontakte."</string>
+    <string name="permission_no_calllog" msgid="555711464287041043">"Da biste videli evidenciju poziva, uključite dozvolu za Telefon."</string>
+    <string name="permission_no_contacts" msgid="6237980143178936279">"Da biste videli kontakte, uključite dozvolu za Kontakte."</string>
+    <string name="permission_no_voicemail" msgid="8306280257799917574">"Da biste pristupili govornoj pošti, uključite dozvolu za Telefon."</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Da biste pretražili kontakte, uključite dozvole za Kontakte."</string>
+    <string name="permission_place_call" msgid="2101287782615887547">"Da biste uputili poziv, uključite dozvolu za Telefon."</string>
+    <string name="toast_cannot_write_system_settings" msgid="5614246168296606709">"Aplikacija Telefon nema dozvolu za upisivanje u sistemska podešavanja."</string>
+</resources>
diff --git a/res/values-bg/strings.xml b/res/values-bg/strings.xml
index 3d0efc0..4ff98ff 100644
--- a/res/values-bg/strings.xml
+++ b/res/values-bg/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Историята на обажд. се изчиства…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Телефон"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Пропуснато обаждане"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Пропуснато служебно обаждане"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Пропуснати обаждания"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> пропуснати обаждания"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Обратно обаждане"</string>
diff --git a/res/values-bn-rBD/strings.xml b/res/values-bn-rBD/strings.xml
index 37ad783..672e09b 100644
--- a/res/values-bn-rBD/strings.xml
+++ b/res/values-bn-rBD/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"কল ইতিহাস সাফ করা হচ্ছে…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"ফোন"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"মিস করা কল"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"কাজের কল মিস করেছেন"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"মিস করা কলগুলি"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>টি মিস করা কল"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"ঘুরিয়ে কল করুন"</string>
diff --git a/res/values-bs-rBA/strings.xml b/res/values-bs-rBA/strings.xml
new file mode 100644
index 0000000..61637f2
--- /dev/null
+++ b/res/values-bs-rBA/strings.xml
@@ -0,0 +1,468 @@
+<?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");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+   -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- no translation found for applicationLabel (7762561155467201526) -->
+    <skip />
+    <!-- no translation found for launcherActivityLabel (1129729740601172692) -->
+    <skip />
+    <!-- no translation found for launcherDialpadActivityLabel (3959809805046059167) -->
+    <skip />
+    <!-- no translation found for dialerIconLabel (6500826552823403796) -->
+    <skip />
+    <!-- no translation found for callHistoryIconLabel (3734413397291301223) -->
+    <skip />
+    <!-- no translation found for action_report_number (4635403959812186162) -->
+    <skip />
+    <!-- no translation found for action_copy_number_text (588249522108594155) -->
+    <skip />
+    <!-- no translation found for copy_transcript_text (5652787482893879382) -->
+    <skip />
+    <!-- no translation found for action_block_number (1482657602262262134) -->
+    <skip />
+    <!-- no translation found for snackbar_number_blocked (939830142765936021) -->
+    <skip />
+    <!-- no translation found for action_unblock_number (3043777622269776127) -->
+    <skip />
+    <!-- no translation found for snackbar_number_unblocked (4854738171099045912) -->
+    <skip />
+    <!-- no translation found for block_number_undo (591338370336724156) -->
+    <skip />
+    <!-- no translation found for call_details_delete (1833359621896346955) -->
+    <skip />
+    <!-- no translation found for action_edit_number_before_call (3100221149873436485) -->
+    <skip />
+    <!-- no translation found for call_log_delete_all (4677609108288680411) -->
+    <skip />
+    <!-- no translation found for call_log_trash_voicemail (1283948488625129019) -->
+    <skip />
+    <!-- no translation found for snackbar_voicemail_deleted (5098542835986188582) -->
+    <skip />
+    <!-- no translation found for snackbar_voicemail_deleted_undo (3741811385891289167) -->
+    <skip />
+    <!-- no translation found for clearCallLogConfirmation_title (801753155679372984) -->
+    <skip />
+    <!-- no translation found for clearCallLogConfirmation (7899552396101432827) -->
+    <skip />
+    <!-- no translation found for clearCallLogProgress_title (3372471156216306132) -->
+    <skip />
+    <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
+    <string name="notification_missedCallTitle" msgid="2078223183024451723">"Propušteni poziv"</string>
+    <!-- no translation found for notification_missedWorkCallTitle (8418335304394771688) -->
+    <skip />
+    <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Propušteni pozivi"</string>
+    <string name="notification_missedCallsMsg" msgid="158790423221579961">"Propuštenih poziva: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
+    <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Pozovi ovaj broj"</string>
+    <string name="notification_missedCall_message" msgid="3042123733754151052">"Poruka"</string>
+    <!-- no translation found for notification_voicemail_title (9088953961148324851) -->
+    <!-- no translation found for notification_action_voicemail_play (6113133136977996863) -->
+    <skip />
+    <!-- no translation found for notification_voicemail_callers_list (1153954809339404149) -->
+    <skip />
+    <!-- no translation found for notification_new_voicemail_ticker (895342132049452081) -->
+    <skip />
+    <!-- no translation found for voicemail_playback_error (3356071912353297599) -->
+    <skip />
+    <!-- no translation found for voicemail_fetching_content (1287895365599580842) -->
+    <skip />
+    <!-- no translation found for voicemail_fetching_timout (3959428065511972176) -->
+    <skip />
+    <!-- no translation found for call_log_voicemail_header (3945407886667089173) -->
+    <skip />
+    <!-- no translation found for call_log_incoming_header (2787722299753674684) -->
+    <skip />
+    <!-- no translation found for call_log_outgoing_header (761009180766735769) -->
+    <skip />
+    <!-- no translation found for call_log_missed_header (8017148056610855956) -->
+    <skip />
+    <!-- no translation found for visual_voicemail_title (4574199312906348905) -->
+    <skip />
+    <!-- no translation found for visual_voicemail_text (164967285234132509) -->
+    <skip />
+    <!-- no translation found for visual_voicemail_settings (8090338793118794741) -->
+    <skip />
+    <!-- no translation found for voicemail_status_voicemail_not_available (5222480147701456390) -->
+    <skip />
+    <!-- no translation found for voicemail_status_messages_waiting (6329544650250068650) -->
+    <skip />
+    <!-- no translation found for voicemail_status_configure_voicemail (8300808991932816153) -->
+    <skip />
+    <!-- no translation found for voicemail_status_audio_not_available (2449801102560158082) -->
+    <skip />
+    <!-- no translation found for voicemail_status_action_configure (8671796489912239589) -->
+    <skip />
+    <!-- no translation found for voicemail_status_action_call_server (1824816252288551794) -->
+    <skip />
+    <!-- no translation found for call_log_item_count_and_date (7641933305703520787) -->
+    <skip />
+    <!-- no translation found for sms_disambig_title (5846266399240630846) -->
+    <skip />
+    <!-- no translation found for call_disambig_title (4392886850104795739) -->
+    <skip />
+    <!-- no translation found for make_primary (5829291915305113983) -->
+    <skip />
+    <!-- no translation found for description_search_button (3660807558587384889) -->
+    <skip />
+    <!-- no translation found for description_dial_button (1274091017188142646) -->
+    <skip />
+    <!-- no translation found for description_digits_edittext (8760207516497016437) -->
+    <skip />
+    <!-- no translation found for description_playback_start_stop (5060732345522492292) -->
+    <skip />
+    <!-- no translation found for description_playback_speakerphone (6008323900245707504) -->
+    <skip />
+    <!-- no translation found for description_playback_seek (4509404274968530055) -->
+    <skip />
+    <!-- no translation found for description_rate_decrease (3161652589401708284) -->
+    <skip />
+    <!-- no translation found for description_rate_increase (6324606574127052385) -->
+    <skip />
+    <!-- no translation found for action_menu_call_history_description (9018442816219748968) -->
+    <skip />
+    <!-- no translation found for action_menu_overflow_description (2303272250613084574) -->
+    <!-- no translation found for action_menu_overflow_description (2295659037509008453) -->
+    <skip />
+    <!-- no translation found for action_menu_dialpad_button (1425910318049008136) -->
+    <skip />
+    <!-- no translation found for menu_show_outgoing_only (1965570298133301970) -->
+    <skip />
+    <!-- no translation found for menu_show_incoming_only (7534206815238877417) -->
+    <skip />
+    <!-- no translation found for menu_show_missed_only (154473166059743996) -->
+    <skip />
+    <!-- no translation found for menu_show_voicemails_only (1898421289561435703) -->
+    <skip />
+    <!-- no translation found for menu_show_all_calls (7560347482073345885) -->
+    <skip />
+    <!-- no translation found for add_2sec_pause (9214012315201040129) -->
+    <skip />
+    <!-- no translation found for add_wait (3360818652790319634) -->
+    <skip />
+    <!-- no translation found for dialer_settings_label (4305043242594150479) -->
+    <skip />
+    <!-- no translation found for menu_newContact (1209922412763274638) -->
+    <skip />
+    <!-- no translation found for menu_allContacts (6948308384034051670) -->
+    <skip />
+    <!-- no translation found for callDetailTitle (5340227785196217938) -->
+    <skip />
+    <!-- no translation found for toast_call_detail_error (6947041258280380832) -->
+    <skip />
+    <!-- no translation found for dialer_useDtmfDialpad (1707548397435075040) -->
+    <skip />
+    <!-- no translation found for dialer_returnToInCallScreen (3719386377550913067) -->
+    <skip />
+    <!-- no translation found for dialer_addAnotherCall (4205688819890074468) -->
+    <skip />
+    <!-- no translation found for type_incoming (6502076603836088532) -->
+    <skip />
+    <!-- no translation found for type_outgoing (343108709599392641) -->
+    <skip />
+    <!-- no translation found for type_missed (2720502601640509542) -->
+    <skip />
+    <!-- no translation found for type_incoming_video (82323391702796181) -->
+    <skip />
+    <!-- no translation found for type_outgoing_video (2858140021680755266) -->
+    <skip />
+    <!-- no translation found for type_missed_video (954396897034220545) -->
+    <skip />
+    <!-- no translation found for type_voicemail (5153139450668549908) -->
+    <skip />
+    <!-- no translation found for type_rejected (7783201828312472691) -->
+    <skip />
+    <!-- no translation found for type_blocked (3521686227115330015) -->
+    <skip />
+    <!-- no translation found for actionIncomingCall (6028930669817038600) -->
+    <skip />
+    <!-- no translation found for description_call_log_play_button (651182125650429846) -->
+    <skip />
+    <!-- no translation found for description_view_contact (5205669345700598415) -->
+    <skip />
+    <!-- no translation found for description_call (3443678121983852666) -->
+    <skip />
+    <!-- no translation found for description_contact_details (51229793651342809) -->
+    <skip />
+    <!-- no translation found for description_num_calls (1601505153694540074) -->
+    <skip />
+    <!-- no translation found for description_video_call (2933838090743214204) -->
+    <skip />
+    <!-- no translation found for description_send_text_message (3118485319691414221) -->
+    <skip />
+    <!-- no translation found for description_call_log_unheard_voicemail (118101684236996786) -->
+    <skip />
+    <!-- no translation found for description_start_voice_search (520539488194946012) -->
+    <skip />
+    <!-- no translation found for menu_callNumber (997146291983360266) -->
+    <skip />
+    <!-- no translation found for unknown (740067747858270469) -->
+    <skip />
+    <!-- no translation found for voicemail (3851469869202611441) -->
+    <skip />
+    <!-- no translation found for private_num (6374339738119166953) -->
+    <skip />
+    <!-- no translation found for payphone (7726415831153618726) -->
+    <skip />
+    <!-- no translation found for callDetailsShortDurationFormat (3988146235579303592) -->
+    <skip />
+    <!-- no translation found for callDetailsDurationFormat (6061406028764382234) -->
+    <skip />
+    <!-- no translation found for voicemailCallLogToday (682363079840402849) -->
+    <skip />
+    <!-- no translation found for voicemailCallLogDateTimeFormat (4388070029056487713) -->
+    <skip />
+    <!-- no translation found for voicemailDurationFormat (228211252076289564) -->
+    <skip />
+    <!-- no translation found for voicemailCallLogDateTimeFormatWithDuration (5118563814451588397) -->
+    <skip />
+    <!-- no translation found for dialog_phone_call_prohibited_message (5730565540182492608) -->
+    <!-- no translation found for dialog_phone_call_prohibited_message (4313552620858880999) -->
+    <skip />
+    <!-- no translation found for dialog_voicemail_not_ready_message (4384716252789515378) -->
+    <skip />
+    <!-- no translation found for dialog_voicemail_airplane_mode_message (530922773669546093) -->
+    <skip />
+    <!-- no translation found for contact_list_loading (5488620820563977329) -->
+    <skip />
+    <!-- no translation found for imei (3045126336951684285) -->
+    <skip />
+    <!-- no translation found for meid (6210568493746275750) -->
+    <skip />
+    <!-- no translation found for simContacts_emptyLoading (6700035985448642408) -->
+    <skip />
+    <!-- no translation found for simContacts_title (27341688347689769) -->
+    <skip />
+    <!-- no translation found for add_contact_not_available (5547311613368004859) -->
+    <skip />
+    <!-- no translation found for voice_search_not_available (2977719040254285301) -->
+    <skip />
+    <!-- no translation found for call_not_available (8941576511946492225) -->
+    <skip />
+    <!-- no translation found for activity_not_available (2287665636817987623) -->
+    <skip />
+    <!-- no translation found for dialer_hint_find_contact (3574350254520035364) -->
+    <skip />
+    <!-- no translation found for block_number_search_hint (5409571607043872758) -->
+    <skip />
+    <!-- no translation found for call_log_all_empty (8357417710416340920) -->
+    <skip />
+    <!-- no translation found for call_log_all_empty_action (9093210119068366147) -->
+    <skip />
+    <!-- no translation found for call_log_missed_empty (3927274175205520135) -->
+    <skip />
+    <!-- no translation found for call_log_voicemail_empty (8383585074222277550) -->
+    <skip />
+    <!-- no translation found for show_favorites_only (5520072531022614595) -->
+    <skip />
+    <!-- no translation found for call_log_activity_title (7949633151371183580) -->
+    <skip />
+    <!-- no translation found for call_log_all_title (3566738938889333307) -->
+    <skip />
+    <!-- no translation found for call_log_missed_title (4541142293870638971) -->
+    <skip />
+    <!-- no translation found for call_log_voicemail_title (940422274047025948) -->
+    <skip />
+    <!-- no translation found for block_number_confirmation_title (6862219558186931304) -->
+    <skip />
+    <!-- no translation found for block_number_confirmation_message_vvm (5655646611437082611) -->
+    <skip />
+    <!-- no translation found for block_number_confirmation_message_no_vvm (4511900601491718173) -->
+    <skip />
+    <!-- no translation found for block_number_ok (770551992296781873) -->
+    <skip />
+    <!-- no translation found for unblock_number_confirmation_title (252824779504084354) -->
+    <skip />
+    <!-- no translation found for unblock_number_confirmation_message (8521058345002166692) -->
+    <skip />
+    <!-- no translation found for unblock_number_ok (6449899182699684786) -->
+    <skip />
+    <!-- no translation found for tab_speed_dial (7552166276545648893) -->
+    <skip />
+    <!-- no translation found for tab_history (2563144697322434940) -->
+    <skip />
+    <!-- no translation found for tab_all_contacts (1410922767166533690) -->
+    <skip />
+    <!-- no translation found for tab_voicemail (155024725947496746) -->
+    <skip />
+    <!-- no translation found for favorite_hidden (5011234945140912047) -->
+    <skip />
+    <!-- no translation found for favorite_hidden_undo (2508998611039406474) -->
+    <skip />
+    <!-- no translation found for search_shortcut_call_number (7277194656832895870) -->
+    <skip />
+    <!-- no translation found for search_shortcut_create_new_contact (1679917465521554093) -->
+    <skip />
+    <!-- no translation found for search_shortcut_add_to_contact (4327842393369915751) -->
+    <skip />
+    <!-- no translation found for search_shortcut_send_sms_message (2569304043345025525) -->
+    <skip />
+    <!-- no translation found for search_shortcut_make_video_call (1265971685034465166) -->
+    <skip />
+    <!-- no translation found for search_shortcut_block_number (4787156645163436072) -->
+    <skip />
+    <!-- no translation found for num_missed_calls (8081736535604293886) -->
+    <skip />
+    <!-- no translation found for speed_dial_empty (8838921693673366129) -->
+    <skip />
+    <!-- no translation found for speed_dial_empty_add_favorite_action (7944893641496695770) -->
+    <skip />
+    <!-- no translation found for all_contacts_empty (471370638298229686) -->
+    <skip />
+    <!-- no translation found for all_contacts_empty_add_contact_action (1515782853819374618) -->
+    <skip />
+    <!-- no translation found for contact_tooltip (2019777545923635266) -->
+    <skip />
+    <!-- no translation found for remove_contact (1080555335283662961) -->
+    <skip />
+    <!-- no translation found for call_log_action_video_call (7724301709041128296) -->
+    <skip />
+    <!-- no translation found for call_log_action_send_message (5679719296905285131) -->
+    <skip />
+    <!-- no translation found for call_log_action_details (701345508704970622) -->
+    <skip />
+    <!-- no translation found for call_log_action_call (463690849042459842) -->
+    <skip />
+    <!-- no translation found for description_incoming_missed_call (2381085098795943627) -->
+    <skip />
+    <!-- no translation found for description_incoming_answered_call (7117665748428816544) -->
+    <skip />
+    <!-- no translation found for description_unread_voicemail (5826351827625665597) -->
+    <skip />
+    <!-- no translation found for description_read_voicemail (133974208364152610) -->
+    <skip />
+    <!-- no translation found for description_outgoing_call (6386364390619734734) -->
+    <skip />
+    <!-- no translation found for description_phone_account (1767072759541443861) -->
+    <skip />
+    <!-- no translation found for description_call_log_call_action (3682561657090693134) -->
+    <skip />
+    <!-- no translation found for description_call_action (4000549004089776147) -->
+    <skip />
+    <!-- no translation found for description_video_call_action (7386922428155062213) -->
+    <skip />
+    <!-- no translation found for description_voicemail_action (8054891873788903063) -->
+    <skip />
+    <!-- no translation found for description_voicemail_play (2689369874037785439) -->
+    <skip />
+    <!-- no translation found for description_voicemail_pause (3905259748756919693) -->
+    <skip />
+    <!-- no translation found for description_voicemail_delete (2025472770630153436) -->
+    <skip />
+    <!-- no translation found for description_voicemail_unread (8708346053055570332) -->
+    <!-- no translation found for description_create_new_contact_action (818755978791008167) -->
+    <skip />
+    <!-- no translation found for description_add_to_existing_contact_action (6081200053494414351) -->
+    <skip />
+    <!-- no translation found for description_details_action (2433827152749491785) -->
+    <skip />
+    <!-- no translation found for toast_entry_removed (8010830299576311534) -->
+    <skip />
+    <!-- no translation found for call_log_header_today (3225248682434212981) -->
+    <skip />
+    <!-- no translation found for call_log_header_yesterday (9139172458834033092) -->
+    <skip />
+    <!-- no translation found for call_log_header_other (5769921959940709084) -->
+    <skip />
+    <!-- no translation found for call_detail_list_header (3752717059699600861) -->
+    <skip />
+    <!-- no translation found for voicemail_speaker_on (209154030283487068) -->
+    <skip />
+    <!-- no translation found for voicemail_speaker_off (7390530056413093958) -->
+    <skip />
+    <!-- no translation found for voicemail_play_faster (3444751008615323006) -->
+    <skip />
+    <!-- no translation found for voicemail_play_slower (4544796503902818832) -->
+    <skip />
+    <!-- no translation found for voicemail_play_start_pause (3687447935787768983) -->
+    <skip />
+    <!-- no translation found for list_delimeter (4571593167738725100) -->
+    <skip />
+    <!-- no translation found for display_options_title (7812852361055667468) -->
+    <skip />
+    <!-- no translation found for sounds_and_vibration_title (1692290115642160845) -->
+    <skip />
+    <!-- no translation found for accessibility_settings_title (6068141142874046249) -->
+    <skip />
+    <!-- no translation found for ringtone_title (760362035635084653) -->
+    <skip />
+    <!-- no translation found for vibrate_on_ring_title (3362916460327555241) -->
+    <skip />
+    <!-- no translation found for dtmf_tone_enable_title (6571449695997521615) -->
+    <skip />
+    <!-- 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) -->
+    <!-- no translation found for respond_via_sms_setting_title (1318281521087951580) -->
+    <skip />
+    <!-- no translation found for call_settings_label (313434211353070209) -->
+    <skip />
+    <!-- no translation found for manage_blocked_numbers_label (5959801428936629196) -->
+    <skip />
+    <!-- no translation found for blocked_numbers_disabled_emergency_header_label (7870947220238070418) -->
+    <skip />
+    <!-- no translation found for blocked_numbers_disabled_emergency_desc (7755803249073401381) -->
+    <skip />
+    <!-- no translation found for import_send_to_voicemail_numbers_label (1606601823746799926) -->
+    <skip />
+    <!-- no translation found for blocked_call_settings_import_description (8640906226815125906) -->
+    <skip />
+    <!-- no translation found for blocked_call_settings_view_numbers_button (6698986720875955935) -->
+    <skip />
+    <!-- no translation found for blocked_call_settings_import_button (178821255125295473) -->
+    <skip />
+    <!-- no translation found for send_to_voicemail_import_failed (5547202002133560069) -->
+    <skip />
+    <!-- no translation found for description_blocked_number_list_delete (3240093199107796792) -->
+    <skip />
+    <!-- no translation found for addBlockedNumber (6064812257482886526) -->
+    <skip />
+    <!-- no translation found for block_number_footer_message_vvm (5387302253765439712) -->
+    <skip />
+    <!-- no translation found for block_number_footer_message_no_vvm (223238617533822381) -->
+    <skip />
+    <!-- no translation found for block_list (7760188925338078011) -->
+    <skip />
+    <!-- no translation found for invalidNumber (619058581062192851) -->
+    <skip />
+    <!-- no translation found for alreadyBlocked (282340105563646876) -->
+    <skip />
+    <!-- no translation found for call_blocking_disabled_notification_title (8185193413377920194) -->
+    <skip />
+    <!-- no translation found for call_blocking_disabled_notification_text (5330772013626378526) -->
+    <skip />
+    <!-- no translation found for phone_account_settings_label (5864322009841175294) -->
+    <skip />
+    <!-- no translation found for permission_single_turn_on (1543391076065465464) -->
+    <skip />
+    <!-- no translation found for permission_multiple_turn_on (2426278457455950554) -->
+    <skip />
+    <!-- no translation found for permission_no_speeddial (6882563445996184051) -->
+    <skip />
+    <!-- no translation found for permission_no_calllog (555711464287041043) -->
+    <skip />
+    <!-- no translation found for permission_no_contacts (6237980143178936279) -->
+    <skip />
+    <!-- no translation found for permission_no_voicemail (8306280257799917574) -->
+    <skip />
+    <!-- no translation found for permission_no_search (84152933267902056) -->
+    <skip />
+    <!-- no translation found for permission_place_call (2101287782615887547) -->
+    <skip />
+    <!-- no translation found for toast_cannot_write_system_settings (5614246168296606709) -->
+    <skip />
+</resources>
diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index b2839ae..d303e39 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Esborrant historial de trucades..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telèfon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Trucada perduda"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Trucada perduda de feina"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Trucades perdudes"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> trucades perdudes"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Torna la trucada"</string>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index 8f524a3..c857ef2 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Mazání historie volání…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Zmeškaný hovor"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Zmeškaný pracovní hovor"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Zmeškané hovory"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"Zmeškané hovory: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Zavolat zpět"</string>
diff --git a/res/values-da/strings.xml b/res/values-da/strings.xml
index 0762924..3cb5e51 100644
--- a/res/values-da/strings.xml
+++ b/res/values-da/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Opkaldshistorik ryddes..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Ubesvaret opkald"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Ubesvaret arbejdsopkald"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Ubesvarede opkald"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ubesvarede opkald"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Ring tilbage"</string>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index f1683f6..855aacb 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Anrufliste wird gelöscht…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Verpasster Anruf"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Verpasster geschäftlicher Anruf"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Verpasste Anrufe"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> verpasste Anrufe"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Zurückrufen"</string>
diff --git a/res/values-el/strings.xml b/res/values-el/strings.xml
index 9f7a6b2..47101e5 100644
--- a/res/values-el/strings.xml
+++ b/res/values-el/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Διαγραφή ιστορικού κλήσεων…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Τηλέφωνο"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Αναπάντητη κλήση"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Αναπάντητη κλήση εργασίας"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Αναπάντητες κλήσεις"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> αναπάντητες κλήσεις"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Επανάκληση"</string>
diff --git a/res/values-en-rAU/strings.xml b/res/values-en-rAU/strings.xml
index 4a398b1..5ea7eb7 100644
--- a/res/values-en-rAU/strings.xml
+++ b/res/values-en-rAU/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Clearing call history…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telephone"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Missed call"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Missed work call"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Missed calls"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> missed calls"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Call back"</string>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index 4a398b1..5ea7eb7 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Clearing call history…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telephone"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Missed call"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Missed work call"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Missed calls"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> missed calls"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Call back"</string>
diff --git a/res/values-en-rIN/strings.xml b/res/values-en-rIN/strings.xml
index 4a398b1..5ea7eb7 100644
--- a/res/values-en-rIN/strings.xml
+++ b/res/values-en-rIN/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Clearing call history…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telephone"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Missed call"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Missed work call"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Missed calls"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> missed calls"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Call back"</string>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index 7078e45..55d9289 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Eliminando historial de llamadas…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Teléfono"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Llamada perdida"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Llamada de trabajo perdida"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Llamadas perdidas"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> llamadas perdidas"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Llamar"</string>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index 730b963..aed5109 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Borrando historial de llamadas…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Teléfono"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Llamada perdida"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Llamada de trabajo perdida"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Llamadas perdidas"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> llamadas perdidas"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Llamar"</string>
diff --git a/res/values-et-rEE/strings.xml b/res/values-et-rEE/strings.xml
index 516316d..f799df4 100644
--- a/res/values-et-rEE/strings.xml
+++ b/res/values-et-rEE/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Kõneajaloo kustutamine ..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Vastamata kõne"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Vastamata kõne töölt"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Vastamata kõned"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> vastamata kõnet"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Helista tagasi"</string>
diff --git a/res/values-eu-rES/strings.xml b/res/values-eu-rES/strings.xml
index dc3674e..0702f4e 100644
--- a/res/values-eu-rES/strings.xml
+++ b/res/values-eu-rES/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Deien historia garbitzen…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefonoa"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Dei galdua"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Laneko dei bat galdu duzu"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Dei galduak"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> dei galdu"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Itzuli deia"</string>
diff --git a/res/values-fa/strings.xml b/res/values-fa/strings.xml
index 597f0d8..bdb8b2e 100644
--- a/res/values-fa/strings.xml
+++ b/res/values-fa/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"در حال پاک کردن سابقه تماس..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"تلفن"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"تماس بی‌پاسخ"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"تماس کاری بی‌پاسخ"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"تماس‌های بی‌پاسخ"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> تماس بی‌پاسخ"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"پاسخ تماس"</string>
diff --git a/res/values-fi/strings.xml b/res/values-fi/strings.xml
index e132146..fb025ec 100644
--- a/res/values-fi/strings.xml
+++ b/res/values-fi/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Tyhjennetään soittohistoriaa…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Puhelin"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Vastaamaton puhelu"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Vastaamaton työpuhelu"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Vastaamattomat puhelut"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> vastaamatonta puhelua"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Soita takaisin"</string>
diff --git a/res/values-fr-rCA/strings.xml b/res/values-fr-rCA/strings.xml
index b9a6232..03f9075 100644
--- a/res/values-fr-rCA/strings.xml
+++ b/res/values-fr-rCA/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Suppression historique des appels…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Téléphone"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Appel manqué"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Appel professionnel manqué"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Appels manqués"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> appels manqués"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Rappeler"</string>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index 04f94b2..6d60f42 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Suppression historique des appels…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Téléphoner"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Appel manqué"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Appel professionnel manqué"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Appels manqués"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> appels manqués"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Rappeler"</string>
diff --git a/res/values-gl-rES/strings.xml b/res/values-gl-rES/strings.xml
index 23ca8a5..8dc5c44 100644
--- a/res/values-gl-rES/strings.xml
+++ b/res/values-gl-rES/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Borrando historial de chamadas…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Teléfono"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Chamada perdida"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Chamada de traballo perdida"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Chamadas perdidas"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> chamadas perdidas"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Devolver chamada"</string>
diff --git a/res/values-gu-rIN/strings.xml b/res/values-gu-rIN/strings.xml
index 055ad72..9d2bcc9 100644
--- a/res/values-gu-rIN/strings.xml
+++ b/res/values-gu-rIN/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"કૉલ ઇતિહાસ સાફ કરી રહ્યાં છે…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"ફોન"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"છૂટેલો કૉલ"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"ચૂકી ગયેલ કાર્ય કૉલ"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"છૂટેલા કૉલ્સ"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> છૂટેલા કૉલ"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"કૉલ બૅક કરો"</string>
diff --git a/res/values-hi/strings.xml b/res/values-hi/strings.xml
index 241480d..1450a35 100644
--- a/res/values-hi/strings.xml
+++ b/res/values-hi/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"कॉल इतिहास साफ़ किया जा रहा है…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"फ़ोन"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"छूटा कॉल"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"कार्यस्थल का छूटा हुआ कॉल"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"छूटे कॉल"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> छूटे कॉल"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"वापस कॉल करें"</string>
diff --git a/res/values-hr/strings.xml b/res/values-hr/strings.xml
index 7dc1ec2..567a5f4 100644
--- a/res/values-hr/strings.xml
+++ b/res/values-hr/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Brisanje povijesti poziva…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Propušteni poziv"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Propušten poslovni poziv"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Propušteni pozivi"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"Propušteni pozivi (<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>)"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Uzvrati poziv"</string>
diff --git a/res/values-hu/strings.xml b/res/values-hu/strings.xml
index cb741a3e..7a3728c 100644
--- a/res/values-hu/strings.xml
+++ b/res/values-hu/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Híváslista törlése…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefonhívás"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Elmulasztott hívás"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Nem fogadott munkahelyi hívás"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Elmulasztott hívások"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> elmulasztott hívás"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Visszahívás"</string>
diff --git a/res/values-hy-rAM/strings.xml b/res/values-hy-rAM/strings.xml
index 254dd73..2dcb65c 100644
--- a/res/values-hy-rAM/strings.xml
+++ b/res/values-hy-rAM/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Զանգերի պատմության մաքրում…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Հեռախոս"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Բաց թողնված զանգ"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Բաց թողնված աշխատանքային զանգ"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Բաց թողնված զանգեր"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> բաց թողնված զանգ"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Հետ զանգել"</string>
diff --git a/res/values-in/strings.xml b/res/values-in/strings.xml
index 91a4661..28fbfad 100644
--- a/res/values-in/strings.xml
+++ b/res/values-in/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Menghapus riwayat panggilan..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telepon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Panggilan tak terjawab"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Panggilan tak terjawab di telepon kerja"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Panggilan tak terjawab"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> panggilan tak terjawab"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Telepon balik"</string>
diff --git a/res/values-is-rIS/strings.xml b/res/values-is-rIS/strings.xml
index 113b260..be67d59 100644
--- a/res/values-is-rIS/strings.xml
+++ b/res/values-is-rIS/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Hreinsar símtalaferil…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Sími"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Ósvarað símtal"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Ósvarað vinnusímtal"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Ósvöruð símtöl"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ósvöruð símtöl"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Hringja til baka"</string>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index db53b53..bd46f64 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Cancellazione cronologia chiamate…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefono"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Chiamata senza risposta"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Chiamata di lavoro persa"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Chiamate senza risposta"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> chiamate senza risposta"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Richiama"</string>
diff --git a/res/values-iw/strings.xml b/res/values-iw/strings.xml
index 240f9a0..659e8f8 100644
--- a/res/values-iw/strings.xml
+++ b/res/values-iw/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"מנקה היסטוריית שיחות…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"טלפון"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"שיחה שלא נענתה"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"שיחה עסקית שלא נענתה"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"שיחות שלא נענו"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> שיחות שלא נענו"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"התקשר חזרה"</string>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index 753eb38..b5b2e01 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"通話履歴の消去中…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"電話"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"不在着信"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"仕事の通話の不在着信"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"不在着信"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"不在着信 <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> 件"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"折り返す"</string>
diff --git a/res/values-ka-rGE/strings.xml b/res/values-ka-rGE/strings.xml
index 7e51483..5e6275f 100644
--- a/res/values-ka-rGE/strings.xml
+++ b/res/values-ka-rGE/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"მიმდ. ზარ. ისტ. გასუფთავება…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"დარეკვა"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"გამოტოვებული ზარი"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"გამოტოვებული ზარი (სამსახური)"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"გამოტოვებული ზარები"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> გამოტოვებული ზარი"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"გადარეკვა"</string>
diff --git a/res/values-kk-rKZ/strings.xml b/res/values-kk-rKZ/strings.xml
index 95fd9c7..9d7b7f6 100644
--- a/res/values-kk-rKZ/strings.xml
+++ b/res/values-kk-rKZ/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Қоңыраулар тарихы тазалануда…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Телефон"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Өткізіп алған қоңырау"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Өткізіп алынған жұмыс қоңырауы"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Қабылданбаған қоңыраулар"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> өткізіп алған қоңырау"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Кері қоңырау шалу"</string>
diff --git a/res/values-km-rKH/strings.xml b/res/values-km-rKH/strings.xml
index d0a3447..f01d652 100644
--- a/res/values-km-rKH/strings.xml
+++ b/res/values-km-rKH/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"កំពុងជម្រះប្រវត្តិហៅ…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"ទូរស័ព្ទ"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"ខកខាន​ទទួល"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"បានខកខានការហៅចូលពីកន្លែងការងារ"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"ខកខាន​ទទួល"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"ខកខានទទួល <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ដង"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"ហៅ​ទៅ​វិញ"</string>
diff --git a/res/values-kn-rIN/strings.xml b/res/values-kn-rIN/strings.xml
index 699c09f..88571cc 100644
--- a/res/values-kn-rIN/strings.xml
+++ b/res/values-kn-rIN/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"ಕರೆ ಇತಿಹಾಸವನ್ನು ತೆರವುಗೊಳಿಸಲಾಗುತ್ತಿದೆ…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"ಫೋನ್"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"ತಪ್ಪಿದ ಕರೆ"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"ತಪ್ಪಿದ ಕೆಲಸದ ಕರೆ"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"ತಪ್ಪಿದ ಕರೆಗಳು"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ತಪ್ಪಿದ ಕರೆಗಳು"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"ಮರಳಿ ಕರೆ"</string>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index 8aef9df..6802141 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"통화 기록을 삭제하는 중…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"전화"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"부재중 전화"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"부재중 업무 통화"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"부재중 전화"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"부재중 전화 <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>통"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"전화 걸기"</string>
diff --git a/res/values-ky-rKG/strings.xml b/res/values-ky-rKG/strings.xml
index dcf756f..f6b890e 100644
--- a/res/values-ky-rKG/strings.xml
+++ b/res/values-ky-rKG/strings.xml
@@ -42,6 +42,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Чалуулар таржымалы тазаланууда…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Телефон"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Кабыл алынбаган чалуу"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Кабыл алынбай калган чалуу (жумуш)"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Кабыл алынбаган чалуулар"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> кабыл алынбаган чалуу"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Кайра чалуу"</string>
diff --git a/res/values-lo-rLA/strings.xml b/res/values-lo-rLA/strings.xml
index 4f8654e..8647882 100644
--- a/res/values-lo-rLA/strings.xml
+++ b/res/values-lo-rLA/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"ກຳ​ລັງ​ລຶບ​ປະ​ຫວັດ​ການ​ໂທ…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"ໂທລະສັບ"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"ສາຍທີ່ບໍ່ໄດ້ຮັບ"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"ສາຍບໍ່ໄດ້ຮັບຈາກບ່ອນເຮັດວຽກ"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"ສາຍທີ່ບໍ່ໄດ້ຮັບ"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ສາຍບໍ່ໄດ້ຮັບ"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"ໂທກັບ"</string>
diff --git a/res/values-lt/strings.xml b/res/values-lt/strings.xml
index a800c14..1fba916 100644
--- a/res/values-lt/strings.xml
+++ b/res/values-lt/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Išvaloma skambučių istorija..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefonas"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Praleisti skambučiai"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Praleistas darbo skambutis"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Praleisti skambučiai"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"Praleistų skambučių: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Perskambinti"</string>
diff --git a/res/values-lv/strings.xml b/res/values-lv/strings.xml
index d5a1700..1d56d6f 100644
--- a/res/values-lv/strings.xml
+++ b/res/values-lv/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Notiek zvanu vēstures dzēšana…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Tālruņa zvans"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Neatbildēts zvans"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Neatbildēts darba zvans"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Neatbildēti zvani"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> neatbildēti zvani"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Atzvanīt"</string>
diff --git a/res/values-mk-rMK/strings.xml b/res/values-mk-rMK/strings.xml
index 097cca2..8e561d2 100644
--- a/res/values-mk-rMK/strings.xml
+++ b/res/values-mk-rMK/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Се чисти историјата на повици…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Телефон"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Пропуштен повик"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Пропуштен работен повик"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Пропуштени повици"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> пропуштени повици"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Повикај назад"</string>
diff --git a/res/values-ml-rIN/strings.xml b/res/values-ml-rIN/strings.xml
index 252efb0..54fe6f8 100644
--- a/res/values-ml-rIN/strings.xml
+++ b/res/values-ml-rIN/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"കോൾ ചരിത്രം മായ്‌ക്കുന്നു..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"ഫോൺ"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"മിസ്‌ഡ് കോൾ"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"മിസ്ഡ് ഔദ്യോഗിക കോൾ"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"മിസ്‌ഡ് കോളുകൾ"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> മിസ്‌ഡ് കോളുകൾ"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"തിരിച്ചുവിളിക്കുക"</string>
diff --git a/res/values-mn-rMN/strings.xml b/res/values-mn-rMN/strings.xml
index 6aa6639..7ab4760 100644
--- a/res/values-mn-rMN/strings.xml
+++ b/res/values-mn-rMN/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Дуудлагын түүхийг устгаж байна..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Утас"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Аваагүй дуудлага"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Аваагүй албаны дуудлага"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Аваагүй дуудлага"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> аваагүй дуудлага"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Буцааж залгах"</string>
diff --git a/res/values-mr-rIN/strings.xml b/res/values-mr-rIN/strings.xml
index 2c5d472..fea8334 100644
--- a/res/values-mr-rIN/strings.xml
+++ b/res/values-mr-rIN/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"कॉल इतिहास साफ करत आहे…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"फोन"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"सुटलेला कॉल"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"कार्याचा कॉल चुकविला"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"सुटलेले कॉल"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> सुटलेले कॉल"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"पुन्हा कॉल करा"</string>
diff --git a/res/values-ms-rMY/strings.xml b/res/values-ms-rMY/strings.xml
index 4844e18..7c9224f 100644
--- a/res/values-ms-rMY/strings.xml
+++ b/res/values-ms-rMY/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Mengosongkan sejarah panggilan..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Panggilan terlepas"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Panggilan terlepas daripada tempat kerja"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Panggilan terlepas"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> panggilan terlepas"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Panggil balik"</string>
diff --git a/res/values-my-rMM/strings.xml b/res/values-my-rMM/strings.xml
index ef9fd3b..b135b61 100644
--- a/res/values-my-rMM/strings.xml
+++ b/res/values-my-rMM/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"ခေါ်ဆိုမှု မှတ်တမ်းကို ရှင်းနေ…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"ဖုန်း"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"လွတ်သွားသော ခေါ်ဆိုမှု"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"လွတ်သွားသော အလုပ်ဖုန်းခေါ်ဆိုမှု"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"လွတ်သွားသော ခေါ်ဆိုမှုများ"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"လွတ်သွားသော ခေါ်ဆိုမှု <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"ပြန်ခေါ်ပါ"</string>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index 93d932c..2482b38 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Sletter anropsloggen …"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Ring"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Tapt anrop"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Tapt jobbanrop"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Tapte anrop"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> tapte anrop"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Ring tilbake"</string>
diff --git a/res/values-ne-rNP/strings.xml b/res/values-ne-rNP/strings.xml
index 410c658..69fa590 100644
--- a/res/values-ne-rNP/strings.xml
+++ b/res/values-ne-rNP/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"कल इतिहास हाटउँदै..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"फोन"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"छुटेको कल"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"कामबाट आएको छुटेको कल"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"छुटेका कलहरू"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> छुटेका कलहरू"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"कल फर्काउने"</string>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index 7250ff9..868b178 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Oproepgeschiedenis wissen…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefoon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Gemiste oproep"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Gemiste zakelijke oproep"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Gemiste oproepen"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> gemiste oproepen"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Terugbellen"</string>
diff --git a/res/values-pa-rIN/strings.xml b/res/values-pa-rIN/strings.xml
index 0c19bfd..1abd488 100644
--- a/res/values-pa-rIN/strings.xml
+++ b/res/values-pa-rIN/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"ਕਾਲ ਇਤਿਹਾਸ ਹਟਾ ਰਿਹਾ ਹੈ…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"ਫੋਨ"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"ਮਿਸ ਹੋਈ ਕਾਲ"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"ਕੰਮ ਨਾਲ ਸਬੰਧਿਤ ਖੁੰਝੀ ਕਾਲ"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"ਮਿਸ ਹੋਈਆਂ ਕਾਲਾਂ"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ਮਿਸ ਹੋਈਆਂ ਕਾਲਾਂ"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"ਕਾਲ ਬੈਕ ਕਰੋ"</string>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index 52c6b39..86fd858 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Czyszczę historię połączeń…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Nieodebrane połączenie"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Nieodebrane połączenie (praca)"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Nieodebrane połączenia"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"Liczba nieodebranych połączeń: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Oddzwoń"</string>
diff --git a/res/values-pt-rBR/strings.xml b/res/values-pt-rBR/strings.xml
index a40c283..8680ea7 100644
--- a/res/values-pt-rBR/strings.xml
+++ b/res/values-pt-rBR/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Limpando histórico de chamadas…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Smartphone"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Chamada perdida"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Chamada de trabalho perdida"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Chamadas perdidas"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> chamadas perdidas"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Retornar chamada"</string>
diff --git a/res/values-pt-rPT/strings.xml b/res/values-pt-rPT/strings.xml
index c8fb02d..c777a0d 100644
--- a/res/values-pt-rPT/strings.xml
+++ b/res/values-pt-rPT/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"A limpar histórico de chamadas…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telemóvel"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Chamada não atendida"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Chamada de trabalho não atendida"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Chamadas não atendidas"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> chamadas não atendidas"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Ligar de volta"</string>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index a40c283..8680ea7 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Limpando histórico de chamadas…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Smartphone"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Chamada perdida"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Chamada de trabalho perdida"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Chamadas perdidas"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> chamadas perdidas"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Retornar chamada"</string>
diff --git a/res/values-ro/strings.xml b/res/values-ro/strings.xml
index 32e39c9..4d67ded 100644
--- a/res/values-ro/strings.xml
+++ b/res/values-ro/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Se șterge istoricul apelurilor…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Apel nepreluat"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Apel de serviciu nepreluat"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Apeluri nepreluate"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> (de) apeluri nepreluate"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Apelați înapoi"</string>
@@ -74,7 +75,7 @@
     <string name="call_disambig_title" msgid="4392886850104795739">"Selectaţi numărul"</string>
     <string name="make_primary" msgid="5829291915305113983">"Rețineți această alegere"</string>
     <string name="description_search_button" msgid="3660807558587384889">"căutare"</string>
-    <string name="description_dial_button" msgid="1274091017188142646">"apelați"</string>
+    <string name="description_dial_button" msgid="1274091017188142646">"apelaţi"</string>
     <string name="description_digits_edittext" msgid="8760207516497016437">"numărul de apelat"</string>
     <string name="description_playback_start_stop" msgid="5060732345522492292">"Porniți sau opriți redarea"</string>
     <string name="description_playback_speakerphone" msgid="6008323900245707504">"Activați sau dezactivați difuzorul"</string>
@@ -111,14 +112,14 @@
     <string name="actionIncomingCall" msgid="6028930669817038600">"Apeluri de intrare"</string>
     <string name="description_call_log_play_button" msgid="651182125650429846">"Redați mesajul vocal"</string>
     <string name="description_view_contact" msgid="5205669345700598415">"Afişaţi persoana din agendă <xliff:g id="NAME">%1$s</xliff:g>"</string>
-    <string name="description_call" msgid="3443678121983852666">"Apelați pe <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="description_call" msgid="3443678121983852666">"Apelaţi pe <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_contact_details" msgid="51229793651342809">"Detalii de contact pentru <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
     <string name="description_num_calls" msgid="1601505153694540074">"<xliff:g id="NUMBEROFCALLS">%1$s</xliff:g> (de) apeluri."</string>
     <string name="description_video_call" msgid="2933838090743214204">"Apel video."</string>
     <string name="description_send_text_message" msgid="3118485319691414221">"Trimiteți SMS la <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Mesaje vocale neascultate"</string>
     <string name="description_start_voice_search" msgid="520539488194946012">"Începeți căutarea vocală"</string>
-    <string name="menu_callNumber" msgid="997146291983360266">"Apelați <xliff:g id="NUMBER">%s</xliff:g>"</string>
+    <string name="menu_callNumber" msgid="997146291983360266">"Apelaţi <xliff:g id="NUMBER">%s</xliff:g>"</string>
     <string name="unknown" msgid="740067747858270469">"Necunoscut"</string>
     <string name="voicemail" msgid="3851469869202611441">"Mesagerie vocală"</string>
     <string name="private_num" msgid="6374339738119166953">"Număr privat"</string>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index 701b6dc..c279b64 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Очистка журнала звонков…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Вызов"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Пропущенный вызов"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Пропущенный звонок (работа)"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Пропущенные вызовы"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"Пропущенных вызовов: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Перезвонить"</string>
diff --git a/res/values-si-rLK/strings.xml b/res/values-si-rLK/strings.xml
index 92dd284..0106cd1 100644
--- a/res/values-si-rLK/strings.xml
+++ b/res/values-si-rLK/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"ඇමතුම් ඉතිහාසය හිස් කරමින්…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"දුරකථනය"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"මඟ හැරුණු ඇමතුම"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"මග හැරුණ කාර්යාල ඇමතුම"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"මඟ හැරුණු ඇමතුම්"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"මඟ හැරුණු ඇමතුම් <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"ආපසු අමතන්න"</string>
diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index e5993df..abf5899 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Vymazáva sa história hovorov..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefón"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Zmeškaný hovor"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Zmeškaný pracovný hovor"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Zmeškané hovory"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"Zmeškané hovory: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Zavolať späť"</string>
diff --git a/res/values-sl/strings.xml b/res/values-sl/strings.xml
index b47c9d0..e823871 100644
--- a/res/values-sl/strings.xml
+++ b/res/values-sl/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Izbris zgodovine klicev …"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefoniranje"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Neodgovorjeni klic"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Neodgovorjen delovni klic"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Neodgovorjeni klici"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"Št. neodgovorjenih klicev: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Povratni klic"</string>
diff --git a/res/values-sq-rAL/strings.xml b/res/values-sq-rAL/strings.xml
index 7ac28bd..2efd621 100644
--- a/res/values-sq-rAL/strings.xml
+++ b/res/values-sq-rAL/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Po pastron historikun e telefonatave…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefoni"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Telefonatë e humbur"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Telefonatë pune e humbur"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Telefonata të humbura"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> telefonata të humbura"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Ri-telefono"</string>
diff --git a/res/values-sr/strings.xml b/res/values-sr/strings.xml
index fb8dd31..e86aa7a 100644
--- a/res/values-sr/strings.xml
+++ b/res/values-sr/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Брише се историја позива…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Телефон"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Пропуштен позив"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Пропуштен позив за Work"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Пропуштени позиви"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"Број пропуштених позива: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Узврати позив"</string>
diff --git a/res/values-sv/strings.xml b/res/values-sv/strings.xml
index e8e582c..a23561d 100644
--- a/res/values-sv/strings.xml
+++ b/res/values-sv/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Rensar samtalshistoriken ..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Ringa"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Missat samtal"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Missat jobbsamtal"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Missade samtal"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> missade samtal"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Ring upp"</string>
diff --git a/res/values-sw/strings.xml b/res/values-sw/strings.xml
index 3550a64..c2153d6 100644
--- a/res/values-sw/strings.xml
+++ b/res/values-sw/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Inafuta rekodi ya simu zilizopigwa..."</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Simu"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Simu ambayo haikujibiwa"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Simu ya kazini ambayo hukujibu"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Simu zisizojibiwa"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"Simu <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ambazo hazikujibiwa"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Mpigie"</string>
diff --git a/res/values-ta-rIN/strings.xml b/res/values-ta-rIN/strings.xml
index fcf004c..fa1be70 100644
--- a/res/values-ta-rIN/strings.xml
+++ b/res/values-ta-rIN/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"அழைப்பு வரலாற்றை அழிக்கிறது…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"ஃபோன்"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"தவறிய அழைப்பு"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"தவறிய அழைப்பு (பணி)"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"தவறிய அழைப்புகள்"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> தவறிய அழைப்புகள்"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"திரும்ப அழை"</string>
diff --git a/res/values-te-rIN/strings.xml b/res/values-te-rIN/strings.xml
index 163ac82..efe563c 100644
--- a/res/values-te-rIN/strings.xml
+++ b/res/values-te-rIN/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"కాల్ చరిత్రను క్లియర్ చేస్తోంది…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"ఫోన్"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"మిస్డ్ కాల్"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"సమాధానమివ్వని కార్యాలయ కాల్"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"మిస్డ్ కాల్‌లు"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> మిస్డ్ కాల్‌లు"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"తిరిగి కాల్ చేయి"</string>
diff --git a/res/values-th/strings.xml b/res/values-th/strings.xml
index 1ac79aa..6c63faf 100644
--- a/res/values-th/strings.xml
+++ b/res/values-th/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"กำลังล้างประวัติการโทร…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"โทรศัพท์"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"สายที่ไม่ได้รับ"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"มีสายจากที่ทำงานที่ไม่ได้รับ"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"สายที่ไม่ได้รับ"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"ไม่ได้รับ <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> สาย"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"โทรกลับ"</string>
diff --git a/res/values-tl/strings.xml b/res/values-tl/strings.xml
index e7a8d8d..29ac565 100644
--- a/res/values-tl/strings.xml
+++ b/res/values-tl/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Kini-clear ang history ng tawag…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telepono"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Hindi nasagot na tawag"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Hindi nasagot na tawag sa trabaho"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Mga hindi nasagot na tawag"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> (na) hindi nasagot na tawag"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Tawagan"</string>
diff --git a/res/values-tr/strings.xml b/res/values-tr/strings.xml
index 2558b16..00eed3d 100644
--- a/res/values-tr/strings.xml
+++ b/res/values-tr/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Çağrı geçmişi temizleniyor…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Cevapsız çağrı"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"İşle ilgili cevapsız çağrı"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Cevapsız çağrılar"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> cevapsız çağrı"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Geri ara"</string>
diff --git a/res/values-uk/strings.xml b/res/values-uk/strings.xml
index 3c715cb..dc42f1f 100644
--- a/res/values-uk/strings.xml
+++ b/res/values-uk/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Очищення історії дзвінків…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Номер телефону"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Пропущений виклик"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Пропущений дзвінок на робочий телефон"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Пропущені виклики"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"Пропущено викликів: <xliff:g id="NUM_MISSED_CALLS">%s</xliff:g>"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Передзвонити"</string>
diff --git a/res/values-ur-rPK/strings.xml b/res/values-ur-rPK/strings.xml
index 832d42c..a74c3de 100644
--- a/res/values-ur-rPK/strings.xml
+++ b/res/values-ur-rPK/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"کال کی سرگزشت صاف کی جا رہی ہے…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"فون"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"چھوٹی ہوئی کال"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"کام سے متعلق چھوٹی ہوئی کال"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"چھوٹی ہوئی کالیں"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> چھوٹی ہوئی کالیں"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"واپس کال کریں"</string>
diff --git a/res/values-uz-rUZ/strings.xml b/res/values-uz-rUZ/strings.xml
index db85cd8..962450e 100644
--- a/res/values-uz-rUZ/strings.xml
+++ b/res/values-uz-rUZ/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Qo‘ng‘iroqlar tarixi tozalanmoqda…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Telefon"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Javobsiz qo‘ng‘iroq"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Javobsiz ishchi qo‘ng‘irog‘i"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Javobsiz qo‘ng‘iroqlar"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> ta javobsiz qo‘ng‘iroq"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Telefon qilish"</string>
diff --git a/res/values-vi/strings.xml b/res/values-vi/strings.xml
index b90907f..f446ad1 100644
--- a/res/values-vi/strings.xml
+++ b/res/values-vi/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Đang xóa nhật ký cuộc gọi…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Điện thoại"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Cuộc gọi nhỡ"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Cuộc gọi nhỡ về công việc"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Cuộc gọi nhỡ"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> cuộc gọi nhỡ"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Gọi lại"</string>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index 2d76c7f..bd81943 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"正在清除通话记录…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"打电话"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"未接电话"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"未接工作来电"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"未接电话"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> 个未接电话"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"回电"</string>
diff --git a/res/values-zh-rHK/strings.xml b/res/values-zh-rHK/strings.xml
index 7232076..fc51ebc 100644
--- a/res/values-zh-rHK/strings.xml
+++ b/res/values-zh-rHK/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"正在清除通話記錄…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"撥打電話"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"未接來電"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"未接工作來電"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"未接來電"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> 個未接來電"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"回電"</string>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index cfdef18..fe1754e 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"正在清除通話紀錄…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"撥打電話"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"未接來電"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"未接公司來電"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"未接來電"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> 通未接來電"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"回撥"</string>
diff --git a/res/values-zu/strings.xml b/res/values-zu/strings.xml
index d54c623..47faaac 100644
--- a/res/values-zu/strings.xml
+++ b/res/values-zu/strings.xml
@@ -41,6 +41,7 @@
     <string name="clearCallLogProgress_title" msgid="3372471156216306132">"Isula umlando wekholi…"</string>
     <string name="userCallActivityLabel" product="default" msgid="6652512551977445095">"Ifoni"</string>
     <string name="notification_missedCallTitle" msgid="2078223183024451723">"Ikholi ephuthelwe"</string>
+    <string name="notification_missedWorkCallTitle" msgid="8418335304394771688">"Ugeje ikholi yomsebenzi"</string>
     <string name="notification_missedCallsTitle" msgid="4948840634672742797">"Amakholi akuphuthele"</string>
     <string name="notification_missedCallsMsg" msgid="158790423221579961">"<xliff:g id="NUM_MISSED_CALLS">%s</xliff:g> amakholi akulahlekele"</string>
     <string name="notification_missedCall_call_back" msgid="1991552423738343203">"Phinda ushayele"</string>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 3c319af..ae63df3 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -106,6 +106,8 @@
     <!-- Notification strings -->
     <!-- Missed call notification label, used when there's exactly one missed call -->
     <string name="notification_missedCallTitle">Missed call</string>
+    <!-- Missed call notification label, used when there's exactly one missed call from work contact -->
+    <string name="notification_missedWorkCallTitle">Missed work call</string>
     <!-- Missed call notification label, used when there are two or more missed calls -->
     <string name="notification_missedCallsTitle">Missed calls</string>
     <!-- Missed call notification message used when there are multiple missed calls -->
diff --git a/src/com/android/dialer/DialerApplication.java b/src/com/android/dialer/DialerApplication.java
index b177d83..078b551 100644
--- a/src/com/android/dialer/DialerApplication.java
+++ b/src/com/android/dialer/DialerApplication.java
@@ -20,7 +20,6 @@
 import android.os.Trace;
 
 import com.android.contacts.common.extensions.ExtensionsFactory;
-import com.android.contacts.commonbind.analytics.AnalyticsUtil;
 
 public class DialerApplication extends Application {
 
@@ -33,9 +32,6 @@
         Trace.beginSection(TAG + " ExtensionsFactory initialization");
         ExtensionsFactory.init(getApplicationContext());
         Trace.endSection();
-        Trace.beginSection(TAG + " Analytics initialization");
-        AnalyticsUtil.initialize(this);
-        Trace.endSection();
         Trace.endSection();
     }
 }
diff --git a/src/com/android/dialer/calllog/CallLogAsyncTaskUtil.java b/src/com/android/dialer/calllog/CallLogAsyncTaskUtil.java
index d73159c..5bcfa6b 100644
--- a/src/com/android/dialer/calllog/CallLogAsyncTaskUtil.java
+++ b/src/com/android/dialer/calllog/CallLogAsyncTaskUtil.java
@@ -408,7 +408,6 @@
                 values.put(CallLog.Calls.IS_READ, "1");
                 context.getContentResolver().update(
                         CallLog.Calls.CONTENT_URI, values, where.toString(), null);
-                ((DialtactsActivity) context).updateTabUnreadCounts();
                 return null;
             }
         });
diff --git a/src/com/android/dialer/calllog/CallLogFragment.java b/src/com/android/dialer/calllog/CallLogFragment.java
index 006fec7..ac8dfda 100644
--- a/src/com/android/dialer/calllog/CallLogFragment.java
+++ b/src/com/android/dialer/calllog/CallLogFragment.java
@@ -16,8 +16,6 @@
 
 package com.android.dialer.calllog;
 
-import static android.Manifest.permission.READ_CALL_LOG;
-
 import android.app.Activity;
 import android.app.Fragment;
 import android.app.KeyguardManager;
@@ -32,7 +30,7 @@
 import android.provider.CallLog;
 import android.provider.CallLog.Calls;
 import android.provider.ContactsContract;
-import android.provider.VoicemailContract.Status;
+import android.support.annotation.Nullable;
 import android.support.v13.app.FragmentCompat;
 import android.support.v7.widget.LinearLayoutManager;
 import android.support.v7.widget.RecyclerView;
@@ -43,7 +41,6 @@
 import com.android.contacts.common.GeoUtil;
 import com.android.contacts.common.util.PermissionsUtil;
 import com.android.dialer.R;
-import com.android.dialer.filterednumber.FilteredNumbersUtil;
 import com.android.dialer.list.ListsFragment;
 import com.android.dialer.util.EmptyLoader;
 import com.android.dialer.voicemail.VoicemailPlaybackPresenter;
@@ -51,6 +48,8 @@
 import com.android.dialer.widget.EmptyContentView.OnEmptyViewActionButtonClickedListener;
 import com.android.dialerbind.ObjectFactory;
 
+import static android.Manifest.permission.READ_CALL_LOG;
+
 /**
  * Displays a list of call log entries. To filter for a particular kind of call
  * (all, missed or voicemails), specify it in the constructor.
@@ -84,11 +83,8 @@
     private LinearLayoutManager mLayoutManager;
     private CallLogAdapter mAdapter;
     private CallLogQueryHandler mCallLogQueryHandler;
-    private VoicemailPlaybackPresenter mVoicemailPlaybackPresenter;
     private boolean mScrollToTop;
 
-    /** Whether there is at least one voicemail source installed. */
-    private boolean mVoicemailSourcesAvailable = false;
 
     private EmptyContentView mEmptyListView;
     private KeyguardManager mKeyguardManager;
@@ -111,7 +107,7 @@
 
     private final Handler mHandler = new Handler();
 
-    private class CustomContentObserver extends ContentObserver {
+    protected class CustomContentObserver extends ContentObserver {
         public CustomContentObserver() {
             super(mHandler);
         }
@@ -124,7 +120,6 @@
     // See issue 6363009
     private final ContentObserver mCallLogObserver = new CustomContentObserver();
     private final ContentObserver mContactsObserver = new CustomContentObserver();
-    private final ContentObserver mVoicemailStatusObserver = new CustomContentObserver();
     private boolean mRefreshDataRequired = true;
 
     private boolean mHasReadCallLogPermission = false;
@@ -210,13 +205,7 @@
         resolver.registerContentObserver(CallLog.CONTENT_URI, true, mCallLogObserver);
         resolver.registerContentObserver(ContactsContract.Contacts.CONTENT_URI, true,
                 mContactsObserver);
-        resolver.registerContentObserver(Status.CONTENT_URI, true, mVoicemailStatusObserver);
         setHasOptionsMenu(true);
-
-        if (mCallTypeFilter == Calls.VOICEMAIL_TYPE) {
-            mVoicemailPlaybackPresenter = VoicemailPlaybackPresenter
-                    .getInstance(activity, state);
-        }
     }
 
     /** Called by the CallLogQueryHandler when the list of calls has been fetched or updated. */
@@ -295,7 +284,12 @@
     @Override
     public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedState) {
         View view = inflater.inflate(R.layout.call_log_fragment, container, false);
+        setupView(view, null);
+        return view;
+    }
 
+    protected void setupView(
+            View view, @Nullable VoicemailPlaybackPresenter voicemailPlaybackPresenter) {
         mRecyclerView = (RecyclerView) view.findViewById(R.id.recycler_view);
         mRecyclerView.setHasFixedSize(true);
         mLayoutManager = new LinearLayoutManager(getActivity());
@@ -309,11 +303,10 @@
                 getActivity(),
                 this,
                 new ContactInfoHelper(getActivity(), currentCountryIso),
-                mVoicemailPlaybackPresenter,
+                voicemailPlaybackPresenter,
                 mIsCallLogActivity);
         mRecyclerView.setAdapter(mAdapter);
         fetchCalls();
-        return view;
     }
 
     @Override
@@ -351,19 +344,11 @@
         mAdapter.onResume();
 
         rescheduleDisplayUpdate();
-
-        if (mVoicemailPlaybackPresenter != null) {
-            mVoicemailPlaybackPresenter.onResume();
-        }
     }
 
     @Override
     public void onPause() {
         cancelDisplayUpdate();
-
-        if (mVoicemailPlaybackPresenter != null) {
-            mVoicemailPlaybackPresenter.onPause();
-        }
         mAdapter.onPause();
         super.onPause();
     }
@@ -379,13 +364,8 @@
     public void onDestroy() {
         mAdapter.changeCursor(null);
 
-        if (mVoicemailPlaybackPresenter != null) {
-            mVoicemailPlaybackPresenter.onDestroy();
-        }
-
         getActivity().getContentResolver().unregisterContentObserver(mCallLogObserver);
         getActivity().getContentResolver().unregisterContentObserver(mContactsObserver);
-        getActivity().getContentResolver().unregisterContentObserver(mVoicemailStatusObserver);
         super.onDestroy();
     }
 
@@ -397,18 +377,11 @@
         outState.putLong(KEY_DATE_LIMIT, mDateLimit);
 
         mAdapter.onSaveInstanceState(outState);
-
-        if (mVoicemailPlaybackPresenter != null) {
-            mVoicemailPlaybackPresenter.onSaveInstanceState(outState);
-        }
     }
 
     @Override
     public void fetchCalls() {
         mCallLogQueryHandler.fetchCalls(mCallTypeFilter, mDateLimit);
-        if (mVoicemailPlaybackPresenter != null) {
-            ((ListsFragment) getParentFragment()).updateTabUnreadCounts();
-        }
     }
 
     private void updateEmptyMessage(int filterType) {
@@ -500,10 +473,6 @@
             mCallLogQueryHandler.markNewCallsAsOld();
             if (mCallTypeFilter == Calls.VOICEMAIL_TYPE) {
                 CallLogNotificationsHelper.updateVoicemailNotifications(getActivity());
-            } else if (((ListsFragment) getParentFragment()).getCurrentTabIndex() ==
-                    ListsFragment.TAB_INDEX_HISTORY && !onEntry) {
-                mCallLogQueryHandler.markMissedCallsAsRead();
-                CallLogNotificationsHelper.removeMissedCallNotifications(getActivity());
             }
         }
     }
diff --git a/src/com/android/dialer/calllog/CallLogListItemViewHolder.java b/src/com/android/dialer/calllog/CallLogListItemViewHolder.java
index f76312d..e60dd27 100644
--- a/src/com/android/dialer/calllog/CallLogListItemViewHolder.java
+++ b/src/com/android/dialer/calllog/CallLogListItemViewHolder.java
@@ -55,7 +55,7 @@
 import com.android.dialer.filterednumber.FilteredNumbersUtil;
 import com.android.dialer.logging.Logger;
 import com.android.dialer.logging.ScreenEvent;
-import com.android.dialer.service.SpamButtonRenderer;
+import com.android.dialer.service.ExtendedBlockingButtonRenderer;
 import com.android.dialer.util.DialerUtils;
 import com.android.dialer.util.PhoneNumberUtil;
 import com.android.dialer.voicemail.VoicemailPlaybackLayout;
@@ -205,8 +205,8 @@
 
     private final int mPhotoSize;
 
-    private ViewStub mSpamViewStub;
-    private SpamButtonRenderer mSpamButtonRenderer;
+    private ViewStub mExtendedBlockingViewStub;
+    private ExtendedBlockingButtonRenderer mExtendedBlockingButtonRenderer;
 
     private View.OnClickListener mExpandCollapseListener;
     private boolean mVoicemailPrimaryActionButtonClicked;
@@ -413,8 +413,10 @@
             callWithNoteButtonView = actionsView.findViewById(R.id.call_with_note_action);
             callWithNoteButtonView.setOnClickListener(this);
 
-            mSpamViewStub = (ViewStub) actionsView.findViewById(R.id.spam_actions_container);
-            mSpamButtonRenderer = ObjectFactory.newSpamButtonRenderer(mContext, mSpamViewStub);
+            mExtendedBlockingViewStub =
+                    (ViewStub) actionsView.findViewById(R.id.extended_blocking_actions_container);
+            mExtendedBlockingButtonRenderer = ObjectFactory
+                    .newExtendedBlockingButtonRenderer(mContext, mExtendedBlockingViewStub);
         }
 
         bindActionButtons();
@@ -545,7 +547,7 @@
         callWithNoteButtonView.setVisibility(
                 supportsCallSubject && !isVoicemailNumber ? View.VISIBLE : View.GONE);
 
-        if(mSpamButtonRenderer != null){
+        if(mExtendedBlockingButtonRenderer != null){
             List<View> completeLogListItems = Lists.newArrayList(
                     createNewContactButtonView,
                     addToExistingContactButtonView,
@@ -555,12 +557,12 @@
                     detailsButtonView,
                     voicemailPlaybackView);
             List<View> blockedNumberVisibleViews = new ArrayList<>();
-            List<View> spamNumberVisibleViews = Lists.newArrayList(detailsButtonView);
+            List<View> extendedBlockingVisibleViews = Lists.newArrayList(detailsButtonView);
 
-            mSpamButtonRenderer.setCompleteListItemViews(completeLogListItems);
-            mSpamButtonRenderer.setFilteredNumberViews(blockedNumberVisibleViews);
-            mSpamButtonRenderer.setSpamFilteredViews(spamNumberVisibleViews);
-            mSpamButtonRenderer.render(number, countryIso);
+            mExtendedBlockingButtonRenderer.setCompleteListItemViews(completeLogListItems);
+            mExtendedBlockingButtonRenderer.setFilteredNumberViews(blockedNumberVisibleViews);
+            mExtendedBlockingButtonRenderer.setExtendedFilteredViews(extendedBlockingVisibleViews);
+            mExtendedBlockingButtonRenderer.render(number, countryIso);
         }
     }
 
diff --git a/src/com/android/dialer/calllog/CallLogNotificationsHelper.java b/src/com/android/dialer/calllog/CallLogNotificationsHelper.java
index 64ccd5f..6abf241 100644
--- a/src/com/android/dialer/calllog/CallLogNotificationsHelper.java
+++ b/src/com/android/dialer/calllog/CallLogNotificationsHelper.java
@@ -26,6 +26,7 @@
 import android.net.Uri;
 import android.provider.CallLog.Calls;
 import android.provider.ContactsContract.PhoneLookup;
+import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.telephony.PhoneNumberUtils;
 import android.text.TextUtils;
@@ -104,37 +105,61 @@
      */
     public String getName(@Nullable String number, int numberPresentation,
                           @Nullable String countryIso) {
-        String name = PhoneNumberDisplayUtil.getDisplayName(
-                mContext,
-                number,
-                numberPresentation,
-                false).toString();
-        if (!TextUtils.isEmpty(name)) {
-            return name;
-        }
+        return getContactInfo(number, numberPresentation, countryIso).name;
+    }
 
-        // Look it up in the database.
-        name = mNameLookupQuery.query(number);
-        if (!TextUtils.isEmpty(name)) {
-            return name;
-        }
-
+    /**
+     * Given a number and number information (presentation and country ISO), get
+     * {@link ContactInfo}. If the name is empty but we have a special presentation, display that.
+     * Otherwise attempt to look it up in the database or the cache.
+     * If that fails, fall back to displaying the number.
+     */
+    public @NonNull ContactInfo getContactInfo(@Nullable String number, int numberPresentation,
+                          @Nullable String countryIso) {
         if (countryIso == null) {
             countryIso = mCurrentCountryIso;
         }
 
-        // Look it up in the cache
-        ContactInfo contactInfo = mContactInfoHelper.lookupNumber(number, countryIso);
+        ContactInfo contactInfo = new ContactInfo();
+        contactInfo.number = number;
+        contactInfo.formattedNumber = PhoneNumberUtils.formatNumber(number, countryIso);
+        // contactInfo.normalizedNumber is not PhoneNumberUtils.normalizeNumber. Read ContactInfo.
+        contactInfo.normalizedNumber = PhoneNumberUtils.formatNumberToE164(number, countryIso);
 
-        if (contactInfo != null && !TextUtils.isEmpty(contactInfo.name)) {
-            return contactInfo.name;
+        // 1. Special number representation.
+        contactInfo.name = PhoneNumberDisplayUtil.getDisplayName(
+                mContext,
+                number,
+                numberPresentation,
+                false).toString();
+        if (!TextUtils.isEmpty(contactInfo.name)) {
+            return contactInfo;
         }
 
-        if (!TextUtils.isEmpty(number)) {
-            // If we cannot lookup the contact, use the number instead.
-            return PhoneNumberUtils.formatNumber(number, countryIso);
+        // 2. Personal ContactsProvider phonelookup query.
+        contactInfo.name = mNameLookupQuery.query(number);
+        if (!TextUtils.isEmpty(contactInfo.name)) {
+            return contactInfo;
         }
-        return mContext.getResources().getString(R.string.unknown);
+
+        // 3. Look it up in the cache.
+        ContactInfo cachedContactInfo = mContactInfoHelper.lookupNumber(number, countryIso);
+
+        if (cachedContactInfo != null && !TextUtils.isEmpty(cachedContactInfo.name)) {
+            return cachedContactInfo;
+        }
+
+        if (!TextUtils.isEmpty(contactInfo.formattedNumber)) {
+            // 4. If we cannot lookup the contact, use the formatted number instead.
+            contactInfo.name = contactInfo.formattedNumber;
+        } else if (!TextUtils.isEmpty(number)) {
+            // 5. If number can't be formatted, use number.
+            contactInfo.name = number;
+        } else {
+            // 6. Otherwise, it's unknown number.
+            contactInfo.name = mContext.getResources().getString(R.string.unknown);
+        }
+        return contactInfo;
     }
 
     /** Removes the missed call notifications. */
diff --git a/src/com/android/dialer/calllog/ContactInfo.java b/src/com/android/dialer/calllog/ContactInfo.java
index 40d963e..8fe4964 100644
--- a/src/com/android/dialer/calllog/ContactInfo.java
+++ b/src/com/android/dialer/calllog/ContactInfo.java
@@ -40,6 +40,15 @@
     public String label;
     public String number;
     public String formattedNumber;
+    /*
+     * ContactInfo.normalizedNumber is a column value returned by PhoneLookup query. By definition,
+     * it's E164 representation.
+     * http://developer.android.com/reference/android/provider/ContactsContract.PhoneLookupColumns.
+     * html#NORMALIZED_NUMBER.
+     *
+     * The fallback value, when PhoneLookup fails or else, should be either null or
+     * PhoneNumberUtils.formatNumberToE164.
+     */
     public String normalizedNumber;
     /** The photo for the contact, if available. */
     public long photoId;
diff --git a/src/com/android/dialer/calllog/ContactInfoHelper.java b/src/com/android/dialer/calllog/ContactInfoHelper.java
index 7f08fdc..75e7ab7 100644
--- a/src/com/android/dialer/calllog/ContactInfoHelper.java
+++ b/src/com/android/dialer/calllog/ContactInfoHelper.java
@@ -40,6 +40,7 @@
 import com.android.dialer.service.CachedNumberLookupService.CachedContactInfo;
 import com.android.dialer.util.TelecomUtil;
 import com.android.dialerbind.ObjectFactory;
+import com.google.common.annotations.VisibleForTesting;
 
 import org.json.JSONException;
 import org.json.JSONObject;
@@ -82,17 +83,17 @@
 
         if (PhoneNumberHelper.isUriNumber(number)) {
             // The number is a SIP address..
-            info = lookupContactFromUri(getContactInfoLookupUri(number));
+            info = lookupContactFromUri(getContactInfoLookupUri(number), true);
             if (info == null || info == ContactInfo.EMPTY) {
                 // If lookup failed, check if the "username" of the SIP address is a phone number.
                 String username = PhoneNumberHelper.getUsernameFromUriNumber(number);
                 if (PhoneNumberUtils.isGlobalPhoneNumber(username)) {
-                    info = queryContactInfoForPhoneNumber(username, countryIso);
+                    info = queryContactInfoForPhoneNumber(username, countryIso, true);
                 }
             }
         } else {
             // Look for a contact that has the given phone number.
-            info = queryContactInfoForPhoneNumber(number, countryIso);
+            info = queryContactInfoForPhoneNumber(number, countryIso, false);
         }
 
         final ContactInfo updatedInfo;
@@ -153,7 +154,7 @@
      * The {@link ContactInfo#formattedNumber} field is always set to {@code null} in the returned
      * value.
      */
-    public ContactInfo lookupContactFromUri(Uri uri) {
+    ContactInfo lookupContactFromUri(Uri uri, boolean isSip) {
         if (uri == null) {
             return null;
         }
@@ -163,8 +164,10 @@
 
         Cursor phoneLookupCursor = null;
         try {
-            phoneLookupCursor = mContext.getContentResolver().query(uri,
-                    PhoneQuery.PHONE_LOOKUP_PROJECTION, null, null, null);
+            String[] projection = (isSip) ? PhoneQuery.SIP_PHONE_LOOKUP_PROJECTION
+                    : PhoneQuery.PHONE_LOOKUP_PROJECTION;
+            phoneLookupCursor = mContext.getContentResolver().query(uri, projection, null, null,
+                    null);
         } catch (NullPointerException e) {
             // Trap NPE from pre-N CP2
             return null;
@@ -241,12 +244,13 @@
      * <p>
      * If the lookup fails for some other reason, it returns null.
      */
-    private ContactInfo queryContactInfoForPhoneNumber(String number, String countryIso) {
+    private ContactInfo queryContactInfoForPhoneNumber(String number, String countryIso,
+                                                       boolean isSip) {
         if (TextUtils.isEmpty(number)) {
             return null;
         }
 
-        ContactInfo info = lookupContactFromUri(getContactInfoLookupUri(number));
+        ContactInfo info = lookupContactFromUri(getContactInfoLookupUri(number), isSip);
         if (info != null && info != ContactInfo.EMPTY) {
             info.formattedNumber = formatPhoneNumber(number, null, countryIso);
         } else if (mCachedNumberLookupService != null) {
diff --git a/src/com/android/dialer/calllog/MissedCallNotifier.java b/src/com/android/dialer/calllog/MissedCallNotifier.java
index 8811baf..a9dfd44 100644
--- a/src/com/android/dialer/calllog/MissedCallNotifier.java
+++ b/src/com/android/dialer/calllog/MissedCallNotifier.java
@@ -26,6 +26,7 @@
 import android.text.TextUtils;
 import android.util.Log;
 
+import com.android.contacts.common.ContactsUtils;
 import com.android.contacts.common.util.PhoneNumberHelper;
 import com.android.dialer.calllog.CallLogNotificationsHelper.NewCall;
 import com.android.dialer.DialtactsActivity;
@@ -97,14 +98,18 @@
         // 1 missed call: <caller name || handle>
         // More than 1 missed call: <number of calls> + "missed calls"
         if (count == 1) {
-            titleResId = R.string.notification_missedCallTitle;
-
             //TODO: look up caller ID that is not in contacts.
-            expandedText = CallLogNotificationsHelper.getInstance(mContext)
-                    .getName(useCallLog ? newestCall.number : number,
+            ContactInfo contactInfo = CallLogNotificationsHelper.getInstance(mContext)
+                    .getContactInfo(useCallLog ? newestCall.number : number,
                             useCallLog ? newestCall.numberPresentation
                                     : Calls.PRESENTATION_ALLOWED,
                             useCallLog ? newestCall.countryIso : null);
+
+            titleResId = contactInfo.userType == ContactsUtils.USER_TYPE_WORK
+                    ? R.string.notification_missedWorkCallTitle
+                    : R.string.notification_missedCallTitle;
+
+            expandedText = contactInfo.name;
         } else {
             titleResId = R.string.notification_missedCallsTitle;
             expandedText =
diff --git a/src/com/android/dialer/calllog/PhoneQuery.java b/src/com/android/dialer/calllog/PhoneQuery.java
index 200b5e1..5261874 100644
--- a/src/com/android/dialer/calllog/PhoneQuery.java
+++ b/src/com/android/dialer/calllog/PhoneQuery.java
@@ -17,6 +17,7 @@
 package com.android.dialer.calllog;
 
 import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.Data;
 import android.provider.ContactsContract.PhoneLookup;
 
 /**
@@ -37,7 +38,25 @@
             PhoneLookup.NORMALIZED_NUMBER,
             PhoneLookup.PHOTO_ID,
             PhoneLookup.LOOKUP_KEY,
-            PhoneLookup.PHOTO_URI};
+            PhoneLookup.PHOTO_URI
+    };
+
+    /**
+     * Similar to {@link PHONE_LOOKUP_PROJECTION}. Due to a bug in framework, the column name of
+     * contact id in normal phonelookup query is _id, but that in sip phonelookup query is
+     * contact_id.
+     */
+    public static final String[] SIP_PHONE_LOOKUP_PROJECTION = new String[] {
+            Data.CONTACT_ID,
+            PhoneLookup.DISPLAY_NAME,
+            PhoneLookup.TYPE,
+            PhoneLookup.LABEL,
+            PhoneLookup.NUMBER,
+            PhoneLookup.NORMALIZED_NUMBER,
+            PhoneLookup.PHOTO_ID,
+            PhoneLookup.LOOKUP_KEY,
+            PhoneLookup.PHOTO_URI
+    };
 
     public static final int PERSON_ID = 0;
     public static final int NAME = 1;
diff --git a/src/com/android/dialer/calllog/VisualVoicemailCallLogFragment.java b/src/com/android/dialer/calllog/VisualVoicemailCallLogFragment.java
new file mode 100644
index 0000000..311ff7d
--- /dev/null
+++ b/src/com/android/dialer/calllog/VisualVoicemailCallLogFragment.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.dialer.calllog;
+
+import android.database.ContentObserver;
+import android.os.Bundle;
+import android.provider.CallLog;
+import android.provider.VoicemailContract;
+import android.support.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.android.dialer.R;
+import com.android.dialer.list.ListsFragment;
+import com.android.dialer.voicemail.VoicemailPlaybackPresenter;
+
+public class VisualVoicemailCallLogFragment extends CallLogFragment {
+
+    private VoicemailPlaybackPresenter mVoicemailPlaybackPresenter;
+    private final ContentObserver mVoicemailStatusObserver = new CustomContentObserver();
+
+    public VisualVoicemailCallLogFragment() {
+        super(CallLog.Calls.VOICEMAIL_TYPE);
+    }
+
+    @Override
+    public void onCreate(Bundle state) {
+        super.onCreate(state);
+        mVoicemailPlaybackPresenter = VoicemailPlaybackPresenter.getInstance(getActivity(), state);
+        getActivity().getContentResolver().registerContentObserver(
+                VoicemailContract.Status.CONTENT_URI, true, mVoicemailStatusObserver);
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedState) {
+        View view = inflater.inflate(R.layout.call_log_fragment, container, false);
+        setupView(view, mVoicemailPlaybackPresenter);
+        return view;
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        mVoicemailPlaybackPresenter.onResume();
+    }
+
+    @Override
+    public void onPause() {
+        mVoicemailPlaybackPresenter.onPause();
+        super.onPause();
+    }
+
+    @Override
+    public void onDestroy() {
+        mVoicemailPlaybackPresenter.onDestroy();
+        getActivity().getContentResolver().unregisterContentObserver(mVoicemailStatusObserver);
+        super.onDestroy();
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        mVoicemailPlaybackPresenter.onSaveInstanceState(outState);
+    }
+
+    @Override
+    public void fetchCalls() {
+        super.fetchCalls();
+        ((ListsFragment) getParentFragment()).updateTabUnreadCounts();
+    }
+}
diff --git a/src/com/android/dialer/list/ListsFragment.java b/src/com/android/dialer/list/ListsFragment.java
index ad3a0d8..9f76148 100644
--- a/src/com/android/dialer/list/ListsFragment.java
+++ b/src/com/android/dialer/list/ListsFragment.java
@@ -37,6 +37,7 @@
 import com.android.dialer.R;
 import com.android.dialer.calllog.CallLogFragment;
 import com.android.dialer.calllog.CallLogQueryHandler;
+import com.android.dialer.calllog.VisualVoicemailCallLogFragment;
 import com.android.dialer.logging.Logger;
 import com.android.dialer.logging.ScreenEvent;
 import com.android.dialer.util.DialerUtils;
@@ -126,7 +127,7 @@
                     mAllContactsFragment = new AllContactsFragment();
                     return mAllContactsFragment;
                 case TAB_INDEX_VOICEMAIL:
-                    mVoicemailFragment = new CallLogFragment(Calls.VOICEMAIL_TYPE);
+                    mVoicemailFragment = new VisualVoicemailCallLogFragment();
                     return mVoicemailFragment;
             }
             throw new IllegalStateException("No fragment at position " + position);
diff --git a/src/com/android/dialer/service/CachedNumberLookupService.java b/src/com/android/dialer/service/CachedNumberLookupService.java
index e91d458..018ada9 100644
--- a/src/com/android/dialer/service/CachedNumberLookupService.java
+++ b/src/com/android/dialer/service/CachedNumberLookupService.java
@@ -1,9 +1,13 @@
 package com.android.dialer.service;
 
 import android.content.Context;
+import android.net.Uri;
+import android.support.annotation.Nullable;
 
 import com.android.dialer.calllog.ContactInfo;
 
+import java.io.InputStream;
+
 public interface CachedNumberLookupService {
 
     public interface CachedContactInfo {
@@ -42,7 +46,10 @@
     public boolean isBusiness(int sourceType);
     public boolean canReportAsInvalid(int sourceType, String objectId);
 
-    public boolean addPhoto(Context context, String number, byte[] photo);
+    /**
+     * @return return {@link Uri} to the photo or return {@code null} when failing to add photo
+     */
+    public @Nullable Uri addPhoto(Context context, String number, InputStream in);
 
     /**
      * Remove all cached phone number entries from the cache, regardless of how old they
diff --git a/src/com/android/dialer/service/ExtendedBlockingButtonRenderer.java b/src/com/android/dialer/service/ExtendedBlockingButtonRenderer.java
new file mode 100644
index 0000000..9ce8447
--- /dev/null
+++ b/src/com/android/dialer/service/ExtendedBlockingButtonRenderer.java
@@ -0,0 +1,23 @@
+package com.android.dialer.service;
+
+import android.view.View;
+
+import java.util.List;
+
+/**
+ * Interface responsible for rendering spam buttons.
+ */
+public interface ExtendedBlockingButtonRenderer {
+
+    /**
+     * Renders buttons for a phone number.
+     */
+    void render(String number, String countryIso);
+
+    void setCompleteListItemViews(List<View> views);
+
+    void setExtendedFilteredViews(List<View> views);
+
+    void setFilteredNumberViews(List<View> views);
+
+}
diff --git a/src/com/android/dialer/service/ExtendedBlockingManager.java b/src/com/android/dialer/service/ExtendedBlockingManager.java
new file mode 100644
index 0000000..3257a72
--- /dev/null
+++ b/src/com/android/dialer/service/ExtendedBlockingManager.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.dialer.service;
+
+import android.support.annotation.Nullable;
+
+/**
+ * Manager of extended blocking events. It notifies all listeners of all blocking-related events.
+ */
+public interface ExtendedBlockingManager {
+
+    interface ButtonRendererListener {
+        void onBlockedNumber(String number, @Nullable String countryIso);
+        void onUnblockedNumber(String number, @Nullable String countryIso);
+    }
+
+    void addButtonRendererListener(@Nullable ButtonRendererListener listener);
+
+    void removeButtonRendererListener(@Nullable ButtonRendererListener listener);
+
+    void notifyOnBlockedNumber(String number, @Nullable String countryIso);
+
+    void notifyOnUnblockedNumber(String number, @Nullable String countryIso);
+}
diff --git a/src/com/android/dialer/service/SpamButtonRenderer.java b/src/com/android/dialer/service/SpamButtonRenderer.java
deleted file mode 100644
index 843bc55..0000000
--- a/src/com/android/dialer/service/SpamButtonRenderer.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package com.android.dialer.service;
-
-import android.view.View;
-
-import java.util.List;
-
-/**
- * Interface responsible for rendering spam buttons.
- */
-public interface SpamButtonRenderer {
-
-    /**
-     * Renders buttons for a phone number.
-     */
-    void render(String number, String countryIso);
-
-    void setCompleteListItemViews(List<View> views);
-
-    void setSpamFilteredViews(List<View> views);
-
-    void setFilteredNumberViews(List<View> views);
-
-}
diff --git a/src/com/android/dialerbind/ObjectFactory.java b/src/com/android/dialerbind/ObjectFactory.java
index d06d55e..51b8fbc 100644
--- a/src/com/android/dialerbind/ObjectFactory.java
+++ b/src/com/android/dialerbind/ObjectFactory.java
@@ -19,8 +19,7 @@
 import static com.android.dialer.calllog.CallLogAdapter.CallFetcher;
 
 import android.content.Context;
-import android.view.View;
-import android.view.ViewGroup;
+import android.support.annotation.Nullable;
 import android.view.ViewStub;
 
 import com.android.dialer.calllog.CallLogAdapter;
@@ -28,7 +27,8 @@
 import com.android.dialer.list.RegularSearchFragment;
 import com.android.dialer.logging.Logger;
 import com.android.dialer.service.CachedNumberLookupService;
-import com.android.dialer.service.SpamButtonRenderer;
+import com.android.dialer.service.ExtendedBlockingManager;
+import com.android.dialer.service.ExtendedBlockingButtonRenderer;
 import com.android.dialer.voicemail.VoicemailPlaybackPresenter;
 
 /**
@@ -45,12 +45,18 @@
         return "com.android.dialer.database.filterednumberprovider";
     }
 
-    public static SpamButtonRenderer newSpamButtonRenderer(
+    @Nullable
+    public static ExtendedBlockingButtonRenderer newExtendedBlockingButtonRenderer(
             Context context,
             ViewStub stub) {
         return null;
     }
 
+    @Nullable
+    public static ExtendedBlockingManager getExtendedBlockingManager() {
+        return null;
+    }
+
     /**
      * Create a new instance of the call log adapter.
      * @param context The context to use.
diff --git a/tests/src/com/android/dialer/calllog/ContactInfoHelperTest.java b/tests/src/com/android/dialer/calllog/ContactInfoHelperTest.java
index 588a27f..0e032c1 100644
--- a/tests/src/com/android/dialer/calllog/ContactInfoHelperTest.java
+++ b/tests/src/com/android/dialer/calllog/ContactInfoHelperTest.java
@@ -58,7 +58,7 @@
     }
 
     public void testLookupContactFromUri_NullUri() {
-        Assert.assertNull(mContactInfoHelper.lookupContactFromUri(null));
+        Assert.assertNull(mContactInfoHelper.lookupContactFromUri(null, false));
     }
 
     public void testLookupContactFromUri_NoResults() {
@@ -66,7 +66,7 @@
                 PhoneQuery.PHONE_LOOKUP_PROJECTION);
 
         Assert.assertEquals(ContactInfo.EMPTY, mContactInfoHelper.lookupContactFromUri(
-                PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI));
+                PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI, false));
         mContext.verify();
     }
 
@@ -77,7 +77,7 @@
                 PhoneQuery.DISPLAY_NAME_ALTERNATIVE_PROJECTION);
 
         ContactInfo contactInfo = mContactInfoHelper.lookupContactFromUri(
-                PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI);
+                PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI, false);
         Assert.assertEquals(TEST_DISPLAY_NAME, contactInfo.name);
         Assert.assertNull(contactInfo.nameAlternative);
         mContext.verify();
@@ -90,7 +90,7 @@
                 PhoneQuery.DISPLAY_NAME_ALTERNATIVE_PROJECTION, TEST_DISPLAY_NAME_ALTERNATIVE_ROW);
 
         ContactInfo contactInfo = mContactInfoHelper.lookupContactFromUri(
-                PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI);
+                PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI, false);
         Assert.assertEquals(TEST_DISPLAY_NAME, contactInfo.name);
         Assert.assertEquals(TEST_DISPLAY_NAME_ALTERNATIVE, contactInfo.nameAlternative);
         mContext.verify();
