diff --git a/java/com/android/dialer/app/res/drawable/ic_launcher_foreground_tint.xml b/java/com/android/dialer/app/res/drawable/ic_launcher_foreground_tint.xml
new file mode 100644
index 0000000..cc9dc29
--- /dev/null
+++ b/java/com/android/dialer/app/res/drawable/ic_launcher_foreground_tint.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.
+-->
+
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+
+   <item>
+    <bitmap
+        android:src="@mipmap/ic_launcher_foreground"
+        android:tint="#ffffff"/>
+  </item>
+
+</selector>
diff --git a/java/com/android/dialer/app/res/drawable/rounded_corner.xml b/java/com/android/dialer/app/res/drawable/rounded_corner.xml
index b4c1006..1567d04 100644
--- a/java/com/android/dialer/app/res/drawable/rounded_corner.xml
+++ b/java/com/android/dialer/app/res/drawable/rounded_corner.xml
@@ -18,5 +18,5 @@
 <shape xmlns:android="http://schemas.android.com/apk/res/android"
   android:shape="rectangle">
   <solid android:color="?android:attr/colorBackgroundFloating"/>
-  <corners android:radius="2dp"/>
+  <corners android:radius="@dimen/search_bar_corner_radius"/>
 </shape>
diff --git a/java/com/android/dialer/app/res/layout/search_edittext.xml b/java/com/android/dialer/app/res/layout/search_edittext.xml
index aba5ba8..d444fe5 100644
--- a/java/com/android/dialer/app/res/layout/search_edittext.xml
+++ b/java/com/android/dialer/app/res/layout/search_edittext.xml
@@ -14,6 +14,7 @@
      limitations under the License.
 -->
 <view xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:app="http://schemas.android.com/apk/res-auto"
   android:id="@+id/search_view_container"
   class="com.android.dialer.app.widget.SearchEditTextLayout"
   android:layout_width="match_parent"
@@ -28,6 +29,7 @@
   android:orientation="horizontal">
 
   <RelativeLayout
+    app:cardCornerRadius="@dimen/search_bar_corner_radius"
     android:id="@+id/search_box_collapsed"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
