diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index fa13adf..05cd5b5 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -40,6 +40,7 @@
     <uses-permission android:name="android.permission.USE_CREDENTIALS" />
     <uses-permission android:name="android.permission.VIBRATE" />
     <uses-permission android:name="android.permission.READ_SYNC_SETTINGS" />
+    <uses-permission android:name="android.permission.CONTROL_INCALL_EXPERIENCE" />
     <uses-permission android:name="com.android.voicemail.permission.ADD_VOICEMAIL" />
     <uses-permission android:name="com.android.voicemail.permission.WRITE_VOICEMAIL" />
     <uses-permission android:name="com.android.voicemail.permission.READ_VOICEMAIL" />
@@ -294,7 +295,8 @@
         </receiver>
 
         <service android:name="com.android.incallui.InCallServiceImpl"
-                 android:process="com.android.incallui">
+                 android:process="com.android.incallui"
+                 android:permission="android.permission.BIND_INCALL_SERVICE" >
             <intent-filter>
                 <action android:name="android.telecomm.InCallService"/>
             </intent-filter>
diff --git a/res/drawable/floating_action_button.xml b/res/drawable/floating_action_button.xml
index 347e9d4..cbbfb85 100644
--- a/res/drawable/floating_action_button.xml
+++ b/res/drawable/floating_action_button.xml
@@ -16,6 +16,6 @@
 -->
 
 <ripple xmlns:android="http://schemas.android.com/apk/res/android"
-    android:color="@color/dialer_accent_color">
+    android:color="@color/floating_action_button_touch_tint">
     <item android:drawable="@drawable/fab_blue" />
 </ripple>
diff --git a/res/layout/call_log_list_item.xml b/res/layout/call_log_list_item.xml
index 4dcffb1..761f352 100644
--- a/res/layout/call_log_list_item.xml
+++ b/res/layout/call_log_list_item.xml
@@ -65,8 +65,9 @@
                 android:id="@+id/quick_contact_photo"
                 android:layout_width="@dimen/contact_photo_size"
                 android:layout_height="@dimen/contact_photo_size"
+                android:paddingTop="2dp"
                 android:nextFocusRight="@id/primary_action_view"
-                android:layout_alignParentStart="true"
+                android:layout_gravity="top"
                 android:focusable="true"
                 />
             <LinearLayout
@@ -118,6 +119,7 @@
                         android:layout_height="@dimen/call_provider_small_icon_size"
                         android:layout_marginEnd="@dimen/call_log_icon_margin"
                         android:layout_gravity="center_vertical"
+                        android:tint="?attr/call_log_secondary_text_color"
                         android:scaleType="centerInside"
                         />
                     <TextView
@@ -137,9 +139,11 @@
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:layout_gravity="center_vertical"
+                android:layout_marginEnd="@dimen/call_log_icon_margin"
                 android:src="@drawable/ic_card_phone"
                 android:tint="@color/recent_call_log_item_phone_icon_tint"
                 android:alpha="0.3"
+                android:importantForAccessibility="no"
                 android:visibility="gone"
                 />
         </LinearLayout>
diff --git a/res/layout/call_log_list_item_extra.xml b/res/layout/call_log_list_item_extra.xml
index fbf71f6..3623e3f 100644
--- a/res/layout/call_log_list_item_extra.xml
+++ b/res/layout/call_log_list_item_extra.xml
@@ -24,8 +24,6 @@
 
     <View android:layout_width="match_parent"
           android:layout_height="1px"
-          android:layout_marginStart="@dimen/call_log_outer_margin"
-          android:layout_marginEnd="@dimen/call_log_outer_margin"
           android:background="@color/favorite_contacts_separator_color"/>
 
     <LinearLayout android:id="@+id/badge_link_container"
@@ -40,9 +38,11 @@
         <ImageView android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:id="@+id/badge_image"
+                   android:tint="@color/dialpad_primary_text_color"
                    android:padding="@dimen/call_log_outer_margin"/>
         <TextView android:layout_width="wrap_content"
                   android:layout_height="wrap_content"
+                  android:paddingStart="@dimen/call_log_start_margin"
                   android:id="@+id/badge_text"
                   android:textColor="@color/dialpad_primary_text_color"
                   android:layout_gravity="center_vertical"
@@ -50,8 +50,11 @@
         <ImageView android:id="@+id/dismiss_button"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
-                   android:paddingTop="8dip"
+                   android:layout_gravity="center_vertical"
+                   android:layout_marginEnd="@dimen/call_log_icon_margin"
                    android:src="@drawable/ic_close_dk"
+                   android:tint="@color/recent_call_log_item_phone_icon_tint"
+                   android:alpha="0.3"
                    android:background="?android:attr/selectableItemBackground"
                    android:visibility="gone"
                    android:contentDescription="@string/description_dismiss"/>
