diff --git a/java/com/android/dialer/widget/FloatingActionButtonController.java b/java/com/android/dialer/widget/FloatingActionButtonController.java
index c89c1a8..eea0b59 100644
--- a/java/com/android/dialer/widget/FloatingActionButtonController.java
+++ b/java/com/android/dialer/widget/FloatingActionButtonController.java
@@ -26,7 +26,6 @@
 import android.view.View;
 import android.view.animation.AnimationUtils;
 import android.view.animation.Interpolator;
-import com.android.contacts.common.R;
 import com.android.dialer.common.Assert;
 
 /** Controls the movement and appearance of the FAB (Floating Action Button). */
diff --git a/java/com/android/dialer/widget/res/drawable/item_background_material_light.xml b/java/com/android/dialer/widget/res/drawable/item_background_material_light.xml
new file mode 100644
index 0000000..6e524ac
--- /dev/null
+++ b/java/com/android/dialer/widget/res/drawable/item_background_material_light.xml
@@ -0,0 +1,24 @@
+<?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
+  -->
+
+<!-- Based on the Theme.Material's default selectableItemBackground -->
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+  android:color="@color/dialer_ripple_material_light">
+  <item android:id="@android:id/mask">
+    <color android:color="@android:color/white"/>
+  </item>
+</ripple>
\ No newline at end of file
diff --git a/java/com/android/dialer/widget/res/drawable/searchedittext_custom_cursor.xml b/java/com/android/dialer/widget/res/drawable/searchedittext_custom_cursor.xml
new file mode 100644
index 0000000..2f01628
--- /dev/null
+++ b/java/com/android/dialer/widget/res/drawable/searchedittext_custom_cursor.xml
@@ -0,0 +1,21 @@
+<?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
+  -->
+
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+  <size android:width="2dp"/>
+  <solid android:color="@color/dialtacts_theme_color"/>
+</shape>
\ No newline at end of file
diff --git a/java/com/android/dialer/widget/res/values/animation_constants.xml b/java/com/android/dialer/widget/res/values/animation_constants.xml
new file mode 100644
index 0000000..9eec7d6
--- /dev/null
+++ b/java/com/android/dialer/widget/res/values/animation_constants.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2014 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<resources>
+  <integer name="floating_action_button_animation_duration">250</integer>
+</resources>
diff --git a/java/com/android/dialer/widget/res/values/colors.xml b/java/com/android/dialer/widget/res/values/colors.xml
index 12a5cb9..70c3197 100644
--- a/java/com/android/dialer/widget/res/values/colors.xml
+++ b/java/com/android/dialer/widget/res/values/colors.xml
@@ -15,6 +15,10 @@
   ~ limitations under the License
   -->
 <resources>
+
+  <!-- Color of ripples used for views with light backgrounds -->
+  <color name="dialer_ripple_material_light">#30000000</color>
+
   <color name="empty_list_text_color">#b2b2b2</color>
   <color name="empty_voicemail_icon_tint_color">#E1E1E1</color>
 </resources>
\ No newline at end of file
diff --git a/java/com/android/dialer/widget/res/values/dimens.xml b/java/com/android/dialer/widget/res/values/dimens.xml
index 65963a6..d29f0fa 100644
--- a/java/com/android/dialer/widget/res/values/dimens.xml
+++ b/java/com/android/dialer/widget/res/values/dimens.xml
@@ -29,4 +29,8 @@
 
   <!-- Empty List -->
   <dimen name="empty_list_message_text_size">16sp</dimen>
+
+  <!-- Floating Action Button -->
+  <dimen name="floating_action_button_margin_right">16dp</dimen>
+  <dimen name="floating_action_button_width">56dp</dimen>
 </resources>
\ No newline at end of file
