diff --git a/Android.mk b/Android.mk
index 5ae5af0..e023434 100644
--- a/Android.mk
+++ b/Android.mk
@@ -77,6 +77,7 @@
 LOCAL_SRC_FILES := $(call all-java-files-under, $(BASE_DIR))
 LOCAL_SRC_FILES += $(call all-proto-files-under, $(BASE_DIR))
 LOCAL_SRC_FILES += $(call all-Iaidl-files-under, $(BASE_DIR))
+LOCAL_AIDL_INCLUDES :=  $(LOCAL_PATH)/java/
 LOCAL_SRC_FILES := $(filter-out $(EXCLUDE_FILES),$(LOCAL_SRC_FILES))
 
 LOCAL_PROTOC_FLAGS := --proto_path=$(LOCAL_PATH)
@@ -102,35 +103,14 @@
 	android-common \
 	android-support-dynamic-animation \
 	com.android.vcard \
-	dialer-animal-sniffer-annotations-target \
-	dialer-commons-io-target \
-	dialer-dagger2-target \
-	dialer-disklrucache-target \
-	dialer-gifdecoder-target \
-	dialer-glide-target \
-	dialer-grpc-all-target \
-	dialer-grpc-context-target \
-	dialer-grpc-core-target \
-	dialer-grpc-okhttp-target \
-	dialer-grpc-protobuf-lite-target \
-	dialer-grpc-stub-target \
-	dialer-j2objc-annotations-target \
-	dialer-javax-annotation-api-target \
-	dialer-javax-inject-target \
-	dialer-libshortcutbadger-target \
-	dialer-mime4j-core-target \
-	dialer-mime4j-dom-target \
-	dialer-okhttp-target \
-	dialer-okio-target \
-	dialer-guava-target \
-	dialer-glide-target \
-	dialer-glide-annotation-target \
-	dialer-zxing-target \
+	dialer-common-m2-target-deps \
+	dialer-glide-target-deps \
 	error_prone_annotations \
 	jsr305 \
 	libbackup \
 	libphonenumber \
 	volley \
+	zxing-core-1.7 \
 
 LOCAL_STATIC_ANDROID_LIBRARIES := \
 	android-support-core-ui \
@@ -148,15 +128,10 @@
 
 LOCAL_ANNOTATION_PROCESSORS := \
 	auto_value_plugin \
-	javapoet-prebuilt-jar \
-	dialer-dagger2 \
-	dialer-dagger2-compiler \
-	dialer-dagger2-producers \
-	dialer-glide-annotation \
-	dialer-glide-compiler \
-	dialer-guava \
-	dialer-javax-annotation-api \
-	dialer-javax-inject \
+	javapoet \
+	dialer-common-m2-host-deps \
+	dialer-dagger2-compiler-deps \
+	dialer-glide-host-deps \
 	dialer-rootcomponentprocessor
 
 LOCAL_ANNOTATION_PROCESSOR_CLASSES := \
@@ -191,328 +166,6 @@
 EXCLUDE_MANIFESTS :=
 EXCLUDE_EXTRA_PACKAGES :=
 
