diff --git a/res/drawable-hdpi/dialer_recent_card_bg.9.png b/res/drawable-hdpi/dialer_recent_card_bg.9.png
index e581943..2bfdbcb 100644
--- a/res/drawable-hdpi/dialer_recent_card_bg.9.png
+++ b/res/drawable-hdpi/dialer_recent_card_bg.9.png
Binary files differ
diff --git a/res/drawable-hdpi/ic_ab_search.png b/res/drawable-hdpi/ic_ab_search.png
new file mode 100644
index 0000000..3702846
--- /dev/null
+++ b/res/drawable-hdpi/ic_ab_search.png
Binary files differ
diff --git a/res/drawable-hdpi/list_item_avatar_bg.png b/res/drawable-hdpi/list_item_avatar_bg.png
index e6eb68e..66e5f3e 100644
--- a/res/drawable-hdpi/list_item_avatar_bg.png
+++ b/res/drawable-hdpi/list_item_avatar_bg.png
Binary files differ
diff --git a/res/drawable-mdpi/dialer_recent_card_bg.9.png b/res/drawable-mdpi/dialer_recent_card_bg.9.png
index cb1d26f..dff6a0b 100644
--- a/res/drawable-mdpi/dialer_recent_card_bg.9.png
+++ b/res/drawable-mdpi/dialer_recent_card_bg.9.png
Binary files differ
diff --git a/res/drawable-mdpi/ic_ab_search.png b/res/drawable-mdpi/ic_ab_search.png
new file mode 100644
index 0000000..cc9f911
--- /dev/null
+++ b/res/drawable-mdpi/ic_ab_search.png
Binary files differ
diff --git a/res/drawable-mdpi/list_item_avatar_bg.png b/res/drawable-mdpi/list_item_avatar_bg.png
index 1306cfc..640eb3e 100644
--- a/res/drawable-mdpi/list_item_avatar_bg.png
+++ b/res/drawable-mdpi/list_item_avatar_bg.png
Binary files differ
diff --git a/res/drawable-xhdpi/dialer_recent_card_bg.9.png b/res/drawable-xhdpi/dialer_recent_card_bg.9.png
index e1a4b67..05d254d 100644
--- a/res/drawable-xhdpi/dialer_recent_card_bg.9.png
+++ b/res/drawable-xhdpi/dialer_recent_card_bg.9.png
Binary files differ
diff --git a/res/drawable-xhdpi/ic_ab_search.png b/res/drawable-xhdpi/ic_ab_search.png
new file mode 100644
index 0000000..718ff49
--- /dev/null
+++ b/res/drawable-xhdpi/ic_ab_search.png
Binary files differ
diff --git a/res/drawable-xhdpi/list_item_avatar_bg.png b/res/drawable-xhdpi/list_item_avatar_bg.png
index 3f271a0..cac7fbd 100644
--- a/res/drawable-xhdpi/list_item_avatar_bg.png
+++ b/res/drawable-xhdpi/list_item_avatar_bg.png
Binary files differ
diff --git a/res/drawable-xxhdpi/dialer_recent_card_bg.9.png b/res/drawable-xxhdpi/dialer_recent_card_bg.9.png
index 6142078..87d95f0 100644
--- a/res/drawable-xxhdpi/dialer_recent_card_bg.9.png
+++ b/res/drawable-xxhdpi/dialer_recent_card_bg.9.png
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_ab_search.png b/res/drawable-xxhdpi/ic_ab_search.png
new file mode 100644
index 0000000..4bb5165
--- /dev/null
+++ b/res/drawable-xxhdpi/ic_ab_search.png
Binary files differ
diff --git a/res/drawable-xxhdpi/list_item_avatar_bg.png b/res/drawable-xxhdpi/list_item_avatar_bg.png
index 8b03a65..fcfe2da 100644
--- a/res/drawable-xxhdpi/list_item_avatar_bg.png
+++ b/res/drawable-xxhdpi/list_item_avatar_bg.png
Binary files differ
diff --git a/res/layout/dialpad_fragment.xml b/res/layout/dialpad_fragment.xml
index 32b1d60..e673cea 100644
--- a/res/layout/dialpad_fragment.xml
+++ b/res/layout/dialpad_fragment.xml
@@ -19,7 +19,8 @@
     android:layout_height="match_parent"
     android:orientation="vertical" >
     <!-- spacer view -->
