diff --git a/quickstep/AndroidManifest.xml b/quickstep/AndroidManifest.xml
index 4e7c3fa..8dab915 100644
--- a/quickstep/AndroidManifest.xml
+++ b/quickstep/AndroidManifest.xml
@@ -27,6 +27,7 @@
         android:permissionGroup="android.permission-group.SYSTEM_TOOLS"
         android:protectionLevel="signatureOrSystem" />
 
+    <uses-permission android:name="android.permission.BROADCAST_CLOSE_SYSTEM_DIALOGS" />
     <uses-permission android:name="android.permission.CONTROL_REMOTE_APP_TRANSITION_ANIMATIONS"/>
     <uses-permission android:name="android.permission.VIBRATE"/>
     <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES"/>
diff --git a/res/layout/search_result_icon.xml b/quickstep/res/layout/search_result_icon.xml
similarity index 88%
rename from res/layout/search_result_icon.xml
rename to quickstep/res/layout/search_result_icon.xml
index 3c1dd49..e1b6dfd 100644
--- a/res/layout/search_result_icon.xml
+++ b/quickstep/res/layout/search_result_icon.xml
@@ -13,7 +13,7 @@
      limitations under the License.
 -->
 
-<com.android.launcher3.views.SearchResultIcon xmlns:launcher="http://schemas.android.com/apk/res-auto"
+<com.android.launcher3.search.SearchResultIcon xmlns:launcher="http://schemas.android.com/apk/res-auto"
     style="@style/BaseIcon.AllApps"
     launcher:iconDisplay="all_apps"
     launcher:centerVertically="true" />
diff --git a/res/layout/search_result_icon_row.xml b/quickstep/res/layout/search_result_icon_row.xml
similarity index 93%
rename from res/layout/search_result_icon_row.xml
rename to quickstep/res/layout/search_result_icon_row.xml
index 81c23e4..1393b87 100644
--- a/res/layout/search_result_icon_row.xml
+++ b/quickstep/res/layout/search_result_icon_row.xml
@@ -12,14 +12,14 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<com.android.launcher3.views.SearchResultIconRow xmlns:android="http://schemas.android.com/apk/res/android"
+<com.android.launcher3.search.SearchResultIconRow xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:launcher="http://schemas.android.com/apk/res-auto"
     android:orientation="horizontal"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:padding="@dimen/dynamic_grid_edge_margin">
 
-    <com.android.launcher3.views.SearchResultIcon
+    <com.android.launcher3.search.SearchResultIcon
         android:layout_width="wrap_content"
         android:id="@+id/icon"
         launcher:iconDisplay="hero_app"
@@ -73,4 +73,4 @@
         launcher:iconSizeOverride="@dimen/deep_shortcut_icon_size"
         launcher:layoutHorizontal="false" />
 
-</com.android.launcher3.views.SearchResultIconRow>
\ No newline at end of file
+</com.android.launcher3.search.SearchResultIconRow>
\ No newline at end of file
diff --git a/res/layout/search_result_people_item.xml b/quickstep/res/layout/search_result_people_item.xml
similarity index 93%
rename from res/layout/search_result_people_item.xml
rename to quickstep/res/layout/search_result_people_item.xml
index 7526f6f..964300d 100644
--- a/res/layout/search_result_people_item.xml
+++ b/quickstep/res/layout/search_result_people_item.xml
@@ -12,7 +12,7 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<com.android.launcher3.views.SearchResultPeopleView xmlns:android="http://schemas.android.com/apk/res/android"
+<com.android.launcher3.search.SearchResultPeopleView xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:gravity="center_vertical"
     android:layout_height="wrap_content"
@@ -60,4 +60,4 @@
         android:layout_width="@dimen/deep_shortcut_icon_size"
         android:layout_height="@dimen/deep_shortcut_icon_size" />
 
-</com.android.launcher3.views.SearchResultPeopleView>
\ No newline at end of file
+</com.android.launcher3.search.SearchResultPeopleView>
\ No newline at end of file
diff --git a/res/layout/search_result_play_item.xml b/quickstep/res/layout/search_result_play_item.xml
similarity index 94%
rename from res/layout/search_result_play_item.xml
rename to quickstep/res/layout/search_result_play_item.xml
index d70c56a..ecd67b1 100644
--- a/res/layout/search_result_play_item.xml
+++ b/quickstep/res/layout/search_result_play_item.xml
@@ -13,7 +13,7 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<com.android.launcher3.views.SearchResultPlayItem xmlns:android="http://schemas.android.com/apk/res/android"
+<com.android.launcher3.search.SearchResultPlayItem xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:padding="4dp"
@@ -76,4 +76,4 @@
     </Button>
 
 
-</com.android.launcher3.views.SearchResultPlayItem>
+</com.android.launcher3.search.SearchResultPlayItem>
diff --git a/res/layout/search_result_settings_row.xml b/quickstep/res/layout/search_result_settings_row.xml
similarity index 93%
rename from res/layout/search_result_settings_row.xml
rename to quickstep/res/layout/search_result_settings_row.xml
index 22c08bf..33c9592 100644
--- a/res/layout/search_result_settings_row.xml
+++ b/quickstep/res/layout/search_result_settings_row.xml
@@ -12,7 +12,7 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<com.android.launcher3.views.SearchSettingsRowView xmlns:android="http://schemas.android.com/apk/res/android"
+<com.android.launcher3.search.SearchSettingsRowView xmlns:android="http://schemas.android.com/apk/res/android"
     style="@style/TextHeadline"
     android:id="@+id/section_title"
     android:background="?android:attr/selectableItemBackground"
@@ -57,4 +57,4 @@
             android:textColor="?android:attr/textColorSecondary"
             android:textSize="@dimen/search_hero_subtitle_size" />
     </LinearLayout>
-</com.android.launcher3.views.SearchSettingsRowView>
\ No newline at end of file
+</com.android.launcher3.search.SearchSettingsRowView>
\ No newline at end of file
diff --git a/res/layout/search_result_slice.xml b/quickstep/res/layout/search_result_slice.xml
similarity index 89%
rename from res/layout/search_result_slice.xml
rename to quickstep/res/layout/search_result_slice.xml
index 24d75e9..f7dcfce 100644
--- a/res/layout/search_result_slice.xml
+++ b/quickstep/res/layout/search_result_slice.xml
@@ -12,7 +12,7 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<com.android.launcher3.views.SearchResultSettingsSlice xmlns:android="http://schemas.android.com/apk/res/android"
+<com.android.launcher3.search.SearchResultSettingsSlice xmlns:android="http://schemas.android.com/apk/res/android"
     android:paddingHorizontal="@dimen/dynamic_grid_cell_padding_x"
     android:layout_width="match_parent"
     android:layout_height="wrap_content">
@@ -36,5 +36,5 @@
         android:layout_marginStart="@dimen/dynamic_grid_cell_padding_x"
         android:layout_width="0dp" />
 
-</com.android.launcher3.views.SearchResultSettingsSlice>
+</com.android.launcher3.search.SearchResultSettingsSlice>
 
diff --git a/res/layout/search_result_suggest.xml b/quickstep/res/layout/search_result_suggest.xml
similarity index 89%
rename from res/layout/search_result_suggest.xml
rename to quickstep/res/layout/search_result_suggest.xml
index 01e25d5..eb5313c 100644
--- a/res/layout/search_result_suggest.xml
+++ b/quickstep/res/layout/search_result_suggest.xml
@@ -12,7 +12,7 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<com.android.launcher3.views.SearchResultSuggestion xmlns:android="http://schemas.android.com/apk/res/android"
+<com.android.launcher3.search.SearchResultSuggestion xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:launcher="http://schemas.android.com/apk/res-auto"
     style="@style/BaseIcon"
     android:layout_width="match_parent"
@@ -31,4 +31,4 @@
     launcher:layoutHorizontal="true"
     android:drawablePadding="@dimen/dynamic_grid_icon_drawable_padding">
 
-</com.android.launcher3.views.SearchResultSuggestion>
\ No newline at end of file
+</com.android.launcher3.search.SearchResultSuggestion>
\ No newline at end of file
diff --git a/res/layout/search_result_thumbnail.xml b/quickstep/res/layout/search_result_thumbnail.xml
similarity index 93%
rename from res/layout/search_result_thumbnail.xml
rename to quickstep/res/layout/search_result_thumbnail.xml
index 0cc5a29..0f25336 100644
--- a/res/layout/search_result_thumbnail.xml
+++ b/quickstep/res/layout/search_result_thumbnail.xml
@@ -13,7 +13,7 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<com.android.launcher3.views.ThumbnailSearchResultView
+<com.android.launcher3.search.ThumbnailSearchResultView
     xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="125dp"
     android:layout_height="125dp"/>
\ No newline at end of file
diff --git a/res/layout/search_result_widget_live.xml b/quickstep/res/layout/search_result_widget_live.xml
similarity index 66%
rename from res/layout/search_result_widget_live.xml
rename to quickstep/res/layout/search_result_widget_live.xml
index 0dd8a06..ffbad55 100644
--- a/res/layout/search_result_widget_live.xml
+++ b/quickstep/res/layout/search_result_widget_live.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<com.android.launcher3.views.SearchResultWidget android:layout_height="wrap_content"
+<com.android.launcher3.search.SearchResultWidget android:layout_height="wrap_content"
     xmlns:android="http://schemas.android.com/apk/res/android"
     android:gravity="center"
     android:layout_width="match_parent" />
\ No newline at end of file
diff --git a/res/layout/search_result_widget_preview.xml b/quickstep/res/layout/search_result_widget_preview.xml
similarity index 64%
rename from res/layout/search_result_widget_preview.xml
rename to quickstep/res/layout/search_result_widget_preview.xml
index 942b199..7af24a1 100644
--- a/res/layout/search_result_widget_preview.xml
+++ b/quickstep/res/layout/search_result_widget_preview.xml
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
-<com.android.launcher3.views.SearchResultWidgetPreview xmlns:android="http://schemas.android.com/apk/res/android"
+<com.android.launcher3.search.SearchResultWidgetPreview xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:padding="@dimen/dynamic_grid_cell_padding_x"
     android:layout_height="wrap_content">
     <include layout="@layout/widget_cell" android:id="@+id/widget_cell"/>
 <!--    <include layout="@layout/widget_cell_content" />-->
-</com.android.launcher3.views.SearchResultWidgetPreview>
\ No newline at end of file
+</com.android.launcher3.search.SearchResultWidgetPreview>
\ No newline at end of file
diff --git a/res/layout/search_section_title.xml b/quickstep/res/layout/search_section_title.xml
similarity index 89%
rename from res/layout/search_section_title.xml
rename to quickstep/res/layout/search_section_title.xml
index b7ba83e..5842e57 100644
--- a/res/layout/search_section_title.xml
+++ b/quickstep/res/layout/search_section_title.xml
@@ -13,7 +13,7 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<com.android.launcher3.views.SearchSectionHeaderView xmlns:android="http://schemas.android.com/apk/res/android"
+<com.android.launcher3.search.SearchSectionHeaderView xmlns:android="http://schemas.android.com/apk/res/android"
     android:id="@+id/section_title"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
diff --git a/quickstep/res/values/dimens.xml b/quickstep/res/values/dimens.xml
index 727fbd3..551f7b0 100644
--- a/quickstep/res/values/dimens.xml
+++ b/quickstep/res/values/dimens.xml
@@ -45,7 +45,6 @@
 
     <!-- Launcher app transition -->
     <dimen name="content_trans_y">50dp</dimen>
-    <dimen name="workspace_trans_y">50dp</dimen>
     <dimen name="closing_window_trans_y">115dp</dimen>
 
     <dimen name="recents_empty_message_text_size">16sp</dimen>
diff --git a/quickstep/src/com/android/launcher3/BaseQuickstepLauncher.java b/quickstep/src/com/android/launcher3/BaseQuickstepLauncher.java
index 4204597..3643d6d 100644
--- a/quickstep/src/com/android/launcher3/BaseQuickstepLauncher.java
+++ b/quickstep/src/com/android/launcher3/BaseQuickstepLauncher.java
@@ -316,12 +316,4 @@
     public void setHintUserWillBeActive() {
         addActivityFlags(ACTIVITY_STATE_USER_WILL_BE_ACTIVE);
     }
-
-    @Override
-    public void onAttachedToWindow() {
-        super.onAttachedToWindow();
-        if (Utilities.ATLEAST_R) {
-            InteractionJankMonitorWrapper.init(getWindow().getDecorView());
-        }
-    }
 }
diff --git a/quickstep/src/com/android/launcher3/QuickstepAppTransitionManagerImpl.java b/quickstep/src/com/android/launcher3/QuickstepAppTransitionManagerImpl.java
index cc3b7b6..8e6a5b6 100644
--- a/quickstep/src/com/android/launcher3/QuickstepAppTransitionManagerImpl.java
+++ b/quickstep/src/com/android/launcher3/QuickstepAppTransitionManagerImpl.java
@@ -33,7 +33,6 @@
 import static com.android.launcher3.config.FeatureFlags.SEPARATE_RECENTS_ACTIVITY;
 import static com.android.launcher3.dragndrop.DragLayer.ALPHA_INDEX_TRANSITIONS;
 import static com.android.launcher3.statehandlers.DepthController.DEPTH;
-import static com.android.launcher3.views.FloatingIconView.SHAPE_PROGRESS_DURATION;
 import static com.android.quickstep.TaskUtils.taskIsATargetWithMode;
 import static com.android.systemui.shared.system.QuickStepContract.getWindowCornerRadius;
 import static com.android.systemui.shared.system.QuickStepContract.supportsRoundedCornersOnWindows;
@@ -149,7 +148,6 @@
     private final boolean mIsRtl;
 
     private final float mContentTransY;
-    private final float mWorkspaceTransY;
     private final float mClosingWindowTransY;
     private final float mMaxShadowRadius;
 
@@ -183,7 +181,6 @@
 
         Resources res = mLauncher.getResources();
         mContentTransY = res.getDimensionPixelSize(R.dimen.content_trans_y);
-        mWorkspaceTransY = res.getDimensionPixelSize(R.dimen.workspace_trans_y);
         mClosingWindowTransY = res.getDimensionPixelSize(R.dimen.closing_window_trans_y);
         mMaxShadowRadius = res.getDimensionPixelSize(R.dimen.max_shadow_radius);
 
@@ -457,39 +454,11 @@
                 new SurfaceTransactionApplier(floatingView);
         openingTargets.addReleaseCheck(surfaceApplier);
 
-        // Scale the app icon to take up the entire screen. This simplifies the math when
-        // animating the app window position / scale.
-        float smallestSize = Math.min(windowTargetBounds.height(), windowTargetBounds.width());
-        float maxScaleX = smallestSize / bounds.width();
-        float maxScaleY = smallestSize / bounds.height();
-        float scale = Math.max(maxScaleX, maxScaleY);
-        float startScale = 1f;
-        if (v instanceof BubbleTextView && !(v.getParent() instanceof DeepShortcutView)) {
-            Drawable dr = ((BubbleTextView) v).getIcon();
-            if (dr instanceof FastBitmapDrawable) {
-                startScale = ((FastBitmapDrawable) dr).getAnimatedScale();
-            }
-        }
-        final float initialStartScale = startScale;
-
         int[] dragLayerBounds = new int[2];
         mDragLayer.getLocationOnScreen(dragLayerBounds);
 
-        // Animate the app icon to the center of the window bounds in screen coordinates.
-        float centerX = windowTargetBounds.centerX() - dragLayerBounds[0];
-        float centerY = windowTargetBounds.centerY() - dragLayerBounds[1];
-
-        float dX = centerX - bounds.centerX();
-        float dY = centerY - bounds.centerY();
-
-        boolean useUpwardAnimation = bounds.top > centerY
-                || Math.abs(dY) < mLauncher.getDeviceProfile().cellHeightPx;
-        final long xDuration = useUpwardAnimation ? APP_LAUNCH_CURVED_DURATION
-                : APP_LAUNCH_DOWN_DURATION;
-        final long yDuration = useUpwardAnimation ? APP_LAUNCH_DURATION
-                : APP_LAUNCH_DOWN_CURVED_DURATION;
-        final long alphaDuration = useUpwardAnimation ? APP_LAUNCH_ALPHA_DURATION
-                : APP_LAUNCH_ALPHA_DOWN_DURATION;
+        AnimOpenProperties prop = new AnimOpenProperties(mLauncher.getResources(), mDeviceProfile,
+                windowTargetBounds, bounds, v, dragLayerBounds);
 
         RectF targetBounds = new RectF(windowTargetBounds);
         RectF iconBounds = new RectF();
@@ -511,39 +480,28 @@
             }
         });
 
-        float shapeRevealDuration = APP_LAUNCH_DURATION * SHAPE_PROGRESS_DURATION;
-
-        final float startCrop;
-        final float endCrop;
-        if (mDeviceProfile.isVerticalBarLayout()) {
-            startCrop = windowTargetBounds.height();
-            endCrop = windowTargetBounds.width();
-        } else {
-            startCrop = windowTargetBounds.width();
-            endCrop = windowTargetBounds.height();
-        }
-
         final float initialWindowRadius = supportsRoundedCornersOnWindows(mLauncher.getResources())
-                ? startCrop / 2f : 0f;
-        final float windowRadius = mDeviceProfile.isMultiWindowMode
+                ? prop.startCrop / 2f : 0f;
+        final float finalWindowRadius = mDeviceProfile.isMultiWindowMode
                 ? 0 : getWindowCornerRadius(mLauncher.getResources());