-# Create references to prebuilt libraries.
-include $(CLEAR_VARS)
-
-LOCAL_PREBUILT_STATIC_JAVA_LIBRARIES := \
-    dialer-dagger2-compiler:../../../prebuilts/tools/common/m2/repository/com/google/dagger/dagger-compiler/2.7/dagger-compiler-2.7.jar \
-    dialer-dagger2:../../../prebuilts/tools/common/m2/repository/com/google/dagger/dagger/2.7/dagger-2.7.jar \
-    dialer-dagger2-producers:../../../prebuilts/tools/common/m2/repository/com/google/dagger/dagger-producers/2.7/dagger-producers-2.7.jar \
-    dialer-glide-annotation:../../../prebuilts/maven_repo/bumptech/com/github/bumptech/glide/annotation/SNAPSHOT/annotation-SNAPSHOT.jar \
-    dialer-glide-compiler:../../../prebuilts/maven_repo/bumptech/com/github/bumptech/glide/compiler/SNAPSHOT/compiler-SNAPSHOT.jar \
-    dialer-grpc-all:../../../prebuilts/tools/common/m2/repository/io/grpc/grpc-all/1.0.3/grpc-all-1.0.3.jar \
-    dialer-grpc-core:../../../prebuilts/tools/common/m2/repository/io/grpc/grpc-core/1.0.3/grpc-core-1.0.3.jar \
-    dialer-grpc-okhttp:../../../prebuilts/tools/common/m2/repository/io/grpc/grpc-okhttp/1.0.3/grpc-okhttp-1.0.3.jar \
-    dialer-grpc-protobuf-lite:../../../prebuilts/tools/common/m2/repository/io/grpc/grpc-protobuf-lite/1.0.3/grpc-protobuf-lite-1.0.3.jar \
-    dialer-grpc-stub:../../../prebuilts/tools/common/m2/repository/io/grpc/grpc-stub/1.0.3/grpc-stub-1.0.3.jar \
-    dialer-guava:../../../prebuilts/tools/common/m2/repository/com/google/guava/guava/23.0/guava-23.0.jar \
-    dialer-javax-annotation-api:../../../prebuilts/tools/common/m2/repository/javax/annotation/javax.annotation-api/1.2/javax.annotation-api-1.2.jar \
-    dialer-javax-inject:../../../prebuilts/tools/common/m2/repository/javax/inject/javax.inject/1/javax.inject-1.jar \
-
-include $(BUILD_HOST_PREBUILT)
-
-# Enumerate target prebuilts to avoid linker warnings like
-# Dialer (java:sdk) should not link to dialer-guava (java:platform)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-guava-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/com/google/guava/guava/23.0/guava-23.0.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-dagger2-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/com/google/dagger/dagger/2.7/dagger-2.7.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-disklrucache-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/maven_repo/bumptech/com/github/bumptech/glide/disklrucache/SNAPSHOT/disklrucache-SNAPSHOT.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-gifdecoder-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/maven_repo/bumptech/com/github/bumptech/glide/gifdecoder/SNAPSHOT/gifdecoder-SNAPSHOT.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-glide-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/maven_repo/bumptech/com/github/bumptech/glide/glide/SNAPSHOT/glide-SNAPSHOT.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-glide-annotation-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/maven_repo/bumptech/com/github/bumptech/glide/annotation/SNAPSHOT/annotation-SNAPSHOT.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-javax-annotation-api-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/javax/annotation/javax.annotation-api/1.2/javax.annotation-api-1.2.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-libshortcutbadger-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/me/leolin/ShortcutBadger/1.1.13/ShortcutBadger-1.1.13.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-javax-inject-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/javax/inject/javax.inject/1/javax.inject-1.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-commons-io-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/commons-io/commons-io/2.4/commons-io-2.4.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-mime4j-core-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/org/apache/james/apache-mime4j-core/0.7.2/apache-mime4j-core-0.7.2.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-mime4j-dom-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/org/apache/james/apache-mime4j-dom/0.7.2/apache-mime4j-dom-0.7.2.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-grpc-core-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/io/grpc/grpc-core/1.0.3/grpc-core-1.0.3.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-grpc-okhttp-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/io/grpc/grpc-okhttp/1.0.3/grpc-okhttp-1.0.3.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-grpc-protobuf-lite-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/io/grpc/grpc-protobuf-lite/1.0.3/grpc-protobuf-lite-1.0.3.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-grpc-stub-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/io/grpc/grpc-stub/1.0.3/grpc-stub-1.0.3.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-grpc-all-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/io/grpc/grpc-all/1.0.3/grpc-all-1.0.3.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-grpc-context-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/io/grpc/grpc-context/1.0.3/grpc-context-1.0.3.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-zxing-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../external/zxing/core/core.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-okhttp-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/com/squareup/okhttp/okhttp/2.7.4/okhttp-2.7.4.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-okio-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/com/squareup/okio/okio/1.9.0/okio-1.9.0.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-j2objc-annotations-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/com/google/j2objc/j2objc-annotations/1.1/j2objc-annotations-1.1.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE_CLASS := JAVA_LIBRARIES
-LOCAL_MODULE := dialer-animal-sniffer-annotations-target
-LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0
-LOCAL_LICENSE_CONDITIONS := notice
-LOCAL_NOTICE_FILE := $(LOCAL_PATH)/LICENSE
-LOCAL_SDK_VERSION := current
-LOCAL_SRC_FILES := ../../../prebuilts/tools/common/m2/repository/org/codehaus/mojo/animal-sniffer-annotations/1.14/animal-sniffer-annotations-1.14.jar
-LOCAL_UNINSTALLABLE_MODULE := true
-
-include $(BUILD_PREBUILT)
-
 include $(CLEAR_VARS)
 
 LOCAL_MODULE := dialer-rootcomponentprocessor
@@ -533,13 +186,10 @@
         $(BASE_DIR)/dialer/inject/RootComponentGeneratorMetadata.java
 
 LOCAL_STATIC_JAVA_LIBRARIES := \
-	dialer-guava \
-	dialer-dagger2 \
-	javapoet-prebuilt-jar \
+	dialer-common-m2-host-deps \
+	javapoet \
 	auto_service_annotations \
 	auto_common \
-	dialer-javax-annotation-api \
-	dialer-javax-inject \
 	error_prone_annotations
 
 LOCAL_JAVA_LANGUAGE_VERSION := 1.8