diff --git a/res/layout/phone_disambig_item.xml b/res/layout/phone_disambig_item.xml
index a097ce7..27bbda1 100755
--- a/res/layout/phone_disambig_item.xml
+++ b/res/layout/phone_disambig_item.xml
@@ -14,7 +14,8 @@
      limitations under the License.
 -->
 
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<view class="com.android.contacts.common.widget.ActivityTouchLinearLayout"
+    xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:orientation="vertical"
@@ -39,4 +40,4 @@
         android:textAppearance="?android:attr/textAppearanceSmall"
         android:textDirection="ltr" />
 
-</LinearLayout>
+</view>
diff --git a/res/values/colors.xml b/res/values/colors.xml
index 448d1e6..a3fd3f9 100644
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@@ -19,7 +19,6 @@
     <color name="dialtacts_primary_text_color">#333</color>
     <!-- Secondary text color in the Dialer -->
     <color name="dialtacts_secondary_text_color">#737373</color>
-    <color name="dialer_accent_color">#eeff41</color>
     <color name="dialer_red_highlight_color">#ff1744</color>
     <color name="dialer_green_highlight_color">#00c853</color>
 
@@ -100,7 +99,8 @@
     <!-- Color for icons in the actionbar -->
     <color name="actionbar_icon_color">#ffffff</color>
 
-    <color name="dialer_dialpad_touch_tint">#331dc7db</color>
+    <color name="dialer_dialpad_touch_tint">#330288d1</color>
 
+    <color name="floating_action_button_touch_tint">#80ffffff</color>
 
 </resources>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 5098369..f9bd79e 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -788,17 +788,17 @@
 
     <!-- Title for the category "sounds", which is shown above sounds and vibration related
          settings. [CHAR LIMIT=30] -->
-    <string name="sounds_and_vibrate_category_title">Sounds and Vibrate</string>
+    <string name="sounds_and_vibrate_category_title">Sounds and vibrate</string>
 
     <!-- Setting option name to pick ringtone (a list dialog comes up). [CHAR LIMIT=30] -->
     <string name="ringtone_title">Phone ringtone</string>
 
     <!-- Setting option name to enable or disable vibration when ringing the phone.
          [CHAR LIMIT=30] -->
-    <string name="vibrate_on_ring_title">Vibrate when ringing</string>
+    <string name="vibrate_on_ring_title">"Also vibrate for calls</string>
 
     <!-- Setting option name to enable or disable DTMF tone sound [CHAR LIMIT=30] -->
-    <string name="dtmf_tone_enable_title">Dialpad touch tones</string>
+    <string name="dtmf_tone_enable_title">Dialpad tones</string>
 
     <!-- Label for section of general call settings where miscellaneous settings are listed. -->
     <string name="other_settings_title">Other</string>
diff --git a/res/values/styles.xml b/res/values/styles.xml
index d0836a5..9d0fcd0 100644
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@@ -29,6 +29,7 @@
         <item name="android:windowContentOverlay">@null</item>
         <item name="android:listViewStyle">@style/ListViewStyle</item>
         <item name="android:overlapAnchor">true</item>
+        <item name="android:alertDialogTheme">@style/AlertDialogTheme</item>
         <item name="activated_background">@drawable/list_item_activated_background</item>
         <item name="section_header_background">@drawable/list_title_holo</item>
         <item name="list_section_header_height">32dip</item>
@@ -164,5 +165,13 @@
         <!-- Setting description. -->
         <item name="android:textColorTertiary">@color/setting_secondary_color</item>
         <item name="android:windowBackground">@color/setting_background_color</item>
+        <item name="android:colorAccent">@color/dialtacts_theme_color</item>
+        <item name="android:textColorLink">@color/dialtacts_theme_color</item>
+    </style>
+
+    <!-- Inherit from Theme.Material.Light.Dialog instead of Theme.Material.Light.Dialog.Alert
+    since the Alert dialog is private. They are identical anyway. -->
+    <style name="AlertDialogTheme" parent="@android:style/Theme.Material.Light.Dialog">
+        <item name="android:colorAccent">@color/dialtacts_theme_color</item>
     </style>
 </resources>
diff --git a/res/xml/general_settings.xml b/res/xml/general_settings.xml
index ecccdfd..7410211 100644
--- a/res/xml/general_settings.xml
+++ b/res/xml/general_settings.xml
@@ -48,17 +48,17 @@
             android:ringtoneType="ringtone" />
 
         <CheckBoxPreference