+
         appAnimator.addUpdateListener(new MultiValueUpdateListener() {
-            FloatProp mDx = new FloatProp(0, dX, 0, xDuration, AGGRESSIVE_EASE);
-            FloatProp mDy = new FloatProp(0, dY, 0, yDuration, AGGRESSIVE_EASE);
-            FloatProp mScale = new FloatProp(initialStartScale, scale, 0, APP_LAUNCH_DURATION,
+            FloatProp mDx = new FloatProp(0, prop.dX, 0, prop.xDuration, AGGRESSIVE_EASE);
+            FloatProp mDy = new FloatProp(0, prop.dY, 0, prop.yDuration, AGGRESSIVE_EASE);
+            FloatProp mScale = new FloatProp(prop.initialAppIconScale,
+                    prop.finalAppIconScale, 0, APP_LAUNCH_DURATION, EXAGGERATED_EASE);
+            FloatProp mIconAlpha = new FloatProp(prop.iconAlphaStart, 0f,
+                    APP_LAUNCH_ALPHA_START_DELAY, prop.alphaDuration, LINEAR);
+            FloatProp mCroppedSize = new FloatProp(prop.startCrop, prop.endCrop, 0, CROP_DURATION,
                     EXAGGERATED_EASE);
-            FloatProp mIconAlpha = new FloatProp(1f, 0f, APP_LAUNCH_ALPHA_START_DELAY,
-                    alphaDuration, LINEAR);
-            FloatProp mCroppedSize = new FloatProp(startCrop, endCrop, 0, CROP_DURATION,
-                    EXAGGERATED_EASE);
-            FloatProp mWindowRadius = new FloatProp(initialWindowRadius, windowRadius, 0,
+            FloatProp mWindowRadius = new FloatProp(initialWindowRadius, finalWindowRadius, 0,
                     RADIUS_DURATION, EXAGGERATED_EASE);
             FloatProp mShadowRadius = new FloatProp(0, mMaxShadowRadius, 0,
                     APP_LAUNCH_DURATION, EXAGGERATED_EASE);
 
             @Override
             public void onUpdate(float percent) {
-                // Calculate the size.
+                // Calculate the size of the scaled icon.
                 float width = bounds.width() * mScale.value;
                 float height = bounds.height() * mScale.value;
 
@@ -559,7 +517,7 @@
                 }
                 crop.set(0, 0, cropWidth, cropHeight);
 
-                // Scale the size to match the crop.
+                // Scale the size of the icon to match the size of the window crop.
                 float scaleX = width / cropWidth;
                 float scaleY = height / cropHeight;
                 float scale = Math.min(1f, Math.max(scaleX, scaleY));
@@ -569,7 +527,7 @@
                 float offsetX  = (scaledCropWidth - width) / 2;
                 float offsetY = (scaledCropHeight - height) / 2;
 
-                // Calculate the window position.
+                // Calculate the window position to match the icon position.
                 temp.set(bounds);
                 temp.offset(dragLayerBounds[0], dragLayerBounds[1]);
                 temp.offset(mDx.value, mDy.value);
@@ -586,8 +544,6 @@
                 iconBounds.right += offsetX;
                 iconBounds.bottom += offsetY;
 
-                float croppedHeight = (windowTargetBounds.height() - crop.height()) * scale;
-                float croppedWidth = (windowTargetBounds.width() - crop.width()) * scale;
                 SurfaceParams[] params = new SurfaceParams[appTargets.length];
                 for (int i = appTargets.length - 1; i >= 0; i--) {
                     RemoteAnimationTargetCompat target = appTargets[i];
@@ -807,7 +763,7 @@
         anim.addListener(new AnimationSuccessListener() {
             @Override
             public void onAnimationStart(Animator animation) {
-                InteractionJankMonitorWrapper.begin(cuj);
+                InteractionJankMonitorWrapper.begin(mDragLayer, cuj);
                 super.onAnimationStart(animation);
             }
 
@@ -970,4 +926,70 @@
             result.setAnimation(anim, mLauncher);
         }
     }
+
+    /**
+     * Class that holds all the variables for the app open animation.
+     */
+    static class AnimOpenProperties {
+
+        public final float startCrop;
+        public final float endCrop;
+
+        public final float dX;
+        public final float dY;
+
+        public final long xDuration;
+        public final long yDuration;
+        public final long alphaDuration;
+
+        public final float initialAppIconScale;
+        public final float finalAppIconScale;
+
+        public final float iconAlphaStart;
+
+        AnimOpenProperties(Resources r, DeviceProfile dp, Rect windowTargetBounds,
+                RectF launcherIconBounds, View view, int[] dragLayerBounds) {
+            // Scale the app icon to take up the entire screen. This simplifies the math when
+            // animating the app window position / scale.
+            float smallestSize = Math.min(windowTargetBounds.height(), windowTargetBounds.width());
+            float maxScaleX = smallestSize / launcherIconBounds.width();
+            float maxScaleY = smallestSize / launcherIconBounds.height();
+            float iconStartScale = 1f;
+            if (view instanceof BubbleTextView && !(view.getParent() instanceof DeepShortcutView)) {
+                Drawable dr = ((BubbleTextView) view).getIcon();
+                if (dr instanceof FastBitmapDrawable) {
+                    iconStartScale = ((FastBitmapDrawable) dr).getAnimatedScale();
+                }
+            }
+
+            initialAppIconScale = iconStartScale;
+            finalAppIconScale = Math.max(maxScaleX, maxScaleY);
+
+            // Animate the app icon to the center of the window bounds in screen coordinates.
+            float centerX = windowTargetBounds.centerX() - dragLayerBounds[0];
+            float centerY = windowTargetBounds.centerY() - dragLayerBounds[1];
+
+            dX = centerX - launcherIconBounds.centerX();
+            dY = centerY - launcherIconBounds.centerY();
+
+            boolean useUpwardAnimation = launcherIconBounds.top > centerY
+                    || Math.abs(dY) < dp.cellHeightPx;
+            xDuration = useUpwardAnimation ? APP_LAUNCH_CURVED_DURATION
+                    : APP_LAUNCH_DOWN_DURATION;
+            yDuration = useUpwardAnimation ? APP_LAUNCH_DURATION
+                    : APP_LAUNCH_DOWN_CURVED_DURATION;
+            alphaDuration = useUpwardAnimation ? APP_LAUNCH_ALPHA_DURATION
+                    : APP_LAUNCH_ALPHA_DOWN_DURATION;
+
+            if (dp.isVerticalBarLayout()) {
+                startCrop = windowTargetBounds.height();
+                endCrop = windowTargetBounds.width();
+            } else {
+                startCrop = windowTargetBounds.width();
+                endCrop = windowTargetBounds.height();
+            }
+
+            iconAlphaStart = 1f;
+        }
+    }
 }
diff --git a/quickstep/src/com/android/launcher3/search/DeviceSearchAdapterProvider.java b/quickstep/src/com/android/launcher3/search/DeviceSearchAdapterProvider.java
new file mode 100644
index 0000000..9ce196e
--- /dev/null
+++ b/quickstep/src/com/android/launcher3/search/DeviceSearchAdapterProvider.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package com.android.launcher3.search;
+
+import static com.android.launcher3.allapps.AllAppsGridAdapter.VIEW_TYPE_ICON;
+
+import android.app.search.SearchTarget;
+import android.util.SparseIntArray;
+import android.view.LayoutInflater;
+import android.view.ViewGroup;
+
+import com.android.launcher3.Launcher;
+import com.android.launcher3.R;
+import com.android.launcher3.allapps.AllAppsContainerView;
+import com.android.launcher3.allapps.AllAppsGridAdapter;
+import com.android.launcher3.allapps.search.SearchAdapterProvider;
+import com.android.launcher3.config.FeatureFlags;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
+
+/**
+ * Provides views for on-device search results
+ */
+public class DeviceSearchAdapterProvider extends SearchAdapterProvider {
+
+    public static final int VIEW_TYPE_SEARCH_CORPUS_TITLE = 1 << 5;
+    public static final int VIEW_TYPE_SEARCH_ROW_WITH_BUTTON = 1 << 7;
+    public static final int VIEW_TYPE_SEARCH_ROW = 1 << 8;
+    public static final int VIEW_TYPE_SEARCH_SLICE = 1 << 9;
+    public static final int VIEW_TYPE_SEARCH_ICON_ROW = 1 << 10;
+    public static final int VIEW_TYPE_SEARCH_PEOPLE = 1 << 11;
+    public static final int VIEW_TYPE_SEARCH_THUMBNAIL = 1 << 12;
+    public static final int VIEW_TYPE_SEARCH_SUGGEST = 1 << 13;
+    public static final int VIEW_TYPE_SEARCH_ICON = (1 << 14) | VIEW_TYPE_ICON;
+    public static final int VIEW_TYPE_SEARCH_WIDGET_LIVE = 1 << 15;
+    public static final int VIEW_TYPE_SEARCH_WIDGET_PREVIEW = 1 << 16;
+
+    private final AllAppsContainerView mAppsView;
+
+    private final SparseIntArray mViewTypeToLayoutMap = new SparseIntArray();
+
+    public DeviceSearchAdapterProvider(Launcher launcher, AllAppsContainerView appsView) {
+        super(launcher);
+        mAppsView = appsView;
+
+        mViewTypeToLayoutMap.put(VIEW_TYPE_SEARCH_ICON, R.layout.search_result_icon);
+        mViewTypeToLayoutMap.put(VIEW_TYPE_SEARCH_CORPUS_TITLE, R.layout.search_section_title);
+        mViewTypeToLayoutMap.put(VIEW_TYPE_SEARCH_ROW_WITH_BUTTON,
+                R.layout.search_result_play_item);
+        mViewTypeToLayoutMap.put(VIEW_TYPE_SEARCH_ROW, R.layout.search_result_settings_row);
+        mViewTypeToLayoutMap.put(VIEW_TYPE_SEARCH_SLICE, R.layout.search_result_slice);
+        mViewTypeToLayoutMap.put(VIEW_TYPE_SEARCH_ICON_ROW, R.layout.search_result_icon_row);
+        mViewTypeToLayoutMap.put(VIEW_TYPE_SEARCH_PEOPLE, R.layout.search_result_people_item);
+        mViewTypeToLayoutMap.put(VIEW_TYPE_SEARCH_THUMBNAIL, R.layout.search_result_thumbnail);
+        mViewTypeToLayoutMap.put(VIEW_TYPE_SEARCH_SUGGEST, R.layout.search_result_suggest);
+        mViewTypeToLayoutMap.put(VIEW_TYPE_SEARCH_WIDGET_LIVE, R.layout.search_result_widget_live);
+        mViewTypeToLayoutMap.put(VIEW_TYPE_SEARCH_WIDGET_PREVIEW,
+                R.layout.search_result_widget_preview);
+    }
+
+    @Override
+    public void onBindView(AllAppsGridAdapter.ViewHolder holder, int position) {
+        SearchAdapterItem item = (SearchAdapterItem) mAppsView.getApps().getAdapterItems().get(
+                position);
+        SearchTargetHandler
+                payloadResultView =
+                (SearchTargetHandler) holder.itemView;
+        if (FeatureFlags.SEARCH_TARGET_LEGACY.get()) {
+            payloadResultView.applySearchTarget(item.getSearchTargetLegacy());
+        } else {
+            payloadResultView.applySearchTarget(item.getSearchTarget());
+        }
+    }
+
+    @Override
+    public boolean isSearchView(int viewType) {
+        return mViewTypeToLayoutMap.get(viewType, -1) != -1;
+    }
+
+    @Override
+    public AllAppsGridAdapter.ViewHolder onCreateViewHolder(LayoutInflater inflater,
+            ViewGroup parent, int viewType) {
+        return new AllAppsGridAdapter.ViewHolder(inflater.inflate(
+                mViewTypeToLayoutMap.get(viewType), parent, false));
+    }
+
+    @Override
+    public int getGridSpanSize(int viewType, int appsPerRow) {
+        if (viewType == VIEW_TYPE_SEARCH_THUMBNAIL
+                || viewType == VIEW_TYPE_SEARCH_WIDGET_PREVIEW) {
+            return appsPerRow;
+        }
+        return super.getGridSpanSize(viewType, appsPerRow);
+    }
+
+
+    @Override
+    public boolean onAdapterItemSelected(AllAppsGridAdapter.AdapterItem focusedItem) {
+        if (focusedItem instanceof SearchTargetHandler) {
+            SearchTargetLegacy searchTarget = ((SearchAdapterItem) focusedItem)
+                    .getSearchTargetLegacy();
+            SearchEventTracker.INSTANCE.get(mLauncher).quickSelect(searchTarget);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Determines what view type should be used to present search target.
+     * Returns -1 if viewType is not found
+     */
+    public int getViewTypeForSearchTarget(SearchTarget t) {
+        //TODO: Replace with values from :SearchUi
+        if (t.getResultType() == 1 && t.getLayoutType().equals("icon")) {
+            return VIEW_TYPE_SEARCH_ICON;
+        }
+        return -1;
+    }
+}
diff --git a/quickstep/src/com/android/launcher3/search/SearchAdapterItem.java b/quickstep/src/com/android/launcher3/search/SearchAdapterItem.java
new file mode 100644
index 0000000..258d977
--- /dev/null
+++ b/quickstep/src/com/android/launcher3/search/SearchAdapterItem.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package com.android.launcher3.search;
+
+import static com.android.launcher3.search.DeviceSearchAdapterProvider.VIEW_TYPE_SEARCH_ICON;
+import static com.android.launcher3.search.DeviceSearchAdapterProvider.VIEW_TYPE_SEARCH_ICON_ROW;
+import static com.android.launcher3.search.DeviceSearchAdapterProvider.VIEW_TYPE_SEARCH_PEOPLE;
+import static com.android.launcher3.search.DeviceSearchAdapterProvider.VIEW_TYPE_SEARCH_ROW;
+import static com.android.launcher3.search.DeviceSearchAdapterProvider.VIEW_TYPE_SEARCH_ROW_WITH_BUTTON;
+import static com.android.launcher3.search.DeviceSearchAdapterProvider.VIEW_TYPE_SEARCH_SLICE;
+import static com.android.launcher3.search.DeviceSearchAdapterProvider.VIEW_TYPE_SEARCH_SUGGEST;
+import static com.android.launcher3.search.DeviceSearchAdapterProvider.VIEW_TYPE_SEARCH_THUMBNAIL;
+import static com.android.launcher3.search.DeviceSearchAdapterProvider.VIEW_TYPE_SEARCH_WIDGET_LIVE;
+import static com.android.launcher3.search.DeviceSearchAdapterProvider.VIEW_TYPE_SEARCH_WIDGET_PREVIEW;
+
+import android.app.search.SearchTarget;
+
+import com.android.launcher3.allapps.AllAppsGridAdapter;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
+
+/**
+ * Extension of AdapterItem that contains an extra payload specific to item
+ */
+public class SearchAdapterItem extends AllAppsGridAdapter.AdapterItem {
+    private SearchTargetLegacy mSearchTargetLegacy;
+    private SearchTarget mSearchTarget;
+
+
+    private static final int AVAILABLE_FOR_ACCESSIBILITY = VIEW_TYPE_SEARCH_ROW_WITH_BUTTON
+            | VIEW_TYPE_SEARCH_SLICE | VIEW_TYPE_SEARCH_ROW | VIEW_TYPE_SEARCH_PEOPLE
+            | VIEW_TYPE_SEARCH_THUMBNAIL | VIEW_TYPE_SEARCH_ICON_ROW | VIEW_TYPE_SEARCH_ICON
+            | VIEW_TYPE_SEARCH_WIDGET_PREVIEW | VIEW_TYPE_SEARCH_WIDGET_LIVE
+            | VIEW_TYPE_SEARCH_SUGGEST;
+
+    public SearchAdapterItem(SearchTargetLegacy searchTargetLegacy, int type) {
+        mSearchTargetLegacy = searchTargetLegacy;
+        viewType = type;
+    }
+
+
+    public SearchAdapterItem(SearchTarget searchTarget, int type) {
+        mSearchTarget = searchTarget;
+        viewType = type;
+    }
+
+    public SearchTargetLegacy getSearchTargetLegacy() {
+        return mSearchTargetLegacy;
+    }
+
+    public SearchTarget getSearchTarget() {
+        return mSearchTarget;
+    }
+
+    @Override
+    protected boolean isCountedForAccessibility() {
+        return (AVAILABLE_FOR_ACCESSIBILITY & viewType) == viewType;
+    }
+}
diff --git a/src/com/android/launcher3/allapps/search/SearchEventTracker.java b/quickstep/src/com/android/launcher3/search/SearchEventTracker.java
similarity index 80%
rename from src/com/android/launcher3/allapps/search/SearchEventTracker.java
rename to quickstep/src/com/android/launcher3/search/SearchEventTracker.java
index c276434..90fe661 100644
--- a/src/com/android/launcher3/allapps/search/SearchEventTracker.java
+++ b/quickstep/src/com/android/launcher3/search/SearchEventTracker.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.android.launcher3.allapps.search;
+package com.android.launcher3.search;
 
 import static com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR;
 
@@ -21,11 +21,10 @@
 
 import androidx.annotation.Nullable;
 
-import com.android.launcher3.allapps.search.AllAppsSearchBarController.SearchTargetHandler;
 import com.android.launcher3.util.MainThreadInitializedObject;
 import com.android.systemui.plugins.AllAppsSearchPlugin;
-import com.android.systemui.plugins.shared.SearchTarget;
-import com.android.systemui.plugins.shared.SearchTargetEvent;
+import com.android.systemui.plugins.shared.SearchTargetEventLegacy;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
 
 import java.util.WeakHashMap;
 
@@ -35,7 +34,7 @@
 public class SearchEventTracker {
     @Nullable
     private AllAppsSearchPlugin mPlugin;
-    private final WeakHashMap<SearchTarget, SearchTargetHandler>
+    private final WeakHashMap<SearchTargetLegacy, SearchTargetHandler>
             mCallbacks = new WeakHashMap<>();
 
     public static final MainThreadInitializedObject<SearchEventTracker> INSTANCE =
@@ -61,26 +60,27 @@
     /**
      * Sends SearchTargetEvent to search provider
      */
-    public void notifySearchTargetEvent(SearchTargetEvent searchTargetEvent) {
+    public void notifySearchTargetEvent(SearchTargetEventLegacy searchTargetEvent) {
         if (mPlugin != null) {
-            UI_HELPER_EXECUTOR.post(() -> mPlugin.notifySearchTargetEvent(searchTargetEvent));
+            UI_HELPER_EXECUTOR.post(() -> mPlugin.notifySearchTargetEventLegacy(searchTargetEvent));
         }
     }
 
     /**
      * Registers a {@link SearchTargetHandler} to handle quick launch for specified SearchTarget.
      */
-    public void registerWeakHandler(SearchTarget searchTarget, SearchTargetHandler targetHandler) {
+    public void registerWeakHandler(SearchTargetLegacy searchTarget,
+            SearchTargetHandler targetHandler) {
         mCallbacks.put(searchTarget, targetHandler);
     }
 
     /**
      * Handles quick select for SearchTarget
      */
-    public void quickSelect(SearchTarget searchTarget) {
+    public void quickSelect(SearchTargetLegacy searchTarget) {
         SearchTargetHandler searchTargetHandler = mCallbacks.get(searchTarget);
         if (searchTargetHandler != null) {
-            searchTargetHandler.handleSelection(SearchTargetEvent.QUICK_SELECT);
+            searchTargetHandler.handleSelection(SearchTargetEventLegacy.QUICK_SELECT);
         }
     }
 
diff --git a/src/com/android/launcher3/views/SearchResultIcon.java b/quickstep/src/com/android/launcher3/search/SearchResultIcon.java
similarity index 89%
rename from src/com/android/launcher3/views/SearchResultIcon.java
rename to quickstep/src/com/android/launcher3/search/SearchResultIcon.java
index 9bcfb8c..e4d737c 100644
--- a/src/com/android/launcher3/views/SearchResultIcon.java
+++ b/quickstep/src/com/android/launcher3/search/SearchResultIcon.java
@@ -13,13 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.android.launcher3.views;
+package com.android.launcher3.search;
 
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 import static com.android.launcher3.util.Executors.MODEL_EXECUTOR;
 import static com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR;
 
 import android.app.RemoteAction;
+import android.app.search.SearchTarget;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.pm.ShortcutInfo;
@@ -34,8 +35,6 @@
 import com.android.launcher3.Launcher;
 import com.android.launcher3.LauncherAppState;
 import com.android.launcher3.allapps.AllAppsStore;
-import com.android.launcher3.allapps.search.AllAppsSearchBarController;
-import com.android.launcher3.allapps.search.SearchEventTracker;
 import com.android.launcher3.icons.BitmapInfo;
 import com.android.launcher3.icons.LauncherIcons;
 import com.android.launcher3.model.data.AppInfo;
@@ -44,8 +43,8 @@
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.touch.ItemLongClickListener;
 import com.android.launcher3.util.ComponentKey;
-import com.android.systemui.plugins.shared.SearchTarget;
-import com.android.systemui.plugins.shared.SearchTargetEvent;
+import com.android.systemui.plugins.shared.SearchTargetEventLegacy;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
 
 import java.util.function.Consumer;
 
@@ -53,7 +52,7 @@
  * A {@link BubbleTextView} representing a single cell result in AllApps
  */
 public class SearchResultIcon extends BubbleTextView implements
-        AllAppsSearchBarController.SearchTargetHandler, View.OnClickListener,
+        SearchTargetHandler, View.OnClickListener,
         View.OnLongClickListener {
 
 
@@ -71,7 +70,7 @@
 
     private final Launcher mLauncher;
 
-    private SearchTarget mSearchTarget;
+    private SearchTargetLegacy mSearchTarget;
     private Consumer<ItemInfoWithIcon> mOnItemInfoChanged;
 
     public SearchResultIcon(Context context) {
@@ -102,13 +101,13 @@
      * Applies search target with a ItemInfoWithIcon consumer to be called after itemInfo is
      * constructed
      */
-    public void applySearchTarget(SearchTarget searchTarget, Consumer<ItemInfoWithIcon> cb) {
+    public void applySearchTarget(SearchTargetLegacy searchTarget, Consumer<ItemInfoWithIcon> cb) {
         mOnItemInfoChanged = cb;
         applySearchTarget(searchTarget);
     }
 
     @Override
-    public void applySearchTarget(SearchTarget searchTarget) {
+    public void applySearchTarget(SearchTargetLegacy searchTarget) {
         mSearchTarget = searchTarget;
         SearchEventTracker.getInstance(getContext()).registerWeakHandler(mSearchTarget, this);
         setVisibility(VISIBLE);
@@ -129,9 +128,16 @@
         }
     }
 
+    @Override
+    public void applySearchTarget(SearchTarget searchTarget) {
+        prepareUsingApp(new ComponentName(searchTarget.getPackageName(),
+                searchTarget.getExtras().getString("class")), searchTarget.getUserHandle());
+    }
+
     private void prepareUsingApp(ComponentName componentName, UserHandle userHandle) {
         AllAppsStore appsStore = mLauncher.getAppsView().getAppsStore();
         AppInfo appInfo = appsStore.getApp(new ComponentKey(componentName, userHandle));
+
         if (appInfo == null) {
             setVisibility(GONE);
             return;
@@ -183,7 +189,8 @@
     }
 
     private void reportEvent(int eventType) {
-        SearchTargetEvent.Builder b = new SearchTargetEvent.Builder(mSearchTarget, eventType);
+        SearchTargetEventLegacy.Builder b = new SearchTargetEventLegacy.Builder(mSearchTarget,
+                eventType);
         if (mSearchTarget.getItemType().equals(TARGET_TYPE_SHORTCUT)) {
             b.setShortcutPosition(0);
         }
@@ -193,7 +200,7 @@
 
     @Override
     public void onClick(View view) {
-        handleSelection(SearchTargetEvent.SELECT);
+        handleSelection(SearchTargetEventLegacy.SELECT);
     }
 
     @Override
@@ -201,7 +208,7 @@
         if (!supportsLongPress(mSearchTarget.getItemType())) {
             return false;
         }
-        reportEvent(SearchTargetEvent.LONG_PRESS);
+        reportEvent(SearchTargetEventLegacy.LONG_PRESS);
         return ItemLongClickListener.INSTANCE_ALL_APPS.onLongClick(view);
 
     }
diff --git a/src/com/android/launcher3/views/SearchResultIconRow.java b/quickstep/src/com/android/launcher3/search/SearchResultIconRow.java
similarity index 91%
rename from src/com/android/launcher3/views/SearchResultIconRow.java
rename to quickstep/src/com/android/launcher3/search/SearchResultIconRow.java
index e3c7661..8c491d2 100644
--- a/src/com/android/launcher3/views/SearchResultIconRow.java
+++ b/quickstep/src/com/android/launcher3/search/SearchResultIconRow.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.android.launcher3.views;
+package com.android.launcher3.search;
 
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 import static com.android.launcher3.util.Executors.MODEL_EXECUTOR;
@@ -36,13 +36,11 @@
 import com.android.launcher3.Launcher;
 import com.android.launcher3.LauncherAppState;
 import com.android.launcher3.R;
-import com.android.launcher3.allapps.search.AllAppsSearchBarController;
-import com.android.launcher3.allapps.search.SearchEventTracker;
 import com.android.launcher3.model.data.ItemInfoWithIcon;
 import com.android.launcher3.model.data.PackageItemInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
-import com.android.systemui.plugins.shared.SearchTarget;
-import com.android.systemui.plugins.shared.SearchTargetEvent;
+import com.android.systemui.plugins.shared.SearchTargetEventLegacy;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -53,7 +51,7 @@
  * shortcuts
  */
 public class SearchResultIconRow extends LinearLayout implements
-        AllAppsSearchBarController.SearchTargetHandler, View.OnClickListener,
+        SearchTargetHandler, View.OnClickListener,
         View.OnLongClickListener, Consumer<ItemInfoWithIcon> {
     public static final int MAX_SHORTCUTS_COUNT = 2;
 
@@ -65,7 +63,7 @@
     private TextView mDescriptionView;
     private BubbleTextView[] mShortcutViews = new BubbleTextView[2];
 
-    private SearchTarget mSearchTarget;
+    private SearchTargetLegacy mSearchTarget;
     private PackageItemInfo mProviderInfo;
 
 
@@ -102,8 +100,9 @@
             lp.width = iconSize;
             bubbleTextView.setOnClickListener(view -> {
                 WorkspaceItemInfo itemInfo = (WorkspaceItemInfo) bubbleTextView.getTag();
-                SearchTargetEvent event = new SearchTargetEvent.Builder(mSearchTarget,
-                        SearchTargetEvent.CHILD_SELECT).setShortcutPosition(itemInfo.rank).build();
+                SearchTargetEventLegacy event = new SearchTargetEventLegacy.Builder(mSearchTarget,
+                        SearchTargetEventLegacy.CHILD_SELECT).setShortcutPosition(
+                        itemInfo.rank).build();
                 SearchEventTracker.getInstance(getContext()).notifySearchTargetEvent(event);
                 mLauncher.getItemOnClickListener().onClick(view);
             });
@@ -113,7 +112,7 @@
     }
 
     @Override
-    public void applySearchTarget(SearchTarget searchTarget) {
+    public void applySearchTarget(SearchTargetLegacy searchTarget) {
         mSearchTarget = searchTarget;
         mResultIcon.applySearchTarget(searchTarget, this);
         String itemType = searchTarget.getItemType();
diff --git a/src/com/android/launcher3/views/SearchResultPeopleView.java b/quickstep/src/com/android/launcher3/search/SearchResultPeopleView.java
similarity index 91%
rename from src/com/android/launcher3/views/SearchResultPeopleView.java
rename to quickstep/src/com/android/launcher3/search/SearchResultPeopleView.java
index e499bd5..8caa51c 100644
--- a/src/com/android/launcher3/views/SearchResultPeopleView.java
+++ b/quickstep/src/com/android/launcher3/search/SearchResultPeopleView.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.android.launcher3.views;
+package com.android.launcher3.search;
 
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 import static com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR;
@@ -42,12 +42,10 @@
 import com.android.launcher3.DeviceProfile;
 import com.android.launcher3.Launcher;
 import com.android.launcher3.R;
-import com.android.launcher3.allapps.search.AllAppsSearchBarController;
-import com.android.launcher3.allapps.search.SearchEventTracker;
 import com.android.launcher3.icons.BitmapInfo;
 import com.android.launcher3.icons.LauncherIcons;
-import com.android.systemui.plugins.shared.SearchTarget;
-import com.android.systemui.plugins.shared.SearchTargetEvent;
+import com.android.systemui.plugins.shared.SearchTargetEventLegacy;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
 
 import java.util.ArrayList;
 
@@ -55,7 +53,7 @@
  * A view representing a single people search result in all apps
  */
 public class SearchResultPeopleView extends LinearLayout implements
-        AllAppsSearchBarController.SearchTargetHandler {
+        SearchTargetHandler {
 
     public static final String TARGET_TYPE_PEOPLE = "people";
 
@@ -68,7 +66,7 @@
     private Intent mIntent;
 
 
-    private SearchTarget mSearchTarget;
+    private SearchTargetLegacy mSearchTarget;
 
     public SearchResultPeopleView(Context context) {
         this(context, null, 0);
@@ -101,11 +99,11 @@
             button.getLayoutParams().width = mButtonSize;
             button.getLayoutParams().height = mButtonSize;
         }
-        setOnClickListener(v -> handleSelection(SearchTargetEvent.SELECT));
+        setOnClickListener(v -> handleSelection(SearchTargetEventLegacy.SELECT));
     }
 
     @Override
-    public void applySearchTarget(SearchTarget searchTarget) {
+    public void applySearchTarget(SearchTargetLegacy searchTarget) {
         mSearchTarget = searchTarget;
         Bundle payload = searchTarget.getExtras();
         mTitleView.setText(payload.getString("title"));
@@ -188,8 +186,8 @@
             Bundle bundle = new Bundle();
             bundle.putBundle("provider", provider);
             SearchEventTracker.INSTANCE.get(getContext()).notifySearchTargetEvent(
-                    new SearchTargetEvent.Builder(mSearchTarget,
-                            SearchTargetEvent.CHILD_SELECT).setExtras(bundle).build());
+                    new SearchTargetEventLegacy.Builder(mSearchTarget,
+                            SearchTargetEventLegacy.CHILD_SELECT).setExtras(bundle).build());
         });
     }
 
@@ -199,7 +197,7 @@
             Launcher launcher = Launcher.getLauncher(getContext());
             launcher.startActivitySafely(this, mIntent, null);
             SearchEventTracker.INSTANCE.get(getContext()).notifySearchTargetEvent(
-                    new SearchTargetEvent.Builder(mSearchTarget, eventType).build());
+                    new SearchTargetEventLegacy.Builder(mSearchTarget, eventType).build());
         }
     }
 }
diff --git a/src/com/android/launcher3/views/SearchResultPlayItem.java b/quickstep/src/com/android/launcher3/search/SearchResultPlayItem.java
similarity index 92%
rename from src/com/android/launcher3/views/SearchResultPlayItem.java
rename to quickstep/src/com/android/launcher3/search/SearchResultPlayItem.java
index 86ed436..3bb821f 100644
--- a/src/com/android/launcher3/views/SearchResultPlayItem.java
+++ b/quickstep/src/com/android/launcher3/search/SearchResultPlayItem.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.android.launcher3.views;
+package com.android.launcher3.search;
 
 import static com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR;
 
@@ -41,12 +41,10 @@
 import com.android.launcher3.DeviceProfile;
 import com.android.launcher3.Launcher;
 import com.android.launcher3.R;
-import com.android.launcher3.allapps.search.AllAppsSearchBarController;
-import com.android.launcher3.allapps.search.SearchEventTracker;
 import com.android.launcher3.icons.BitmapRenderer;
 import com.android.launcher3.util.Themes;
-import com.android.systemui.plugins.shared.SearchTarget;
-import com.android.systemui.plugins.shared.SearchTargetEvent;
+import com.android.systemui.plugins.shared.SearchTargetEventLegacy;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
 
 import java.io.IOException;
 import java.net.URL;
@@ -56,7 +54,7 @@
  * A View representing a PlayStore item.
  */
 public class SearchResultPlayItem extends LinearLayout implements
-        AllAppsSearchBarController.SearchTargetHandler {
+        SearchTargetHandler {
 
     public static final String TARGET_TYPE_PLAY = "play";
 
@@ -71,7 +69,7 @@
     private String mPackageName;
     private boolean mIsInstantGame;
 
-    private SearchTarget mSearchTarget;
+    private SearchTargetLegacy mSearchTarget;
 
 
     public SearchResultPlayItem(Context context) {
@@ -103,7 +101,7 @@
         ViewGroup.LayoutParams iconParams = mIconView.getLayoutParams();
         iconParams.height = mDeviceProfile.allAppsIconSizePx;
         iconParams.width = mDeviceProfile.allAppsIconSizePx;
-        setOnClickListener(view -> handleSelection(SearchTargetEvent.SELECT));
+        setOnClickListener(view -> handleSelection(SearchTargetEventLegacy.SELECT));
     }
 
 
@@ -129,7 +127,7 @@
 
 
     @Override
-    public void applySearchTarget(SearchTarget searchTarget) {
+    public void applySearchTarget(SearchTargetLegacy searchTarget) {
         mSearchTarget = searchTarget;
         Bundle bundle = searchTarget.getExtras();
         SearchEventTracker.INSTANCE.get(getContext()).registerWeakHandler(searchTarget, this);
@@ -195,11 +193,11 @@
         intent.putExtra("callerId", getContext().getPackageName());
         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
         getContext().startActivity(intent);
-        logSearchEvent(SearchTargetEvent.CHILD_SELECT);
+        logSearchEvent(SearchTargetEventLegacy.CHILD_SELECT);
     }
 
     private void logSearchEvent(int eventType) {
         SearchEventTracker.INSTANCE.get(getContext()).notifySearchTargetEvent(
-                new SearchTargetEvent.Builder(mSearchTarget, eventType).build());
+                new SearchTargetEventLegacy.Builder(mSearchTarget, eventType).build());
     }
 }
diff --git a/src/com/android/launcher3/views/SearchResultSettingsSlice.java b/quickstep/src/com/android/launcher3/search/SearchResultSettingsSlice.java
similarity index 83%
rename from src/com/android/launcher3/views/SearchResultSettingsSlice.java
rename to quickstep/src/com/android/launcher3/search/SearchResultSettingsSlice.java
index 29e6c1b..80ad305 100644
--- a/src/com/android/launcher3/views/SearchResultSettingsSlice.java
+++ b/quickstep/src/com/android/launcher3/search/SearchResultSettingsSlice.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.android.launcher3.views;
+package com.android.launcher3.search;
 
 import android.content.Context;
 import android.net.Uri;
@@ -32,16 +32,14 @@
 
 import com.android.launcher3.Launcher;
 import com.android.launcher3.R;
-import com.android.launcher3.allapps.search.AllAppsSearchBarController;
-import com.android.launcher3.allapps.search.SearchEventTracker;
-import com.android.systemui.plugins.shared.SearchTarget;
-import com.android.systemui.plugins.shared.SearchTargetEvent;
+import com.android.systemui.plugins.shared.SearchTargetEventLegacy;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
 
 /**
  * A slice view wrapper with settings app icon at start
  */
 public class SearchResultSettingsSlice extends LinearLayout implements
-        AllAppsSearchBarController.SearchTargetHandler, SliceView.OnSliceActionListener {
+        SearchTargetHandler, SliceView.OnSliceActionListener {
 
 
     public static final String TARGET_TYPE_SLICE = "settings_slice";
@@ -52,7 +50,7 @@
     private SliceView mSliceView;
     private View mIcon;
     private LiveData<Slice> mSliceLiveData;
-    private SearchTarget mSearchTarget;
+    private SearchTargetLegacy mSearchTarget;
     private final Launcher mLauncher;
 
     public SearchResultSettingsSlice(Context context) {
@@ -79,7 +77,7 @@
     }
 
     @Override
-    public void applySearchTarget(SearchTarget searchTarget) {
+    public void applySearchTarget(SearchTargetLegacy searchTarget) {
         reset();
         mSearchTarget = searchTarget;
         try {
@@ -105,8 +103,8 @@
     @Override
     public void handleSelection(int eventType) {
         SearchEventTracker.INSTANCE.get(mLauncher).notifySearchTargetEvent(
-                new SearchTargetEvent.Builder(mSearchTarget,
-                        SearchTargetEvent.CHILD_SELECT).build());
+                new SearchTargetEventLegacy.Builder(mSearchTarget,
+                        SearchTargetEventLegacy.CHILD_SELECT).build());
     }
 
     private void reset() {
@@ -118,7 +116,7 @@
 
     @Override
     public void onSliceAction(@NonNull EventInfo eventInfo, @NonNull SliceItem sliceItem) {
-        handleSelection(SearchTargetEvent.CHILD_SELECT);
+        handleSelection(SearchTargetEventLegacy.CHILD_SELECT);
     }
 
     private Uri getSliceUri() {
diff --git a/src/com/android/launcher3/views/SearchResultSuggestion.java b/quickstep/src/com/android/launcher3/search/SearchResultSuggestion.java
similarity index 95%
rename from src/com/android/launcher3/views/SearchResultSuggestion.java
rename to quickstep/src/com/android/launcher3/search/SearchResultSuggestion.java
index c67b1cf..6a6bd1b 100644
--- a/src/com/android/launcher3/views/SearchResultSuggestion.java
+++ b/quickstep/src/com/android/launcher3/search/SearchResultSuggestion.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.android.launcher3.views;
+package com.android.launcher3.search;
 
 import android.content.Context;
 import android.content.res.TypedArray;
@@ -22,6 +22,7 @@
 import android.view.ViewGroup;
 
 import com.android.launcher3.R;
+import com.android.launcher3.views.BaseDragLayer;
 
 /**
  * {@link SearchResultIconRow} with custom drawable resource
diff --git a/src/com/android/launcher3/views/SearchResultWidget.java b/quickstep/src/com/android/launcher3/search/SearchResultWidget.java
similarity index 90%
rename from src/com/android/launcher3/views/SearchResultWidget.java
rename to quickstep/src/com/android/launcher3/search/SearchResultWidget.java
index f76de3d..4fe9229 100644
--- a/src/com/android/launcher3/views/SearchResultWidget.java
+++ b/quickstep/src/com/android/launcher3/search/SearchResultWidget.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.android.launcher3.views;
+package com.android.launcher3.search;
 
 import android.appwidget.AppWidgetHostView;
 import android.appwidget.AppWidgetProviderInfo;
@@ -32,21 +32,19 @@
 import com.android.launcher3.CheckLongPressHelper;
 import com.android.launcher3.DeviceProfile;
 import com.android.launcher3.Launcher;
-import com.android.launcher3.allapps.search.AllAppsSearchBarController;
-import com.android.launcher3.allapps.search.SearchEventTracker;
 import com.android.launcher3.allapps.search.SearchWidgetInfoContainer;
 import com.android.launcher3.dragndrop.DraggableView;
 import com.android.launcher3.touch.ItemLongClickListener;
 import com.android.launcher3.widget.PendingAddWidgetInfo;
-import com.android.systemui.plugins.shared.SearchTarget;
-import com.android.systemui.plugins.shared.SearchTargetEvent;
+import com.android.systemui.plugins.shared.SearchTargetEventLegacy;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
 
 /**
  * displays live version of a widget upon receiving {@link AppWidgetProviderInfo} from Search
  * provider
  */
 public class SearchResultWidget extends RelativeLayout implements
-        AllAppsSearchBarController.SearchTargetHandler, DraggableView, View.OnLongClickListener {
+        SearchTargetHandler, DraggableView, View.OnLongClickListener {
 
     private static final String TAG = "SearchResultWidget";
 
@@ -60,7 +58,7 @@
     private final AppWidgetHostView mHostView;
     private final float mScaleToFit;
 
-    private SearchTarget mSearchTarget;
+    private SearchTargetLegacy mSearchTarget;
     private AppWidgetProviderInfo mProviderInfo;
 
     private SearchWidgetInfoContainer mInfoContainer;
@@ -84,7 +82,7 @@
 
         // detect tap event on widget container for search target event reporting
         mClickDetector = new GestureDetector(context,
-                new ClickListener(() -> handleSelection(SearchTargetEvent.CHILD_SELECT)));
+                new ClickListener(() -> handleSelection(SearchTargetEventLegacy.CHILD_SELECT)));
 
         mLongPressHelper = new CheckLongPressHelper(this);
         mLongPressHelper.setLongPressTimeoutFactor(1);
@@ -98,7 +96,7 @@
     }
 
     @Override
-    public void applySearchTarget(SearchTarget searchTarget) {
+    public void applySearchTarget(SearchTargetLegacy searchTarget) {
         if (searchTarget.getExtras() == null
                 || searchTarget.getExtras().getParcelable("provider") == null) {
             setVisibility(GONE);
@@ -143,7 +141,7 @@
     @Override
     public void handleSelection(int eventType) {
         SearchEventTracker.INSTANCE.get(getContext()).notifySearchTargetEvent(
-                new SearchTargetEvent.Builder(mSearchTarget, eventType).build());
+                new SearchTargetEventLegacy.Builder(mSearchTarget, eventType).build());
     }
 
     @Override
@@ -184,7 +182,7 @@
     @Override
     public boolean onLongClick(View view) {
         ItemLongClickListener.INSTANCE_ALL_APPS.onLongClick(view);
-        handleSelection(SearchTargetEvent.LONG_PRESS);
+        handleSelection(SearchTargetEventLegacy.LONG_PRESS);
         return false;
     }
 
diff --git a/src/com/android/launcher3/views/SearchResultWidgetPreview.java b/quickstep/src/com/android/launcher3/search/SearchResultWidgetPreview.java
similarity index 87%
rename from src/com/android/launcher3/views/SearchResultWidgetPreview.java
rename to quickstep/src/com/android/launcher3/search/SearchResultWidgetPreview.java
index c11c232..5effbe5 100644
--- a/src/com/android/launcher3/views/SearchResultWidgetPreview.java
+++ b/quickstep/src/com/android/launcher3/search/SearchResultWidgetPreview.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.android.launcher3.views;
+package com.android.launcher3.search;
 
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 import static com.android.launcher3.util.Executors.MODEL_EXECUTOR;
@@ -32,8 +32,6 @@
 import com.android.launcher3.LauncherAppState;
 import com.android.launcher3.LauncherAppWidgetProviderInfo;
 import com.android.launcher3.R;
-import com.android.launcher3.allapps.search.AllAppsSearchBarController;
-import com.android.launcher3.allapps.search.SearchEventTracker;
 import com.android.launcher3.dragndrop.DragOptions;
 import com.android.launcher3.model.WidgetItem;
 import com.android.launcher3.touch.ItemLongClickListener;
@@ -41,14 +39,14 @@
 import com.android.launcher3.widget.PendingItemDragHelper;
 import com.android.launcher3.widget.WidgetCell;
 import com.android.launcher3.widget.WidgetImageView;
-import com.android.systemui.plugins.shared.SearchTarget;
-import com.android.systemui.plugins.shared.SearchTargetEvent;
+import com.android.systemui.plugins.shared.SearchTargetEventLegacy;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
 
 /**
  * displays preview of a widget upon receiving {@link AppWidgetProviderInfo} from Search provider
  */
 public class SearchResultWidgetPreview extends LinearLayout implements
-        AllAppsSearchBarController.SearchTargetHandler, View.OnLongClickListener,
+        SearchTargetHandler, View.OnLongClickListener,
         View.OnClickListener {
 
     public static final String TARGET_TYPE_WIDGET_PREVIEW = "widget_preview";
@@ -57,7 +55,7 @@
     private WidgetCell mWidgetCell;
     private Toast mWidgetToast;
 
-    private SearchTarget mSearchTarget;
+    private SearchTargetLegacy mSearchTarget;
 
 
     public SearchResultWidgetPreview(Context context) {
@@ -85,7 +83,7 @@
     }
 
     @Override
-    public void applySearchTarget(SearchTarget searchTarget) {
+    public void applySearchTarget(SearchTargetLegacy searchTarget) {
         if (searchTarget.getExtras() == null
                 || searchTarget.getExtras().getParcelable("provider") == null) {
             setVisibility(GONE);
@@ -123,19 +121,19 @@
         new PendingItemDragHelper(mWidgetCell).startDrag(
                 imageView.getBitmapBounds(), imageView.getBitmap().getWidth(), imageView.getWidth(),
                 new Point(loc[0], loc[1]), mLauncher.getAppsView(), new DragOptions());
-        handleSelection(SearchTargetEvent.LONG_PRESS);
+        handleSelection(SearchTargetEventLegacy.LONG_PRESS);
         return true;
     }
 
     @Override
     public void onClick(View view) {
         mWidgetToast = BaseWidgetSheet.showWidgetToast(getContext(), mWidgetToast);
-        handleSelection(SearchTargetEvent.SELECT);
+        handleSelection(SearchTargetEventLegacy.SELECT);
     }
 
     @Override
     public void handleSelection(int eventType) {
         SearchEventTracker.INSTANCE.get(getContext()).notifySearchTargetEvent(
-                new SearchTargetEvent.Builder(mSearchTarget, eventType).build());
+                new SearchTargetEventLegacy.Builder(mSearchTarget, eventType).build());
     }
 }
diff --git a/src/com/android/launcher3/views/SearchSectionHeaderView.java b/quickstep/src/com/android/launcher3/search/SearchSectionHeaderView.java
similarity index 84%
rename from src/com/android/launcher3/views/SearchSectionHeaderView.java
rename to quickstep/src/com/android/launcher3/search/SearchSectionHeaderView.java
index 326c23d..eb40938 100644
--- a/src/com/android/launcher3/views/SearchSectionHeaderView.java
+++ b/quickstep/src/com/android/launcher3/search/SearchSectionHeaderView.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.android.launcher3.views;
+package com.android.launcher3.search;
 
 import android.content.Context;
 import android.util.AttributeSet;
@@ -21,14 +21,13 @@
 
 import androidx.annotation.Nullable;
 
-import com.android.launcher3.allapps.search.AllAppsSearchBarController;
-import com.android.systemui.plugins.shared.SearchTarget;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
 
 /**
  * Header text view that shows a title for a given section in All apps search
  */
 public class SearchSectionHeaderView extends TextView implements
-        AllAppsSearchBarController.SearchTargetHandler {
+        SearchTargetHandler {
     public static final String TARGET_TYPE_SECTION_HEADER = "section_header";
 
     public SearchSectionHeaderView(Context context) {
@@ -45,7 +44,7 @@
     }
 
     @Override
-    public void applySearchTarget(SearchTarget searchTarget) {
+    public void applySearchTarget(SearchTargetLegacy searchTarget) {
         String title = searchTarget.getExtras().getString("title");
         if (title == null || !title.isEmpty()) {
             setText(title);
diff --git a/src/com/android/launcher3/views/SearchSettingsRowView.java b/quickstep/src/com/android/launcher3/search/SearchSettingsRowView.java
similarity index 89%
rename from src/com/android/launcher3/views/SearchSettingsRowView.java
rename to quickstep/src/com/android/launcher3/search/SearchSettingsRowView.java
index 160ee65..8306e3b 100644
--- a/src/com/android/launcher3/views/SearchSettingsRowView.java
+++ b/quickstep/src/com/android/launcher3/search/SearchSettingsRowView.java
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.android.launcher3.views;
+package com.android.launcher3.search;
 
 import static com.android.launcher3.FastBitmapDrawable.newIcon;
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
@@ -37,11 +37,9 @@
 import com.android.launcher3.Launcher;
 import com.android.launcher3.LauncherAppState;
 import com.android.launcher3.R;
-import com.android.launcher3.allapps.search.AllAppsSearchBarController;
-import com.android.launcher3.allapps.search.SearchEventTracker;
 import com.android.launcher3.model.data.PackageItemInfo;
-import com.android.systemui.plugins.shared.SearchTarget;
-import com.android.systemui.plugins.shared.SearchTargetEvent;
+import com.android.systemui.plugins.shared.SearchTargetEventLegacy;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -50,7 +48,7 @@
  * A row of clickable TextViews with a breadcrumb for settings search.
  */
 public class SearchSettingsRowView extends LinearLayout implements
-        View.OnClickListener, AllAppsSearchBarController.SearchTargetHandler {
+        View.OnClickListener, SearchTargetHandler {
 
     public static final String TARGET_TYPE_SETTINGS_ROW = "settings_row";
 
@@ -58,7 +56,7 @@
     private TextView mTitleView;
     private TextView mBreadcrumbsView;
     private Intent mIntent;
-    private SearchTarget mSearchTarget;
+    private SearchTargetLegacy mSearchTarget;
 
 
     public SearchSettingsRowView(@NonNull Context context) {
@@ -86,7 +84,7 @@
     }
 
     @Override
-    public void applySearchTarget(SearchTarget searchTarget) {
+    public void applySearchTarget(SearchTargetLegacy searchTarget) {
         mSearchTarget = searchTarget;
         Bundle bundle = searchTarget.getExtras();
         mIntent = bundle.getParcelable("intent");
@@ -110,7 +108,7 @@
 
     @Override
     public void onClick(View view) {
-        handleSelection(SearchTargetEvent.SELECT);
+        handleSelection(SearchTargetEventLegacy.SELECT);
     }
 
     @Override
@@ -122,7 +120,7 @@
         launcher.startActivityForResult(mIntent, 0);
 
         SearchEventTracker.INSTANCE.get(getContext()).notifySearchTargetEvent(
-                new SearchTargetEvent.Builder(mSearchTarget, eventType).build());
+                new SearchTargetEventLegacy.Builder(mSearchTarget, eventType).build());
     }
 
     /**
diff --git a/quickstep/src/com/android/launcher3/search/SearchTargetHandler.java b/quickstep/src/com/android/launcher3/search/SearchTargetHandler.java
new file mode 100644
index 0000000..9ff057f
--- /dev/null
+++ b/quickstep/src/com/android/launcher3/search/SearchTargetHandler.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package com.android.launcher3.search;
+
+import android.app.search.SearchTarget;
+
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
+
+/**
+ * An interface for supporting dynamic search results
+ */
+public interface SearchTargetHandler {
+
+    /**
+     * Update view using values from {@link SearchTargetLegacy}
+     */
+    void applySearchTarget(SearchTargetLegacy searchTarget);
+
+    /**
+     * Update view using values from {@link SearchTargetLegacy}
+     */
+    default void applySearchTarget(SearchTarget searchTarget){
+
+    }
+
+    /**
+     * Handles selection of SearchTarget
+     */
+    default void handleSelection(int eventType) {
+    }
+
+}
diff --git a/src/com/android/launcher3/views/ThumbnailSearchResultView.java b/quickstep/src/com/android/launcher3/search/ThumbnailSearchResultView.java
similarity index 85%
rename from src/com/android/launcher3/views/ThumbnailSearchResultView.java
rename to quickstep/src/com/android/launcher3/search/ThumbnailSearchResultView.java
index 573d48f..44f7057 100644
--- a/src/com/android/launcher3/views/ThumbnailSearchResultView.java
+++ b/quickstep/src/com/android/launcher3/search/ThumbnailSearchResultView.java
@@ -13,11 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package com.android.launcher3.views;
+package com.android.launcher3.search;
 
 
-import static com.android.launcher3.views.SearchResultIcon.REMOTE_ACTION_SHOULD_START;
-import static com.android.launcher3.views.SearchResultIcon.REMOTE_ACTION_TOKEN;
+import static com.android.launcher3.search.SearchResultIcon.REMOTE_ACTION_SHOULD_START;
+import static com.android.launcher3.search.SearchResultIcon.REMOTE_ACTION_TOKEN;
 
 import android.content.Context;
 import android.content.Intent;
@@ -30,26 +30,24 @@
 import androidx.core.graphics.drawable.RoundedBitmapDrawableFactory;
 
 import com.android.launcher3.Launcher;
-import com.android.launcher3.allapps.search.AllAppsSearchBarController;
-import com.android.launcher3.allapps.search.SearchEventTracker;
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.model.data.RemoteActionItemInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.touch.ItemClickHandler;
 import com.android.launcher3.util.Themes;
-import com.android.systemui.plugins.shared.SearchTarget;
-import com.android.systemui.plugins.shared.SearchTargetEvent;
+import com.android.systemui.plugins.shared.SearchTargetEventLegacy;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
 
 /**
  * A view representing a high confidence app search result that includes shortcuts
  */
 public class ThumbnailSearchResultView extends androidx.appcompat.widget.AppCompatImageView
-        implements AllAppsSearchBarController.SearchTargetHandler {
+        implements SearchTargetHandler {
 
     public static final String TARGET_TYPE_SCREENSHOT = "screenshot";
     public static final String TARGET_TYPE_SCREENSHOT_LEGACY = "screenshot_legacy";
 
-    private SearchTarget mSearchTarget;
+    private SearchTargetLegacy mSearchTarget;
 
     public ThumbnailSearchResultView(Context context) {
         super(context);
@@ -74,11 +72,11 @@
             ItemClickHandler.onClickAppShortcut(this, (WorkspaceItemInfo) itemInfo, launcher);
         }
         SearchEventTracker.INSTANCE.get(getContext()).notifySearchTargetEvent(
-                new SearchTargetEvent.Builder(mSearchTarget, eventType).build());
+                new SearchTargetEventLegacy.Builder(mSearchTarget, eventType).build());
     }
 
     @Override
-    public void applySearchTarget(SearchTarget target) {
+    public void applySearchTarget(SearchTargetLegacy target) {
         mSearchTarget = target;
         Bitmap bitmap;
         if (target.getRemoteAction() != null) {
@@ -110,7 +108,7 @@
         RoundedBitmapDrawable drawable = RoundedBitmapDrawableFactory.create(null, bitmap);
         drawable.setCornerRadius(Themes.getDialogCornerRadius(getContext()));
         setImageDrawable(drawable);
-        setOnClickListener(v -> handleSelection(SearchTargetEvent.SELECT));
+        setOnClickListener(v -> handleSelection(SearchTargetEventLegacy.SELECT));
         SearchEventTracker.INSTANCE.get(getContext()).registerWeakHandler(target, this);
     }
 }
diff --git a/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java b/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java
index 8c3b57a..3be1ced 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java
@@ -42,6 +42,8 @@
 import com.android.launcher3.LauncherSettings.Favorites;
 import com.android.launcher3.LauncherState;
 import com.android.launcher3.Workspace;
+import com.android.launcher3.allapps.AllAppsContainerView;
+import com.android.launcher3.allapps.search.SearchAdapterProvider;
 import com.android.launcher3.anim.AnimatorPlaybackController;
 import com.android.launcher3.appprediction.PredictionRowView;
 import com.android.launcher3.config.FeatureFlags;
@@ -51,6 +53,7 @@
 import com.android.launcher3.model.BgDataModel.FixedContainerItems;
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.popup.SystemShortcut;
+import com.android.launcher3.search.DeviceSearchAdapterProvider;
 import com.android.launcher3.statemanager.StateManager.AtomicAnimationFactory;
 import com.android.launcher3.uioverrides.states.QuickstepAtomicAnimationFactory;
 import com.android.launcher3.uioverrides.touchcontrollers.NavBarToHomeTouchController;
@@ -264,6 +267,11 @@
     }
 
     @Override
+    public SearchAdapterProvider createSearchAdapterProvider(AllAppsContainerView appsView) {
+        return new DeviceSearchAdapterProvider(this, appsView);
+    }
+
+    @Override
     public TouchController[] createTouchControllers() {
         Mode mode = SysUINavigationMode.getMode(this);
 
diff --git a/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java b/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java
index f82bc2d..3d5b1c6 100644
--- a/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java
+++ b/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java
@@ -721,8 +721,11 @@
 
     @UiThread
     public void onGestureStarted(boolean isLikelyToStartNewTask) {
-        InteractionJankMonitorWrapper.begin(
-                InteractionJankMonitorWrapper.CUJ_QUICK_SWITCH, 2000 /* ms timeout */);
+        // Temporarily disable this until we have a view that we can use
+        // InteractionJankMonitorWrapper.begin(mRecentsView,
+        //         InteractionJankMonitorWrapper.CUJ_QUICK_SWITCH, 2000 /* ms timeout */);
+        // InteractionJankMonitorWrapper.begin(mRecentsView,
+        //         InteractionJankMonitorWrapper.CUJ_APP_CLOSE_TO_HOME);
         notifyGestureStartedAsync();
         setIsLikelyToStartNewTask(isLikelyToStartNewTask, false /* animate */);
         mStateCallback.setStateOnUiThread(STATE_GESTURE_STARTED);
@@ -802,6 +805,14 @@
         // Fast-finish the attaching animation if it's still running.
         maybeUpdateRecentsAttachedState(false);
         final GestureEndTarget endTarget = mGestureState.getEndTarget();
+        if (endTarget != NEW_TASK) {
+            InteractionJankMonitorWrapper.cancel(
+                    InteractionJankMonitorWrapper.CUJ_QUICK_SWITCH);
+        }
+        if (endTarget != HOME) {
+            InteractionJankMonitorWrapper.cancel(
+                    InteractionJankMonitorWrapper.CUJ_APP_CLOSE_TO_HOME);
+        }
         switch (endTarget) {
             case HOME:
                 mStateCallback.setState(STATE_SCALED_CONTROLLER_HOME | STATE_CAPTURE_SCREENSHOT);
@@ -820,9 +831,6 @@
                 break;
         }
         ActiveGestureLog.INSTANCE.addLog("onSettledOnEndTarget " + endTarget);
-        if (endTarget != NEW_TASK) {
-            InteractionJankMonitorWrapper.cancel(InteractionJankMonitorWrapper.CUJ_QUICK_SWITCH);
-        }
     }
 
     /** @return Whether this was the task we were waiting to appear, and thus handled it. */
@@ -1159,7 +1167,8 @@
                 TaskInfoCompat.getPipSourceRectHint(runningTaskTarget.pictureInPictureParams),
                 TaskInfoCompat.getWindowConfigurationBounds(taskInfo),
                 startBounds,
-                destinationBounds);
+                destinationBounds,
+                mRecentsView);
         // We would assume home and app window always in the same rotation While homeRotation
         // is not ROTATION_0 (which implies the rotation is turned on in launcher settings).
         if (homeRotation == ROTATION_0
@@ -1219,11 +1228,9 @@
         anim.addOnUpdateListener((r, p) -> {
             updateSysUiFlags(Math.max(p, mCurrentShift.value));
         });
-        final int cuj = InteractionJankMonitorWrapper.CUJ_APP_CLOSE_TO_HOME;
         anim.addAnimatorListener(new AnimationSuccessListener() {
             @Override
             public void onAnimationStart(Animator animation) {
-                InteractionJankMonitorWrapper.begin(cuj);
                 if (mActivity != null) {
                     removeLiveTileOverlay();
                 }
@@ -1237,13 +1244,6 @@
                 // Make sure recents is in its final state
                 maybeUpdateRecentsAttachedState(false);
                 mActivityInterface.onSwipeUpToHomeComplete(mDeviceState);
-                InteractionJankMonitorWrapper.end(cuj);
-            }
-
-            @Override
-            public void onAnimationCancel(Animator animation) {
-                super.onAnimationCancel(animation);
-                InteractionJankMonitorWrapper.cancel(cuj);
             }
         });
         if (mRecentsAnimationTargets != null) {
diff --git a/quickstep/src/com/android/quickstep/OrientationTouchTransformer.java b/quickstep/src/com/android/quickstep/OrientationTouchTransformer.java
index eb33f98..b258a10 100644
--- a/quickstep/src/com/android/quickstep/OrientationTouchTransformer.java
+++ b/quickstep/src/com/android/quickstep/OrientationTouchTransformer.java
@@ -66,6 +66,7 @@
     private final RectF mOneHandedModeRegion = new RectF();
     private int mCurrentDisplayRotation;
     private int mNavBarGesturalHeight;
+    private int mNavBarLargerGesturalHeight;
     private boolean mEnableMultipleRegions;
     private Resources mResources;
     private OrientationRectF mLastRectTouched;
@@ -106,6 +107,9 @@
         mMode = mode;
         mContractInfo = contractInfo;
         mNavBarGesturalHeight = getNavbarSize(ResourceUtils.NAVBAR_BOTTOM_GESTURE_SIZE);
+        mNavBarLargerGesturalHeight = ResourceUtils.getDimenByName(
+                ResourceUtils.NAVBAR_BOTTOM_GESTURE_LARGER_SIZE, resources,
+                mNavBarGesturalHeight);
     }
 
     private void refreshTouchRegion(Info info, Resources newRes) {
@@ -234,6 +238,7 @@
         Point size = display.realSize;
         int rotation = display.rotation;
         int touchHeight = mNavBarGesturalHeight;
+        int largerGesturalHeight = mNavBarLargerGesturalHeight;
         OrientationRectF orientationRectF =
                 new OrientationRectF(0, 0, size.x, size.y, rotation);
         if (mMode == SysUINavigationMode.Mode.NO_BUTTON) {
@@ -256,7 +261,8 @@
             }
         }
         // One handed gestural only active on portrait mode
-        mOneHandedModeRegion.set(0, orientationRectF.bottom - touchHeight, size.x, size.y);
+        mOneHandedModeRegion.set(0, orientationRectF.bottom - mNavBarLargerGesturalHeight,
+                size.x, size.y);
 
         return orientationRectF;
     }
@@ -378,6 +384,7 @@
         }
         pw.println(regions.toString());
         pw.println("  mNavBarGesturalHeight=" + mNavBarGesturalHeight);
+        pw.println("  mNavBarLargerGesturalHeight=" + mNavBarLargerGesturalHeight);
         pw.println("  mOneHandedModeRegion=" + mOneHandedModeRegion);
     }
 
diff --git a/quickstep/src/com/android/quickstep/OverviewCommandHelper.java b/quickstep/src/com/android/quickstep/OverviewCommandHelper.java
index fd9c315..ec6e303 100644
--- a/quickstep/src/com/android/quickstep/OverviewCommandHelper.java
+++ b/quickstep/src/com/android/quickstep/OverviewCommandHelper.java
@@ -175,7 +175,9 @@
                 return;
             }
 
-            InteractionJankMonitorWrapper.begin(InteractionJankMonitorWrapper.CUJ_QUICK_SWITCH);
+            InteractionJankMonitorWrapper.begin(
+                    mActivityInterface.getCreatedActivity().getRootView(),
+                    InteractionJankMonitorWrapper.CUJ_QUICK_SWITCH);
 
             // Otherwise, start overview.
             mListener = mActivityInterface.createActivityInitListener(this::onActivityReady);
diff --git a/quickstep/src/com/android/quickstep/OverviewComponentObserver.java b/quickstep/src/com/android/quickstep/OverviewComponentObserver.java
index 49feef0..7bf7712 100644
--- a/quickstep/src/com/android/quickstep/OverviewComponentObserver.java
+++ b/quickstep/src/com/android/quickstep/OverviewComponentObserver.java
@@ -23,7 +23,6 @@
 import static com.android.launcher3.config.FeatureFlags.SEPARATE_RECENTS_ACTIVITY;
 import static com.android.launcher3.util.PackageManagerHelper.getPackageFilter;
 import static com.android.systemui.shared.system.PackageManagerWrapper.ACTION_PREFERRED_ACTIVITY_CHANGED;
-import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_ASSIST_GESTURE_CONSTRAINED;
 
 import android.content.BroadcastReceiver;
 import android.content.ComponentName;
@@ -119,10 +118,6 @@
         updateOverviewTargets();
     }
 
-    public boolean assistantGestureIsConstrained() {
-        return (mDeviceState.getSystemUiStateFlags() & SYSUI_STATE_ASSIST_GESTURE_CONSTRAINED) != 0;
-    }
-
     /**
      * Update overview intent and {@link BaseActivityInterface} based off the current launcher home
      * component.
diff --git a/quickstep/src/com/android/quickstep/RecentsActivity.java b/quickstep/src/com/android/quickstep/RecentsActivity.java
index d050030..c37fd84 100644
--- a/quickstep/src/com/android/quickstep/RecentsActivity.java
+++ b/quickstep/src/com/android/quickstep/RecentsActivity.java
@@ -45,6 +45,7 @@
 import com.android.launcher3.R;
 import com.android.launcher3.WrappedAnimationRunnerImpl;
 import com.android.launcher3.WrappedLauncherAnimationRunner;
+import com.android.launcher3.allapps.search.SearchAdapterProvider;
 import com.android.launcher3.anim.Interpolators;
 import com.android.launcher3.anim.PendingAnimation;
 import com.android.launcher3.compat.AccessibilityManagerCompat;
@@ -91,6 +92,7 @@
 
     // Strong refs to runners which are cleared when the activity is destroyed
     private WrappedAnimationRunnerImpl mActivityLaunchAnimationRunner;
+    private SearchAdapterProvider mSearchAdapterProvider;
 
     /**
      * Init drag layer and overview panel views.
diff --git a/quickstep/src/com/android/quickstep/RecentsAnimationController.java b/quickstep/src/com/android/quickstep/RecentsAnimationController.java
index bc5e18d..646c5a0 100644
--- a/quickstep/src/com/android/quickstep/RecentsAnimationController.java
+++ b/quickstep/src/com/android/quickstep/RecentsAnimationController.java
@@ -136,6 +136,7 @@
         UI_HELPER_EXECUTOR.execute(() -> {
             mController.finish(toRecents, sendUserLeaveHint);
             InteractionJankMonitorWrapper.end(InteractionJankMonitorWrapper.CUJ_QUICK_SWITCH);
+            InteractionJankMonitorWrapper.end(InteractionJankMonitorWrapper.CUJ_APP_CLOSE_TO_HOME);
             if (callback != null) {
                 MAIN_EXECUTOR.execute(callback);
             }
diff --git a/quickstep/src/com/android/quickstep/RecentsAnimationDeviceState.java b/quickstep/src/com/android/quickstep/RecentsAnimationDeviceState.java
index 960abeb..74b56e9 100644
--- a/quickstep/src/com/android/quickstep/RecentsAnimationDeviceState.java
+++ b/quickstep/src/com/android/quickstep/RecentsAnimationDeviceState.java
@@ -23,6 +23,7 @@
 import static com.android.quickstep.SysUINavigationMode.Mode.THREE_BUTTONS;
 import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_A11Y_BUTTON_CLICKABLE;
 import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_A11Y_BUTTON_LONG_CLICKABLE;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_ASSIST_GESTURE_CONSTRAINED;
 import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_BUBBLES_EXPANDED;
 import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_GLOBAL_ACTIONS_SHOWING;
 import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_HOME_DISABLED;
@@ -373,7 +374,7 @@
      * @return the system ui state flags.
      */
     // TODO(141886704): See if we can remove this
-    public @SystemUiStateFlags int getSystemUiStateFlags() {
+    public int getSystemUiStateFlags() {
         return mSystemUiStateFlags;
     }
 
@@ -406,6 +407,13 @@
     }
 
     /**
+     * @return whether assistant gesture is constraint
+     */
+    public boolean isAssistantGestureIsConstrained() {
+        return (mSystemUiStateFlags & SYSUI_STATE_ASSIST_GESTURE_CONSTRAINED) != 0;
+    }
+
+    /**
      * @return whether the bubble stack is expanded
      */
     public boolean isBubblesExpanded() {
diff --git a/quickstep/src/com/android/quickstep/SysUINavigationMode.java b/quickstep/src/com/android/quickstep/SysUINavigationMode.java
index 71bf1bb..efec037 100644
--- a/quickstep/src/com/android/quickstep/SysUINavigationMode.java
+++ b/quickstep/src/com/android/quickstep/SysUINavigationMode.java
@@ -73,6 +73,7 @@
     private Mode mMode;
 
     private int mNavBarGesturalHeight;
+    private int mNavBarLargerGesturalHeight;
 
     private final List<NavigationModeChangeListener> mChangeListeners = new ArrayList<>();
     private final List<OneHandedModeChangeListener> mOneHandedOverlayChangeListeners =
@@ -112,6 +113,17 @@
 
         if (mNavBarGesturalHeight != newGesturalHeight) {
             mNavBarGesturalHeight = newGesturalHeight;
+        }
+
+        int newLargerGesturalHeight = ResourceUtils.getDimenByName(
+                ResourceUtils.NAVBAR_BOTTOM_GESTURE_LARGER_SIZE, mContext.getResources(),
+                INVALID_RESOURCE_HANDLE);
+        if (newLargerGesturalHeight == INVALID_RESOURCE_HANDLE) {
+            Log.e(TAG, "Failed to get system resource ID. Incompatible framework version?");
+            return;
+        }
+        if (mNavBarLargerGesturalHeight != newLargerGesturalHeight) {
+            mNavBarLargerGesturalHeight = newLargerGesturalHeight;
             dispatchOneHandedOverlayChange();
         }
     }
@@ -122,6 +134,9 @@
         mNavBarGesturalHeight = ResourceUtils.getDimenByName(
                 ResourceUtils.NAVBAR_BOTTOM_GESTURE_SIZE, mContext.getResources(),
                 INVALID_RESOURCE_HANDLE);
+        mNavBarLargerGesturalHeight = ResourceUtils.getDimenByName(
+                ResourceUtils.NAVBAR_BOTTOM_GESTURE_LARGER_SIZE, mContext.getResources(),
+                mNavBarGesturalHeight);
 
         if (modeInt == INVALID_RESOURCE_HANDLE) {
             Log.e(TAG, "Failed to get system resource ID. Incompatible framework version?");
@@ -143,7 +158,7 @@
 
     private void dispatchOneHandedOverlayChange() {
         for (OneHandedModeChangeListener listener : mOneHandedOverlayChangeListeners) {
-            listener.onOneHandedModeChanged(mNavBarGesturalHeight);
+            listener.onOneHandedModeChanged(mNavBarLargerGesturalHeight);
         }
     }
 
@@ -158,7 +173,7 @@
 
     public int addOneHandedOverlayChangeListener(OneHandedModeChangeListener listener) {
         mOneHandedOverlayChangeListeners.add(listener);
-        return mNavBarGesturalHeight;
+        return mNavBarLargerGesturalHeight;
     }
 
     public void removeOneHandedOverlayChangeListener(OneHandedModeChangeListener listener) {
@@ -182,4 +197,4 @@
     public interface OneHandedModeChangeListener {
         void onOneHandedModeChanged(int newGesturalHeight);
     }
-}
\ No newline at end of file
+}
diff --git a/quickstep/src/com/android/quickstep/TouchInteractionService.java b/quickstep/src/com/android/quickstep/TouchInteractionService.java
index 1e0a00a..e59035c 100644
--- a/quickstep/src/com/android/quickstep/TouchInteractionService.java
+++ b/quickstep/src/com/android/quickstep/TouchInteractionService.java
@@ -466,7 +466,8 @@
                             this,
                             mGestureState,
                             InputConsumer.NO_OP, mInputMonitorCompat,
-                            mOverviewComponentObserver.assistantGestureIsConstrained());
+                            mDeviceState,
+                            event);
                 } else if (mDeviceState.canTriggerOneHandedAction(event)
                     && !mDeviceState.isOneHandedModeActive()) {
                     // Consume gesture event for triggering one handed feature.
@@ -563,12 +564,8 @@
         }
         if (mDeviceState.isFullyGesturalNavMode()) {
             if (mDeviceState.canTriggerAssistantAction(event, newGestureState.getRunningTask())) {
-                base = new AssistantInputConsumer(
-                    this,
-                    newGestureState,
-                    base,
-                    mInputMonitorCompat,
-                    mOverviewComponentObserver.assistantGestureIsConstrained());
+                base = new AssistantInputConsumer(this, newGestureState, base, mInputMonitorCompat,
+                        mDeviceState, event);
             }
 
             if (FeatureFlags.ENABLE_QUICK_CAPTURE_GESTURE.get()) {
diff --git a/quickstep/src/com/android/quickstep/inputconsumers/AssistantInputConsumer.java b/quickstep/src/com/android/quickstep/inputconsumers/AssistantInputConsumer.java
index 580e4ec..a3cd7df 100644
--- a/quickstep/src/com/android/quickstep/inputconsumers/AssistantInputConsumer.java
+++ b/quickstep/src/com/android/quickstep/inputconsumers/AssistantInputConsumer.java
@@ -44,9 +44,12 @@
 import com.android.quickstep.BaseActivityInterface;
 import com.android.quickstep.GestureState;
 import com.android.quickstep.InputConsumer;
+import com.android.quickstep.RecentsAnimationDeviceState;
 import com.android.quickstep.SystemUiProxy;
 import com.android.systemui.shared.system.InputMonitorCompat;
 
+import java.util.function.Consumer;
+
 /**
  * Touch consumer for handling events to launch assistant from launcher
  */
@@ -81,19 +84,18 @@
     private final int mAngleThreshold;
     private final float mSquaredSlop;
     private final Context mContext;
-    private final GestureDetector mGestureDetector;
-    private final boolean mIsAssistGestureConstrained;
+    private final Consumer<MotionEvent> mGestureDetector;
 
     public AssistantInputConsumer(
             Context context,
             GestureState gestureState,
             InputConsumer delegate,
             InputMonitorCompat inputMonitor,
-            boolean isAssistGestureConstrained) {
+            RecentsAnimationDeviceState deviceState,
+            MotionEvent startEvent) {
         super(delegate, inputMonitor);
         final Resources res = context.getResources();
         mContext = context;
-        mIsAssistGestureConstrained = isAssistGestureConstrained;
         mDragDistThreshold = res.getDimension(R.dimen.gestures_assistant_drag_threshold);
         mFlingDistThreshold = res.getDimension(R.dimen.gestures_assistant_fling_threshold);
         mTimeThreshold = res.getInteger(R.integer.assistant_gesture_min_time_threshold);
@@ -104,7 +106,11 @@
         mSquaredSlop = slop * slop;
         mActivityInterface = gestureState.getActivityInterface();
 
-        mGestureDetector = new GestureDetector(context, new AssistantGestureListener());
+        boolean flingDisabled = deviceState.isAssistantGestureIsConstrained()
+                || deviceState.isInDeferredGestureRegion(startEvent);
+        mGestureDetector = flingDisabled
+                ? ev -> { }
+                : new GestureDetector(context, new AssistantGestureListener())::onTouchEvent;
     }
 
     @Override
@@ -201,7 +207,7 @@
                 break;
         }
 
-        mGestureDetector.onTouchEvent(ev);
+        mGestureDetector.accept(ev);
 
         if (mState != STATE_ACTIVE) {
             mDelegate.onMotionEvent(ev);
@@ -214,12 +220,6 @@
             if (mDistance >= mDragDistThreshold && mTimeFraction >= 1) {
                 SystemUiProxy.INSTANCE.get(mContext).onAssistantGestureCompletion(0);
                 startAssistantInternal();
-
-                Bundle args = new Bundle();
-                args.putInt(OPA_BUNDLE_TRIGGER, OPA_BUNDLE_TRIGGER_DIAG_SWIPE_GESTURE);
-                args.putInt(INVOCATION_TYPE_KEY, INVOCATION_TYPE_GESTURE);
-                SystemUiProxy.INSTANCE.get(mContext).startAssistant(args);
-                mLaunchedAssistant = true;
             } else {
                 SystemUiProxy.INSTANCE.get(mContext).onAssistantProgress(mLastProgress);
             }
@@ -233,6 +233,12 @@
                 13, // HapticFeedbackConstants.GESTURE_END
                 HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
         }
+
+        Bundle args = new Bundle();
+        args.putInt(OPA_BUNDLE_TRIGGER, OPA_BUNDLE_TRIGGER_DIAG_SWIPE_GESTURE);
+        args.putInt(INVOCATION_TYPE_KEY, INVOCATION_TYPE_GESTURE);
+        SystemUiProxy.INSTANCE.get(mContext).startAssistant(args);
+        mLaunchedAssistant = true;
     }
 
     /**
@@ -250,8 +256,7 @@
     private class AssistantGestureListener extends SimpleOnGestureListener {
         @Override
         public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
-            if (!mIsAssistGestureConstrained
-                && isValidAssistantGestureAngle(velocityX, -velocityY)
+            if (isValidAssistantGestureAngle(velocityX, -velocityY)
                     && mDistance >= mFlingDistThreshold
                     && !mLaunchedAssistant
                     && mState != STATE_DELEGATE_ACTIVE) {
@@ -259,11 +264,6 @@
                 SystemUiProxy.INSTANCE.get(mContext).onAssistantGestureCompletion(
                     (float) Math.sqrt(velocityX * velocityX + velocityY * velocityY));
                 startAssistantInternal();
-
-                Bundle args = new Bundle();
-                args.putInt(INVOCATION_TYPE_KEY, INVOCATION_TYPE_GESTURE);
-                SystemUiProxy.INSTANCE.get(mContext).startAssistant(args);
-                mLaunchedAssistant = true;
             }
             return true;
         }
diff --git a/quickstep/src/com/android/quickstep/util/SwipePipToHomeAnimator.java b/quickstep/src/com/android/quickstep/util/SwipePipToHomeAnimator.java
index 8fbd645..378f25b 100644
--- a/quickstep/src/com/android/quickstep/util/SwipePipToHomeAnimator.java
+++ b/quickstep/src/com/android/quickstep/util/SwipePipToHomeAnimator.java
@@ -28,6 +28,7 @@
 import android.util.Log;
 import android.view.Surface;
 import android.view.SurfaceControl;
+import android.view.View;
 
 import androidx.annotation.NonNull;
 
@@ -91,7 +92,8 @@
             @NonNull Rect sourceRectHint,
             @NonNull Rect appBounds,
             @NonNull Rect startBounds,
-            @NonNull Rect destinationBounds) {
+            @NonNull Rect destinationBounds,
+            @NonNull View view) {
         mTaskId = taskId;
         mComponentName = componentName;
         mLeash = leash;
@@ -110,7 +112,7 @@
         addListener(new AnimationSuccessListener() {
             @Override
             public void onAnimationStart(Animator animation) {
-                InteractionJankMonitorWrapper.begin(CUJ_APP_CLOSE_TO_PIP);
+                InteractionJankMonitorWrapper.begin(view, CUJ_APP_CLOSE_TO_PIP);
                 super.onAnimationStart(animation);
             }
 
diff --git a/robolectric_tests/src/com/android/launcher3/model/PackageInstallStateChangedTaskTest.java b/robolectric_tests/src/com/android/launcher3/model/PackageInstallStateChangedTaskTest.java
index e43df21..412ace0 100644
--- a/robolectric_tests/src/com/android/launcher3/model/PackageInstallStateChangedTaskTest.java
+++ b/robolectric_tests/src/com/android/launcher3/model/PackageInstallStateChangedTaskTest.java
@@ -67,7 +67,7 @@
         for (ItemInfo info : mModelHelper.getBgDataModel().itemsIdMap) {
             if (info instanceof WorkspaceItemInfo) {
                 assertEquals(updates.contains(info.id) ? progress: 0,
-                        ((WorkspaceItemInfo) info).getInstallProgress());
+                        ((WorkspaceItemInfo) info).getProgressLevel());
             } else {
                 assertEquals(updates.contains(info.id) ? progress: -1,
                         ((LauncherAppWidgetInfo) info).installProgress);
diff --git a/src/com/android/launcher3/BaseDraggingActivity.java b/src/com/android/launcher3/BaseDraggingActivity.java
index 52f0a4a..5bfde15 100644
--- a/src/com/android/launcher3/BaseDraggingActivity.java
+++ b/src/com/android/launcher3/BaseDraggingActivity.java
@@ -43,6 +43,9 @@
 import androidx.annotation.Nullable;
 
 import com.android.launcher3.LauncherSettings.Favorites;
+import com.android.launcher3.allapps.AllAppsContainerView;
+import com.android.launcher3.allapps.search.DefaultSearchAdapterProvider;
+import com.android.launcher3.allapps.search.SearchAdapterProvider;
 import com.android.launcher3.logging.InstanceId;
 import com.android.launcher3.logging.InstanceIdSequence;
 import com.android.launcher3.model.data.ItemInfo;
@@ -187,7 +190,7 @@
                 logAppLaunch(item, instanceId);
             }
             return true;
-        } catch (NullPointerException|ActivityNotFoundException|SecurityException e) {
+        } catch (NullPointerException | ActivityNotFoundException | SecurityException e) {
             Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
             Log.e(TAG, "Unable to launch. tag=" + item + " intent=" + intent, e);
         }
@@ -290,4 +293,12 @@
         display.getSize(mwSize);
         return new WindowBounds(new Rect(0, 0, mwSize.x, mwSize.y), new Rect());
     }
+
+    /**
+     * Creates and returns {@link SearchAdapterProvider} for build variant specific search result
+     * views
+     */
+    public SearchAdapterProvider createSearchAdapterProvider(AllAppsContainerView allapps) {
+        return new DefaultSearchAdapterProvider(this);
+    }
 }
diff --git a/src/com/android/launcher3/BubbleTextView.java b/src/com/android/launcher3/BubbleTextView.java
index 3eb52ad..f44f88b 100644
--- a/src/com/android/launcher3/BubbleTextView.java
+++ b/src/com/android/launcher3/BubbleTextView.java
@@ -50,6 +50,7 @@
 import android.view.ViewDebug;
 import android.widget.TextView;
 
+import androidx.annotation.Nullable;
 import androidx.core.graphics.ColorUtils;
 
 import com.android.launcher3.Launcher.OnResumeCallback;
@@ -71,7 +72,6 @@
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.model.data.ItemInfoWithIcon;
 import com.android.launcher3.model.data.PackageItemInfo;
-import com.android.launcher3.model.data.PromiseAppInfo;
 import com.android.launcher3.model.data.RemoteActionItemInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.util.SafeCloseable;
@@ -287,10 +287,7 @@
     public void applyFromWorkspaceItem(WorkspaceItemInfo info, boolean promiseStateChanged) {
         applyIconAndLabel(info);
         setTag(info);
-        if (promiseStateChanged || (info.hasPromiseIconUi())) {
-            applyPromiseState(promiseStateChanged);
-        }
-
+        applyLoadingState(promiseStateChanged);
         applyDotState(info, false /* animate */);
     }
 
@@ -303,9 +300,8 @@
         // Verify high res immediately
         verifyHighRes();
 
-        if (info instanceof PromiseAppInfo) {
-            PromiseAppInfo promiseAppInfo = (PromiseAppInfo) info;
-            applyProgressLevel(promiseAppInfo.level);
+        if ((info.runtimeStatusFlags & ItemInfoWithIcon.FLAG_SHOW_DOWNLOAD_PROGRESS_MASK) != 0) {
+            applyProgressLevel(info.getProgressLevel());
         }
         applyDotState(info, false /* animate */);
     }
@@ -335,6 +331,10 @@
         mDotParams.color = IconPalette.getMutedColor(info.bitmap.color, 0.54f);
 
         setIcon(iconDrawable);
+        applyLabel(info);
+    }
+
+    private void applyLabel(ItemInfoWithIcon info) {
         setText(info.title);
         if (info.contentDescription != null) {
             setContentDescription(info.isDisabled()
@@ -595,21 +595,35 @@
         mLongPressHelper.cancelLongPress();
     }
 
-    public void applyPromiseState(boolean promiseStateChanged) {
+    /** Applies the loading progress value to the progress bar.
+     *
+     * If this app is installing, the progress bar will be updated with the installation progress.
+     * If this app is installed and downloading incrementally, the progress bar will be updated
+     * with the total download progress.
+     */
+    public void applyLoadingState(boolean promiseStateChanged) {
         if (getTag() instanceof WorkspaceItemInfo) {
             WorkspaceItemInfo info = (WorkspaceItemInfo) getTag();
-            final boolean isPromise = info.hasPromiseIconUi();
-            final int progressLevel = isPromise ?
-                    ((info.hasStatusFlag(WorkspaceItemInfo.FLAG_INSTALL_SESSION_ACTIVE) ?
-                            info.getInstallProgress() : 0)) : 100;
-
-            PreloadIconDrawable preloadDrawable = applyProgressLevel(progressLevel);
-            if (preloadDrawable != null && promiseStateChanged) {
-                preloadDrawable.maybePerformFinishedAnimation();
+            int progressLevel = info.getProgressLevel();
+            if ((info.runtimeStatusFlags & ItemInfoWithIcon.FLAG_INCREMENTAL_DOWNLOAD_ACTIVE)
+                    != 0) {
+                updateProgressBarUi(progressLevel, progressLevel == 100);
+            } else if (info.hasPromiseIconUi() || (info.runtimeStatusFlags
+                        & ItemInfoWithIcon.FLAG_INSTALL_SESSION_ACTIVE) != 0) {
+                updateProgressBarUi(progressLevel, promiseStateChanged);
             }
         }
     }
 
+    private void updateProgressBarUi(int progressLevel, boolean maybePerformFinishedAnimation) {
+        PreloadIconDrawable preloadDrawable = applyProgressLevel(progressLevel);
+        if (preloadDrawable != null && maybePerformFinishedAnimation) {
+            preloadDrawable.maybePerformFinishedAnimation();
+        }
+    }
+
+    /** Applies the given progress level to the this icon's progress bar. */
+    @Nullable
     public PreloadIconDrawable applyProgressLevel(int progressLevel) {
         if (getTag() instanceof ItemInfoWithIcon) {
             ItemInfoWithIcon info = (ItemInfoWithIcon) getTag();
@@ -629,9 +643,11 @@
                 if (mIcon instanceof PreloadIconDrawable) {
                     preloadDrawable = (PreloadIconDrawable) mIcon;
                     preloadDrawable.setLevel(progressLevel);
+                    preloadDrawable.setIsDisabled(!info.isAppStartable());
                 } else {
                     preloadDrawable = newPendingIcon(getContext(), info);
                     preloadDrawable.setLevel(progressLevel);
+                    preloadDrawable.setIsDisabled(!info.isAppStartable());
                     setIcon(preloadDrawable);
                 }
                 return preloadDrawable;
diff --git a/src/com/android/launcher3/Launcher.java b/src/com/android/launcher3/Launcher.java
index a96fabd..5b55c4b 100644
--- a/src/com/android/launcher3/Launcher.java
+++ b/src/com/android/launcher3/Launcher.java
@@ -137,7 +137,6 @@
 import com.android.launcher3.model.data.FolderInfo;
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.model.data.LauncherAppWidgetInfo;
-import com.android.launcher3.model.data.PromiseAppInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.notification.NotificationListener;
 import com.android.launcher3.pm.PinRequestHelper;
@@ -2516,8 +2515,8 @@
     }
 
     @Override
-    public void bindPromiseAppProgressUpdated(PromiseAppInfo app) {
-        mAppsView.getAppsStore().updatePromiseAppProgress(app);
+    public void bindIncrementalDownloadProgressUpdated(AppInfo app) {
+        mAppsView.getAppsStore().updateProgressBar(app);
     }
 
     @Override
diff --git a/src/com/android/launcher3/LauncherModel.java b/src/com/android/launcher3/LauncherModel.java
index 8458152..e89b9b0 100644
--- a/src/com/android/launcher3/LauncherModel.java
+++ b/src/com/android/launcher3/LauncherModel.java
@@ -48,6 +48,7 @@
 import com.android.launcher3.model.LoaderTask;
 import com.android.launcher3.model.ModelDelegate;
 import com.android.launcher3.model.ModelWriter;
+import com.android.launcher3.model.PackageIncrementalDownloadUpdatedTask;
 import com.android.launcher3.model.PackageInstallStateChangedTask;
 import com.android.launcher3.model.PackageUpdatedTask;
 import com.android.launcher3.model.ShortcutsChangedTask;
@@ -196,6 +197,15 @@
     }
 
     @Override
+    public void onPackageLoadingProgressChanged(
+                String packageName, UserHandle user, float progress) {
+        if (Utilities.ATLEAST_S) {
+            enqueueModelUpdateTask(new PackageIncrementalDownloadUpdatedTask(
+                    packageName, user, progress));
+        }
+    }
+
+    @Override
     public void onShortcutsChanged(String packageName, List<ShortcutInfo> shortcuts,
             UserHandle user) {
         enqueueModelUpdateTask(new ShortcutsChangedTask(packageName, shortcuts, user, true));
diff --git a/src/com/android/launcher3/ResourceUtils.java b/src/com/android/launcher3/ResourceUtils.java
index c9fb75a..f60e1f8 100644
--- a/src/com/android/launcher3/ResourceUtils.java
+++ b/src/com/android/launcher3/ResourceUtils.java
@@ -25,6 +25,8 @@
     public static final int INVALID_RESOURCE_HANDLE = -1;
     public static final String NAVBAR_LANDSCAPE_LEFT_RIGHT_SIZE = "navigation_bar_width";
     public static final String NAVBAR_BOTTOM_GESTURE_SIZE = "navigation_bar_gesture_height";
+    public static final String NAVBAR_BOTTOM_GESTURE_LARGER_SIZE =
+            "navigation_bar_gesture_larger_height";
 
     public static int getNavbarSize(String resName, Resources res) {
         return getDimenByName(resName, res, DEFAULT_NAVBAR_VALUE);
diff --git a/src/com/android/launcher3/Utilities.java b/src/com/android/launcher3/Utilities.java
index 5c2f35b..df5d234 100644
--- a/src/com/android/launcher3/Utilities.java
+++ b/src/com/android/launcher3/Utilities.java
@@ -107,12 +107,13 @@
     public static final String[] EMPTY_STRING_ARRAY = new String[0];
     public static final Person[] EMPTY_PERSON_ARRAY = new Person[0];
 
-    public static final boolean ATLEAST_R = BuildCompat.isAtLeastR();
+    public static final boolean ATLEAST_P = Build.VERSION.SDK_INT >= Build.VERSION_CODES.P;
 
     public static final boolean ATLEAST_Q = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q;
 
-    public static final boolean ATLEAST_P =
-            Build.VERSION.SDK_INT >= Build.VERSION_CODES.P;
+    public static final boolean ATLEAST_R = Build.VERSION.SDK_INT >= Build.VERSION_CODES.R;
+
+    public static final boolean ATLEAST_S = BuildCompat.isAtLeastS();
 
     /**
      * Set on a motion event dispatched from the nav bar. See {@link MotionEvent#setEdgeFlags(int)}.
diff --git a/src/com/android/launcher3/Workspace.java b/src/com/android/launcher3/Workspace.java
index 777ea3c..65eba20 100644
--- a/src/com/android/launcher3/Workspace.java
+++ b/src/com/android/launcher3/Workspace.java
@@ -3154,7 +3154,7 @@
         ItemOperator op = (info, v) -> {
             if (info instanceof WorkspaceItemInfo && v instanceof BubbleTextView
                     && updates.contains(info)) {
-                ((BubbleTextView) v).applyPromiseState(false /* promiseStateChanged */);
+                ((BubbleTextView) v).applyLoadingState(false /* promiseStateChanged */);
             } else if (v instanceof PendingAppWidgetHostView
                     && info instanceof LauncherAppWidgetInfo
                     && updates.contains(info)) {
diff --git a/src/com/android/launcher3/allapps/AllAppsContainerView.java b/src/com/android/launcher3/allapps/AllAppsContainerView.java
index 558c6a8..4d51d70 100644
--- a/src/com/android/launcher3/allapps/AllAppsContainerView.java
+++ b/src/com/android/launcher3/allapps/AllAppsContainerView.java
@@ -16,7 +16,6 @@
 package com.android.launcher3.allapps;
 
 import static com.android.launcher3.allapps.AllAppsGridAdapter.AdapterItem;
-import static com.android.launcher3.allapps.AllAppsGridAdapter.SearchAdapterItem;
 import static com.android.launcher3.model.BgDataModel.Callbacks.FLAG_HAS_SHORTCUT_PERMISSION;
 import static com.android.launcher3.model.BgDataModel.Callbacks.FLAG_QUIET_MODE_CHANGE_PERMISSION;
 import static com.android.launcher3.model.BgDataModel.Callbacks.FLAG_QUIET_MODE_ENABLED;
@@ -57,7 +56,7 @@
 import com.android.launcher3.InsettableFrameLayout;
 import com.android.launcher3.R;
 import com.android.launcher3.Utilities;
-import com.android.launcher3.allapps.search.SearchEventTracker;
+import com.android.launcher3.allapps.search.SearchAdapterProvider;
 import com.android.launcher3.config.FeatureFlags;
 import com.android.launcher3.keyboard.FocusedItemDecorator;
 import com.android.launcher3.model.data.AppInfo;
@@ -68,7 +67,6 @@
 import com.android.launcher3.util.Themes;
 import com.android.launcher3.views.RecyclerViewFastScroller;
 import com.android.launcher3.views.SpringRelativeLayout;
-import com.android.systemui.plugins.shared.SearchTarget;
 
 /**
  * The all apps view container.
@@ -110,6 +108,8 @@
 
     private Rect mInsets = new Rect();
 
+    SearchAdapterProvider mSearchAdapterProvider;
+
     public AllAppsContainerView(Context context) {
         this(context, null);
     }
@@ -124,6 +124,7 @@
         mLauncher = BaseDraggingActivity.fromContext(context);
         mLauncher.addOnDeviceProfileChangeListener(this);
 
+        mSearchAdapterProvider = mLauncher.createSearchAdapterProvider(this);
         mSearchQueryBuilder = new SpannableStringBuilder();
         Selection.setSelection(mSearchQueryBuilder, 0);
 
@@ -141,6 +142,7 @@
         addSpringView(R.id.all_apps_tabs_view_pager);
 
         mMultiValueAlpha = new MultiValueAlpha(this, ALPHA_CHANNEL_COUNT);
+
     }
 
     /**
@@ -545,9 +547,7 @@
             return mLauncher.startActivitySafely(v, headerItem.getIntent(), headerItem);
         }
         AdapterItem focusedItem = getActiveRecyclerView().getApps().getFocusedChild();
-        if (focusedItem instanceof SearchAdapterItem) {
-            SearchTarget searchTarget = ((SearchAdapterItem) focusedItem).getSearchTarget();
-            SearchEventTracker.INSTANCE.get(getContext()).quickSelect(searchTarget);
+        if (mSearchAdapterProvider.onAdapterItemSelected(focusedItem)) {
             return true;
         }
         if (focusedItem.appInfo != null) {
@@ -569,6 +569,10 @@
         return null;
     }
 
+    public SearchAdapterProvider getSearchAdapterProvider() {
+        return mSearchAdapterProvider;
+    }
+
     public RecyclerViewFastScroller getScrollBar() {
         AllAppsRecyclerView rv = getActiveRecyclerView();
         return rv == null ? null : rv.getScrollbar();
@@ -677,7 +681,8 @@
         AdapterHolder(boolean isWork) {
             mIsWork = isWork;
             appsList = new AlphabeticalAppsList(mLauncher, mAllAppsStore, isWork);
-            adapter = new AllAppsGridAdapter(mLauncher, getLayoutInflater(), appsList);
+            adapter = new AllAppsGridAdapter(mLauncher, getLayoutInflater(), appsList,
+                    mSearchAdapterProvider);
             appsList.setAdapter(adapter);
             layoutManager = adapter.getLayoutManager();
         }
diff --git a/src/com/android/launcher3/allapps/AllAppsGridAdapter.java b/src/com/android/launcher3/allapps/AllAppsGridAdapter.java
index 3c88288..715c142 100644
--- a/src/com/android/launcher3/allapps/AllAppsGridAdapter.java
+++ b/src/com/android/launcher3/allapps/AllAppsGridAdapter.java
@@ -41,13 +41,11 @@
 import com.android.launcher3.BaseDraggingActivity;
 import com.android.launcher3.BubbleTextView;
 import com.android.launcher3.R;
-import com.android.launcher3.allapps.search.AllAppsSearchBarController.SearchTargetHandler;
+import com.android.launcher3.allapps.search.SearchAdapterProvider;
 import com.android.launcher3.allapps.search.SearchSectionInfo;
 import com.android.launcher3.config.FeatureFlags;
 import com.android.launcher3.model.data.AppInfo;
 import com.android.launcher3.util.PackageManagerHelper;
-import com.android.launcher3.views.SearchResultWidget;
-import com.android.systemui.plugins.shared.SearchTarget;
 
 import java.util.List;
 
@@ -72,31 +70,11 @@
     // A divider that separates the apps list and the search market button
     public static final int VIEW_TYPE_ALL_APPS_DIVIDER = 1 << 4;
 
-    public static final int VIEW_TYPE_SEARCH_CORPUS_TITLE = 1 << 5;
-
-    public static final int VIEW_TYPE_SEARCH_ROW_WITH_BUTTON = 1 << 7;
-
-    public static final int VIEW_TYPE_SEARCH_ROW = 1 << 8;
-
-    public static final int VIEW_TYPE_SEARCH_SLICE = 1 << 9;
-
-    public static final int VIEW_TYPE_SEARCH_ICON_ROW = 1 << 10;
-
-    public static final int VIEW_TYPE_SEARCH_PEOPLE = 1 << 11;
-
-    public static final int VIEW_TYPE_SEARCH_THUMBNAIL = 1 << 12;
-
-    public static final int VIEW_TYPE_SEARCH_SUGGEST = 1 << 13;
-
-    public static final int VIEW_TYPE_SEARCH_ICON = 1 << 14;
-
-    public static final int VIEW_TYPE_SEARCH_WIDGET_LIVE = 1 << 15;
-
-    public static final int VIEW_TYPE_SEARCH_WIDGET_PREVIEW = 1 << 16;
-
     // Common view type masks
     public static final int VIEW_TYPE_MASK_DIVIDER = VIEW_TYPE_ALL_APPS_DIVIDER;
-    public static final int VIEW_TYPE_MASK_ICON = VIEW_TYPE_ICON | VIEW_TYPE_SEARCH_ICON;
+    public static final int VIEW_TYPE_MASK_ICON = VIEW_TYPE_ICON;
+
+    private final SearchAdapterProvider mSearchAdapterProvider;
 
     /**
      * ViewHolder for each icon.
@@ -177,32 +155,8 @@
             return item;
         }
 
-        boolean isCountedForAccessibility() {
-            return viewType == VIEW_TYPE_ICON
-                    || viewType == VIEW_TYPE_SEARCH_ROW_WITH_BUTTON
-                    || viewType == VIEW_TYPE_SEARCH_SLICE
-                    || viewType == VIEW_TYPE_SEARCH_ROW
-                    || viewType == VIEW_TYPE_SEARCH_PEOPLE
-                    || viewType == VIEW_TYPE_SEARCH_THUMBNAIL
-                    || viewType == VIEW_TYPE_SEARCH_ICON_ROW
-                    || viewType == VIEW_TYPE_SEARCH_ICON
-                    || viewType == VIEW_TYPE_SEARCH_SUGGEST;
-        }
-    }
-
-    /**
-     * Extension of AdapterItem that contains an extra payload specific to item
-     */
-    public static class SearchAdapterItem extends AdapterItem {
-        private SearchTarget mSearchTarget;
-
-        public SearchAdapterItem(SearchTarget searchTarget, int type) {
-            mSearchTarget = searchTarget;
-            viewType = type;
-        }
-
-        public SearchTarget getSearchTarget() {
-            return mSearchTarget;
+        protected boolean isCountedForAccessibility() {
+            return viewType == VIEW_TYPE_ICON || viewType == VIEW_TYPE_SEARCH_MARKET;
         }
     }
 
@@ -289,9 +243,8 @@
             int viewType = mApps.getAdapterItems().get(position).viewType;
             if (isIconViewType(viewType)) {
                 return 1 * SPAN_MULTIPLIER;
-            } else if (viewType == VIEW_TYPE_SEARCH_THUMBNAIL
-                    || viewType == VIEW_TYPE_SEARCH_WIDGET_PREVIEW) {
-                return mAppsPerRow;
+            } else if (mSearchAdapterProvider.isSearchView(viewType)) {
+                return mSearchAdapterProvider.getGridSpanSize(viewType, mAppsPerRow);
             } else {
                 // Section breaks span the full width
                 return mAppsPerRow * SPAN_MULTIPLIER;
@@ -321,7 +274,7 @@
     private Intent mMarketSearchIntent;
 
     public AllAppsGridAdapter(BaseDraggingActivity launcher, LayoutInflater inflater,
-            AlphabeticalAppsList apps) {
+            AlphabeticalAppsList apps, SearchAdapterProvider searchAdapterProvider) {
         Resources res = launcher.getResources();
         mLauncher = launcher;
         mApps = apps;
@@ -334,6 +287,8 @@
         mOnIconClickListener = launcher.getItemOnClickListener();
 
         setAppsPerRow(mLauncher.getDeviceProfile().inv.numAllAppsColumns);
+
+        mSearchAdapterProvider = searchAdapterProvider;
     }
 
     public void setAppsPerRow(int appsPerRow) {
@@ -406,40 +361,11 @@
             case VIEW_TYPE_ALL_APPS_DIVIDER:
                 return new ViewHolder(mLayoutInflater.inflate(
                         R.layout.all_apps_divider, parent, false));
-            case VIEW_TYPE_SEARCH_ICON:
-                return new ViewHolder(mLayoutInflater.inflate(
-                        R.layout.search_result_icon, parent, false));
-            case VIEW_TYPE_SEARCH_CORPUS_TITLE:
-                return new ViewHolder(
-                        mLayoutInflater.inflate(R.layout.search_section_title, parent, false));
-            case VIEW_TYPE_SEARCH_ROW_WITH_BUTTON:
-                return new ViewHolder(mLayoutInflater.inflate(
-                        R.layout.search_result_play_item, parent, false));
-            case VIEW_TYPE_SEARCH_ROW:
-                return new ViewHolder(mLayoutInflater.inflate(
-                        R.layout.search_result_settings_row, parent, false));
-            case VIEW_TYPE_SEARCH_SLICE:
-                return new ViewHolder(mLayoutInflater.inflate(
-                        R.layout.search_result_slice, parent, false));
-            case VIEW_TYPE_SEARCH_ICON_ROW:
-                return new ViewHolder(mLayoutInflater.inflate(
-                        R.layout.search_result_icon_row, parent, false));
-            case VIEW_TYPE_SEARCH_PEOPLE:
-                return new ViewHolder(mLayoutInflater.inflate(
-                        R.layout.search_result_people_item, parent, false));
-            case VIEW_TYPE_SEARCH_THUMBNAIL:
-                return new ViewHolder(mLayoutInflater.inflate(
-                        R.layout.search_result_thumbnail, parent, false));
-            case VIEW_TYPE_SEARCH_SUGGEST:
-                return new ViewHolder(mLayoutInflater.inflate(
-                        R.layout.search_result_suggest, parent, false));
-            case VIEW_TYPE_SEARCH_WIDGET_LIVE:
-                return new ViewHolder(mLayoutInflater.inflate(
-                        R.layout.search_result_widget_live, parent, false));
-            case VIEW_TYPE_SEARCH_WIDGET_PREVIEW:
-                return new ViewHolder(mLayoutInflater.inflate(
-                        R.layout.search_result_widget_preview, parent, false));
             default:
+                if (mSearchAdapterProvider.isSearchView(viewType)) {
+                    return mSearchAdapterProvider.onCreateViewHolder(mLayoutInflater, parent,
+                            viewType);
+                }
                 throw new RuntimeException("Unexpected view type");
         }
     }
@@ -472,25 +398,11 @@
                     searchView.setVisibility(View.GONE);
                 }
                 break;
-            case VIEW_TYPE_SEARCH_CORPUS_TITLE:
-            case VIEW_TYPE_SEARCH_ROW_WITH_BUTTON:
-            case VIEW_TYPE_SEARCH_SLICE:
-            case VIEW_TYPE_SEARCH_ROW:
-            case VIEW_TYPE_SEARCH_ICON:
-            case VIEW_TYPE_SEARCH_ICON_ROW:
-            case VIEW_TYPE_SEARCH_PEOPLE:
-            case VIEW_TYPE_SEARCH_THUMBNAIL:
-            case VIEW_TYPE_SEARCH_SUGGEST:
-            case VIEW_TYPE_SEARCH_WIDGET_LIVE:
-            case VIEW_TYPE_SEARCH_WIDGET_PREVIEW:
-                SearchAdapterItem item =
-                        (SearchAdapterItem) mApps.getAdapterItems().get(position);
-                SearchTargetHandler payloadResultView = (SearchTargetHandler) holder.itemView;
-                payloadResultView.applySearchTarget(item.getSearchTarget());
-                break;
             case VIEW_TYPE_ALL_APPS_DIVIDER:
                 // nothing to do
                 break;
+            default:
+                mSearchAdapterProvider.onBindView(holder, position);
         }
     }
 
@@ -501,9 +413,6 @@
         if (holder.itemView instanceof AllAppsSectionDecorator.SelfDecoratingView) {
             ((AllAppsSectionDecorator.SelfDecoratingView) holder.itemView).removeDecoration();
         }
-        if (holder.itemView instanceof SearchResultWidget) {
-            ((SearchResultWidget) holder.itemView).removeListener();
-        }
     }
 
     @Override
diff --git a/src/com/android/launcher3/allapps/AllAppsRecyclerView.java b/src/com/android/launcher3/allapps/AllAppsRecyclerView.java
index 1fa43d0..e61b95d 100644
--- a/src/com/android/launcher3/allapps/AllAppsRecyclerView.java
+++ b/src/com/android/launcher3/allapps/AllAppsRecyclerView.java
@@ -104,7 +104,6 @@
         pool.setMaxRecycledViews(AllAppsGridAdapter.VIEW_TYPE_ALL_APPS_DIVIDER, 1);
         pool.setMaxRecycledViews(AllAppsGridAdapter.VIEW_TYPE_SEARCH_MARKET, 1);
         pool.setMaxRecycledViews(AllAppsGridAdapter.VIEW_TYPE_ICON, approxRows * mNumAppsPerRow);
-        pool.setMaxRecycledViews(AllAppsGridAdapter.VIEW_TYPE_SEARCH_CORPUS_TITLE, 1);
 
         mViewHeights.clear();
         mViewHeights.put(AllAppsGridAdapter.VIEW_TYPE_ICON, grid.allAppsCellHeightPx);
diff --git a/src/com/android/launcher3/allapps/AllAppsStore.java b/src/com/android/launcher3/allapps/AllAppsStore.java
index 3ae0a18..00bdb70 100644
--- a/src/com/android/launcher3/allapps/AllAppsStore.java
+++ b/src/com/android/launcher3/allapps/AllAppsStore.java
@@ -24,7 +24,6 @@
 import com.android.launcher3.BubbleTextView;
 import com.android.launcher3.model.data.AppInfo;
 import com.android.launcher3.model.data.ItemInfo;
-import com.android.launcher3.model.data.PromiseAppInfo;
 import com.android.launcher3.util.ComponentKey;
 import com.android.launcher3.util.PackageUserKey;
 
@@ -145,10 +144,17 @@
         });
     }
 
-    public void updatePromiseAppProgress(PromiseAppInfo app) {
+    /**
+     * Sets the AppInfo's associated icon's progress bar.
+     *
+     * If this app is installed and supports incremental downloads, the progress bar will be updated
+     * the app's total download progress. Otherwise, the progress bar will be updated to the app's
+     * installation progress.
+     */
+    public void updateProgressBar(AppInfo app) {
         updateAllIcons((child) -> {
             if (child.getTag() == app) {
-                child.applyProgressLevel(app.level);
+                child.applyProgressLevel(app.getProgressLevel());
             }
         });
     }
diff --git a/src/com/android/launcher3/allapps/AllAppsTransitionController.java b/src/com/android/launcher3/allapps/AllAppsTransitionController.java
index f9ab196..c03619e 100644
--- a/src/com/android/launcher3/allapps/AllAppsTransitionController.java
+++ b/src/com/android/launcher3/allapps/AllAppsTransitionController.java
@@ -142,7 +142,8 @@
         float shiftCurrent = progress * mShiftRange;
 
         mAppsView.setTranslationY(shiftCurrent);
-        if (FeatureFlags.ENABLE_DEVICE_SEARCH.get()) {
+        if (FeatureFlags.ENABLE_DEVICE_SEARCH.get()
+                && !FeatureFlags.DISABLE_INITIAL_IME_IN_ALLAPPS.get()) {
             mInsetController.setProgress(progress);
         }
     }
@@ -233,7 +234,9 @@
     public void setupViews(AllAppsContainerView appsView, ScrimView scrimView) {
         mAppsView = appsView;
         mScrimView = scrimView;
-        if (FeatureFlags.ENABLE_DEVICE_SEARCH.get() && BuildCompat.isAtLeastR()) {
+        if (FeatureFlags.ENABLE_DEVICE_SEARCH.get()
+                && !FeatureFlags.DISABLE_INITIAL_IME_IN_ALLAPPS.get()
+                && BuildCompat.isAtLeastR()) {
             mInsetController = new AllAppsInsetTransitionController(mShiftRange, mAppsView);
             mLauncher.getSystemUiController().updateUiState(UI_STATE_ALLAPPS,
                     View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
@@ -261,7 +264,8 @@
         if (Float.compare(mProgress, 1f) == 0) {
             mAppsView.reset(false /* animate */);
         }
-        if (FeatureFlags.ENABLE_DEVICE_SEARCH.get() && BuildCompat.isAtLeastR()) {
+        if (FeatureFlags.ENABLE_DEVICE_SEARCH.get()
+                && !FeatureFlags.DISABLE_INITIAL_IME_IN_ALLAPPS.get() && BuildCompat.isAtLeastR()) {
             mInsetController.onAnimationEnd(mProgress);
             if (Float.compare(mProgress, 0f) == 0) {
                 mLauncher.getLiveSearchManager().start();
diff --git a/src/com/android/launcher3/allapps/search/AllAppsSearchBarController.java b/src/com/android/launcher3/allapps/search/AllAppsSearchBarController.java
index bc5a5f2..522f1d4 100644
--- a/src/com/android/launcher3/allapps/search/AllAppsSearchBarController.java
+++ b/src/com/android/launcher3/allapps/search/AllAppsSearchBarController.java
@@ -15,7 +15,6 @@
  */
 package com.android.launcher3.allapps.search;
 
-import android.os.Bundle;
 import android.text.Editable;
 import android.text.TextUtils;
 import android.text.TextWatcher;
@@ -34,10 +33,8 @@
 import com.android.launcher3.config.FeatureFlags;
 import com.android.launcher3.util.PackageManagerHelper;
 import com.android.systemui.plugins.AllAppsSearchPlugin;
-import com.android.systemui.plugins.shared.SearchTarget;
 
 import java.util.ArrayList;
-import java.util.List;
 import java.util.function.Consumer;
 
 /**
@@ -63,7 +60,7 @@
      */
     public final void initialize(
             SearchAlgorithm searchAlgorithm, ExtendedEditText input,
-            BaseDraggingActivity launcher, Callbacks cb, Consumer<List<Bundle>> secondaryCb) {
+            BaseDraggingActivity launcher, Callbacks cb) {
         mCb = cb;
         mLauncher = launcher;
 
@@ -211,23 +208,5 @@
         void clearSearchResult();
     }
 
-    /**
-     * An interface for supporting dynamic search results
-     */
-    public interface SearchTargetHandler {
-
-        /**
-         * Update view using values from {@link SearchTarget}
-         */
-        void applySearchTarget(SearchTarget searchTarget);
-
-        /**
-         * Handles selection of SearchTarget
-         */
-        default void handleSelection(int eventType) {
-        }
-
-    }
-
 
 }
\ No newline at end of file
diff --git a/src/com/android/launcher3/allapps/search/AppsSearchContainerLayout.java b/src/com/android/launcher3/allapps/search/AppsSearchContainerLayout.java
index bd2f04d..4f79fb8 100644
--- a/src/com/android/launcher3/allapps/search/AppsSearchContainerLayout.java
+++ b/src/com/android/launcher3/allapps/search/AppsSearchContainerLayout.java
@@ -24,7 +24,6 @@
 
 import android.content.Context;
 import android.graphics.Rect;
-import android.os.Bundle;
 import android.text.Selection;
 import android.text.SpannableStringBuilder;
 import android.text.method.TextKeyListener;
@@ -50,15 +49,13 @@
 import com.android.launcher3.config.FeatureFlags;
 
 import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Consumer;
 
 /**
  * Layout to contain the All-apps search UI.
  */
 public class AppsSearchContainerLayout extends ExtendedEditText
         implements SearchUiManager, AllAppsSearchBarController.Callbacks,
-        AllAppsStore.OnUpdateListener, Insettable, Consumer<List<Bundle>> {
+        AllAppsStore.OnUpdateListener, Insettable {
 
     private final BaseDraggingActivity mLauncher;
     private final AllAppsSearchBarController mSearchBarController;
@@ -141,7 +138,7 @@
         mAppsView = appsView;
         mSearchBarController.initialize(
                 new DefaultAppSearchAlgorithm(mLauncher, LauncherAppState.getInstance(mLauncher)),
-                this, mLauncher, this, this);
+                this, mLauncher, this);
     }
 
     @Override
@@ -234,9 +231,4 @@
     public EditText getEditText() {
         return this;
     }
-
-    @Override
-    public void accept(List<Bundle> bundles) {
-        // TODO: Render the result on mAppsView object
-    }
 }
diff --git a/src/com/android/launcher3/allapps/search/DefaultSearchAdapterProvider.java b/src/com/android/launcher3/allapps/search/DefaultSearchAdapterProvider.java
new file mode 100644
index 0000000..e3c178b
--- /dev/null
+++ b/src/com/android/launcher3/allapps/search/DefaultSearchAdapterProvider.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+package com.android.launcher3.allapps.search;
+
+import android.view.LayoutInflater;
+import android.view.ViewGroup;
+
+import com.android.launcher3.BaseDraggingActivity;
+import com.android.launcher3.allapps.AllAppsGridAdapter;
+
+/**
+ * Provides views for local search results
+ */
+public class DefaultSearchAdapterProvider extends SearchAdapterProvider {
+
+    public DefaultSearchAdapterProvider(BaseDraggingActivity launcher) {
+        super(launcher);
+    }
+
+    @Override
+    public void onBindView(AllAppsGridAdapter.ViewHolder holder, int position) {
+
+    }
+
+    @Override
+    public boolean isSearchView(int viewType) {
+        return false;
+    }
+
+    @Override
+    public AllAppsGridAdapter.ViewHolder onCreateViewHolder(LayoutInflater layoutInflater,
+            ViewGroup parent, int viewType) {
+        return null;
+    }
+
+    @Override
+    public boolean onAdapterItemSelected(AllAppsGridAdapter.AdapterItem focusedItem) {
+        return false;
+    }
+}
diff --git a/src/com/android/launcher3/allapps/search/SearchAdapterProvider.java b/src/com/android/launcher3/allapps/search/SearchAdapterProvider.java
new file mode 100644
index 0000000..1c7247a
--- /dev/null
+++ b/src/com/android/launcher3/allapps/search/SearchAdapterProvider.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+package com.android.launcher3.allapps.search;
+
+
+import android.view.LayoutInflater;
+import android.view.ViewGroup;
+
+import com.android.launcher3.BaseDraggingActivity;
+import com.android.launcher3.allapps.AllAppsGridAdapter;
+
+/**
+ * A UI expansion wrapper providing for search results
+ */
+public abstract class SearchAdapterProvider {
+
+    protected final BaseDraggingActivity mLauncher;
+
+    public SearchAdapterProvider(BaseDraggingActivity launcher) {
+        mLauncher = launcher;
+    }
+
+    /**
+     * Called from RecyclerView.Adapter#onBindViewHolder
+     */
+    public abstract void onBindView(AllAppsGridAdapter.ViewHolder holder, int position);
+
+    /**
+     * Returns whether or not viewType can be handled by searchProvider
+     */
+    public abstract boolean isSearchView(int viewType);
+
+    /**
+     * Called from RecyclerView.Adapter#onCreateViewHolder
+     */
+    public abstract AllAppsGridAdapter.ViewHolder onCreateViewHolder(LayoutInflater layoutInflater,
+            ViewGroup parent, int viewType);
+
+    /**
+     * Returns how many cells a view should span
+     */
+    public int getGridSpanSize(int viewType, int appsPerRow) {
+        return appsPerRow * AllAppsGridAdapter.SPAN_MULTIPLIER;
+    }
+
+    /**
+     * handles selection event on search adapter item. Returns false if provider can not handle
+     * event
+     */
+    public abstract boolean onAdapterItemSelected(AllAppsGridAdapter.AdapterItem focusedItem);
+}
diff --git a/src/com/android/launcher3/config/FeatureFlags.java b/src/com/android/launcher3/config/FeatureFlags.java
index 68641d9..2455706 100644
--- a/src/com/android/launcher3/config/FeatureFlags.java
+++ b/src/com/android/launcher3/config/FeatureFlags.java
@@ -98,6 +98,13 @@
     public static final BooleanFlag ENABLE_DEVICE_SEARCH = getDebugFlag(
             "ENABLE_DEVICE_SEARCH", false, "Allows on device search in all apps");
 
+    public static final BooleanFlag SEARCH_TARGET_LEGACY = getDebugFlag(
+            "SEARCH_TARGET_LEGACY", true,
+            "Use SearchTarget provided by plugin lib (only during migration)");
+
+    public static final BooleanFlag DISABLE_INITIAL_IME_IN_ALLAPPS = getDebugFlag(
+            "DISABLE_INITIAL_IME_IN_ALLAPPS", false, "Disable default IME state in all apps");
+
     public static final BooleanFlag FOLDER_NAME_SUGGEST = new DeviceFlag(
             "FOLDER_NAME_SUGGEST", true,
             "Suggests folder names instead of blank text.");
diff --git a/src/com/android/launcher3/folder/PreviewItemManager.java b/src/com/android/launcher3/folder/PreviewItemManager.java
index 7f8a15c..9ae7faf 100644
--- a/src/com/android/launcher3/folder/PreviewItemManager.java
+++ b/src/com/android/launcher3/folder/PreviewItemManager.java
@@ -39,6 +39,7 @@
 
 import com.android.launcher3.Utilities;
 import com.android.launcher3.graphics.PreloadIconDrawable;
+import com.android.launcher3.model.data.ItemInfoWithIcon;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.views.ActivityContext;
 
@@ -394,9 +395,10 @@
     }
 
     private void setDrawable(PreviewItemDrawingParams p, WorkspaceItemInfo item) {
-        if (item.hasPromiseIconUi()) {
+        if (item.hasPromiseIconUi() || (item.runtimeStatusFlags
+                    & ItemInfoWithIcon.FLAG_SHOW_DOWNLOAD_PROGRESS_MASK) != 0) {
             PreloadIconDrawable drawable = newPendingIcon(mContext, item);
-            drawable.setLevel(item.getInstallProgress());
+            drawable.setLevel(item.getProgressLevel());
             p.drawable = drawable;
         } else {
             p.drawable = newIcon(mContext, item);
diff --git a/src/com/android/launcher3/graphics/PreloadIconDrawable.java b/src/com/android/launcher3/graphics/PreloadIconDrawable.java
index e85b056..9971990 100644
--- a/src/com/android/launcher3/graphics/PreloadIconDrawable.java
+++ b/src/com/android/launcher3/graphics/PreloadIconDrawable.java
@@ -117,6 +117,8 @@
         mIndicatorColor = IconPalette.getPreloadProgressColor(context, mIconColor);
 
         setInternalProgress(0);
+
+        setIsDisabled(!info.isAppStartable());
     }
 
     @Override
@@ -266,14 +268,12 @@
             mIconScale = SMALL_SCALE;
             mScaledTrackPath.reset();
             mTrackAlpha = MAX_PAINT_ALPHA;
-            setIsDisabled(true);
         }
 
         if (progress < 1 && progress > 0) {
             mPathMeasure.getSegment(0, progress * mTrackLength, mScaledProgressPath, true);
             mIconScale = SMALL_SCALE;
             mTrackAlpha = MAX_PAINT_ALPHA;
-            setIsDisabled(true);
         } else if (progress >= 1) {
             setIsDisabled(mItem.isDisabled());
             mScaledTrackPath.set(mScaledProgressPath);
diff --git a/src/com/android/launcher3/model/AddWorkspaceItemsTask.java b/src/com/android/launcher3/model/AddWorkspaceItemsTask.java
index c236fa6..56dbbd3 100644
--- a/src/com/android/launcher3/model/AddWorkspaceItemsTask.java
+++ b/src/com/android/launcher3/model/AddWorkspaceItemsTask.java
@@ -34,6 +34,7 @@
 import com.android.launcher3.model.data.LauncherAppWidgetInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.pm.InstallSessionHelper;
+import com.android.launcher3.pm.PackageInstallInfo;
 import com.android.launcher3.util.GridOccupancy;
 import com.android.launcher3.util.IntArray;
 import com.android.launcher3.util.PackageManagerHelper;
@@ -132,7 +133,9 @@
                             continue;
                         }
                     } else {
-                        workspaceInfo.setInstallProgress((int) sessionInfo.getProgress());
+                        workspaceInfo.setProgressLevel(
+                                (int) (sessionInfo.getProgress() * 100),
+                                PackageInstallInfo.STATUS_INSTALLING);
                     }
 
                     if (hasActivity) {
diff --git a/src/com/android/launcher3/model/AllAppsList.java b/src/com/android/launcher3/model/AllAppsList.java
index 2695e66..c57c3e4 100644
--- a/src/com/android/launcher3/model/AllAppsList.java
+++ b/src/com/android/launcher3/model/AllAppsList.java
@@ -21,6 +21,7 @@
 
 import android.content.ComponentName;
 import android.content.Context;
+import android.content.Intent;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.LauncherActivityInfo;
 import android.content.pm.LauncherApps;
@@ -37,7 +38,6 @@
 import com.android.launcher3.icons.IconCache;
 import com.android.launcher3.model.BgDataModel.Callbacks;
 import com.android.launcher3.model.data.AppInfo;
-import com.android.launcher3.model.data.PromiseAppInfo;
 import com.android.launcher3.pm.PackageInstallInfo;
 import com.android.launcher3.util.FlagOp;
 import com.android.launcher3.util.ItemInfoMatcher;
@@ -150,7 +150,7 @@
                 .getApplicationInfo(installInfo.packageName, installInfo.user, 0);
         // only if not yet installed
         if (applicationInfo == null) {
-            PromiseAppInfo info = new PromiseAppInfo(installInfo);
+            AppInfo info = new AppInfo(installInfo);
             mIconCache.getTitleAndIcon(info, info.usingLowResIcon());
             info.sectionName = mIndex.computeSectionName(info.title);
 
@@ -159,24 +159,30 @@
         }
     }
 
-    public PromiseAppInfo updatePromiseInstallInfo(PackageInstallInfo installInfo) {
+    /** Updates the given PackageInstallInfo's associated AppInfo's installation info. */
+    public List<AppInfo> updatePromiseInstallInfo(PackageInstallInfo installInfo) {
+        List<AppInfo> updatedAppInfos = new ArrayList<>();
         UserHandle user = Process.myUserHandle();
-        for (int i=0; i < data.size(); i++) {
+        for (int i = data.size() - 1; i >= 0; i--) {
             final AppInfo appInfo = data.get(i);
             final ComponentName tgtComp = appInfo.getTargetComponent();
             if (tgtComp != null && tgtComp.getPackageName().equals(installInfo.packageName)
-                    && appInfo.user.equals(user)
-                    && appInfo instanceof PromiseAppInfo) {
-                final PromiseAppInfo promiseAppInfo = (PromiseAppInfo) appInfo;
-                if (installInfo.state == PackageInstallInfo.STATUS_INSTALLING) {
-                    promiseAppInfo.level = installInfo.progress;
-                    return promiseAppInfo;
+                    && appInfo.user.equals(user)) {
+                if (installInfo.state == PackageInstallInfo.STATUS_INSTALLED_DOWNLOADING
+                        || installInfo.state == PackageInstallInfo.STATUS_INSTALLING) {
+                    if (appInfo.isAppStartable()
+                            && installInfo.state == PackageInstallInfo.STATUS_INSTALLING) {
+                        continue;
+                    }
+                    appInfo.setProgressLevel(installInfo);
+
+                    updatedAppInfos.add(appInfo);
                 } else if (installInfo.state == PackageInstallInfo.STATUS_FAILED) {
                     removeApp(i);
                 }
             }
         }
-        return null;
+        return updatedAppInfos;
     }
 
     private void removeApp(int index) {
@@ -268,8 +274,14 @@
                 if (applicationInfo == null) {
                     add(new AppInfo(context, info, user), info);
                 } else {
+                    Intent launchIntent = AppInfo.makeLaunchIntent(info);
+
                     mIconCache.getTitleAndIcon(applicationInfo, info, true /* useLowResIcon */);
                     applicationInfo.sectionName = mIndex.computeSectionName(applicationInfo.title);
+                    applicationInfo.setProgressLevel(
+                            PackageManagerHelper.getLoadingProgress(info),
+                            PackageInstallInfo.STATUS_INSTALLED_DOWNLOADING);
+                    applicationInfo.intent = launchIntent;
 
                     mDataChanged = true;
                 }
diff --git a/src/com/android/launcher3/model/BgDataModel.java b/src/com/android/launcher3/model/BgDataModel.java
index c217a47..2d860a4 100644
--- a/src/com/android/launcher3/model/BgDataModel.java
+++ b/src/com/android/launcher3/model/BgDataModel.java
@@ -39,7 +39,6 @@
 import com.android.launcher3.model.data.FolderInfo;
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.model.data.LauncherAppWidgetInfo;
-import com.android.launcher3.model.data.PromiseAppInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.pm.UserCache;
 import com.android.launcher3.shortcuts.ShortcutKey;
@@ -459,7 +458,11 @@
         void preAddApps();
         void bindAppsAdded(IntArray newScreens,
                 ArrayList<ItemInfo> addNotAnimated, ArrayList<ItemInfo> addAnimated);
-        void bindPromiseAppProgressUpdated(PromiseAppInfo app);
+
+        /**
+         * Binds updated incremental download progress
+         */
+        void bindIncrementalDownloadProgressUpdated(AppInfo app);
         void bindWorkspaceItemsChanged(List<WorkspaceItemInfo> updated);
         void bindWidgetsRestored(ArrayList<LauncherAppWidgetInfo> widgets);
         void bindRestoreItemsChange(HashSet<ItemInfo> updates);
diff --git a/src/com/android/launcher3/model/LoaderCursor.java b/src/com/android/launcher3/model/LoaderCursor.java
index 532834e..19d9af9 100644
--- a/src/com/android/launcher3/model/LoaderCursor.java
+++ b/src/com/android/launcher3/model/LoaderCursor.java
@@ -35,11 +35,13 @@
 import android.util.Log;
 import android.util.LongSparseArray;
 
+import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 
 import com.android.launcher3.InvariantDeviceProfile;
 import com.android.launcher3.LauncherAppState;
 import com.android.launcher3.LauncherSettings;
+import com.android.launcher3.LauncherSettings.Favorites;
 import com.android.launcher3.Utilities;
 import com.android.launcher3.Workspace;
 import com.android.launcher3.config.FeatureFlags;
@@ -92,6 +94,9 @@
     private final int restoredIndex;
     private final int intentIndex;
 
+    @Nullable
+    private LauncherActivityInfo mActivityInfo;
+
     // Properties loaded per iteration
     public long serialNumber;
     public UserHandle user;
@@ -132,6 +137,8 @@
     public boolean moveToNext() {
         boolean result = super.moveToNext();
         if (result) {
+            mActivityInfo = null;
+
             // Load common properties.
             itemType = getInt(itemTypeIndex);
             container = getInt(containerIndex);
@@ -245,6 +252,10 @@
         return info;
     }
 
+    public LauncherActivityInfo getLauncherActivityInfo() {
+        return mActivityInfo;
+    }
+
     /**
      * Make an WorkspaceItemInfo object for a shortcut that is an application.
      */
@@ -264,25 +275,25 @@
         Intent newIntent = new Intent(Intent.ACTION_MAIN, null);
         newIntent.addCategory(Intent.CATEGORY_LAUNCHER);
         newIntent.setComponent(componentName);
-        LauncherActivityInfo lai = mContext.getSystemService(LauncherApps.class)
+        mActivityInfo = mContext.getSystemService(LauncherApps.class)
                 .resolveActivity(newIntent, user);
-        if ((lai == null) && !allowMissingTarget) {
+        if ((mActivityInfo == null) && !allowMissingTarget) {
             Log.d(TAG, "Missing activity found in getShortcutInfo: " + componentName);
             return null;
         }
 
         final WorkspaceItemInfo info = new WorkspaceItemInfo();
-        info.itemType = LauncherSettings.Favorites.ITEM_TYPE_APPLICATION;
+        info.itemType = Favorites.ITEM_TYPE_APPLICATION;
         info.user = user;
         info.intent = newIntent;
 
-        mIconCache.getTitleAndIcon(info, lai, useLowResIcon);
+        mIconCache.getTitleAndIcon(info, mActivityInfo, useLowResIcon);
         if (mIconCache.isDefaultIcon(info.bitmap, user)) {
             loadIcon(info);
         }
 
-        if (lai != null) {
-            AppInfo.updateRuntimeFlagsForActivityTarget(info, lai);
+        if (mActivityInfo != null) {
+            AppInfo.updateRuntimeFlagsForActivityTarget(info, mActivityInfo);
         }
 
         // from the db
diff --git a/src/com/android/launcher3/model/LoaderTask.java b/src/com/android/launcher3/model/LoaderTask.java
index 8e085ce..f74c8b5 100644
--- a/src/com/android/launcher3/model/LoaderTask.java
+++ b/src/com/android/launcher3/model/LoaderTask.java
@@ -69,6 +69,7 @@
 import com.android.launcher3.model.data.AppInfo;
 import com.android.launcher3.model.data.FolderInfo;
 import com.android.launcher3.model.data.ItemInfo;
+import com.android.launcher3.model.data.ItemInfoWithIcon;
 import com.android.launcher3.model.data.LauncherAppWidgetInfo;
 import com.android.launcher3.model.data.PackageItemInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
@@ -591,11 +592,24 @@
                                 if (c.restoreFlag != 0 && !TextUtils.isEmpty(targetPkg)) {
                                     tempPackageKey.update(targetPkg, c.user);
                                     SessionInfo si = installingPkgs.get(tempPackageKey);
-                                    if (si == null) {
-                                        info.status &= ~WorkspaceItemInfo.FLAG_INSTALL_SESSION_ACTIVE;
-                                    } else {
-                                        info.setInstallProgress((int) (si.getProgress() * 100));
-                                    }
+                                        LauncherActivityInfo activityInfo =
+                                                c.getLauncherActivityInfo();
+                                        if (si == null) {
+                                            info.runtimeStatusFlags &=
+                                                    ~ItemInfoWithIcon.FLAG_INSTALL_SESSION_ACTIVE;
+                                        } else if (activityInfo == null) {
+                                            int installProgress = (int) (si.getProgress() * 100);
+
+                                            info.setProgressLevel(
+                                                    installProgress,
+                                                    PackageInstallInfo.STATUS_INSTALLING);
+                                        } else {
+                                            info.setProgressLevel(
+                                                    PackageManagerHelper
+                                                            .getLoadingProgress(activityInfo),
+                                                    PackageInstallInfo
+                                                            .STATUS_INSTALLED_DOWNLOADING);
+                                        }
                                 }
 
                                 c.checkAndAddItem(info, mBgDataModel);
diff --git a/src/com/android/launcher3/model/PackageIncrementalDownloadUpdatedTask.java b/src/com/android/launcher3/model/PackageIncrementalDownloadUpdatedTask.java
new file mode 100644
index 0000000..e3e8769
--- /dev/null
+++ b/src/com/android/launcher3/model/PackageIncrementalDownloadUpdatedTask.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2020 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.
+ */
+package com.android.launcher3.model;
+
+import android.content.ComponentName;
+import android.os.UserHandle;
+
+import com.android.launcher3.LauncherAppState;
+import com.android.launcher3.model.data.AppInfo;
+import com.android.launcher3.model.data.ItemInfoWithIcon;
+import com.android.launcher3.model.data.WorkspaceItemInfo;
+import com.android.launcher3.pm.PackageInstallInfo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Handles updates due to incremental download progress updates.
+ */
+public class PackageIncrementalDownloadUpdatedTask extends BaseModelUpdateTask {
+
+    private final UserHandle mUser;
+    private final int mProgress;
+    private final String mPackageName;
+
+    public PackageIncrementalDownloadUpdatedTask(
+            String packageName, UserHandle user, float progress) {
+        mUser = user;
+        mProgress = 1 - progress > 0.001 ? (int) (100 * progress) : 100;
+        mPackageName = packageName;
+    }
+
+    @Override
+    public void execute(LauncherAppState app, BgDataModel dataModel, AllAppsList appsList) {
+        PackageInstallInfo downloadInfo = new PackageInstallInfo(
+                mPackageName,
+                PackageInstallInfo.STATUS_INSTALLED_DOWNLOADING,
+                mProgress,
+                mUser);
+
+        synchronized (appsList) {
+            List<AppInfo> updatedAppInfos = appsList.updatePromiseInstallInfo(downloadInfo);
+            if (!updatedAppInfos.isEmpty()) {
+                for (AppInfo appInfo : updatedAppInfos) {
+                    appInfo.runtimeStatusFlags &= ~ItemInfoWithIcon.FLAG_INSTALL_SESSION_ACTIVE;
+                    scheduleCallbackTask(
+                            c -> c.bindIncrementalDownloadProgressUpdated(appInfo));
+                }
+            }
+            bindApplicationsIfNeeded();
+        }
+
+        final ArrayList<WorkspaceItemInfo> updatedWorkspaceItems = new ArrayList<>();
+        synchronized (dataModel) {
+            dataModel.forAllWorkspaceItemInfos(mUser, si -> {
+                ComponentName cn = si.getTargetComponent();
+                if ((cn != null) && cn.getPackageName().equals(mPackageName)) {
+                    si.runtimeStatusFlags &= ~ItemInfoWithIcon.FLAG_INSTALL_SESSION_ACTIVE;
+                    si.setProgressLevel(downloadInfo);
+                    updatedWorkspaceItems.add(si);
+                }
+            });
+        }
+        bindUpdatedWorkspaceItems(updatedWorkspaceItems);
+    }
+}
diff --git a/src/com/android/launcher3/model/PackageInstallStateChangedTask.java b/src/com/android/launcher3/model/PackageInstallStateChangedTask.java
index 8369c48..8215edd 100644
--- a/src/com/android/launcher3/model/PackageInstallStateChangedTask.java
+++ b/src/com/android/launcher3/model/PackageInstallStateChangedTask.java
@@ -20,14 +20,15 @@
 import android.content.pm.PackageManager;
 
 import com.android.launcher3.LauncherAppState;
+import com.android.launcher3.model.data.AppInfo;
 import com.android.launcher3.model.data.ItemInfo;
+import com.android.launcher3.model.data.ItemInfoWithIcon;
 import com.android.launcher3.model.data.LauncherAppWidgetInfo;
-import com.android.launcher3.model.data.PromiseAppInfo;
-import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.pm.PackageInstallInfo;
 import com.android.launcher3.util.InstantAppResolver;
 
 import java.util.HashSet;
+import java.util.List;
 
 /**
  * Handles changes due to a sessions updates for a currently installing app.
@@ -59,9 +60,11 @@
         }
 
         synchronized (apps) {
-            PromiseAppInfo updated = apps.updatePromiseInstallInfo(mInstallInfo);
-            if (updated != null) {
-                scheduleCallbackTask(c -> c.bindPromiseAppProgressUpdated(updated));
+            List<AppInfo> updatedAppInfos = apps.updatePromiseInstallInfo(mInstallInfo);
+            if (!updatedAppInfos.isEmpty()) {
+                for (AppInfo appInfo : updatedAppInfos) {
+                    scheduleCallbackTask(c -> c.bindIncrementalDownloadProgressUpdated(appInfo));
+                }
             }
             bindApplicationsIfNeeded();
         }
@@ -71,11 +74,13 @@
             dataModel.forAllWorkspaceItemInfos(mInstallInfo.user, si -> {
                 ComponentName cn = si.getTargetComponent();
                 if (si.hasPromiseIconUi() && (cn != null)
-                        && mInstallInfo.packageName.equals(cn.getPackageName())) {
-                    si.setInstallProgress(mInstallInfo.progress);
+                        && cn.getPackageName().equals(mInstallInfo.packageName)) {
+                    int installProgress = mInstallInfo.progress;
+
+                    si.setProgressLevel(installProgress, PackageInstallInfo.STATUS_INSTALLING);
                     if (mInstallInfo.state == PackageInstallInfo.STATUS_FAILED) {
                         // Mark this info as broken.
-                        si.status &= ~WorkspaceItemInfo.FLAG_INSTALL_SESSION_ACTIVE;
+                        si.runtimeStatusFlags &= ~ItemInfoWithIcon.FLAG_INSTALL_SESSION_ACTIVE;
                     }
                     updates.add(si);
                 }
diff --git a/src/com/android/launcher3/model/PackageUpdatedTask.java b/src/com/android/launcher3/model/PackageUpdatedTask.java
index 896bfb6..3275d59 100644
--- a/src/com/android/launcher3/model/PackageUpdatedTask.java
+++ b/src/com/android/launcher3/model/PackageUpdatedTask.java
@@ -38,6 +38,7 @@
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.model.data.LauncherAppWidgetInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
+import com.android.launcher3.pm.PackageInstallInfo;
 import com.android.launcher3.pm.UserCache;
 import com.android.launcher3.shortcuts.ShortcutRequest;
 import com.android.launcher3.util.FlagOp;
@@ -246,6 +247,7 @@
 
                         if (isNewApkAvailable
                                 && si.itemType == Favorites.ITEM_TYPE_APPLICATION) {
+                            si.setProgressLevel(100, PackageInstallInfo.STATUS_INSTALLED);
                             iconCache.getTitleAndIcon(si, si.usingLowResIcon());
                             infoUpdated = true;
                         }
diff --git a/src/com/android/launcher3/model/data/AppInfo.java b/src/com/android/launcher3/model/data/AppInfo.java
index aee1f2a..dde0cf4 100644
--- a/src/com/android/launcher3/model/data/AppInfo.java
+++ b/src/com/android/launcher3/model/data/AppInfo.java
@@ -28,10 +28,13 @@
 import android.os.UserHandle;
 import android.os.UserManager;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 
 import com.android.launcher3.LauncherSettings;
 import com.android.launcher3.Utilities;
+import com.android.launcher3.pm.PackageInstallInfo;
 import com.android.launcher3.util.ComponentKey;
 import com.android.launcher3.util.PackageManagerHelper;
 
@@ -91,8 +94,6 @@
         componentName = info.componentName;
         title = Utilities.trim(info.title);
         intent = new Intent(info.intent);
-        user = info.user;
-        runtimeStatusFlags = info.runtimeStatusFlags;
     }
 
     @VisibleForTesting
@@ -104,13 +105,38 @@
         this.intent = intent;
     }
 
+    public AppInfo(@NonNull PackageInstallInfo installInfo) {
+        componentName = installInfo.componentName;
+        intent = new Intent(Intent.ACTION_MAIN)
+            .addCategory(Intent.CATEGORY_LAUNCHER)
+            .setComponent(componentName)
+            .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
+                | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
+        setProgressLevel(installInfo);
+        user = installInfo.user;
+    }
+
     @Override
     protected String dumpProperties() {
         return super.dumpProperties() + " componentName=" + componentName;
     }
 
     public WorkspaceItemInfo makeWorkspaceItem() {
-        return new WorkspaceItemInfo(this);
+        WorkspaceItemInfo workspaceItemInfo = new WorkspaceItemInfo(this);
+
+        if ((runtimeStatusFlags & FLAG_INSTALL_SESSION_ACTIVE) != 0) {
+            // We need to update the component name when the apk is installed
+            workspaceItemInfo.status |= WorkspaceItemInfo.FLAG_AUTOINSTALL_ICON;
+            // Since the user is manually placing it on homescreen, it should not be auto-removed
+            // later
+            workspaceItemInfo.status |= WorkspaceItemInfo.FLAG_RESTORE_STARTED;
+            workspaceItemInfo.status |= FLAG_INSTALL_SESSION_ACTIVE;
+        }
+        if ((runtimeStatusFlags & FLAG_INCREMENTAL_DOWNLOAD_ACTIVE) != 0) {
+            workspaceItemInfo.runtimeStatusFlags |= FLAG_INCREMENTAL_DOWNLOAD_ACTIVE;
+        }
+
+        return workspaceItemInfo;
     }
 
     public ComponentKey toComponentKey() {
@@ -129,6 +155,12 @@
                         | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
     }
 
+    @Nullable
+    @Override
+    public ComponentName getTargetComponent() {
+        return componentName;
+    }
+
     public static void updateRuntimeFlagsForActivityTarget(
             ItemInfoWithIcon info, LauncherActivityInfo lai) {
         ApplicationInfo appInfo = lai.getApplicationInfo();
@@ -143,6 +175,11 @@
             // The icon for a non-primary user is badged, hence it's not exactly an adaptive icon.
             info.runtimeStatusFlags |= FLAG_ADAPTIVE_ICON;
         }
+
+        // Sets the progress level, installation and incremental download flags.
+        info.setProgressLevel(
+                PackageManagerHelper.getLoadingProgress(lai),
+                PackageInstallInfo.STATUS_INSTALLED);
     }
 
     @Override
diff --git a/src/com/android/launcher3/model/data/ItemInfoWithIcon.java b/src/com/android/launcher3/model/data/ItemInfoWithIcon.java
index d95f94f..d95e708 100644
--- a/src/com/android/launcher3/model/data/ItemInfoWithIcon.java
+++ b/src/com/android/launcher3/model/data/ItemInfoWithIcon.java
@@ -16,7 +16,15 @@
 
 package com.android.launcher3.model.data;
 
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+
+import androidx.annotation.Nullable;
+
 import com.android.launcher3.icons.BitmapInfo;
+import com.android.launcher3.pm.PackageInstallInfo;
+import com.android.launcher3.util.PackageManagerHelper;
 
 /**
  * Represents an ItemInfo which also holds an icon.
@@ -88,17 +96,42 @@
     public static final int FLAG_ICON_BADGED = 1 << 9;
 
     /**
+     * The icon is being installed. If {@link WorkspaceItemInfo#FLAG_RESTORED_ICON} or
+     * {@link WorkspaceItemInfo#FLAG_AUTOINSTALL_ICON} is set, then the icon is either being
+     * installed or is in a broken state.
+     */
+    public static final int FLAG_INSTALL_SESSION_ACTIVE = 1 << 10;
+
+    /**
+     * This icon is still being downloaded.
+     */
+    public static final int FLAG_INCREMENTAL_DOWNLOAD_ACTIVE = 1 << 11;
+
+    public static final int FLAG_SHOW_DOWNLOAD_PROGRESS_MASK = FLAG_INSTALL_SESSION_ACTIVE
+            | FLAG_INCREMENTAL_DOWNLOAD_ACTIVE;
+
+    /**
      * Status associated with the system state of the underlying item. This is calculated every
      * time a new info is created and not persisted on the disk.
      */
     public int runtimeStatusFlags = 0;
 
+    /**
+     * The download progress of the package that this shortcut represents. For legacy apps, this
+     * will always be the installation progress. For apps that support incremental downloads, this
+     * will only match be the installation progress until the app is installed, then this will the
+     * total download progress.
+     */
+    private int mProgressLevel = 100;
+
     protected ItemInfoWithIcon() { }
 
     protected ItemInfoWithIcon(ItemInfoWithIcon info) {
         super(info);
         bitmap = info.bitmap;
+        mProgressLevel = info.mProgressLevel;
         runtimeStatusFlags = info.runtimeStatusFlags;
+        user = info.user;
     }
 
     @Override
@@ -114,6 +147,72 @@
     }
 
     /**
+     * Returns whether the app this shortcut represents is able to be started. For legacy apps,
+     * this returns whether it is fully installed. For apps that support incremental downloads,
+     * this returns whether the app is either fully downloaded or has installed and is downloading
+     * incrementally.
+     */
+    public boolean isAppStartable() {
+        return ((runtimeStatusFlags & FLAG_INSTALL_SESSION_ACTIVE) == 0)
+                && (((runtimeStatusFlags & FLAG_INCREMENTAL_DOWNLOAD_ACTIVE) != 0)
+                    || mProgressLevel == 100);
+    }
+
+    /**
+     * Returns the download progress for the app this shortcut represents. If this app is not yet
+     * installed or does not support incremental downloads, this will return the installation
+     * progress.
+     */
+    public int getProgressLevel() {
+        if ((runtimeStatusFlags & FLAG_SHOW_DOWNLOAD_PROGRESS_MASK) != 0) {
+            return mProgressLevel;
+        }
+        return 100;
+    }
+
+    /**
+     * Sets the download progress for the app this shortcut represents. If this app is not yet
+     * installed or does not support incremental downloads, this will set
+     * {@code FLAG_INSTALL_SESSION_ACTIVE}. If this app is downloading incrementally, this will
+     * set {@code FLAG_INCREMENTAL_DOWNLOAD_ACTIVE}. Otherwise, this will remove both flags.
+     */
+    public void setProgressLevel(PackageInstallInfo installInfo) {
+        setProgressLevel(installInfo.progress, installInfo.state);
+    }
+
+    /**
+     * Sets the download progress for the app this shortcut represents.
+     */
+    public void setProgressLevel(int progress, int status) {
+        if (status == PackageInstallInfo.STATUS_INSTALLING) {
+            mProgressLevel = progress;
+            runtimeStatusFlags = progress < 100
+                    ? runtimeStatusFlags | FLAG_INSTALL_SESSION_ACTIVE
+                    : runtimeStatusFlags & ~FLAG_INSTALL_SESSION_ACTIVE;
+        } else if (status == PackageInstallInfo.STATUS_INSTALLED_DOWNLOADING) {
+            mProgressLevel = progress;
+            runtimeStatusFlags = runtimeStatusFlags & ~FLAG_INSTALL_SESSION_ACTIVE;
+            runtimeStatusFlags = progress < 100
+                    ? runtimeStatusFlags | FLAG_INCREMENTAL_DOWNLOAD_ACTIVE
+                    : runtimeStatusFlags & ~FLAG_INCREMENTAL_DOWNLOAD_ACTIVE;
+        } else {
+            mProgressLevel = status == PackageInstallInfo.STATUS_INSTALLED ? 100 : 0;
+            runtimeStatusFlags &= ~FLAG_INSTALL_SESSION_ACTIVE;
+            runtimeStatusFlags &= ~FLAG_INCREMENTAL_DOWNLOAD_ACTIVE;
+        }
+    }
+
+    /** Creates an intent to that launches the app store at this app's page. */
+    @Nullable
+    public Intent getMarketIntent(Context context) {
+        ComponentName componentName = getTargetComponent();
+
+        return componentName != null
+                ? new PackageManagerHelper(context).getMarketIntent(componentName.getPackageName())
+                : null;
+    }
+
+    /**
      * @return a copy of this
      */
     public abstract ItemInfoWithIcon clone();
diff --git a/src/com/android/launcher3/model/data/PromiseAppInfo.java b/src/com/android/launcher3/model/data/PromiseAppInfo.java
deleted file mode 100644
index b6231ed..0000000
--- a/src/com/android/launcher3/model/data/PromiseAppInfo.java
+++ /dev/null
@@ -1,54 +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.
- */
-
-package com.android.launcher3.model.data;
-
-import android.content.Context;
-import android.content.Intent;
-
-import androidx.annotation.NonNull;
-
-import com.android.launcher3.pm.PackageInstallInfo;
-import com.android.launcher3.util.PackageManagerHelper;
-
-public class PromiseAppInfo extends AppInfo {
-
-    public int level = 0;
-
-    public PromiseAppInfo(@NonNull PackageInstallInfo installInfo) {
-        componentName = installInfo.componentName;
-        intent = new Intent(Intent.ACTION_MAIN)
-                .addCategory(Intent.CATEGORY_LAUNCHER)
-                .setComponent(componentName)
-                .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
-                        | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
-    }
-
-    @Override
-    public WorkspaceItemInfo makeWorkspaceItem() {
-        WorkspaceItemInfo shortcut = new WorkspaceItemInfo(this);
-        shortcut.setInstallProgress(level);
-        // We need to update the component name when the apk is installed
-        shortcut.status |= WorkspaceItemInfo.FLAG_AUTOINSTALL_ICON;
-        // Since the user is manually placing it on homescreen, it should not be auto-removed later
-        shortcut.status |= WorkspaceItemInfo.FLAG_RESTORE_STARTED;
-        return shortcut;
-    }
-
-    public Intent getMarketIntent(Context context) {
-        return new PackageManagerHelper(context).getMarketIntent(componentName.getPackageName());
-    }
-}
diff --git a/src/com/android/launcher3/model/data/WorkspaceItemInfo.java b/src/com/android/launcher3/model/data/WorkspaceItemInfo.java
index 1e1d093..690e904 100644
--- a/src/com/android/launcher3/model/data/WorkspaceItemInfo.java
+++ b/src/com/android/launcher3/model/data/WorkspaceItemInfo.java
@@ -58,20 +58,14 @@
     public static final int FLAG_AUTOINSTALL_ICON = 1 << 1;
 
     /**
-     * The icon is being installed. If {@link #FLAG_RESTORED_ICON} or {@link #FLAG_AUTOINSTALL_ICON}
-     * is set, then the icon is either being installed or is in a broken state.
-     */
-    public static final int FLAG_INSTALL_SESSION_ACTIVE = 1 << 2;
-
-    /**
      * Indicates that the widget restore has started.
      */
-    public static final int FLAG_RESTORE_STARTED = 1 << 3;
+    public static final int FLAG_RESTORE_STARTED = 1 << 2;
 
     /**
      * Web UI supported.
      */
-    public static final int FLAG_SUPPORTS_WEB_UI = 1 << 4;
+    public static final int FLAG_SUPPORTS_WEB_UI = 1 << 3;
 
     /**
      * The intent used to start the application.
@@ -98,11 +92,6 @@
      */
     @NonNull private String[] personKeys = Utilities.EMPTY_STRING_ARRAY;
 
-    /**
-     * The installation progress [0-100] of the package that this shortcut represents.
-     */
-    private int mInstallProgress;
-
 
     public WorkspaceItemInfo() {
         itemType = LauncherSettings.Favorites.ITEM_TYPE_SHORTCUT;
@@ -114,7 +103,6 @@
         intent = new Intent(info.intent);
         iconResource = info.iconResource;
         status = info.status;
-        mInstallProgress = info.mInstallProgress;
         personKeys = info.personKeys.clone();
     }
 
@@ -168,15 +156,6 @@
         return isPromise() && !hasStatusFlag(FLAG_SUPPORTS_WEB_UI);
     }
 
-    public int getInstallProgress() {
-        return mInstallProgress;
-    }
-
-    public void setInstallProgress(int progress) {
-        mInstallProgress = progress;
-        status |= FLAG_INSTALL_SESSION_ACTIVE;
-    }
-
     public void updateFromDeepShortcutInfo(ShortcutInfo shortcutInfo, Context context) {
         // {@link ShortcutInfo#getActivity} can change during an update. Recreate the intent
         intent = ShortcutKey.makeIntent(shortcutInfo);
diff --git a/src/com/android/launcher3/pm/PackageInstallInfo.java b/src/com/android/launcher3/pm/PackageInstallInfo.java
index 7997d16..fad904f 100644
--- a/src/com/android/launcher3/pm/PackageInstallInfo.java
+++ b/src/com/android/launcher3/pm/PackageInstallInfo.java
@@ -25,7 +25,8 @@
 
     public static final int STATUS_INSTALLED = 0;
     public static final int STATUS_INSTALLING = 1;
-    public static final int STATUS_FAILED = 2;
+    public static final int STATUS_INSTALLED_DOWNLOADING = 2;
+    public static final int STATUS_FAILED = 3;
 
     public final ComponentName componentName;
     public final String packageName;
@@ -56,5 +57,4 @@
     public static PackageInstallInfo fromState(int state, String packageName, UserHandle user) {
         return new PackageInstallInfo(packageName, state, 0 /* progress */, user);
     }
-
 }
diff --git a/src/com/android/launcher3/secondarydisplay/SecondaryDisplayLauncher.java b/src/com/android/launcher3/secondarydisplay/SecondaryDisplayLauncher.java
index b496608..0266345 100644
--- a/src/com/android/launcher3/secondarydisplay/SecondaryDisplayLauncher.java
+++ b/src/com/android/launcher3/secondarydisplay/SecondaryDisplayLauncher.java
@@ -35,8 +35,8 @@
 import com.android.launcher3.model.BgDataModel;
 import com.android.launcher3.model.data.AppInfo;
 import com.android.launcher3.model.data.ItemInfo;
+import com.android.launcher3.model.data.ItemInfoWithIcon;
 import com.android.launcher3.model.data.LauncherAppWidgetInfo;
-import com.android.launcher3.model.data.PromiseAppInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.popup.PopupContainerWithArrow;
 import com.android.launcher3.popup.PopupDataProvider;
@@ -215,8 +215,8 @@
             ArrayList<ItemInfo> addAnimated) { }
 
     @Override
-    public void bindPromiseAppProgressUpdated(PromiseAppInfo app) {
-        mAppsView.getAppsStore().updatePromiseAppProgress(app);
+    public void bindIncrementalDownloadProgressUpdated(AppInfo app) {
+        mAppsView.getAppsStore().updateProgressBar(app);
     }
 
     @Override
@@ -315,9 +315,11 @@
         if (tag instanceof ItemInfo) {
             ItemInfo item = (ItemInfo) tag;
             Intent intent;
-            if (item instanceof PromiseAppInfo) {
-                PromiseAppInfo promiseAppInfo = (PromiseAppInfo) item;
-                intent = promiseAppInfo.getMarketIntent(this);
+            if (item instanceof ItemInfoWithIcon
+                    && (((ItemInfoWithIcon) item).runtimeStatusFlags
+                        & ItemInfoWithIcon.FLAG_INSTALL_SESSION_ACTIVE) != 0) {
+                ItemInfoWithIcon appInfo = (ItemInfoWithIcon) item;
+                intent = appInfo.getMarketIntent(this);
             } else {
                 intent = item.getIntent();
             }
diff --git a/src/com/android/launcher3/touch/AbstractStateChangeTouchController.java b/src/com/android/launcher3/touch/AbstractStateChangeTouchController.java
index 23baaf0..10cd04c 100644
--- a/src/com/android/launcher3/touch/AbstractStateChangeTouchController.java
+++ b/src/com/android/launcher3/touch/AbstractStateChangeTouchController.java
@@ -261,7 +261,9 @@
         mCanBlockFling = mFromState == NORMAL;
         mFlingBlockCheck.unblockFling();
         // Must be called after all the animation controllers have been paused
-        if (FeatureFlags.ENABLE_DEVICE_SEARCH.get() && BuildCompat.isAtLeastR()
+        if (FeatureFlags.ENABLE_DEVICE_SEARCH.get()
+                && !FeatureFlags.DISABLE_INITIAL_IME_IN_ALLAPPS.get()
+                && BuildCompat.isAtLeastR()
                 && (mToState == ALL_APPS || mToState == NORMAL)) {
             mLauncher.getAllAppsController().getInsetController().onDragStart(
                     mFromState == NORMAL ? 1f : 0f);
diff --git a/src/com/android/launcher3/touch/ItemClickHandler.java b/src/com/android/launcher3/touch/ItemClickHandler.java
index 9b9cb0a..4158735 100644
--- a/src/com/android/launcher3/touch/ItemClickHandler.java
+++ b/src/com/android/launcher3/touch/ItemClickHandler.java
@@ -49,8 +49,8 @@
 import com.android.launcher3.model.data.AppInfo;
 import com.android.launcher3.model.data.FolderInfo;
 import com.android.launcher3.model.data.ItemInfo;
+import com.android.launcher3.model.data.ItemInfoWithIcon;
 import com.android.launcher3.model.data.LauncherAppWidgetInfo;
-import com.android.launcher3.model.data.PromiseAppInfo;
 import com.android.launcher3.model.data.RemoteActionItemInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.pm.InstallSessionHelper;
@@ -231,8 +231,12 @@
                     ? shortcut.getIntent().getComponent().getPackageName()
                     : shortcut.getIntent().getPackage();
             if (!TextUtils.isEmpty(packageName)) {
-                onClickPendingAppItem(v, launcher, packageName,
-                        shortcut.hasStatusFlag(WorkspaceItemInfo.FLAG_INSTALL_SESSION_ACTIVE));
+                onClickPendingAppItem(
+                        v,
+                        launcher,
+                        packageName,
+                        (shortcut.runtimeStatusFlags
+                                & ItemInfoWithIcon.FLAG_INSTALL_SESSION_ACTIVE) != 0);
                 return;
             }
         }
@@ -266,9 +270,12 @@
         TestLogging.recordEvent(
                 TestProtocol.SEQUENCE_MAIN, "start: startAppShortcutOrInfoActivity");
         Intent intent;
-        if (item instanceof PromiseAppInfo) {
-            PromiseAppInfo promiseAppInfo = (PromiseAppInfo) item;
-            intent = promiseAppInfo.getMarketIntent(launcher);
+        if (item instanceof ItemInfoWithIcon
+                && (((ItemInfoWithIcon) item).runtimeStatusFlags
+                    & ItemInfoWithIcon.FLAG_INSTALL_SESSION_ACTIVE) != 0) {
+            ItemInfoWithIcon appInfo = (ItemInfoWithIcon) item;
+            intent = new PackageManagerHelper(launcher)
+                    .getMarketIntent(appInfo.getTargetComponent().getPackageName());
         } else {
             intent = item.getIntent();
         }
diff --git a/src/com/android/launcher3/util/PackageManagerHelper.java b/src/com/android/launcher3/util/PackageManagerHelper.java
index 523545a..7b26427 100644
--- a/src/com/android/launcher3/util/PackageManagerHelper.java
+++ b/src/com/android/launcher3/util/PackageManagerHelper.java
@@ -45,10 +45,11 @@
 
 import com.android.launcher3.PendingAddItemInfo;
 import com.android.launcher3.R;
+import com.android.launcher3.Utilities;
 import com.android.launcher3.model.data.AppInfo;
 import com.android.launcher3.model.data.ItemInfo;
+import com.android.launcher3.model.data.ItemInfoWithIcon;
 import com.android.launcher3.model.data.LauncherAppWidgetInfo;
-import com.android.launcher3.model.data.PromiseAppInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 
 import java.net.URISyntaxException;
@@ -200,9 +201,12 @@
      * Starts the details activity for {@code info}
      */
     public void startDetailsActivityForInfo(ItemInfo info, Rect sourceBounds, Bundle opts) {
-        if (info instanceof PromiseAppInfo) {
-            PromiseAppInfo promiseAppInfo = (PromiseAppInfo) info;
-            mContext.startActivity(promiseAppInfo.getMarketIntent(mContext));
+        if (info instanceof ItemInfoWithIcon
+                && (((ItemInfoWithIcon) info).runtimeStatusFlags
+                    & ItemInfoWithIcon.FLAG_INSTALL_SESSION_ACTIVE) != 0) {
+            ItemInfoWithIcon appInfo = (ItemInfoWithIcon) info;
+            mContext.startActivity(new PackageManagerHelper(mContext)
+                    .getMarketIntent(appInfo.getTargetComponent().getPackageName()));
             return;
         }
         ComponentName componentName = null;
@@ -319,4 +323,12 @@
         }
         return false;
     }
+
+    /** Returns the incremental download progress for the given shortcut's app. */
+    public static int getLoadingProgress(LauncherActivityInfo info) {
+        if (Utilities.ATLEAST_S) {
+            return (int) (100 * info.getLoadingProgress());
+        }
+        return 100;
+    }
 }
diff --git a/src_plugins/com/android/systemui/plugins/AllAppsSearchPlugin.java b/src_plugins/com/android/systemui/plugins/AllAppsSearchPlugin.java
index 5cc238d..0b48c07 100644
--- a/src_plugins/com/android/systemui/plugins/AllAppsSearchPlugin.java
+++ b/src_plugins/com/android/systemui/plugins/AllAppsSearchPlugin.java
@@ -19,11 +19,12 @@
 import android.app.Activity;
 import android.os.Bundle;
 import android.os.CancellationSignal;
+import android.os.Parcelable;
 import android.view.View;
 
 import com.android.systemui.plugins.annotations.ProvidesInterface;
-import com.android.systemui.plugins.shared.SearchTarget;
-import com.android.systemui.plugins.shared.SearchTargetEvent;
+import com.android.systemui.plugins.shared.SearchTargetEventLegacy;
+import com.android.systemui.plugins.shared.SearchTargetLegacy;
 
 import java.util.List;
 import java.util.function.Consumer;
@@ -34,20 +35,25 @@
 @ProvidesInterface(action = AllAppsSearchPlugin.ACTION, version = AllAppsSearchPlugin.VERSION)
 public interface AllAppsSearchPlugin extends Plugin {
     String ACTION = "com.android.systemui.action.PLUGIN_ALL_APPS_SEARCH_ACTIONS";
-    int VERSION = 8;
+    int VERSION = 9;
 
-    void setup(Activity activity, View view);
+    /**
+     * init plugin
+     */
+    void setup(Activity activity, View view, boolean useLegacy);
 
     /**
      * Send launcher state related signals.
      */
     void onStateTransitionStart(int fromState, int toState);
+
     void onStateTransitionComplete(int state);
 
     /**
      * Send launcher window focus and visibility changed signals.
      */
     void onWindowFocusChanged(boolean hasFocus);
+
     void onWindowVisibilityChanged(int visibility);
 
     /**
@@ -59,22 +65,41 @@
     /**
      * Main function that triggers search.
      *
-     * @param input string that has been typed by a user
-     * @param inputArgs extra info that may be relevant for the input query
-     * @param results contains the result that will be rendered in all apps search surface
+     * @param input              string that has been typed by a user
+     * @param inputArgs          extra info that may be relevant for the input query
+     * @param results            contains the result that will be rendered in all apps search
+     *                           surface
      * @param cancellationSignal {@link CancellationSignal} can be used to share status of current
      */
-    void query(String input, Bundle inputArgs, Consumer<List<SearchTarget>> results,
+    void queryLegacy(String input, Bundle inputArgs, Consumer<List<SearchTargetLegacy>> results,
+            CancellationSignal cancellationSignal);
+
+    /**
+     * Main function that triggers search.
+     *
+     * @param input              string that has been typed by a user
+     * @param inputArgs          extra info that may be relevant for the input query
+     * @param results            contains the result that will be rendered in all apps search
+     *                           surface
+     * @param cancellationSignal {@link CancellationSignal} can be used to share status of current
+     */
+    void query(String input, Bundle inputArgs, Consumer<List<Parcelable>> results,
             CancellationSignal cancellationSignal);
 
     /**
      * Send over search target interaction events to Plugin
      */
-    void notifySearchTargetEvent(SearchTargetEvent event);
+    void notifySearchTargetEventLegacy(SearchTargetEventLegacy event);
+
+    /**
+     * Send over search target interaction events to Plugin
+     */
+    void notifySearchTargetEvent(Parcelable event);
 
     /**
      * Launcher activity lifecycle callbacks
      */
     void onResume(int state);
+
     void onStop(int state);
 }
\ No newline at end of file
diff --git a/src_plugins/com/android/systemui/plugins/shared/SearchTargetEvent.java b/src_plugins/com/android/systemui/plugins/shared/SearchTargetEventLegacy.java
similarity index 75%
rename from src_plugins/com/android/systemui/plugins/shared/SearchTargetEvent.java
rename to src_plugins/com/android/systemui/plugins/shared/SearchTargetEventLegacy.java
index 290fe54..7fbd6ac 100644
--- a/src_plugins/com/android/systemui/plugins/shared/SearchTargetEvent.java
+++ b/src_plugins/com/android/systemui/plugins/shared/SearchTargetEventLegacy.java
@@ -19,8 +19,11 @@
 
 /**
  * Event used for the feedback loop to the plugin. (and future aiai)
+ *
+ * @deprecated Use SearchTargetEvent
  */
-public class SearchTargetEvent {
+@Deprecated
+public class SearchTargetEventLegacy {
     public static final int POSITION_NONE = -1;
 
     public static final int SELECT = 0;
@@ -28,12 +31,13 @@
     public static final int LONG_PRESS = 2;
     public static final int CHILD_SELECT = 3;
 
-    private final SearchTarget mSearchTarget;
+    private final SearchTargetLegacy mSearchTarget;
     private final int mEventType;
     private final int mShortcutPosition;
     private final Bundle mExtras;
 
-    public SearchTargetEvent(SearchTarget searchTarget, int eventType, int shortcutPosition,
+    public SearchTargetEventLegacy(SearchTargetLegacy searchTarget, int eventType,
+            int shortcutPosition,
             Bundle extras) {
         mSearchTarget = searchTarget;
         mEventType = eventType;
@@ -42,7 +46,7 @@
     }
 
 
-    public SearchTarget getSearchTarget() {
+    public SearchTargetLegacy getSearchTarget() {
         return mSearchTarget;
     }
 
@@ -59,15 +63,15 @@
     }
 
     /**
-     * A builder for {@link SearchTarget}
+     * A builder for {@link SearchTargetLegacy}
      */
     public static final class Builder {
-        private final SearchTarget mSearchTarget;
+        private final SearchTargetLegacy mSearchTarget;
         private final int mEventType;
         private int mShortcutPosition = POSITION_NONE;
         private Bundle mExtras;
 
-        public Builder(SearchTarget searchTarget, int eventType) {
+        public Builder(SearchTargetLegacy searchTarget, int eventType) {
             mSearchTarget = searchTarget;
             mEventType = eventType;
         }
@@ -82,8 +86,9 @@
             return this;
         }
 
-        public SearchTargetEvent build() {
-            return new SearchTargetEvent(mSearchTarget, mEventType, mShortcutPosition, mExtras);
+        public SearchTargetEventLegacy build() {
+            return new SearchTargetEventLegacy(mSearchTarget, mEventType, mShortcutPosition,
+                    mExtras);
         }
     }
 
diff --git a/src_plugins/com/android/systemui/plugins/shared/SearchTarget.java b/src_plugins/com/android/systemui/plugins/shared/SearchTargetLegacy.java
similarity index 89%
rename from src_plugins/com/android/systemui/plugins/shared/SearchTarget.java
rename to src_plugins/com/android/systemui/plugins/shared/SearchTargetLegacy.java
index 2c7972e..2a6ba88 100644
--- a/src_plugins/com/android/systemui/plugins/shared/SearchTarget.java
+++ b/src_plugins/com/android/systemui/plugins/shared/SearchTargetLegacy.java
@@ -25,8 +25,11 @@
 
 /**
  * Used to return all apps search targets.
+ *
+ * @deprecated Use SearchTarget
  */
-public class SearchTarget implements Comparable<SearchTarget> {
+@Deprecated
+public class SearchTargetLegacy implements Comparable<SearchTargetLegacy> {
 
     private final String mItemId;
     private final String mItemType;
@@ -39,7 +42,7 @@
     private final RemoteAction mRemoteAction;
     private final Bundle mExtras;
 
-    private SearchTarget(String itemId, String itemType, float score,
+    private SearchTargetLegacy(String itemId, String itemType, float score,
             ComponentName componentName, UserHandle userHandle, List<ShortcutInfo> shortcutInfos,
             RemoteAction remoteAction, Bundle extras) {
         mItemId = itemId;
@@ -85,12 +88,12 @@
     }
 
     @Override
-    public int compareTo(SearchTarget o) {
+    public int compareTo(SearchTargetLegacy o) {
         return Float.compare(o.mScore, mScore);
     }
 
     /**
-     * A builder for {@link SearchTarget}
+     * A builder for {@link SearchTargetLegacy}
      */
     public static final class Builder {
 
@@ -158,13 +161,13 @@
         }
 
         /**
-         * Builds a {@link SearchTarget}
+         * Builds a {@link SearchTargetLegacy}
          */
-        public SearchTarget build() {
+        public SearchTargetLegacy build() {
             if (mItemId == null) {
                 throw new IllegalStateException("Item ID is required for building SearchTarget");
             }
-            return new SearchTarget(mItemId, mItemType, mScore, mComponentName, mUserHandle,
+            return new SearchTargetLegacy(mItemId, mItemType, mScore, mComponentName, mUserHandle,
                     mShortcutInfos,
                     mRemoteAction, mExtras);
         }
diff --git a/tests/src/com/android/launcher3/ui/WorkTabTest.java b/tests/src/com/android/launcher3/ui/WorkTabTest.java
index ac0d355..aef26ae 100644
--- a/tests/src/com/android/launcher3/ui/WorkTabTest.java
+++ b/tests/src/com/android/launcher3/ui/WorkTabTest.java
@@ -150,11 +150,15 @@
         waitForLauncherCondition("Launcher did not show the next edu screen", l -> {
             Log.d(TestProtocol.WORK_PROFILE_REMOVED,
                     "running test attempt" + attempt.getAndIncrement());
+            if (!(l.getAppsView().getContentView() instanceof AllAppsPagedView)) {
+                Log.d(TestProtocol.WORK_PROFILE_REMOVED, "Work tab not setup. Skipping test");
+                return false;
+            }
             return ((AllAppsPagedView) l.getAppsView().getContentView()).getCurrentPage()
                     == WORK_PAGE && ((TextView) workEduView.findViewById(
                     R.id.content_text)).getText().equals(
                     l.getResources().getString(R.string.work_profile_edu_work_apps));
-        });
+        }, 60000);
     }
 
     @Test