diff --git a/assets/product/res/drawable-hdpi/product_logo_avatar_anonymous_color_120.png b/assets/product/res/drawable-hdpi/product_logo_avatar_anonymous_color_120.png
deleted file mode 100644
index 70d3011..0000000
--- a/assets/product/res/drawable-hdpi/product_logo_avatar_anonymous_color_120.png
+++ /dev/null
Binary files differ
diff --git a/assets/product/res/drawable-hdpi/product_logo_avatar_anonymous_white_color_120.png b/assets/product/res/drawable-hdpi/product_logo_avatar_anonymous_white_color_120.png
deleted file mode 100644
index 4068d5a..0000000
--- a/assets/product/res/drawable-hdpi/product_logo_avatar_anonymous_white_color_120.png
+++ /dev/null
Binary files differ
diff --git a/assets/product/res/drawable-mdpi/product_logo_avatar_anonymous_color_120.png b/assets/product/res/drawable-mdpi/product_logo_avatar_anonymous_color_120.png
deleted file mode 100644
index 60d3c3a..0000000
--- a/assets/product/res/drawable-mdpi/product_logo_avatar_anonymous_color_120.png
+++ /dev/null
Binary files differ
diff --git a/assets/product/res/drawable-xhdpi/product_logo_avatar_anonymous_color_120.png b/assets/product/res/drawable-xhdpi/product_logo_avatar_anonymous_color_120.png
deleted file mode 100644
index ec99ca6..0000000
--- a/assets/product/res/drawable-xhdpi/product_logo_avatar_anonymous_color_120.png
+++ /dev/null
Binary files differ
diff --git a/assets/product/res/drawable-xxhdpi/product_logo_avatar_anonymous_color_120.png b/assets/product/res/drawable-xxhdpi/product_logo_avatar_anonymous_color_120.png
deleted file mode 100644
index 2b009a3..0000000
--- a/assets/product/res/drawable-xxhdpi/product_logo_avatar_anonymous_color_120.png
+++ /dev/null
Binary files differ
diff --git a/assets/product/res/drawable-xxxhdpi/product_logo_avatar_anonymous_color_120.png b/assets/product/res/drawable-xxxhdpi/product_logo_avatar_anonymous_color_120.png
deleted file mode 100644
index 4b111b1..0000000
--- a/assets/product/res/drawable-xxxhdpi/product_logo_avatar_anonymous_color_120.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-hdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index cd19726..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_bluetooth_audio_grey600_24.png b/assets/quantum/res/drawable-hdpi/quantum_ic_bluetooth_audio_grey600_24.png
deleted file mode 100644
index ec2349c..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_bluetooth_audio_grey600_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_history_white_24.png b/assets/quantum/res/drawable-hdpi/quantum_ic_history_white_24.png
deleted file mode 100644
index 485c826..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_history_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_search_white_24.png b/assets/quantum/res/drawable-hdpi/quantum_ic_search_white_24.png
deleted file mode 100644
index bbfbc96..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_search_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-ldrtl-hdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-ldrtl-hdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index f517557..0000000
--- a/assets/quantum/res/drawable-ldrtl-hdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-ldrtl-mdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-ldrtl-mdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index 22a1140..0000000
--- a/assets/quantum/res/drawable-ldrtl-mdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-ldrtl-xhdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-ldrtl-xhdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index d858f18..0000000
--- a/assets/quantum/res/drawable-ldrtl-xhdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-ldrtl-xxhdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-ldrtl-xxhdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index 614ad49..0000000
--- a/assets/quantum/res/drawable-ldrtl-xxhdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-ldrtl-xxxhdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-ldrtl-xxxhdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index d409b54..0000000
--- a/assets/quantum/res/drawable-ldrtl-xxxhdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-mdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index 4ef72ee..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_bluetooth_audio_grey600_24.png b/assets/quantum/res/drawable-mdpi/quantum_ic_bluetooth_audio_grey600_24.png
deleted file mode 100644
index de635e0..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_bluetooth_audio_grey600_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_history_white_24.png b/assets/quantum/res/drawable-mdpi/quantum_ic_history_white_24.png
deleted file mode 100644
index d67647c..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_history_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_search_white_24.png b/assets/quantum/res/drawable-mdpi/quantum_ic_search_white_24.png
deleted file mode 100644
index faefc59..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_search_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index 832f5a3..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_bluetooth_audio_grey600_24.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_bluetooth_audio_grey600_24.png
deleted file mode 100644
index eea1bbf..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_bluetooth_audio_grey600_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_history_white_24.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_history_white_24.png
deleted file mode 100644
index 3e73b49..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_history_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_search_white_24.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_search_white_24.png
deleted file mode 100644
index bfc3e39..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_search_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index 32a6d91..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_bluetooth_audio_grey600_24.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_bluetooth_audio_grey600_24.png
deleted file mode 100644
index 99f57c1..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_bluetooth_audio_grey600_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_history_white_24.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_history_white_24.png
deleted file mode 100644
index 1358a12..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_history_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_search_white_24.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_search_white_24.png
deleted file mode 100644
index abbb989..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_search_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index e27034d..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_bluetooth_audio_grey600_24.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_bluetooth_audio_grey600_24.png
deleted file mode 100644
index 1595be1..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_bluetooth_audio_grey600_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_history_white_24.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_history_white_24.png
deleted file mode 100644
index 5b99ef6..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_history_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_search_white_24.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_search_white_24.png
deleted file mode 100644
index dd5adfc..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_search_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable/quantum_ic_clear_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_clear_vd_theme_24.xml
deleted file mode 100644
index f55a394..0000000
--- a/assets/quantum/res/drawable/quantum_ic_clear_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2017 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
-  -->
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="24.0"
-    android:viewportHeight="24.0"
-    android:tint="?attr/colorControlNormal">
-  <path
-      android:fillColor="@android:color/white"
-      android:pathData="M19,6.41L17.59,5 12,10.59 6.41,5 5,6.41 10.59,12 5,17.59 6.41,19 12,13.41 17.59,19 19,17.59 13.41,12z"/>
-</vector>
\ No newline at end of file
diff --git a/assets/quantum/res/drawable/quantum_ic_error_outline_vd_theme_36.xml b/assets/quantum/res/drawable/quantum_ic_error_outline_vd_theme_36.xml
deleted file mode 100644
index df4dc32..0000000
--- a/assets/quantum/res/drawable/quantum_ic_error_outline_vd_theme_36.xml
+++ /dev/null
@@ -1,33 +0,0 @@
-<!--
-  ~ Copyright (C) 2018 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
-  -->
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="36dp"
-    android:height="36dp"
-    android:viewportWidth="36.0"
-    android:viewportHeight="36.0"
-    android:tint="?attr/colorControlNormal">
-  <group
-      android:pivotX="12"
-      android:pivotY="12"
-      android:scaleX="1.5"
-      android:scaleY="1.5"
-      android:translateX="6"
-      android:translateY="6">
-    <path
-        android:fillColor="@android:color/white"
-        android:pathData="M11,15h2v2h-2zM11,7h2v6h-2zM11.99,2C6.47,2 2,6.48 2,12s4.47,10 9.99,10C17.52,22 22,17.52 22,12S17.52,2 11.99,2zM12,20c-4.42,0 -8,-3.58 -8,-8s3.58,-8 8,-8 8,3.58 8,8 -3.58,8 -8,8z"/>
-  </group>
-</vector>
\ No newline at end of file
diff --git a/assets/quantum/res/drawable/quantum_ic_fiber_manual_record_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_fiber_manual_record_vd_theme_24.xml
deleted file mode 100644
index 21993c3..0000000
--- a/assets/quantum/res/drawable/quantum_ic_fiber_manual_record_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2018 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
-  -->
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0"
-        android:tint="?attr/colorControlNormal">
-    <path
-        android:pathData="M12,12m-8,0a8,8 0,1 1,16 0a8,8 0,1 1,-16 0"
-        android:fillColor="@android:color/white"/>
-</vector>
diff --git a/assets/quantum/res/drawable/quantum_ic_fullscreen_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_fullscreen_vd_theme_24.xml
deleted file mode 100644
index baa88f4..0000000
--- a/assets/quantum/res/drawable/quantum_ic_fullscreen_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2017 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
-  -->
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0"
-        android:tint="?attr/colorControlNormal">
-    <path
-        android:fillColor="@android:color/white"
-        android:pathData="M7,14L5,14v5h5v-2L7,17v-3zM5,10h2L7,7h3L10,5L5,5v5zM17,17h-3v2h5v-5h-2v3zM14,5v2h3v3h2L19,5h-5z"/>
-</vector>
diff --git a/assets/quantum/res/drawable/quantum_ic_my_location_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_my_location_vd_theme_24.xml
deleted file mode 100644
index b13816e..0000000
--- a/assets/quantum/res/drawable/quantum_ic_my_location_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2017 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
-  -->
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0"
-        android:tint="?attr/colorControlNormal">
-    <path
-        android:fillColor="@android:color/white"
-        android:pathData="M12,8c-2.21,0 -4,1.79 -4,4s1.79,4 4,4 4,-1.79 4,-4 -1.79,-4 -4,-4zM20.94,11c-0.46,-4.17 -3.77,-7.48 -7.94,-7.94L13,1h-2v2.06C6.83,3.52 3.52,6.83 3.06,11L1,11v2h2.06c0.46,4.17 3.77,7.48 7.94,7.94L11,23h2v-2.06c4.17,-0.46 7.48,-3.77 7.94,-7.94L23,13v-2h-2.06zM12,19c-3.87,0 -7,-3.13 -7,-7s3.13,-7 7,-7 7,3.13 7,7 -3.13,7 -7,7z"/>
-</vector>
diff --git a/assets/quantum/res/drawable/quantum_ic_perm_phone_msg_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_perm_phone_msg_vd_theme_24.xml
deleted file mode 100644
index 68735dd..0000000
--- a/assets/quantum/res/drawable/quantum_ic_perm_phone_msg_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2017 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
-  -->
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0"
-        android:tint="?attr/colorControlNormal">
-    <path
-        android:fillColor="@android:color/white"
-        android:pathData="M20,15.5c-1.25,0 -2.45,-0.2 -3.57,-0.57 -0.35,-0.11 -0.74,-0.03 -1.02,0.24l-2.2,2.2c-2.83,-1.44 -5.15,-3.75 -6.59,-6.58l2.2,-2.21c0.28,-0.27 0.36,-0.66 0.25,-1.01C8.7,6.45 8.5,5.25 8.5,4c0,-0.55 -0.45,-1 -1,-1H4c-0.55,0 -1,0.45 -1,1 0,9.39 7.61,17 17,17 0.55,0 1,-0.45 1,-1v-3.5c0,-0.55 -0.45,-1 -1,-1zM12,3v10l3,-3h6V3h-9z"/>
-</vector>
diff --git a/assets/quantum/res/drawable/quantum_ic_schedule_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_schedule_vd_theme_24.xml
deleted file mode 100644
index 54fd545..0000000
--- a/assets/quantum/res/drawable/quantum_ic_schedule_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2018 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
-  -->
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0"
-        android:tint="?attr/colorControlNormal">
-    <path
-        android:fillColor="@android:color/white"
-        android:pathData="M11.99,2C6.47,2 2,6.48 2,12s4.47,10 9.99,10C17.52,22 22,17.52 22,12S17.52,2 11.99,2zM12,20c-4.42,0 -8,-3.58 -8,-8s3.58,-8 8,-8 8,3.58 8,8 -3.58,8 -8,8zM12.5,7L11,7v6l5.25,3.15 0.75,-1.23 -4.5,-2.67z"/>
-</vector>
diff --git a/assets/quantum/res/drawable/quantum_ic_security_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_security_vd_theme_24.xml
deleted file mode 100644
index 36ea6eb..0000000
--- a/assets/quantum/res/drawable/quantum_ic_security_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2018 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
-  -->
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="24.0"
-    android:viewportHeight="24.0"
-    android:tint="?attr/colorControlNormal">
-  <path
-      android:fillColor="@android:color/white"
-      android:pathData="M12,1L3,5v6c0,5.55 3.84,10.74 9,12 5.16,-1.26 9,-6.45 9,-12L21,5l-9,-4zM12,11.99h7c-0.53,4.12 -3.28,7.79 -7,8.94L12,12L5,12L5,6.3l7,-3.11v8.8z"/>
-</vector>
diff --git a/java/com/android/contacts/common/model/dataitem/ImDataItem.java b/java/com/android/contacts/common/model/dataitem/ImDataItem.java
index 16b9fd0..b990255 100644
--- a/java/com/android/contacts/common/model/dataitem/ImDataItem.java
+++ b/java/com/android/contacts/common/model/dataitem/ImDataItem.java
@@ -22,6 +22,8 @@
 import android.provider.ContactsContract.CommonDataKinds.Im;
 import android.text.TextUtils;
 