diff --git a/java/com/android/dialer/app/res/mipmap-anydpi/ic_launcher_phone.xml b/java/com/android/dialer/app/res/mipmap-anydpi/ic_launcher_phone.xml
new file mode 100644
index 0000000..316f086
--- /dev/null
+++ b/java/com/android/dialer/app/res/mipmap-anydpi/ic_launcher_phone.xml
@@ -0,0 +1,19 @@
+<?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.
+-->
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground_tint"/>
+</adaptive-icon>
diff --git a/java/com/android/dialer/app/res/mipmap-hdpi/ic_launcher_foreground.png b/java/com/android/dialer/app/res/mipmap-hdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..30287ed
--- /dev/null
+++ b/java/com/android/dialer/app/res/mipmap-hdpi/ic_launcher_foreground.png
Binary files differ
diff --git a/java/com/android/dialer/app/res/mipmap-mdpi/ic_launcher_foreground.png b/java/com/android/dialer/app/res/mipmap-mdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..bb6facf
--- /dev/null
+++ b/java/com/android/dialer/app/res/mipmap-mdpi/ic_launcher_foreground.png
Binary files differ
diff --git a/java/com/android/dialer/app/res/mipmap-xhdpi/ic_launcher_foreground.png b/java/com/android/dialer/app/res/mipmap-xhdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..9806ffd
--- /dev/null
+++ b/java/com/android/dialer/app/res/mipmap-xhdpi/ic_launcher_foreground.png
Binary files differ
diff --git a/java/com/android/dialer/app/res/mipmap-xxhdpi/ic_launcher_foreground.png b/java/com/android/dialer/app/res/mipmap-xxhdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..2c646a8
--- /dev/null
+++ b/java/com/android/dialer/app/res/mipmap-xxhdpi/ic_launcher_foreground.png
Binary files differ
diff --git a/java/com/android/dialer/app/res/mipmap-xxxhdpi/ic_launcher_foreground.png b/java/com/android/dialer/app/res/mipmap-xxxhdpi/ic_launcher_foreground.png
new file mode 100644
index 0000000..efa3f47
--- /dev/null
+++ b/java/com/android/dialer/app/res/mipmap-xxxhdpi/ic_launcher_foreground.png
Binary files differ
diff --git a/java/com/android/dialer/app/res/values-af/custom_strings.xml b/java/com/android/dialer/app/res/values-af/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-af/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-am/custom_strings.xml b/java/com/android/dialer/app/res/values-am/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-am/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-ar/custom_strings.xml b/java/com/android/dialer/app/res/values-ar/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-ar/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-az-rAZ/custom_strings.xml b/java/com/android/dialer/app/res/values-az-rAZ/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-az-rAZ/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-bg/custom_strings.xml b/java/com/android/dialer/app/res/values-bg/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-bg/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-ca/custom_strings.xml b/java/com/android/dialer/app/res/values-ca/custom_strings.xml
new file mode 100644
index 0000000..aeba071
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-ca/custom_strings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Inhabilita el sensor de proximitat</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-cs/custom_strings.xml b/java/com/android/dialer/app/res/values-cs/custom_strings.xml
new file mode 100644
index 0000000..65cd6f9
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-cs/custom_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Zakázat senzor přiblížení</string>
+  <string name="disable_proximity_sensor_summary">Nevypínat dotykovou obrazovku a displej při hovoru na základě senzoru přiblížení</string>
+  <string name="sensor_settings_titile">Senzory</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-da/custom_strings.xml b/java/com/android/dialer/app/res/values-da/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-da/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-de/custom_strings.xml b/java/com/android/dialer/app/res/values-de/custom_strings.xml
new file mode 100644
index 0000000..754a4b7
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-de/custom_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Näherungssensor deaktivieren</string>
+  <string name="disable_proximity_sensor_summary">Touchscreen und Display während eines Anrufs basierend auf den Näherungssensor nicht ausschalten</string>
+  <string name="sensor_settings_titile">Sensoren</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-el/custom_strings.xml b/java/com/android/dialer/app/res/values-el/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-el/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-es/custom_strings.xml b/java/com/android/dialer/app/res/values-es/custom_strings.xml
new file mode 100644
index 0000000..f3fbade
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-es/custom_strings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Desactivar el sensor de proximidad</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-et/custom_strings.xml b/java/com/android/dialer/app/res/values-et/custom_strings.xml
new file mode 100644
index 0000000..5ab69fe
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-et/custom_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Keela lähedusandur</string>
+  <string name="disable_proximity_sensor_summary">Ära lülita puuteekraani kõne ajal lähedusanduri põhjal välja</string>
+  <string name="sensor_settings_titile">Andurid</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-fa/custom_strings.xml b/java/com/android/dialer/app/res/values-fa/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-fa/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-fi/custom_strings.xml b/java/com/android/dialer/app/res/values-fi/custom_strings.xml
new file mode 100644
index 0000000..d58a396
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-fi/custom_strings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Poista etäisyyssensori käytöstä</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-fr/custom_strings.xml b/java/com/android/dialer/app/res/values-fr/custom_strings.xml
new file mode 100644
index 0000000..5246daf
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-fr/custom_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Désactiver le capteur de proximité</string>
+  <string name="disable_proximity_sensor_summary">Ne pas éteindre l\'écran tactile et l\'écran pendant les appels en se basant sur le capteur de proximité</string>
+  <string name="sensor_settings_titile">Capteurs</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-hi/custom_strings.xml b/java/com/android/dialer/app/res/values-hi/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-hi/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-hr/custom_strings.xml b/java/com/android/dialer/app/res/values-hr/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-hr/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-hu/custom_strings.xml b/java/com/android/dialer/app/res/values-hu/custom_strings.xml
new file mode 100644
index 0000000..f9728dc
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-hu/custom_strings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Közelség érzékelő letiltása</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-hy/custom_strings.xml b/java/com/android/dialer/app/res/values-hy/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-hy/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-in/custom_strings.xml b/java/com/android/dialer/app/res/values-in/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-in/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-it/custom_strings.xml b/java/com/android/dialer/app/res/values-it/custom_strings.xml
new file mode 100644
index 0000000..6f74037
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-it/custom_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Disattiva il sensore di prossimità</string>
+  <string name="disable_proximity_sensor_summary">Non disattivare il touchscreen e lo schermo in chiamata in base al sensore di prossimità</string>
+  <string name="sensor_settings_titile">Sensori</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-iw/custom_strings.xml b/java/com/android/dialer/app/res/values-iw/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-iw/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-ja/custom_strings.xml b/java/com/android/dialer/app/res/values-ja/custom_strings.xml
new file mode 100644
index 0000000..67db9f8
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-ja/custom_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">近接センサーを無効化</string>
+  <string name="disable_proximity_sensor_summary">近接センサーに基づいて通話中にタッチスクリーンと画面を OFF にしない</string>
+  <string name="sensor_settings_titile">センサー</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-ka/custom_strings.xml b/java/com/android/dialer/app/res/values-ka/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-ka/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-km/custom_strings.xml b/java/com/android/dialer/app/res/values-km/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-km/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-ko/custom_strings.xml b/java/com/android/dialer/app/res/values-ko/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-ko/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-lo-rLA/custom_strings.xml b/java/com/android/dialer/app/res/values-lo-rLA/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-lo-rLA/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-lt/custom_strings.xml b/java/com/android/dialer/app/res/values-lt/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-lt/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-lv/custom_strings.xml b/java/com/android/dialer/app/res/values-lv/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-lv/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-mn/custom_strings.xml b/java/com/android/dialer/app/res/values-mn/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-mn/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-ms/custom_strings.xml b/java/com/android/dialer/app/res/values-ms/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-ms/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-nb/custom_strings.xml b/java/com/android/dialer/app/res/values-nb/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-nb/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-ne/custom_strings.xml b/java/com/android/dialer/app/res/values-ne/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-ne/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-night/colors.xml b/java/com/android/dialer/app/res/values-night/colors.xml
new file mode 100644
index 0000000..ae050c6
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-night/colors.xml
@@ -0,0 +1,27 @@
+<!--
+  ~ 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>
+  <color name="voicemail_icon_disabled_tint">#80ffffff</color>
+
+  <!-- Text color for the "Remove" text when a contact is dragged on top of the remove view -->
+  <color name="remove_highlighted_text_color">#FF3F3B</color>
+
+  <!--  Colors for blocked numbers list -->
+  <color name="blocked_number_block_color">#F44336</color>
+
+  <color name="ic_launcher_background">@color/dialer_theme_color</color>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-night/styles.xml b/java/com/android/dialer/app/res/values-night/styles.xml
new file mode 100644
index 0000000..0d02e41
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-night/styles.xml
@@ -0,0 +1,171 @@
+<?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>
+  <style name="DialtactsTheme" parent="Dialer.ThemeBase.ActionBar">
+    <!-- todo(calderwoodra): fill this in with dialpad theme and call log card theme -->
+  </style>
+
+  <style name="DialpadTheme" parent="DialtactsTheme">
+    <item name="android:textColorPrimary">?android:attr/textColorPrimaryInverse</item>
+  </style>
+
+  <style name="ActionModeStyle" parent="Widget.AppCompat.ActionMode">
+    <item name="android:background">?android:attr/colorPrimary</item>
+    <item name="background">?android:attr/colorPrimary</item>
+    <item name="closeItemLayout">@layout/action_mode_close_button</item>
+  </style>
+
+  <style name="DialtactsSearchBarThemeOverlay" parent="ThemeOverlay.AppCompat">
+      <item name="android:background">@*android:color/primary_dark_device_default_settings</item>
+  </style>
+
+  <!-- Text in the action bar at the top of the screen -->
+  <style name="DialtactsActionBarTitleText" parent="@android:style/TextAppearance.Material.Widget.ActionBar.Title">
+    <item name="android:textColor">?colorTextOnUnthemedDarkBackground</item>
+  </style>
+
+  <!-- Text style for tabs. -->
+  <style name="DialtactsActionBarTabTextStyle"
+    parent="android:style/Widget.Material.ActionBar.TabText">
+    <item name="android:textColor">?colorTextOnUnthemedDarkBackground</item>
+    <item name="android:textSize">@dimen/tab_text_size</item>
+    <item name="android:fontFamily">"sans-serif-medium"</item>
+  </style>
+
+  <style name="CallLogActionStyle">
+    <item name="android:layout_width">match_parent</item>
+    <item name="android:layout_height">@dimen/call_log_action_height</item>
+    <item name="android:background">@*android:color/primary_device_default_settings</item>
+    <item name="android:orientation">horizontal</item>
+    <item name="android:gravity">center_vertical</item>
+  </style>
+
+  <style name="CallLogActionTextStyle" parent="Dialer.TextAppearance.Primary.Ellipsize">
+    <item name="android:layout_width">match_parent</item>
+    <item name="android:layout_height">wrap_content</item>
+    <item name="android:paddingStart">@dimen/call_log_action_horizontal_padding</item>
+    <item name="android:paddingEnd">@dimen/call_log_action_horizontal_padding</item>
+    <item name="android:focusable">true</item>
+    <item name="android:importantForAccessibility">no</item>
+  </style>
+
+  <style name="CallLogActionSupportTextStyle" parent="Dialer.TextAppearance.Secondary.Ellipsize">
+    <item name="android:layout_width">match_parent</item>
+    <item name="android:layout_height">wrap_content</item>
+    <item name="android:paddingStart">@dimen/call_log_action_horizontal_padding</item>
+    <item name="android:paddingEnd">@dimen/call_log_action_horizontal_padding</item>
+    <item name="android:focusable">true</item>
+    <item name="android:importantForAccessibility">no</item>
+  </style>
+
+  <style name="CallLogActionIconStyle">
+    <item name="android:layout_width">@dimen/call_log_action_icon_dimen</item>
+    <item name="android:layout_height">@dimen/call_log_action_icon_dimen</item>
+    <item name="android:layout_marginStart">@dimen/call_log_action_icon_margin_start</item>
+    <item name="android:tint">?colorIcon</item>
+    <item name="android:importantForAccessibility">no</item>
+  </style>
+
+  <style name="ManageBlockedNumbersStyle" parent="SettingsStyle">
+    <!-- Styles that require AppCompat compatibility, remember to update both sets -->
+    <item name="android:windowActionBarOverlay">true</item>
+    <item name="windowActionBarOverlay">true</item>
+    <item name="android:actionBarStyle">@style/ManageBlockedNumbersActionBarStyle</item>
+    <item name="android:fastScrollTrackDrawable">@null</item>
+  </style>
+
+  <style name="ManageBlockedNumbersActionBarStyle" parent="DialerActionBarBaseStyle">
+    <!-- Styles that require AppCompat compatibility, remember to update both sets -->
+    <item name="android:height">@dimen/action_bar_height</item>
+    <item name="height">@dimen/action_bar_height</item>
+
+    <!-- Styles that require AppCompat compatibility, remember to update both sets -->
+    <item name="android:displayOptions"></item>
+    <item name="displayOptions"></item>
+    <!-- Override ActionBar title offset to keep search box aligned left -->
+    <item name="android:contentInsetStart">0dp</item>
+    <item name="contentInsetStart">0dp</item>
+    <item name="android:contentInsetEnd">0dp</item>
+    <item name="contentInsetEnd">0dp</item>
+
+    <!-- Styles that require AppCompat compatibility, remember to update both sets -->
+    <item name="android:background">?android:attr/colorPrimary</item>
+    <item name="background">?android:attr/colorPrimary</item>
+    <item name="android:titleTextStyle">@style/DialtactsActionBarTitleText</item>
+    <item name="titleTextStyle">@style/DialtactsActionBarTitleText</item>
+    <item name="android:elevation">@dimen/action_bar_elevation</item>
+    <item name="elevation">@dimen/action_bar_elevation</item>
+    <!-- Empty icon -->
+    <item name="android:icon">@android:color/transparent</item>
+    <item name="icon">@android:color/transparent</item>
+  </style>
+
+  <style name="VoicemailPlaybackLayoutButtonStyle">
+    <item name="android:layout_width">56dp</item>
+    <item name="android:layout_height">56dp</item>
+    <item name="android:background">@drawable/oval_ripple</item>
+    <item name="android:padding">8dp</item>
+  </style>
+
+  <style name="DialerFlatButtonStyle" parent="@android:style/Widget.Material.Button">
+    <item name="android:background">?android:attr/selectableItemBackground</item>
+    <item name="android:paddingEnd">@dimen/button_horizontal_padding</item>
+    <item name="android:paddingStart">@dimen/button_horizontal_padding</item>
+    <item name="android:textColor">?android:attr/colorPrimary</item>
+  </style>
+
+  <!-- Style for the 'primary' button in a view. Unlike the DialerFlatButtonStyle, this button -->
+  <!-- is not colored white, to draw more attention to it. -->
+  <style name="DialerPrimaryFlatButtonStyle" parent="@android:style/Widget.Material.Button">
+    <item name="android:background">@drawable/selectable_primary_flat_button</item>
+    <item name="android:paddingEnd">@dimen/button_horizontal_padding</item>
+    <item name="android:paddingStart">@dimen/button_horizontal_padding</item>
+    <item name="android:textColor">@android:color/white</item>
+  </style>
+
+  <style name="BlockedNumbersDescriptionTextStyle">
+    <item name="android:lineSpacingMultiplier">1.43</item>
+    <item name="android:paddingTop">8dp</item>
+    <item name="android:paddingBottom">8dp</item>
+    <item name="android:textSize">@dimen/blocked_number_settings_description_text_size</item>
+  </style>
+
+  <style name="FullWidthDivider">
+    <item name="android:layout_width">match_parent</item>
+    <item name="android:layout_height">1dp</item>
+    <item name="android:background">?android:attr/listDivider</item>
+  </style>
+
+  <style name="TranscriptionQualityRating" parent="Dialer.TextAppearance.Secondary">
+    <item name="android:textStyle">italic</item>
+    <item name="android:paddingRight">20dp</item>
+    <item name="android:minHeight">56dp</item>
+  </style>
+
+  <style name="TranscriptionQualityRatingIcon">
+    <item name="android:paddingTop">8dp</item>
+    <item name="android:paddingBottom">8dp</item>
+    <item name="android:paddingLeft">16dp</item>
+    <item name="android:paddingRight">16dp</item>
+    <item name="android:minHeight">56dp</item>
+  </style>
+
+  <style name="PromoLinkStyle">
+    <item name="android:textColor">?android:attr/colorPrimary</item>
+    <item name="android:fontFamily">"sans-serif-medium"</item>
+  </style>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-nl/custom_strings.xml b/java/com/android/dialer/app/res/values-nl/custom_strings.xml
new file mode 100644
index 0000000..1b19435
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-nl/custom_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Schakel nabijheidssensor uit</string>
+  <string name="sensor_settings_titile">Sensoren</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-pl/custom_strings.xml b/java/com/android/dialer/app/res/values-pl/custom_strings.xml
new file mode 100644
index 0000000..9e4be9a
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-pl/custom_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Wyłącz czujnik zbliżeniowy</string>
+  <string name="disable_proximity_sensor_summary">Nie wyłączaj ekranu dotykowego i wyświetlacza podczas połączenia na podstawie czujnika zbliżeniowego</string>
+  <string name="sensor_settings_titile">Czujniki</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-pt-rBR/custom_strings.xml b/java/com/android/dialer/app/res/values-pt-rBR/custom_strings.xml
new file mode 100644
index 0000000..ad6c4d0
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-pt-rBR/custom_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Desativar o sensor de proximidade</string>
+  <string name="disable_proximity_sensor_summary">Não desligue a tela sensível ao toque e apresente a chamada com base no sensor de proximidade</string>
+  <string name="sensor_settings_titile">Sensores</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-pt-rPT/custom_strings.xml b/java/com/android/dialer/app/res/values-pt-rPT/custom_strings.xml
new file mode 100644
index 0000000..e4a8757
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-pt-rPT/custom_strings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Desativar o sensor de proximidade</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-rm/custom_strings.xml b/java/com/android/dialer/app/res/values-rm/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-rm/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-ro/custom_strings.xml b/java/com/android/dialer/app/res/values-ro/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-ro/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-ru/custom_strings.xml b/java/com/android/dialer/app/res/values-ru/custom_strings.xml
new file mode 100644
index 0000000..158eb3e
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-ru/custom_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Отключить датчик приближения</string>
+  <string name="disable_proximity_sensor_summary">Не отключать дисплей и экран вызова на основе датчика приближения</string>
+  <string name="sensor_settings_titile">Датчики</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-si/custom_strings.xml b/java/com/android/dialer/app/res/values-si/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-si/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-sk/custom_strings.xml b/java/com/android/dialer/app/res/values-sk/custom_strings.xml
new file mode 100644
index 0000000..7c66c87
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-sk/custom_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Vypnúť senzor priblíženia</string>
+  <string name="disable_proximity_sensor_summary">Nevypínať dotykovú obrazovku a displej pri hovore na základe senzoru priblíženia</string>
+  <string name="sensor_settings_titile">Senzory</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-sl/custom_strings.xml b/java/com/android/dialer/app/res/values-sl/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-sl/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-sr/custom_strings.xml b/java/com/android/dialer/app/res/values-sr/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-sr/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-sv/custom_strings.xml b/java/com/android/dialer/app/res/values-sv/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-sv/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-sw/custom_strings.xml b/java/com/android/dialer/app/res/values-sw/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-sw/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-th/custom_strings.xml b/java/com/android/dialer/app/res/values-th/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-th/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-tl/custom_strings.xml b/java/com/android/dialer/app/res/values-tl/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-tl/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-tr/custom_strings.xml b/java/com/android/dialer/app/res/values-tr/custom_strings.xml
new file mode 100644
index 0000000..eebb170
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-tr/custom_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Yakınlık sensörünü devre dışı bırak</string>
+  <string name="disable_proximity_sensor_summary">Arama esnasında dokunmatiği ve ekranı yakınlık sensörüne istinaden kapatmaz</string>
+  <string name="sensor_settings_titile">Sensörler</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-uk/custom_strings.xml b/java/com/android/dialer/app/res/values-uk/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-uk/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-vi/custom_strings.xml b/java/com/android/dialer/app/res/values-vi/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-vi/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-zh-rCN/custom_strings.xml b/java/com/android/dialer/app/res/values-zh-rCN/custom_strings.xml
new file mode 100644
index 0000000..cf02426
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-zh-rCN/custom_strings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">禁用近距离传感</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-zh-rHK/custom_strings.xml b/java/com/android/dialer/app/res/values-zh-rHK/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-zh-rHK/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values-zh-rTW/custom_strings.xml b/java/com/android/dialer/app/res/values-zh-rTW/custom_strings.xml
new file mode 100644
index 0000000..59944e3
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-zh-rTW/custom_strings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">禁用距離感應器</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/values-zu/custom_strings.xml b/java/com/android/dialer/app/res/values-zu/custom_strings.xml
new file mode 100644
index 0000000..f318bd1
--- /dev/null
+++ b/java/com/android/dialer/app/res/values-zu/custom_strings.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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"></resources>
diff --git a/java/com/android/dialer/app/res/values/colors.xml b/java/com/android/dialer/app/res/values/colors.xml
index a971347..acb995f 100644
--- a/java/com/android/dialer/app/res/values/colors.xml
+++ b/java/com/android/dialer/app/res/values/colors.xml
@@ -23,4 +23,6 @@
 
   <!--  Colors for blocked numbers list -->
   <color name="blocked_number_block_color">#F44336</color>
