diff --git a/Android.mk b/Android.mk
index 1d1c609..b19df65 100644
--- a/Android.mk
+++ b/Android.mk
@@ -12,7 +12,7 @@
 endif
 
 src_dirs := src src-bind $(phone_common_dir)/src
-res_dirs := res res-aosp res-common res-icons $(phone_common_dir)/res
+res_dirs := res res-aosp res-icons $(phone_common_dir)/res
 asset_dirs := assets
 
 LOCAL_SRC_FILES := $(call all-java-files-under, $(src_dirs))
diff --git a/res-common/drawable-v21/view_pager_tab_background.xml b/res-common/drawable-v21/view_pager_tab_background.xml
deleted file mode 100644
index b9e0805..0000000
--- a/res-common/drawable-v21/view_pager_tab_background.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2016 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-<ripple xmlns:android="http://schemas.android.com/apk/res/android"
-        android:color="@color/tab_ripple_color">
-    <item android:id="@android:id/mask">
-        <color android:color="@android:color/white" />
-    </item>
-</ripple>
diff --git a/res-common/drawable/view_pager_tab_background.xml b/res-common/drawable/view_pager_tab_background.xml
deleted file mode 100644
index 9f59845..0000000
--- a/res-common/drawable/view_pager_tab_background.xml
+++ /dev/null
@@ -1,21 +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:state_pressed="true"
-        android:drawable="@color/tab_ripple_color"/>
-</selector>
\ No newline at end of file
diff --git a/res-common/values-land/integers.xml b/res-common/values-land/integers.xml
deleted file mode 100644
index 8ddef80..0000000
--- a/res-common/values-land/integers.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.
-  -->
-<resources>
-    <integer name="contact_tile_column_count_in_favorites">3</integer>
-
-    <!-- The number of characters in the snippet before we need to tokenize and ellipse. -->
-    <integer name="snippet_length_before_tokenize">60</integer>
-</resources>
diff --git a/res-common/values-sw600dp-land/integers.xml b/res-common/values-sw600dp-land/integers.xml
deleted file mode 100644
index bd9eb0e..0000000
--- a/res-common/values-sw600dp-land/integers.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.
-  -->
-<resources>
-    <integer name="contact_tile_column_count_in_favorites">3</integer>
-
-    <!-- The number of characters in the snippet before we need to tokenize and ellipse. -->
-    <integer name="snippet_length_before_tokenize">20</integer>
-</resources>
diff --git a/res-common/values-sw600dp/dimens.xml b/res-common/values-sw600dp/dimens.xml
deleted file mode 100644
index 8a6f799..0000000
--- a/res-common/values-sw600dp/dimens.xml
+++ /dev/null
@@ -1,35 +0,0 @@
-<!--
-  ~ 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="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>
-
-    <!-- End margin of the account filter header icon -->
-    <dimen name="contact_browser_list_header_icon_right_margin">22dp</dimen>
-    <dimen name="contact_browser_list_header_icon_right_margin_alt">24dp</dimen>
-
-    <dimen name="contact_filter_list_item_padding_start">24dp</dimen>
-    <dimen name="contact_filter_left_margin">16dp</dimen>
-
-    <!-- Right margin of the floating action button -->
-    <dimen name="floating_action_button_margin_right">32dp</dimen>
-    <!-- Bottom margin of the floating action button -->
-    <dimen name="floating_action_button_margin_bottom">32dp</dimen>
-</resources>
diff --git a/res-common/values-sw600dp/integers.xml b/res-common/values-sw600dp/integers.xml
deleted file mode 100644
index 5b1c92b..0000000
--- a/res-common/values-sw600dp/integers.xml
+++ /dev/null
@@ -1,24 +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>
-    <integer name="contact_tile_column_count_in_favorites">3</integer>
-
-    <!-- The number of characters in the snippet before we need to tokenize and ellipse. -->
-    <!-- Yikes, there is less space on a tablet!  This makes the search experience rather
-         poor. Another reason to get rid of the exist tablet layout. -->
-    <integer name="snippet_length_before_tokenize">15</integer>
-</resources>
diff --git a/res-common/values-sw720dp/integers.xml b/res-common/values-sw720dp/integers.xml
deleted file mode 100644
index 930adb3..0000000
--- a/res-common/values-sw720dp/integers.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.
-  -->
-<resources>
-    <integer name="contact_tile_column_count_in_favorites">2</integer>
-
-    <!-- The number of characters in the snippet before we need to tokenize and ellipse. -->
-    <integer name="snippet_length_before_tokenize">20</integer>
-</resources>
diff --git a/res-common/values/attrs.xml b/res-common/values/attrs.xml
deleted file mode 100644
index fe1cc56..0000000
--- a/res-common/values/attrs.xml
+++ /dev/null
@@ -1,85 +0,0 @@
-<!--
-  ~ 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>
-    <declare-styleable name="Theme">
-        <attr name="android:textColorSecondary" />
-    </declare-styleable>
-
-    <declare-styleable name="ContactsDataKind">
-        <!-- Mime-type handled by this mapping. -->
-        <attr name="android:mimeType" />
-        <!-- Icon used to represent data of this kind. -->
-        <attr name="android:icon" />
-        <!-- Column in data table that summarizes this data. -->
-        <attr name="android:summaryColumn" />
-        <!-- Column in data table that contains details for this data. -->
-        <attr name="android:detailColumn" />
-        <!-- Flag indicating that detail should be built from SocialProvider. -->
-        <attr name="android:detailSocialSummary" />
-        <!-- Resource representing the term "All Contacts" (e.g. "All Friends" or
-        "All connections"). Optional (Default is "All Contacts"). -->
-        <attr name="android:allContactsName" />
-    </declare-styleable>
-
-    <declare-styleable name="ContactListItemView">
-        <attr name="list_item_height" format="dimension"/>
-        <attr name="list_section_header_height" format="dimension"/>
-        <attr name="activated_background" format="reference"/>
-        <attr name="section_header_background" format="reference"/>
-        <attr name="list_item_padding_top" format="dimension"/>
-        <attr name="list_item_padding_right" format="dimension"/>
-        <attr name="list_item_padding_bottom" format="dimension"/>
-        <attr name="list_item_padding_left" format="dimension"/>
-        <attr name="list_item_gap_between_image_and_text" format="dimension"/>
-        <attr name="list_item_gap_between_indexer_and_image" format="dimension"/>
-        <attr name="list_item_gap_between_label_and_data" format="dimension"/>
-        <attr name="list_item_presence_icon_margin" format="dimension"/>
-        <attr name="list_item_presence_icon_size" format="dimension"/>
-        <attr name="list_item_photo_size" format="dimension"/>
-        <attr name="list_item_profile_photo_size" format="dimension"/>
-        <attr name="list_item_prefix_highlight_color" format="color"/>
-        <attr name="list_item_background_color" format="color"/>
-        <attr name="list_item_header_text_indent" format="dimension"/>
-        <attr name="list_item_header_text_color" format="color"/>
-        <attr name="list_item_header_text_size" format="dimension"/>
-        <attr name="list_item_header_height" format="dimension"/>
-        <attr name="list_item_name_text_color" format="color"/>
-        <attr name="list_item_name_text_size" format="dimension"/>
-        <attr name="list_item_text_indent" format="dimension"/>
-        <attr name="list_item_text_offset_top" format="dimension"/>
-        <attr name="list_item_avatar_offset_top" format="dimension"/>
-        <attr name="list_item_data_width_weight" format="integer"/>
-        <attr name="list_item_label_width_weight" format="integer"/>
-        <attr name="list_item_video_call_icon_size" format="dimension"/>
-        <attr name="list_item_video_call_icon_margin" format="dimension"/>
-    </declare-styleable>
-
-    <declare-styleable name="ContactBrowser">
-        <attr name="contact_browser_list_padding_left" format="dimension"/>
-        <attr name="contact_browser_list_padding_right" format="dimension"/>
-        <attr name="contact_browser_background" format="reference"/>
-    </declare-styleable>
-
-    <declare-styleable name="ProportionalLayout">
-        <attr name="direction" format="string"/>
-        <attr name="ratio" format="float"/>
-    </declare-styleable>
-
-    <declare-styleable name="Favorites">
-        <attr name="favorites_padding_bottom" format="dimension"/>
-    </declare-styleable>
-</resources>
diff --git a/res-common/values/colors.xml b/res-common/values/colors.xml
deleted file mode 100644
index f547d80..0000000
--- a/res-common/values/colors.xml
+++ /dev/null
@@ -1,191 +0,0 @@
-<!--
-  ~ 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>
-    <!-- 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="ripple_material_dark">#a0ffffff</color>
-
-    <!-- Divider color for header separator -->
-    <color name="primary_text_color">#363636</color>
-
-    <color name="secondary_text_color">@color/dialtacts_secondary_text_color</color>
-
-    <!-- Text color for section header. -->
-    <color name="section_header_text_color">@color/dialtacts_theme_color</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 the theme of the Dialer app -->
-    <color name="dialtacts_theme_color">#0288d1</color>
-
-    <!-- Color of image view placeholder. -->
-    <color name="image_placeholder">#DDDDDD</color>
-
-    <!-- Primary text color in the Phone app -->
-    <color name="dialtacts_primary_text_color">#333333</color>
-
-    <!-- Secondary text color in the Phone app -->
-    <color name="dialtacts_secondary_text_color">#737373</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>
-
-    <!-- Background colors for LetterTileDrawables. This set of colors is a subset of
-        https://spec.googleplex.com/quantumpalette#extended which passes Google Accessibility
-        Requirements for the color in question on white with >= 3.0 contrast. We used
-        http://leaverou.github.io/contrast-ratio/#white-on-%23db4437 to double-check the contrast.
-
-        These colors are also used by MaterialColorMapUtils to generate primary activity colors.
-    -->
-    <array name="letter_tile_colors">
-        <item>#DB4437</item>
-        <item>#E91E63</item>
-        <item>#9C27B0</item>
-        <item>#673AB7</item>
-        <item>#3F51B5</item>
-        <item>#4285F4</item>
-        <item>#039BE5</item>
-        <item>#0097A7</item>
-        <item>#009688</item>
-        <item>#0F9D58</item>
-        <item>#689F38</item>
-        <item>#EF6C00</item>
-        <item>#FF5722</item>
-        <item>#757575</item>
-    </array>
-
-    <!-- Darker versions of letter_tile_colors, two shades darker. These colors are used
-        for settings secondary activity colors. -->
-    <array name="letter_tile_colors_dark">
-        <item>#C53929</item>
-        <item>#C2185B</item>
-        <item>#7B1FA2</item>
-        <item>#512DA8</item>
-        <item>#303F9F</item>
-        <item>#3367D6</item>
-        <item>#0277BD</item>
-        <item>#006064</item>
-        <item>#00796B</item>
-        <item>#0B8043</item>
-        <item>#33691E</item>
-        <item>#E65100</item>
-        <item>#E64A19</item>
-        <item>#424242</item>
-    </array>
-
-    <!-- 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="letter_tile_default_color">#cccccc</color>
-
-    <color name="letter_tile_font_color">#ffffff</color>
-
-    <!-- Background color of action bars. Ensure this stays in sync with packages/Telephony
-         actionbar_background_color. -->
-    <color name="actionbar_background_color">#0fc6dc</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">@color/tab_accent_color</color>
-    <color name="tab_accent_color">#ffffff</color>
-    <color name="tab_selected_underline_color">@color/tab_accent_color</color>
-    <color name="tab_unread_count_background_color">#700f4b70</color>
-
-    <!-- Color of the title to the Frequently Contacted section -->
-    <color name="frequently_contacted_title_color">@color/actionbar_background_color</color>
-
-    <!-- Color of action bar text. Ensure this stays in sync with packages/Telephony
-    phone_settings_actionbar_text_color-->
-    <color name="actionbar_text_color">#ffffff</color>
-    <!-- 54% black for icons -->
-    <color name="actionbar_icon_color_grey">#8C000000</color>
-    <!-- 87% black for actionbar text -->
-    <color name="actionbar_text_color_black">#DF000000</color>
-    <!-- Solid grey for status bar overlay-->
-    <color name="actionbar_color_grey_solid">#777777</color>
-    <color name="actionbar_unselected_text_color">#a6ffffff</color>
-
-    <!-- Text color of the search box text as entered by user  -->
-    <color name="searchbox_text_color">#000000</color>
-    <!-- Background color of the search box -->
-    <color name="searchbox_background_color">#ffffff</color>
-
-    <color name="searchbox_hint_text_color">#66000000</color>
-    <color name="searchbox_icon_tint">@color/searchbox_hint_text_color</color>
-
-    <color name="search_shortcut_icon_color">@color/dialtacts_theme_color</color>
-
-    <!-- Color of the background of the contact detail and editor pages -->
-    <color name="background_primary">#f9f9f9</color>
-    <color name="contact_all_list_background_color">#FFFFFF</color>
-
-    <!-- Text color used for character counter when the max limit has been exceeded -->
-    <color name="call_subject_limit_exceeded">#d1041c</color>
-
-    <!-- Tint color for the call subject history icon. -->
-    <color name="call_subject_history_icon">#000000</color>
-
-    <!-- Divider line on the call subject dialog. -->
-    <color name="call_subject_divider">#d8d8d8</color>
-
-    <!-- Text color for the SEND & CALL button on the call subject dialog. -->
-    <color name="call_subject_button">#00c853</color>
-
-    <!-- Background color for the call subject history view. -->
-    <color name="call_subject_history_background">#ffffff</color>
-    <color name="search_video_call_icon_tint">@color/searchbox_hint_text_color</color>
-
-    <!-- Text color for an action in a snackbar. -->
-    <color name="snackbar_action_text">#40c4ff</color>
-    <!-- Background color for a snackbar. -->
-    <color name="snackbar_background">#333333</color>
-
-    <!-- Color of account/custom filters -->
-    <color name="account_filter_text_color">@color/actionbar_text_color_black</color>
-    <color name="custom_filter_divider">#dbdbdb</color>
-
-    <color name="material_star_pink">#f50057</color>
-
-    <!-- Primary text color in Contacts app -->
-    <color name="contacts_text_color">#333333</color>
-</resources>
diff --git a/res-common/values/dimens.xml b/res-common/values/dimens.xml
deleted file mode 100644
index a382ad2..0000000
--- a/res-common/values/dimens.xml
+++ /dev/null
@@ -1,185 +0,0 @@
-<!--
-  ~ 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>
-
-    <!-- Padding between the action bar's bottom edge and the first header
-         in contacts/group lists. -->
-    <dimen name="list_header_extra_top_padding">0dip</dimen>
-
-    <dimen name="list_section_divider_min_height">32dip</dimen>
-
-    <dimen name="directory_header_extra_top_padding">18dp</dimen>
-    <dimen name="directory_header_extra_bottom_padding">8dp</dimen>
-    <dimen name="directory_header_left_padding">16dp</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>
-
-    <!-- For contact filter setting screens -->
-    <dimen name="contact_filter_left_margin">8dp</dimen>
-    <dimen name="contact_filter_right_margin">16dip</dimen>
-    <dimen name="contact_filter_item_min_height">48dip</dimen>
-    <dimen name="contact_filter_icon_size">32dip</dimen>
-    <dimen name="contact_filter_list_item_height">56dp</dimen>
-    <dimen name="contact_filter_list_item_padding_start">16dp</dimen>
-    <!-- contact_filter_indicator is the arrow in expandable list view -->
-    <dimen name="contact_filter_indicator_padding_start">6dp</dimen>
-    <dimen name="contact_filter_indicator_padding_end">46dp</dimen>
-    <dimen name="contact_filter_action_button_width">72dp</dimen>
-
-    <!-- Padding to be used between a visible scrollbar and the contact list -->
-    <dimen name="list_visible_scrollbar_padding">32dip</dimen>
-
-    <dimen name="contact_browser_list_header_icon_left_margin">16dp</dimen>
-    <dimen name="contact_browser_list_header_icon_right_margin">14dp</dimen>
-    <dimen name="contact_browser_list_header_icon_left_margin_alt">18dp</dimen>
-    <dimen name="contact_browser_list_header_icon_right_margin_alt">16dp</dimen>
-    <dimen name="contact_browser_list_header_left_margin">16dip</dimen>
-    <dimen name="contact_browser_list_header_right_margin">@dimen/list_visible_scrollbar_padding</dimen>
-    <dimen name="contact_browser_list_item_text_indent">8dip</dimen>
-    <dimen name="contact_browser_list_header_height">48dp</dimen>
-    <dimen name="contact_browser_list_header_icon_size">24dp</dimen>
-    <dimen name="contact_browser_list_header_icon_size_alt">20dp</dimen>
-    <dimen name="contact_browser_list_header_text_margin">10dp</dimen>
-    <!-- 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">40dp</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_item_gap_between_indexer_and_image">16dp</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>
-
-    <!-- Dimensions for contact letter tiles -->
-    <dimen name="tile_letter_font_size">40dp</dimen>
-    <dimen name="tile_letter_font_size_small">20dp</dimen>
-    <dimen name="tile_divider_width">1dp</dimen>
-    <item name="letter_to_tile_ratio" type="dimen">67%</item>
-
-    <!-- Height of the floating action button -->
-    <dimen name="floating_action_button_height">56dp</dimen>
-    <!-- Width of the floating action button -->
-    <dimen name="floating_action_button_width">56dp</dimen>
-    <!-- Corner radius of the floating action button -->
-    <dimen name="floating_action_button_radius">28dp</dimen>
-    <!-- Z translation of the floating action button -->
-    <dimen name="floating_action_button_translation_z">8dp</dimen>
-    <!-- Padding to be applied to the bottom of lists to make space for the floating action
-         button -->
-    <dimen name="floating_action_button_list_bottom_padding">88dp</dimen>
-    <!-- Right margin of the floating action button -->
-    <dimen name="floating_action_button_margin_right">16dp</dimen>
-    <!-- Bottom margin of the floating action button -->
-    <dimen name="floating_action_button_margin_bottom">16dp</dimen>
-    <!-- Offset of bottom margin of the floating action button used when dialpad is up -->
-    <dimen name="floating_action_button_dialpad_margin_bottom_offset">4dp</dimen>
-
-    <!-- Height of the selection indicator of a tab. -->
-    <dimen name="tab_selected_underline_height">2dp</dimen>
-    <!-- Size of text in tabs. -->
-    <dimen name="tab_text_size">14sp</dimen>
-    <dimen name="tab_elevation">2dp</dimen>
-    <dimen name="tab_unread_count_background_size">16dp</dimen>
-    <dimen name="tab_unread_count_background_radius">2dp</dimen>
-    <dimen name="tab_unread_count_margin_left">10dp</dimen>
-    <dimen name="tab_unread_count_margin_top">2dp</dimen>
-    <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">56dp</dimen>
-    <!-- Size of the close icon.-->
-    <dimen name="search_box_close_icon_size">56dp</dimen>
-    <!-- Padding around the close button. It's visible size without padding is 24dp. -->
-    <dimen name="search_box_close_icon_padding">16dp</dimen>
-    <!-- End margin of the back arrow icon in the search box -->
-    <dimen name="search_box_navigation_icon_margin">8dp</dimen>
-    <!-- Left margin of the text field in the search box. -->
-    <dimen name="search_box_text_left_margin">8dp</dimen>
-    <!-- Search box text size -->
-    <dimen name="search_text_size">16sp</dimen>
-
-    <item name="close_icon_alpha" format="float" type="dimen">0.54</item>
-
-    <!-- Size of the close icon in selection bar.-->
-    <dimen name="selection_bar_close_icon_size">56dp</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
-         items. -->
-    <dimen name="call_subject_dialog_margin">20dp</dimen>
-    <!-- Padding used between lines of text in the call subject dialog. -->
-    <dimen name="call_subject_dialog_between_line_margin">8dp</dimen>
-    <!-- Size of the contact photo in the call subject dialog. -->
-    <dimen name="call_subject_dialog_contact_photo_size">50dp</dimen>
-    <!-- Margin above the edit text in the call subject dialog. -->
-    <dimen name="call_subject_dialog_edit_spacing">60dp</dimen>
-    <!-- Size of primary text in the call subject dialog. -->
-    <dimen name="call_subject_dialog_primary_text_size">16sp</dimen>
-    <!-- Size of secondary text in the call subject dialog. -->
-    <dimen name="call_subject_dialog_secondary_text_size">14sp</dimen>
-    <!-- Row padding for call subject history items. -->
-    <dimen name="call_subject_history_item_padding">15dp</dimen>
-</resources>
diff --git a/res-common/values/donottranslate_config.xml b/res-common/values/donottranslate_config.xml
deleted file mode 100644
index ad36362..0000000
--- a/res-common/values/donottranslate_config.xml
+++ /dev/null
@@ -1,95 +0,0 @@
-<!--
-  ~ 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>
-    <!-- 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>
-
-    <!-- If true, the default sort order is primary (i.e. by given name) -->
-    <bool name="config_default_sort_order_primary">true</bool>
-
-    <!-- If true, an option is shown in Display Options UI to choose a name display order -->
-    <bool name="config_display_order_user_changeable">true</bool>
-
-    <!-- If true, the default sort order is primary (i.e. by given name) -->
-    <bool name="config_default_display_order_primary">true</bool>
-
-    <!-- If true, the order of name fields in the editor is primary (i.e. given name first) -->
-    <bool name="config_editor_field_order_primary">true</bool>
-
-    <!-- If true, an option is shown in Display Options UI to choose a default account -->
-    <bool name="config_default_account_user_changeable">true</bool>
-
-    <!-- Contacts preferences key for contact editor default account -->
-    <string name="contact_editor_default_account_key">ContactEditorUtils_default_account</string>
-
-    <!-- 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">\u2605</string>
-</resources>
diff --git a/res-common/values/ids.xml b/res-common/values/ids.xml
deleted file mode 100644
index e084bf3..0000000
--- a/res-common/values/ids.xml
+++ /dev/null
@@ -1,42 +0,0 @@
-<!--
-  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>
-    <!-- For vcard.ImportVCardActivity -->
-    <item type="id" name="dialog_cache_vcard"/>
-    <item type="id" name="dialog_error_with_message"/>
-
-    <!-- For vcard.CancelActivity -->
-    <item type="id" name="dialog_cancel_confirmation"/>
-    <item type="id" name="dialog_cancel_failed"/>
-
-    <!-- For ExportVCardActivity -->
-    <item type="id" name="dialog_exporting_vcard"/>
-    <item type="id" name="dialog_fail_to_export_with_reason"/>
-
-    <!-- For Debug Purpose -->
-    <item type="id" name="cliv_name_textview"/>
-    <item type="id" name="cliv_phoneticname_textview"/>
-    <item type="id" name="cliv_label_textview"/>
-    <item type="id" name="cliv_data_view"/>
-
-    <!-- For tag ids used by ContactPhotoManager to tag views with contact details -->
-    <item type="id" name="tag_display_name"/>
-    <item type="id" name="tag_identifier"/>
-    <item type="id" name="tag_contact_type"/>
-
-    <item type="id" name="menu_save"/>
-</resources>
diff --git a/res-common/values/integers.xml b/res-common/values/integers.xml
deleted file mode 100644
index fada850..0000000
--- a/res-common/values/integers.xml
+++ /dev/null
@@ -1,42 +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>
-
-    <!--  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>
-
-    <!-- Layout weight of space elements in contact list view.
-    Default to 0 to indicate no padding-->
-    <integer name="contact_list_space_layout_weight">0</integer>
-    <!-- Layout weight of card in contact list view.
-    Default to 0 to indicate no padding -->
-    <integer name="contact_list_card_layout_weight">0</integer>
-
-    <!-- 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>
-
-    <!-- Duration of the animations when a contact list loads. -->
-    <integer name="lists_on_load_animation_duration">190</integer>
-</resources>
diff --git a/res-common/values/strings.xml b/res-common/values/strings.xml
deleted file mode 100644
index 182e3fb..0000000
--- a/res-common/values/strings.xml
+++ /dev/null
@@ -1,848 +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 xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-
-    <!-- Toast shown when text is copied to the clipboard [CHAR LIMIT=64] -->
-    <string name="toast_text_copied">Text copied</string>
-    <!-- Option displayed in context menu to copy long pressed item to clipboard [CHAR LIMIT=64] -->
-    <string name="copy_text">Copy to clipboard</string>
-
-    <!-- Action string for calling a custom phone number -->
-    <string name="call_custom">Call
-        <xliff:g id="custom">%s</xliff:g>
-    </string>
-    <!-- Action string for calling a home phone number -->
-    <string name="call_home">Call home</string>
-    <!-- Action string for calling a mobile phone number -->
-    <string name="call_mobile">Call mobile</string>
-    <!-- Action string for calling a work phone number -->
-    <string name="call_work">Call work</string>
-    <!-- Action string for calling a work fax phone number -->
-    <string name="call_fax_work">Call work fax</string>
-    <!-- Action string for calling a home fax phone number -->
-    <string name="call_fax_home">Call home fax</string>
-    <!-- Action string for calling a pager phone number -->
-    <string name="call_pager">Call pager</string>
-    <!-- Action string for calling an other phone number -->
-    <string name="call_other">Call</string>
-    <!-- Action string for calling a callback number -->
-    <string name="call_callback">Call callback</string>
-    <!-- Action string for calling a car phone number -->
-    <string name="call_car">Call car</string>
-    <!-- Action string for calling a company main phone number -->
-    <string name="call_company_main">Call company main</string>
-    <!-- Action string for calling a ISDN phone number -->
-    <string name="call_isdn">Call ISDN</string>
-    <!-- Action string for calling a main phone number -->
-    <string name="call_main">Call main</string>
-    <!-- Action string for calling an other fax phone number -->
-    <string name="call_other_fax">Call fax</string>
-    <!-- Action string for calling a radio phone number -->
-    <string name="call_radio">Call radio</string>
-    <!-- Action string for calling a Telex phone number -->
-    <string name="call_telex">Call telex</string>
-    <!-- Action string for calling a TTY/TDD phone number -->
-    <string name="call_tty_tdd">Call TTY/TDD</string>
-    <!-- Action string for calling a work mobile phone number -->
-    <string name="call_work_mobile">Call work mobile</string>
-    <!-- Action string for calling a work pager phone number -->
-    <string name="call_work_pager">Call work pager</string>
-    <!-- Action string for calling an assistant phone number -->
-    <string name="call_assistant">Call
-        <xliff:g id="assistant">%s</xliff:g>
-    </string>
-    <!-- Action string for calling a MMS phone number -->
-    <string name="call_mms">Call MMS</string>
-    <!-- Action string for calling a contact by shortcut -->
-    <string name="call_by_shortcut"><xliff:g id="contact_name">%s</xliff:g> (Call)</string>
-
-    <!-- Action string for sending an SMS to a custom phone number -->
-    <string name="sms_custom">Text
-        <xliff:g id="custom">%s</xliff:g>
-    </string>
-    <!-- Action string for sending an SMS to a home phone number -->
-    <string name="sms_home">Text home</string>
-    <!-- Action string for sending an SMS to a mobile phone number -->
-    <string name="sms_mobile">Text mobile</string>
-    <!-- Action string for sending an SMS to a work phone number -->
-    <string name="sms_work">Text work</string>
-    <!-- Action string for sending an SMS to a work fax phone number -->
-    <string name="sms_fax_work">Text work fax</string>
-    <!-- Action string for sending an SMS to a home fax phone number -->
-    <string name="sms_fax_home">Text home fax</string>
-    <!-- Action string for sending an SMS to a pager phone number -->
-    <string name="sms_pager">Text pager</string>
-    <!-- Action string for sending an SMS to an other phone number -->
-    <string name="sms_other">Text</string>
-    <!-- Action string for sending an SMS to a callback number -->
-    <string name="sms_callback">Text callback</string>
-    <!-- Action string for sending an SMS to a car phone number -->
-    <string name="sms_car">Text car</string>
-    <!-- Action string for sending an SMS to a company main phone number -->
-    <string name="sms_company_main">Text company main</string>
-    <!-- Action string for sending an SMS to a ISDN phone number -->
-    <string name="sms_isdn">Text ISDN</string>
-    <!-- Action string for sending an SMS to a main phone number -->
-    <string name="sms_main">Text main</string>
-    <!-- Action string for sending an SMS to an other fax phone number -->
-    <string name="sms_other_fax">Text fax</string>
-    <!-- Action string for sending an SMS to a radio phone number -->
-    <string name="sms_radio">Text radio</string>
-    <!-- Action string for sending an SMS to a Telex phone number -->
-    <string name="sms_telex">Text telex</string>
-    <!-- Action string for sending an SMS to a TTY/TDD phone number -->
-    <string name="sms_tty_tdd">Text TTY/TDD</string>
-    <!-- Action string for sending an SMS to a work mobile phone number -->
-    <string name="sms_work_mobile">Text work mobile</string>
-    <!-- Action string for sending an SMS to a work pager phone number -->
-    <string name="sms_work_pager">Text work pager</string>
-    <!-- Action string for sending an SMS to an assistant phone number -->
-    <string name="sms_assistant">Text
-        <xliff:g id="assistant">%s</xliff:g>
-    </string>
-    <!-- Action string for sending an SMS to a MMS phone number -->
-    <string name="sms_mms">Text MMS</string>
-    <!-- Action string for sending an SMS to a contact by shortcut -->
-    <string name="sms_by_shortcut"><xliff:g id="contact_name">%s</xliff:g> (Message)</string>
-
-    <!-- Description string for an action button to initiate a video call. -->
-    <string name="description_video_call">Make video call</string>
-
-    <!-- Title of the confirmation dialog for clearing frequents. [CHAR LIMIT=37] -->
-    <string name="clearFrequentsConfirmation_title">Clear frequently contacted?</string>
-
-    <!-- Confirmation dialog for clearing frequents. [CHAR LIMIT=NONE] -->
-    <string name="clearFrequentsConfirmation">You\'ll clear the frequently contacted list in the
-        Contacts and Phone apps, and force email apps to learn your addressing preferences from
-        scratch.
-    </string>
-
-    <!-- Title of the "Clearing frequently contacted" progress-dialog [CHAR LIMIT=35] -->
-    <string name="clearFrequentsProgress_title">Clearing frequently contacted\u2026</string>
-
-    <!--  Used to display as default status when the contact is available for chat [CHAR LIMIT=19] -->
-    <string name="status_available">Available</string>
-
-    <!--  Used to display as default status when the contact is away or idle for chat [CHAR LIMIT=19] -->
-    <string name="status_away">Away</string>
-
-    <!--  Used to display as default status when the contact is busy or Do not disturb for chat [CHAR LIMIT=19] -->
-    <string name="status_busy">Busy</string>
-
-    <!-- Directory partition name (also exists in contacts) -->
-    <string name="contactsList">Contacts</string>
-
-    <!-- The name of the invisible local contact directory -->
-    <string name="local_invisible_directory">Other</string>
-
-    <!-- The label in section header in the contact list for a contact directory [CHAR LIMIT=128] -->
-    <string name="directory_search_label">Directory</string>
-
-    <!-- The label in section header in the contact list for a work contact directory [CHAR LIMIT=128] -->
-    <string name="directory_search_label_work">Work directory</string>
-
-    <!-- The label in section header in the contact list for a local contacts [CHAR LIMIT=128] -->
-    <string name="local_search_label">All contacts</string>
-
-    <!-- Title shown in the search result activity of contacts app while searching.  [CHAR LIMIT=20]
-         (also in contacts) -->
-    <string name="search_results_searching">Searching\u2026</string>
-
-    <!-- Displayed at the top of search results indicating that more contacts were found than shown [CHAR LIMIT=64] -->
-    <string name="foundTooManyContacts">More than <xliff:g id="count">%d</xliff:g> found.</string>
-
-    <!-- Displayed at the top of the contacts showing the zero total number of contacts found when "Only contacts with phones" not selected. [CHAR LIMIT=30]
-         (also in contacts) -->
-    <string name="listFoundAllContactsZero">No contacts</string>
-
-    <!-- Displayed at the top of the contacts showing the total number of contacts found when typing search query -->
-    <plurals name="searchFoundContacts">
-        <item quantity="one">1 found</item>
-        <item quantity="other"><xliff:g id="count">%d</xliff:g> found</item>
-    </plurals>
-
-    <!-- String describing the text for photo of a contact in a contacts list.
-
-        Note: AccessibilityServices use this attribute to announce what the view represents.
-              This is especially valuable for views without textual representation like ImageView.
-    -->
-    <string name="description_quick_contact_for">Quick contact for <xliff:g id="name">%1$s</xliff:g></string>
-
-    <!-- Shown as the display name for a person when the name is missing or unknown. [CHAR LIMIT=18]-->
-    <string name="missing_name">(No name)</string>
-
-    <!-- The text displayed on the divider for the Favorites tab in People app indicating that items below it are frequently contacted [CHAR LIMIT = 39] -->
-    <string name="favoritesFrequentContacted">Frequently contacted</string>
-
-    <!-- String describing a contact picture that introduces users to the contact detail screen.
-
-       Used by AccessibilityService to announce the purpose of the button.
-
-       [CHAR LIMIT=NONE]
-    -->
-    <string name="description_view_contact_detail" msgid="2795575601596468581">View contact</string>
-
-    <!-- Contact list filter selection indicating that the list shows all contacts with phone numbers [CHAR LIMIT=64] -->
-    <string name="list_filter_phones">All contacts with phone numbers</string>
-
-    <!-- Contact list filter selection indicating that the list shows all work contacts with phone numbers [CHAR LIMIT=64] -->
-    <string name="list_filter_phones_work">Work profile contacts</string>
-
-    <!-- Button to view the updates from the current group on the group detail page [CHAR LIMIT=25] -->
-    <string name="view_updates_from_group">View updates</string>
-
-    <!-- Title for data source when creating or editing a contact that doesn't
-         belong to a specific account.  This contact will only exist on the phone
-         and will not be synced. [CHAR LIMIT=20]  -->
-    <string name="account_phone">Device</string>
-
-    <!-- Header that expands to list all name types when editing a structured name of a contact
-         [CHAR LIMIT=20] -->
-    <string name="nameLabelsGroup">Name</string>
-
-    <!-- Header that expands to list all nickname types when editing a nickname of a contact
-         [CHAR LIMIT=20] -->
-    <string name="nicknameLabelsGroup">Nickname</string>
-
-    <!-- Field title for the full name of a contact [CHAR LIMIT=64]-->
-    <string name="full_name">Name</string>
-    <!-- Field title for the given name of a contact -->
-    <string name="name_given">First name</string>
-    <!-- Field title for the family name of a contact -->
-    <string name="name_family">Last name</string>
-    <!-- Field title for the prefix name of a contact -->
-    <string name="name_prefix">Name prefix</string>
-    <!-- Field title for the middle name of a contact -->
-    <string name="name_middle">Middle name</string>
-    <!-- Field title for the suffix name of a contact -->
-    <string name="name_suffix">Name suffix</string>
-
-    <!-- Field title for the phonetic name of a contact [CHAR LIMIT=64]-->
-    <string name="name_phonetic">Phonetic name</string>
-
-    <!-- Field title for the phonetic given name of a contact -->
-    <string name="name_phonetic_given">Phonetic first name</string>
-    <!-- Field title for the phonetic middle name of a contact -->
-    <string name="name_phonetic_middle">Phonetic middle name</string>
-    <!-- Field title for the phonetic family name of a contact -->
-    <string name="name_phonetic_family">Phonetic last name</string>
-
-    <!-- Header that expands to list all of the types of phone numbers when editing or creating a
-         phone number for a contact [CHAR LIMIT=20] -->
-    <string name="phoneLabelsGroup">Phone</string>
-
-    <!-- Header that expands to list all of the types of email addresses when editing or creating
-         an email address for a contact [CHAR LIMIT=20] -->
-    <string name="emailLabelsGroup">Email</string>
-
-    <!-- Header that expands to list all of the types of postal addresses when editing or creating
-         an postal address for a contact [CHAR LIMIT=20] -->
-    <string name="postalLabelsGroup">Address</string>
-
-    <!-- Header that expands to list all of the types of IM account when editing or creating an IM
-         account for a contact [CHAR LIMIT=20] -->
-    <string name="imLabelsGroup">IM</string>
-
-    <!-- Header that expands to list all organization types when editing an organization of a
-         contact [CHAR LIMIT=20] -->
-    <string name="organizationLabelsGroup">Organization</string>
-
-    <!-- Header for the list of all relationships for a contact [CHAR LIMIT=20] -->
-    <string name="relationLabelsGroup">Relationship</string>
-
-    <!-- Header that expands to list all event types when editing an event of a contact
-         [CHAR LIMIT=20] -->
-    <string name="eventLabelsGroup">Special date</string>
-
-    <!-- Generic action string for text messaging a contact. Used by AccessibilityService to
-         announce the purpose of the view. [CHAR LIMIT=NONE] -->
-    <string name="sms">Text message</string>
-
-    <!-- Field title for the full postal address of a contact [CHAR LIMIT=64]-->
-    <string name="postal_address">Address</string>
-
-    <!-- Hint text for the organization name when editing -->
-    <string name="ghostData_company">Company</string>
-
-    <!-- Hint text for the organization title when editing -->
-    <string name="ghostData_title">Title</string>
-
-    <!-- The label describing the Notes field of a contact. This field allows free form text entry
-         about a contact -->
-    <string name="label_notes">Notes</string>
-
-    <!-- The label describing the SIP address field of a contact. [CHAR LIMIT=20] -->
-    <string name="label_sip_address">SIP</string>
-
-    <!-- Header that expands to list all website types when editing a website of a contact
-         [CHAR LIMIT=20] -->
-    <string name="websiteLabelsGroup">Website</string>
-
-    <!-- Header for the list of all labels for a contact [CHAR LIMIT=20] -->
-    <string name="groupsLabel">Labels</string>
-
-    <!-- Action string for sending an email to a home email address -->
-    <string name="email_home">Email home</string>
-    <!-- Action string for sending an email to a mobile email address -->
-    <string name="email_mobile">Email mobile</string>
-    <!-- Action string for sending an email to a work email address -->
-    <string name="email_work">Email work</string>
-    <!-- Action string for sending an email to an other email address -->
-    <string name="email_other">Email</string>
-    <!-- Action string for sending an email to a custom email address -->
-    <string name="email_custom">Email <xliff:g id="custom">%s</xliff:g></string>
-
-    <!-- Generic action string for sending an email -->
-    <string name="email">Email</string>
-
-    <!-- Field title for the street of a structured postal address of a contact -->
-    <string name="postal_street">Street</string>
-    <!-- Field title for the PO box of a structured postal address of a contact -->
-    <string name="postal_pobox">PO box</string>
-    <!-- Field title for the neighborhood of a structured postal address of a contact -->
-    <string name="postal_neighborhood">Neighborhood</string>
-    <!-- Field title for the city of a structured postal address of a contact -->
-    <string name="postal_city">City</string>
-    <!-- Field title for the region, or state, of a structured postal address of a contact -->
-    <string name="postal_region">State</string>
-    <!-- Field title for the postal code of a structured postal address of a contact -->
-    <string name="postal_postcode">ZIP code</string>
-    <!-- Field title for the country of a structured postal address of a contact -->
-    <string name="postal_country">Country</string>
-
-    <!-- Action string for viewing a home postal address -->
-    <string name="map_home">View home address</string>
-    <!-- Action string for viewing a work postal address -->
-    <string name="map_work">View work address</string>
-    <!-- Action string for viewing an other postal address -->
-    <string name="map_other">View address</string>
-    <!-- Action string for viewing a custom postal address -->
-    <string name="map_custom">View <xliff:g id="custom">%s</xliff:g> address</string>
-
-    <!-- Action string for starting an IM chat with the AIM protocol -->
-    <string name="chat_aim">Chat using AIM</string>
-    <!-- Action string for starting an IM chat with the MSN or Windows Live protocol -->
-    <string name="chat_msn">Chat using Windows Live</string>
-    <!-- Action string for starting an IM chat with the Yahoo protocol -->
-    <string name="chat_yahoo">Chat using Yahoo</string>
-    <!-- Action string for starting an IM chat with the Skype protocol -->
-    <string name="chat_skype">Chat using Skype</string>
-    <!-- Action string for starting an IM chat with the QQ protocol -->
-    <string name="chat_qq">Chat using QQ</string>
-    <!-- Action string for starting an IM chat with the Google Talk protocol -->
-    <string name="chat_gtalk">Chat using Google Talk</string>
-    <!-- Action string for starting an IM chat with the ICQ protocol -->
-    <string name="chat_icq">Chat using ICQ</string>
-    <!-- Action string for starting an IM chat with the Jabber protocol -->
-    <string name="chat_jabber">Chat using Jabber</string>
-
-    <!-- Generic action string for starting an IM chat -->
-    <string name="chat">Chat</string>
-
-    <!-- String describing the Contact Editor Minus button
-
-         Used by AccessibilityService to announce the purpose of the button.
-
-         [CHAR LIMIT=NONE]
-    -->
-    <string name="description_minus_button">delete</string>
-
-    <!-- Content description for the expand or collapse name fields button.
-         Clicking this button causes the name editor to toggle between showing
-         a single field where the entire name is edited at once, or multiple
-         fields corresponding to each part of the name (Name Prefix, First Name,
-         Middle Name, Last Name, Name Suffix).
-         [CHAR LIMIT=NONE] -->
-    <string name="expand_collapse_name_fields_description">Expand or collapse name fields</string>
-
-    <!-- Content description for the expand or collapse phonetic name fields button. [CHAR LIMIT=100] -->
-    <string name="expand_collapse_phonetic_name_fields_description">Expand or collapse phonetic
-        name fields</string>
-
-    <!-- Contact list filter label indicating that the list is showing all available accounts [CHAR LIMIT=64] -->
-    <string name="list_filter_all_accounts">All contacts</string>
-
-    <!-- Contact list filter label indicating that the list is showing all starred contacts [CHAR LIMIT=64] -->
-    <string name="list_filter_all_starred">Starred</string>
-
-    <!-- Contact list filter selection indicating that the list shows groups chosen by the user [CHAR LIMIT=64] -->
-    <string name="list_filter_customize">Customize</string>
-
-    <!-- Contact list filter selection indicating that the list shows only the selected contact [CHAR LIMIT=64] -->
-    <string name="list_filter_single">Contact</string>
-
-    <!-- List title for a special contacts group that covers all contacts. [CHAR LIMIT=25] -->
-    <string name="display_ungrouped">All other contacts</string>
-
-    <!-- List title for a special contacts group that covers all contacts that aren't members of any other group. [CHAR LIMIT=25] -->
-    <string name="display_all_contacts">All contacts</string>
-
-    <!-- Menu item to remove a contacts sync group. [CHAR LIMIT=40] -->
-    <string name="menu_sync_remove">Remove sync group</string>
-
-    <!-- Menu item to add a contacts sync group. [CHAR LIMIT=40] -->
-    <string name="dialog_sync_add">Add sync group</string>
-
-    <!-- Text displayed in the sync groups footer view for unknown sync groups. [CHAR LIMIT=40 -->
-    <string name="display_more_groups">More groups\u2026</string>
-
-    <!-- Warning message given to users just before they remove a currently syncing
-         group that would also cause all ungrouped contacts to stop syncing.  [CHAR LIMIT=NONE] -->
-    <string name="display_warn_remove_ungrouped">Removing \"<xliff:g id="group" example="Starred">%s</xliff:g>\" from sync will also remove any ungrouped contacts from sync.</string>
-
-    <!-- Displayed in a spinner dialog as user changes to display options are saved -->
-    <string name="savingDisplayGroups">Saving display options\u2026</string>
-
-    <!-- Menu item to indicate you are done editing a contact and want to save the changes you've made -->
-    <string name="menu_done">Done</string>
-
-    <!-- Menu item to indicate you want to cancel the current editing process and NOT save the changes you've made [CHAR LIMIT=12] -->
-    <string name="menu_doNotSave">Cancel</string>
-
-    <!-- Displayed at the top of the contacts showing single contact. [CHAR LIMIT=50] -->
-    <string name="listCustomView">Customized view</string>
-
-    <!-- Message asking user to select an account to save contacts imported from vcard or SIM card [CHAR LIMIT=64] -->
-    <string name="dialog_new_contact_account">Save imported contacts to:</string>
-
-    <!-- Action string for selecting SIM for importing contacts -->
-    <string name="import_from_sim">Import from SIM card</string>
-
-    <!-- Action string for selecting a SIM subscription for importing contacts -->
-    <string name="import_from_sim_summary">Import from SIM <xliff:g id="sim_name">^1</xliff:g> - <xliff:g id="sim_number">^2</xliff:g></string>
-
-    <!-- Action string for selecting a SIM subscription for importing contacts, without a phone number -->
-    <string name="import_from_sim_summary_no_number">Import from SIM <xliff:g id="sim_name">%1$s</xliff:g></string>
-
-    <!-- Action string for selecting a .vcf file to import contacts from [CHAR LIMIT=30] -->
-    <string name="import_from_vcf_file" product="default">Import from .vcf file</string>
-
-    <!-- Message shown in a Dialog confirming a user's cancel request toward existing vCard import.
-         The argument is file name for the vCard import the user wants to cancel.
-         [CHAR LIMIT=128] -->
-    <string name="cancel_import_confirmation_message">Cancel import of <xliff:g id="filename" example="import.vcf">%s</xliff:g>?</string>
-
-    <!-- Message shown in a Dialog confirming a user's cancel request toward existing vCard export.
-         The argument is file name for the vCard export the user wants to cancel.
-         [CHAR LIMIT=128] -->
-    <string name="cancel_export_confirmation_message">Cancel export of <xliff:g id="filename" example="export.vcf">%s</xliff:g>?</string>
-
-    <!-- Title shown in a Dialog telling users cancel vCard import/export operation is failed. [CHAR LIMIT=40] -->
-    <string name="cancel_vcard_import_or_export_failed">Couldn\'t cancel vCard import/export</string>
-
-    <!-- The failed reason which should not be shown but it may in some buggy condition. [CHAR LIMIT=40] -->
-    <string name="fail_reason_unknown">Unknown error.</string>
-
-    <!-- The failed reason shown when vCard importer/exporter could not open the file
-         specified by a user. The file name should be in the message. [CHAR LIMIT=NONE] -->
-    <string name="fail_reason_could_not_open_file">Couldn\'t open \"<xliff:g id="file_name">%s</xliff:g>\": <xliff:g id="exact_reason">%s</xliff:g>.</string>
-
-    <!-- The failed reason shown when contacts exporter fails to be initialized.
-         Some exact reason must follow this. [CHAR LIMIT=NONE]-->
-    <string name="fail_reason_could_not_initialize_exporter">Couldn\'t start the exporter: \"<xliff:g id="exact_reason">%s</xliff:g>\".</string>
-
-    <!-- The failed reason shown when there's no contact which is allowed to be exported.
-         Note that user may have contacts data but all of them are probably not allowed to be
-         exported because of security/permission reasons. [CHAR LIMIT=NONE] -->
-    <string name="fail_reason_no_exportable_contact">There is no exportable contact.</string>
-
-    <!-- The user doesn't have all permissions required to use the current screen. So
-         close the current screen and show the user this message. -->
-    <string name="missing_required_permission">You have disabled a required permission.</string>
-
-    <!-- The failed reason shown when some error happend during contacts export.
-         Some exact reason must follow this. [CHAR LIMIT=NONE] -->
-    <string name="fail_reason_error_occurred_during_export">An error occurred during export: \"<xliff:g id="exact_reason">%s</xliff:g>\".</string>
-
-    <!-- The failed reason shown when the given file name is too long for the system.
-         The length limit of each file is different in each Android device, so we don't need to
-         mention it here. [CHAR LIMIT=NONE] -->
-    <string name="fail_reason_too_long_filename">Required filename is too long (\"<xliff:g id="filename">%s</xliff:g>\").</string>
-
-    <!-- The failed reason shown when Contacts app (especially vCard importer/exporter)
-         emitted some I/O error. Exact reason will be appended by the system. [CHAR LIMIT=NONE] -->
-    <string name="fail_reason_io_error">I/O error</string>
-
-    <!-- Failure reason show when Contacts app (especially vCard importer) encountered
-         low memory problem and could not proceed its import procedure. [CHAR LIMIT=NONE] -->
-    <string name="fail_reason_low_memory_during_import">Not enough memory. The file may be too large.</string>
-
-    <!-- The failed reason shown when vCard parser was not able to be parsed by the current vCard
-         implementation. This might happen even when the input vCard is completely valid, though
-         we believe it is rather rare in the actual world. [CHAR LIMIT=NONE] -->
-    <string name="fail_reason_vcard_parse_error">Couldn\'t parse vCard for an unexpected reason.</string>
-
-    <!-- The failed reason shown when vCard importer doesn't support the format.
-         This may be shown when the vCard is corrupted [CHAR LIMIT=40] -->
-    <string name="fail_reason_not_supported">The format isn\'t supported.</string>
-
-    <!-- Fail reason shown when vCard importer failed to look over meta information stored in vCard file(s). -->
-    <string name="fail_reason_failed_to_collect_vcard_meta_info">Couldn\'t collect meta information of given vCard file(s).</string>
-
-    <!-- The failed reason shown when the import of some of vCard files failed during multiple vCard
-         files import. It includes the case where all files were failed to be imported. -->
-    <string name="fail_reason_failed_to_read_files">One or more files couldn\'t be imported (%s).</string>
-
-    <!-- The title shown when exporting vCard is successfuly finished [CHAR LIMIT=40] -->
-    <string name="exporting_vcard_finished_title">Finished exporting <xliff:g id="filename" example="export.vcf">%s</xliff:g>.</string>
-
-    <!-- The title shown when exporting vCard has finished successfully but the destination filename could not be resolved. [CHAR LIMIT=NONE] -->
-    <string name="exporting_vcard_finished_title_fallback">Finished exporting contacts.</string>
-
-    <!-- The toast message shown when exporting vCard has finished and vCards are ready to be shared [CHAR LIMIT=150]-->
-    <string name="exporting_vcard_finished_toast">Finished exporting contacts, click the notification to share contacts.</string>
-
-    <!-- The message on notification shown when exporting vCard has finished and vCards are ready to be shared [CHAR LIMIT=60]-->
-    <string name="touch_to_share_contacts">Tap to share contacts.</string>
-
-    <!-- The title shown when exporting vCard is canceled (probably by a user)
-         The argument is file name the user canceled importing.
-         [CHAR LIMIT=40] -->
-    <string name="exporting_vcard_canceled_title">Exporting <xliff:g id="filename" example="export.vcf">%s</xliff:g> canceled.</string>
-
-    <!-- Dialog title shown when the application is exporting contact data outside. [CHAR LIMIT=NONE] -->
-    <string name="exporting_contact_list_title">Exporting contact data</string>
-
-    <!-- Message shown when the application is exporting contact data outside -->
-    <string name="exporting_contact_list_message">Contact data is being exported.</string>
-
-    <!-- The error reason the vCard composer "may" emit when database is corrupted or
-         something is going wrong. Usually users should not see this text. [CHAR LIMIT=NONE] -->
-    <string name="composer_failed_to_get_database_infomation">Couldn\'t get database information.</string>
-
-    <!-- This error message shown when the user actually have no contact
-         (e.g. just after data-wiping), or, data providers of the contact list prohibits their
-         contacts from being exported to outside world via vcard exporter, etc. [CHAR LIMIT=NONE] -->
-    <string name="composer_has_no_exportable_contact">There are no exportable contacts. If you do have contacts on your phone, some data providers may not allow the contacts to be exported from the phone.</string>
-
-    <!-- The error reason the vCard composer may emit when vCard composer is not initialized
-         even when needed.
-         Users should not usually see this error message. [CHAR LIMIT=NONE] -->
-    <string name="composer_not_initialized">The vCard composer didn\'t start properly.</string>
-
-    <!-- Dialog title shown when exporting Contact data failed. [CHAR LIMIT=20] -->
-    <string name="exporting_contact_failed_title">Couldn\'t export</string>
-
-    <!-- Dialog message shown when exporting Contact data failed. [CHAR LIMIT=NONE] -->
-    <string name="exporting_contact_failed_message">The contact data wasn\'t exported.\nReason: \"<xliff:g id="fail_reason">%s</xliff:g>\"</string>
-
-    <!-- Description shown when importing vCard data.
-         The argument is the name of a contact which is being read.
-         [CHAR LIMIT=20] -->
-    <string name="importing_vcard_description">Importing <xliff:g id="name" example="Joe Due">%s</xliff:g></string>
-
-    <!-- Dialog title shown when reading vCard data failed [CHAR LIMIT=40] -->
-    <string name="reading_vcard_failed_title">Couldn\'t read vCard data</string>
-
-    <!-- The title shown when reading vCard is canceled (probably by a user)
-         [CHAR LIMIT=40] -->
-    <string name="reading_vcard_canceled_title">Reading vCard data canceled</string>
-
-    <!-- The title shown when reading vCard finished
-         The argument is file name the user imported.
-         [CHAR LIMIT=40] -->
-    <string name="importing_vcard_finished_title">Finished importing vCard <xliff:g id="filename" example="import.vcf">%s</xliff:g></string>
-
-    <!-- The title shown when importing vCard is canceled (probably by a user)
-         The argument is file name the user canceled importing.
-         [CHAR LIMIT=40] -->
-    <string name="importing_vcard_canceled_title">Importing <xliff:g id="filename" example="import.vcf">%s</xliff:g> canceled</string>
-
-    <!-- The message shown when vCard import request is accepted. The system may start that work soon, or do it later
-         when there are already other import/export requests.
-         The argument is file name the user imported.
-         [CHAR LIMIT=40] -->
-    <string name="vcard_import_will_start_message"><xliff:g id="filename" example="import.vcf">%s</xliff:g> will be imported shortly.</string>
-    <!-- The message shown when vCard import request is accepted. The system may start that work soon, or do it later when there are already other import/export requests.
-         "The file" is what a user selected for importing.
-         [CHAR LIMIT=40] -->
-    <string name="vcard_import_will_start_message_with_default_name">The file will be imported shortly.</string>
-    <!-- The message shown when a given vCard import request is rejected by the system. [CHAR LIMIT=NONE] -->
-    <string name="vcard_import_request_rejected_message">vCard import request was rejected. Try again later.</string>
-    <!-- The message shown when vCard export request is accepted. The system may start that work soon, or do it later
-         when there are already other import/export requests.
-         The argument is file name the user exported.
-         [CHAR LIMIT=40] -->
-    <string name="vcard_export_will_start_message"><xliff:g id="filename" example="import.vcf">%s</xliff:g> will be exported shortly.</string>
-
-    <!-- The message shown when a vCard export request is accepted but the destination filename could not be resolved. [CHAR LIMIT=NONE] -->
-    <string name="vcard_export_will_start_message_fallback">The file will be exported shortly.</string>
-
-    <!-- The message shown when a vCard export request is accepted and contacts will be exported shortly. [CHAR LIMIT=70]-->
-    <string name="contacts_export_will_start_message">Contacts will be exported shortly.</string>
-
-    <!-- The message shown when a given vCard export request is rejected by the system. [CHAR LIMIT=NONE] -->
-    <string name="vcard_export_request_rejected_message">vCard export request was rejected. Try again later.</string>
-    <!-- Used when file name is unknown in vCard processing. It typically happens
-         when the file is given outside the Contacts app. [CHAR LIMIT=30] -->
-    <string name="vcard_unknown_filename">contact</string>
-
-    <!-- The message shown when vCard importer is caching files to be imported into local temporary
-         data storage. [CHAR LIMIT=NONE] -->
-    <string name="caching_vcard_message">Caching vCard(s) to local temporary storage. The actual import will start soon.</string>
-
-    <!-- Message used when vCard import has failed. [CHAR LIMIT=40] -->
-    <string name="vcard_import_failed">Couldn\'t import vCard.</string>
-
-    <!-- The "file name" displayed for vCards received directly via NFC [CHAR LIMIT=16] -->
-    <string name="nfc_vcard_file_name">Contact received over NFC</string>
-
-    <!-- Dialog title shown when a user confirms whether he/she export Contact data. [CHAR LIMIT=32] -->
-    <string name="confirm_export_title">Export contacts?</string>
-
-    <!-- The title shown when vCard importer is caching files to be imported into local temporary
-         data storage.  [CHAR LIMIT=40] -->
-    <string name="caching_vcard_title">Caching</string>
-
-    <!-- The message shown while importing vCard(s).
-         First argument is current index of contacts to be imported.
-         Second argument is the total number of contacts.
-         Third argument is the name of a contact which is being read.
-         [CHAR LIMIT=20] -->
-    <string name="progress_notifier_message">Importing <xliff:g id="current_number">%s</xliff:g>/<xliff:g id="total_number">%s</xliff:g>: <xliff:g id="name" example="Joe Due">%s</xliff:g></string>
-
-    <!-- Action that exports all contacts to a user selected destination. [CHAR LIMIT=25] -->
-    <string name="export_to_vcf_file" product="default">Export to .vcf file</string>
-
-    <!-- Contact preferences related strings -->
-
-    <!-- Label of the "sort by" display option -->
-    <string name="display_options_sort_list_by">Sort by</string>
-
-    <!-- An allowable value for the "sort list by" contact display option  -->
-    <string name="display_options_sort_by_given_name">First name</string>
-
-    <!-- An allowable value for the "sort list by" contact display option  -->
-    <string name="display_options_sort_by_family_name">Last name</string>
-
-    <!-- Label of the "name format" display option [CHAR LIMIT=64]-->
-    <string name="display_options_view_names_as">Name format</string>
-
-    <!-- An allowable value for the "view names as" contact display option  -->
-    <string name="display_options_view_given_name_first">First name first</string>
-
-    <!-- An allowable value for the "view names as" contact display option  -->
-    <string name="display_options_view_family_name_first">Last name first</string>
-
-    <!--Lable of the "Accounts" in settings [CHAR LIMIT=30]-->
-    <string name="settings_accounts">Accounts</string>
-
-    <!--Label of the "default account" setting option to set default editor account. [CHAR LIMIT=80]-->
-    <string name="default_editor_account">Default account for new contacts</string>
-
-    <!--Label of the "Sync contact metadata" setting option to set sync account for Lychee. [CHAR LIMIT=80]-->
-    <string name="sync_contact_metadata_title">Sync contact metadata [DOGFOOD]</string>
-
-    <!--Label of the "Sync contact metadata" setting dialog to set sync account for Lychee. [CHAR LIMIT=80]-->
-    <string name="sync_contact_metadata_dialog_title">Sync contact metadata</string>
-
-    <!-- Title of my info preference, showing the name of user's personal profile [CHAR LIMIT=30]-->
-    <string name="settings_my_info_title">My info</string>
-
-    <!-- Displayed below my info for user to set up the user's personal profile entry [CHAR LIMIT=64] -->
-    <string name="set_up_profile">Set up your profile</string>
-
-    <!-- Label of the "About" setting -->
-    <string name="setting_about">About Contacts</string>
-
-    <!-- Title of the settings activity [CHAR LIMIT=64] -->
-    <string name="activity_title_settings">Settings</string>
-
-    <!-- Action that shares visible contacts -->
-    <string name="share_visible_contacts">Share visible contacts</string>
-
-    <!-- A framework exception (ie, transaction too large) can be thrown while attempting to share all visible contacts. If so, show this toast. -->
-    <string name="share_visible_contacts_failure">Failed to share visible contacts.</string>
-
-    <!-- Action that shares favorite contacts [CHAR LIMIT=40]-->
-    <string name="share_favorite_contacts">Share favorite contacts</string>
-
-    <!-- Action that shares contacts [CHAR LIMIT=30]-->
-    <string name="share_contacts">Share all contacts</string>
-
-    <!-- A framework exception can be thrown while attempting to share all contacts. If so, show this toast. [CHAR LIMIT=40]-->
-    <string name="share_contacts_failure">Failed to share contacts.</string>
-
-    <!-- Dialog title when selecting the bulk operation to perform from a list. [CHAR LIMIT=36] -->
-    <string name="dialog_import_export">Import/export contacts</string>
-
-    <!-- Dialog title when importing contacts from an external source. [CHAR LIMIT=36] -->
-    <string name="dialog_import">Import contacts</string>
-
-    <!-- Toast indicating that sharing a contact has failed. [CHAR LIMIT=NONE]  -->
-    <string name="share_error">This contact can\'t be shared.</string>
-
-    <!-- Toast indicating that no visible contact to share [CHAR LIMIT=NONE]  -->
-    <string name="no_contact_to_share">There are no contacts to share.</string>
-
-    <!-- Menu item to search contacts -->
-    <string name="menu_search">Search</string>
-
-    <!-- The menu item to filter the list of contacts displayed -->
-    <string name="menu_contacts_filter">Contacts to display</string>
-
-    <!-- Title of the activity that allows the uesr to filter the list of contacts displayed according to account [CHAR LIMIT=25] -->
-    <string name="activity_title_contacts_filter">Contacts to display</string>
-
-    <!-- Title of the activity that allows the user to customize filtering of contact list [CHAR LIMIT=128] -->
-    <string name="custom_list_filter">Define customized view</string>
-
-    <!-- Menu item to save changes to custom filter. [CHAR LIMIT=15] -->
-    <string name="menu_custom_filter_save">Save</string>
-
-    <!-- Query hint displayed inside the search field [CHAR LIMIT=64] -->
-    <string name="hint_findContacts">Search contacts</string>
-
-    <!-- The description text for the favorites tab.
-
-         Note: AccessibilityServices use this attribute to announce what the view represents.
-         This is especially valuable for views without textual representation like ImageView.
-
-         [CHAR LIMIT=NONE] -->
-    <string name="contactsFavoritesLabel">Favorites</string>
-
-    <!-- Displayed at the top of the contacts showing the zero total number of contacts visible when "All contacts" is selected  [CHAR LIMIT=64]-->
-    <string name="listTotalAllContactsZero">No contacts.</string>
-
-    <!--  The menu item to clear frequents [CHAR LIMIT=30] -->
-    <string name="menu_clear_frequents">Clear frequents</string>
-
-    <!-- Menu item to select SIM card -->
-    <string name="menu_select_sim">Select SIM card</string>
-
-    <!-- The menu item to open the list of accounts. [CHAR LIMIT=60]-->
-    <string name="menu_accounts">Manage accounts</string>
-
-    <!-- The menu item to bulk import or bulk export contacts from SIM card or SD card.  [CHAR LIMIT=30]-->
-    <string name="menu_import_export">Import/export</string>
-
-    <!-- The menu item to open blocked numbers activity [CHAR LIMIT=60]-->
-    <string name="menu_blocked_numbers">Blocked numbers</string>
-
-    <!-- The font-family to use for tab text.
-         Do not translate. -->
-    <string name="tab_font_family">sans-serif</string>
-
-    <!-- Attribution of a contact status update, when the time of update is unknown -->
-    <string name="contact_status_update_attribution">via <xliff:g id="source" example="Google Talk">%1$s</xliff:g></string>
-
-    <!-- Attribution of a contact status update, when the time of update is known -->
-    <string name="contact_status_update_attribution_with_date"><xliff:g id="date" example="3 hours ago">%1$s</xliff:g> via <xliff:g id="source" example="Google Talk">%2$s</xliff:g></string>
-
-    <!-- Font family used when drawing letters for letter tile avatars.
-         Do not translate. -->
-    <string name="letter_tile_letter_font_family">sans-serif-medium</string>
-
-    <!-- Content description for the fake action menu up button as used
-     inside search. [CHAR LIMIT=NONE] -->
-    <string name="action_menu_back_from_search">stop searching</string>
-
-    <!--  String describing the icon used to clear the search field -->
-    <string name="description_clear_search">Clear search</string>
-
-    <!-- The font-family to use for the text inside the searchbox.
-         Do not translate. -->
-    <string name="search_font_family">sans-serif</string>
-
-    <!-- The title of the preference section that allows users to configure how they want their
-         contacts to be displayed. [CHAR LIMIT=128] -->
-    <string name="settings_contact_display_options_title">Contact display options</string>
-
-    <!-- Title for Select Account Dialog [CHAR LIMIT=30] -->
-    <string name="select_account_dialog_title">Account</string>
-
-    <!-- Label for the check box to toggle default sim card setting [CHAR LIMIT=35]-->
-    <string name="set_default_account">Always use this for calls</string>
-
-    <!-- Title for dialog to select Phone Account for outgoing call.  [CHAR LIMIT=40] -->
-    <string name="select_phone_account_for_calls">Call with</string>
-
-    <!-- String used for actions in the dialer call log and the quick contact card to initiate
-         a call to an individual.  The user is prompted to enter a note which is sent along with
-         the call (e.g. a call subject). [CHAR LIMIT=40] -->
-    <string name="call_with_a_note">Call with a note</string>
-
-    <!-- Hint text shown in the call subject dialog. [CHAR LIMIT=255] -->
-    <string name="call_subject_hint">Type a note to send with call ...</string>
-
-    <!-- Button used to start a new call with the user entered subject. [CHAR LIMIT=32] -->
-    <string name="send_and_call_button">SEND &amp; CALL</string>
-
-    <!-- String used to represent the total number of characters entered for a call subject,
-         compared to the character limit.  Example: 2 / 64 -->
-    <string name="call_subject_limit"><xliff:g id="count" example="4">%1$s</xliff:g> / <xliff:g id="limit" example="64">%2$s</xliff:g></string>
-
-    <!-- String used to build a phone number bype and phone number string.
-         Example: Mobile • 650-555-1212  -->
-    <string name="call_subject_type_and_number"><xliff:g id="type" example="Mobile">%1$s</xliff:g> • <xliff:g id="number" example="(650) 555-1212">%2$s</xliff:g></string>
-
-    <!-- String format to describe the number of unread items in a tab.
-
-        Note: AccessibilityServices use this attribute to announce what the view represents.
-              This is especially valuable for views without textual representation like ImageView.
-    -->
-    <plurals name="tab_title_with_unread_items">
-        <item quantity="one">
-            <xliff:g id="title">%1$s</xliff:g>. <xliff:g id="count">%2$d</xliff:g> unread item.
-        </item>
-        <item quantity="other">
-            <xliff:g id="title">%1$s</xliff:g>. <xliff:g id="count">%2$d</xliff:g> unread items.
-        </item>
-    </plurals>
-
-    <!-- Build version title in About preference. [CHAR LIMIT=40]-->
-    <string name="about_build_version">Build version</string>
-
-    <!-- Open source licenses title in About preference. [CHAR LIMIT=60] -->
-    <string name="about_open_source_licenses">Open source licenses</string>
-
-    <!-- Open source licenses summary in About preference. [CHAR LIMIT=NONE] -->
-    <string name="about_open_source_licenses_summary">License details for open source software</string>
-
-    <!-- Privacy policy title in About preference. [CHAR LIMIT=40]-->
-    <string name="about_privacy_policy">Privacy policy</string>
-
-    <!-- Terms of service title in about preference. [CHAR LIMIT=60]-->
-    <string name="about_terms_of_service">Terms of service</string>
-
-    <!-- Title for the activity that displays licenses for open source libraries. [CHAR LIMIT=100]-->
-    <string name="activity_title_licenses">Open source licenses</string>
-
-    <!-- Toast message showing when failed to open the url. [CHAR LIMIT=100]-->
-    <string name="url_open_error_toast">Failed to open the url.</string>
-
-    <!-- Content description of entries (including that radio button is checked) in contact
-         accounts list filter. For example: Google abc@gmail.com checked, etc [CHAR LIMIT=30]-->
-    <string name="account_filter_view_checked"><xliff:g id="account_info">%s</xliff:g> checked</string>
-
-    <!-- Content description of entries (including that the radio button is not checked) in contact
-         accounts list filter. For example: Google abc@gmail.com not checked, etc [CHAR LIMIT=30]-->
-    <string name="account_filter_view_not_checked"><xliff:g id="account_info">%s</xliff:g> not checked</string>
-
-    <!-- Description string for an action button to initiate a video call from search results.
-         Note: AccessibilityServices use this attribute to announce what the view represents.
-         This is especially valuable for views without textual representation like ImageView.
-
-         [CHAR LIMIT=NONE]-->
-    <string name="description_search_video_call">Place video call</string>
-
-    <!-- Content description of delete contact button [CHAR LIMIT=30]-->
-    <string name="description_delete_contact">Delete</string>
-
-    <!-- Content description for (...) in no name header [CHAR LIMIT=30]-->
-    <string name="description_no_name_header">Ellipsis</string>
-</resources>
diff --git a/res-common/values/styles.xml b/res-common/values/styles.xml
deleted file mode 100644
index ead4221..0000000
--- a/res-common/values/styles.xml
+++ /dev/null
@@ -1,113 +0,0 @@
-<!--
-  ~ Copyright (C) 2012 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License
-  -->
-
-<resources>
-
-    <style name="DirectoryHeader">
-        <item name="android:background">@android:color/transparent</item>
-    </style>
-
-    <style name="SectionHeaderStyle" parent="@android:style/TextAppearance.Large">
-        <item name="android:textSize">16sp</item>
-        <item name="android:textAllCaps">true</item>
-        <item name="android:textColor">@color/section_header_text_color</item>
-        <item name="android:textStyle">bold</item>
-    </style>
-
-    <style name="DirectoryHeaderStyle" parent="@android:style/TextAppearance.Small">
-        <item name="android:textSize">14sp</item>
-        <item name="android:textColor">@color/dialtacts_secondary_text_color</item>
-        <item name="android:fontFamily">sans-serif-medium</item>
-    </style>
-
-    <!-- TextView style used for headers.
-
-This is similar to ?android:attr/listSeparatorTextView but uses different
-background and text color. See also android:style/Widget.Holo.TextView.ListSeparator
-(which is private, so we cannot specify it as a parent style).  -->
-    <style name="ContactListSeparatorTextViewStyle">
-        <item name="android:layout_width">match_parent</item>
-        <item name="android:layout_height">wrap_content</item>
-        <!-- See comments for @dimen/list_section_divider_min_height -->
-        <item name="android:minHeight">@dimen/list_section_divider_min_height</item>
-        <item name="android:textAppearance">@style/DirectoryHeaderStyle</item>
-        <item name="android:gravity">center_vertical</item>
-        <item name="android:paddingLeft">8dip</item>
-        <item name="android:paddingStart">8dip</item>
-        <item name="android:paddingTop">4dip</item>
-        <item name="android:paddingBottom">4dip</item>
-        <item name="android:ellipsize">end</item>
-        <item name="android:singleLine">true</item>
-        <item name="android:textAllCaps">true</item>
-    </style>
-
-    <style name="TextAppearanceMedium" parent="@android:style/TextAppearance.Medium">
-        <item name="android:textSize">16sp</item>
-        <item name="android:textColor">#000000</item>
-    </style>
-
-    <style name="TextAppearanceSmall" parent="@android:style/TextAppearance.Small">
-        <item name="android:textSize">14sp</item>
-        <item name="android:textColor">#737373</item>
-    </style>
-
-    <style name="ListViewStyle" parent="@android:style/Widget.Material.Light.ListView">
-        <item name="android:overScrollMode">always</item>
-    </style>
-
-    <style name="ContactListFilterTheme" parent="@android:Theme.Holo.Light">
-        <item name="android:listViewStyle">@style/ListViewStyle</item>
-        <item name="android:actionButtonStyle">@style/FilterActionButtonStyle</item>
-    </style>
-
-    <!-- Adding padding to action button doesn't move it to left, we increase the button width to
-     make margin between the button and screen edge 16dp -->
-    <style name="FilterActionButtonStyle" parent="@android:Widget.ActionButton">
-        <item name="android:minWidth">@dimen/contact_filter_action_button_width</item>
-        <item name="android:textColor">@color/actionbar_text_color</item>
-    </style>
-
-    <style name="CustomContactListFilterView" parent="ContactListFilterTheme">
-        <item name="android:layout_width">match_parent</item>
-        <item name="android:layout_height">match_parent</item>
-    </style>
-
-    <style name="BackgroundOnlyTheme" parent="@android:style/Theme.Material.Light">
-        <item name="android:windowBackground">@null</item>
-        <item name="android:windowContentOverlay">@null</item>
-        <item name="android:windowAnimationStyle">@null</item>
-        <item name="android:windowNoTitle">true</item>
-        <!-- Activities that use this theme are background activities without obvious displays.
-            However, some also have dialogs. Therefore, it doesn't make sense to set this true.-->
-        <item name="android:windowNoDisplay">false</item>
-        <item name="android:windowIsFloating">true</item>
-    </style>
-
-    <style name="Theme.CallSubjectDialogTheme" parent="@android:style/Theme.Material.Light.Dialog">
-        <item name="android:layout_width">match_parent</item>
-        <item name="android:layout_height">match_parent</item>
-
-        <!-- No backgrounds, titles or window float -->
-        <item name="android:windowIsTranslucent">true</item>
-        <item name="android:windowNoTitle">true</item>
-        <item name="android:windowFullscreen">false</item>
-        <item name="android:windowIsFloating">true</item>
-        <item name="android:windowBackground">@android:color/transparent</item>
-        <item name="android:windowDrawsSystemBarBackgrounds">false</item>
-        <item name="android:windowContentOverlay">@null</item>
-        <item name="android:windowElevation">0dp</item>
-    </style>
-</resources>
diff --git a/res/drawable-v21/view_pager_tab_background.xml b/res/drawable-v21/view_pager_tab_background.xml
index 00c6db7..b9e0805 100644
--- a/res/drawable-v21/view_pager_tab_background.xml
+++ b/res/drawable-v21/view_pager_tab_background.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
-  ~ Copyright (C) 2015 The Android Open Source Project
+  ~ Copyright (C) 2016 The Android Open Source Project
   ~
   ~ Licensed under the Apache License, Version 2.0 (the "License");
   ~ you may not use this file except in compliance with the License.
@@ -15,8 +15,8 @@
   ~ limitations under the License
   -->
 <ripple xmlns:android="http://schemas.android.com/apk/res/android"
-    android:color="@color/tab_ripple_color">
+        android:color="@color/tab_ripple_color">
     <item android:id="@android:id/mask">
         <color android:color="@android:color/white" />
     </item>
-</ripple>
\ No newline at end of file
+</ripple>
diff --git a/res/drawable/view_pager_tab_background.xml b/res/drawable/view_pager_tab_background.xml
index f1ddbe2..9f59845 100644
--- a/res/drawable/view_pager_tab_background.xml
+++ b/res/drawable/view_pager_tab_background.xml
@@ -17,5 +17,5 @@
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
     <item
         android:state_pressed="true"
-        android:drawable="@color/primary_color_dark"/>
+        android:drawable="@color/tab_ripple_color"/>
 </selector>
\ No newline at end of file
diff --git a/res/values-land/integers.xml b/res/values-land/integers.xml
index 8bc7b04..4b26d4c 100644
--- a/res/values-land/integers.xml
+++ b/res/values-land/integers.xml
@@ -22,4 +22,9 @@
 
     <!-- Top margin ratio for the image for empty account view -->
     <integer name="empty_account_view_image_margin_divisor">6</integer>
+
+    <integer name="contact_tile_column_count_in_favorites">3</integer>
+
+    <!-- The number of characters in the snippet before we need to tokenize and ellipse. -->
+    <integer name="snippet_length_before_tokenize">60</integer>
 </resources>
diff --git a/res/values-sw600dp-land/integers.xml b/res/values-sw600dp-land/integers.xml
index 1785443..b6fe15a 100644
--- a/res/values-sw600dp-land/integers.xml
+++ b/res/values-sw600dp-land/integers.xml
@@ -26,4 +26,9 @@
 
     <!-- Top margin ratio for the image for empty account view -->
     <integer name="empty_account_view_image_margin_divisor">5</integer>
+
+    <integer name="contact_tile_column_count_in_favorites">3</integer>
+
+    <!-- The number of characters in the snippet before we need to tokenize and ellipse. -->
+    <integer name="snippet_length_before_tokenize">20</integer>
 </resources>
diff --git a/res/values-sw600dp/dimens.xml b/res/values-sw600dp/dimens.xml
index 6e4f808..6f6f4e1 100644
--- a/res/values-sw600dp/dimens.xml
+++ b/res/values-sw600dp/dimens.xml
@@ -59,4 +59,22 @@
 
     <!-- Margin offset b/w the image top and app bar bottom for no account empty view -->
     <dimen name="contacts_no_account_empty_image_offset">238dp</dimen>
+
+    <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>
+
+    <!-- End margin of the account filter header icon -->
+    <dimen name="contact_browser_list_header_icon_right_margin">22dp</dimen>
+    <dimen name="contact_browser_list_header_icon_right_margin_alt">24dp</dimen>
+
+    <dimen name="contact_filter_list_item_padding_start">24dp</dimen>
+    <dimen name="contact_filter_left_margin">16dp</dimen>
+
+    <!-- Right margin of the floating action button -->
+    <dimen name="floating_action_button_margin_right">32dp</dimen>
+    <!-- Bottom margin of the floating action button -->
+    <dimen name="floating_action_button_margin_bottom">32dp</dimen>
 </resources>
diff --git a/res/values-sw600dp/integers.xml b/res/values-sw600dp/integers.xml
index 4eb0061..4b2d73f 100644
--- a/res/values-sw600dp/integers.xml
+++ b/res/values-sw600dp/integers.xml
@@ -3,4 +3,11 @@
 <resources>
     <!-- Top margin ratio for the image for empty group view -->
     <integer name="empty_group_view_image_margin_divisor">4</integer>
-</resources>
\ No newline at end of file
+
+    <integer name="contact_tile_column_count_in_favorites">3</integer>
+
+    <!-- The number of characters in the snippet before we need to tokenize and ellipse. -->
+    <!-- Yikes, there is less space on a tablet!  This makes the search experience rather
+         poor. Another reason to get rid of the exist tablet layout. -->
+    <integer name="snippet_length_before_tokenize">15</integer>
+</resources>
diff --git a/res/values-sw720dp/integers.xml b/res/values-sw720dp/integers.xml
index 1cc510e..93bbc68 100644
--- a/res/values-sw720dp/integers.xml
+++ b/res/values-sw720dp/integers.xml
@@ -20,4 +20,9 @@
     <!-- Layout weight of the content column for tile favorites list, all contacts list, and
          QuickContact -->
     <integer name="contact_list_card_layout_weight">81</integer>
+
+    <integer name="contact_tile_column_count_in_favorites">2</integer>
+
+    <!-- The number of characters in the snippet before we need to tokenize and ellipse. -->
+    <integer name="snippet_length_before_tokenize">20</integer>
 </resources>
diff --git a/res/values/attrs.xml b/res/values/attrs.xml
index 86c46fc..e979611 100644
--- a/res/values/attrs.xml
+++ b/res/values/attrs.xml
@@ -49,4 +49,71 @@
         <attr name="layout_widePaddingRight" format="dimension"/>
     </declare-styleable>
 
+    <declare-styleable name="Theme">
+        <attr name="android:textColorSecondary" />
+    </declare-styleable>
+
+    <declare-styleable name="ContactsDataKind">
+        <!-- Mime-type handled by this mapping. -->
+        <attr name="android:mimeType" />
+        <!-- Icon used to represent data of this kind. -->
+        <attr name="android:icon" />
+        <!-- Column in data table that summarizes this data. -->
+        <attr name="android:summaryColumn" />
+        <!-- Column in data table that contains details for this data. -->
+        <attr name="android:detailColumn" />
+        <!-- Flag indicating that detail should be built from SocialProvider. -->
+        <attr name="android:detailSocialSummary" />
+        <!-- Resource representing the term "All Contacts" (e.g. "All Friends" or
+        "All connections"). Optional (Default is "All Contacts"). -->
+        <attr name="android:allContactsName" />
+    </declare-styleable>
+
+    <declare-styleable name="ContactListItemView">
+        <attr name="list_item_height" format="dimension"/>
+        <attr name="list_section_header_height" format="dimension"/>
+        <attr name="activated_background" format="reference"/>
+        <attr name="section_header_background" format="reference"/>
+        <attr name="list_item_padding_top" format="dimension"/>
+        <attr name="list_item_padding_right" format="dimension"/>
+        <attr name="list_item_padding_bottom" format="dimension"/>
+        <attr name="list_item_padding_left" format="dimension"/>
+        <attr name="list_item_gap_between_image_and_text" format="dimension"/>
+        <attr name="list_item_gap_between_indexer_and_image" format="dimension"/>
+        <attr name="list_item_gap_between_label_and_data" format="dimension"/>
+        <attr name="list_item_presence_icon_margin" format="dimension"/>
+        <attr name="list_item_presence_icon_size" format="dimension"/>
+        <attr name="list_item_photo_size" format="dimension"/>
+        <attr name="list_item_profile_photo_size" format="dimension"/>
+        <attr name="list_item_prefix_highlight_color" format="color"/>
+        <attr name="list_item_background_color" format="color"/>
+        <attr name="list_item_header_text_indent" format="dimension"/>
+        <attr name="list_item_header_text_color" format="color"/>
+        <attr name="list_item_header_text_size" format="dimension"/>
+        <attr name="list_item_header_height" format="dimension"/>
+        <attr name="list_item_name_text_color" format="color"/>
+        <attr name="list_item_name_text_size" format="dimension"/>
+        <attr name="list_item_text_indent" format="dimension"/>
+        <attr name="list_item_text_offset_top" format="dimension"/>
+        <attr name="list_item_avatar_offset_top" format="dimension"/>
+        <attr name="list_item_data_width_weight" format="integer"/>
+        <attr name="list_item_label_width_weight" format="integer"/>
+        <attr name="list_item_video_call_icon_size" format="dimension"/>
+        <attr name="list_item_video_call_icon_margin" format="dimension"/>
+    </declare-styleable>
+
+    <declare-styleable name="ContactBrowser">
+        <attr name="contact_browser_list_padding_left" format="dimension"/>
+        <attr name="contact_browser_list_padding_right" format="dimension"/>
+        <attr name="contact_browser_background" format="reference"/>
+    </declare-styleable>
+
+    <declare-styleable name="ProportionalLayout">
+        <attr name="direction" format="string"/>
+        <attr name="ratio" format="float"/>
+    </declare-styleable>
+
+    <declare-styleable name="Favorites">
+        <attr name="favorites_padding_bottom" format="dimension"/>
+    </declare-styleable>
 </resources>
diff --git a/res/values/colors.xml b/res/values/colors.xml
index f5bf4cc..37ea0ba 100644
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@@ -83,4 +83,178 @@
 
     <!-- Color of hamburger icon in promo -->
     <color name="hamburger_feature_highlight_inner_color">#00ffffff</color>
+
+    <!-- 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="ripple_material_dark">#a0ffffff</color>
+
+    <!-- Divider color for header separator -->
+    <color name="primary_text_color">#363636</color>
+
+    <color name="secondary_text_color">@color/dialtacts_secondary_text_color</color>
+
+    <!-- Text color for section header. -->
+    <color name="section_header_text_color">@color/dialtacts_theme_color</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 the theme of the Dialer app -->
+    <color name="dialtacts_theme_color">#0288d1</color>
+
+    <!-- Color of image view placeholder. -->
+    <color name="image_placeholder">#DDDDDD</color>
+
+    <!-- Primary text color in the Phone app -->
+    <color name="dialtacts_primary_text_color">#333333</color>
+
+    <!-- Secondary text color in the Phone app -->
+    <color name="dialtacts_secondary_text_color">#737373</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>
+
+    <!-- Background colors for LetterTileDrawables. This set of colors is a subset of
+        https://spec.googleplex.com/quantumpalette#extended which passes Google Accessibility
+        Requirements for the color in question on white with >= 3.0 contrast. We used
+        http://leaverou.github.io/contrast-ratio/#white-on-%23db4437 to double-check the contrast.
+
+        These colors are also used by MaterialColorMapUtils to generate primary activity colors.
+    -->
+    <array name="letter_tile_colors">
+        <item>#DB4437</item>
+        <item>#E91E63</item>
+        <item>#9C27B0</item>
+        <item>#673AB7</item>
+        <item>#3F51B5</item>
+        <item>#4285F4</item>
+        <item>#039BE5</item>
+        <item>#0097A7</item>
+        <item>#009688</item>
+        <item>#0F9D58</item>
+        <item>#689F38</item>
+        <item>#EF6C00</item>
+        <item>#FF5722</item>
+        <item>#757575</item>
+    </array>
+
+    <!-- Darker versions of letter_tile_colors, two shades darker. These colors are used
+        for settings secondary activity colors. -->
+    <array name="letter_tile_colors_dark">
+        <item>#C53929</item>
+        <item>#C2185B</item>
+        <item>#7B1FA2</item>
+        <item>#512DA8</item>
+        <item>#303F9F</item>
+        <item>#3367D6</item>
+        <item>#0277BD</item>
+        <item>#006064</item>
+        <item>#00796B</item>
+        <item>#0B8043</item>
+        <item>#33691E</item>
+        <item>#E65100</item>
+        <item>#E64A19</item>
+        <item>#424242</item>
+    </array>
+
+    <!-- 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="letter_tile_default_color">#cccccc</color>
+
+    <color name="letter_tile_font_color">#ffffff</color>
+
+    <!-- Background color of action bars. Ensure this stays in sync with packages/Telephony
+         actionbar_background_color. -->
+    <color name="actionbar_background_color">#0fc6dc</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">@color/tab_accent_color</color>
+    <color name="tab_accent_color">#ffffff</color>
+    <color name="tab_selected_underline_color">@color/tab_accent_color</color>
+    <color name="tab_unread_count_background_color">#700f4b70</color>
+
+    <!-- Color of the title to the Frequently Contacted section -->
+    <color name="frequently_contacted_title_color">@color/actionbar_background_color</color>
+
+    <!-- Color of action bar text. Ensure this stays in sync with packages/Telephony
+    phone_settings_actionbar_text_color-->
+    <color name="actionbar_text_color">#ffffff</color>
+    <!-- 54% black for icons -->
+    <color name="actionbar_icon_color_grey">#8C000000</color>
+    <!-- 87% black for actionbar text -->
+    <color name="actionbar_text_color_black">#DF000000</color>
+    <!-- Solid grey for status bar overlay-->
+    <color name="actionbar_color_grey_solid">#777777</color>
+    <color name="actionbar_unselected_text_color">#a6ffffff</color>
+
+    <!-- Text color of the search box text as entered by user  -->
+    <color name="searchbox_text_color">#000000</color>
+    <!-- Background color of the search box -->
+    <color name="searchbox_background_color">#ffffff</color>
+
+    <color name="searchbox_hint_text_color">#66000000</color>
+    <color name="searchbox_icon_tint">@color/searchbox_hint_text_color</color>
+
+    <color name="search_shortcut_icon_color">@color/dialtacts_theme_color</color>
+
+    <!-- Color of the background of the contact detail and editor pages -->
+    <color name="background_primary">#f9f9f9</color>
+    <color name="contact_all_list_background_color">#FFFFFF</color>
+
+    <!-- Text color used for character counter when the max limit has been exceeded -->
+    <color name="call_subject_limit_exceeded">#d1041c</color>
+
+    <!-- Tint color for the call subject history icon. -->
+    <color name="call_subject_history_icon">#000000</color>
+
+    <!-- Divider line on the call subject dialog. -->
+    <color name="call_subject_divider">#d8d8d8</color>
+
+    <!-- Text color for the SEND & CALL button on the call subject dialog. -->
+    <color name="call_subject_button">#00c853</color>
+
+    <!-- Background color for the call subject history view. -->
+    <color name="call_subject_history_background">#ffffff</color>
+    <color name="search_video_call_icon_tint">@color/searchbox_hint_text_color</color>
+
+    <!-- Text color for an action in a snackbar. -->
+    <color name="snackbar_action_text">#40c4ff</color>
+    <!-- Background color for a snackbar. -->
+    <color name="snackbar_background">#333333</color>
+
+    <!-- Color of account/custom filters -->
+    <color name="account_filter_text_color">@color/actionbar_text_color_black</color>
+    <color name="custom_filter_divider">#dbdbdb</color>
+
+    <color name="material_star_pink">#f50057</color>
+
+    <!-- Primary text color in Contacts app -->
+    <color name="contacts_text_color">#333333</color>
 </resources>
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index a73e449..d355021 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -321,4 +321,171 @@
 
     <!-- Margin b/w add account button and import contacts button for no account empty view -->
     <dimen name="contacts_no_account_buttons_margin">8dp</dimen>
+
+    <!-- Padding between the action bar's bottom edge and the first header
+         in contacts/group lists. -->
+    <dimen name="list_header_extra_top_padding">0dip</dimen>
+
+    <dimen name="list_section_divider_min_height">32dip</dimen>
+
+    <dimen name="directory_header_extra_top_padding">18dp</dimen>
+    <dimen name="directory_header_extra_bottom_padding">8dp</dimen>
+    <dimen name="directory_header_left_padding">16dp</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>
+
+    <!-- For contact filter setting screens -->
+    <dimen name="contact_filter_left_margin">8dp</dimen>
+    <dimen name="contact_filter_right_margin">16dip</dimen>
+    <dimen name="contact_filter_item_min_height">48dip</dimen>
+    <dimen name="contact_filter_icon_size">32dip</dimen>
+    <dimen name="contact_filter_list_item_height">56dp</dimen>
+    <dimen name="contact_filter_list_item_padding_start">16dp</dimen>
+    <!-- contact_filter_indicator is the arrow in expandable list view -->
+    <dimen name="contact_filter_indicator_padding_start">6dp</dimen>
+    <dimen name="contact_filter_indicator_padding_end">46dp</dimen>
+    <dimen name="contact_filter_action_button_width">72dp</dimen>
+
+    <!-- Padding to be used between a visible scrollbar and the contact list -->
+    <dimen name="list_visible_scrollbar_padding">32dip</dimen>
+
+    <dimen name="contact_browser_list_header_icon_left_margin">16dp</dimen>
+    <dimen name="contact_browser_list_header_icon_right_margin">14dp</dimen>
+    <dimen name="contact_browser_list_header_icon_left_margin_alt">18dp</dimen>
+    <dimen name="contact_browser_list_header_icon_right_margin_alt">16dp</dimen>
+    <dimen name="contact_browser_list_header_left_margin">16dip</dimen>
+    <dimen name="contact_browser_list_header_right_margin">@dimen/list_visible_scrollbar_padding</dimen>
+    <dimen name="contact_browser_list_item_text_indent">8dip</dimen>
+    <dimen name="contact_browser_list_header_height">48dp</dimen>
+    <dimen name="contact_browser_list_header_icon_size">24dp</dimen>
+    <dimen name="contact_browser_list_header_icon_size_alt">20dp</dimen>
+    <dimen name="contact_browser_list_header_text_margin">10dp</dimen>
+    <!-- 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">40dp</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_item_gap_between_indexer_and_image">16dp</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>
+
+    <!-- Dimensions for contact letter tiles -->
+    <dimen name="tile_letter_font_size">40dp</dimen>
+    <dimen name="tile_letter_font_size_small">20dp</dimen>
+    <dimen name="tile_divider_width">1dp</dimen>
+    <item name="letter_to_tile_ratio" type="dimen">67%</item>
+
+    <!-- Height of the floating action button -->
+    <dimen name="floating_action_button_height">56dp</dimen>
+    <!-- Width of the floating action button -->
+    <dimen name="floating_action_button_width">56dp</dimen>
+    <!-- Corner radius of the floating action button -->
+    <dimen name="floating_action_button_radius">28dp</dimen>
+    <!-- Z translation of the floating action button -->
+    <dimen name="floating_action_button_translation_z">8dp</dimen>
+    <!-- Padding to be applied to the bottom of lists to make space for the floating action
+         button -->
+    <dimen name="floating_action_button_list_bottom_padding">88dp</dimen>
+    <!-- Right margin of the floating action button -->
+    <dimen name="floating_action_button_margin_right">16dp</dimen>
+    <!-- Bottom margin of the floating action button -->
+    <dimen name="floating_action_button_margin_bottom">16dp</dimen>
+    <!-- Offset of bottom margin of the floating action button used when dialpad is up -->
+    <dimen name="floating_action_button_dialpad_margin_bottom_offset">4dp</dimen>
+
+    <!-- Height of the selection indicator of a tab. -->
+    <dimen name="tab_selected_underline_height">2dp</dimen>
+    <!-- Size of text in tabs. -->
+    <dimen name="tab_text_size">14sp</dimen>
+    <dimen name="tab_elevation">2dp</dimen>
+    <dimen name="tab_unread_count_background_size">16dp</dimen>
+    <dimen name="tab_unread_count_background_radius">2dp</dimen>
+    <dimen name="tab_unread_count_margin_left">10dp</dimen>
+    <dimen name="tab_unread_count_margin_top">2dp</dimen>
+    <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">56dp</dimen>
+    <!-- Size of the close icon.-->
+    <dimen name="search_box_close_icon_size">56dp</dimen>
+    <!-- Padding around the close button. It's visible size without padding is 24dp. -->
+    <dimen name="search_box_close_icon_padding">16dp</dimen>
+    <!-- End margin of the back arrow icon in the search box -->
+    <dimen name="search_box_navigation_icon_margin">8dp</dimen>
+    <!-- Left margin of the text field in the search box. -->
+    <dimen name="search_box_text_left_margin">8dp</dimen>
+    <!-- Search box text size -->
+    <dimen name="search_text_size">16sp</dimen>
+
+    <item name="close_icon_alpha" format="float" type="dimen">0.54</item>
+
+    <!-- Size of the close icon in selection bar.-->
+    <dimen name="selection_bar_close_icon_size">56dp</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
+         items. -->
+    <dimen name="call_subject_dialog_margin">20dp</dimen>
+    <!-- Padding used between lines of text in the call subject dialog. -->
+    <dimen name="call_subject_dialog_between_line_margin">8dp</dimen>
+    <!-- Size of the contact photo in the call subject dialog. -->
+    <dimen name="call_subject_dialog_contact_photo_size">50dp</dimen>
+    <!-- Margin above the edit text in the call subject dialog. -->
+    <dimen name="call_subject_dialog_edit_spacing">60dp</dimen>
+    <!-- Size of primary text in the call subject dialog. -->
+    <dimen name="call_subject_dialog_primary_text_size">16sp</dimen>
+    <!-- Size of secondary text in the call subject dialog. -->
+    <dimen name="call_subject_dialog_secondary_text_size">14sp</dimen>
+    <!-- Row padding for call subject history items. -->
+    <dimen name="call_subject_history_item_padding">15dp</dimen>
 </resources>
diff --git a/res/values/donottranslate_config.xml b/res/values/donottranslate_config.xml
index bfe7880..8668159 100644
--- a/res/values/donottranslate_config.xml
+++ b/res/values/donottranslate_config.xml
@@ -39,4 +39,81 @@
 
     <!-- File Authority for AOSP Contacts files -->
     <string name="contacts_file_provider_authority">com.android.contacts.files</string>
+    <!-- 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>
+
+    <!-- If true, the default sort order is primary (i.e. by given name) -->
+    <bool name="config_default_sort_order_primary">true</bool>
+
+    <!-- If true, an option is shown in Display Options UI to choose a name display order -->
+    <bool name="config_display_order_user_changeable">true</bool>
+
+    <!-- If true, the default sort order is primary (i.e. by given name) -->
+    <bool name="config_default_display_order_primary">true</bool>
+
+    <!-- If true, the order of name fields in the editor is primary (i.e. given name first) -->
+    <bool name="config_editor_field_order_primary">true</bool>
+
+    <!-- If true, an option is shown in Display Options UI to choose a default account -->
+    <bool name="config_default_account_user_changeable">true</bool>
+
+    <!-- Contacts preferences key for contact editor default account -->
+    <string name="contact_editor_default_account_key">ContactEditorUtils_default_account</string>
+
+    <!-- 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">\u2605</string>
 </resources>
diff --git a/res/values/ids.xml b/res/values/ids.xml
index f5649d9..0808496 100644
--- a/res/values/ids.xml
+++ b/res/values/ids.xml
@@ -52,4 +52,29 @@
 
     <!-- Menu group ID for the contact filters -->
     <item type="id" name="nav_filters_items" />
+
+    <!-- For vcard.ImportVCardActivity -->
+    <item type="id" name="dialog_cache_vcard"/>
+    <item type="id" name="dialog_error_with_message"/>
+
+    <!-- For vcard.CancelActivity -->
+    <item type="id" name="dialog_cancel_confirmation"/>
+    <item type="id" name="dialog_cancel_failed"/>
+
+    <!-- For ExportVCardActivity -->
+    <item type="id" name="dialog_exporting_vcard"/>
+    <item type="id" name="dialog_fail_to_export_with_reason"/>
+
+    <!-- For Debug Purpose -->
+    <item type="id" name="cliv_name_textview"/>
+    <item type="id" name="cliv_phoneticname_textview"/>
+    <item type="id" name="cliv_label_textview"/>
+    <item type="id" name="cliv_data_view"/>
+
+    <!-- For tag ids used by ContactPhotoManager to tag views with contact details -->
+    <item type="id" name="tag_display_name"/>
+    <item type="id" name="tag_identifier"/>
+    <item type="id" name="tag_contact_type"/>
+
+    <item type="id" name="menu_save"/>
 </resources>
diff --git a/res/values/integers.xml b/res/values/integers.xml
index 60034e5..9ef7810 100644
--- a/res/values/integers.xml
+++ b/res/values/integers.xml
@@ -36,4 +36,27 @@
 
     <!-- Top margin ratio for the image for empty contacts view-->
     <integer name="contacts_no_account_empty_image_margin_divisor">2</integer>
+
+    <!--  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>
+
+    <!-- Layout weight of space elements in contact list view.
+    Default to 0 to indicate no padding-->
+    <integer name="contact_list_space_layout_weight">0</integer>
+    <!-- Layout weight of card in contact list view.
+    Default to 0 to indicate no padding -->
+    <integer name="contact_list_card_layout_weight">0</integer>
+
+    <!-- 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>
+
+    <!-- Duration of the animations when a contact list loads. -->
+    <integer name="lists_on_load_animation_duration">190</integer>
 </resources>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 909b684..4fe3edc 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -963,4 +963,834 @@
     <string name="hamburger_feature_highlight_header">Organize your list</string>
     <!-- The body text for hamburger promo [CHAR LIMIT=200]-->
     <string name="hamburger_feature_highlight_body">Clean up duplicates &amp; group contacts by label</string>
+
+    <!-- Toast shown when text is copied to the clipboard [CHAR LIMIT=64] -->
+    <string name="toast_text_copied">Text copied</string>
+    <!-- Option displayed in context menu to copy long pressed item to clipboard [CHAR LIMIT=64] -->
+    <string name="copy_text">Copy to clipboard</string>
+
+    <!-- Action string for calling a custom phone number -->
+    <string name="call_custom">Call
+        <xliff:g id="custom">%s</xliff:g>
+    </string>
+    <!-- Action string for calling a home phone number -->
+    <string name="call_home">Call home</string>
+    <!-- Action string for calling a mobile phone number -->
+    <string name="call_mobile">Call mobile</string>
+    <!-- Action string for calling a work phone number -->
+    <string name="call_work">Call work</string>
+    <!-- Action string for calling a work fax phone number -->
+    <string name="call_fax_work">Call work fax</string>
+    <!-- Action string for calling a home fax phone number -->
+    <string name="call_fax_home">Call home fax</string>
+    <!-- Action string for calling a pager phone number -->
+    <string name="call_pager">Call pager</string>
+    <!-- Action string for calling an other phone number -->
+    <string name="call_other">Call</string>
+    <!-- Action string for calling a callback number -->
+    <string name="call_callback">Call callback</string>
+    <!-- Action string for calling a car phone number -->
+    <string name="call_car">Call car</string>
+    <!-- Action string for calling a company main phone number -->
+    <string name="call_company_main">Call company main</string>
+    <!-- Action string for calling a ISDN phone number -->
+    <string name="call_isdn">Call ISDN</string>
+    <!-- Action string for calling a main phone number -->
+    <string name="call_main">Call main</string>
+    <!-- Action string for calling an other fax phone number -->
+    <string name="call_other_fax">Call fax</string>
+    <!-- Action string for calling a radio phone number -->
+    <string name="call_radio">Call radio</string>
+    <!-- Action string for calling a Telex phone number -->
+    <string name="call_telex">Call telex</string>
+    <!-- Action string for calling a TTY/TDD phone number -->
+    <string name="call_tty_tdd">Call TTY/TDD</string>
+    <!-- Action string for calling a work mobile phone number -->
+    <string name="call_work_mobile">Call work mobile</string>
+    <!-- Action string for calling a work pager phone number -->
+    <string name="call_work_pager">Call work pager</string>
+    <!-- Action string for calling an assistant phone number -->
+    <string name="call_assistant">Call
+        <xliff:g id="assistant">%s</xliff:g>
+    </string>
+    <!-- Action string for calling a MMS phone number -->
+    <string name="call_mms">Call MMS</string>
+    <!-- Action string for calling a contact by shortcut -->
+    <string name="call_by_shortcut"><xliff:g id="contact_name">%s</xliff:g> (Call)</string>
+
+    <!-- Action string for sending an SMS to a custom phone number -->
+    <string name="sms_custom">Text
+        <xliff:g id="custom">%s</xliff:g>
+    </string>
+    <!-- Action string for sending an SMS to a home phone number -->
+    <string name="sms_home">Text home</string>
+    <!-- Action string for sending an SMS to a mobile phone number -->
+    <string name="sms_mobile">Text mobile</string>
+    <!-- Action string for sending an SMS to a work phone number -->
+    <string name="sms_work">Text work</string>
+    <!-- Action string for sending an SMS to a work fax phone number -->
+    <string name="sms_fax_work">Text work fax</string>
+    <!-- Action string for sending an SMS to a home fax phone number -->
+    <string name="sms_fax_home">Text home fax</string>
+    <!-- Action string for sending an SMS to a pager phone number -->
+    <string name="sms_pager">Text pager</string>
+    <!-- Action string for sending an SMS to an other phone number -->
+    <string name="sms_other">Text</string>
+    <!-- Action string for sending an SMS to a callback number -->
+    <string name="sms_callback">Text callback</string>
+    <!-- Action string for sending an SMS to a car phone number -->
+    <string name="sms_car">Text car</string>
+    <!-- Action string for sending an SMS to a company main phone number -->
+    <string name="sms_company_main">Text company main</string>
+    <!-- Action string for sending an SMS to a ISDN phone number -->
+    <string name="sms_isdn">Text ISDN</string>
+    <!-- Action string for sending an SMS to a main phone number -->
+    <string name="sms_main">Text main</string>
+    <!-- Action string for sending an SMS to an other fax phone number -->
+    <string name="sms_other_fax">Text fax</string>
+    <!-- Action string for sending an SMS to a radio phone number -->
+    <string name="sms_radio">Text radio</string>
+    <!-- Action string for sending an SMS to a Telex phone number -->
+    <string name="sms_telex">Text telex</string>
+    <!-- Action string for sending an SMS to a TTY/TDD phone number -->
+    <string name="sms_tty_tdd">Text TTY/TDD</string>
+    <!-- Action string for sending an SMS to a work mobile phone number -->
+    <string name="sms_work_mobile">Text work mobile</string>
+    <!-- Action string for sending an SMS to a work pager phone number -->
+    <string name="sms_work_pager">Text work pager</string>
+    <!-- Action string for sending an SMS to an assistant phone number -->
+    <string name="sms_assistant">Text
+        <xliff:g id="assistant">%s</xliff:g>
+    </string>
+    <!-- Action string for sending an SMS to a MMS phone number -->
+    <string name="sms_mms">Text MMS</string>
+    <!-- Action string for sending an SMS to a contact by shortcut -->
+    <string name="sms_by_shortcut"><xliff:g id="contact_name">%s</xliff:g> (Message)</string>
+
+    <!-- Description string for an action button to initiate a video call. -->
+    <string name="description_video_call">Make video call</string>
+
+    <!-- Title of the confirmation dialog for clearing frequents. [CHAR LIMIT=37] -->
+    <string name="clearFrequentsConfirmation_title">Clear frequently contacted?</string>
+
+    <!-- Confirmation dialog for clearing frequents. [CHAR LIMIT=NONE] -->
+    <string name="clearFrequentsConfirmation">You\'ll clear the frequently contacted list in the
+        Contacts and Phone apps, and force email apps to learn your addressing preferences from
+        scratch.
+    </string>
+
+    <!-- Title of the "Clearing frequently contacted" progress-dialog [CHAR LIMIT=35] -->
+    <string name="clearFrequentsProgress_title">Clearing frequently contacted\u2026</string>
+
+    <!--  Used to display as default status when the contact is available for chat [CHAR LIMIT=19] -->
+    <string name="status_available">Available</string>
+
+    <!--  Used to display as default status when the contact is away or idle for chat [CHAR LIMIT=19] -->
+    <string name="status_away">Away</string>
+
+    <!--  Used to display as default status when the contact is busy or Do not disturb for chat [CHAR LIMIT=19] -->
+    <string name="status_busy">Busy</string>
+
+    <!-- Directory partition name (also exists in contacts) -->
+    <string name="contactsList">Contacts</string>
+
+    <!-- The name of the invisible local contact directory -->
+    <string name="local_invisible_directory">Other</string>
+
+    <!-- The label in section header in the contact list for a contact directory [CHAR LIMIT=128] -->
+    <string name="directory_search_label">Directory</string>
+
+    <!-- The label in section header in the contact list for a work contact directory [CHAR LIMIT=128] -->
+    <string name="directory_search_label_work">Work directory</string>
+
+    <!-- The label in section header in the contact list for a local contacts [CHAR LIMIT=128] -->
+    <string name="local_search_label">All contacts</string>
+
+    <!-- Title shown in the search result activity of contacts app while searching.  [CHAR LIMIT=20]
+         (also in contacts) -->
+    <string name="search_results_searching">Searching\u2026</string>
+
+    <!-- Displayed at the top of search results indicating that more contacts were found than shown [CHAR LIMIT=64] -->
+    <string name="foundTooManyContacts">More than <xliff:g id="count">%d</xliff:g> found.</string>
+
+    <!-- Displayed at the top of the contacts showing the zero total number of contacts found when "Only contacts with phones" not selected. [CHAR LIMIT=30]
+         (also in contacts) -->
+    <string name="listFoundAllContactsZero">No contacts</string>
+
+    <!-- Displayed at the top of the contacts showing the total number of contacts found when typing search query -->
+    <plurals name="searchFoundContacts">
+        <item quantity="one">1 found</item>
+        <item quantity="other"><xliff:g id="count">%d</xliff:g> found</item>
+    </plurals>
+
+    <!-- String describing the text for photo of a contact in a contacts list.
+
+        Note: AccessibilityServices use this attribute to announce what the view represents.
+              This is especially valuable for views without textual representation like ImageView.
+    -->
+    <string name="description_quick_contact_for">Quick contact for <xliff:g id="name">%1$s</xliff:g></string>
+
+    <!-- Shown as the display name for a person when the name is missing or unknown. [CHAR LIMIT=18]-->
+    <string name="missing_name">(No name)</string>
+
+    <!-- The text displayed on the divider for the Favorites tab in People app indicating that items below it are frequently contacted [CHAR LIMIT = 39] -->
+    <string name="favoritesFrequentContacted">Frequently contacted</string>
+
+    <!-- String describing a contact picture that introduces users to the contact detail screen.
+
+       Used by AccessibilityService to announce the purpose of the button.
+
+       [CHAR LIMIT=NONE]
+    -->
+    <string name="description_view_contact_detail" msgid="2795575601596468581">View contact</string>
+
+    <!-- Contact list filter selection indicating that the list shows all contacts with phone numbers [CHAR LIMIT=64] -->
+    <string name="list_filter_phones">All contacts with phone numbers</string>
+
+    <!-- Contact list filter selection indicating that the list shows all work contacts with phone numbers [CHAR LIMIT=64] -->
+    <string name="list_filter_phones_work">Work profile contacts</string>
+
+    <!-- Button to view the updates from the current group on the group detail page [CHAR LIMIT=25] -->
+    <string name="view_updates_from_group">View updates</string>
+
+    <!-- Title for data source when creating or editing a contact that doesn't
+         belong to a specific account.  This contact will only exist on the phone
+         and will not be synced. [CHAR LIMIT=20]  -->
+    <string name="account_phone">Device</string>
+
+    <!-- Header that expands to list all name types when editing a structured name of a contact
+         [CHAR LIMIT=20] -->
+    <string name="nameLabelsGroup">Name</string>
+
+    <!-- Header that expands to list all nickname types when editing a nickname of a contact
+         [CHAR LIMIT=20] -->
+    <string name="nicknameLabelsGroup">Nickname</string>
+
+    <!-- Field title for the full name of a contact [CHAR LIMIT=64]-->
+    <string name="full_name">Name</string>
+    <!-- Field title for the given name of a contact -->
+    <string name="name_given">First name</string>
+    <!-- Field title for the family name of a contact -->
+    <string name="name_family">Last name</string>
+    <!-- Field title for the prefix name of a contact -->
+    <string name="name_prefix">Name prefix</string>
+    <!-- Field title for the middle name of a contact -->
+    <string name="name_middle">Middle name</string>
+    <!-- Field title for the suffix name of a contact -->
+    <string name="name_suffix">Name suffix</string>
+
+    <!-- Field title for the phonetic name of a contact [CHAR LIMIT=64]-->
+    <string name="name_phonetic">Phonetic name</string>
+
+    <!-- Field title for the phonetic given name of a contact -->
+    <string name="name_phonetic_given">Phonetic first name</string>
+    <!-- Field title for the phonetic middle name of a contact -->
+    <string name="name_phonetic_middle">Phonetic middle name</string>
+    <!-- Field title for the phonetic family name of a contact -->
+    <string name="name_phonetic_family">Phonetic last name</string>
+
+    <!-- Header that expands to list all of the types of phone numbers when editing or creating a
+         phone number for a contact [CHAR LIMIT=20] -->
+    <string name="phoneLabelsGroup">Phone</string>
+
+    <!-- Header that expands to list all of the types of email addresses when editing or creating
+         an email address for a contact [CHAR LIMIT=20] -->
+    <string name="emailLabelsGroup">Email</string>
+
+    <!-- Header that expands to list all of the types of postal addresses when editing or creating
+         an postal address for a contact [CHAR LIMIT=20] -->
+    <string name="postalLabelsGroup">Address</string>
+
+    <!-- Header that expands to list all of the types of IM account when editing or creating an IM
+         account for a contact [CHAR LIMIT=20] -->
+    <string name="imLabelsGroup">IM</string>
+
+    <!-- Header that expands to list all organization types when editing an organization of a
+         contact [CHAR LIMIT=20] -->
+    <string name="organizationLabelsGroup">Organization</string>
+
+    <!-- Header for the list of all relationships for a contact [CHAR LIMIT=20] -->
+    <string name="relationLabelsGroup">Relationship</string>
+
+    <!-- Header that expands to list all event types when editing an event of a contact
+         [CHAR LIMIT=20] -->
+    <string name="eventLabelsGroup">Special date</string>
+
+    <!-- Generic action string for text messaging a contact. Used by AccessibilityService to
+         announce the purpose of the view. [CHAR LIMIT=NONE] -->
+    <string name="sms">Text message</string>
+
+    <!-- Field title for the full postal address of a contact [CHAR LIMIT=64]-->
+    <string name="postal_address">Address</string>
+
+    <!-- Hint text for the organization name when editing -->
+    <string name="ghostData_company">Company</string>
+
+    <!-- Hint text for the organization title when editing -->
+    <string name="ghostData_title">Title</string>
+
+    <!-- The label describing the Notes field of a contact. This field allows free form text entry
+         about a contact -->
+    <string name="label_notes">Notes</string>
+
+    <!-- The label describing the SIP address field of a contact. [CHAR LIMIT=20] -->
+    <string name="label_sip_address">SIP</string>
+
+    <!-- Header that expands to list all website types when editing a website of a contact
+         [CHAR LIMIT=20] -->
+    <string name="websiteLabelsGroup">Website</string>
+
+    <!-- Header for the list of all labels for a contact [CHAR LIMIT=20] -->
+    <string name="groupsLabel">Labels</string>
+
+    <!-- Action string for sending an email to a home email address -->
+    <string name="email_home">Email home</string>
+    <!-- Action string for sending an email to a mobile email address -->
+    <string name="email_mobile">Email mobile</string>
+    <!-- Action string for sending an email to a work email address -->
+    <string name="email_work">Email work</string>
+    <!-- Action string for sending an email to an other email address -->
+    <string name="email_other">Email</string>
+    <!-- Action string for sending an email to a custom email address -->
+    <string name="email_custom">Email <xliff:g id="custom">%s</xliff:g></string>
+
+    <!-- Generic action string for sending an email -->
+    <string name="email">Email</string>
+
+    <!-- Field title for the street of a structured postal address of a contact -->
+    <string name="postal_street">Street</string>
+    <!-- Field title for the PO box of a structured postal address of a contact -->
+    <string name="postal_pobox">PO box</string>
+    <!-- Field title for the neighborhood of a structured postal address of a contact -->
+    <string name="postal_neighborhood">Neighborhood</string>
+    <!-- Field title for the city of a structured postal address of a contact -->
+    <string name="postal_city">City</string>
+    <!-- Field title for the region, or state, of a structured postal address of a contact -->
+    <string name="postal_region">State</string>
+    <!-- Field title for the postal code of a structured postal address of a contact -->
+    <string name="postal_postcode">ZIP code</string>
+    <!-- Field title for the country of a structured postal address of a contact -->
+    <string name="postal_country">Country</string>
+
+    <!-- Action string for viewing a home postal address -->
+    <string name="map_home">View home address</string>
+    <!-- Action string for viewing a work postal address -->
+    <string name="map_work">View work address</string>
+    <!-- Action string for viewing an other postal address -->
+    <string name="map_other">View address</string>
+    <!-- Action string for viewing a custom postal address -->
+    <string name="map_custom">View <xliff:g id="custom">%s</xliff:g> address</string>
+
+    <!-- Action string for starting an IM chat with the AIM protocol -->
+    <string name="chat_aim">Chat using AIM</string>
+    <!-- Action string for starting an IM chat with the MSN or Windows Live protocol -->
+    <string name="chat_msn">Chat using Windows Live</string>
+    <!-- Action string for starting an IM chat with the Yahoo protocol -->
+    <string name="chat_yahoo">Chat using Yahoo</string>
+    <!-- Action string for starting an IM chat with the Skype protocol -->
+    <string name="chat_skype">Chat using Skype</string>
+    <!-- Action string for starting an IM chat with the QQ protocol -->
+    <string name="chat_qq">Chat using QQ</string>
+    <!-- Action string for starting an IM chat with the Google Talk protocol -->
+    <string name="chat_gtalk">Chat using Google Talk</string>
+    <!-- Action string for starting an IM chat with the ICQ protocol -->
+    <string name="chat_icq">Chat using ICQ</string>
+    <!-- Action string for starting an IM chat with the Jabber protocol -->
+    <string name="chat_jabber">Chat using Jabber</string>
+
+    <!-- Generic action string for starting an IM chat -->
+    <string name="chat">Chat</string>
+
+    <!-- String describing the Contact Editor Minus button
+
+         Used by AccessibilityService to announce the purpose of the button.
+
+         [CHAR LIMIT=NONE]
+    -->
+    <string name="description_minus_button">delete</string>
+
+    <!-- Content description for the expand or collapse name fields button.
+         Clicking this button causes the name editor to toggle between showing
+         a single field where the entire name is edited at once, or multiple
+         fields corresponding to each part of the name (Name Prefix, First Name,
+         Middle Name, Last Name, Name Suffix).
+         [CHAR LIMIT=NONE] -->
+    <string name="expand_collapse_name_fields_description">Expand or collapse name fields</string>
+
+    <!-- Content description for the expand or collapse phonetic name fields button. [CHAR LIMIT=100] -->
+    <string name="expand_collapse_phonetic_name_fields_description">Expand or collapse phonetic
+        name fields</string>
+
+    <!-- Contact list filter label indicating that the list is showing all available accounts [CHAR LIMIT=64] -->
+    <string name="list_filter_all_accounts">All contacts</string>
+
+    <!-- Contact list filter label indicating that the list is showing all starred contacts [CHAR LIMIT=64] -->
+    <string name="list_filter_all_starred">Starred</string>
+
+    <!-- Contact list filter selection indicating that the list shows groups chosen by the user [CHAR LIMIT=64] -->
+    <string name="list_filter_customize">Customize</string>
+
+    <!-- Contact list filter selection indicating that the list shows only the selected contact [CHAR LIMIT=64] -->
+    <string name="list_filter_single">Contact</string>
+
+    <!-- List title for a special contacts group that covers all contacts. [CHAR LIMIT=25] -->
+    <string name="display_ungrouped">All other contacts</string>
+
+    <!-- List title for a special contacts group that covers all contacts that aren't members of any other group. [CHAR LIMIT=25] -->
+    <string name="display_all_contacts">All contacts</string>
+
+    <!-- Menu item to remove a contacts sync group. [CHAR LIMIT=40] -->
+    <string name="menu_sync_remove">Remove sync group</string>
+
+    <!-- Menu item to add a contacts sync group. [CHAR LIMIT=40] -->
+    <string name="dialog_sync_add">Add sync group</string>
+
+    <!-- Text displayed in the sync groups footer view for unknown sync groups. [CHAR LIMIT=40 -->
+    <string name="display_more_groups">More groups\u2026</string>
+
+    <!-- Warning message given to users just before they remove a currently syncing
+         group that would also cause all ungrouped contacts to stop syncing.  [CHAR LIMIT=NONE] -->
+    <string name="display_warn_remove_ungrouped">Removing \"<xliff:g id="group" example="Starred">%s</xliff:g>\" from sync will also remove any ungrouped contacts from sync.</string>
+
+    <!-- Displayed in a spinner dialog as user changes to display options are saved -->
+    <string name="savingDisplayGroups">Saving display options\u2026</string>
+
+    <!-- Menu item to indicate you are done editing a contact and want to save the changes you've made -->
+    <string name="menu_done">Done</string>
+
+    <!-- Menu item to indicate you want to cancel the current editing process and NOT save the changes you've made [CHAR LIMIT=12] -->
+    <string name="menu_doNotSave">Cancel</string>
+
+    <!-- Displayed at the top of the contacts showing single contact. [CHAR LIMIT=50] -->
+    <string name="listCustomView">Customized view</string>
+
+    <!-- Message asking user to select an account to save contacts imported from vcard or SIM card [CHAR LIMIT=64] -->
+    <string name="dialog_new_contact_account">Save imported contacts to:</string>
+
+    <!-- Action string for selecting SIM for importing contacts -->
+    <string name="import_from_sim">Import from SIM card</string>
+
+    <!-- Action string for selecting a SIM subscription for importing contacts -->
+    <string name="import_from_sim_summary">Import from SIM <xliff:g id="sim_name">^1</xliff:g> - <xliff:g id="sim_number">^2</xliff:g></string>
+
+    <!-- Action string for selecting a SIM subscription for importing contacts, without a phone number -->
+    <string name="import_from_sim_summary_no_number">Import from SIM <xliff:g id="sim_name">%1$s</xliff:g></string>
+
+    <!-- Action string for selecting a .vcf file to import contacts from [CHAR LIMIT=30] -->
+    <string name="import_from_vcf_file" product="default">Import from .vcf file</string>
+
+    <!-- Message shown in a Dialog confirming a user's cancel request toward existing vCard import.
+         The argument is file name for the vCard import the user wants to cancel.
+         [CHAR LIMIT=128] -->
+    <string name="cancel_import_confirmation_message">Cancel import of <xliff:g id="filename" example="import.vcf">%s</xliff:g>?</string>
+
+    <!-- Message shown in a Dialog confirming a user's cancel request toward existing vCard export.
+         The argument is file name for the vCard export the user wants to cancel.
+         [CHAR LIMIT=128] -->
+    <string name="cancel_export_confirmation_message">Cancel export of <xliff:g id="filename" example="export.vcf">%s</xliff:g>?</string>
+
+    <!-- Title shown in a Dialog telling users cancel vCard import/export operation is failed. [CHAR LIMIT=40] -->
+    <string name="cancel_vcard_import_or_export_failed">Couldn\'t cancel vCard import/export</string>
+
+    <!-- The failed reason which should not be shown but it may in some buggy condition. [CHAR LIMIT=40] -->
+    <string name="fail_reason_unknown">Unknown error.</string>
+
+    <!-- The failed reason shown when vCard importer/exporter could not open the file
+         specified by a user. The file name should be in the message. [CHAR LIMIT=NONE] -->
+    <string name="fail_reason_could_not_open_file">Couldn\'t open \"<xliff:g id="file_name">%s</xliff:g>\": <xliff:g id="exact_reason">%s</xliff:g>.</string>
+
+    <!-- The failed reason shown when contacts exporter fails to be initialized.
+         Some exact reason must follow this. [CHAR LIMIT=NONE]-->
+    <string name="fail_reason_could_not_initialize_exporter">Couldn\'t start the exporter: \"<xliff:g id="exact_reason">%s</xliff:g>\".</string>
+
+    <!-- The failed reason shown when there's no contact which is allowed to be exported.
+         Note that user may have contacts data but all of them are probably not allowed to be
+         exported because of security/permission reasons. [CHAR LIMIT=NONE] -->
+    <string name="fail_reason_no_exportable_contact">There is no exportable contact.</string>
+
+    <!-- The user doesn't have all permissions required to use the current screen. So
+         close the current screen and show the user this message. -->
+    <string name="missing_required_permission">You have disabled a required permission.</string>
+
+    <!-- The failed reason shown when some error happend during contacts export.
+         Some exact reason must follow this. [CHAR LIMIT=NONE] -->
+    <string name="fail_reason_error_occurred_during_export">An error occurred during export: \"<xliff:g id="exact_reason">%s</xliff:g>\".</string>
+
+    <!-- The failed reason shown when the given file name is too long for the system.
+         The length limit of each file is different in each Android device, so we don't need to
+         mention it here. [CHAR LIMIT=NONE] -->
+    <string name="fail_reason_too_long_filename">Required filename is too long (\"<xliff:g id="filename">%s</xliff:g>\").</string>
+
+    <!-- The failed reason shown when Contacts app (especially vCard importer/exporter)
+         emitted some I/O error. Exact reason will be appended by the system. [CHAR LIMIT=NONE] -->
+    <string name="fail_reason_io_error">I/O error</string>
+
+    <!-- Failure reason show when Contacts app (especially vCard importer) encountered
+         low memory problem and could not proceed its import procedure. [CHAR LIMIT=NONE] -->
+    <string name="fail_reason_low_memory_during_import">Not enough memory. The file may be too large.</string>
+
+    <!-- The failed reason shown when vCard parser was not able to be parsed by the current vCard
+         implementation. This might happen even when the input vCard is completely valid, though
+         we believe it is rather rare in the actual world. [CHAR LIMIT=NONE] -->
+    <string name="fail_reason_vcard_parse_error">Couldn\'t parse vCard for an unexpected reason.</string>
+
+    <!-- The failed reason shown when vCard importer doesn't support the format.
+         This may be shown when the vCard is corrupted [CHAR LIMIT=40] -->
+    <string name="fail_reason_not_supported">The format isn\'t supported.</string>
+
+    <!-- Fail reason shown when vCard importer failed to look over meta information stored in vCard file(s). -->
+    <string name="fail_reason_failed_to_collect_vcard_meta_info">Couldn\'t collect meta information of given vCard file(s).</string>
+
+    <!-- The failed reason shown when the import of some of vCard files failed during multiple vCard
+         files import. It includes the case where all files were failed to be imported. -->
+    <string name="fail_reason_failed_to_read_files">One or more files couldn\'t be imported (%s).</string>
+
+    <!-- The title shown when exporting vCard is successfuly finished [CHAR LIMIT=40] -->
+    <string name="exporting_vcard_finished_title">Finished exporting <xliff:g id="filename" example="export.vcf">%s</xliff:g>.</string>
+
+    <!-- The title shown when exporting vCard has finished successfully but the destination filename could not be resolved. [CHAR LIMIT=NONE] -->
+    <string name="exporting_vcard_finished_title_fallback">Finished exporting contacts.</string>
+
+    <!-- The toast message shown when exporting vCard has finished and vCards are ready to be shared [CHAR LIMIT=150]-->
+    <string name="exporting_vcard_finished_toast">Finished exporting contacts, click the notification to share contacts.</string>
+
+    <!-- The message on notification shown when exporting vCard has finished and vCards are ready to be shared [CHAR LIMIT=60]-->
+    <string name="touch_to_share_contacts">Tap to share contacts.</string>
+
+    <!-- The title shown when exporting vCard is canceled (probably by a user)
+         The argument is file name the user canceled importing.
+         [CHAR LIMIT=40] -->
+    <string name="exporting_vcard_canceled_title">Exporting <xliff:g id="filename" example="export.vcf">%s</xliff:g> canceled.</string>
+
+    <!-- Dialog title shown when the application is exporting contact data outside. [CHAR LIMIT=NONE] -->
+    <string name="exporting_contact_list_title">Exporting contact data</string>
+
+    <!-- Message shown when the application is exporting contact data outside -->
+    <string name="exporting_contact_list_message">Contact data is being exported.</string>
+
+    <!-- The error reason the vCard composer "may" emit when database is corrupted or
+         something is going wrong. Usually users should not see this text. [CHAR LIMIT=NONE] -->
+    <string name="composer_failed_to_get_database_infomation">Couldn\'t get database information.</string>
+
+    <!-- This error message shown when the user actually have no contact
+         (e.g. just after data-wiping), or, data providers of the contact list prohibits their
+         contacts from being exported to outside world via vcard exporter, etc. [CHAR LIMIT=NONE] -->
+    <string name="composer_has_no_exportable_contact">There are no exportable contacts. If you do have contacts on your phone, some data providers may not allow the contacts to be exported from the phone.</string>
+
+    <!-- The error reason the vCard composer may emit when vCard composer is not initialized
+         even when needed.
+         Users should not usually see this error message. [CHAR LIMIT=NONE] -->
+    <string name="composer_not_initialized">The vCard composer didn\'t start properly.</string>
+
+    <!-- Dialog title shown when exporting Contact data failed. [CHAR LIMIT=20] -->
+    <string name="exporting_contact_failed_title">Couldn\'t export</string>
+
+    <!-- Dialog message shown when exporting Contact data failed. [CHAR LIMIT=NONE] -->
+    <string name="exporting_contact_failed_message">The contact data wasn\'t exported.\nReason: \"<xliff:g id="fail_reason">%s</xliff:g>\"</string>
+
+    <!-- Description shown when importing vCard data.
+         The argument is the name of a contact which is being read.
+         [CHAR LIMIT=20] -->
+    <string name="importing_vcard_description">Importing <xliff:g id="name" example="Joe Due">%s</xliff:g></string>
+
+    <!-- Dialog title shown when reading vCard data failed [CHAR LIMIT=40] -->
+    <string name="reading_vcard_failed_title">Couldn\'t read vCard data</string>
+
+    <!-- The title shown when reading vCard is canceled (probably by a user)
+         [CHAR LIMIT=40] -->
+    <string name="reading_vcard_canceled_title">Reading vCard data canceled</string>
+
+    <!-- The title shown when reading vCard finished
+         The argument is file name the user imported.
+         [CHAR LIMIT=40] -->
+    <string name="importing_vcard_finished_title">Finished importing vCard <xliff:g id="filename" example="import.vcf">%s</xliff:g></string>
+
+    <!-- The title shown when importing vCard is canceled (probably by a user)
+         The argument is file name the user canceled importing.
+         [CHAR LIMIT=40] -->
+    <string name="importing_vcard_canceled_title">Importing <xliff:g id="filename" example="import.vcf">%s</xliff:g> canceled</string>
+
+    <!-- The message shown when vCard import request is accepted. The system may start that work soon, or do it later
+         when there are already other import/export requests.
+         The argument is file name the user imported.
+         [CHAR LIMIT=40] -->
+    <string name="vcard_import_will_start_message"><xliff:g id="filename" example="import.vcf">%s</xliff:g> will be imported shortly.</string>
+    <!-- The message shown when vCard import request is accepted. The system may start that work soon, or do it later when there are already other import/export requests.
+         "The file" is what a user selected for importing.
+         [CHAR LIMIT=40] -->
+    <string name="vcard_import_will_start_message_with_default_name">The file will be imported shortly.</string>
+    <!-- The message shown when a given vCard import request is rejected by the system. [CHAR LIMIT=NONE] -->
+    <string name="vcard_import_request_rejected_message">vCard import request was rejected. Try again later.</string>
+    <!-- The message shown when vCard export request is accepted. The system may start that work soon, or do it later
+         when there are already other import/export requests.
+         The argument is file name the user exported.
+         [CHAR LIMIT=40] -->
+    <string name="vcard_export_will_start_message"><xliff:g id="filename" example="import.vcf">%s</xliff:g> will be exported shortly.</string>
+
+    <!-- The message shown when a vCard export request is accepted but the destination filename could not be resolved. [CHAR LIMIT=NONE] -->
+    <string name="vcard_export_will_start_message_fallback">The file will be exported shortly.</string>
+
+    <!-- The message shown when a vCard export request is accepted and contacts will be exported shortly. [CHAR LIMIT=70]-->
+    <string name="contacts_export_will_start_message">Contacts will be exported shortly.</string>
+
+    <!-- The message shown when a given vCard export request is rejected by the system. [CHAR LIMIT=NONE] -->
+    <string name="vcard_export_request_rejected_message">vCard export request was rejected. Try again later.</string>
+    <!-- Used when file name is unknown in vCard processing. It typically happens
+         when the file is given outside the Contacts app. [CHAR LIMIT=30] -->
+    <string name="vcard_unknown_filename">contact</string>
+
+    <!-- The message shown when vCard importer is caching files to be imported into local temporary
+         data storage. [CHAR LIMIT=NONE] -->
+    <string name="caching_vcard_message">Caching vCard(s) to local temporary storage. The actual import will start soon.</string>
+
+    <!-- Message used when vCard import has failed. [CHAR LIMIT=40] -->
+    <string name="vcard_import_failed">Couldn\'t import vCard.</string>
+
+    <!-- The "file name" displayed for vCards received directly via NFC [CHAR LIMIT=16] -->
+    <string name="nfc_vcard_file_name">Contact received over NFC</string>
+
+    <!-- Dialog title shown when a user confirms whether he/she export Contact data. [CHAR LIMIT=32] -->
+    <string name="confirm_export_title">Export contacts?</string>
+
+    <!-- The title shown when vCard importer is caching files to be imported into local temporary
+         data storage.  [CHAR LIMIT=40] -->
+    <string name="caching_vcard_title">Caching</string>
+
+    <!-- The message shown while importing vCard(s).
+         First argument is current index of contacts to be imported.
+         Second argument is the total number of contacts.
+         Third argument is the name of a contact which is being read.
+         [CHAR LIMIT=20] -->
+    <string name="progress_notifier_message">Importing <xliff:g id="current_number">%s</xliff:g>/<xliff:g id="total_number">%s</xliff:g>: <xliff:g id="name" example="Joe Due">%s</xliff:g></string>
+
+    <!-- Action that exports all contacts to a user selected destination. [CHAR LIMIT=25] -->
+    <string name="export_to_vcf_file" product="default">Export to .vcf file</string>
+
+    <!-- Contact preferences related strings -->
+
+    <!-- Label of the "sort by" display option -->
+    <string name="display_options_sort_list_by">Sort by</string>
+
+    <!-- An allowable value for the "sort list by" contact display option  -->
+    <string name="display_options_sort_by_given_name">First name</string>
+
+    <!-- An allowable value for the "sort list by" contact display option  -->
+    <string name="display_options_sort_by_family_name">Last name</string>
+
+    <!-- Label of the "name format" display option [CHAR LIMIT=64]-->
+    <string name="display_options_view_names_as">Name format</string>
+
+    <!-- An allowable value for the "view names as" contact display option  -->
+    <string name="display_options_view_given_name_first">First name first</string>
+
+    <!-- An allowable value for the "view names as" contact display option  -->
+    <string name="display_options_view_family_name_first">Last name first</string>
+
+    <!--Lable of the "Accounts" in settings [CHAR LIMIT=30]-->
+    <string name="settings_accounts">Accounts</string>
+
+    <!--Label of the "default account" setting option to set default editor account. [CHAR LIMIT=80]-->
+    <string name="default_editor_account">Default account for new contacts</string>
+
+    <!--Label of the "Sync contact metadata" setting option to set sync account for Lychee. [CHAR LIMIT=80]-->
+    <string name="sync_contact_metadata_title">Sync contact metadata [DOGFOOD]</string>
+
+    <!--Label of the "Sync contact metadata" setting dialog to set sync account for Lychee. [CHAR LIMIT=80]-->
+    <string name="sync_contact_metadata_dialog_title">Sync contact metadata</string>
+
+    <!-- Title of my info preference, showing the name of user's personal profile [CHAR LIMIT=30]-->
+    <string name="settings_my_info_title">My info</string>
+
+    <!-- Displayed below my info for user to set up the user's personal profile entry [CHAR LIMIT=64] -->
+    <string name="set_up_profile">Set up your profile</string>
+
+    <!-- Label of the "About" setting -->
+    <string name="setting_about">About Contacts</string>
+
+    <!-- Title of the settings activity [CHAR LIMIT=64] -->
+    <string name="activity_title_settings">Settings</string>
+
+    <!-- Action that shares visible contacts -->
+    <string name="share_visible_contacts">Share visible contacts</string>
+
+    <!-- A framework exception (ie, transaction too large) can be thrown while attempting to share all visible contacts. If so, show this toast. -->
+    <string name="share_visible_contacts_failure">Failed to share visible contacts.</string>
+
+    <!-- Action that shares favorite contacts [CHAR LIMIT=40]-->
+    <string name="share_favorite_contacts">Share favorite contacts</string>
+
+    <!-- Action that shares contacts [CHAR LIMIT=30]-->
+    <string name="share_contacts">Share all contacts</string>
+
+    <!-- A framework exception can be thrown while attempting to share all contacts. If so, show this toast. [CHAR LIMIT=40]-->
+    <string name="share_contacts_failure">Failed to share contacts.</string>
+
+    <!-- Dialog title when selecting the bulk operation to perform from a list. [CHAR LIMIT=36] -->
+    <string name="dialog_import_export">Import/export contacts</string>
+
+    <!-- Dialog title when importing contacts from an external source. [CHAR LIMIT=36] -->
+    <string name="dialog_import">Import contacts</string>
+
+    <!-- Toast indicating that sharing a contact has failed. [CHAR LIMIT=NONE]  -->
+    <string name="share_error">This contact can\'t be shared.</string>
+
+    <!-- Toast indicating that no visible contact to share [CHAR LIMIT=NONE]  -->
+    <string name="no_contact_to_share">There are no contacts to share.</string>
+
+    <!-- Menu item to search contacts -->
+    <string name="menu_search">Search</string>
+
+    <!-- The menu item to filter the list of contacts displayed -->
+    <string name="menu_contacts_filter">Contacts to display</string>
+
+    <!-- Title of the activity that allows the uesr to filter the list of contacts displayed according to account [CHAR LIMIT=25] -->
+    <string name="activity_title_contacts_filter">Contacts to display</string>
+
+    <!-- Title of the activity that allows the user to customize filtering of contact list [CHAR LIMIT=128] -->
+    <string name="custom_list_filter">Define customized view</string>
+
+    <!-- Menu item to save changes to custom filter. [CHAR LIMIT=15] -->
+    <string name="menu_custom_filter_save">Save</string>
+
+    <!-- Query hint displayed inside the search field [CHAR LIMIT=64] -->
+    <string name="hint_findContacts">Search contacts</string>
+
+    <!-- The description text for the favorites tab.
+
+         Note: AccessibilityServices use this attribute to announce what the view represents.
+         This is especially valuable for views without textual representation like ImageView.
+
+         [CHAR LIMIT=NONE] -->
+    <string name="contactsFavoritesLabel">Favorites</string>
+
+    <!-- Displayed at the top of the contacts showing the zero total number of contacts visible when "All contacts" is selected  [CHAR LIMIT=64]-->
+    <string name="listTotalAllContactsZero">No contacts.</string>
+
+    <!--  The menu item to clear frequents [CHAR LIMIT=30] -->
+    <string name="menu_clear_frequents">Clear frequents</string>
+
+    <!-- Menu item to select SIM card -->
+    <string name="menu_select_sim">Select SIM card</string>
+
+    <!-- The menu item to open the list of accounts. [CHAR LIMIT=60]-->
+    <string name="menu_accounts">Manage accounts</string>
+
+    <!-- The menu item to bulk import or bulk export contacts from SIM card or SD card.  [CHAR LIMIT=30]-->
+    <string name="menu_import_export">Import/export</string>
+
+    <!-- The menu item to open blocked numbers activity [CHAR LIMIT=60]-->
+    <string name="menu_blocked_numbers">Blocked numbers</string>
+
+    <!-- The font-family to use for tab text.
+         Do not translate. -->
+    <string name="tab_font_family">sans-serif</string>
+
+    <!-- Attribution of a contact status update, when the time of update is unknown -->
+    <string name="contact_status_update_attribution">via <xliff:g id="source" example="Google Talk">%1$s</xliff:g></string>
+
+    <!-- Attribution of a contact status update, when the time of update is known -->
+    <string name="contact_status_update_attribution_with_date"><xliff:g id="date" example="3 hours ago">%1$s</xliff:g> via <xliff:g id="source" example="Google Talk">%2$s</xliff:g></string>
+
+    <!-- Font family used when drawing letters for letter tile avatars.
+         Do not translate. -->
+    <string name="letter_tile_letter_font_family">sans-serif-medium</string>
+
+    <!-- Content description for the fake action menu up button as used
+     inside search. [CHAR LIMIT=NONE] -->
+    <string name="action_menu_back_from_search">stop searching</string>
+
+    <!--  String describing the icon used to clear the search field -->
+    <string name="description_clear_search">Clear search</string>
+
+    <!-- The font-family to use for the text inside the searchbox.
+         Do not translate. -->
+    <string name="search_font_family">sans-serif</string>
+
+    <!-- The title of the preference section that allows users to configure how they want their
+         contacts to be displayed. [CHAR LIMIT=128] -->
+    <string name="settings_contact_display_options_title">Contact display options</string>
+
+    <!-- Title for Select Account Dialog [CHAR LIMIT=30] -->
+    <string name="select_account_dialog_title">Account</string>
+
+    <!-- Label for the check box to toggle default sim card setting [CHAR LIMIT=35]-->
+    <string name="set_default_account">Always use this for calls</string>
+
+    <!-- Title for dialog to select Phone Account for outgoing call.  [CHAR LIMIT=40] -->
+    <string name="select_phone_account_for_calls">Call with</string>
+
+    <!-- String used for actions in the dialer call log and the quick contact card to initiate
+         a call to an individual.  The user is prompted to enter a note which is sent along with
+         the call (e.g. a call subject). [CHAR LIMIT=40] -->
+    <string name="call_with_a_note">Call with a note</string>
+
+    <!-- Hint text shown in the call subject dialog. [CHAR LIMIT=255] -->
+    <string name="call_subject_hint">Type a note to send with call ...</string>
+
+    <!-- Button used to start a new call with the user entered subject. [CHAR LIMIT=32] -->
+    <string name="send_and_call_button">SEND &amp; CALL</string>
+
+    <!-- String used to represent the total number of characters entered for a call subject,
+         compared to the character limit.  Example: 2 / 64 -->
+    <string name="call_subject_limit"><xliff:g id="count" example="4">%1$s</xliff:g> / <xliff:g id="limit" example="64">%2$s</xliff:g></string>
+
+    <!-- String used to build a phone number bype and phone number string.
+         Example: Mobile • 650-555-1212  -->
+    <string name="call_subject_type_and_number"><xliff:g id="type" example="Mobile">%1$s</xliff:g> • <xliff:g id="number" example="(650) 555-1212">%2$s</xliff:g></string>
+
+    <!-- String format to describe the number of unread items in a tab.
+
+        Note: AccessibilityServices use this attribute to announce what the view represents.
+              This is especially valuable for views without textual representation like ImageView.
+    -->
+    <plurals name="tab_title_with_unread_items">
+        <item quantity="one">
+            <xliff:g id="title">%1$s</xliff:g>. <xliff:g id="count">%2$d</xliff:g> unread item.
+        </item>
+        <item quantity="other">
+            <xliff:g id="title">%1$s</xliff:g>. <xliff:g id="count">%2$d</xliff:g> unread items.
+        </item>
+    </plurals>
+
+    <!-- Build version title in About preference. [CHAR LIMIT=40]-->
+    <string name="about_build_version">Build version</string>
+
+    <!-- Open source licenses title in About preference. [CHAR LIMIT=60] -->
+    <string name="about_open_source_licenses">Open source licenses</string>
+
+    <!-- Open source licenses summary in About preference. [CHAR LIMIT=NONE] -->
+    <string name="about_open_source_licenses_summary">License details for open source software</string>
+
+    <!-- Privacy policy title in About preference. [CHAR LIMIT=40]-->
+    <string name="about_privacy_policy">Privacy policy</string>
+
+    <!-- Terms of service title in about preference. [CHAR LIMIT=60]-->
+    <string name="about_terms_of_service">Terms of service</string>
+
+    <!-- Title for the activity that displays licenses for open source libraries. [CHAR LIMIT=100]-->
+    <string name="activity_title_licenses">Open source licenses</string>
+
+    <!-- Toast message showing when failed to open the url. [CHAR LIMIT=100]-->
+    <string name="url_open_error_toast">Failed to open the url.</string>
+
+    <!-- Content description of entries (including that radio button is checked) in contact
+         accounts list filter. For example: Google abc@gmail.com checked, etc [CHAR LIMIT=30]-->
+    <string name="account_filter_view_checked"><xliff:g id="account_info">%s</xliff:g> checked</string>
+
+    <!-- Content description of entries (including that the radio button is not checked) in contact
+         accounts list filter. For example: Google abc@gmail.com not checked, etc [CHAR LIMIT=30]-->
+    <string name="account_filter_view_not_checked"><xliff:g id="account_info">%s</xliff:g> not checked</string>
+
+    <!-- Description string for an action button to initiate a video call from search results.
+         Note: AccessibilityServices use this attribute to announce what the view represents.
+         This is especially valuable for views without textual representation like ImageView.
+
+         [CHAR LIMIT=NONE]-->
+    <string name="description_search_video_call">Place video call</string>
+
+    <!-- Content description of delete contact button [CHAR LIMIT=30]-->
+    <string name="description_delete_contact">Delete</string>
+
+    <!-- Content description for (...) in no name header [CHAR LIMIT=30]-->
+    <string name="description_no_name_header">Ellipsis</string>
 </resources>
diff --git a/res/values/styles.xml b/res/values/styles.xml
index 9c6ace4..9ff882d 100644
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@@ -434,4 +434,98 @@
         <item name="android:fontFamily">sans-serif-medium</item>
         <item name="android:textAllCaps">true</item>
     </style>
+    <style name="DirectoryHeader">
+        <item name="android:background">@android:color/transparent</item>
+    </style>
+
+    <style name="SectionHeaderStyle" parent="@android:style/TextAppearance.Large">
+        <item name="android:textSize">16sp</item>
+        <item name="android:textAllCaps">true</item>
+        <item name="android:textColor">@color/section_header_text_color</item>
+        <item name="android:textStyle">bold</item>
+    </style>
+
+    <style name="DirectoryHeaderStyle" parent="@android:style/TextAppearance.Small">
+        <item name="android:textSize">14sp</item>
+        <item name="android:textColor">@color/dialtacts_secondary_text_color</item>
+        <item name="android:fontFamily">sans-serif-medium</item>
+    </style>
+
+    <!-- TextView style used for headers.
+
+This is similar to ?android:attr/listSeparatorTextView but uses different
+background and text color. See also android:style/Widget.Holo.TextView.ListSeparator
+(which is private, so we cannot specify it as a parent style).  -->
+    <style name="ContactListSeparatorTextViewStyle">
+        <item name="android:layout_width">match_parent</item>
+        <item name="android:layout_height">wrap_content</item>
+        <!-- See comments for @dimen/list_section_divider_min_height -->
+        <item name="android:minHeight">@dimen/list_section_divider_min_height</item>
+        <item name="android:textAppearance">@style/DirectoryHeaderStyle</item>
+        <item name="android:gravity">center_vertical</item>
+        <item name="android:paddingLeft">8dip</item>
+        <item name="android:paddingStart">8dip</item>
+        <item name="android:paddingTop">4dip</item>
+        <item name="android:paddingBottom">4dip</item>
+        <item name="android:ellipsize">end</item>
+        <item name="android:singleLine">true</item>
+        <item name="android:textAllCaps">true</item>
+    </style>
+
+    <style name="TextAppearanceMedium" parent="@android:style/TextAppearance.Medium">
+        <item name="android:textSize">16sp</item>
+        <item name="android:textColor">#000000</item>
+    </style>
+
+    <style name="TextAppearanceSmall" parent="@android:style/TextAppearance.Small">
+        <item name="android:textSize">14sp</item>
+        <item name="android:textColor">#737373</item>
+    </style>
+
+    <style name="ListViewStyle" parent="@android:style/Widget.Material.Light.ListView">
+        <item name="android:overScrollMode">always</item>
+    </style>
+
+    <style name="ContactListFilterTheme" parent="@android:Theme.Holo.Light">
+        <item name="android:listViewStyle">@style/ListViewStyle</item>
+        <item name="android:actionButtonStyle">@style/FilterActionButtonStyle</item>
+    </style>
+
+    <!-- Adding padding to action button doesn't move it to left, we increase the button width to
+     make margin between the button and screen edge 16dp -->
+    <style name="FilterActionButtonStyle" parent="@android:Widget.ActionButton">
+        <item name="android:minWidth">@dimen/contact_filter_action_button_width</item>
+        <item name="android:textColor">@color/actionbar_text_color</item>
+    </style>
+
+    <style name="CustomContactListFilterView" parent="ContactListFilterTheme">
+        <item name="android:layout_width">match_parent</item>
+        <item name="android:layout_height">match_parent</item>
+    </style>
+
+    <style name="BackgroundOnlyTheme" parent="@android:style/Theme.Material.Light">
+        <item name="android:windowBackground">@null</item>
+        <item name="android:windowContentOverlay">@null</item>
+        <item name="android:windowAnimationStyle">@null</item>
+        <item name="android:windowNoTitle">true</item>
+        <!-- Activities that use this theme are background activities without obvious displays.
+            However, some also have dialogs. Therefore, it doesn't make sense to set this true.-->
+        <item name="android:windowNoDisplay">false</item>
+        <item name="android:windowIsFloating">true</item>
+    </style>
+
+    <style name="Theme.CallSubjectDialogTheme" parent="@android:style/Theme.Material.Light.Dialog">
+        <item name="android:layout_width">match_parent</item>
+        <item name="android:layout_height">match_parent</item>
+
+        <!-- No backgrounds, titles or window float -->
+        <item name="android:windowIsTranslucent">true</item>
+        <item name="android:windowNoTitle">true</item>
+        <item name="android:windowFullscreen">false</item>
+        <item name="android:windowIsFloating">true</item>
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowDrawsSystemBarBackgrounds">false</item>
+        <item name="android:windowContentOverlay">@null</item>
+        <item name="android:windowElevation">0dp</item>
+    </style>
 </resources>
diff --git a/src/com/android/contacts/editor/LabeledEditorView.java b/src/com/android/contacts/editor/LabeledEditorView.java
index 61c1061..947f35e 100644
--- a/src/com/android/contacts/editor/LabeledEditorView.java
+++ b/src/com/android/contacts/editor/LabeledEditorView.java
@@ -37,6 +37,7 @@
 import android.widget.AdapterView.OnItemSelectedListener;
 import android.widget.ArrayAdapter;
 import android.widget.Button;
+import android.widget.CheckedTextView;
 import android.widget.EditText;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
@@ -44,10 +45,10 @@
 import android.widget.TextView;
 
 import com.android.contacts.R;
-import com.android.contacts.common.model.RawContactDelta;
 import com.android.contacts.common.ContactsUtils;
-import com.android.contacts.common.model.ValuesDelta;
+import com.android.contacts.common.model.RawContactDelta;
 import com.android.contacts.common.model.RawContactModifier;
+import com.android.contacts.common.model.ValuesDelta;
 import com.android.contacts.common.model.account.AccountType.EditType;
 import com.android.contacts.common.model.dataitem.DataKind;
 import com.android.contacts.util.DialogManager;
@@ -86,6 +87,7 @@
     private DialogManager mDialogManager = null;
     private EditorListener mListener;
     protected int mMinLineItemHeight;
+    private int mSelectedLabelIndex;
 
     /**
      * A marker in the spinner adapter of the currently selected custom type.
@@ -292,6 +294,7 @@
      */
     public void rebuildLabel() {
         mEditTypeAdapter = new EditTypeAdapter(getContext());
+        mEditTypeAdapter.setSelectedIndex(mSelectedLabelIndex);
         mLabel.setAdapter(mEditTypeAdapter);
         if (mEditTypeAdapter.hasCustomSelection()) {
             mLabel.setSelection(mEditTypeAdapter.getPosition(CUSTOM_SELECTION));
@@ -518,6 +521,7 @@
             // User picked type, and we're sure it's ok to actually write the entry.
             mType = selected;
             mEntry.put(mKind.typeColumn, mType.rawValue);
+            mSelectedLabelIndex = position;
             rebuildLabel();
             requestFocusForFirstEditField();
             onLabelRebuilt();
@@ -563,6 +567,7 @@
         private boolean mHasCustomSelection;
         private int mTextColorHintUnfocused;
         private int mTextColorDark;
+        private int mSelectedIndex;
 
         public EditTypeAdapter(Context context) {
             super(context, 0);
@@ -609,8 +614,11 @@
 
         @Override
         public View getDropDownView(int position, View convertView, ViewGroup parent) {
-            return createViewFromResource(
+            final CheckedTextView dropDownView = (CheckedTextView) createViewFromResource(
                     position, convertView, parent, android.R.layout.simple_spinner_dropdown_item);
+            dropDownView.setBackground(getContext().getDrawable(R.drawable.drawer_item_background));
+            dropDownView.setChecked(position == mSelectedIndex);
+            return dropDownView;
         }
 
         private TextView createViewFromResource(int position, View convertView, ViewGroup parent,
@@ -636,5 +644,9 @@
             textView.setText(text);
             return textView;
         }
+
+        public void setSelectedIndex(int selectedIndex) {
+            mSelectedIndex = selectedIndex;
+        }
     }
 }
diff --git a/tests/Android.mk b/tests/Android.mk
index f018d3e..48a00f4 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -7,11 +7,8 @@
 
 LOCAL_STATIC_JAVA_LIBRARIES := android-support-test
 
-src_dirs := src
-res_dirs := res res-common
-
-LOCAL_SRC_FILES := $(call all-java-files-under, $(src_dirs))
-LOCAL_RESOURCE_DIR := $(addprefix $(LOCAL_PATH)/, $(res_dirs))
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+LOCAL_RESOURCE_DIR := $(addprefix $(LOCAL_PATH)/, res)
 
 LOCAL_PACKAGE_NAME := ContactsTests
 