+import java.util.Objects;
+
 /**
  * Represents an IM data item, wrapping the columns in {@link ContactsContract.CommonDataKinds.Im}.
  */
@@ -97,7 +99,7 @@
         return that.getProtocol() == Im.PROTOCOL_CUSTOM;
       }
       return true;
-    } else if (getProtocol() != that.getProtocol()) {
+    } else if (!Objects.equals(getProtocol(), that.getProtocol())) {
       return false;
     } else if (getProtocol() == Im.PROTOCOL_CUSTOM
         && !TextUtils.equals(getCustomProtocol(), that.getCustomProtocol())) {
diff --git a/java/com/android/contacts/common/util/DateUtils.java b/java/com/android/contacts/common/util/DateUtils.java
index 09d52bc..d5147eb 100644
--- a/java/com/android/contacts/common/util/DateUtils.java
+++ b/java/com/android/contacts/common/util/DateUtils.java
@@ -16,7 +16,11 @@
 
 package com.android.contacts.common.util;
 
-import android.text.format.Time;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.ZoneId;
+import java.time.temporal.ChronoUnit;
+
 
 /** Utility methods for processing dates. */
 public class DateUtils {
@@ -30,13 +34,9 @@
    * @param date2 Second date to check.
    * @return The absolute difference in days between the two dates.
    */
-  public static int getDayDifference(Time time, long date1, long date2) {
-    time.set(date1);
-    int startDay = Time.getJulianDay(date1, time.gmtoff);
-
-    time.set(date2);
-    int currentDay = Time.getJulianDay(date2, time.gmtoff);
-
-    return Math.abs(currentDay - startDay);
+  public static int getDayDifference(ZoneId timeZone, long date1, long date2) {
+    LocalDate localDate1 = Instant.ofEpochMilli(date1).atZone(timeZone).toLocalDate();
+    LocalDate localDate2 = Instant.ofEpochMilli(date2).atZone(timeZone).toLocalDate();
+    return Math.abs((int) ChronoUnit.DAYS.between(localDate2, localDate1));
   }
 }
diff --git a/java/com/android/dialer/app/calllog/CallLogGroupBuilder.java b/java/com/android/dialer/app/calllog/CallLogGroupBuilder.java
index e525911..805ee64 100644
--- a/java/com/android/dialer/app/calllog/CallLogGroupBuilder.java
+++ b/java/com/android/dialer/app/calllog/CallLogGroupBuilder.java
@@ -23,7 +23,6 @@
 import android.support.annotation.VisibleForTesting;
 import android.telephony.PhoneNumberUtils;
 import android.text.TextUtils;
-import android.text.format.Time;
 import com.android.contacts.common.util.DateUtils;
 import com.android.dialer.calllogutils.CallbackActionHelper;
 import com.android.dialer.calllogutils.CallbackActionHelper.CallbackAction;
@@ -31,6 +30,8 @@
 import com.android.dialer.inject.ApplicationContext;
 import com.android.dialer.phonenumbercache.CallLogQuery;
 import com.android.dialer.phonenumberutil.PhoneNumberHelper;
+
+import java.time.ZoneId;
 import java.util.Objects;
 
 /**
@@ -56,7 +57,7 @@
   /** Day grouping for calls which occurred before last week. */
   public static final int DAY_GROUP_OTHER = 2;
   /** Instance of the time object used for time calculations. */
-  private static final Time TIME = new Time();
+  private static final ZoneId TIME_ZONE = ZoneId.systemDefault();
 
   private final Context appContext;
   /** The object on which the groups are created. */
@@ -255,7 +256,7 @@
    * @return The date group the call belongs in.
    */
   private int getDayGroup(long date, long now) {
-    int days = DateUtils.getDayDifference(TIME, date, now);
+    int days = DateUtils.getDayDifference(TIME_ZONE, date, now);
 
     if (days == 0) {
       return DAY_GROUP_TODAY;
diff --git a/java/com/android/dialer/app/calllog/MissedCallNotifier.java b/java/com/android/dialer/app/calllog/MissedCallNotifier.java
index f2d2af8..64536c8 100644
--- a/java/com/android/dialer/app/calllog/MissedCallNotifier.java
+++ b/java/com/android/dialer/app/calllog/MissedCallNotifier.java
@@ -17,6 +17,7 @@
 
 import static com.android.dialer.app.DevicePolicyResources.NOTIFICATION_MISSED_WORK_CALL_TITLE;
 
+import android.app.BroadcastOptions;
 import android.app.Notification;
 import android.app.Notification.Builder;
 import android.app.PendingIntent;
@@ -27,6 +28,7 @@
 import android.graphics.Bitmap;
 import android.graphics.drawable.Icon;
 import android.net.Uri;
+import android.os.Bundle;
 import android.provider.CallLog.Calls;
 import android.service.notification.StatusBarNotification;
 import android.support.annotation.NonNull;
@@ -44,6 +46,7 @@
 import android.text.TextDirectionHeuristics;
 import android.text.TextUtils;
 import android.util.ArraySet;
+
 import com.android.contacts.common.ContactsUtils;
 import com.android.dialer.app.MainComponent;
 import com.android.dialer.app.R;
@@ -68,6 +71,7 @@
 import com.android.dialer.theme.base.ThemeComponent;
 import com.android.dialer.util.DialerUtils;
 import com.android.dialer.util.IntentUtil;
+
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
@@ -500,6 +504,12 @@
 
   /** Closes open system dialogs and the notification shade. */
   private void closeSystemDialogs(Context context) {
-    context.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));
+    final Intent intent = new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)
+            .addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
+    final Bundle options = BroadcastOptions.makeBasic()
+            .setDeliveryGroupPolicy(BroadcastOptions.DELIVERY_GROUP_POLICY_MOST_RECENT)
+            .setDeferralPolicy(BroadcastOptions.DEFERRAL_POLICY_UNTIL_ACTIVE)
+            .toBundle();
+    context.sendBroadcast(intent, null /* receiverPermission */, options);
   }
 }
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_not_interested_googblue_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_not_interested_googblue_24dp.png
deleted file mode 100644
index 393a0c8..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_not_interested_googblue_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-mdpi/ic_not_interested_googblue_24dp.png b/java/com/android/dialer/app/res/drawable-mdpi/ic_not_interested_googblue_24dp.png
deleted file mode 100644
index d7d5c58..0000000
--- a/java/com/android/dialer/app/res/drawable-mdpi/ic_not_interested_googblue_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xhdpi/ic_not_interested_googblue_24dp.png b/java/com/android/dialer/app/res/drawable-xhdpi/ic_not_interested_googblue_24dp.png
deleted file mode 100644
index 3e6ec07..0000000
--- a/java/com/android/dialer/app/res/drawable-xhdpi/ic_not_interested_googblue_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xxhdpi/ic_not_interested_googblue_24dp.png b/java/com/android/dialer/app/res/drawable-xxhdpi/ic_not_interested_googblue_24dp.png
deleted file mode 100644
index 7c256b5..0000000
--- a/java/com/android/dialer/app/res/drawable-xxhdpi/ic_not_interested_googblue_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xxxhdpi/ic_not_interested_googblue_24dp.png b/java/com/android/dialer/app/res/drawable-xxxhdpi/ic_not_interested_googblue_24dp.png
deleted file mode 100644
index 6591ed4..0000000
--- a/java/com/android/dialer/app/res/drawable-xxxhdpi/ic_not_interested_googblue_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/callintent/CallIntent.java b/java/com/android/dialer/callintent/CallIntent.java
index ef7aff6..183eb16 100644
--- a/java/com/android/dialer/callintent/CallIntent.java
+++ b/java/com/android/dialer/callintent/CallIntent.java
@@ -152,8 +152,7 @@
             .setTimeSinceFirstClick(PerformanceReport.getTimeSinceFirstClick())
             .addAllUiActionsSinceAppLaunch(PerformanceReport.getActions())
             .addAllUiActionTimestampsSinceAppLaunch(PerformanceReport.getActionTimestamps())