+
+  <color name="ic_launcher_background">@color/dialer_theme_color</color>
 </resources>
diff --git a/java/com/android/dialer/app/res/values/custom_config.xml b/java/com/android/dialer/app/res/values/custom_config.xml
new file mode 100644
index 0000000..94c8e59
--- /dev/null
+++ b/java/com/android/dialer/app/res/values/custom_config.xml
@@ -0,0 +1,19 @@
+<?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>
+    <bool name="config_answerAntiFalsingClassifierEnabled">true</bool>
+</resources>
diff --git a/java/com/android/dialer/app/res/values/custom_strings.xml b/java/com/android/dialer/app/res/values/custom_strings.xml
new file mode 100644
index 0000000..8397dd0
--- /dev/null
+++ b/java/com/android/dialer/app/res/values/custom_strings.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 Omnirom
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR 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">
+  <string name="disable_proximity_sensor_title">Disable proximity sensor</string>
+  <string name="disable_proximity_sensor_summary">Do not turn off touchscreen and display in call based on proximity sensor</string>
+  <string name="sensor_settings_titile">Sensors</string>
+</resources>
diff --git a/java/com/android/dialer/app/res/xml/sensor_settings.xml b/java/com/android/dialer/app/res/xml/sensor_settings.xml
new file mode 100644
index 0000000..619620b
--- /dev/null
+++ b/java/com/android/dialer/app/res/xml/sensor_settings.xml
@@ -0,0 +1,27 @@
+<?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
+  -->
+
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
+
+  <SwitchPreference
+    android:defaultValue="false"
+    android:key="disable_proximity_sensor_key"
+    android:title="@string/disable_proximity_sensor_title"
+    android:summary="@string/disable_proximity_sensor_summary" />
+
+</PreferenceScreen>
diff --git a/java/com/android/dialer/app/settings/DialerSettingsActivity.java b/java/com/android/dialer/app/settings/DialerSettingsActivity.java
index d9bcd6b..79d5d7e 100644
--- a/java/com/android/dialer/app/settings/DialerSettingsActivity.java
+++ b/java/com/android/dialer/app/settings/DialerSettingsActivity.java
@@ -18,6 +18,7 @@
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
+import android.hardware.SensorManager;
 import android.net.Uri;
 import android.os.Build.VERSION;
 import android.os.Build.VERSION_CODES;
