diff --git a/icons/res/mipmap-hdpi/ic_contacts_launcher.png b/icons/res/mipmap-hdpi/ic_contacts_launcher.png
new file mode 100644
index 0000000..86380d1
--- /dev/null
+++ b/icons/res/mipmap-hdpi/ic_contacts_launcher.png
Binary files differ
diff --git a/icons/res/mipmap-mdpi/ic_contacts_launcher.png b/icons/res/mipmap-mdpi/ic_contacts_launcher.png
new file mode 100644
index 0000000..85132c5
--- /dev/null
+++ b/icons/res/mipmap-mdpi/ic_contacts_launcher.png
Binary files differ
diff --git a/icons/res/mipmap-xhdpi/ic_contacts_launcher.png b/icons/res/mipmap-xhdpi/ic_contacts_launcher.png
new file mode 100644
index 0000000..c198749
--- /dev/null
+++ b/icons/res/mipmap-xhdpi/ic_contacts_launcher.png
Binary files differ
diff --git a/icons/res/mipmap-xxhdpi/ic_contacts_launcher.png b/icons/res/mipmap-xxhdpi/ic_contacts_launcher.png
new file mode 100644
index 0000000..4fa10a6
--- /dev/null
+++ b/icons/res/mipmap-xxhdpi/ic_contacts_launcher.png
Binary files differ
diff --git a/icons/res/mipmap-xxxhdpi/ic_contacts_launcher.png b/icons/res/mipmap-xxxhdpi/ic_contacts_launcher.png
new file mode 100644
index 0000000..10bda63
--- /dev/null
+++ b/icons/res/mipmap-xxxhdpi/ic_contacts_launcher.png
Binary files differ
diff --git a/res-common/drawable-hdpi/ic_menu_settings_holo_light.png b/res-common/drawable-hdpi/ic_menu_settings_holo_light.png
new file mode 100644
index 0000000..b7bb5c4
--- /dev/null
+++ b/res-common/drawable-hdpi/ic_menu_settings_holo_light.png
Binary files differ
diff --git a/res-common/drawable-hdpi/unknown_source.png b/res-common/drawable-hdpi/unknown_source.png
new file mode 100644
index 0000000..0a8f37d
--- /dev/null
+++ b/res-common/drawable-hdpi/unknown_source.png
Binary files differ
diff --git a/res-common/drawable-ldrtl-hdpi/ic_menu_settings_holo_light.png b/res-common/drawable-ldrtl-hdpi/ic_menu_settings_holo_light.png
new file mode 100644
index 0000000..c3d86ca
--- /dev/null
+++ b/res-common/drawable-ldrtl-hdpi/ic_menu_settings_holo_light.png
Binary files differ
diff --git a/res-common/drawable-ldrtl-mdpi/ic_menu_settings_holo_light.png b/res-common/drawable-ldrtl-mdpi/ic_menu_settings_holo_light.png
new file mode 100644
index 0000000..ac172b2
--- /dev/null
+++ b/res-common/drawable-ldrtl-mdpi/ic_menu_settings_holo_light.png
Binary files differ
diff --git a/res-common/drawable-ldrtl-xhdpi/ic_menu_settings_holo_light.png b/res-common/drawable-ldrtl-xhdpi/ic_menu_settings_holo_light.png
new file mode 100644
index 0000000..d3a334a
--- /dev/null
+++ b/res-common/drawable-ldrtl-xhdpi/ic_menu_settings_holo_light.png
Binary files differ
diff --git a/res-common/drawable-mdpi/ic_menu_settings_holo_light.png b/res-common/drawable-mdpi/ic_menu_settings_holo_light.png
new file mode 100644
index 0000000..1ebc112
--- /dev/null
+++ b/res-common/drawable-mdpi/ic_menu_settings_holo_light.png
Binary files differ
diff --git a/res-common/drawable-mdpi/ic_menu_star_holo_light.png b/res-common/drawable-mdpi/ic_menu_star_holo_light.png
new file mode 100644
index 0000000..8263b27
--- /dev/null
+++ b/res-common/drawable-mdpi/ic_menu_star_holo_light.png
Binary files differ
diff --git a/res-common/drawable-mdpi/unknown_source.png b/res-common/drawable-mdpi/unknown_source.png
new file mode 100644
index 0000000..356748f
--- /dev/null
+++ b/res-common/drawable-mdpi/unknown_source.png
Binary files differ
diff --git a/res-common/drawable-xhdpi/ic_menu_settings_holo_light.png b/res-common/drawable-xhdpi/ic_menu_settings_holo_light.png
new file mode 100644
index 0000000..68ba92b
--- /dev/null
+++ b/res-common/drawable-xhdpi/ic_menu_settings_holo_light.png
Binary files differ
diff --git a/res-common/drawable-xhdpi/unknown_source.png b/res-common/drawable-xhdpi/unknown_source.png
new file mode 100644
index 0000000..35e8fb4
--- /dev/null
+++ b/res-common/drawable-xhdpi/unknown_source.png
Binary files differ
diff --git a/res-common/drawable-xxhdpi/ic_menu_settings_holo_light.png b/res-common/drawable-xxhdpi/ic_menu_settings_holo_light.png
new file mode 100644
index 0000000..5b672a3
--- /dev/null
+++ b/res-common/drawable-xxhdpi/ic_menu_settings_holo_light.png
Binary files differ
diff --git a/res-common/layout/contact_list_filter.xml b/res-common/layout/contact_list_filter.xml
new file mode 100644
index 0000000..d419c7e
--- /dev/null
+++ b/res-common/layout/contact_list_filter.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Copyright (C) 2011 The Android Open Source Project
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  -->
+
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    android:fillViewport="true">
+
+    <ListView
+        android:id="@android:id/list"
+        android:layout_width="match_parent"
+        android:layout_height="0dip"
+        android:layout_weight="1"
+        android:layout_marginLeft="@dimen/contact_filter_left_margin"
+        android:layout_marginRight="@dimen/contact_filter_right_margin"
+        android:layout_marginStart="@dimen/contact_filter_left_margin"
+        android:layout_marginEnd="@dimen/contact_filter_right_margin" />
+
+    <View
+        android:layout_width="match_parent"
+        android:layout_height="1dip"
+        android:layout_marginLeft="16dip"
+        android:layout_marginRight="16dip"
+        android:layout_marginStart="16dip"
+        android:layout_marginEnd="16dip"
+        android:background="?android:attr/dividerHorizontal" />
+</LinearLayout>
diff --git a/res-common/layout/contact_list_filter_custom.xml b/res-common/layout/contact_list_filter_custom.xml
new file mode 100644
index 0000000..b6d9229
--- /dev/null
+++ b/res-common/layout/contact_list_filter_custom.xml
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2007 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    style="@style/CustomContactListFilterView"
+    android:orientation="vertical"
+    android:fillViewport="true">
+
+    <ExpandableListView
+        android:id="@android:id/list"
+        android:layout_width="match_parent"
+        android:layout_height="0dip"
+        android:layout_weight="1"
+        android:layout_marginLeft="@dimen/contact_filter_left_margin"
+        android:layout_marginRight="@dimen/contact_filter_right_margin"
+        android:layout_marginStart="@dimen/contact_filter_left_margin"
+        android:layout_marginEnd="@dimen/contact_filter_right_margin"
+        android:overScrollMode="always" />
+
+    <View
+        android:layout_width="match_parent"
+        android:layout_height="1dip"
+        android:layout_marginLeft="16dip"
+        android:layout_marginRight="16dip"
+        android:layout_marginStart="16dip"
+        android:layout_marginEnd="16dip"
+        android:background="?android:attr/dividerHorizontal" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        style="?android:attr/buttonBarStyle">
+
+        <Button
+            android:id="@+id/btn_discard"
+            style="?android:attr/buttonBarButtonStyle"
+            android:layout_width="0dip"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@android:string/cancel" />
+
+        <Button
+            android:id="@+id/btn_done"
+            style="?android:attr/buttonBarButtonStyle"
+            android:layout_width="0dip"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@android:string/ok" />
+
+    </LinearLayout>
+</LinearLayout>
diff --git a/res-common/layout/contact_list_filter_item.xml b/res-common/layout/contact_list_filter_item.xml
new file mode 100644
index 0000000..09bbe55
--- /dev/null
+++ b/res-common/layout/contact_list_filter_item.xml
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2010 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<view
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    class="com.android.contacts.common.list.ContactListFilterView"
+    android:descendantFocusability="blocksDescendants"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:minHeight="@dimen/contact_filter_item_min_height"
+    android:gravity="center_vertical">
+
+    <ImageView
+        android:id="@+id/icon"
+        android:scaleType="fitCenter"
+        android:layout_width="@dimen/contact_filter_icon_size"
+        android:layout_height="@dimen/contact_filter_icon_size"/>
+
+    <LinearLayout
+        android:layout_width="0dip"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:orientation="vertical"
+        android:layout_marginLeft="8dip"
+        android:layout_marginStart="8dip">
+
+        <TextView
+            android:id="@+id/accountType"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:textAppearance="?android:attr/textAppearanceMedium"
+            android:singleLine="true"
+            android:ellipsize="end"/>
+
+        <TextView
+            android:id="@+id/accountUserName"
+            android:layout_marginTop="-3dip"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:textAppearance="?android:attr/textAppearanceSmall"
+            android:textColor="?android:attr/textColorTertiary"
+            android:singleLine="true"
+            android:ellipsize="end"/>
+    </LinearLayout>
+
+    <RadioButton
+        android:id="@+id/radioButton"
+        android:clickable="false"
+        android:layout_marginTop="1dip"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="end|center_vertical" />
+</view>
+
diff --git a/res-common/layout/custom_contact_list_filter_account.xml b/res-common/layout/custom_contact_list_filter_account.xml
new file mode 100644
index 0000000..b1f3f2b
--- /dev/null
+++ b/res-common/layout/custom_contact_list_filter_account.xml
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2009 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:minHeight="?android:attr/listPreferredItemHeight"
+    android:gravity="center_vertical"
+    android:paddingLeft="?android:attr/expandableListPreferredItemPaddingLeft"
+    android:paddingRight="?android:attr/scrollbarSize"
+    android:paddingStart="?android:attr/expandableListPreferredItemPaddingLeft"
+    android:paddingEnd="?android:attr/scrollbarSize">
+
+    <RelativeLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginRight="6dip"
+        android:layout_marginEnd="6dip"
+        android:layout_marginTop="6dip"
+        android:layout_marginBottom="6dip"
+        android:layout_weight="1"
+        android:duplicateParentState="true">
+
+        <TextView
+            android:id="@android:id/text1"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:singleLine="true"
+            android:ellipsize="marquee"
+            android:textAppearance="?android:attr/textAppearanceMedium"
+            android:duplicateParentState="true" />
+
+        <TextView
+            android:id="@android:id/text2"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_below="@android:id/text1"
+            android:layout_alignLeft="@android:id/text1"
+            android:layout_alignStart="@android:id/text1"
+            android:maxLines="1"
+            android:textAppearance="?android:attr/textAppearanceSmall"
+            android:textColor="?android:attr/textColorTertiary"
+            android:duplicateParentState="true" />
+
+    </RelativeLayout>
+
+</LinearLayout>
diff --git a/res-common/layout/custom_contact_list_filter_group.xml b/res-common/layout/custom_contact_list_filter_group.xml
new file mode 100644
index 0000000..bd8c604
--- /dev/null
+++ b/res-common/layout/custom_contact_list_filter_group.xml
@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2009 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:minHeight="?android:attr/listPreferredItemHeight"
+    android:gravity="center_vertical"
+    android:paddingLeft="?android:attr/expandableListPreferredItemPaddingLeft"
+    android:paddingRight="?android:attr/scrollbarSize"
+    android:paddingStart="?android:attr/expandableListPreferredItemPaddingLeft"
+    android:paddingEnd="?android:attr/scrollbarSize"
+>
+
+    <RelativeLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginRight="6dip"
+        android:layout_marginEnd="6dip"
+        android:layout_marginTop="6dip"
+        android:layout_marginBottom="6dip"
+        android:layout_weight="1"
+        android:duplicateParentState="true"
+    >
+
+        <TextView
+            android:id="@android:id/text1"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:singleLine="true"
+            android:ellipsize="marquee"
+            android:textAppearance="?android:attr/textAppearanceMedium"
+            android:duplicateParentState="true"
+        />
+
+        <TextView
+            android:id="@android:id/text2"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_below="@android:id/text1"
+            android:layout_alignLeft="@android:id/text1"
+            android:layout_alignStart="@android:id/text1"
+            android:maxLines="2"
+            android:textAppearance="?android:attr/textAppearanceSmall"
+            android:duplicateParentState="true"
+        />
+
+    </RelativeLayout>
+
+    <CheckBox
+        android:id="@android:id/checkbox"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginRight="4dip"
+        android:layout_marginEnd="4dip"
+        android:focusable="false"
+        android:clickable="false"
+        android:gravity="center_vertical"
+        android:orientation="vertical"
+        android:duplicateParentState="true"
+    />
+
+</LinearLayout>
diff --git a/res-common/mipmap-hdpi/ic_contacts_launcher.png b/res-common/mipmap-hdpi/ic_contacts_launcher.png
deleted file mode 100644
index 64eff00..0000000
--- a/res-common/mipmap-hdpi/ic_contacts_launcher.png
+++ /dev/null
Binary files differ
diff --git a/res-common/mipmap-mdpi/ic_contacts_launcher.png b/res-common/mipmap-mdpi/ic_contacts_launcher.png
deleted file mode 100644
index b4ee821..0000000
--- a/res-common/mipmap-mdpi/ic_contacts_launcher.png
+++ /dev/null
Binary files differ
diff --git a/res-common/mipmap-xhdpi/ic_contacts_launcher.png b/res-common/mipmap-xhdpi/ic_contacts_launcher.png
deleted file mode 100644
index 6feeadf..0000000
--- a/res-common/mipmap-xhdpi/ic_contacts_launcher.png
+++ /dev/null
Binary files differ
diff --git a/res-common/mipmap-xxhdpi/ic_contacts_launcher.png b/res-common/mipmap-xxhdpi/ic_contacts_launcher.png
deleted file mode 100644
index 01a3fde..0000000
--- a/res-common/mipmap-xxhdpi/ic_contacts_launcher.png
+++ /dev/null
Binary files differ
diff --git a/res-common/mipmap-xxxhdpi/ic_contacts_launcher.png b/res-common/mipmap-xxxhdpi/ic_contacts_launcher.png
deleted file mode 100644
index 328e067..0000000
--- a/res-common/mipmap-xxxhdpi/ic_contacts_launcher.png
+++ /dev/null
Binary files differ
diff --git a/res-common/values-sw600dp/styles.xml b/res-common/values-sw600dp/styles.xml
new file mode 100644
index 0000000..2130ce1
--- /dev/null
+++ b/res-common/values-sw600dp/styles.xml
@@ -0,0 +1,28 @@
+<!--
+  ~ 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="ContactListFilterTheme" parent="@android:Theme.Holo.Light.Dialog">
+        <item name="android:windowCloseOnTouchOutside">true</item>
+        <item name="android:listViewStyle">@style/ListViewStyle</item>
+    </style>
+
+    <style name="CustomContactListFilterView" parent="ContactListFilterTheme">
+        <item name="android:layout_width">match_parent</item>
+        <item name="android:layout_height">400dip</item>
+    </style>
+
+</resources>
diff --git a/res-common/values/dimens.xml b/res-common/values/dimens.xml
index 54fb8a8..fa82570 100644
--- a/res-common/values/dimens.xml
+++ b/res-common/values/dimens.xml
@@ -40,6 +40,12 @@
     -->
     <dimen name="contact_tile_shadowbox_height">48sp</dimen>
 