-            android:key="button_vibrate_on_ring"
-            android:title="@string/vibrate_on_ring_title"
-            android:persistent="false"
-            android:defaultValue="false" />
-
-        <CheckBoxPreference
             android:key="button_play_dtmf_tone"
             android:title="@string/dtmf_tone_enable_title"
             android:persistent="false"
             android:defaultValue="true" />
 
+        <CheckBoxPreference
+            android:key="button_vibrate_on_ring"
+            android:title="@string/vibrate_on_ring_title"
+            android:persistent="false"
+            android:defaultValue="false" />
+
     </PreferenceCategory>
 
     <PreferenceCategory
diff --git a/src/com/android/dialer/DialtactsActivity.java b/src/com/android/dialer/DialtactsActivity.java
index 12c52da..36f7b8d 100644
--- a/src/com/android/dialer/DialtactsActivity.java
+++ b/src/com/android/dialer/DialtactsActivity.java
@@ -102,7 +102,6 @@
  * The dialer tab's title is 'phone', a more common name (see strings.xml).
  */
 public class DialtactsActivity extends TransactionSafeActivity implements View.OnClickListener,
-        View.OnTouchListener,
         DialpadFragment.OnDialpadQueryChangedListener,
         OnListFragmentScrolledListener,
         DialpadFragment.HostInterface,
@@ -230,10 +229,6 @@
     private String mActionMenuDialpadButtonStr;
     private ImageButton mFloatingActionButton;
     private FloatingActionButtonController mFloatingActionButtonController;
-    /**
-     * Additional offset for FAB to be lowered when dialpad is open.
-     */
-    private int mFloatingActionButtonDialpadMarginBottomOffset;
 
     private int mActionBarHeight;
 
@@ -342,6 +337,15 @@
     };
 
     @Override
+    public boolean dispatchTouchEvent(MotionEvent ev) {
+        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
+            TouchPointManager.getInstance().setPoint((int) ev.getRawX(), (int) ev.getRawY());
+        }
+        return super.dispatchTouchEvent(ev);
+
+    }
+
+    @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         mFirstLaunch = true;
@@ -390,11 +394,8 @@
         int floatingActionButtonWidth = resources.getDimensionPixelSize(
                 R.dimen.floating_action_button_width);
         mFloatingActionButton.setOnClickListener(this);
-        mFloatingActionButton.setOnTouchListener(this);
         mFloatingActionButtonController = new FloatingActionButtonController(this,
-                floatingActionButtonContainer);
-        mFloatingActionButtonDialpadMarginBottomOffset = resources.getDimensionPixelOffset(
-                R.dimen.floating_action_button_dialpad_margin_bottom_offset);
+                floatingActionButtonContainer, mFloatingActionButton);
 
         ImageButton optionsMenuButton =
                 (ImageButton) searchEditTextLayout.findViewById(R.id.dialtacts_options_menu_button);
@@ -467,8 +468,6 @@
                 if (!mIsDialpadShown) {
                     maybeExitSearchUi();
                 }
-
-                recordTouchEvent(v, event);
                 return false;
             }
         });
@@ -570,18 +569,6 @@
     }
 
     @Override
-    public boolean onTouch(View view, MotionEvent event) {
-        recordTouchEvent(view, event);
-        return false;
-    }
-
-    private void recordTouchEvent(View view, MotionEvent event) {
-        if (event.getAction() == MotionEvent.ACTION_DOWN) {
-            TouchPointManager.getInstance().setPoint((int) event.getRawX(), (int) event.getRawY());
-        }
-    }
-
-    @Override
     public boolean onMenuItemClick(MenuItem item) {
         switch (item.getItemId()) {
             case R.id.menu_history:
@@ -1207,9 +1194,6 @@
                 align = FloatingActionButtonController.ALIGN_END;
             }
         }
-        mFloatingActionButtonController.align(align,
-                0 /* offsetX */,
-                mIsDialpadShown ? mFloatingActionButtonDialpadMarginBottomOffset : 0 /* offsetY */,
-                animate);
+        mFloatingActionButtonController.align(align, 0 /* offsetX */, 0 /* offsetY */, animate);
     }
 }
diff --git a/src/com/android/dialer/PhoneCallDetailsHelper.java b/src/com/android/dialer/PhoneCallDetailsHelper.java
index be5ee72..c5f2fb6 100644
--- a/src/com/android/dialer/PhoneCallDetailsHelper.java
+++ b/src/com/android/dialer/PhoneCallDetailsHelper.java
@@ -25,6 +25,7 @@
 import android.view.View;
 import android.widget.TextView;
 
+import com.android.contacts.common.CallUtil;
 import com.android.contacts.common.testing.NeededForTesting;
 import com.android.contacts.common.util.PhoneNumberHelper;
 import com.android.dialer.calllog.CallTypeHelper;