@@ -43,6 +44,9 @@
 import com.android.dialer.util.PermissionsUtil;
 import com.android.dialer.voicemail.settings.VoicemailSettingsFragment;
 import com.android.voicemail.VoicemailClient;
+
+import static android.hardware.Sensor.TYPE_PROXIMITY;
+
 import java.util.List;
 
 /** Activity for dialer settings. */
@@ -105,6 +109,13 @@
     soundSettingsHeader.id = R.id.settings_header_sounds_and_vibration;
     target.add(soundSettingsHeader);
 
+    if (showSensorOptions()) {
+      Header sensorSettingsHeader = new Header();
+      sensorSettingsHeader.titleRes = R.string.sensor_settings_titile;
+      sensorSettingsHeader.fragment = SensorSettingsFragment.class.getName();
+      target.add(sensorSettingsHeader);
+    }
+
     Header quickResponseSettingsHeader = new Header();
     Intent quickResponseSettingsIntent =
         new Intent(TelecomManager.ACTION_SHOW_RESPOND_VIA_SMS_SETTINGS);
@@ -326,4 +337,9 @@
   private boolean isPrimaryUser() {
     return getSystemService(UserManager.class).isSystemUser();
   }
+
+  private boolean showSensorOptions() {
+    SensorManager sm = (SensorManager) this.getSystemService(Context.SENSOR_SERVICE);
+    return sm.getDefaultSensor(TYPE_PROXIMITY) != null;
+  }
 }
diff --git a/java/com/android/dialer/app/settings/SensorSettingsFragment.java b/java/com/android/dialer/app/settings/SensorSettingsFragment.java
new file mode 100644
index 0000000..3be01f0
--- /dev/null
+++ b/java/com/android/dialer/app/settings/SensorSettingsFragment.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.dialer.app.settings;
+
+import android.os.Bundle;
+import android.preference.PreferenceFragment;
+import com.android.dialer.app.R;
+
+public class SensorSettingsFragment extends PreferenceFragment {
+
+  @Override
+  public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    addPreferencesFromResource(R.xml.sensor_settings);
+  }
+}
diff --git a/java/com/android/dialer/blockreportspam/res/values-night/colors.xml b/java/com/android/dialer/blockreportspam/res/values-night/colors.xml
new file mode 100644
index 0000000..15a5c0a
--- /dev/null
+++ b/java/com/android/dialer/blockreportspam/res/values-night/colors.xml
@@ -0,0 +1,21 @@
+<!--
+  ~ 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>
+
+  <!-- 87% white -->
+  <color name="block_report_spam_primary_text_color">#deffffff</color>
+
+</resources>
diff --git a/java/com/android/dialer/calldetails/res/values-night/styles.xml b/java/com/android/dialer/calldetails/res/values-night/styles.xml
new file mode 100644
index 0000000..8b98735
--- /dev/null
+++ b/java/com/android/dialer/calldetails/res/values-night/styles.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+  <style name="CallDetailsActionItemStyle" parent="Dialer.TextAppearance.Secondary.Ellipsize">
+    <item name="android:foreground">?android:attr/selectableItemBackground</item>
+    <item name="android:clickable">true</item>
+    <item name="android:drawablePadding">28dp</item>
+    <item name="android:gravity">center_vertical</item>
+    <item name="android:paddingStart">28dp</item>
+    <item name="android:paddingEnd">28dp</item>
+    <item name="android:paddingTop">16dp</item>
+    <item name="android:textColor">#ffffff</item>
+    <item name="android:paddingBottom">16dp</item>
+  </style>
+
+</resources>
diff --git a/java/com/android/dialer/calllog/ui/res/values-night/colors.xml b/java/com/android/dialer/calllog/ui/res/values-night/colors.xml
new file mode 100644
index 0000000..d7e987d
--- /dev/null
+++ b/java/com/android/dialer/calllog/ui/res/values-night/colors.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<resources>
+  <!-- TODO(a bug): remove these? -->
+  <color name="feature_icon_read_color">#9E9E9E</color>
+  <color name="feature_icon_unread_color">#777777</color>
+
+  <color name="call_type_icon_read_color">#757575</color>
+  <color name="call_type_icon_unread_color">#D32F2F</color>
+</resources>
diff --git a/java/com/android/dialer/contacts/resources/res/values-night/colors.xml b/java/com/android/dialer/contacts/resources/res/values-night/colors.xml
new file mode 100644
index 0000000..a2a4f1f
--- /dev/null
+++ b/java/com/android/dialer/contacts/resources/res/values-night/colors.xml
@@ -0,0 +1,51 @@
+<!--
+  ~ 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>
+  <!-- Color of the theme of the People app -->
+  <color name="people_app_theme_color">@*android:color/primary_dark_device_default_settings</color>
+
+  <!-- Darker versions of letter_tile_colors, two shades darker. These colors are used
+      for settings secondary activity colors. -->
+  <array name="letter_tile_colors_dark">
+    <item>#C53929</item>
+    <item>#C2185B</item>
+    <item>#7B1FA2</item>
+    <item>#512DA8</item>
+    <item>#303F9F</item>
+    <item>#3367D6</item>
+    <item>#0277BD</item>
+    <item>#006064</item>
+    <item>#00796B</item>
+    <item>#0B8043</item>
+    <item>#33691E</item>
+    <item>#E65100</item>
+    <item>#E64A19</item>
+    <item>#424242</item>
+  </array>
+
+  <!-- Text color used for character counter when the max limit has been exceeded -->
+  <color name="call_subject_limit_exceeded">#d1041c</color>
+
+  <!-- Tint color for the call subject history icon. -->
+  <color name="call_subject_history_icon">#ffffff</color>
+
+  <!-- Divider line on the call subject dialog. -->
+  <color name="call_subject_divider">#282828</color>
+
+  <!-- Text color for the SEND & CALL button on the call subject dialog. -->
+  <color name="call_subject_button">#00c853</color>
+</resources>
diff --git a/java/com/android/dialer/dialpadview/theme/res/values-night/styles.xml b/java/com/android/dialer/dialpadview/theme/res/values-night/styles.xml
new file mode 100644
index 0000000..a37be2d
--- /dev/null
+++ b/java/com/android/dialer/dialpadview/theme/res/values-night/styles.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+  <style name="Dialpad">
+    <item name="dialpad_digits_adjustable_height">@dimen/dialpad_digits_height</item>
+    <item name="dialpad_digits_adjustable_text_size">@dimen/dialpad_digits_text_size</item>
+    <item name="dialpad_key_letters_size_for_dual_alphabets">
+      @dimen/dialpad_key_letters_default_size_for_dual_alphabets
+    </item>
+    <item name="dialpad_key_letters_size_for_single_alphabet">
+      @dimen/dialpad_key_letters_default_size_for_single_alphabet
+    </item>
+    <item name="dialpad_key_numbers_size">@dimen/dialpad_key_numbers_default_size</item>
+    <item name="dialpad_key_number_margin_bottom">
+      @dimen/dialpad_key_number_default_margin_bottom
+    </item>
+    <item name="dialpad_end_key_spacing">@dimen/dialpad_bottom_space_height</item>
+    <item name="dialpad_elevation">0dp</item>
+  </style>
+
+  <style name="Dialpad.Themed">
+    <item name="dialpad_text_color">?android:attr/textColorSecondary</item>
+    <item name="dialpad_text_color_primary">?android:attr/colorPrimary</item>
+    <item name="dialpad_text_color_secondary">?android:attr/textColorSecondary</item>
+    <item name="dialpad_background">@*android:color/primary_device_default_settings</item>
+  </style>
+</resources>
diff --git a/java/com/android/dialer/interactions/res/layout/phone_disambig_item.xml b/java/com/android/dialer/interactions/res/layout/phone_disambig_item.xml
index 879ea0e..4544d8d 100755
--- a/java/com/android/dialer/interactions/res/layout/phone_disambig_item.xml
+++ b/java/com/android/dialer/interactions/res/layout/phone_disambig_item.xml
@@ -36,8 +36,9 @@
     android:id="@android:id/text2"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