-            .setStartingTabIndex(PerformanceReport.getStartingTabIndex())
-            .build();
+            .setStartingTabIndex(PerformanceReport.getStartingTabIndex());
         PerformanceReport.stopRecording();
       }
 
diff --git a/java/com/android/dialer/callintent/CallIntentBuilder.java b/java/com/android/dialer/callintent/CallIntentBuilder.java
index 7cc5891..b7f7d76 100644
--- a/java/com/android/dialer/callintent/CallIntentBuilder.java
+++ b/java/com/android/dialer/callintent/CallIntentBuilder.java
@@ -77,8 +77,7 @@
           .setTimeSinceFirstClick(PerformanceReport.getTimeSinceFirstClick())
           .addAllUiActionsSinceAppLaunch(PerformanceReport.getActions())
           .addAllUiActionTimestampsSinceAppLaunch(PerformanceReport.getActionTimestamps())
-          .setStartingTabIndex(PerformanceReport.getStartingTabIndex())
-          .build();
+          .setStartingTabIndex(PerformanceReport.getStartingTabIndex());
       PerformanceReport.stopRecording();
     }
 
diff --git a/java/com/android/dialer/contacts/resources/res/drawable-mdpi/ic_scroll_handle.png b/java/com/android/dialer/contacts/resources/res/drawable-mdpi/ic_scroll_handle.png
deleted file mode 100644
index 0724e2a..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable-mdpi/ic_scroll_handle.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/contacts/resources/res/drawable-xhdpi/ic_scroll_handle.png b/java/com/android/dialer/contacts/resources/res/drawable-xhdpi/ic_scroll_handle.png
deleted file mode 100644
index e0adfbb..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable-xhdpi/ic_scroll_handle.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/contacts/resources/res/drawable-xxhdpi/ic_scroll_handle.png b/java/com/android/dialer/contacts/resources/res/drawable-xxhdpi/ic_scroll_handle.png
deleted file mode 100644
index 37e041c..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable-xxhdpi/ic_scroll_handle.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/contacts/resources/res/drawable-xxxhdpi/ic_scroll_handle.png b/java/com/android/dialer/contacts/resources/res/drawable-xxxhdpi/ic_scroll_handle.png
deleted file mode 100644
index d725ce1..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable-xxxhdpi/ic_scroll_handle.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/contacts/resources/res/drawable/fastscroll_thumb.xml b/java/com/android/dialer/contacts/resources/res/drawable/fastscroll_thumb.xml
deleted file mode 100644
index 67645ff..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable/fastscroll_thumb.xml
+++ /dev/null
@@ -1,19 +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:drawable="@drawable/ic_scroll_handle_pressed" android:state_pressed="true"/>
-  <item android:drawable="@drawable/ic_scroll_handle_default"/>
-</selector>
\ No newline at end of file
diff --git a/java/com/android/dialer/contacts/resources/res/drawable/ic_scroll_handle_default.xml b/java/com/android/dialer/contacts/resources/res/drawable/ic_scroll_handle_default.xml
deleted file mode 100644
index 9164ab1..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable/ic_scroll_handle_default.xml
+++ /dev/null
@@ -1,20 +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.
--->
-
-<bitmap xmlns:android="http://schemas.android.com/apk/res/android"
-  android:src="@drawable/ic_scroll_handle"
-  android:tint="?colorIcon"/>
diff --git a/java/com/android/dialer/contacts/resources/res/drawable/ic_scroll_handle_pressed.xml b/java/com/android/dialer/contacts/resources/res/drawable/ic_scroll_handle_pressed.xml
deleted file mode 100644
index c9b93d9..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable/ic_scroll_handle_pressed.xml
+++ /dev/null
@@ -1,20 +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.
--->
-
-<bitmap xmlns:android="http://schemas.android.com/apk/res/android"
-  android:src="@drawable/ic_scroll_handle"
-  android:tint="?android:attr/colorPrimary"/>
\ No newline at end of file
diff --git a/java/com/android/dialer/voicemail/settings/res/drawable-xhdpi/ic_arrow_back_grey600_48dp.png b/java/com/android/dialer/voicemail/settings/res/drawable-xhdpi/ic_arrow_back_grey600_48dp.png
deleted file mode 100644
index 0a379b4..0000000
--- a/java/com/android/dialer/voicemail/settings/res/drawable-xhdpi/ic_arrow_back_grey600_48dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/voicemail/settings/res/drawable-xhdpi/ic_stop_circle_filled_blue_24dp.png b/java/com/android/dialer/voicemail/settings/res/drawable-xhdpi/ic_stop_circle_filled_blue_24dp.png
deleted file mode 100644
index 520f860..0000000
--- a/java/com/android/dialer/voicemail/settings/res/drawable-xhdpi/ic_stop_circle_filled_blue_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/NotificationBroadcastReceiver.java b/java/com/android/incallui/NotificationBroadcastReceiver.java
index 241d8ed..91421ea 100644
--- a/java/com/android/incallui/NotificationBroadcastReceiver.java
+++ b/java/com/android/incallui/NotificationBroadcastReceiver.java
@@ -16,14 +16,17 @@
 
 package com.android.incallui;
 