-    <Space
+    <View
+        android:id="@+id/spacer"
         android:layout_width="match_parent"
         android:layout_height="0dp"
         android:layout_weight="1" />
diff --git a/res/layout/dialtacts_activity.xml b/res/layout/dialtacts_activity.xml
index 255eb49..e2c3853 100644
--- a/res/layout/dialtacts_activity.xml
+++ b/res/layout/dialtacts_activity.xml
@@ -81,36 +81,41 @@
             android:id="@+id/dialtacts_frame"
             android:clipChildren="false">
         </FrameLayout>
+        <View
+            android:layout_height="2dp"
+            android:layout_width="match_parent"
+            android:background="#33999999"
+        />
         <FrameLayout
-        android:layout_height="@dimen/fake_action_bar_height"
-        android:layout_width="match_parent"
-        android:id="@+id/fake_action_bar"
-        android:background="@color/actionbar_background_color">
-        <ImageButton
-            android:id="@+id/call_history_button"
-            android:layout_width="@dimen/fake_menu_button_min_width"
-            android:layout_height="match_parent"
-            android:layout_gravity="bottom|start"
-            android:background="?android:attr/selectableItemBackground"
-            android:contentDescription="@string/action_menu_call_history_description"
-            android:src="@drawable/ic_menu_history_dk"/>
-        <ImageButton
-            android:id="@+id/dialpad_button"
-            android:layout_width="@dimen/fake_menu_button_min_width"
-            android:layout_height="match_parent"
-            android:layout_gravity="bottom|center"
-            android:background="?android:attr/selectableItemBackground"
-            android:contentDescription="@string/action_menu_dialpad_button"
-            android:src="@drawable/ic_menu_dialpad_dk"/>
-        <ImageButton
-             android:id="@+id/overflow_menu"
-             android:layout_width="@dimen/fake_menu_button_min_width"
-             android:layout_height="match_parent"
-             android:layout_gravity="bottom|end"
-             android:src="@drawable/ic_menu_overflow_dk"
-             android:contentDescription="@string/action_menu_overflow_description"
-             android:background="?android:attr/selectableItemBackground"/>
-    </FrameLayout>
+            android:layout_height="@dimen/fake_action_bar_height"
+            android:layout_width="match_parent"
+            android:id="@+id/fake_action_bar"
+            android:background="@color/actionbar_background_color">
+            <ImageButton
+                android:id="@+id/call_history_button"
+                android:layout_width="@dimen/fake_menu_button_min_width"
+                android:layout_height="match_parent"
+                android:layout_gravity="bottom|start"
+                android:background="?android:attr/selectableItemBackground"
+                android:contentDescription="@string/action_menu_call_history_description"
+                android:src="@drawable/ic_menu_history_dk"/>
+            <ImageButton
+                android:id="@+id/dialpad_button"
+                android:layout_width="@dimen/fake_menu_button_min_width"
+                android:layout_height="match_parent"
+                android:layout_gravity="bottom|center"
+                android:background="?android:attr/selectableItemBackground"
+                android:contentDescription="@string/action_menu_dialpad_button"
+                android:src="@drawable/ic_menu_dialpad_dk"/>
+            <ImageButton
+                 android:id="@+id/overflow_menu"
+                 android:layout_width="@dimen/fake_menu_button_min_width"
+                 android:layout_height="match_parent"
+                 android:layout_gravity="bottom|end"
+                 android:src="@drawable/ic_menu_overflow_dk"
+                 android:contentDescription="@string/action_menu_overflow_description"
+                 android:background="?android:attr/selectableItemBackground"/>
+        </FrameLayout>
         <View
             android:id="@+id/dialtacts_bottom_padding"
             android:layout_width="match_parent"
diff --git a/res/layout/show_all_contact_button.xml b/res/layout/show_all_contact_button.xml
index 824d10c..30060d7 100644
--- a/res/layout/show_all_contact_button.xml
+++ b/res/layout/show_all_contact_button.xml
@@ -14,7 +14,7 @@
      limitations under the License.
 -->
 
-<LinearLayout
+<com.android.contacts.common.list.ContactListItemView
     xmlns:android="http://schemas.android.com/apk/res/android"
     android:id="@+id/show_all_contact_button"
     android:orientation="horizontal"