-    android:layout_marginTop="-4dip"
-    android:textAppearance="?android:attr/textAppearanceSmall"
+    android:layout_marginTop="-2dip"
+    android:textColor="?android:attr/textColorSecondary"
+    android:textAppearance="@style/TextAppearanceSmall"
     android:textDirection="ltr"/>
 
 </view>
diff --git a/java/com/android/dialer/interactions/res/layout/set_primary_checkbox.xml b/java/com/android/dialer/interactions/res/layout/set_primary_checkbox.xml
index 62ef4b7..fa4639a 100644
--- a/java/com/android/dialer/interactions/res/layout/set_primary_checkbox.xml
+++ b/java/com/android/dialer/interactions/res/layout/set_primary_checkbox.xml
@@ -28,5 +28,6 @@
     android:layout_height="wrap_content"
     android:clickable="true"
     android:focusable="true"
+    android:textColor="?android:attr/textColorSecondary"
     android:text="@string/make_primary"/>
 </LinearLayout>
diff --git a/java/com/android/dialer/main/impl/bottomnav/res/layout/bottom_nav_bar_layout.xml b/java/com/android/dialer/main/impl/bottomnav/res/layout/bottom_nav_bar_layout.xml
index 1dd60d8..da97600 100644
--- a/java/com/android/dialer/main/impl/bottomnav/res/layout/bottom_nav_bar_layout.xml
+++ b/java/com/android/dialer/main/impl/bottomnav/res/layout/bottom_nav_bar_layout.xml
@@ -19,7 +19,6 @@
     android:orientation="horizontal"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
-    android:background="?android:attr/colorBackgroundFloating"
     android:elevation="8dp">
 
   <include
@@ -49,4 +48,4 @@
       android:layout_height="wrap_content"
       android:layout_weight="1"
       layout="@layout/bottom_nav_item"/>
-</com.android.dialer.main.impl.bottomnav.BottomNavBar>
\ No newline at end of file
+</com.android.dialer.main.impl.bottomnav.BottomNavBar>
diff --git a/java/com/android/dialer/main/impl/bottomnav/res/values/styles.xml b/java/com/android/dialer/main/impl/bottomnav/res/values/styles.xml
new file mode 100644
index 0000000..dafbaa5
--- /dev/null
+++ b/java/com/android/dialer/main/impl/bottomnav/res/values/styles.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+  <style name="BottomNavigationBarStyle" parent="@style/Widget.MaterialComponents.BottomNavigationView">
+    <item name="background">?android:attr/colorBackgroundFloating</item>
+  </style>
+</resources>
diff --git a/java/com/android/dialer/main/impl/res/values-night/styles.xml b/java/com/android/dialer/main/impl/res/values-night/styles.xml
new file mode 100644
index 0000000..1b09d98
--- /dev/null
+++ b/java/com/android/dialer/main/impl/res/values-night/styles.xml
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+
+  <!-- Activities should use this theme as their style -->
+  <style name="MainActivityTheme" parent="MainActivityThemeBase"/>
+
+  <style name="MainActivityTheme.Dark" parent="MainActivityTheme.Dark"/>
+
+  <!-- Used as a procy for values-v27/styles.xml -->
+  <style name="MainActivityThemeBase" parent="Dialer.ThemeBase.NoActionBar">
+    <!-- Required for actionmode/multiselect to render properly. -->
+    <!-- TODO(a bug): Check to see if we can remove this after NewVoicemailFragment launches -->
+    <item name="actionModeStyle">@style/MainActionModeStyle</item>
+    <item name="actionBarTheme">@style/ThemeOverlay.AppCompat.Dark.ActionBar</item>
+    <item name="dialpad_style">@style/Dialpad.Themed</item>
+  </style>
+
+  <style name="MainActivityThemeBase.Dark" parent="Dialer.Dark.ThemeBase.NoActionBar">
+    <!-- Required for actionmode/multiselect to render properly. -->
+    <!-- TODO(a bug): Check to see if we can remove this after NewVoicemailFragment launches -->
+    <item name="actionModeStyle">@style/MainActionModeStyle</item>
+    <item name="actionBarTheme">@style/ThemeOverlay.AppCompat.Dark.ActionBar</item>
+    <item name="dialpad_style">@style/Dialpad.Themed</item>
+  </style>
+
+  <!-- Colors our actionbar in action mode to dialer theme color. -->
+  <style name="MainActionModeStyle" parent="@style/Widget.AppCompat.ActionMode">
+    <item name="background">?android:attr/colorPrimary</item>
+    <item name="titleTextStyle">@style/ActionModeTitleTextStyle</item>
+  </style>
+
+  <!-- Colors our actionbar text in action mode to dialer white text color. -->
+  <style name="ActionModeTitleTextStyle" parent="@style/TextAppearance.AppCompat.Widget.ActionMode.Title">
+    <item name="android:textColor">?android:attr/textColorPrimary</item>
+  </style>
+  <style name="BottomNavigationBarStyle" parent="@style/Widget.MaterialComponents.BottomNavigationView">
+    <item name="background">@*android:color/background_floating_device_default_dark</item>
+  </style>
+</resources>
diff --git a/java/com/android/dialer/main/impl/toolbar/res/drawable-night/search_bar_background.xml b/java/com/android/dialer/main/impl/toolbar/res/drawable-night/search_bar_background.xml
new file mode 100644
index 0000000..e4e51a7
--- /dev/null
+++ b/java/com/android/dialer/main/impl/toolbar/res/drawable-night/search_bar_background.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="rectangle">
+  <solid android:color="@*android:color/primary_device_default_settings"/>
+</shape>
diff --git a/java/com/android/dialer/main/impl/toolbar/res/drawable-night/search_bar_background_rounded_corners.xml b/java/com/android/dialer/main/impl/toolbar/res/drawable-night/search_bar_background_rounded_corners.xml
new file mode 100644
index 0000000..1ed81e0
--- /dev/null
+++ b/java/com/android/dialer/main/impl/toolbar/res/drawable-night/search_bar_background_rounded_corners.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+  android:shape="rectangle">
+  <solid android:color="@*android:color/primary_device_default_settings"/>
+  <corners android:radius="@dimen/search_bar_corner_radius"/>
+</shape>
diff --git a/java/com/android/dialer/main/impl/toolbar/res/drawable/search_bar_background_rounded_corners.xml b/java/com/android/dialer/main/impl/toolbar/res/drawable/search_bar_background_rounded_corners.xml
index 88f5a04..353de9a 100644
--- a/java/com/android/dialer/main/impl/toolbar/res/drawable/search_bar_background_rounded_corners.xml
+++ b/java/com/android/dialer/main/impl/toolbar/res/drawable/search_bar_background_rounded_corners.xml
@@ -17,5 +17,5 @@
 <shape xmlns:android="http://schemas.android.com/apk/res/android"
   android:shape="rectangle">
   <solid android:color="?android:attr/colorBackgroundFloating"/>