+import android.app.BroadcastOptions;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Build.VERSION_CODES;
+import android.os.Bundle;
 import android.support.annotation.NonNull;
 import android.support.annotation.RequiresApi;
 import android.telecom.CallAudioState;
 import android.telecom.VideoProfile;
+
 import com.android.dialer.common.LogUtil;
 import com.android.dialer.common.concurrent.DialerExecutorComponent;
 import com.android.dialer.logging.DialerImpression;
@@ -32,6 +35,7 @@
 import com.android.incallui.call.DialerCall;
 import com.android.incallui.call.TelecomAdapter;
 import com.android.incallui.speakeasy.SpeakEasyCallManager;
+
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
@@ -97,7 +101,7 @@
     } else if (action.equals(ACTION_DECLINE_VIDEO_UPGRADE_REQUEST)) {
       declineUpgradeRequest();
     } else if (action.equals(ACTION_PULL_EXTERNAL_CALL)) {
-      context.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));
+      closeSystemDialogs(context);
       int notificationId = intent.getIntExtra(EXTRA_NOTIFICATION_ID, -1);
       InCallPresenter.getInstance().getExternalCallNotifier().pullExternalCall(notificationId);
     } else if (action.equals(ACTION_TURN_ON_SPEAKER)) {
@@ -220,4 +224,15 @@
       }
     }
   }