@@ -23,23 +23,4 @@
     android:layout_height="match_parent"
     android:minHeight="?android:attr/listPreferredItemHeight"
     android:gravity="center"
-    android:background="?android:attr/selectableItemBackground"
-    android:focusable="true">
-
-    <ImageView
-        android:layout_height="match_parent"
-        android:layout_width="wrap_content"
-        android:layout_gravity="center"
-        android:src="@drawable/ic_menu_all_contacts_dk"
-        android:layout_marginEnd="10dp"/>
-
-    <TextView
-        android:layout_width="wrap_content"
-        android:layout_height="match_parent"
-        android:textSize="14sp"
-        android:ellipsize="marquee"
-        android:singleLine="true"
-        android:text="@string/show_all_contacts_button_text"
-        android:textAlignment="center"
-        android:gravity="center"/>
-</LinearLayout>
\ No newline at end of file
+    android:focusable="true" />
\ No newline at end of file
diff --git a/res/values/colors.xml b/res/values/colors.xml
index d49aaaa..a8ddf2b 100644
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@@ -41,7 +41,7 @@
     <color name="background_dialer_light">#cecece</color>
 
     <!-- Background color of dialer list items (contacts, call log entries) -->
-    <color name="background_dialer_list_items">#f5f5f5</color>
+    <color name="background_dialer_list_items">#eeeeee</color>
 
     <!-- Background color of new dialpad -->
     <color name="background_dialpad">#f2020709</color>
@@ -52,7 +52,7 @@
     <color name="dialpad_secondary_text_color">#aaaaaa</color>
 
     <!-- Background color of action bars -->
-    <color name="actionbar_background_color">#e6e6e6</color>
+    <color name="actionbar_background_color">#ffffff</color>
 
     <!-- Color of the 1dp divider that separates favorites -->
     <color name="favorite_contacts_separator_color">#d0d0d0</color>
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index e4e847c..1743952 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -30,7 +30,7 @@
     <dimen name="call_button_height">74dp</dimen>
 
     <!--  Search View -->
-    <dimen name="search_text_size">16sp</dimen>
+    <dimen name="search_text_size">14sp</dimen>
 
     <!-- Call Log -->
     <dimen name="call_log_call_action_size">32dip</dimen>
diff --git a/src/com/android/dialer/DialtactsActivity.java b/src/com/android/dialer/DialtactsActivity.java
index faf63cd..04934c7 100644
--- a/src/com/android/dialer/DialtactsActivity.java
+++ b/src/com/android/dialer/DialtactsActivity.java
@@ -27,6 +27,7 @@
 import android.content.ActivityNotFoundException;
 import android.content.Context;
 import android.content.Intent;
+import android.graphics.drawable.Drawable;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.RemoteException;
@@ -38,8 +39,11 @@
 import android.speech.RecognizerIntent;
 import android.telephony.TelephonyManager;
 import android.text.Editable;
+import android.text.Spannable;
+import android.text.SpannableStringBuilder;
 import android.text.TextUtils;
 import android.text.TextWatcher;
+import android.text.style.ImageSpan;
 import android.util.Log;
 import android.view.Menu;
 import android.view.MenuItem;
@@ -507,7 +511,19 @@
         mVoiceSearchButton.setOnClickListener(this);
         mSearchView = (EditText) findViewById(R.id.search_view);
         mSearchView.addTextChangedListener(mPhoneSearchQueryTextListener);
-        mSearchView.setHint(getString(R.string.dialer_hint_find_contact));
+
+        final String hintText = getString(R.string.dialer_hint_find_contact);
+
+        // The following code is used to insert an icon into a CharSequence (copied from
+        // SearchView)
+        final SpannableStringBuilder ssb = new SpannableStringBuilder("   "); // for the icon
+        ssb.append(hintText);
+        final Drawable searchIcon = getResources().getDrawable(R.drawable.ic_ab_search);
+        final int textSize = (int) (mSearchView.getTextSize() * 1.20);
+        searchIcon.setBounds(0, 0, textSize, textSize);
+        ssb.setSpan(new ImageSpan(searchIcon), 1, 2, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+
+        mSearchView.setHint(ssb);
     }
 
     final AnimatorListener mHideListener = new AnimatorListenerAdapter() {
diff --git a/src/com/android/dialer/dialpad/DialpadFragment.java b/src/com/android/dialer/dialpad/DialpadFragment.java
index 9ebf112..00b8281 100644
--- a/src/com/android/dialer/dialpad/DialpadFragment.java
+++ b/src/com/android/dialer/dialpad/DialpadFragment.java
@@ -206,6 +206,8 @@
     private ToneGenerator mToneGenerator;
     private final Object mToneGeneratorLock = new Object();
     private View mDialpad;
+    private View mSpacer;
+
     /**
      * Set of dialpad keys that are currently being pressed
      */
@@ -428,6 +430,18 @@
             mDelete.setOnLongClickListener(this);
         }
 