-  <corners android:radius="2dp"/>
+  <corners android:radius="@dimen/search_bar_corner_radius"/>
 </shape>
diff --git a/java/com/android/dialer/main/impl/toolbar/res/values/dimens.xml b/java/com/android/dialer/main/impl/toolbar/res/values/dimens.xml
index ed6f197..247485e 100644
--- a/java/com/android/dialer/main/impl/toolbar/res/values/dimens.xml
+++ b/java/com/android/dialer/main/impl/toolbar/res/values/dimens.xml
@@ -19,4 +19,5 @@
   <dimen name="collapsed_search_bar_height">48dp</dimen>
   <!-- collapsed + margin * 2 -->
   <dimen name="expanded_search_bar_height">64dp</dimen>
-</resources>
\ No newline at end of file
+  <dimen name="search_bar_corner_radius">@*android:dimen/config_dialogCornerRadius</dimen>
+</resources>
diff --git a/java/com/android/dialer/rtt/res/values-night/colors.xml b/java/com/android/dialer/rtt/res/values-night/colors.xml
new file mode 100644
index 0000000..960fe60
--- /dev/null
+++ b/java/com/android/dialer/rtt/res/values-night/colors.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+  <color name="rtt_transcript_primary_color">#92bcd1</color>
+  <color name="rtt_transcript_primary_color_dark">#576f7a</color>
+  <color name="rtt_transcript_background_color">#232324</color>
+</resources>
diff --git a/java/com/android/dialer/shortcuts/res/values-night/colors.xml b/java/com/android/dialer/shortcuts/res/values-night/colors.xml
new file mode 100644
index 0000000..ad8aa80
--- /dev/null
+++ b/java/com/android/dialer/shortcuts/res/values-night/colors.xml
@@ -0,0 +1,20 @@
+<?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>
+  <color name="shortcut_add_contact_foreground_color">@*android:color/accent_device_default_light</color>
+  <color name="shortcut_add_contact_background_color">@*android:color/primary_dark_device_default_settings</color>
+</resources>
diff --git a/java/com/android/dialer/theme/base/res/values/theme_dialer_dark.xml b/java/com/android/dialer/theme/base/res/values/theme_dialer_dark.xml
index 142bb89..9577cd9 100644
--- a/java/com/android/dialer/theme/base/res/values/theme_dialer_dark.xml
+++ b/java/com/android/dialer/theme/base/res/values/theme_dialer_dark.xml
@@ -47,8 +47,8 @@
     <!-- These will be automatically used to color most Appcompat/Material widgets. -->
     <item name="android:colorPrimary">@color/dialer_dark_theme_color</item>
     <item name="colorPrimary">@color/dialer_dark_theme_color</item>
-    <item name="android:colorPrimaryDark">@color/dialer_dark_theme_color_dark</item>
-    <item name="colorPrimaryDark">@color/dialer_dark_theme_color_dark</item>
+    <item name="android:colorPrimaryDark">@color/dialer_dark_theme_color</item>
+    <item name="colorPrimaryDark">@color/dialer_dark_theme_color</item>
     <item name="android:colorAccent">@color/dialer_dark_secondary_color</item>
     <item name="colorAccent">@color/dialer_dark_secondary_color</item>
 
@@ -62,4 +62,4 @@
     <item name="colorIconOnUnthemedDarkBackground">@android:color/white</item>
     <item name="colorPrimary20pct">@color/dialer_dark_theme_color_20pct</item>
   </style>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/java/com/android/dialer/theme/base/res/values/theme_dialer_light.xml b/java/com/android/dialer/theme/base/res/values/theme_dialer_light.xml
index db06df4..6c1aac5 100644
--- a/java/com/android/dialer/theme/base/res/values/theme_dialer_light.xml
+++ b/java/com/android/dialer/theme/base/res/values/theme_dialer_light.xml
@@ -52,8 +52,8 @@
     <!-- These will be automatically used to color most Appcompat/Material widgets. -->
     <item name="android:colorPrimary">@color/dialer_theme_color</item>
     <item name="colorPrimary">@color/dialer_theme_color</item>
-    <item name="android:colorPrimaryDark">@color/dialer_theme_color_dark</item>
-    <item name="colorPrimaryDark">@color/dialer_theme_color_dark</item>
+    <item name="android:colorPrimaryDark">@color/dialer_theme_color</item>
+    <item name="colorPrimaryDark">@color/dialer_theme_color</item>
     <item name="android:colorAccent">@color/dialer_secondary_color</item>
     <item name="colorAccent">@color/dialer_secondary_color</item>
 