+    <!-- For contact filter setting screens -->
+    <dimen name="contact_filter_left_margin">16dip</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>
+
     <!-- Padding to be used between a visible scrollbar and the contact list -->
     <dimen name="list_visible_scrollbar_padding">32dip</dimen>
 
diff --git a/res-common/values/strings.xml b/res-common/values/strings.xml
index 13df8cd..271d071 100644
--- a/res-common/values/strings.xml
+++ b/res-common/values/strings.xml
@@ -373,12 +373,49 @@
     <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=64] -->
+    <string name="listCustomView">Contacts in custom 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>
 
@@ -655,6 +692,15 @@
     <!-- 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 custom view</string>
+
     <!-- Query hint displayed inside the search field [CHAR LIMIT=64] -->
     <string name="hint_findContacts">Search contacts</string>
 
@@ -776,6 +822,14 @@
     <!-- 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.
diff --git a/res-common/values/styles.xml b/res-common/values/styles.xml
index e6150df..b99c1bd 100644
--- a/res-common/values/styles.xml
+++ b/res-common/values/styles.xml
@@ -68,6 +68,15 @@
         <item name="android:overScrollMode">always</item>
     </style>
 
+    <style name="ContactListFilterTheme" parent="@android:Theme.Holo.Light">
+        <item name="android:listViewStyle">@style/ListViewStyle</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>
diff --git a/res-common/xml/preference_display_options.xml b/res-common/xml/preference_display_options.xml
index f8ec7f4..44a991f 100644
--- a/res-common/xml/preference_display_options.xml
+++ b/res-common/xml/preference_display_options.xml
@@ -46,6 +46,11 @@
 
     <Preference
         android:icon="@null"
+        android:key="customContactsFilter"
+        android:title="@string/menu_contacts_filter"/>
+
+    <Preference
+        android:icon="@null"
         android:key="importExport"
         android:title="@string/menu_import_export"/>
 
