diff --git a/java/com/android/contacts/common/res/color/popup_menu_color.xml b/java/com/android/contacts/common/res/color/popup_menu_color.xml
deleted file mode 100644
index c52bd5b..0000000
--- a/java/com/android/contacts/common/res/color/popup_menu_color.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2014 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-  <item android:alpha="0.5" android:color="#ff000000" android:state_enabled="false"/>
-  <item android:color="#ff000000"/>
-</selector>
\ No newline at end of file
diff --git a/java/com/android/contacts/common/res/drawable/ic_more_vert.xml b/java/com/android/contacts/common/res/drawable/ic_more_vert.xml
deleted file mode 100644
index fcc3d9e..0000000
--- a/java/com/android/contacts/common/res/drawable/ic_more_vert.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-  android:height="24dp"
-  android:viewportHeight="24.0"
-  android:viewportWidth="24.0"
-  android:width="24dp">
-  <path
-    android:fillColor="#FF000000"
-    android:pathData="M12 8c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2zm0 2c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2zm0 6c-1.1 0-2 .9-2 2s.9 2 2 2 2-.9 2-2-.9-2-2-2z"/>
-</vector>
diff --git a/java/com/android/contacts/common/res/layout/account_selector_list_item.xml b/java/com/android/contacts/common/res/layout/account_selector_list_item.xml
deleted file mode 100644
index 587626e..0000000
--- a/java/com/android/contacts/common/res/layout/account_selector_list_item.xml
+++ /dev/null
@@ -1,57 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2010 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-  android:layout_width="match_parent"
-  android:layout_height="?android:attr/listPreferredItemHeight"
-  android:orientation="horizontal">
-  <ImageView
-    android:id="@android:id/icon"
-    android:layout_width="@dimen/detail_network_icon_size"
-    android:layout_height="@dimen/detail_network_icon_size"
-    android:layout_margin="16dip"
-    android:layout_gravity="center_vertical"/>
-
-  <LinearLayout
-    android:layout_width="0dip"
-    android:layout_height="wrap_content"
-    android:layout_weight="1"
-    android:layout_marginLeft="8dp"
-    android:layout_gravity="center_vertical"
-    android:orientation="vertical">
-
-    <TextView
-      android:id="@android:id/text1"
-      android:layout_width="wrap_content"
-      android:layout_height="wrap_content"
-      android:layout_marginEnd="8dip"
-      android:layout_marginRight="8dip"
-      android:ellipsize="end"
-      android:singleLine="true"
-      android:textAppearance="?android:attr/textAppearanceMedium"/>
-
-    <TextView
-      android:id="@android:id/text2"
-      android:layout_width="wrap_content"
-      android:layout_height="wrap_content"
-      android:layout_marginEnd="8dip"
-      android:layout_marginRight="8dip"
-      android:ellipsize="end"
-      android:singleLine="true"
-      android:textAppearance="?android:attr/textAppearanceSmall"
-      android:textColor="?android:attr/textColorSecondary"/>
-  </LinearLayout>
-</LinearLayout>
diff --git a/java/com/android/contacts/common/res/layout/account_selector_list_item_condensed.xml b/java/com/android/contacts/common/res/layout/account_selector_list_item_condensed.xml
deleted file mode 100644
index 3382116..0000000
--- a/java/com/android/contacts/common/res/layout/account_selector_list_item_condensed.xml
+++ /dev/null
@@ -1,56 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2015 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-  android:layout_width="match_parent"
-  android:layout_height="?android:attr/listPreferredItemHeight"
-  android:orientation="horizontal">
-  <ImageView
-    android:id="@android:id/icon"
-    android:layout_width="@dimen/detail_network_icon_size"
-    android:layout_height="@dimen/detail_network_icon_size"
-    android:layout_margin="24dip"
-    android:layout_gravity="center_vertical"/>
-
-  <LinearLayout
-    android:layout_width="wrap_content"
-    android:layout_height="wrap_content"
-    android:layout_weight="1"
-    android:layout_gravity="center_vertical"
-    android:orientation="vertical">
-
-    <TextView
-      android:id="@android:id/text1"
-      android:layout_width="wrap_content"
-      android:layout_height="wrap_content"
-      android:layout_marginEnd="8dip"
-      android:layout_marginRight="8dip"
-      android:ellipsize="end"
-      android:singleLine="true"
-      android:textAppearance="?android:attr/textAppearanceMedium"/>
-
-    <TextView
-      android:id="@android:id/text2"
-      android:layout_width="wrap_content"
-      android:layout_height="wrap_content"
-      android:layout_marginEnd="8dip"
-      android:layout_marginRight="8dip"
-      android:ellipsize="end"
-      android:singleLine="true"
-      android:textAppearance="?android:attr/textAppearanceSmall"
-      android:textColor="?android:attr/textColorSecondary"/>
-  </LinearLayout>
-</LinearLayout>
diff --git a/java/com/android/contacts/common/res/layout/call_subject_history.xml b/java/com/android/contacts/common/res/layout/call_subject_history.xml
deleted file mode 100644
index 733f1d8..0000000
--- a/java/com/android/contacts/common/res/layout/call_subject_history.xml
+++ /dev/null
@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2015 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-
-<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
-  android:id="@+id/background"
-  android:layout_width="match_parent"
-  android:layout_height="match_parent"
-  android:background="@android:color/transparent">
-
-  <ListView
-    android:id="@+id/subject_list"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:layout_alignParentBottom="true"
-    android:background="@color/call_subject_history_background"
-    android:divider="@null"
-    android:elevation="8dp"/>
-
-</RelativeLayout>
\ No newline at end of file
diff --git a/java/com/android/contacts/common/res/layout/list_separator.xml b/java/com/android/contacts/common/res/layout/list_separator.xml
deleted file mode 100644
index ab60605..0000000
--- a/java/com/android/contacts/common/res/layout/list_separator.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2008 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-<TextView
-  xmlns:android="http://schemas.android.com/apk/res/android"
-  android:id="@+id/title"
-  android:textStyle="bold"
-  android:paddingTop="16dip"
-  android:paddingBottom="15dip"
-  android:paddingStart="16dip"
-  android:paddingEnd="16dip"
-  android:paddingLeft="16dip"
-  android:paddingRight="16dip"
-  android:textColor="@color/frequently_contacted_title_color"
-  android:textSize="@dimen/frequently_contacted_title_text_size"/>
diff --git a/java/com/android/contacts/common/res/values-ja/donottranslate_config.xml b/java/com/android/contacts/common/res/values-ja/donottranslate_config.xml
index e05c6d6..29512c0 100644
--- a/java/com/android/contacts/common/res/values-ja/donottranslate_config.xml
+++ b/java/com/android/contacts/common/res/values-ja/donottranslate_config.xml
@@ -1,4 +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
+  -->
+
 <resources>
   <!-- If true, an option is shown in Display Options UI to choose a sort order -->
   <bool name="config_sort_order_user_changeable">false</bool>
@@ -14,7 +30,4 @@
 
   <!-- If true, the order of name fields in the editor is primary (i.e. given name first) -->
   <bool name="config_editor_field_order_primary">false</bool>
-
-  <!-- If true, phonetic name is included in the contact editor by default -->
-  <bool name="config_editor_include_phonetic_name">true</bool>
 </resources>
\ No newline at end of file
diff --git a/java/com/android/contacts/common/res/values-sw600dp/dimens.xml b/java/com/android/contacts/common/res/values-sw600dp/dimens.xml
index cf67a1e..e5773b4 100644
--- a/java/com/android/contacts/common/res/values-sw600dp/dimens.xml
+++ b/java/com/android/contacts/common/res/values-sw600dp/dimens.xml
@@ -15,12 +15,9 @@
   -->
 
 <resources>
-  <dimen name="detail_item_side_margin">0dip</dimen>
-
   <dimen name="contact_browser_list_header_left_margin">@dimen/list_visible_scrollbar_padding
   </dimen>
   <dimen name="contact_browser_list_header_right_margin">24dip</dimen>
-  <dimen name="contact_browser_list_top_margin">16dip</dimen>
 
   <!-- Right margin of the floating action button -->
   <dimen name="floating_action_button_margin_right">32dp</dimen>
diff --git a/java/com/android/contacts/common/res/values/colors.xml b/java/com/android/contacts/common/res/values/colors.xml
index ca87341..1f46233 100644
--- a/java/com/android/contacts/common/res/values/colors.xml
+++ b/java/com/android/contacts/common/res/values/colors.xml
@@ -15,11 +15,6 @@
   -->
 
 <resources>
-  <!-- Background color corresponding to the holo list 9-patch. -->
-  <color name="holo_list_background_color">#eeeeee</color>
-
-  <color name="focus_color">#44ff0000</color>
-
   <!-- Color of ripples used for views with dark backgrounds -->
   <color name="dialer_ripple_material_dark">#a0ffffff</color>
 
@@ -34,29 +29,9 @@
   <!-- Text color for section header. -->
   <color name="section_header_text_color">#2A56C6</color>
 
-  <!-- Divider color for header separator -->
-  <color name="main_header_separator_color">#AAAAAA</color>
-
-  <!-- Divider color for header separator -->
-  <color name="secondary_header_separator_color">#D0D0D0</color>
-
   <!-- Color of the theme of the People app -->
   <color name="people_app_theme_color">#363636</color>
 
-  <!-- Color of image view placeholder. -->
-  <color name="image_placeholder">#DDDDDD</color>
-
-  <!--  Color of the semi-transparent shadow box on contact tiles -->
-  <color name="contact_tile_shadow_box_color">#7F000000</color>
-
-  <!--  Color of the status message for starred contacts in the People app -->
-  <color name="people_contact_tile_status_color">#CCCCCC</color>
-
-  <color name="shortcut_overlay_text_background">#7f000000</color>
-
-  <color name="textColorIconOverlay">#fff</color>
-  <color name="textColorIconOverlayShadow">#000</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">
@@ -76,18 +51,7 @@
     <item>#424242</item>
   </array>
 
-  <!-- The default color used for tinting photos when no color can be extracted via Palette,
-          this is Blue Grey 500 -->
-  <color name="quickcontact_default_photo_tint_color">#607D8B</color>
-  <!-- The default secondary color when no color can be extracted via Palette,
-          this is Blue Grey 700 -->
-  <color name="quickcontact_default_photo_tint_color_dark">#455A64</color>
-
   <color name="contactscommon_actionbar_background_color">@color/dialer_theme_color</color>
-  <!-- Color for icons in the actionbar -->
-  <color name="actionbar_icon_color">#ffffff</color>
-  <!-- Darker version of the actionbar color. Used for the status bar and navigation bar colors. -->
-  <color name="actionbar_background_color_dark">#008aa1</color>
 
   <color name="tab_ripple_color">#ffffff</color>
   <color name="tab_accent_color">@color/tab_ripple_color</color>