diff --git a/java/com/android/dialer/theme/common/res/values-night/colors.xml b/java/com/android/dialer/theme/common/res/values-night/colors.xml
new file mode 100644
index 0000000..68c48cd
--- /dev/null
+++ b/java/com/android/dialer/theme/common/res/values-night/colors.xml
@@ -0,0 +1,20 @@
+<?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
+  -->
+<!-- The colors in this file aren't configured at the theme level. -->
+<resources>
+  <color name="dialer_divider_line_color">#282828</color>
+</resources>
diff --git a/java/com/android/dialer/theme/common/res/values-night/styles.xml b/java/com/android/dialer/theme/common/res/values-night/styles.xml
new file mode 100644
index 0000000..f313bdf
--- /dev/null
+++ b/java/com/android/dialer/theme/common/res/values-night/styles.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+  <!-- TODO(calderwoodra): Delete this once new call log and new voicemail ship. -->
+  <!-- Ideally we would make a callLogCardStyle attribute but we don't want to expand dialer/app -->
+  <style name="CallLogCardStyle" parent="CardView">
+    <item name="android:layout_width">match_parent</item>
+    <item name="android:layout_height">wrap_content</item>
+    <item name="android:layout_margin">4dp</item>
+    <item name="android:baselineAligned">false</item>
+    <item name="cardCornerRadius">2dp</item>
+    <item name="cardBackgroundColor">@*android:color/primary_device_default_settings</item>
+  </style>
+
+  <!-- This Checkbox style helps align checkboxes with the common list element layout(Image + text) -->
+  <style name="DialerCheckboxStyle" parent="Widget.AppCompat.CompoundButton.CheckBox">
+    <item name="android:layout_marginStart">20dp</item>
+    <item name="android:paddingLeft">12dp</item>
+  </style>
+</resources>
diff --git a/java/com/android/dialer/theme/hidden/res/color-night/dialer_secondary_text_color.xml b/java/com/android/dialer/theme/hidden/res/color-night/dialer_secondary_text_color.xml
new file mode 100644
index 0000000..6a95917
--- /dev/null
+++ b/java/com/android/dialer/theme/hidden/res/color-night/dialer_secondary_text_color.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<!-- Secondary text color in the Phone app -->
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:state_enabled="false" android:color="#ffffff"/>
+  <item android:color="#eeeeee"/>
+</selector>
diff --git a/java/com/android/dialer/theme/hidden/res/values-night/colors_dialer_dark.xml b/java/com/android/dialer/theme/hidden/res/values-night/colors_dialer_dark.xml
new file mode 100644
index 0000000..7cd016e
--- /dev/null
+++ b/java/com/android/dialer/theme/hidden/res/values-night/colors_dialer_dark.xml
@@ -0,0 +1,22 @@
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+  <!-- Essential theme colors -->
+  <color name="dialer_dark_theme_color">@*android:color/accent_device_default_light</color>
+  <color name="dialer_dark_theme_color_20pct">@*android:color/accent_device_default_light</color>
+  <color name="dialer_dark_theme_color_dark">@*android:color/accent_device_default_dark</color>
+  <color name="dialer_dark_secondary_color">@*android:color/accent_device_default_light</color>
+</resources>
diff --git a/java/com/android/dialer/theme/hidden/res/values-night/colors_dialer_light.xml b/java/com/android/dialer/theme/hidden/res/values-night/colors_dialer_light.xml
new file mode 100644
index 0000000..7cc4081
--- /dev/null
+++ b/java/com/android/dialer/theme/hidden/res/values-night/colors_dialer_light.xml
@@ -0,0 +1,23 @@
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+  <!-- Essential theme colors -->
+  <color name="dialer_theme_color">@*android:color/accent_device_default_light</color>
+  <color name="dialer_theme_color_20pct">@*android:color/accent_device_default_light</color>
+  <color name="dialer_theme_color_dark">@*android:color/accent_device_default_dark</color>
+  <color name="dialer_secondary_color">#F50057</color>
+  <color name="dialer_background_color">@*android:color/primary_dark_device_default_settings</color>
+</resources>
diff --git a/java/com/android/dialer/theme/hidden/res/values-night/colors_pallet.xml b/java/com/android/dialer/theme/hidden/res/values-night/colors_pallet.xml
new file mode 100644
index 0000000..49699e7
--- /dev/null
+++ b/java/com/android/dialer/theme/hidden/res/values-night/colors_pallet.xml
@@ -0,0 +1,35 @@
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+  <color name="google_blue_900">#174EA6</color>
+  <color name="google_blue_800">#185ABC</color>
+  <color name="google_blue_700">#1967D2</color>
+  <color name="google_blue_600">#1A73E8</color>
+  <color name="google_blue_500">#4285F4</color>
+  <color name="google_blue_100">#D2E3FC</color>
+  <color name="google_blue_50">#E8F0FE</color>
+
+  <color name="google_grey_50">#202124</color>
+  <color name="google_grey_100">#3C4043</color>
+  <color name="google_grey_200">#5F6368</color>
+  <color name="google_grey_300">#80868B</color>
+  <color name="google_grey_400">#9AA0A6</color>
+  <color name="google_grey_500">#BDC1C6</color>
+  <color name="google_grey_600">#DADCE0</color>
+  <color name="google_grey_700">#E8EAED</color>
+  <color name="google_grey_800">#F1F3F4</color>
+  <color name="google_grey_900">#F8F9FA</color>
+</resources>
diff --git a/java/com/android/dialer/theme/hidden/res/values-night/styles.xml b/java/com/android/dialer/theme/hidden/res/values-night/styles.xml
new file mode 100644
index 0000000..e857e68
--- /dev/null
+++ b/java/com/android/dialer/theme/hidden/res/values-night/styles.xml
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+  <!-- Update to Theme.AppCompat.Light.NoActionBar once we no longer depend on ActionBars. -->
+  <style name="Dialer" parent="Theme.AppCompat.Light">
+    <!-- Used to automatically style all buttons in Dialer -->
+    <item name="android:textAppearanceButton">@style/DialerButtonTextStyle</item>
+    <item name="android:colorButtonNormal">?android:attr/colorPrimary</item>
+
+    <!-- Used to style link text -->
+    <item name="android:textColorLink">@color/dialer_theme_color</item>
+
+    <!-- Used to automatically style AlertDialogs -->
+    <item name="alertDialogTheme">@style/AlertDialogTheme</item>
+    <item name="android:alertDialogTheme">@style/AlertDialogTheme</item>
+  </style>
+
+  <style name="Dialer.Dark" parent="Theme.AppCompat">
+    <!-- Used to automatically style all buttons in Dialer -->
+    <item name="android:textAppearanceButton">@style/DialerButtonTextStyle</item>
+    <item name="android:colorButtonNormal">?android:attr/colorPrimary</item>
+
+    <!-- Used to style link text -->
+    <item name="android:textColorLink">@color/dialer_theme_color</item>
+
+    <!-- Used to automatically style AlertDialogs -->
+    <item name="alertDialogTheme">@style/AlertDialogTheme</item>
+    <item name="android:alertDialogTheme">@style/AlertDialogTheme</item>
+  </style>
+
+  <!-- Used to style all Dialer's button's text. Every button is awarded this for free if the parent
+     activity's theme extends from Dialer.ThemeBase(.NoActionBar) or doesn't specify a theme. -->
+  <style name="DialerButtonTextStyle" parent="@android:style/TextAppearance.DeviceDefault.Widget.Button">
+    <item name="android:textColor">?android:attr/textColorPrimaryInverse</item>
+  </style>
+
+  <!-- Used to style all Dialer's AlertDialogs. Every button is awarded this for free if the parent
+     activity's theme extends from Dialer.ThemeBase(.NoActionBar) or doesn't specify a theme. -->
+  <style name="AlertDialogTheme" parent="@android:style/Theme.DeviceDefault.Dialog.Alert">
+    <item name="android:textColorPrimary">@color/dialer_primary_text_color</item>
+    <!-- TODO(a bug): figure out why ?android:attr/colorPrimary doesn't work here -->
+    <item name="android:colorAccent">@color/dialer_theme_color</item>
+    <item name="colorAccent">@color/dialer_theme_color</item>
+    <item name="android:textColorSecondary">@color/dialer_secondary_text_color</item>
+  </style>
+</resources>
diff --git a/java/com/android/dialer/theme/hidden/res/values/styles.xml b/java/com/android/dialer/theme/hidden/res/values/styles.xml
index 44a35f8..97190b0 100644
--- a/java/com/android/dialer/theme/hidden/res/values/styles.xml
+++ b/java/com/android/dialer/theme/hidden/res/values/styles.xml
@@ -50,7 +50,7 @@
 
   <!-- Used to style all Dialer's AlertDialogs. Every button is awarded this for free if the parent
      activity's theme extends from Dialer.ThemeBase(.NoActionBar) or doesn't specify a theme. -->