@@ -32,7 +33,6 @@
 import com.android.dialer.calllog.PhoneNumberDisplayHelper;
 import com.android.dialer.calllog.PhoneNumberUtilsWrapper;
 import com.android.dialer.util.DialerUtils;
-
 import com.google.common.collect.Lists;
 
 import java.util.ArrayList;
@@ -85,8 +85,7 @@
 
         // Show the video icon if the call had video enabled.
         views.callTypeIcons.setShowVideo(
-                (details.features & Calls.FEATURES_VIDEO) == Calls.FEATURES_VIDEO
-                        && DialerUtils.isVideoEnabled());
+                (details.features & Calls.FEATURES_VIDEO) == Calls.FEATURES_VIDEO);
         views.callTypeIcons.requestLayout();
         views.callTypeIcons.setVisibility(View.VISIBLE);
 
diff --git a/src/com/android/dialer/calllog/CallDetailHistoryAdapter.java b/src/com/android/dialer/calllog/CallDetailHistoryAdapter.java
index 7a8b922..d53f77f 100644
--- a/src/com/android/dialer/calllog/CallDetailHistoryAdapter.java
+++ b/src/com/android/dialer/calllog/CallDetailHistoryAdapter.java
@@ -26,6 +26,7 @@
 import android.widget.BaseAdapter;
 import android.widget.TextView;
 
+import com.android.contacts.common.CallUtil;
 import com.android.dialer.PhoneCallDetails;
 import com.android.dialer.R;
 import com.android.dialer.util.DialerUtils;
@@ -123,7 +124,7 @@
 
         int callType = details.callTypes[0];
         boolean isVideoCall = (details.features & Calls.FEATURES_VIDEO) == Calls.FEATURES_VIDEO
-                && DialerUtils.isVideoEnabled();
+                && CallUtil.isVideoEnabled(mContext);
 
         callTypeIconView.clear();
         callTypeIconView.add(callType);
diff --git a/src/com/android/dialer/calllog/CallLogActivity.java b/src/com/android/dialer/calllog/CallLogActivity.java
index 0054ac0..2a47271 100644
--- a/src/com/android/dialer/calllog/CallLogActivity.java
+++ b/src/com/android/dialer/calllog/CallLogActivity.java
@@ -29,7 +29,9 @@
 import android.view.Menu;
 import android.view.MenuInflater;
 import android.view.MenuItem;
+import android.view.MotionEvent;
 
+import com.android.contacts.common.interactions.TouchPointManager;
 import com.android.contacts.common.list.ViewPagerTabs;
 import com.android.dialer.DialtactsActivity;
 import com.android.dialer.R;
@@ -104,6 +106,14 @@
     }
 
     @Override
+    public boolean dispatchTouchEvent(MotionEvent ev) {
+        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
+            TouchPointManager.getInstance().setPoint((int) ev.getRawX(), (int) ev.getRawY());
+        }
+        return super.dispatchTouchEvent(ev);
+    }
+
+    @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
diff --git a/src/com/android/dialer/calllog/CallLogAdapter.java b/src/com/android/dialer/calllog/CallLogAdapter.java
index 64b1055..e009dda 100644
--- a/src/com/android/dialer/calllog/CallLogAdapter.java
+++ b/src/com/android/dialer/calllog/CallLogAdapter.java
@@ -16,7 +16,6 @@
 
 package com.android.dialer.calllog;
 
-import android.content.ComponentName;
 import android.content.ContentValues;
 import android.content.Context;
 import android.content.Intent;
@@ -29,9 +28,7 @@
 import android.provider.CallLog.Calls;
 import android.provider.ContactsContract.PhoneLookup;
 import android.telecomm.PhoneAccountHandle;
-import android.telecomm.TelecommManager;
 import android.text.TextUtils;
-import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.View.AccessibilityDelegate;
@@ -39,7 +36,6 @@
 import android.view.ViewStub;
 import android.view.ViewTreeObserver;
 import android.view.accessibility.AccessibilityEvent;
-import android.view.accessibility.AccessibilityRecord;
 import android.widget.ImageView;
 import android.widget.TextView;
 import android.widget.Toast;
@@ -66,6 +62,8 @@
 public class CallLogAdapter extends GroupingListAdapter
         implements ViewTreeObserver.OnPreDrawListener, CallLogGroupBuilder.GroupCreator {
 
+    private static final int VOICEMAIL_TRANSCRIPTION_MAX_LINES = 10;
+
     /** The enumeration of {@link android.os.AsyncTask} objects used in this class. */
     public enum Tasks {
         REMOVE_CALL_LOG_ENTRIES,
@@ -777,7 +775,7 @@
                     null, accountIcon, features, dataUsage, transcription);
         }
 