diff --git a/java/com/android/contacts/common/res/values/dimens.xml b/java/com/android/contacts/common/res/values/dimens.xml
index 74e1547..19b27b8 100644
--- a/java/com/android/contacts/common/res/values/dimens.xml
+++ b/java/com/android/contacts/common/res/values/dimens.xml
@@ -14,7 +14,7 @@
   ~ limitations under the License
   -->
 
-<resources>
+<resources xmlns:tools="http://schemas.android.com/tools">
 
   <!-- Padding between the action bar's bottom edge and the first header
        in contacts/group lists. -->
@@ -28,24 +28,6 @@
   <dimen name="directory_header_extra_top_padding">18dp</dimen>
   <dimen name="directory_header_extra_bottom_padding">8dp</dimen>
 
-  <!--  Horizontal padding in between contact tiles -->
-  <dimen name="contact_tile_divider_padding">23dip</dimen>
-  <!--  Horizontal whitespace (both padding and margin) before the first tile and after the last tile -->
-  <dimen name="contact_tile_start_end_whitespace">16dip</dimen>
-
-  <!-- Left and right padding for a contact detail item -->
-  <dimen name="detail_item_side_margin">16dip</dimen>
-
-  <!-- ContactTile Layouts -->
-  <!--
-    Use sp instead of dip so that the shadowbox heights can all scale uniformly
-    when the font size is scaled for accessibility purposes
-  -->
-  <dimen name="contact_tile_shadowbox_height">48sp</dimen>
-
-  <!-- Top padding of the ListView in the contact tile list -->
-  <dimen name="contact_tile_list_padding_top">0dip</dimen>
-
   <!-- Padding to be used between a visible scrollbar and the contact list -->
   <dimen name="list_visible_scrollbar_padding">32dip</dimen>
 
@@ -56,32 +38,10 @@
   <!-- Width of a contact list item section header. -->
   <dimen name="contact_list_section_header_width">56dp</dimen>
 
-  <!-- Size of the shortcut icon. 0dip means: use the system default -->
-  <dimen name="shortcut_icon_size">0dip</dimen>
-
-  <!-- Text size of shortcut icon overlay text -->
-  <dimen name="shortcut_overlay_text_size">12dp</dimen>
-
-  <!-- Extra vertical padding for darkened background behind shortcut icon overlay text -->
-  <dimen name="shortcut_overlay_text_background_padding">1dp</dimen>
-
-  <!-- Width of height of an icon from a third-party app in the networks section of the contact card. -->
-  <dimen name="detail_network_icon_size">32dip</dimen>
-
-  <!-- Empty message margins -->
-  <dimen name="empty_message_top_margin">48dip</dimen>
-
   <!-- contact browser list margins -->
   <dimen name="contact_browser_list_item_text_size">16sp</dimen>
   <dimen name="contact_browser_list_item_photo_size">40dp</dimen>
   <dimen name="contact_browser_list_item_gap_between_image_and_text">15dp</dimen>
-  <dimen name="contact_browser_list_top_margin">12dp</dimen>
-
-  <!-- Dimensions for "No contacts" string in PhoneFavoriteFragment for the All contacts
-       with phone numbers section
-  -->
-  <dimen name="contact_phone_list_empty_description_size">20sp</dimen>
-  <dimen name="contact_phone_list_empty_description_padding">10dip</dimen>
 
   <!-- Height of the floating action button -->
   <dimen name="floating_action_button_height">56dp</dimen>
@@ -109,8 +69,6 @@
   <dimen name="tab_unread_count_text_size">12sp</dimen>
   <dimen name="tab_unread_count_text_padding">2dp</dimen>
 
-  <!-- Padding around the icon in the search box. -->
-  <dimen name="search_box_icon_margin">4dp</dimen>
   <!-- Size of the icon (voice search, back arrow) in the search box. -->
   <dimen name="search_box_icon_size">48dp</dimen>
   <!-- Size of the close icon.-->
@@ -124,17 +82,6 @@
   <!-- Search box text size -->
   <dimen name="search_text_size">20sp</dimen>
 
-  <!-- Top margin for the Frequently Contacted section title -->
-  <dimen name="frequently_contacted_title_top_margin_when_first_row">16dp</dimen>
-  <!-- Top margin for the Frequently Contacted section title, when the title is the first
-       item in the list -->
-  <dimen name="frequently_contacted_title_top_margin">57dp</dimen>
-
-  <dimen name="frequently_contacted_title_text_size">24sp</dimen>
-
-  <!-- Size of icon for contacts number shortcuts -->
-  <dimen name="search_shortcut_radius">40dp</dimen>
-
   <dimen name="contact_list_card_elevation">2dp</dimen>
 
   <!-- Padding used around the periphery of the call subject dialog, as well as in between the
diff --git a/java/com/android/contacts/common/res/values/donottranslate_config.xml b/java/com/android/contacts/common/res/values/donottranslate_config.xml
index 3244379..f37e0b8 100644
--- a/java/com/android/contacts/common/res/values/donottranslate_config.xml
+++ b/java/com/android/contacts/common/res/values/donottranslate_config.xml
@@ -15,9 +15,6 @@
   -->
 
 <resources>
-  <!-- Flag indicating whether Contacts app is allowed to import contacts -->
-  <bool name="config_allow_import_from_vcf_file">true</bool>
-
   <!-- If true, an option is shown in Display Options UI to choose a sort order -->
   <bool name="config_sort_order_user_changeable">true</bool>
 
@@ -41,55 +38,4 @@
 
   <!-- Contacts preferences key for contact editor anything saved -->
   <string name="contact_editor_anything_saved_key">ContactEditorUtils_anything_saved</string>
-
-  <!-- The type of VCard for export. If you want to let the app emit vCard which is
-  specific to some vendor (like DoCoMo), specify this type (e.g. "docomo") -->
-  <string name="config_export_vcard_type" translatable="false">default</string>
-
-  <!-- The type of vcard for improt. If the vcard importer cannot guess the exact type
-  of a vCard type, the improter uses this type. -->
-  <string name="config_import_vcard_type" translatable="false">default</string>
-
-  <!-- Prefix of exported VCard file -->
-  <string name="config_export_file_prefix" translatable="false"></string>
-
-  <!-- Suffix of exported VCard file. Attached before an extension -->
-  <string name="config_export_file_suffix" translatable="false"></string>
-
-  <!-- Extension for exported VCard files -->
-  <string name="config_export_file_extension">vcf</string>
-
-  <!-- The filename that is suggested that users use when exporting vCards. Should include the .vcf extension. -->
-  <string name="exporting_vcard_filename" translatable="false">contacts.vcf</string>
-
-  <!-- Minimum number of exported VCard file index -->
-  <integer name="config_export_file_min_index">1</integer>
-
-  <!-- Maximum number of exported VCard file index -->
-  <integer name="config_export_file_max_index">99999</integer>
-
-  <!-- The list (separated by ',') of extensions should be checked in addition to
-   config_export_extension. e.g. If "aaa" is added to here and 00001.vcf and 00002.aaa
-   exist in a target directory, 00003.vcf becomes a next file name candidate.
-   Without this configuration, 00002.vcf becomes the candidate.-->
-  <string name="config_export_extensions_to_consider" translatable="false"></string>
-
-  <!-- If true, enable the "import contacts from SIM" feature if the device
-       has an appropriate SIM or ICC card.
-       Setting this flag to false in a resource overlay allows you to
-       entirely disable SIM import on a per-product basis. -->
-  <bool name="config_allow_sim_import">true</bool>
-
-  <!-- Flag indicating whether Contacts app is allowed to export contacts -->
-  <bool name="config_allow_export">true</bool>
-
-  <!-- Flag indicating whether Contacts app is allowed to share contacts with devices outside -->
-  <bool name="config_allow_share_contacts">true</bool>
-
-  <string name="pref_build_version_key">pref_build_version</string>
-  <string name="pref_open_source_licenses_key">pref_open_source_licenses</string>
-  <string name="pref_privacy_policy_key">pref_privacy_policy</string>
-  <string name="pref_terms_of_service_key">pref_terms_of_service</string>
-
-  <string name="star_sign">★</string>
 </resources>
diff --git a/java/com/android/contacts/common/res/values/integers.xml b/java/com/android/contacts/common/res/values/integers.xml
index d38ad1d..f4ed5c2 100644
--- a/java/com/android/contacts/common/res/values/integers.xml
+++ b/java/com/android/contacts/common/res/values/integers.xml
@@ -19,7 +19,6 @@
 
   <!--  Determines the number of columns in a ContactTileRow in the favorites tab -->
   <integer name="contact_tile_column_count_in_favorites">2</integer>
-  <integer name="contact_tile_column_count_in_favorites_new">3</integer>
 
   <!-- The number of characters in the snippet before we need to tokenize and ellipse. -->
   <integer name="snippet_length_before_tokenize">30</integer>
@@ -33,7 +32,4 @@
 
   <!-- Duration of the animations on the call subject dialog. -->
   <integer name="call_subject_animation_duration">250</integer>
-
-  <!-- A big number to make sure "About contacts" always showing at the bottom of Settings.-->
-  <integer name="about_contacts_order_number">100</integer>
 </resources>
diff --git a/java/com/android/dialer/about/Licenses.java b/java/com/android/dialer/about/Licenses.java
index d90c282..bd3d0ce 100644
--- a/java/com/android/dialer/about/Licenses.java
+++ b/java/com/android/dialer/about/Licenses.java
@@ -73,7 +73,7 @@
     // When aapt is called with --rename-manifest-package, the package name is changed for the
     // application, but not for the resources. This is to find the package name of a known
     // resource to know what package to lookup the license files in.
-    String packageName = resources.getResourcePackageName(R.id.dummy_placeholder);
+    String packageName = resources.getResourcePackageName(R.id.license);
     InputStream stream =
         resources.openRawResource(resources.getIdentifier(filename, "raw", packageName));
     return getTextFromInputStream(stream, offset, length);