+
+  /** Closes open system dialogs and the notification shade. */
+  private void closeSystemDialogs(Context context) {
+    final Intent intent = new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)
+            .addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
+    final Bundle options = BroadcastOptions.makeBasic()
+            .setDeliveryGroupPolicy(BroadcastOptions.DELIVERY_GROUP_POLICY_MOST_RECENT)
+            .setDeferralPolicy(BroadcastOptions.DEFERRAL_POLICY_UNTIL_ACTIVE)
+            .toBundle();
+    context.sendBroadcast(intent, null /* receiverPermission */, options);
+  }
 }
diff --git a/java/com/android/incallui/calllocation/impl/res/drawable/bg_location_card.xml b/java/com/android/incallui/calllocation/impl/res/drawable/bg_location_card.xml
deleted file mode 100644
index 0bcba95..0000000
--- a/java/com/android/incallui/calllocation/impl/res/drawable/bg_location_card.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2017 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/ripple_material_light">
-  <item android:drawable="@android:color/white"/>
-</ripple>
diff --git a/java/com/android/incallui/rtt/impl/res/drawable/incallui_message_bubble.xml b/java/com/android/incallui/rtt/impl/res/drawable/incallui_message_bubble.xml
deleted file mode 100644
index 31044b6..0000000
--- a/java/com/android/incallui/rtt/impl/res/drawable/incallui_message_bubble.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2018 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"
-    android:shape="rectangle">
-  <solid android:color="?android:attr/colorBackgroundFloating"/>
-  <corners android:radius="20dp"/>
-</shape>
\ No newline at end of file