-  <style name="AlertDialogTheme" parent="Theme.AppCompat.Light.Dialog.Alert">
+  <style name="AlertDialogTheme" parent="@android:style/Theme.DeviceDefault.Light.Dialog.Alert">
     <item name="android:textColorPrimary">@color/dialer_primary_text_color</item>
     <!-- TODO(a bug): figure out why ?android:attr/colorPrimary doesn't work here -->
     <item name="android:colorAccent">@color/dialer_theme_color</item>
diff --git a/java/com/android/dialer/voicemail/listui/res/values-night/colors.xml b/java/com/android/dialer/voicemail/listui/res/values-night/colors.xml
new file mode 100644
index 0000000..2e400b0
--- /dev/null
+++ b/java/com/android/dialer/voicemail/listui/res/values-night/colors.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2018 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+  <color name="voicemail_icon_disabled_tint">#80ffffff</color>
+</resources>
diff --git a/java/com/android/incallui/ProximitySensor.java b/java/com/android/incallui/ProximitySensor.java
index 9719e5d..50c741f 100644
--- a/java/com/android/incallui/ProximitySensor.java
+++ b/java/com/android/incallui/ProximitySensor.java
@@ -17,6 +17,7 @@
 package com.android.incallui;
 
 import android.content.Context;
+import android.content.SharedPreferences;
 import android.hardware.display.DisplayManager;
 import android.hardware.display.DisplayManager.DisplayListener;
 import android.os.PowerManager;
@@ -31,6 +32,7 @@
 import com.android.incallui.audiomode.AudioModeProvider.AudioModeListener;
 import com.android.incallui.call.CallList;
 import com.android.incallui.call.DialerCall;
+import android.preference.PreferenceManager;
 
 /**
  * Class manages the proximity sensor for the in-call UI. We enable the proximity sensor while the
@@ -43,6 +45,7 @@
     implements AccelerometerListener.OrientationListener, InCallStateListener, AudioModeListener {
 
   private static final String TAG = ProximitySensor.class.getSimpleName();
+  private static final String PREF_KEY_DISABLE_PROXI_SENSOR = "disable_proximity_sensor_key";
 
   private final PowerManager powerManager;
   private final PowerManager.WakeLock proximityWakeLock;
@@ -56,12 +59,14 @@
   private boolean isAttemptingVideoCall;
   private boolean isVideoCall;
   private boolean isRttCall;
+  private final Context mContext;
 
   public ProximitySensor(
       @NonNull Context context,
       @NonNull AudioModeProvider audioModeProvider,
       @NonNull AccelerometerListener accelerometerListener) {
     Trace.beginSection("ProximitySensor.Constructor");
+    mContext = context;
     powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
     if (powerManager.isWakeLockLevelSupported(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK)) {
       proximityWakeLock =
@@ -217,6 +222,14 @@
     Trace.beginSection("ProximitySensor.updateProximitySensorMode");
     final int audioRoute = audioModeProvider.getAudioState().getRoute();
 
+    boolean isProximitySensorDisabled = false;
+    try {
+        final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext);
+        isProximitySensorDisabled = prefs.getBoolean(PREF_KEY_DISABLE_PROXI_SENSOR, false);
+    } catch (Exception e) {
+        // when called befoire first unlock
+    }
+
     boolean screenOnImmediately =
         (CallAudioState.ROUTE_WIRED_HEADSET == audioRoute
             || CallAudioState.ROUTE_SPEAKER == audioRoute
@@ -240,15 +253,17 @@
     LogUtil.i(
         "ProximitySensor.updateProximitySensorMode",
         "screenOnImmediately: %b, dialPadVisible: %b, "
-            + "offHook: %b, horizontal: %b, uiShowing: %b, audioRoute: %s",
+            + "offHook: %b, horizontal: %b, uiShowing: %b, audioRoute: %s, "
+            + "isProximitySensorDisabled: %b",
         screenOnImmediately,
         dialpadVisible,
         isPhoneOffhook,
         orientation == AccelerometerListener.ORIENTATION_HORIZONTAL,
         uiShowing,
-        CallAudioState.audioRouteToString(audioRoute));
+        CallAudioState.audioRouteToString(audioRoute),
+        isProximitySensorDisabled);
 
-    if (isPhoneOffhook && !screenOnImmediately) {
+    if (isPhoneOffhook && !screenOnImmediately && !isProximitySensorDisabled) {
       LogUtil.v("ProximitySensor.updateProximitySensorMode", "turning on proximity sensor");
       // Phone is in use!  Arrange for the screen to turn off
       // automatically when the sensor detects a close object.
diff --git a/java/com/android/incallui/answer/impl/classifier/HumanInteractionClassifier.java b/java/com/android/incallui/answer/impl/classifier/HumanInteractionClassifier.java
index 494a622..5a7b426 100644
--- a/java/com/android/incallui/answer/impl/classifier/HumanInteractionClassifier.java
+++ b/java/com/android/incallui/answer/impl/classifier/HumanInteractionClassifier.java
@@ -21,6 +21,7 @@
 import android.util.DisplayMetrics;
 import android.view.MotionEvent;
 import com.android.dialer.configprovider.ConfigProviderComponent;
+import com.android.dialer.R;
 
 /** An classifier trying to determine whether it is a human interacting with the phone or not. */
 class HumanInteractionClassifier extends Classifier {
@@ -35,6 +36,8 @@
 
   HumanInteractionClassifier(Context context) {
     DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
+    final boolean defaultValue = context.getResources().getBoolean(
+                R.bool.config_answerAntiFalsingClassifierEnabled);
 
     // If the phone is rotated to landscape, the calculations would be wrong if xdpi and ydpi
     // were to be used separately. Due negligible differences in xdpi and ydpi we can just
@@ -46,7 +49,7 @@
     enabled =
         ConfigProviderComponent.get(context)
             .getConfigProvider()
-            .getBoolean(CONFIG_ANSWER_FALSE_TOUCH_DETECTION_ENABLED, true);
+            .getBoolean(CONFIG_ANSWER_FALSE_TOUCH_DETECTION_ENABLED, defaultValue);
 
     strokeClassifiers =
         new StrokeClassifier[] {
diff --git a/java/com/android/incallui/theme/res/values-night/colors.xml b/java/com/android/incallui/theme/res/values-night/colors.xml
new file mode 100644
index 0000000..c2b50f2
--- /dev/null
+++ b/java/com/android/incallui/theme/res/values-night/colors.xml
@@ -0,0 +1,28 @@
+<?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>
+  <color name="conference_call_manager_caller_name_text_color">#4d4d4d</color>
+  <!-- Used with some smaller texts in manage conference screen. -->
+  <color name="conference_call_manager_secondary_text_color">#999999</color>
+
+  <color name="incall_dialpad_background">@*android:color/primary_dark_device_default_settings</color>
+
+  <!-- Background color for status bar. For portrait this will be ignored. -->
+  <color name="statusbar_background_color">?android:attr/colorPrimary</color>
+
+</resources>
diff --git a/java/com/android/incallui/theme/res/values/styles.xml b/java/com/android/incallui/theme/res/values/styles.xml
index 5b65cc3..63c752a 100644
--- a/java/com/android/incallui/theme/res/values/styles.xml
+++ b/java/com/android/incallui/theme/res/values/styles.xml
@@ -39,8 +39,8 @@
     <item name="android:statusBarColor">@android:color/transparent</item>
     <item name="android:navigationBarColor">@android:color/transparent</item>
     <item name="android:windowDrawsSystemBarBackgrounds">true</item>
-    <item name="android:colorPrimaryDark">@color/dialer_theme_color_dark</item>
-    <item name="colorPrimaryDark">@color/dialer_theme_color_dark</item>
+    <item name="android:colorPrimaryDark">@color/dialer_theme_color</item>
+    <item name="colorPrimaryDark">@color/dialer_theme_color</item>
 
     <item name="dialpad_key_button_touch_tint">?attr/colorPrimary20pct</item>
     <item name="dialpad_style">@style/InCallDialpad</item>