diff --git a/java/com/android/dialer/about/res/layout/dummy_placeholder.xml b/java/com/android/dialer/about/res/layout/dummy_placeholder.xml
deleted file mode 100644
index 6d867ef..0000000
--- a/java/com/android/dialer/about/res/layout/dummy_placeholder.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?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
-  -->
-<!-- See Licenses.java for why this exists. -->
-<TextView xmlns:android="http://schemas.android.com/apk/res/android"
-          android:id="@+id/dummy_placeholder"
-          android:layout_width="wrap_content"
-          android:layout_height="wrap_content" />
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_archive_white_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_archive_white_24dp.png
deleted file mode 100644
index bb72e89..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_archive_white_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_content_copy_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_content_copy_24dp.png
deleted file mode 100644
index 70eb073..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_content_copy_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_delete_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_delete_24dp.png
deleted file mode 100644
index 9fb43b0..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_delete_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_grade_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_grade_24dp.png
deleted file mode 100644
index 86eecdd..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_grade_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_more_vert_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_more_vert_24dp.png
deleted file mode 100644
index 67f07e4..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_more_vert_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_pause_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_pause_24dp.png
deleted file mode 100644
index 4d2ea05..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_pause_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_people_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_people_24dp.png
deleted file mode 100644
index ff698af..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_people_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_play_arrow_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_play_arrow_24dp.png
deleted file mode 100644
index 57c9fa5..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_play_arrow_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_schedule_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_schedule_24dp.png
deleted file mode 100644
index f3581d1..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_schedule_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_share_white_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_share_white_24dp.png
deleted file mode 100644
index b09a692..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_share_white_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_vm_sound_off_dis.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_vm_sound_off_dis.png
deleted file mode 100644
index 47e3249..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_vm_sound_off_dis.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_vm_sound_off_dk.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_vm_sound_off_dk.png
deleted file mode 100644
index 2bfe0c0..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_vm_sound_off_dk.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_vm_sound_on_dis.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_vm_sound_on_dis.png
deleted file mode 100644
index 90b5238..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_vm_sound_on_dis.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_vm_sound_on_dk.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_vm_sound_on_dk.png
deleted file mode 100644
index 7556637..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_vm_sound_on_dk.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_voicemail_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_voicemail_24dp.png
deleted file mode 100644
index 03a62e1..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_voicemail_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_volume_down_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_volume_down_24dp.png
deleted file mode 100644
index e22e92c..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_volume_down_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_volume_up_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_volume_up_24dp.png
deleted file mode 100644
index 57d7871..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_volume_up_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-mdpi/ic_vm_sound_off_dis.png b/java/com/android/dialer/app/res/drawable-mdpi/ic_vm_sound_off_dis.png
deleted file mode 100644
index 4c671ec..0000000
--- a/java/com/android/dialer/app/res/drawable-mdpi/ic_vm_sound_off_dis.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-mdpi/ic_vm_sound_off_dk.png b/java/com/android/dialer/app/res/drawable-mdpi/ic_vm_sound_off_dk.png
deleted file mode 100644
index 41044b4..0000000
--- a/java/com/android/dialer/app/res/drawable-mdpi/ic_vm_sound_off_dk.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-mdpi/ic_vm_sound_on_dis.png b/java/com/android/dialer/app/res/drawable-mdpi/ic_vm_sound_on_dis.png
deleted file mode 100644
index c6040c0..0000000
--- a/java/com/android/dialer/app/res/drawable-mdpi/ic_vm_sound_on_dis.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-mdpi/ic_vm_sound_on_dk.png b/java/com/android/dialer/app/res/drawable-mdpi/ic_vm_sound_on_dk.png
deleted file mode 100644
index ac6a69c..0000000
--- a/java/com/android/dialer/app/res/drawable-mdpi/ic_vm_sound_on_dk.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xhdpi/ic_vm_sound_off_dis.png b/java/com/android/dialer/app/res/drawable-xhdpi/ic_vm_sound_off_dis.png
deleted file mode 100644
index 36b5e20..0000000
--- a/java/com/android/dialer/app/res/drawable-xhdpi/ic_vm_sound_off_dis.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xhdpi/ic_vm_sound_off_dk.png b/java/com/android/dialer/app/res/drawable-xhdpi/ic_vm_sound_off_dk.png
deleted file mode 100644
index 99d7fd5..0000000
--- a/java/com/android/dialer/app/res/drawable-xhdpi/ic_vm_sound_off_dk.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xhdpi/ic_vm_sound_on_dis.png b/java/com/android/dialer/app/res/drawable-xhdpi/ic_vm_sound_on_dis.png
deleted file mode 100644
index 468023d..0000000
--- a/java/com/android/dialer/app/res/drawable-xhdpi/ic_vm_sound_on_dis.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xhdpi/ic_vm_sound_on_dk.png b/java/com/android/dialer/app/res/drawable-xhdpi/ic_vm_sound_on_dk.png
deleted file mode 100644
index 9703294..0000000
--- a/java/com/android/dialer/app/res/drawable-xhdpi/ic_vm_sound_on_dk.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xxhdpi/ic_vm_sound_off_dis.png b/java/com/android/dialer/app/res/drawable-xxhdpi/ic_vm_sound_off_dis.png
deleted file mode 100644
index bab4a43..0000000
--- a/java/com/android/dialer/app/res/drawable-xxhdpi/ic_vm_sound_off_dis.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xxhdpi/ic_vm_sound_off_dk.png b/java/com/android/dialer/app/res/drawable-xxhdpi/ic_vm_sound_off_dk.png
deleted file mode 100644
index 1c13101..0000000
--- a/java/com/android/dialer/app/res/drawable-xxhdpi/ic_vm_sound_off_dk.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xxhdpi/ic_vm_sound_on_dis.png b/java/com/android/dialer/app/res/drawable-xxhdpi/ic_vm_sound_on_dis.png
deleted file mode 100644
index ed3a173..0000000
--- a/java/com/android/dialer/app/res/drawable-xxhdpi/ic_vm_sound_on_dis.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xxhdpi/ic_vm_sound_on_dk.png b/java/com/android/dialer/app/res/drawable-xxhdpi/ic_vm_sound_on_dk.png
deleted file mode 100644
index c04b8d1..0000000
--- a/java/com/android/dialer/app/res/drawable-xxhdpi/ic_vm_sound_on_dk.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable/background_dial_holo_dark.xml b/java/com/android/dialer/app/res/drawable/background_dial_holo_dark.xml
deleted file mode 100644
index 35afbe0..0000000
--- a/java/com/android/dialer/app/res/drawable/background_dial_holo_dark.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?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.
--->
-
-<shape xmlns:android="http://schemas.android.com/apk/res/android">
-  <gradient
-    android:angle="270"
-    android:endColor="#ff0a242d"
-    android:startColor="#ff020709"/>
-</shape>
diff --git a/java/com/android/dialer/app/res/drawable/ic_speakerphone_off.xml b/java/com/android/dialer/app/res/drawable/ic_speakerphone_off.xml
deleted file mode 100644
index f07d0a8..0000000
--- a/java/com/android/dialer/app/res/drawable/ic_speakerphone_off.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?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 android:drawable="@drawable/ic_vm_sound_off_dis" android:state_enabled="false"/>
-  <item android:drawable="@drawable/ic_vm_sound_off_dk"/>
-</selector>
diff --git a/java/com/android/dialer/app/res/drawable/ic_speakerphone_on.xml b/java/com/android/dialer/app/res/drawable/ic_speakerphone_on.xml
deleted file mode 100644
index 456a048..0000000
--- a/java/com/android/dialer/app/res/drawable/ic_speakerphone_on.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?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 android:drawable="@drawable/ic_vm_sound_on_dis" android:state_enabled="false"/>
-  <item android:drawable="@drawable/ic_vm_sound_on_dk"/>
-</selector>
diff --git a/java/com/android/dialer/app/res/layout/account_filter_header_for_phone_favorite.xml b/java/com/android/dialer/app/res/layout/account_filter_header_for_phone_favorite.xml
deleted file mode 100644
index c6e1862..0000000
--- a/java/com/android/dialer/app/res/layout/account_filter_header_for_phone_favorite.xml
+++ /dev/null
@@ -1,47 +0,0 @@
-<?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.
--->
-
-<!-- Layout showing the type of account filter for phone favorite screen
-     (or, new phone "all" screen).
-     This is very similar to account_filter_header.xml but different in its
-     top padding. -->
-<LinearLayout
-  xmlns:android="http://schemas.android.com/apk/res/android"
-  android:id="@+id/account_filter_header_container"
-  android:layout_width="match_parent"
-  android:layout_height="wrap_content"
-  android:layout_marginStart="@dimen/contact_browser_list_header_left_margin"
-  android:layout_marginEnd="@dimen/contact_browser_list_header_right_margin"
-  android:paddingTop="8dip"
-  android:background="?android:attr/selectableItemBackground"
-  android:orientation="vertical"
-  android:visibility="gone">
-  <TextView
-    android:id="@+id/account_filter_header"
-    style="@style/ContactListSeparatorTextViewStyle"
-    android:paddingStart="@dimen/contact_browser_list_item_text_indent"/>
-  <TextView
-    android:id="@+id/contact_list_all_empty"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:paddingTop="@dimen/contact_phone_list_empty_description_padding"
-    android:paddingBottom="@dimen/contact_phone_list_empty_description_padding"
-    android:paddingStart="8dip"
-    android:text="@string/listFoundAllContactsZero"
-    android:textColor="?android:attr/textColorSecondary"
-    android:textSize="@dimen/contact_phone_list_empty_description_size"
-    android:visibility="gone"/>
-</LinearLayout>
diff --git a/java/com/android/dialer/app/res/layout/all_contacts_activity.xml b/java/com/android/dialer/app/res/layout/all_contacts_activity.xml
deleted file mode 100644
index 72f0a14..0000000
--- a/java/com/android/dialer/app/res/layout/all_contacts_activity.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2013 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
-  android:id="@+id/all_contacts_frame"
-  android:layout_width="match_parent"
-  android:layout_height="match_parent">
-  <fragment
-    android:id="@+id/all_contacts_fragment"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    android:name="com.android.dialer.app.list.AllContactsFragment"/>
-</FrameLayout>
diff --git a/java/com/android/dialer/app/res/layout/keyguard_preview.xml b/java/com/android/dialer/app/res/layout/keyguard_preview.xml
index 41fe891..eab98d2 100644
--- a/java/com/android/dialer/app/res/layout/keyguard_preview.xml
+++ b/java/com/android/dialer/app/res/layout/keyguard_preview.xml
@@ -15,9 +15,11 @@
   ~ limitations under the License
   -->
 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-  android:layout_width="match_parent"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
   android:layout_height="match_parent"
-  android:orientation="vertical">
+  android:orientation="vertical"
+    tools:ignore="UnusedResources">
   <View
     android:layout_width="match_parent"
     android:layout_height="25dp"
diff --git a/java/com/android/dialer/app/res/values/animation_constants.xml b/java/com/android/dialer/app/res/values/animation_constants.xml
index 91230cd..4029e77 100644
--- a/java/com/android/dialer/app/res/values/animation_constants.xml
+++ b/java/com/android/dialer/app/res/values/animation_constants.xml
@@ -16,15 +16,4 @@
   -->
 <resources>
   <integer name="fade_duration">300</integer>