+        mSpacer = fragmentView.findViewById(R.id.spacer);
+        mSpacer.setOnTouchListener(new View.OnTouchListener() {
+            @Override
+            public boolean onTouch(View v, MotionEvent event) {
+                if (isDigitsEmpty()) {
+                    hideAndClearDialpad();
+                    return true;
+                }
+                return false;
+            }
+        });
+
         mDialpad = fragmentView.findViewById(R.id.dialpad);  // This is null in landscape mode.
 
         // In landscape we put the keyboard in phone mode.
diff --git a/src/com/android/dialer/list/PhoneFavoriteFragment.java b/src/com/android/dialer/list/PhoneFavoriteFragment.java
index 73703a0..34666ee 100644
--- a/src/com/android/dialer/list/PhoneFavoriteFragment.java
+++ b/src/com/android/dialer/list/PhoneFavoriteFragment.java
@@ -27,6 +27,7 @@
 import android.content.CursorLoader;
 import android.content.Loader;
 import android.content.SharedPreferences;
+import android.content.res.Resources;
 import android.database.Cursor;
 import android.graphics.Rect;
 import android.net.Uri;
@@ -50,6 +51,7 @@
 import com.android.contacts.common.ContactTileLoaderFactory;
 import com.android.contacts.common.GeoUtil;
 import com.android.contacts.common.list.ContactEntry;
+import com.android.contacts.common.list.ContactListItemView;
 import com.android.contacts.common.list.ContactTileView;
 import com.android.dialer.DialtactsActivity;
 import com.android.dialer.R;
@@ -290,21 +292,12 @@
 
         mShowAllContactsInEmptyViewButton = mParentView.findViewById(
                 R.id.show_all_contact_button_in_nofav);
-        mShowAllContactsInEmptyViewButton.setOnClickListener(new OnClickListener() {
-            @Override
-            public void onClick(View view) {
-                showAllContacts();
-            }
-        });
+        prepareAllContactsButton(mShowAllContactsInEmptyViewButton);
 
         mShowAllContactsButton = inflater.inflate(R.layout.show_all_contact_button, mListView,
                 false);
-        mShowAllContactsButton.setOnClickListener(new OnClickListener() {
-            @Override
-            public void onClick(View view) {
-                showAllContacts();
-            }
-        });
+
+        prepareAllContactsButton(mShowAllContactsButton);
 
         mContactTileFrame = mParentView.findViewById(R.id.contact_tile_frame);
 
@@ -638,4 +631,33 @@
                 .apply();
         fetchCalls();
     }
+
+    /**
+     * Returns a view that is laid out and styled to look like a regular contact, with the correct
+     * click behavior (to launch the all contacts activity when it is clicked).
+     */
+    private View prepareAllContactsButton(View v) {
+        final ContactListItemView view = (ContactListItemView) v;
+        view.setOnClickListener(new OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                showAllContacts();
+            }
+        });
+
+        view.setPhotoPosition(ContactListItemView.PhotoPosition.LEFT);
+        final Resources resources = getResources();
+        view.setBackgroundResource(R.drawable.contact_list_item_background);
+
+        view.setPaddingRelative(
+                resources.getDimensionPixelSize(R.dimen.favorites_row_start_padding),
+                resources.getDimensionPixelSize(R.dimen.favorites_row_end_padding),
+                resources.getDimensionPixelSize(R.dimen.favorites_row_top_padding),
+                resources.getDimensionPixelSize(R.dimen.favorites_row_bottom_padding));
+
+        view.setDisplayName(resources.getString(R.string.show_all_contacts_button_text));
+        view.setDrawableResource(R.drawable.list_item_avatar_bg,
+                R.drawable.ic_menu_all_contacts_dk);
+        return view;
+    }
 }