-        mCallLogViewsHelper.setPhoneCallDetails(views, details);
+        mCallLogViewsHelper.setPhoneCallDetails(mContext, views, details);
 
         int contactType = ContactPhotoManager.TYPE_DEFAULT;
 
@@ -887,6 +885,7 @@
     private void expandOrCollapseActions(CallLogListItemView callLogItem, boolean isExpanded) {
         final CallLogListItemViews views = (CallLogListItemViews)callLogItem.getTag();
 
+        expandVoicemailTranscriptionView(views, isExpanded);
         if (isExpanded) {
             // Inflate the view stub if necessary, and wire up the event handlers.
             inflateActionViewStub(callLogItem);
@@ -909,6 +908,20 @@
         }
     }
 
+    public static void expandVoicemailTranscriptionView(CallLogListItemViews views,
+            boolean isExpanded) {
+        if (views.callType != Calls.VOICEMAIL_TYPE) {
+            return;
+        }
+
+        final TextView view = views.phoneCallDetailsViews.voicemailTranscriptionView;
+        if (TextUtils.isEmpty(view.getText())) {
+            return;
+        }
+        view.setMaxLines(isExpanded ? VOICEMAIL_TRANSCRIPTION_MAX_LINES : 1);
+        view.setSingleLine(!isExpanded);
+    }
+
     /**
      * Configures the action buttons in the expandable actions ViewStub.  The ViewStub is not
      * inflated during initial binding, so click handlers, tags and accessibility text must be set
diff --git a/src/com/android/dialer/calllog/CallLogFragment.java b/src/com/android/dialer/calllog/CallLogFragment.java
index ded65ed..b75e1c6 100644
--- a/src/com/android/dialer/calllog/CallLogFragment.java
+++ b/src/com/android/dialer/calllog/CallLogFragment.java
@@ -17,8 +17,8 @@
 package com.android.dialer.calllog;
 
 import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
 import android.animation.ValueAnimator;
-import android.animation.Animator.AnimatorListener;
 import android.app.Activity;
 import android.app.DialogFragment;
 import android.app.KeyguardManager;
@@ -26,28 +26,24 @@
 import android.content.Intent;
 import android.database.ContentObserver;
 import android.database.Cursor;
-import android.graphics.Outline;
-import android.net.Uri;
 import android.os.Bundle;
 import android.os.Handler;
 import android.provider.CallLog;
 import android.provider.CallLog.Calls;
 import android.provider.ContactsContract;
 import android.provider.VoicemailContract.Status;
+import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewTreeObserver;
 import android.view.View.OnClickListener;
 import android.view.ViewGroup.LayoutParams;
-import android.widget.ImageView;
 import android.widget.ListView;
 import android.widget.TextView;
 
 import com.android.common.io.MoreCloseables;
-import com.android.contacts.common.CallUtil;
 import com.android.contacts.common.GeoUtil;
-import com.android.contacts.common.util.PhoneNumberHelper;
 import com.android.contacts.common.util.ViewUtil;
 import com.android.dialer.R;
 import com.android.dialer.list.ListsFragment.HostInterface;
@@ -574,6 +570,7 @@
                 if (!isExpand) {
                     viewHolder.actionsView.setVisibility(View.VISIBLE);
                 }
+                CallLogAdapter.expandVoicemailTranscriptionView(viewHolder, !isExpand);
 
                 // Set up the fade effect for the action buttons.
                 if (isExpand) {
@@ -612,7 +609,7 @@
                     }
                 });
                 // Set everything to their final values when the animation's done.
-                animator.addListener(new AnimatorListener() {
+                animator.addListener(new AnimatorListenerAdapter() {
                     @Override
                     public void onAnimationEnd(Animator animation) {
                         view.getLayoutParams().height = LayoutParams.WRAP_CONTENT;
@@ -625,14 +622,8 @@
                             // is defaulting to the value (0) at the start of the expand animation.
                             viewHolder.actionsView.setAlpha(1);
                         }
+                        CallLogAdapter.expandVoicemailTranscriptionView(viewHolder, isExpand);
                     }
-
-                    @Override
-                    public void onAnimationCancel(Animator animation) { }
-                    @Override
-                    public void onAnimationRepeat(Animator animation) { }
-                    @Override
-                    public void onAnimationStart(Animator animation) { }
                 });
 
                 animator.setDuration(mExpandCollapseDuration);
diff --git a/src/com/android/dialer/calllog/CallLogListItemHelper.java b/src/com/android/dialer/calllog/CallLogListItemHelper.java
index 78a0105..68ca7a8 100644
--- a/src/com/android/dialer/calllog/CallLogListItemHelper.java
+++ b/src/com/android/dialer/calllog/CallLogListItemHelper.java
@@ -16,14 +16,15 @@
 
 package com.android.dialer.calllog;
 
+import android.content.Context;
 import android.content.res.Resources;
 import android.provider.CallLog.Calls;
 import android.text.TextUtils;
 
+import com.android.contacts.common.CallUtil;
 import com.android.dialer.PhoneCallDetails;
 import com.android.dialer.PhoneCallDetailsHelper;
 import com.android.dialer.R;
-import com.android.dialer.util.DialerUtils;
 
 /**
  * Helper class to fill in the views of a call log entry.
@@ -52,17 +53,19 @@
     /**
      * Sets the name, label, and number for a contact.
      *
+     * @param context The application context.
      * @param views the views to populate
      * @param details the details of a phone call needed to fill in the data
      */