-
-  <!-- Swipe constants -->
-  <integer name="swipe_escape_velocity">100</integer>
-  <integer name="escape_animation_duration">200</integer>
-  <integer name="max_escape_animation_duration">400</integer>
-  <integer name="max_dismiss_velocity">2000</integer>
-  <integer name="snap_animation_duration">350</integer>
-  <integer name="swipe_scroll_slop">2</integer>
-  <dimen name="min_swipe">0dip</dimen>
-  <dimen name="min_vert">10dip</dimen>
-  <dimen name="min_lock">20dip</dimen>
 </resources>
diff --git a/java/com/android/dialer/app/res/values/colors.xml b/java/com/android/dialer/app/res/values/colors.xml
index 7a08dca..aca63d2 100644
--- a/java/com/android/dialer/app/res/values/colors.xml
+++ b/java/com/android/dialer/app/res/values/colors.xml
@@ -15,9 +15,6 @@
 -->
 
 <resources>
-  <color name="dialer_red_highlight_color">#ff1744</color>
-
-  <color name="dialer_button_text_color">#fff</color>
   <color name="dialer_flat_button_text_color">@color/dialer_theme_color</color>
 
   <!-- Color for the setting text. -->
@@ -26,7 +23,6 @@
   <color name="setting_secondary_color">@color/dialer_secondary_text_color</color>
   <color name="setting_disabled_color">#aaaaaa</color>
   <color name="setting_background_color">#ffffff</color>
-  <color name="setting_button_color">#eee</color>
 
   <!-- 54% black -->
   <color name="call_log_icon_tint">#8a000000</color>
@@ -55,33 +51,18 @@
   <!-- Background color for search results and call details -->
   <color name="background_dialer_results">#f9f9f9</color>
 
-  <!-- Color of the 1dp divider that separates favorites -->
-  <color name="favorite_contacts_separator_color">#d0d0d0</color>
-
   <!-- Color of the contact name in favorite tiles -->
   <color name="contact_tile_name_color">#ffffff</color>
 
   <color name="contact_list_name_text_color">@color/dialer_primary_text_color</color>
 
-  <!-- Undo dialogue color -->
-  <color name="undo_dialogue_text_color">#4d4d4d</color>
-
   <color name="remove_text_color">#ffffff</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>
 
-  <!-- Color of the bottom border below the contacts grid on the main dialer screen. -->
-  <color name="contacts_grid_bottom_border_color">#16000000</color>
-
-  <!-- Color of actions in expanded call log entries.  This text color represents actions such
-       as call back, play voicemail, etc. -->
-  <color name="call_log_action_text">@color/dialer_theme_color</color>
-
   <color name="dialer_dialpad_touch_tint">@color/dialer_theme_color_20pct</color>
 
-  <color name="floating_action_button_touch_tint">#80ffffff</color>
-
   <color name="call_log_action_divider">#eeeeee</color>
   <color name="divider_line_color">#D8D8D8</color>
 
@@ -92,11 +73,7 @@
   <color name="blocked_number_background">#FFFFFF</color>
   <color name="blocked_number_block_color">#F44336</color>
   <color name="blocked_number_header_color">@color/dialer_theme_color</color>
-  <color name="blocked_number_disabled_emergency_header_color">#616161</color>
   <color name="blocked_number_disabled_emergency_background_color">#E0E0E0</color>
   <color name="add_blocked_number_icon_color">#bdbdbd</color>
-  <!-- Grey 700 -->
-  <color name="call_detail_footer_text_color">#616161</color>
-  <color name="call_detail_footer_icon_tint">@color/call_detail_footer_text_color</color>
 
 </resources>
diff --git a/java/com/android/dialer/app/res/values/dimens.xml b/java/com/android/dialer/app/res/values/dimens.xml
index 4327fb9..5f252ee 100644
--- a/java/com/android/dialer/app/res/values/dimens.xml
+++ b/java/com/android/dialer/app/res/values/dimens.xml
@@ -14,9 +14,8 @@
   ~ See the License for the specific language governing permissions and
   ~ limitations under the License
 -->
-<resources>
+<resources xmlns:tools="http://schemas.android.com/tools">
   <dimen name="button_horizontal_padding">16dp</dimen>
-  <dimen name="divider_line_thickness">1dp</dimen>
 
   <!--
         Drag to remove view (in dp because it is used in conjunction with a statically
@@ -31,40 +30,15 @@
 
   <!-- Call Log -->
   <dimen name="call_log_horizontal_margin">8dp</dimen>
-  <dimen name="call_log_call_action_size">32dp</dimen>
-  <dimen name="call_log_call_action_width">54dp</dimen>
-  <dimen name="call_log_inner_margin">13dp</dimen>
   <dimen name="call_log_outer_margin">8dp</dimen>
   <dimen name="call_log_start_margin">8dp</dimen>
-  <dimen name="call_log_indent_margin">24dp</dimen>
   <dimen name="call_log_name_margin_bottom">2dp</dimen>
   <dimen name="call_log_call_account_margin_bottom">2dp</dimen>
   <dimen name="call_log_vertical_padding">8dp</dimen>
-  <dimen name="call_log_list_item_height">56dp</dimen>
   <dimen name="call_log_list_item_info_margin_start">16dp</dimen>
-  <dimen name="show_call_history_list_item_height">72dp</dimen>
 
   <!-- Size of contact photos in the call log and call details. -->
   <dimen name="contact_photo_size">48dp</dimen>
-  <dimen name="call_detail_button_spacing">2dip</dimen>
-  <dimen name="call_detail_horizontal_margin">20dp</dimen>
-  <dimen name="call_detail_top_margin">16dp</dimen>
-  <dimen name="call_detail_bottom_margin">16dp</dimen>
-  <dimen name="call_detail_header_top_margin">20dp</dimen>
-  <dimen name="call_detail_header_bottom_margin">9dp</dimen>
-  <dimen name="call_detail_elevation">0.5dp</dimen>
-  <dimen name="call_detail_action_item_padding_horizontal">28dp</dimen>
-  <dimen name="call_detail_action_item_padding_vertical">16dp</dimen>
-  <dimen name="call_detail_action_item_drawable_padding">28dp</dimen>
-  <dimen name="call_detail_action_item_text_size">16sp</dimen>
-  <dimen name="transcription_top_margin">18dp</dimen>
-  <dimen name="transcription_bottom_margin">18dp</dimen>
-
-  <!-- Size of call provider icon width and height -->
-  <dimen name="call_provider_small_icon_size">12dp</dimen>
-
-  <!-- Match call_button_height to Phone's dimens/in_call_end_button_height -->
-  <dimen name="call_button_height">74dp</dimen>
 
   <!-- Dimensions for speed dial tiles -->
   <dimen name="contact_tile_divider_width">1dp</dimen>
@@ -73,20 +47,14 @@
   <dimen name="contact_tile_text_side_padding">12dp</dimen>
   <dimen name="contact_tile_text_bottom_padding">9dp</dimen>
   <dimen name="favorites_row_top_padding">1dp</dimen>
-  <dimen name="favorites_row_bottom_padding">0dp</dimen>
   <dimen name="favorites_row_start_padding">1dp</dimen>
 
   <!-- Padding from the last contact tile will provide the end padding. -->
   <dimen name="favorites_row_end_padding">0dp</dimen>
-  <dimen name="favorites_row_undo_text_side_padding">32dp</dimen>
 
   <!-- Size of the star icon on the favorites tile. -->
   <dimen name="favorites_star_icon_size">12dp</dimen>
 
-  <!-- Padding for the tooltip -->
-  <dimen name="dismiss_button_padding_start">20dip</dimen>
-  <dimen name="dismiss_button_padding_end">28dip</dimen>
-
   <!-- Margin to the left and right of the search box. -->
   <dimen name="search_margin_horizontal">8dp</dimen>
   <!-- Margin above the search box. -->
@@ -103,16 +71,6 @@
   <dimen name="search_list_padding_top">16dp</dimen>
   <dimen name="search_box_elevation">3dp</dimen>
 
-  <!-- Padding for icons to increase their touch target. Icons are typically 24 dps in size
-       so this extra padding makes the entire touch target 40dp -->
-  <dimen name="icon_padding">8dp</dimen>
-
-  <!-- Dimensions for individual preference cards -->
-  <dimen name="preference_padding_top">16dp</dimen>
-  <dimen name="preference_padding_bottom">16dp</dimen>
-  <dimen name="preference_side_margin">16dp</dimen>
-  <dimen name="preference_summary_line_spacing_extra">4dp</dimen>
-
   <dimen name="call_log_list_item_primary_action_dimen">48dp</dimen>
 
   <!-- Dimensions for promo cards -->
@@ -136,9 +94,7 @@
   <dimen name="blocked_number_add_top_margin">8dp</dimen>
   <dimen name="blocked_number_add_bottom_margin">8dp</dimen>
   <dimen name="blocked_number_primary_text_size">16sp</dimen>
-  <dimen name="blocked_number_secondary_text_size">12sp</dimen>
   <dimen name="blocked_number_delete_icon_size">32dp</dimen>
   <dimen name="blocked_number_search_text_size">14sp</dimen>
   <dimen name="blocked_number_settings_description_text_size">14sp</dimen>
-  <dimen name="blocked_number_header_height">48dp</dimen>
 </resources>
diff --git a/java/com/android/dialer/app/res/values/donottranslate_config.xml b/java/com/android/dialer/app/res/values/donottranslate_config.xml
deleted file mode 100644
index 0d18d55..0000000
--- a/java/com/android/dialer/app/res/values/donottranslate_config.xml
+++ /dev/null
@@ -1,32 +0,0 @@
-<?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>
-
-  <!-- If true, enable vibration (haptic feedback) for dialer key presses.
-       The pattern is set on a per-platform basis using config_virtualKeyVibePattern.
-       TODO: If enough users are annoyed by this, we might eventually
-       need to make it a user preference rather than a per-platform
-        resource. -->
-  <bool name="config_enable_dialer_key_vibration">true</bool>
-
-  <!-- If true, show an onscreen "Dial" button in the dialer.
-       In practice this is used on all platforms even the ones with hard SEND/END
-       keys, but for maximum flexibility it's controlled by a flag here
-       (which can be overridden on a per-product basis.) -->
-  <bool name="config_show_onscreen_dial_button">true</bool>
-</resources>
diff --git a/java/com/android/dialer/app/res/values/styles.xml b/java/com/android/dialer/app/res/values/styles.xml
index e0122e8..d464ca7 100644
--- a/java/com/android/dialer/app/res/values/styles.xml
+++ b/java/com/android/dialer/app/res/values/styles.xml
@@ -105,19 +105,6 @@
     <item name="android:fastScrollTrackDrawable">@null</item>
   </style>
 
-  <style name="CallDetailActionItemStyle">
-    <item name="android:foreground">?android:attr/selectableItemBackground</item>
-    <item name="android:clickable">true</item>
-    <item name="android:drawablePadding">@dimen/call_detail_action_item_drawable_padding</item>
-    <item name="android:gravity">center_vertical</item>
-    <item name="android:paddingStart">@dimen/call_detail_action_item_padding_horizontal</item>
-    <item name="android:paddingEnd">@dimen/call_detail_action_item_padding_horizontal</item>
-    <item name="android:paddingTop">@dimen/call_detail_action_item_padding_vertical</item>
-    <item name="android:paddingBottom">@dimen/call_detail_action_item_padding_vertical</item>
-    <item name="android:textColor">@color/call_detail_footer_text_color</item>
-    <item name="android:textSize">@dimen/call_detail_action_item_text_size</item>
-  </style>
-
   <style name="DialtactsActionBarStyle" parent="DialerActionBarBaseStyle">
     <!-- Styles that require AppCompat compatibility, remember to update both sets -->
     <item name="android:background">@color/actionbar_background_color</item>
@@ -203,11 +190,6 @@
     <item name="android:importantForAccessibility">no</item>
   </style>
 
-  <style name="DismissButtonStyle">
-    <item name="android:paddingLeft">@dimen/dismiss_button_padding_start</item>
-    <item name="android:paddingRight">@dimen/dismiss_button_padding_end</item>
-  </style>
-
   <!-- Style applied to the "Settings" screen.  Keep in sync with SettingsLight in Telephony. -->
   <style name="SettingsStyle" parent="DialtactsThemeWithoutActionBarOverlay">
     <!-- Setting text. -->
@@ -234,10 +216,6 @@
     <item name="height">@dimen/action_bar_height</item>
   </style>
 
-  <style name="VoicemailPlaybackLayoutTextStyle">
-    <item name="android:textSize">14sp</item>
-  </style>
-
   <style name="VoicemailPlaybackLayoutButtonStyle">
     <item name="android:layout_width">56dp</item>
     <item name="android:layout_height">56dp</item>
diff --git a/java/com/android/dialer/app/res/xml/file_paths.xml b/java/com/android/dialer/app/res/xml/file_paths.xml
index 41522e4..0dd41a0 100644
--- a/java/com/android/dialer/app/res/xml/file_paths.xml
+++ b/java/com/android/dialer/app/res/xml/file_paths.xml
@@ -14,7 +14,8 @@
      limitations under the License.
 -->
 
-<paths>
+<paths xmlns:tools="http://schemas.android.com/tools"
+    tools:ignore="UnusedResources">
   <!-- Offer access to files under Context.getCacheDir() -->
   <cache-path name="my_cache"/>
   <!-- Offer access to voicemail folder under Context.getFilesDir() -->
diff --git a/java/com/android/dialer/app/res/xml/searchable.xml b/java/com/android/dialer/app/res/xml/searchable.xml
deleted file mode 100644
index 0ea1685..0000000
--- a/java/com/android/dialer/app/res/xml/searchable.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?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.
--->
-<searchable xmlns:android="http://schemas.android.com/apk/res/android"
-  android:hint="@string/dialer_hint_find_contact"
-  android:imeOptions="actionSearch"
-  android:inputType="textNoSuggestions"
-  android:label="@string/applicationLabel"
-  android:voiceSearchMode="showVoiceSearchButton|launchRecognizer"
-  />
\ No newline at end of file
diff --git a/java/com/android/dialer/app/voicemail/error/res/values/dimens.xml b/java/com/android/dialer/app/voicemail/error/res/values/dimens.xml
index dd815ca..867bd2f 100644
--- a/java/com/android/dialer/app/voicemail/error/res/values/dimens.xml
+++ b/java/com/android/dialer/app/voicemail/error/res/values/dimens.xml
@@ -16,20 +16,11 @@
   -->
 
 <resources>
-  <dimen name="alert_icon_size">24dp</dimen>
-  <dimen name="alert_start_padding">16dp</dimen>
-  <dimen name="alert_top_padding">21dp</dimen>
   <dimen name="alert_main_padding">24dp</dimen>
-  <dimen name="alert_title_padding">12dp</dimen>
-  <dimen name="alert_action_vertical_padding">4dp</dimen>
-  <dimen name="alert_action_horizontal_padding">4dp</dimen>
   <dimen name="alert_action_between_padding">11dp</dimen>
-  <dimen name="alert_line_spacing">4dp</dimen>
 
   <!-- Dimensions for promo card -->
   <dimen name="voicemail_promo_card_icon_size">24dp</dimen>
-  <dimen name="voicemail_promo_card_start_padding">16dp</dimen>
-  <dimen name="voicemail_promo_card_top_padding">21dp</dimen>
   <dimen name="voicemail_promo_card_main_padding">24dp</dimen>
   <dimen name="voicemail_promo_card_title_padding">12dp</dimen>
   <dimen name="voicemail_promo_card_action_vertical_padding">4dp</dimen>
diff --git a/java/com/android/dialer/blocking/res/drawable-hdpi/ic_block_24dp.png b/java/com/android/dialer/blocking/res/drawable-hdpi/ic_block_24dp.png
deleted file mode 100644
index 2ccc89d..0000000
--- a/java/com/android/dialer/blocking/res/drawable-hdpi/ic_block_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/blocking/res/drawable-hdpi/ic_report_24dp.png b/java/com/android/dialer/blocking/res/drawable-hdpi/ic_report_24dp.png
deleted file mode 100644
index dc0c995..0000000
--- a/java/com/android/dialer/blocking/res/drawable-hdpi/ic_report_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/blocking/res/drawable-hdpi/ic_report_white_36dp.png b/java/com/android/dialer/blocking/res/drawable-hdpi/ic_report_white_36dp.png
deleted file mode 100644
index 919a872..0000000
--- a/java/com/android/dialer/blocking/res/drawable-hdpi/ic_report_white_36dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/callcomposer/res/values/colors.xml b/java/com/android/dialer/callcomposer/res/values/colors.xml
index 89e55b7..8393c55 100644
--- a/java/com/android/dialer/callcomposer/res/values/colors.xml
+++ b/java/com/android/dialer/callcomposer/res/values/colors.xml
@@ -20,5 +20,4 @@
   <color name="call_composer_divider">#12000000</color>
   <color name="compose_and_call_background">#00BC35</color>
   <color name="gallery_item_image_color">#607D8B</color>
-  <color name="gallery_item_background_color">#ECEFF1</color>
 </resources>
\ No newline at end of file
diff --git a/java/com/android/dialer/callcomposer/res/values/dimens.xml b/java/com/android/dialer/callcomposer/res/values/dimens.xml
index 798c46f..f4c2c3b 100644
--- a/java/com/android/dialer/callcomposer/res/values/dimens.xml
+++ b/java/com/android/dialer/callcomposer/res/values/dimens.xml
@@ -32,9 +32,7 @@
   <dimen name="call_composer_media_bar_height">48dp</dimen>
 
   <!-- Send and Call button -->
-  <dimen name="send_and_call_icon_size">18dp</dimen>
   <dimen name="send_and_call_text_size">16sp</dimen>
-  <dimen name="send_and_call_padding">8dp</dimen>
   <dimen name="send_and_call_drawable_padding">4dp</dimen>
 
   <!-- Message Composer -->
diff --git a/java/com/android/dialer/calldetails/res/values/dimens.xml b/java/com/android/dialer/calldetails/res/values/dimens.xml
index 91bf70e..694c8f4 100644
--- a/java/com/android/dialer/calldetails/res/values/dimens.xml
+++ b/java/com/android/dialer/calldetails/res/values/dimens.xml
@@ -26,13 +26,11 @@
   <dimen name="call_back_button_size">48dp</dimen>
 
   <!-- call entry container -->
-  <dimen name="call_entry_icon_size">24dp</dimen>
   <dimen name="call_entry_padding">16dp</dimen>
   <dimen name="call_entry_bottom_padding">14dp</dimen>
   <dimen name="call_entry_text_left_margin">72dp</dimen>
 
   <!-- EC container -->
-  <dimen name="call_details_ec_text_size">12sp</dimen>
   <dimen name="ec_container_height">48dp</dimen>
   <dimen name="ec_photo_size">40dp</dimen>
   <dimen name="ec_divider_top_bottom_margin">8dp</dimen>
diff --git a/java/com/android/dialer/common/res/values/config.xml b/java/com/android/dialer/common/res/values/config.xml
deleted file mode 100644
index c4df279..0000000
--- a/java/com/android/dialer/common/res/values/config.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-  <bool name="spring_hd_codec">false</bool>
-</resources>
\ No newline at end of file
diff --git a/java/com/android/dialer/dialpadview/res/drawable-hdpi/ic_close_black_24dp.png b/java/com/android/dialer/dialpadview/res/drawable-hdpi/ic_close_black_24dp.png
deleted file mode 100644
index 1a9cd75..0000000
--- a/java/com/android/dialer/dialpadview/res/drawable-hdpi/ic_close_black_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/dialpadview/res/drawable-hdpi/ic_dialpad_delete.png b/java/com/android/dialer/dialpadview/res/drawable-hdpi/ic_dialpad_delete.png
deleted file mode 100644
index e588d90..0000000
--- a/java/com/android/dialer/dialpadview/res/drawable-hdpi/ic_dialpad_delete.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/dialpadview/res/drawable-hdpi/ic_dialpad_voicemail.png b/java/com/android/dialer/dialpadview/res/drawable-hdpi/ic_dialpad_voicemail.png
deleted file mode 100644
index 4706112..0000000
--- a/java/com/android/dialer/dialpadview/res/drawable-hdpi/ic_dialpad_voicemail.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/dialpadview/res/drawable-hdpi/ic_overflow_menu.png b/java/com/android/dialer/dialpadview/res/drawable-hdpi/ic_overflow_menu.png
deleted file mode 100644
index 262e9df..0000000
--- a/java/com/android/dialer/dialpadview/res/drawable-hdpi/ic_overflow_menu.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/dialpadview/res/drawable/dialpad_scrim.xml b/java/com/android/dialer/dialpadview/res/drawable/dialpad_scrim.xml
deleted file mode 100644
index ee0f40a..0000000
--- a/java/com/android/dialer/dialpadview/res/drawable/dialpad_scrim.xml
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<shape xmlns:android="http://schemas.android.com/apk/res/android">
-  <gradient
-    android:angle="270"
-    android:endColor="@android:color/darker_gray"
-    android:startColor="@android:color/transparent"/>
-</shape>
diff --git a/java/com/android/dialer/dialpadview/res/values/colors.xml b/java/com/android/dialer/dialpadview/res/values/colors.xml
index d27468d..8bea357 100644
--- a/java/com/android/dialer/dialpadview/res/values/colors.xml
+++ b/java/com/android/dialer/dialpadview/res/values/colors.xml
@@ -17,11 +17,9 @@
 <resources>
   <!-- Colors for the dialpad -->
   <color name="background_dialpad">#fcfcfc</color>
-  <color name="background_dialpad_pressed">#ececec</color>
   <color name="dialpad_primary_text_color">@color/dialer_theme_color</color>
   <color name="dialpad_secondary_text_color">#737373</color>
   <color name="dialpad_digits_text_color">#333</color>
-  <color name="dialpad_separator_line_color">#dadada</color>
   <color name="dialpad_icon_tint">#89000000</color>
   <color name="dialpad_voicemail_tint">#919191</color>
 </resources>
diff --git a/java/com/android/dialer/dialpadview/res/values/dimens.xml b/java/com/android/dialer/dialpadview/res/values/dimens.xml
index ac4c7b4..1e5880a 100644
--- a/java/com/android/dialer/dialpadview/res/values/dimens.xml
+++ b/java/com/android/dialer/dialpadview/res/values/dimens.xml
@@ -25,16 +25,12 @@
   <!-- Zero key should have less space between self and text because "+" is smaller -->
   <dimen name="dialpad_zero_key_number_default_margin_bottom">1dp</dimen>
   <dimen name="dialpad_symbol_margin_bottom">13dp</dimen>
-  <dimen name="dialpad_key_plus_size">18sp</dimen>
-  <dimen name="dialpad_horizontal_padding">5dp</dimen>
   <dimen name="dialpad_digits_text_size">34sp</dimen>
   <dimen name="dialpad_digits_text_min_size">24sp</dimen>
   <dimen name="dialpad_digits_height">60dp</dimen>
   <dimen name="dialpad_digits_padding">16dp</dimen>
   <dimen name="dialpad_digits_menu_left_padding">8dp</dimen>
   <dimen name="dialpad_digits_menu_right_padding">10dp</dimen>
-  <dimen name="dialpad_center_margin">3dp</dimen>
-  <dimen name="dialpad_button_margin">2dp</dimen>
   <dimen name="dialpad_voicemail_icon_size">18dp</dimen>
   <dimen name="dialpad_key_button_translate_y">100dp</dimen>
   <dimen name="dialpad_overflow_margin">8dp</dimen>
diff --git a/java/com/android/dialer/searchfragment/common/res/values/dimens.xml b/java/com/android/dialer/searchfragment/common/res/values/dimens.xml
index d5459dd..f666416 100644
--- a/java/com/android/dialer/searchfragment/common/res/values/dimens.xml
+++ b/java/com/android/dialer/searchfragment/common/res/values/dimens.xml
@@ -19,5 +19,4 @@
   <dimen name="search_photo_padding">8dp</dimen>
   <dimen name="call_to_action_padding">8dp</dimen>
   <dimen name="search_text_padding_start">16dp</dimen>
-  <dimen name="new_search_text_size">16sp</dimen>
 </resources>
\ No newline at end of file
diff --git a/java/com/android/dialer/theme/res/animator/button_elevation.xml b/java/com/android/dialer/theme/res/animator/button_elevation.xml
deleted file mode 100644
index 8dd019e..0000000
--- a/java/com/android/dialer/theme/res/animator/button_elevation.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-  <item
-    android:state_enabled="true"
-    android:state_pressed="true">
-    <objectAnimator
-      android:duration="@android:integer/config_shortAnimTime"
-      android:propertyName="translationZ"
-      android:valueFrom="0dp"
-      android:valueTo="4dp"
-      android:valueType="floatType"/>
-  </item>
-  <item>
-    <objectAnimator
-      android:duration="@android:integer/config_shortAnimTime"
-      android:propertyName="translationZ"
-      android:valueFrom="4dp"
-      android:valueTo="0dp"
-      android:valueType="floatType"/>
-  </item>
-</selector>
diff --git a/java/com/android/dialer/theme/res/drawable-hdpi/ic_block_24dp.png b/java/com/android/dialer/theme/res/drawable-hdpi/ic_block_24dp.png
deleted file mode 100644
index 2ccc89d..0000000
--- a/java/com/android/dialer/theme/res/drawable-hdpi/ic_block_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/theme/res/values/colors.xml b/java/com/android/dialer/theme/res/values/colors.xml
index 52af142..0e6f54f 100644
--- a/java/com/android/dialer/theme/res/values/colors.xml
+++ b/java/com/android/dialer/theme/res/values/colors.xml
@@ -55,7 +55,6 @@
   <!-- Colors for the notification actions -->
   <color name="notification_action_accept">#097138</color>
   <color name="notification_action_dismiss">#A52714</color>
-  <color name="notification_action_end_call">#FFFFFF</color>
   <color name="notification_action_answer_video">#097138</color>
 
   <!-- Background color of action bars -->
diff --git a/java/com/android/dialer/theme/res/values/dimens.xml b/java/com/android/dialer/theme/res/values/dimens.xml
index 8b8e61f..ee52c97 100644
--- a/java/com/android/dialer/theme/res/values/dimens.xml
+++ b/java/com/android/dialer/theme/res/values/dimens.xml
@@ -1,12 +1,24 @@
 <?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2012 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
 <resources>
   <dimen name="call_log_action_icon_margin_start">16dp</dimen>
   <dimen name="call_log_action_icon_dimen">24dp</dimen>
   <dimen name="call_log_action_horizontal_padding">24dp</dimen>
 
-  <dimen name="call_log_actions_left_padding">64dp</dimen>
-  <dimen name="call_log_actions_top_padding">8dp</dimen>
-  <dimen name="call_log_actions_bottom_padding">8dp</dimen>
   <dimen name="call_log_primary_text_size">16sp</dimen>
   <dimen name="call_log_detail_text_size">12sp</dimen>
   <dimen name="call_log_day_group_heading_size">14sp</dimen>
@@ -23,7 +35,6 @@
   <dimen name="action_bar_elevation">3dp</dimen>
   <dimen name="tab_height">48dp</dimen>
   <!-- actionbar height + tab height -->
-  <dimen name="actionbar_and_tab_height">107dp</dimen>
   <dimen name="actionbar_contentInsetStart">72dp</dimen>
 
   <dimen name="call_log_icon_margin">2dp</dimen>
diff --git a/java/com/android/dialer/widget/res/values/dimens.xml b/java/com/android/dialer/widget/res/values/dimens.xml
index 537ad7b..65963a6 100644
--- a/java/com/android/dialer/widget/res/values/dimens.xml
+++ b/java/com/android/dialer/widget/res/values/dimens.xml
@@ -23,12 +23,10 @@
   <dimen name="send_container_width">48dp</dimen>
 
   <dimen name="toolbar_title_text_size">20sp</dimen>
-  <dimen name="toolbar_title_small_text_size">14sp</dimen>
   <dimen name="toolbar_subtitle_text_size">12sp</dimen>
   <dimen name="toolbar_elevation">4dp</dimen>
   <dimen name="toolbar_end_padding">4dp</dimen>
 
   <!-- Empty List -->
-  <dimen name="empty_list_message_top_padding">20dp</dimen>
   <dimen name="empty_list_message_text_size">16sp</dimen>
 </resources>
\ No newline at end of file
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/drawable/call_answer.xml b/java/com/android/incallui/answer/impl/answermethod/res/drawable/call_answer.xml
deleted file mode 100644
index 451c862..0000000
--- a/java/com/android/incallui/answer/impl/answermethod/res/drawable/call_answer.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-  android:height="24dp"
-  android:viewportHeight="32.0"
-  android:viewportWidth="32.0"
-  android:width="24dp">
-  <group
-    android:name="rotationGroup"
-    android:pivotX="12"
-    android:pivotY="12"
-    android:translateX="4"
-    android:translateY="4"
-    android:rotation="0"
-    >
-    <path
-      android:fillColor="#FFFFFFFF"
-      android:pathData="M6.62,10.79c1.44,2.83 3.76,5.14 6.59,6.59l2.2,-2.2c0.27,-0.27 0.67,-0.36 1.02,-0.24 1.12,0.37 2.33,0.57 3.57,0.57 0.55,0 1,0.45 1,1V20c0,0.55 -0.45,1 -1,1 -9.39,0 -17,-7.61 -17,-17 0,-0.55 0.45,-1 1,-1h3.5c0.55,0 1,0.45 1,1 0,1.25 0.2,2.45 0.57,3.57 0.11,0.35 0.03,0.74 -0.25,1.02l-2.2,2.2z"/>
-  </group>
-</vector>
diff --git a/java/com/android/incallui/answer/impl/answermethod/res/values/values.xml b/java/com/android/incallui/answer/impl/answermethod/res/values/values.xml
index 43b2cd2..cc17183 100644
--- a/java/com/android/incallui/answer/impl/answermethod/res/values/values.xml
+++ b/java/com/android/incallui/answer/impl/answermethod/res/values/values.xml
@@ -16,10 +16,8 @@
   -->
 
 <resources>
-  <color name="incoming_or_outgoing_call_screen_mask">@android:color/transparent</color>
   <color name="call_hangup_background">#DF0000</color>
   <color name="call_accept_background">#00C853</color>
   <color name="incoming_answer_icon">#00C853</color>
-  <integer name="button_exit_fade_delay_ms">300</integer>
   <bool name="two_button_show_button_labels">false</bool>
 </resources>
diff --git a/java/com/android/incallui/answer/impl/res/anim/incoming_unlocked_icon_entry.xml b/java/com/android/incallui/answer/impl/res/anim/incoming_unlocked_icon_entry.xml
deleted file mode 100644
index 6490bbc..0000000
--- a/java/com/android/incallui/answer/impl/res/anim/incoming_unlocked_icon_entry.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<set xmlns:android="http://schemas.android.com/apk/res/android"
-  android:ordering="together">
-  <alpha
-    android:duration="583"
-    android:fromAlpha="0.0"
-    android:interpolator="@android:anim/accelerate_interpolator"
-    android:startOffset="167"
-    android:toAlpha="1.0"/>
-  <scale
-    android:duration="600"
-    android:fromXScale="0px"
-    android:fromYScale="0px"
-    android:interpolator="@android:anim/accelerate_interpolator"
-    android:pivotX="50%"
-    android:pivotY="50%"
-    android:toXScale="100%"
-    android:toYScale="100%"/>
-</set>
diff --git a/java/com/android/incallui/answer/impl/res/anim/incoming_unlocked_text_entry.xml b/java/com/android/incallui/answer/impl/res/anim/incoming_unlocked_text_entry.xml
deleted file mode 100644
index 9d3195a..0000000
--- a/java/com/android/incallui/answer/impl/res/anim/incoming_unlocked_text_entry.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<set xmlns:android="http://schemas.android.com/apk/res/android">
-  <alpha
-    android:duration="583"
-    android:fromAlpha="0.0"
-    android:interpolator="@android:anim/accelerate_interpolator"
-    android:startOffset="167"
-    android:toAlpha="1.0"/>
-</set>
diff --git a/java/com/android/incallui/answer/impl/res/values/attrs.xml b/java/com/android/incallui/answer/impl/res/values/attrs.xml
index 1086e1c..9b0e65d 100644
--- a/java/com/android/incallui/answer/impl/res/values/attrs.xml
+++ b/java/com/android/incallui/answer/impl/res/values/attrs.xml
@@ -20,7 +20,4 @@
     <attr name="scaleWidth" format="boolean"/>
     <attr name="scaleHeight" format="boolean"/>
   </declare-styleable>
-
-  <item name="match_parent" type="dimen">-1</item>
-  <item name="wrap_content" type="dimen">-2</item>
 </resources>
\ No newline at end of file
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_add_call.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_add_call.xml
deleted file mode 100644
index 4daf052..0000000
--- a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_add_call.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-  <item android:drawable="@drawable/ic_addcall_white"/>
-</selector>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_dialpad.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_dialpad.xml
deleted file mode 100644
index 091142b..0000000
--- a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_dialpad.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-  <item android:drawable="@drawable/quantum_ic_dialpad_white_36"/>
-</selector>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_manage.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_manage.xml
deleted file mode 100644
index a48e4c4..0000000
--- a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_manage.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-  <item android:drawable="@drawable/quantum_ic_group_white_36"/>
-</selector>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_merge.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_merge.xml
deleted file mode 100644
index 61d7555..0000000
--- a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_merge.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-  <item android:drawable="@drawable/quantum_ic_call_merge_white_36"/>
-</selector>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_pause.xml b/java/com/android/incallui/incall/impl/res/drawable/incall_ic_pause.xml
deleted file mode 100644
index 6aa8ab8..0000000
--- a/java/com/android/incallui/incall/impl/res/drawable/incall_ic_pause.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-  <item android:drawable="@drawable/quantum_ic_pause_white_36"/>
-</selector>
diff --git a/java/com/android/incallui/incall/impl/res/drawable/tab_indicator_default.xml b/java/com/android/incallui/incall/impl/res/drawable/tab_indicator_default.xml
deleted file mode 100644
index 6a55b35..0000000
--- a/java/com/android/incallui/incall/impl/res/drawable/tab_indicator_default.xml
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
-  <item>
-    <shape
-      android:innerRadius="0dp"
-      android:shape="ring"
-      android:thickness="2dp"
-      android:useLevel="false">
-      <solid android:color="@android:color/darker_gray"/>
-    </shape>
-  </item>
-</layer-list>
\ No newline at end of file
diff --git a/java/com/android/incallui/incall/impl/res/drawable/tab_indicator_selected.xml b/java/com/android/incallui/incall/impl/res/drawable/tab_indicator_selected.xml
deleted file mode 100644
index fc673c6..0000000
--- a/java/com/android/incallui/incall/impl/res/drawable/tab_indicator_selected.xml
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
-  <item>
-    <shape
-      android:innerRadius="0dp"
-      android:shape="ring"
-      android:thickness="4dp"
-      android:useLevel="false">
-      <solid android:color="@color/background_dialer_white"/>
-    </shape>
-  </item>
-</layer-list>
\ No newline at end of file
diff --git a/java/com/android/incallui/incall/impl/res/drawable/tab_selector.xml b/java/com/android/incallui/incall/impl/res/drawable/tab_selector.xml
deleted file mode 100644
index 303a49b..0000000
--- a/java/com/android/incallui/incall/impl/res/drawable/tab_selector.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-  <item android:drawable="@drawable/tab_indicator_selected"
-    android:state_selected="true"/>
-  <item android:drawable="@drawable/tab_indicator_default"/>
-</selector>
\ No newline at end of file
diff --git a/java/com/android/incallui/incall/impl/res/layout/call_composer_data_fragment.xml b/java/com/android/incallui/incall/impl/res/layout/call_composer_data_fragment.xml
deleted file mode 100644
index 335ac8a..0000000
--- a/java/com/android/incallui/incall/impl/res/layout/call_composer_data_fragment.xml
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
-  android:orientation="vertical"
-  android:layout_width="match_parent"
-  android:layout_height="match_parent">
-  <TextView
-    android:id="@+id/subject"
-    android:layout_width="wrap_content"
-    android:layout_height="wrap_content"
-    android:layout_margin="8dp"
-    android:padding="8dp"
-    android:textSize="24sp"
-    android:textColor="@color/primary_text_color"
-    android:background="@color/background_dialer_white"/>
-</FrameLayout>
\ No newline at end of file
diff --git a/java/com/android/incallui/incall/impl/res/values-h385dp/dimens.xml b/java/com/android/incallui/incall/impl/res/values-h385dp/dimens.xml
index aac42c5..ba728d5 100644
--- a/java/com/android/incallui/incall/impl/res/values-h385dp/dimens.xml
+++ b/java/com/android/incallui/incall/impl/res/values-h385dp/dimens.xml
@@ -1,5 +1,19 @@
 <?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>
   <dimen name="incall_avatar_size">64dp</dimen>
-  <dimen name="incall_avatar_marginBottom">8dp</dimen>
 </resources>
diff --git a/java/com/android/incallui/incall/impl/res/values-w260dp-h580dp/dimens.xml b/java/com/android/incallui/incall/impl/res/values-w260dp-h580dp/dimens.xml
index 834ea2f..1572bb9 100644
--- a/java/com/android/incallui/incall/impl/res/values-w260dp-h580dp/dimens.xml
+++ b/java/com/android/incallui/incall/impl/res/values-w260dp-h580dp/dimens.xml
@@ -16,7 +16,6 @@
   -->
 
 <resources>
-  <dimen name="incall_button_horizontal_padding">16dp</dimen>
   <dimen name="incall_button_vertical_padding">16dp</dimen>
   <dimen name="incall_labeled_button_size">64dp</dimen>
   <dimen name="tools_button_height">92dp</dimen>
diff --git a/java/com/android/incallui/incall/impl/res/values-w300dp-h620dp/dimens.xml b/java/com/android/incallui/incall/impl/res/values-w300dp-h620dp/dimens.xml
index c7ac35e..7592812 100644
--- a/java/com/android/incallui/incall/impl/res/values-w300dp-h620dp/dimens.xml
+++ b/java/com/android/incallui/incall/impl/res/values-w300dp-h620dp/dimens.xml
@@ -16,6 +16,5 @@
   -->
 
 <resources>
-  <dimen name="incall_button_horizontal_padding">32dp</dimen>
   <dimen name="incall_button_vertical_padding">32dp</dimen>
 </resources>
diff --git a/java/com/android/incallui/incall/impl/res/values/dimens.xml b/java/com/android/incallui/incall/impl/res/values/dimens.xml
index 72602e3..076a7d7 100644
--- a/java/com/android/incallui/incall/impl/res/values/dimens.xml
+++ b/java/com/android/incallui/incall/impl/res/values/dimens.xml
@@ -1,13 +1,27 @@
 <?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2012 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
 <resources>
   <dimen name="incall_button_label_margin">8dp</dimen>
   <dimen name="incall_button_elevation">0dp</dimen>
   <dimen name="incall_end_call_spacing">116dp</dimen>
   <dimen name="incall_button_padding">4dp</dimen>
-  <dimen name="incall_button_horizontal_padding">8dp</dimen>
   <dimen name="incall_button_vertical_padding">8dp</dimen>
   <dimen name="incall_avatar_size">0dp</dimen>
-  <dimen name="incall_avatar_marginBottom">0dp</dimen>
   <dimen name="incall_labeled_button_size">48dp</dimen>
   <dimen name="tools_button_height">76dp</dimen>
   <dimen name="incall_window_margin_horizontal">24dp</dimen>
diff --git a/java/com/android/incallui/res/anim/activity_open_enter.xml b/java/com/android/incallui/res/anim/activity_open_enter.xml
deleted file mode 100644
index 71cc096..0000000
--- a/java/com/android/incallui/res/anim/activity_open_enter.xml
+++ /dev/null
@@ -1,43 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-/*
-** Copyright 2009, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
--->
-
-<set xmlns:android="http://schemas.android.com/apk/res/android"
-  android:shareInterpolator="false"
-  android:zAdjustment="top">
-  <alpha
-    android:duration="300"
-    android:fillAfter="true"
-    android:fillBefore="false"
-    android:fillEnabled="true"
-    android:fromAlpha="0.0"
-    android:interpolator="@anim/decelerate_cubic"
-    android:toAlpha="1.0"/>
-  <scale
-    android:duration="300"
-    android:fillAfter="true"
-    android:fillBefore="false"
-    android:fillEnabled="true"
-    android:fromXScale=".8"
-    android:fromYScale=".8"
-    android:interpolator="@anim/decelerate_cubic"
-    android:pivotX="50%p"
-    android:pivotY="50%p"
-    android:toXScale="1.0"
-    android:toYScale="1.0"/>
-</set>
\ No newline at end of file
diff --git a/java/com/android/incallui/res/anim/activity_open_exit.xml b/java/com/android/incallui/res/anim/activity_open_exit.xml
deleted file mode 100644
index 9b36bb3..0000000
--- a/java/com/android/incallui/res/anim/activity_open_exit.xml
+++ /dev/null
@@ -1,31 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-/*
-** Copyright 2009, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
--->
-
-<set xmlns:android="http://schemas.android.com/apk/res/android"
-  android:background="#ff000000"
-  android:zAdjustment="normal">
-  <alpha
-    android:duration="300"
-    android:fillAfter="true"
-    android:fillBefore="false"
-    android:fillEnabled="true"
-    android:fromAlpha="1.0"
-    android:interpolator="@anim/decelerate_quint"
-    android:toAlpha="0.0"/>
-</set>
\ No newline at end of file
diff --git a/java/com/android/incallui/res/anim/decelerate_cubic.xml b/java/com/android/incallui/res/anim/decelerate_cubic.xml
deleted file mode 100644
index c2f4159..0000000
--- a/java/com/android/incallui/res/anim/decelerate_cubic.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-/*
-** Copyright 2010, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
--->
-
-<decelerateInterpolator xmlns:android="http://schemas.android.com/apk/res/android"
-  android:factor="1.5"/>
diff --git a/java/com/android/incallui/res/anim/decelerate_quint.xml b/java/com/android/incallui/res/anim/decelerate_quint.xml
deleted file mode 100644
index e55e99c..0000000
--- a/java/com/android/incallui/res/anim/decelerate_quint.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-/*
-** Copyright 2010, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
--->
-
-<decelerateInterpolator xmlns:android="http://schemas.android.com/apk/res/android"
-  android:factor="2.5"/>
diff --git a/java/com/android/incallui/res/color/ota_title_color.xml b/java/com/android/incallui/res/color/ota_title_color.xml
deleted file mode 100644
index bf36f56..0000000
--- a/java/com/android/incallui/res/color/ota_title_color.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2013 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-  <item android:color="#FFA6C839"/>
-</selector>
-
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_location_on_white_24dp.png b/java/com/android/incallui/res/drawable-hdpi/ic_location_on_white_24dp.png
deleted file mode 100644
index 7c281c3..0000000
--- a/java/com/android/incallui/res/drawable-hdpi/ic_location_on_white_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_question_mark.png b/java/com/android/incallui/res/drawable-hdpi/ic_question_mark.png
deleted file mode 100644
index bd9489c..0000000
--- a/java/com/android/incallui/res/drawable-hdpi/ic_question_mark.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-hdpi/ic_schedule_white_24dp.png b/java/com/android/incallui/res/drawable-hdpi/ic_schedule_white_24dp.png
deleted file mode 100644
index f3581d1..0000000
--- a/java/com/android/incallui/res/drawable-hdpi/ic_schedule_white_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_location_on_white_24dp.png b/java/com/android/incallui/res/drawable-mdpi/ic_location_on_white_24dp.png
deleted file mode 100644
index 933eb51..0000000
--- a/java/com/android/incallui/res/drawable-mdpi/ic_location_on_white_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_question_mark.png b/java/com/android/incallui/res/drawable-mdpi/ic_question_mark.png
deleted file mode 100644
index 594d0b9..0000000
--- a/java/com/android/incallui/res/drawable-mdpi/ic_question_mark.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-mdpi/ic_schedule_white_24dp.png b/java/com/android/incallui/res/drawable-mdpi/ic_schedule_white_24dp.png
deleted file mode 100644
index 501ee84..0000000
--- a/java/com/android/incallui/res/drawable-mdpi/ic_schedule_white_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_location_on_white_24dp.png b/java/com/android/incallui/res/drawable-xhdpi/ic_location_on_white_24dp.png
deleted file mode 100644
index 814ca8d..0000000
--- a/java/com/android/incallui/res/drawable-xhdpi/ic_location_on_white_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_question_mark.png b/java/com/android/incallui/res/drawable-xhdpi/ic_question_mark.png
deleted file mode 100644
index ec915f6..0000000
--- a/java/com/android/incallui/res/drawable-xhdpi/ic_question_mark.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xhdpi/ic_schedule_white_24dp.png b/java/com/android/incallui/res/drawable-xhdpi/ic_schedule_white_24dp.png
deleted file mode 100644
index 2e27936..0000000
--- a/java/com/android/incallui/res/drawable-xhdpi/ic_schedule_white_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_location_on_white_24dp.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_location_on_white_24dp.png
deleted file mode 100644
index 078b10d..0000000
--- a/java/com/android/incallui/res/drawable-xxhdpi/ic_location_on_white_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_question_mark.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_question_mark.png
deleted file mode 100644
index e3f6d28..0000000
--- a/java/com/android/incallui/res/drawable-xxhdpi/ic_question_mark.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxhdpi/ic_schedule_white_24dp.png b/java/com/android/incallui/res/drawable-xxhdpi/ic_schedule_white_24dp.png
deleted file mode 100644
index bfc7273..0000000
--- a/java/com/android/incallui/res/drawable-xxhdpi/ic_schedule_white_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/ic_location_on_white_24dp.png b/java/com/android/incallui/res/drawable-xxxhdpi/ic_location_on_white_24dp.png
deleted file mode 100644
index 8bcb6f6..0000000
--- a/java/com/android/incallui/res/drawable-xxxhdpi/ic_location_on_white_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/ic_question_mark.png b/java/com/android/incallui/res/drawable-xxxhdpi/ic_question_mark.png
deleted file mode 100644
index 1a6bf1e..0000000
--- a/java/com/android/incallui/res/drawable-xxxhdpi/ic_question_mark.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/drawable-xxxhdpi/ic_schedule_white_24dp.png b/java/com/android/incallui/res/drawable-xxxhdpi/ic_schedule_white_24dp.png
deleted file mode 100644
index b94f4df..0000000
--- a/java/com/android/incallui/res/drawable-xxxhdpi/ic_schedule_white_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/res/values/animation_constants.xml b/java/com/android/incallui/res/values/animation_constants.xml
deleted file mode 100644
index ac50db2..0000000
--- a/java/com/android/incallui/res/values/animation_constants.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2014 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<resources>
-  <integer name="reveal_animation_duration">333</integer>
-</resources>
diff --git a/java/com/android/incallui/res/values/colors.xml b/java/com/android/incallui/res/values/colors.xml
index 5d97d72..4bded78 100644
--- a/java/com/android/incallui/res/values/colors.xml
+++ b/java/com/android/incallui/res/values/colors.xml
@@ -16,27 +16,16 @@
   -->
 
 <resources>
-
-  <color name="incall_action_bar_background_color">@color/dialer_theme_color</color>
-  <color name="incall_action_bar_text_color">#ffffff</color>
-
-  <!-- Put on top of each photo, implying 80% darker than usual. -->
-  <color name="on_hold_dim_effect">#cc000000</color>
-
   <color name="conference_call_manager_caller_name_text_color">#4d4d4d</color>
   <color name="conference_call_manager_icon_color">#999999</color>
   <!-- Used with some smaller texts in manage conference screen. -->
   <color name="conference_call_manager_secondary_text_color">#999999</color>
 
   <color name="incall_dialpad_background">#ffffff</color>
-  <color name="incall_dialpad_background_pressed">#ccaaaaaa</color>
-  <color name="incall_window_scrim">#b2000000</color>
 
   <!-- Background color for status bar. For portrait this will be ignored. -->
   <color name="statusbar_background_color">@color/dialer_theme_color</color>
 
-  <color name="translucent_shadow">#33999999</color>
-
   <!-- 20% opacity, theme color. -->
   <color name="incall_dialpad_touch_tint">@color/dialer_theme_color_20pct</color>
 
@@ -69,12 +58,6 @@
     <item>#841F10</item>
   </array>
 
-  <!-- Ripple color used over light backgrounds. -->
-  <color name="ripple_light">#40000000</color>
-
-  <!-- Background color for large notification icon in after call from unknown numbers -->
-  <color name="unknown_number_color">#F4B400</color>
-
   <color name="incall_background_gradient_top">#E91141BB</color>
   <color name="incall_background_gradient_middle">#E91141BB</color>
   <color name="incall_background_gradient_bottom">#CC229FEB</color>
diff --git a/java/com/android/incallui/res/values/dimens.xml b/java/com/android/incallui/res/values/dimens.xml
index 56b9ae1..9310281 100644
--- a/java/com/android/incallui/res/values/dimens.xml
+++ b/java/com/android/incallui/res/values/dimens.xml
@@ -16,20 +16,6 @@
   -->
 
 <resources>
-  <dimen name="incall_action_bar_elevation">3dp</dimen>
-
-  <!-- Margin between the bottom of the "call card" photo
-       and the top of the in-call button cluster. -->
-  <dimen name="in_call_touch_ui_upper_margin">2dp</dimen>
-
-  <!-- Padding at the top and bottom edges of the "provider information" -->
-  <dimen name="provider_info_top_bottom_padding">8dp</dimen>
-
-  <!-- Right padding for name and number fields in the call banner.
-       This padding is used to ensure that ultra-long names or
-       numbers won't overlap the elapsed time indication. -->
-  <dimen name="call_banner_name_number_right_padding">50sp</dimen>
-
   <!-- The InCallUI dialpad will sometimes want digits sizes that are different
        from dialer. Note, these are the default sizes for small devices. Larger
        screen sizes apply the values in values-sw360dp/dimens.xml. -->
@@ -40,22 +26,10 @@
   <dimen name="incall_dialpad_digits_adjustable_height">50dp</dimen>
   <dimen name="incall_dialpad_key_numbers_size">36dp</dimen>
 
-  <!-- Dimensions for OTA Call Card -->
-  <dimen name="otaactivate_layout_marginTop">10dp</dimen>
-  <dimen name="otalistenprogress_layout_marginTop">5dp</dimen>
-  <dimen name="otasuccessfail_layout_marginTop">10dp</dimen>
-
   <!-- Dimension used to possibly down-scale high-res photo into what is suitable
        for notification's large icon. -->
   <dimen name="notification_icon_size">64dp</dimen>
 
-  <!-- Height of translucent shadow effect -->
-  <dimen name="translucent_shadow_height">2dp</dimen>
-
-  <!-- The smaller dimension of the video preview.  When in portrait orientation this is the
-       width of the preview.  When in landscape, this is the height. -->
-  <dimen name="video_preview_small_dimension">90dp</dimen>
-
   <dimen name="conference_call_manager_button_dimension">48dp</dimen>
 
   <dimen name="return_to_call_initial_offset_y">120dp</dimen>
diff --git a/java/com/android/incallui/res/values/styles.xml b/java/com/android/incallui/res/values/styles.xml
index 3c036c9..5f1aefd 100644
--- a/java/com/android/incallui/res/values/styles.xml
+++ b/java/com/android/incallui/res/values/styles.xml
@@ -16,8 +16,6 @@
   -->
 
 <resources>
-  <drawable name="grayBg">#FF333333</drawable>
-
   <!-- Theme for the InCallActivity activity. Should have a transparent background for the
        circular reveal animation for a new outgoing call to work correctly. We don't just use
        Theme.Black.NoTitleBar directly, since we want any popups or dialogs from the
diff --git a/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_checked_disabled.png b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_checked_disabled.png
deleted file mode 100644
index 2deaadd..0000000
--- a/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_checked_disabled.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_disabled.png b/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_disabled.png
deleted file mode 100644
index 95d6824..0000000
--- a/java/com/android/incallui/video/impl/res/drawable-hdpi/video_button_bg_disabled.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_checked_disabled.png b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_checked_disabled.png
deleted file mode 100644
index c752813..0000000
--- a/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_checked_disabled.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_disabled.png b/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_disabled.png
deleted file mode 100644
index 1ff3e7c..0000000
--- a/java/com/android/incallui/video/impl/res/drawable-mdpi/video_button_bg_disabled.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_checked_disabled.png b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_checked_disabled.png
deleted file mode 100644
index 4d5e033..0000000
--- a/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_checked_disabled.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_disabled.png b/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_disabled.png
deleted file mode 100644
index e5c3fc4..0000000
--- a/java/com/android/incallui/video/impl/res/drawable-xhdpi/video_button_bg_disabled.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_checked_disabled.png b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_checked_disabled.png
deleted file mode 100644
index a0be8d1..0000000
--- a/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_checked_disabled.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_disabled.png b/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_disabled.png
deleted file mode 100644
index 9961858..0000000
--- a/java/com/android/incallui/video/impl/res/drawable-xxhdpi/video_button_bg_disabled.png
+++ /dev/null
Binary files differ