-    public void setPhoneCallDetails(CallLogListItemViews views, PhoneCallDetails details) {
+    public void setPhoneCallDetails(
+            Context context, CallLogListItemViews views, PhoneCallDetails details) {
         mPhoneCallDetailsHelper.setPhoneCallDetails(views.phoneCallDetailsViews, details);
 
         // Set the accessibility text for the contact badge
         views.quickContactView.setContentDescription(getContactBadgeDescription(details));
 
         // Set the primary action accessibility description
-        views.primaryActionView.setContentDescription(getCallDescription(details));
+        views.primaryActionView.setContentDescription(getCallDescription(context, details));
 
         // Cache name or number of caller.  Used when setting the content descriptions of buttons
         // when the actions ViewStub is inflated.
@@ -124,10 +127,12 @@
      * Examples:
      * 3 calls.  New Voicemail.  Missed call from Joe Smith mobile 2 hours ago.
      * 2 calls.  Answered call from John Doe mobile.  Last called 1 hour ago.
+     *
+     * @param context The application context.
      * @param details Details of call.
      * @return Return call action description.
      */
-    public CharSequence getCallDescription(PhoneCallDetails details) {
+    public CharSequence getCallDescription(Context context, PhoneCallDetails details) {
         int lastCallType = getLastCallType(details.callTypes);
         boolean isVoiceMail = lastCallType == Calls.VOICEMAIL_TYPE;
 
@@ -155,7 +160,7 @@
 
         // If call had video capabilities, add the "Video Call" string.
         if ((details.features & Calls.FEATURES_VIDEO) == Calls.FEATURES_VIDEO &&
-                DialerUtils.isVideoEnabled()) {
+                CallUtil.isVideoEnabled(context)) {
             callDescription.append(mResources.getString(R.string.description_video_call));
         }
 
diff --git a/src/com/android/dialer/calllog/DefaultVoicemailNotifier.java b/src/com/android/dialer/calllog/DefaultVoicemailNotifier.java
index 477aa86..837cfba 100644
--- a/src/com/android/dialer/calllog/DefaultVoicemailNotifier.java
+++ b/src/com/android/dialer/calllog/DefaultVoicemailNotifier.java
@@ -157,6 +157,7 @@
                 .setSmallIcon(icon)
                 .setContentTitle(title)
                 .setContentText(callers)
+                .setColor(resources.getColor(R.color.dialer_theme_color))
                 .setDefaults(callToNotify != null ? Notification.DEFAULT_ALL : 0)
                 .setDeleteIntent(createMarkNewVoicemailsAsOldIntent())
                 .setAutoCancel(true);
diff --git a/src/com/android/dialer/dialpad/DialpadFragment.java b/src/com/android/dialer/dialpad/DialpadFragment.java
index ce6c46d..84f1c64 100644
--- a/src/com/android/dialer/dialpad/DialpadFragment.java
+++ b/src/com/android/dialer/dialpad/DialpadFragment.java
@@ -650,11 +650,14 @@
 
         mSmsPackageComponentName = DialerUtils.getSmsComponent(activity);
 
+        // Populate the overflow menu in onResume instead of onCreate, so that if the SMS activity
+        // is disabled while Dialer is paused, the "Send a text message" option can be correctly
+        // removed when resumed.
         mOverflowMenuButton = mDialpadView.getOverflowMenuButton();
         mOverflowPopupMenu = buildOptionsMenu(mOverflowMenuButton);
         mOverflowMenuButton.setOnTouchListener(mOverflowPopupMenu.getDragToOpenListener());
         mOverflowMenuButton.setOnClickListener(this);
-        mOverflowMenuButton.setVisibility(View.INVISIBLE);
+        mOverflowMenuButton.setVisibility(isDigitsEmpty() ? View.INVISIBLE : View.VISIBLE);
     }
 
     @Override
diff --git a/src/com/android/dialer/list/RegularSearchListAdapter.java b/src/com/android/dialer/list/RegularSearchListAdapter.java
index 8e4382c..3ce4bea 100644
--- a/src/com/android/dialer/list/RegularSearchListAdapter.java
+++ b/src/com/android/dialer/list/RegularSearchListAdapter.java
@@ -21,12 +21,12 @@
 import android.provider.ContactsContract;
 import android.text.TextUtils;
 
+import com.android.contacts.common.CallUtil;
 import com.android.contacts.common.list.DirectoryPartition;
 import com.android.contacts.common.list.PhoneNumberListAdapter;
 import com.android.dialer.calllog.ContactInfo;
 import com.android.dialer.service.CachedNumberLookupService;
 import com.android.dialer.service.CachedNumberLookupService.CachedContactInfo;
-import com.android.dialer.util.DialerUtils;
 
 /**
  * List adapter to display regular search results.
@@ -75,7 +75,7 @@
         // Otherwise, it should add it to a new contact as a name.
         setShortcutEnabled(SHORTCUT_ADD_NUMBER_TO_CONTACTS, showNumberShortcuts);
         setShortcutEnabled(SHORTCUT_MAKE_VIDEO_CALL,
-                showNumberShortcuts && DialerUtils.isVideoEnabled());
+                showNumberShortcuts && CallUtil.isVideoEnabled(getContext()));
         super.setQueryString(queryString);
     }
 }
diff --git a/src/com/android/dialer/list/SmartDialNumberListAdapter.java b/src/com/android/dialer/list/SmartDialNumberListAdapter.java
index 231611d..b2e0310 100644
--- a/src/com/android/dialer/list/SmartDialNumberListAdapter.java
+++ b/src/com/android/dialer/list/SmartDialNumberListAdapter.java
@@ -25,6 +25,7 @@
 import android.text.TextUtils;
 import android.util.Log;
 
+import com.android.contacts.common.CallUtil;
 import com.android.contacts.common.list.ContactListItemView;
 import com.android.contacts.common.list.PhoneNumberListAdapter;
 import com.android.contacts.common.list.PhoneNumberListAdapter.PhoneQuery;
@@ -32,7 +33,6 @@
 import com.android.dialer.dialpad.SmartDialNameMatcher;
 import com.android.dialer.dialpad.SmartDialPrefix;
 import com.android.dialer.dialpad.SmartDialMatchPosition;
-import com.android.dialer.util.DialerUtils;
 
 import java.util.ArrayList;
 
@@ -120,7 +120,7 @@
         final boolean showNumberShortcuts = !TextUtils.isEmpty(getFormattedQueryString());
         setShortcutEnabled(SHORTCUT_ADD_NUMBER_TO_CONTACTS, showNumberShortcuts);
         setShortcutEnabled(SHORTCUT_MAKE_VIDEO_CALL,
-                showNumberShortcuts && DialerUtils.isVideoEnabled());
+                showNumberShortcuts && CallUtil.isVideoEnabled(getContext()));
         super.setQueryString(queryString);
     }
 }
diff --git a/src/com/android/dialer/util/DialerUtils.java b/src/com/android/dialer/util/DialerUtils.java
index 7f6e75b..686884a 100644
--- a/src/com/android/dialer/util/DialerUtils.java
+++ b/src/com/android/dialer/util/DialerUtils.java
@@ -183,10 +183,4 @@
             imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
         }
     }
-
-    public static boolean isVideoEnabled() {
-        // TODO: Write utility methods to check subscriptions and settings, and use it to determine
-        // whether to enable or disable video call functionality.
-        return false;
-    }
 }
diff --git a/tests/src/com/android/dialer/calllog/CallLogListItemHelperTest.java b/tests/src/com/android/dialer/calllog/CallLogListItemHelperTest.java
index c001165..85dbf8c 100644
--- a/tests/src/com/android/dialer/calllog/CallLogListItemHelperTest.java
+++ b/tests/src/com/android/dialer/calllog/CallLogListItemHelperTest.java
@@ -233,7 +233,7 @@
                 TEST_FORMATTED_NUMBER,
                 TEST_COUNTRY_ISO, TEST_GEOCODE,
                 new int[]{Calls.OUTGOING_TYPE, Calls.OUTGOING_TYPE}, TEST_DATE, TEST_DURATION);
-        CharSequence description = mHelper.getCallDescription(details);
+        CharSequence description = mHelper.getCallDescription(getContext(), details);
         assertFalse(description.toString()
                 .contains(this.mResources.getString(R.string.description_new_voicemail)));
     }
@@ -247,7 +247,7 @@
                 TEST_FORMATTED_NUMBER,
                 TEST_COUNTRY_ISO, TEST_GEOCODE,
                 new int[]{Calls.INCOMING_TYPE, Calls.OUTGOING_TYPE}, TEST_DATE, TEST_DURATION);
-        CharSequence description = mHelper.getCallDescription(details);
+        CharSequence description = mHelper.getCallDescription(getContext(), details);
         assertFalse(description.toString()
                 .contains(this.mResources.getString(R.string.description_new_voicemail)));
     }
@@ -261,7 +261,7 @@
                 TEST_FORMATTED_NUMBER,
                 TEST_COUNTRY_ISO, TEST_GEOCODE,
                 new int[]{Calls.MISSED_TYPE, Calls.OUTGOING_TYPE}, TEST_DATE, TEST_DURATION);
-        CharSequence description = mHelper.getCallDescription(details);
+        CharSequence description = mHelper.getCallDescription(getContext(), details);
         assertFalse(description.toString()
                 .contains(this.mResources.getString(R.string.description_new_voicemail)));
     }
@@ -275,7 +275,7 @@
                 TEST_FORMATTED_NUMBER,
                 TEST_COUNTRY_ISO, TEST_GEOCODE,
                 new int[]{Calls.VOICEMAIL_TYPE, Calls.OUTGOING_TYPE}, TEST_DATE, TEST_DURATION);
-        CharSequence description = mHelper.getCallDescription(details);
+        CharSequence description = mHelper.getCallDescription(getContext(), details);
         assertTrue(description.toString()
                 .contains(this.mResources.getString(R.string.description_new_voicemail)));
     }
@@ -289,7 +289,7 @@
                 TEST_FORMATTED_NUMBER,
                 TEST_COUNTRY_ISO, TEST_GEOCODE,
                 new int[]{Calls.VOICEMAIL_TYPE}, TEST_DATE, TEST_DURATION);
-        CharSequence description = mHelper.getCallDescription(details);
+        CharSequence description = mHelper.getCallDescription(getContext(), details);
 
         // Rather than hard coding the "X calls" string message, we'll generate it with an empty
         // number of calls, and trim the resulting string.  This gets us just the word "calls",
@@ -308,7 +308,7 @@
                 TEST_FORMATTED_NUMBER,
                 TEST_COUNTRY_ISO, TEST_GEOCODE,
                 new int[]{Calls.VOICEMAIL_TYPE, Calls.INCOMING_TYPE}, TEST_DATE, TEST_DURATION);
-        CharSequence description = mHelper.getCallDescription(details);
+        CharSequence description = mHelper.getCallDescription(getContext(), details);
         assertTrue(description.toString()
                 .contains(this.mResources.getString(R.string.description_num_calls, 2)));
     }
@@ -324,7 +324,7 @@
                 new int[]{Calls.INCOMING_TYPE, Calls.INCOMING_TYPE}, TEST_DATE, TEST_DURATION,
                 null, null, Calls.FEATURES_VIDEO, null, null);
 
-        CharSequence description = mHelper.getCallDescription(details);
+        CharSequence description = mHelper.getCallDescription(getContext(), details);
         assertTrue(description.toString()
                 .contains(this.mResources.getString(R.string.description_video_call, 2)));
     }
@@ -346,7 +346,7 @@
     /** Sets the details of a phone call using the specified phone number. */
     private void setPhoneCallDetailsWithNumberAndType(String number,
             int presentation, String formattedNumber, int callType) {
-        mHelper.setPhoneCallDetails(mViews,
+        mHelper.setPhoneCallDetails(getContext(), mViews,
                 new PhoneCallDetails(number, presentation, formattedNumber,
                         TEST_COUNTRY_ISO, TEST_GEOCODE,
                         new int[]{ callType }, TEST_DATE, TEST_DURATION)
@@ -355,7 +355,7 @@
 
     /** Sets the details of a phone call using the specified call type. */
     private void setPhoneCallDetailsWithTypes(int... types) {
-        mHelper.setPhoneCallDetails(mViews,
+        mHelper.setPhoneCallDetails(getContext() ,mViews,
                 new PhoneCallDetails(TEST_NUMBER, Calls.PRESENTATION_ALLOWED,
                         TEST_FORMATTED_NUMBER, TEST_COUNTRY_ISO, TEST_GEOCODE,
                         types, TEST_DATE, TEST_DURATION)
@@ -364,7 +364,7 @@
 
     /** Sets the details of an unread phone call using the specified call type. */
     private void setUnreadPhoneCallDetailsWithTypes(int... types) {
-        mHelper.setPhoneCallDetails(mViews,
+        mHelper.setPhoneCallDetails(getContext(), mViews,
                 new PhoneCallDetails(TEST_NUMBER, Calls.PRESENTATION_ALLOWED,
                         TEST_FORMATTED_NUMBER, TEST_COUNTRY_ISO, TEST_GEOCODE,
                         types, TEST_DATE, TEST_DURATION)
