diff --git a/build.gradle b/build.gradle
index 5bdb7f7f35..605df57222 100644
--- a/build.gradle
+++ b/build.gradle
@@ -278,7 +278,7 @@ android {
         lawn {
             java.srcDirs = ['src_flags', 'src_shortcuts_overrides', 'lawnchair/src', 'tests/shared']
             aidl.srcDirs = ['lawnchair/aidl']
-            res.srcDirs = ['lawnchair/res']
+            res.srcDirs = ['lawnchair/res', 'platform_frameworks_libs_systemui/animationlib/res']
             manifest.srcFile "lawnchair/AndroidManifest.xml"
             assets {
                 srcDirs 'lawnchair/assets'
@@ -354,9 +354,10 @@ dependencies {
     withQuickstepImplementation projects.compatLib.compatLibVV
     withQuickstepImplementation projects.wmshell
     withQuickstepImplementation projects.flags
-    withQuickstepImplementation projects.androidxLib
+//    withQuickstepImplementation projects.androidxLib
+    implementation 'androidx.dynamicanimation:dynamicanimation:1.0.0'
 
-    implementation fileTree(dir: FRAMEWORK_PREBUILTS_DIR, include: 'SystemUI-statsd-14.jar')
+    implementation fileTree(dir: FRAMEWORK_PREBUILTS_DIR, include: 'SystemUI-statsd-15.jar')
     implementation fileTree(dir: FRAMEWORK_PREBUILTS_DIR, include: 'WindowManager-Shell-15.jar')
     withQuickstepCompileOnly fileTree(dir: FRAMEWORK_PREBUILTS_DIR, include: 'framework-15.jar')
 
diff --git a/flags/build.gradle b/flags/build.gradle
index ee1b25c573..d3ace21187 100644
--- a/flags/build.gradle
+++ b/flags/build.gradle
@@ -4,11 +4,10 @@ plugins {
 }
 
 android {
-    namespace "com.android.launcher3"
+    namespace "com.android.launcher3.flags"
     sourceSets {
         main {
             java.srcDirs = ['src']
-            res.srcDirs = ['res']
         }
     }
 }
diff --git a/flags/src/com/android/wm/shell/CustomFeatureFlags.java b/flags/src/com/android/wm/shell/CustomFeatureFlags.java
new file mode 100644
index 0000000000..e8a55c4591
--- /dev/null
+++ b/flags/src/com/android/wm/shell/CustomFeatureFlags.java
@@ -0,0 +1,174 @@
+package com.android.wm.shell;
+
+// TODO(b/303773055): Remove the annotation after access issue is resolved.
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.BiPredicate;
+import java.util.function.Predicate;
+
+/** @hide */
+public class CustomFeatureFlags implements FeatureFlags {
+
+    private BiPredicate<String, Predicate<FeatureFlags>> mGetValueImpl;
+
+    public CustomFeatureFlags(BiPredicate<String, Predicate<FeatureFlags>> getValueImpl) {
+        mGetValueImpl = getValueImpl;
+    }
+    @Override
+
+    public boolean animateBubbleSizeChange() {
+        return getValue(Flags.FLAG_ANIMATE_BUBBLE_SIZE_CHANGE,
+                FeatureFlags::animateBubbleSizeChange);
+    }
+
+    @Override
+    
+    public boolean enableAppPairs() {
+        return getValue(Flags.FLAG_ENABLE_APP_PAIRS,
+                FeatureFlags::enableAppPairs);
+    }
+
+    @Override
+    
+    public boolean enableBubbleAnything() {
+        return getValue(Flags.FLAG_ENABLE_BUBBLE_ANYTHING,
+                FeatureFlags::enableBubbleAnything);
+    }
+
+    @Override
+    
+    public boolean enableBubbleBar() {
+        return getValue(Flags.FLAG_ENABLE_BUBBLE_BAR,
+                FeatureFlags::enableBubbleBar);
+    }
+
+    @Override
+    
+    public boolean enableBubbleStashing() {
+        return getValue(Flags.FLAG_ENABLE_BUBBLE_STASHING,
+                FeatureFlags::enableBubbleStashing);
+    }
+
+    @Override
+    
+    public boolean enableBubblesLongPressNavHandle() {
+        return getValue(Flags.FLAG_ENABLE_BUBBLES_LONG_PRESS_NAV_HANDLE,
+                FeatureFlags::enableBubblesLongPressNavHandle);
+    }
+
+    @Override
+    
+    public boolean enableLeftRightSplitInPortrait() {
+        return getValue(Flags.FLAG_ENABLE_LEFT_RIGHT_SPLIT_IN_PORTRAIT,
+                FeatureFlags::enableLeftRightSplitInPortrait);
+    }
+
+    @Override
+    
+    public boolean enableNewBubbleAnimations() {
+        return getValue(Flags.FLAG_ENABLE_NEW_BUBBLE_ANIMATIONS,
+                FeatureFlags::enableNewBubbleAnimations);
+    }
+
+    @Override
+    
+    public boolean enableOptionalBubbleOverflow() {
+        return getValue(Flags.FLAG_ENABLE_OPTIONAL_BUBBLE_OVERFLOW,
+                FeatureFlags::enableOptionalBubbleOverflow);
+    }
+
+    @Override
+    
+    public boolean enablePip2Implementation() {
+        return getValue(Flags.FLAG_ENABLE_PIP2_IMPLEMENTATION,
+                FeatureFlags::enablePip2Implementation);
+    }
+
+    @Override
+    
+    public boolean enablePipUmoExperience() {
+        return getValue(Flags.FLAG_ENABLE_PIP_UMO_EXPERIENCE,
+                FeatureFlags::enablePipUmoExperience);
+    }
+
+    @Override
+    
+    public boolean enableRetrievableBubbles() {
+        return getValue(Flags.FLAG_ENABLE_RETRIEVABLE_BUBBLES,
+                FeatureFlags::enableRetrievableBubbles);
+    }
+
+    @Override
+    
+    public boolean enableSplitContextual() {
+        return getValue(Flags.FLAG_ENABLE_SPLIT_CONTEXTUAL,
+                FeatureFlags::enableSplitContextual);
+    }
+
+    @Override
+    
+    public boolean enableTaskbarNavbarUnification() {
+        return getValue(Flags.FLAG_ENABLE_TASKBAR_NAVBAR_UNIFICATION,
+                FeatureFlags::enableTaskbarNavbarUnification);
+    }
+
+    @Override
+    
+    public boolean enableTinyTaskbar() {
+        return getValue(Flags.FLAG_ENABLE_TINY_TASKBAR,
+                FeatureFlags::enableTinyTaskbar);
+    }
+
+    @Override
+    
+    public boolean onlyReuseBubbledTaskWhenLaunchedFromBubble() {
+        return getValue(Flags.FLAG_ONLY_REUSE_BUBBLED_TASK_WHEN_LAUNCHED_FROM_BUBBLE,
+                FeatureFlags::onlyReuseBubbledTaskWhenLaunchedFromBubble);
+    }
+
+    public boolean isFlagReadOnlyOptimized(String flagName) {
+        if (mReadOnlyFlagsSet.contains(flagName) &&
+                isOptimizationEnabled()) {
+            return true;
+        }
+        return false;
+    }
+
+    private boolean isOptimizationEnabled() {
+        return false;
+    }
+
+    protected boolean getValue(String flagName, Predicate<FeatureFlags> getter) {
+        return mGetValueImpl.test(flagName, getter);
+    }
+
+    public List<String> getFlagNames() {
+        return Arrays.asList(
+                Flags.FLAG_ANIMATE_BUBBLE_SIZE_CHANGE,
+                Flags.FLAG_ENABLE_APP_PAIRS,
+                Flags.FLAG_ENABLE_BUBBLE_ANYTHING,
+                Flags.FLAG_ENABLE_BUBBLE_BAR,
+                Flags.FLAG_ENABLE_BUBBLE_STASHING,
+                Flags.FLAG_ENABLE_BUBBLES_LONG_PRESS_NAV_HANDLE,
+                Flags.FLAG_ENABLE_LEFT_RIGHT_SPLIT_IN_PORTRAIT,
+                Flags.FLAG_ENABLE_NEW_BUBBLE_ANIMATIONS,
+                Flags.FLAG_ENABLE_OPTIONAL_BUBBLE_OVERFLOW,
+                Flags.FLAG_ENABLE_PIP2_IMPLEMENTATION,
+                Flags.FLAG_ENABLE_PIP_UMO_EXPERIENCE,
+                Flags.FLAG_ENABLE_RETRIEVABLE_BUBBLES,
+                Flags.FLAG_ENABLE_SPLIT_CONTEXTUAL,
+                Flags.FLAG_ENABLE_TASKBAR_NAVBAR_UNIFICATION,
+                Flags.FLAG_ENABLE_TINY_TASKBAR,
+                Flags.FLAG_ONLY_REUSE_BUBBLED_TASK_WHEN_LAUNCHED_FROM_BUBBLE
+        );
+    }
+
+    private Set<String> mReadOnlyFlagsSet = new HashSet<>(
+            Arrays.asList(
+                    Flags.FLAG_ENABLE_PIP2_IMPLEMENTATION,
+                    ""
+            )
+    );
+}
diff --git a/flags/src/com/android/wm/shell/FakeFeatureFlagsImpl.java b/flags/src/com/android/wm/shell/FakeFeatureFlagsImpl.java
new file mode 100644
index 0000000000..c4594f283f
--- /dev/null
+++ b/flags/src/com/android/wm/shell/FakeFeatureFlagsImpl.java
@@ -0,0 +1,49 @@
+package com.android.wm.shell;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Predicate;
+
+/** @hide */
+public class FakeFeatureFlagsImpl extends CustomFeatureFlags {
+    private final Map<String, Boolean> mFlagMap = new HashMap<>();
+    private final FeatureFlags mDefaults;
+
+    public FakeFeatureFlagsImpl() {
+        this(null);
+    }
+
+    public FakeFeatureFlagsImpl(FeatureFlags defaults) {
+        super(null);
+        mDefaults = defaults;
+        // Initialize the map with null values
+        for (String flagName : getFlagNames()) {
+            mFlagMap.put(flagName, null);
+        }
+    }
+
+    @Override
+    protected boolean getValue(String flagName, Predicate<FeatureFlags> getter) {
+        Boolean value = this.mFlagMap.get(flagName);
+        if (value != null) {
+            return value;
+        }
+        if (mDefaults != null) {
+            return getter.test(mDefaults);
+        }
+        throw new IllegalArgumentException(flagName + " is not set");
+    }
+
+    public void setFlag(String flagName, boolean value) {
+        if (!this.mFlagMap.containsKey(flagName)) {
+            throw new IllegalArgumentException("no such flag " + flagName);
+        }
+        this.mFlagMap.put(flagName, value);
+    }
+
+    public void resetAll() {
+        for (Map.Entry entry : mFlagMap.entrySet()) {
+            entry.setValue(null);
+        }
+    }
+}
diff --git a/flags/src/com/android/wm/shell/FeatureFlags.java b/flags/src/com/android/wm/shell/FeatureFlags.java
new file mode 100644
index 0000000000..5c5ba5bcc0
--- /dev/null
+++ b/flags/src/com/android/wm/shell/FeatureFlags.java
@@ -0,0 +1,53 @@
+package com.android.wm.shell;
+// TODO(b/303773055): Remove the annotation after access issue is resolved.
+/** @hide */
+public interface FeatureFlags {
+
+
+    
+    boolean animateBubbleSizeChange();
+    
+    
+    boolean enableAppPairs();
+    
+    
+    boolean enableBubbleAnything();
+    
+    
+    boolean enableBubbleBar();
+    
+    
+    boolean enableBubbleStashing();
+    
+    
+    boolean enableBubblesLongPressNavHandle();
+    
+    
+    boolean enableLeftRightSplitInPortrait();
+    
+    
+    boolean enableNewBubbleAnimations();
+    
+    
+    boolean enableOptionalBubbleOverflow();
+    
+    boolean enablePip2Implementation();
+    
+    
+    boolean enablePipUmoExperience();
+    
+    
+    boolean enableRetrievableBubbles();
+    
+    
+    boolean enableSplitContextual();
+    
+    
+    boolean enableTaskbarNavbarUnification();
+    
+    
+    boolean enableTinyTaskbar();
+    
+    
+    boolean onlyReuseBubbledTaskWhenLaunchedFromBubble();
+}
diff --git a/flags/src/com/android/wm/shell/FeatureFlagsImpl.java b/flags/src/com/android/wm/shell/FeatureFlagsImpl.java
new file mode 100644
index 0000000000..26af996c32
--- /dev/null
+++ b/flags/src/com/android/wm/shell/FeatureFlagsImpl.java
@@ -0,0 +1,393 @@
+package com.android.wm.shell;
+// TODO(b/303773055): Remove the annotation after access issue is resolved.
+import android.provider.DeviceConfig;
+import android.provider.DeviceConfig.Properties;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+/** @hide */
+public final class FeatureFlagsImpl implements FeatureFlags {
+    private static final boolean isReadFromNew = Files.exists(Paths.get("/metadata/aconfig/boot/enable_only_new_storage"));
+    private static volatile boolean isCached = false;
+    private static volatile boolean multitasking_is_cached = false;
+    private static boolean animateBubbleSizeChange = false;
+    private static boolean enableAppPairs = true;
+    private static boolean enableBubbleAnything = false;
+    private static boolean enableBubbleBar = false;
+    private static boolean enableBubbleStashing = false;
+    private static boolean enableBubblesLongPressNavHandle = false;
+    private static boolean enableLeftRightSplitInPortrait = true;
+    private static boolean enableNewBubbleAnimations = false;
+    private static boolean enableOptionalBubbleOverflow = true;
+    private static boolean enablePipUmoExperience = false;
+    private static boolean enableRetrievableBubbles = false;
+    private static boolean enableSplitContextual = true;
+    private static boolean enableTaskbarNavbarUnification = true;
+    private static boolean enableTinyTaskbar = false;
+    private static boolean onlyReuseBubbledTaskWhenLaunchedFromBubble = false;
+
+
+    private void init() {
+        boolean foundPackage = true;
+
+        animateBubbleSizeChange = foundPackage;
+
+
+        enableAppPairs = foundPackage;
+
+
+        enableBubbleAnything = foundPackage;
+
+
+        enableBubbleBar = foundPackage;
+
+
+        enableBubbleStashing = foundPackage;
+
+
+        enableBubblesLongPressNavHandle = foundPackage ;
+
+
+        enableLeftRightSplitInPortrait = foundPackage;
+
+
+        enableNewBubbleAnimations = foundPackage;
+
+
+        enableOptionalBubbleOverflow = foundPackage;
+
+
+
+        enablePipUmoExperience = foundPackage;
+
+
+        enableRetrievableBubbles = foundPackage;
+
+
+        enableSplitContextual = foundPackage;
+
+
+        enableTaskbarNavbarUnification = foundPackage;
+
+
+        enableTinyTaskbar = foundPackage;
+
+
+        onlyReuseBubbledTaskWhenLaunchedFromBubble = foundPackage ;
+
+        isCached = true;
+    }
+
+
+
+
+    private void load_overrides_multitasking() {
+        try {
+            Properties properties = DeviceConfig.getProperties("multitasking");
+            animateBubbleSizeChange =
+                    properties.getBoolean(Flags.FLAG_ANIMATE_BUBBLE_SIZE_CHANGE, false);
+            enableAppPairs =
+                    properties.getBoolean(Flags.FLAG_ENABLE_APP_PAIRS, true);
+            enableBubbleAnything =
+                    properties.getBoolean(Flags.FLAG_ENABLE_BUBBLE_ANYTHING, false);
+            enableBubbleBar =
+                    properties.getBoolean(Flags.FLAG_ENABLE_BUBBLE_BAR, false);
+            enableBubbleStashing =
+                    properties.getBoolean(Flags.FLAG_ENABLE_BUBBLE_STASHING, false);
+            enableBubblesLongPressNavHandle =
+                    properties.getBoolean(Flags.FLAG_ENABLE_BUBBLES_LONG_PRESS_NAV_HANDLE, false);
+            enableLeftRightSplitInPortrait =
+                    properties.getBoolean(Flags.FLAG_ENABLE_LEFT_RIGHT_SPLIT_IN_PORTRAIT, true);
+            enableNewBubbleAnimations =
+                    properties.getBoolean(Flags.FLAG_ENABLE_NEW_BUBBLE_ANIMATIONS, false);
+            enableOptionalBubbleOverflow =
+                    properties.getBoolean(Flags.FLAG_ENABLE_OPTIONAL_BUBBLE_OVERFLOW, true);
+            enablePipUmoExperience =
+                    properties.getBoolean(Flags.FLAG_ENABLE_PIP_UMO_EXPERIENCE, false);
+            enableRetrievableBubbles =
+                    properties.getBoolean(Flags.FLAG_ENABLE_RETRIEVABLE_BUBBLES, false);
+            enableSplitContextual =
+                    properties.getBoolean(Flags.FLAG_ENABLE_SPLIT_CONTEXTUAL, true);
+            enableTaskbarNavbarUnification =
+                    properties.getBoolean(Flags.FLAG_ENABLE_TASKBAR_NAVBAR_UNIFICATION, true);
+            enableTinyTaskbar =
+                    properties.getBoolean(Flags.FLAG_ENABLE_TINY_TASKBAR, false);
+            onlyReuseBubbledTaskWhenLaunchedFromBubble =
+                    properties.getBoolean(Flags.FLAG_ONLY_REUSE_BUBBLED_TASK_WHEN_LAUNCHED_FROM_BUBBLE, false);
+        } catch (NullPointerException e) {
+            throw new RuntimeException(
+                    "Cannot read value from namespace multitasking "
+                            + "from DeviceConfig. It could be that the code using flag "
+                            + "executed before SettingsProvider initialization. Please use "
+                            + "fixed read-only flag by adding is_fixed_read_only: true in "
+                            + "flag declaration.",
+                    e
+            );
+        }
+        multitasking_is_cached = true;
+    }
+
+    @Override
+    
+    
+    public boolean animateBubbleSizeChange() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return animateBubbleSizeChange;
+
+    }
+
+    @Override
+    
+    
+    public boolean enableAppPairs() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enableAppPairs;
+
+    }
+
+    @Override
+    
+    
+    public boolean enableBubbleAnything() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enableBubbleAnything;
+
+    }
+
+    @Override
+    
+    
+    public boolean enableBubbleBar() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enableBubbleBar;
+
+    }
+
+    @Override
+    
+    
+    public boolean enableBubbleStashing() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enableBubbleStashing;
+
+    }
+
+    @Override
+    
+    
+    public boolean enableBubblesLongPressNavHandle() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enableBubblesLongPressNavHandle;
+
+    }
+
+    @Override
+    
+    
+    public boolean enableLeftRightSplitInPortrait() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enableLeftRightSplitInPortrait;
+
+    }
+
+    @Override
+    
+    
+    public boolean enableNewBubbleAnimations() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enableNewBubbleAnimations;
+
+    }
+
+    @Override
+    
+    
+    public boolean enableOptionalBubbleOverflow() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enableOptionalBubbleOverflow;
+
+    }
+
+    @Override
+    
+    
+    public boolean enablePip2Implementation() {
+        return false;
+
+    }
+
+    @Override
+    
+    
+    public boolean enablePipUmoExperience() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enablePipUmoExperience;
+
+    }
+
+    @Override
+    
+    
+    public boolean enableRetrievableBubbles() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enableRetrievableBubbles;
+
+    }
+
+    @Override
+    
+    
+    public boolean enableSplitContextual() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enableSplitContextual;
+
+    }
+
+    @Override
+    
+    
+    public boolean enableTaskbarNavbarUnification() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enableTaskbarNavbarUnification;
+
+    }
+
+    @Override
+    
+    
+    public boolean enableTinyTaskbar() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return enableTinyTaskbar;
+
+    }
+
+    @Override
+    
+    
+    public boolean onlyReuseBubbledTaskWhenLaunchedFromBubble() {
+        if (isReadFromNew) {
+            if (!isCached) {
+                init();
+            }
+        } else {
+            if (!multitasking_is_cached) {
+                load_overrides_multitasking();
+            }
+        }
+        return onlyReuseBubbledTaskWhenLaunchedFromBubble;
+
+    }
+
+}
+
diff --git a/flags/src/com/android/wm/shell/Flags.java b/flags/src/com/android/wm/shell/Flags.java
new file mode 100644
index 0000000000..5dd4ab7470
--- /dev/null
+++ b/flags/src/com/android/wm/shell/Flags.java
@@ -0,0 +1,119 @@
+package com.android.wm.shell;
+// TODO(b/303773055): Remove the annotation after access issue is resolved.
+/** @hide */
+public final class Flags {
+    /** @hide */
+    public static final String FLAG_ANIMATE_BUBBLE_SIZE_CHANGE = "com.android.wm.shell.animate_bubble_size_change";
+    /** @hide */
+    public static final String FLAG_ENABLE_APP_PAIRS = "com.android.wm.shell.enable_app_pairs";
+    /** @hide */
+    public static final String FLAG_ENABLE_BUBBLE_ANYTHING = "com.android.wm.shell.enable_bubble_anything";
+    /** @hide */
+    public static final String FLAG_ENABLE_BUBBLE_BAR = "com.android.wm.shell.enable_bubble_bar";
+    /** @hide */
+    public static final String FLAG_ENABLE_BUBBLE_STASHING = "com.android.wm.shell.enable_bubble_stashing";
+    /** @hide */
+    public static final String FLAG_ENABLE_BUBBLES_LONG_PRESS_NAV_HANDLE = "com.android.wm.shell.enable_bubbles_long_press_nav_handle";
+    /** @hide */
+    public static final String FLAG_ENABLE_LEFT_RIGHT_SPLIT_IN_PORTRAIT = "com.android.wm.shell.enable_left_right_split_in_portrait";
+    /** @hide */
+    public static final String FLAG_ENABLE_NEW_BUBBLE_ANIMATIONS = "com.android.wm.shell.enable_new_bubble_animations";
+    /** @hide */
+    public static final String FLAG_ENABLE_OPTIONAL_BUBBLE_OVERFLOW = "com.android.wm.shell.enable_optional_bubble_overflow";
+    /** @hide */
+    public static final String FLAG_ENABLE_PIP2_IMPLEMENTATION = "com.android.wm.shell.enable_pip2_implementation";
+    /** @hide */
+    public static final String FLAG_ENABLE_PIP_UMO_EXPERIENCE = "com.android.wm.shell.enable_pip_umo_experience";
+    /** @hide */
+    public static final String FLAG_ENABLE_RETRIEVABLE_BUBBLES = "com.android.wm.shell.enable_retrievable_bubbles";
+    /** @hide */
+    public static final String FLAG_ENABLE_SPLIT_CONTEXTUAL = "com.android.wm.shell.enable_split_contextual";
+    /** @hide */
+    public static final String FLAG_ENABLE_TASKBAR_NAVBAR_UNIFICATION = "com.android.wm.shell.enable_taskbar_navbar_unification";
+    /** @hide */
+    public static final String FLAG_ENABLE_TINY_TASKBAR = "com.android.wm.shell.enable_tiny_taskbar";
+    /** @hide */
+    public static final String FLAG_ONLY_REUSE_BUBBLED_TASK_WHEN_LAUNCHED_FROM_BUBBLE = "com.android.wm.shell.only_reuse_bubbled_task_when_launched_from_bubble";
+    
+    
+    public static boolean animateBubbleSizeChange() {
+        return FEATURE_FLAGS.animateBubbleSizeChange();
+    }
+    
+    
+    public static boolean enableAppPairs() {
+        return FEATURE_FLAGS.enableAppPairs();
+    }
+    
+    
+    public static boolean enableBubbleAnything() {
+        return FEATURE_FLAGS.enableBubbleAnything();
+    }
+    
+    
+    public static boolean enableBubbleBar() {
+        return FEATURE_FLAGS.enableBubbleBar();
+    }
+    
+    
+    public static boolean enableBubbleStashing() {
+        return FEATURE_FLAGS.enableBubbleStashing();
+    }
+    
+    
+    public static boolean enableBubblesLongPressNavHandle() {
+        return FEATURE_FLAGS.enableBubblesLongPressNavHandle();
+    }
+    
+    
+    public static boolean enableLeftRightSplitInPortrait() {
+        return FEATURE_FLAGS.enableLeftRightSplitInPortrait();
+    }
+    
+    
+    public static boolean enableNewBubbleAnimations() {
+        return FEATURE_FLAGS.enableNewBubbleAnimations();
+    }
+    
+    
+    public static boolean enableOptionalBubbleOverflow() {
+        return FEATURE_FLAGS.enableOptionalBubbleOverflow();
+    }
+    
+    public static boolean enablePip2Implementation() {
+        return FEATURE_FLAGS.enablePip2Implementation();
+    }
+    
+    
+    public static boolean enablePipUmoExperience() {
+        return FEATURE_FLAGS.enablePipUmoExperience();
+    }
+    
+    
+    public static boolean enableRetrievableBubbles() {
+        return FEATURE_FLAGS.enableRetrievableBubbles();
+    }
+    
+    
+    public static boolean enableSplitContextual() {
+        return FEATURE_FLAGS.enableSplitContextual();
+    }
+    
+    
+    public static boolean enableTaskbarNavbarUnification() {
+        return FEATURE_FLAGS.enableTaskbarNavbarUnification();
+    }
+    
+    
+    public static boolean enableTinyTaskbar() {
+        return FEATURE_FLAGS.enableTinyTaskbar();
+    }
+    
+    
+    public static boolean onlyReuseBubbledTaskWhenLaunchedFromBubble() {
+        return FEATURE_FLAGS.onlyReuseBubbledTaskWhenLaunchedFromBubble();
+    }
+
+    private static FeatureFlags FEATURE_FLAGS = new FeatureFlagsImpl();
+
+}
diff --git a/lawnchair/res/layout/overview_actions_container.xml b/lawnchair/res/layout/overview_actions_container.xml
deleted file mode 100644
index 2b40529519..0000000000
--- a/lawnchair/res/layout/overview_actions_container.xml
+++ /dev/null
@@ -1,128 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-     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.
--->
-<!-- NOTE! don't add dimensions for margins / gravity to root view in this file, they need to be
-     loaded at runtime. -->
-<app.lawnchair.overview.LawnchairOverviewActionsView xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:layout_gravity="center_horizontal|bottom">
-
-    <LinearLayout
-        android:id="@+id/action_buttons"
-        android:layout_width="match_parent"
-        android:layout_height="@dimen/overview_actions_height"
-        android:layout_gravity="bottom|center_horizontal"
-        android:orientation="horizontal">
-
-        <Space
-            android:layout_width="0dp"
-            android:layout_height="1dp"
-            android:layout_weight="1" />
-
-        <app.lawnchair.views.CustomButton
-            android:id="@+id/action_screenshot"
-            style="@style/OverviewActionButton"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:drawableStart="@drawable/ic_screenshot"
-            android:text="@string/action_screenshot" />
-
-        <Space
-            android:layout_width="0dp"
-            android:layout_height="1dp"
-            android:layout_weight="1"
-            android:visibility="gone" />
-
-        <app.lawnchair.views.CustomButton
-            android:id="@+id/action_share"
-            style="@style/OverviewActionButton"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:drawableStart="@drawable/ic_share"
-            android:text="@string/action_share" />
-
-        <Space
-            android:id="@+id/oav_three_button_space"
-            android:layout_width="0dp"
-            android:layout_height="1dp"
-            android:layout_weight="1" />
-
-        <Button
-            android:id="@+id/action_split"
-            style="@style/OverviewActionButton"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:text="@string/action_split"
-            android:theme="@style/ThemeControlHighlightWorkspaceColor"
-            android:visibility="gone" />
-
-        <Space
-            android:id="@+id/action_split_space"
-            android:layout_width="@dimen/overview_actions_button_spacing"
-            android:layout_height="1dp"
-            android:visibility="gone" />
-
-        <app.lawnchair.views.CustomButton
-            android:id="@+id/action_lens"
-            style="@style/OverviewActionButton"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:drawableStart="@drawable/ic_lens"
-            android:text="@string/action_lens" />
-
-        <Space
-            android:id="@+id/lens_space"
-            android:layout_width="0dp"
-            android:layout_height="1dp"
-            android:layout_weight="1"
-            android:visibility="gone" />
-
-        <app.lawnchair.views.CustomButton
-            style="@style/OverviewActionButton"
-            android:id="@+id/action_clear_all"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:text="@string/recents_clear_all"
-            android:drawableStart="@drawable/ic_clear_all_recents"
-            android:visibility="gone"
-            />
-
-        <Space
-            android:id="@+id/clear_all_space"
-            android:layout_width="0dp"
-            android:layout_height="1dp"
-            android:layout_weight="1"
-            android:visibility="gone" />
-
-        <app.lawnchair.views.CustomButton
-            style="@style/OverviewActionButton"
-            android:id="@+id/action_locked"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:text="@string/action_lock"
-            android:drawableStart="@drawable/ic_locked_recents"
-            android:visibility="gone" />
-
-        <Space
-            android:id="@+id/locked_space"
-            android:layout_width="0dp"
-            android:layout_height="1dp"
-            android:layout_weight="1"
-            android:visibility="gone" />
-    </LinearLayout>
-
-</app.lawnchair.overview.LawnchairOverviewActionsView>
diff --git a/lawnchair/res/values/config.xml b/lawnchair/res/values/config.xml
index 35b15eab75..3d6b155e14 100644
--- a/lawnchair/res/values/config.xml
+++ b/lawnchair/res/values/config.xml
@@ -18,6 +18,7 @@
 <resources>
     <string name="app_filter_class" translatable="false">app.lawnchair.DefaultAppFilter</string>
     <string name="calendar_component_name" translatable="false">com.google.android.calendar/com.android.calendar.AllInOneActivity</string>
+    <dimen name="settingslib_preferred_minimum_touch_target">48dp</dimen>
     <string-array name="dynamic_calendar_components_name">
         <item>com.android.calendar</item>
         <item>com.blackberry.calendar</item>
@@ -32,11 +33,14 @@
         <item>org.withouthat.acalendar</item>
         <item>ws.xsoh.etar</item>
     </string-array>
+    <!-- String representing the intent for search on the apps market. To specify a query, add
+    q=<query> to the data to the intent -->
+    <string name="market_search_intent" translatable="false">market://search?c=apps</string>
     <string name="icon_packs_intent_name" translatable="false">app.lawnchair.icons.THEMED_ICON</string>
     <string name="clock_component_name" translatable="false">com.google.android.deskclock/com.android.deskclock.DeskClock</string>
     <string name="launcher_activity_logic_class" translatable="false">app.lawnchair.LauncherActivityCachingLogic</string>
     <string name="main_process_initializer_class" translatable="false">app.lawnchair.LawnchairProcessInitializer</string>
-    <string name="task_overlay_factory_class" translatable="false">app.lawnchair.overview.TaskOverlayFactoryImpl</string>
+<!--    <string name="task_overlay_factory_class" translatable="false">app.lawnchair.overview.TaskOverlayFactoryImpl</string>-->
     <string name="wallpaper_picker_package" translatable="false">com.android.wallpaper</string>
     <string name="wallpaper_picker_package_alt" translatable="false">com.google.android.apps.wallpaper</string>
     <string name="widget_holder_factory_class" translatable="false">app.lawnchair.factory.LawnchairWidgetHolder$LawnchairHolderFactory</string>
@@ -55,6 +59,8 @@
         <item>@string/launcher_component</item>
     </string-array>
 
+    <dimen name="page_indicator_dot_size_v2">6dp</dimen>
+
     <!-- Which QSB search provider to use by default -->
     <string name="config_default_qsb_search_provider_id" translatable="false">startpage</string>
 
diff --git a/lawnchair/src/app/lawnchair/AccentColorExtractor.java b/lawnchair/src/app/lawnchair/AccentColorExtractor.java
index 7d81b2217e..98c51992b5 100644
--- a/lawnchair/src/app/lawnchair/AccentColorExtractor.java
+++ b/lawnchair/src/app/lawnchair/AccentColorExtractor.java
@@ -42,25 +42,12 @@ import dev.kdrag0n.monet.theme.ColorScheme;
 public class AccentColorExtractor extends LocalColorExtractor implements ThemeProvider.ColorSchemeChangeListener {
 
     private final ThemeProvider mThemeProvider;
-    private final RectF mTmpRect = new RectF();
-    private Listener mListener;
 
     @Keep
     public AccentColorExtractor(Context context) {
         mThemeProvider = ThemeProvider.INSTANCE.get(context);
     }
 
-    @Override
-    public void setListener(@Nullable Listener listener) {
-        mListener = listener;
-        notifyListener();
-    }
-
-    @Override
-    public void setWorkspaceLocation(Rect pos, View child, int screenId) {
-
-    }
-
     @Nullable
     protected SparseIntArray generateColorsOverride(ColorScheme colorScheme) {
         SparseIntArray colorRes = new SparseIntArray(5 * 13);
@@ -84,15 +71,7 @@ public class AccentColorExtractor extends LocalColorExtractor implements ThemePr
     }
 
     @Override
-    public void onColorSchemeChanged() {
-        notifyListener();
-    }
-
-    private void notifyListener() {
-        if (mListener != null) {
-            mListener.onColorsChanged(generateColorsOverride(mThemeProvider.getColorScheme()));
-        }
-    }
+    public void onColorSchemeChanged() {}
 
     // Shade number -> color resource ID maps
     private static final SparseIntArray ACCENT1_RES = new SparseIntArray(13);
diff --git a/lawnchair/src/app/lawnchair/DeviceProfileOverrides.kt b/lawnchair/src/app/lawnchair/DeviceProfileOverrides.kt
index 8dd18b3618..fbae2b108c 100644
--- a/lawnchair/src/app/lawnchair/DeviceProfileOverrides.kt
+++ b/lawnchair/src/app/lawnchair/DeviceProfileOverrides.kt
@@ -104,8 +104,8 @@ class DeviceProfileOverrides(context: Context) : SafeCloseable {
             // apply grid size
             idp.numAllAppsColumns = numAllAppsColumns
             idp.numDatabaseAllAppsColumns = numAllAppsColumns
-            idp.numFolderRows = numFolderRows
-            idp.numFolderColumns = numFolderColumns
+            idp.numFolderRows[INDEX_DEFAULT] = numFolderRows
+            idp.numFolderColumns[INDEX_DEFAULT] = numFolderColumns
 
             // apply icon and text size
             idp.iconSize[INDEX_DEFAULT] *= iconSizeFactor
diff --git a/lawnchair/src/app/lawnchair/bubbles/DismissView.kt b/lawnchair/src/app/lawnchair/bubbles/DismissView.kt
index 93c01c11b6..af1d559626 100644
--- a/lawnchair/src/app/lawnchair/bubbles/DismissView.kt
+++ b/lawnchair/src/app/lawnchair/bubbles/DismissView.kt
@@ -51,6 +51,8 @@ class DismissView(context: Context) : FrameLayout(context) {
      * @see [setup] method
      */
     data class Config(
+        /** The resource id to set on the dismiss target circle view */
+        val dismissViewResId: Int,
         /** dimen resource id of the dismiss target circle view size */
         @DimenRes val targetSizeResId: Int,
         /** dimen resource id of the icon size in the dismiss target */
@@ -64,27 +66,27 @@ class DismissView(context: Context) : FrameLayout(context) {
         /** drawable resource id of the dismiss target background */
         @DrawableRes val backgroundResId: Int,
         /** drawable resource id of the icon for the dismiss target */
-        @DrawableRes val iconResId: Int,
+        @DrawableRes val iconResId: Int
     )
 
     companion object {
         private const val SHOULD_SETUP =
             "The view isn't ready. Should be called after `setup`"
         private val TAG = DismissView::class.simpleName
-        private const val DISMISS_SCRIM_FADE_MS = 200L
     }
 
     var circle = DismissCircleView(context)
-    private var isShowing = false
+    var isShowing = false
     var config: Config? = null
 
     private val animator = PhysicsAnimator.getInstance(circle)
     private val spring = PhysicsAnimator.SpringConfig(STIFFNESS_LOW, DAMPING_RATIO_LOW_BOUNCY)
+    private val DISMISS_SCRIM_FADE_MS = 200L
     private var wm: WindowManager =
         context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
     private var gradientDrawable: GradientDrawable? = null
 
-    private val gradientAlpha: IntProperty<GradientDrawable> =
+    private val GRADIENT_ALPHA: IntProperty<GradientDrawable> =
         object : IntProperty<GradientDrawable>("alpha") {
             override fun setValue(d: GradientDrawable, percent: Int) {
                 d.alpha = percent
@@ -95,9 +97,9 @@ class DismissView(context: Context) : FrameLayout(context) {
         }
 
     init {
-        clipToPadding = false
-        clipChildren = false
-        visibility = View.INVISIBLE
+        setClipToPadding(false)
+        setClipChildren(false)
+        setVisibility(View.INVISIBLE)
         addView(circle)
     }
 
@@ -115,8 +117,7 @@ class DismissView(context: Context) : FrameLayout(context) {
         layoutParams = LayoutParams(
             ViewGroup.LayoutParams.MATCH_PARENT,
             resources.getDimensionPixelSize(config.floatingGradientHeightResId),
-            Gravity.BOTTOM,
-        )
+            Gravity.BOTTOM)
         updatePadding()
 
         // Setup gradient
@@ -124,13 +125,11 @@ class DismissView(context: Context) : FrameLayout(context) {
         setBackgroundDrawable(gradientDrawable)
 
         // Setup DismissCircleView
+        circle.id = config.dismissViewResId
         circle.setup(config.backgroundResId, config.iconResId, config.iconSizeResId)
         val targetSize: Int = resources.getDimensionPixelSize(config.targetSizeResId)
-        circle.layoutParams = LayoutParams(
-            targetSize,
-            targetSize,
-            Gravity.BOTTOM or Gravity.CENTER_HORIZONTAL,
-        )
+        circle.layoutParams = LayoutParams(targetSize, targetSize,
+            Gravity.BOTTOM or Gravity.CENTER_HORIZONTAL)
         // Initial position with circle offscreen so it's animated up
         circle.translationY = resources.getDimensionPixelSize(config.floatingGradientHeightResId)
             .toFloat()
@@ -143,13 +142,9 @@ class DismissView(context: Context) : FrameLayout(context) {
         if (isShowing) return
         val gradientDrawable = checkExists(gradientDrawable) ?: return
         isShowing = true
-        visibility = View.VISIBLE
-        val alphaAnim = ObjectAnimator.ofInt(
-            gradientDrawable,
-            gradientAlpha,
-            gradientDrawable.alpha,
-            255,
-        )
+        setVisibility(View.VISIBLE)
+        val alphaAnim = ObjectAnimator.ofInt(gradientDrawable, GRADIENT_ALPHA,
+            gradientDrawable.alpha, 255)
         alphaAnim.setDuration(DISMISS_SCRIM_FADE_MS)
         alphaAnim.start()
 
@@ -167,21 +162,18 @@ class DismissView(context: Context) : FrameLayout(context) {
         if (!isShowing) return
         val gradientDrawable = checkExists(gradientDrawable) ?: return
         isShowing = false
-        val alphaAnim = ObjectAnimator.ofInt(
-            gradientDrawable,
-            gradientAlpha,
-            gradientDrawable.alpha,
-            0,
-        )
+        val alphaAnim = ObjectAnimator.ofInt(gradientDrawable, GRADIENT_ALPHA,
+            gradientDrawable.alpha, 0)
         alphaAnim.setDuration(DISMISS_SCRIM_FADE_MS)
         alphaAnim.start()
         animator
-            .spring(
-                DynamicAnimation.TRANSLATION_Y,
-                height.toFloat(),
-                spring,
-            )
-            .withEndActions({ visibility = View.INVISIBLE })
+            .spring(DynamicAnimation.TRANSLATION_Y, height.toFloat(),
+                spring)
+            .withEndActions({
+                visibility = View.INVISIBLE
+                circle.scaleX = 1f
+                circle.scaleY = 1f
+            })
             .start()
     }
 
@@ -205,35 +197,25 @@ class DismissView(context: Context) : FrameLayout(context) {
     private fun createGradient(@ColorRes color: Int): GradientDrawable {
         val gradientColor = ContextCompat.getColor(context, color)
         val alpha = 0.7f * 255
-        val gradientColorWithAlpha = Color.argb(
-            alpha.toInt(),
+        val gradientColorWithAlpha = Color.argb(alpha.toInt(),
             Color.red(gradientColor),
             Color.green(gradientColor),
-            Color.blue(gradientColor),
-        )
+            Color.blue(gradientColor))
         val gd = GradientDrawable(
             GradientDrawable.Orientation.BOTTOM_TOP,
-            intArrayOf(gradientColorWithAlpha, Color.TRANSPARENT),
-        )
+            intArrayOf(gradientColorWithAlpha, Color.TRANSPARENT))
         gd.setDither(true)
-        gd.alpha = 0
+        gd.setAlpha(0)
         return gd
     }
 
     private fun updatePadding() {
-        if (!Utilities.ATLEAST_R) return
         val config = checkExists(config) ?: return
-        val insets: WindowInsets = wm.currentWindowMetrics.getWindowInsets()
+        val insets: WindowInsets = wm.getCurrentWindowMetrics().getWindowInsets()
         val navInset = insets.getInsetsIgnoringVisibility(
-            WindowInsets.Type.navigationBars(),
-        )
-        setPadding(
-            0,
-            0,
-            0,
-            navInset.bottom +
-                resources.getDimensionPixelSize(config.bottomMarginResId),
-        )
+            WindowInsets.Type.navigationBars())
+        setPadding(0, 0, 0, navInset.bottom +
+                resources.getDimensionPixelSize(config.bottomMarginResId))
     }
 
     /**
@@ -242,7 +224,7 @@ class DismissView(context: Context) : FrameLayout(context) {
      *
      * @return value provided as argument
      */
-    private fun <T> checkExists(value: T?): T? {
+    private fun <T>checkExists(value: T?): T? {
         if (value == null) Log.e(TAG, SHOULD_SETUP)
         return value
     }
diff --git a/lawnchair/src/app/lawnchair/bugreport/LawnchairBugReporter.kt b/lawnchair/src/app/lawnchair/bugreport/LawnchairBugReporter.kt
index 3c7e167472..d9520f6a8d 100644
--- a/lawnchair/src/app/lawnchair/bugreport/LawnchairBugReporter.kt
+++ b/lawnchair/src/app/lawnchair/bugreport/LawnchairBugReporter.kt
@@ -6,16 +6,15 @@ import android.content.Context
 import android.os.Build
 import android.util.Log
 import app.lawnchair.LawnchairApp
+import app.lawnchair.util.MainThreadInitializedObject
 import app.lawnchair.util.requireSystemService
 import com.android.launcher3.BuildConfig
 import com.android.launcher3.R
-import com.android.launcher3.util.MainThreadInitializedObject
-import com.android.launcher3.util.SafeCloseable
 import java.io.File
 import java.text.SimpleDateFormat
 import java.util.Date
 
-class LawnchairBugReporter(private val context: Context) : SafeCloseable {
+class LawnchairBugReporter(private val context: Context) {
 
     private val notificationManager: NotificationManager = context.requireSystemService()
     private val logsFolder by lazy { File(context.cacheDir, "logs").apply { mkdirs() } }
diff --git a/lawnchair/src/app/lawnchair/common/MagnetizedObject.kt b/lawnchair/src/app/lawnchair/common/MagnetizedObject.kt
index 755b666ad1..4f1b9deab4 100644
--- a/lawnchair/src/app/lawnchair/common/MagnetizedObject.kt
+++ b/lawnchair/src/app/lawnchair/common/MagnetizedObject.kt
@@ -19,7 +19,6 @@ package app.lawnchair.common
 import android.annotation.SuppressLint
 import android.content.Context
 import android.graphics.PointF
-import android.os.Build
 import android.os.VibrationAttributes
 import android.os.VibrationEffect
 import android.os.Vibrator
@@ -27,11 +26,10 @@ import android.view.MotionEvent
 import android.view.VelocityTracker
 import android.view.View
 import android.view.ViewConfiguration
-import androidx.annotation.RequiresApi
 import androidx.dynamicanimation.animation.DynamicAnimation
 import androidx.dynamicanimation.animation.FloatPropertyCompat
 import androidx.dynamicanimation.animation.SpringForce
-import app.lawnchair.animation.PhysicsAnimator
+import com.android.wm.shell.shared.animation.PhysicsAnimator
 import kotlin.math.abs
 import kotlin.math.hypot
 
@@ -66,7 +64,7 @@ abstract class MagnetizedObject<T : Any>(
     val xProperty: FloatPropertyCompat<in T>,
 
     /** Property that gets/sets the object's Y value. */
-    val yProperty: FloatPropertyCompat<in T>,
+    val yProperty: FloatPropertyCompat<in T>
 ) {
 
     /** Return the width of the object. */
@@ -94,8 +92,9 @@ abstract class MagnetizedObject<T : Any>(
          * to [onUnstuckFromTarget] or [onReleasedInTarget].
          *
          * @param target The target that the object is now stuck to.
+         * @param draggedObject The object that is stuck to the target.
          */
-        fun onStuckToTarget(target: MagneticTarget)
+        fun onStuckToTarget(target: MagneticTarget, draggedObject: MagnetizedObject<*>)
 
         /**
          * Called when the object is no longer stuck to a target. This means that either touch
@@ -113,6 +112,7 @@ abstract class MagnetizedObject<T : Any>(
          * and [maybeConsumeMotionEvent] is now returning false.
          *
          * @param target The target that this object was just unstuck from.
+         * @param draggedObject The object being unstuck from the target.
          * @param velX The X velocity of the touch gesture when it exited the magnetic field.
          * @param velY The Y velocity of the touch gesture when it exited the magnetic field.
          * @param wasFlungOut Whether the object was unstuck via a fling gesture. This means that
@@ -122,9 +122,10 @@ abstract class MagnetizedObject<T : Any>(
          */
         fun onUnstuckFromTarget(
             target: MagneticTarget,
+            draggedObject: MagnetizedObject<*>,
             velX: Float,
             velY: Float,
-            wasFlungOut: Boolean,
+            wasFlungOut: Boolean
         )
 
         /**
@@ -132,8 +133,9 @@ abstract class MagnetizedObject<T : Any>(
          * velocity to reach it.
          *
          * @param target The target that the object was released in.
+         * @param draggedObject The object released in the target.
          */
-        fun onReleasedInTarget(target: MagneticTarget)
+        fun onReleasedInTarget(target: MagneticTarget, draggedObject: MagnetizedObject<*>)
     }
 
     private val animator: PhysicsAnimator<T> = PhysicsAnimator.getInstance(underlyingObject)
@@ -147,11 +149,8 @@ abstract class MagnetizedObject<T : Any>(
 
     private val velocityTracker: VelocityTracker = VelocityTracker.obtain()
     private val vibrator: Vibrator = context.getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
-
-    @RequiresApi(Build.VERSION_CODES.R)
     private val vibrationAttributes: VibrationAttributes = VibrationAttributes.createForUsage(
-        VibrationAttributes.USAGE_TOUCH,
-    )
+        VibrationAttributes.USAGE_TOUCH)
 
     private var touchDown = PointF()
     private var touchSlop = 0
@@ -168,7 +167,7 @@ abstract class MagnetizedObject<T : Any>(
      * Sets the listener to receive events. This must be set, or [maybeConsumeMotionEvent]
      * will always return false and no magnetic effects will occur.
      */
-    lateinit var magnetListener: MagnetListener
+    lateinit var magnetListener: MagnetizedObject.MagnetListener
 
     /**
      * Optional update listener to provide to the PhysicsAnimator that is used to spring the object
@@ -265,9 +264,7 @@ abstract class MagnetizedObject<T : Any>(
 
     /** Default spring configuration to use for animating the object into a target. */
     var springConfig = PhysicsAnimator.SpringConfig(
-        SpringForce.STIFFNESS_MEDIUM,
-        SpringForce.DAMPING_RATIO_NO_BOUNCY,
-    )
+        SpringForce.STIFFNESS_MEDIUM, SpringForce.DAMPING_RATIO_NO_BOUNCY)
 
     /**
      * Spring configuration to use to spring the object into a target specifically when it's flung
@@ -360,9 +357,8 @@ abstract class MagnetizedObject<T : Any>(
 
         val targetObjectIsInMagneticFieldOf = associatedTargets.firstOrNull { target ->
             val distanceFromTargetCenter = hypot(
-                ev.rawX - target.centerOnScreen.x,
-                ev.rawY - target.centerOnScreen.y,
-            )
+                ev.rawX - target.centerOnDisplayX(),
+                ev.rawY - target.centerOnDisplayY())
             distanceFromTargetCenter < target.magneticFieldRadiusPx
         }
 
@@ -376,8 +372,8 @@ abstract class MagnetizedObject<T : Any>(
         // adjacent target's magnetic field.
         val objectMovedIntoDifferentTarget =
             objectStuckToTarget &&
-                targetObjectIsInMagneticFieldOf != null &&
-                targetObjectIsStuckTo != targetObjectIsInMagneticFieldOf
+                    targetObjectIsInMagneticFieldOf != null &&
+                    targetObjectIsStuckTo != targetObjectIsInMagneticFieldOf
 
         if (objectNewlyStuckToTarget || objectMovedIntoDifferentTarget) {
             velocityTracker.computeCurrentVelocity(1000)
@@ -395,7 +391,7 @@ abstract class MagnetizedObject<T : Any>(
             // animate sticking to the magnet.
             targetObjectIsStuckTo = targetObjectIsInMagneticFieldOf
             cancelAnimations()
-            magnetListener.onStuckToTarget(targetObjectIsInMagneticFieldOf!!)
+            magnetListener.onStuckToTarget(targetObjectIsInMagneticFieldOf!!, this)
             animateStuckToTarget(targetObjectIsInMagneticFieldOf, velX, velY, false, null)
 
             vibrateIfEnabled(VibrationEffect.EFFECT_HEAVY_CLICK)
@@ -406,11 +402,9 @@ abstract class MagnetizedObject<T : Any>(
             // move the object out of the target using its own movement logic.
             cancelAnimations()
             magnetListener.onUnstuckFromTarget(
-                targetObjectIsStuckTo!!,
-                velocityTracker.xVelocity,
-                velocityTracker.yVelocity,
-                wasFlungOut = false,
-            )
+                targetObjectIsStuckTo!!, this,
+                velocityTracker.xVelocity, velocityTracker.yVelocity,
+                wasFlungOut = false)
             targetObjectIsStuckTo = null
 
             vibrateIfEnabled(VibrationEffect.EFFECT_TICK)
@@ -418,7 +412,7 @@ abstract class MagnetizedObject<T : Any>(
 
         // First, check for relevant gestures concluding with an ACTION_UP.
         if (ev.action == MotionEvent.ACTION_UP) {
-            velocityTracker.computeCurrentVelocity(1000) /* units */
+            velocityTracker.computeCurrentVelocity(1000 /* units */)
             val velX = velocityTracker.xVelocity
             val velY = velocityTracker.yVelocity
 
@@ -432,14 +426,11 @@ abstract class MagnetizedObject<T : Any>(
                     // the upward direction, tell the listener so the object can be animated out of
                     // the target.
                     magnetListener.onUnstuckFromTarget(
-                        targetObjectIsStuckTo!!,
-                        velX,
-                        velY,
-                        wasFlungOut = true,
-                    )
+                        targetObjectIsStuckTo!!, this,
+                        velX, velY, wasFlungOut = true)
                 } else {
                     // If the object is stuck and not flung away, it was released inside the target.
-                    magnetListener.onReleasedInTarget(targetObjectIsStuckTo!!)
+                    magnetListener.onReleasedInTarget(targetObjectIsStuckTo!!, this)
                     vibrateIfEnabled(VibrationEffect.EFFECT_HEAVY_CLICK)
                 }
 
@@ -456,11 +447,11 @@ abstract class MagnetizedObject<T : Any>(
             if (flungToTarget != null) {
                 // If this is a fling-to-target, animate the object to the magnet and then release
                 // it.
-                magnetListener.onStuckToTarget(flungToTarget)
+                magnetListener.onStuckToTarget(flungToTarget, this)
                 targetObjectIsStuckTo = flungToTarget
 
                 animateStuckToTarget(flungToTarget, velX, velY, true) {
-                    magnetListener.onReleasedInTarget(flungToTarget)
+                    magnetListener.onReleasedInTarget(flungToTarget, this)
                     targetObjectIsStuckTo = null
                     vibrateIfEnabled(VibrationEffect.EFFECT_HEAVY_CLICK)
                 }
@@ -500,7 +491,7 @@ abstract class MagnetizedObject<T : Any>(
         velX: Float,
         velY: Float,
         flung: Boolean,
-        after: (() -> Unit)? = null,
+        after: (() -> Unit)? = null
     ) {
         target.updateLocationOnScreen()
         getLocationOnScreen(underlyingObject, objectLocationOnScreen)
@@ -509,9 +500,9 @@ abstract class MagnetizedObject<T : Any>(
         // Animating the object's x/y properties by these values will center the object on top
         // of the magnetic target.
         val xDiff = target.centerOnScreen.x -
-            getWidth(underlyingObject) / 2f - objectLocationOnScreen[0]
+                getWidth(underlyingObject) / 2f - objectLocationOnScreen[0]
         val yDiff = target.centerOnScreen.y -
-            getHeight(underlyingObject) / 2f - objectLocationOnScreen[1]
+                getHeight(underlyingObject) / 2f - objectLocationOnScreen[1]
 
         val springConfig = if (flung) flungIntoTargetSpringConfig else springConfig
 
@@ -519,18 +510,10 @@ abstract class MagnetizedObject<T : Any>(
 
         // Animate to the center of the target.
         animator
-            .spring(
-                xProperty,
-                xProperty.getValue(underlyingObject) + xDiff,
-                velX,
-                springConfig,
-            )
-            .spring(
-                yProperty,
-                yProperty.getValue(underlyingObject) + yDiff,
-                velY,
-                springConfig,
-            )
+            .spring(xProperty, xProperty.getValue(underlyingObject) + xDiff, velX,
+                springConfig)
+            .spring(yProperty, yProperty.getValue(underlyingObject) + yDiff, velY,
+                springConfig)
 
         if (physicsAnimatorUpdateListener != null) {
             animator.addUpdateListener(physicsAnimatorUpdateListener!!)
@@ -556,7 +539,7 @@ abstract class MagnetizedObject<T : Any>(
         rawX: Float,
         rawY: Float,
         velX: Float,
-        velY: Float,
+        velY: Float
     ): Boolean {
         if (!flingToTargetEnabled) {
             return false
@@ -565,11 +548,8 @@ abstract class MagnetizedObject<T : Any>(
         // Whether velocity is sufficient, depending on whether we're flinging into a target at the
         // top or the bottom of the screen.
         val velocitySufficient =
-            if (rawY < target.centerOnScreen.y) {
-                velY > flingToTargetMinVelocity
-            } else {
-                velY < flingToTargetMinVelocity
-            }
+            if (rawY < target.centerOnDisplayY()) velY > flingToTargetMinVelocity
+            else velY < flingToTargetMinVelocity
 
         if (!velocitySufficient) {
             return false
@@ -586,15 +566,15 @@ abstract class MagnetizedObject<T : Any>(
             val yIntercept = rawY - slope * rawX
 
             // ...calculate the x value when y = the target's y-coordinate.
-            targetCenterXIntercept = (target.centerOnScreen.y - yIntercept) / slope
+            targetCenterXIntercept = (target.centerOnDisplayY() - yIntercept) / slope
         }
 
         // The width of the area we're looking for a fling towards.
         val targetAreaWidth = target.targetView.width * flingToTargetWidthPercent
 
         // Velocity was sufficient, so return true if the intercept is within the target area.
-        return targetCenterXIntercept > target.centerOnScreen.x - targetAreaWidth / 2 &&
-            targetCenterXIntercept < target.centerOnScreen.x + targetAreaWidth / 2
+        return targetCenterXIntercept > target.centerOnDisplayX() - targetAreaWidth / 2 &&
+                targetCenterXIntercept < target.centerOnDisplayX() + targetAreaWidth / 2
     }
 
     /** Cancel animations on this object's x/y properties. */
@@ -623,10 +603,26 @@ abstract class MagnetizedObject<T : Any>(
      */
     class MagneticTarget(
         val targetView: View,
-        var magneticFieldRadiusPx: Int,
+        var magneticFieldRadiusPx: Int
     ) {
         val centerOnScreen = PointF()
 
+        /**
+         * Set screen vertical offset amount.
+         *
+         * Screen surface may be vertically shifted in some cases, for example when one-handed mode
+         * is enabled. [MagneticTarget] and [MagnetizedObject] set their location in screen
+         * coordinates (see [MagneticTarget.centerOnScreen] and
+         * [MagnetizedObject.getLocationOnScreen] respectively).
+         *
+         * When a [MagnetizedObject] is dragged, the touch location is determined by
+         * [MotionEvent.getRawX] and [MotionEvent.getRawY]. These work in display coordinates. When
+         * screen is shifted due to one-handed mode, display coordinates and screen coordinates do
+         * not match. To determine if a [MagnetizedObject] is dragged into a [MagneticTarget], view
+         * location on screen is translated to display coordinates using this offset value.
+         */
+        var screenVerticalOffset: Int = 0
+
         private val tempLoc = IntArray(2)
 
         fun updateLocationOnScreen() {
@@ -637,10 +633,26 @@ abstract class MagnetizedObject<T : Any>(
                 // target could be animating in while we're doing this calculation.
                 centerOnScreen.set(
                     tempLoc[0] + targetView.width / 2f - targetView.translationX,
-                    tempLoc[1] + targetView.height / 2f - targetView.translationY,
-                )
+                    tempLoc[1] + targetView.height / 2f - targetView.translationY)
             }
         }
+
+        /**
+         * Get target center coordinate on x-axis on display. [centerOnScreen] has to be up to date
+         * by calling [updateLocationOnScreen] first.
+         */
+        fun centerOnDisplayX(): Float {
+            return centerOnScreen.x
+        }
+
+        /**
+         * Get target center coordinate on y-axis on display. [centerOnScreen] has to be up to date
+         * by calling [updateLocationOnScreen] first. Use [screenVerticalOffset] to update the
+         * screen offset compared to the display.
+         */
+        fun centerOnDisplayY(): Float {
+            return centerOnScreen.y + screenVerticalOffset
+        }
     }
 
     companion object {
@@ -673,15 +685,13 @@ abstract class MagnetizedObject<T : Any>(
                 view.context,
                 view,
                 DynamicAnimation.TRANSLATION_X,
-                DynamicAnimation.TRANSLATION_Y,
-            ) {
+                DynamicAnimation.TRANSLATION_Y) {
                 override fun getWidth(underlyingObject: T): Float {
                     return underlyingObject.width.toFloat()
                 }
 
                 override fun getHeight(underlyingObject: T): Float {
-                    return underlyingObject.height.toFloat()
-                }
+                    return underlyingObject.height.toFloat() }
 
                 override fun getLocationOnScreen(underlyingObject: T, loc: IntArray) {
                     underlyingObject.getLocationOnScreen(loc)
@@ -689,4 +699,4 @@ abstract class MagnetizedObject<T : Any>(
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/lawnchair/src/app/lawnchair/data/AppDatabase.kt b/lawnchair/src/app/lawnchair/data/AppDatabase.kt
index af2c34dc1b..1d37cdb270 100644
--- a/lawnchair/src/app/lawnchair/data/AppDatabase.kt
+++ b/lawnchair/src/app/lawnchair/data/AppDatabase.kt
@@ -7,12 +7,11 @@ import androidx.room.TypeConverters
 import androidx.sqlite.db.SimpleSQLiteQuery
 import app.lawnchair.data.iconoverride.IconOverride
 import app.lawnchair.data.iconoverride.IconOverrideDao
-import com.android.launcher3.util.MainThreadInitializedObject
-import com.android.launcher3.util.SafeCloseable
+import app.lawnchair.util.MainThreadInitializedObject
 
 @Database(entities = [IconOverride::class], version = 1)
 @TypeConverters(Converters::class)
-abstract class AppDatabase : RoomDatabase(), SafeCloseable {
+abstract class AppDatabase : RoomDatabase() {
 
     abstract fun iconOverrideDao(): IconOverrideDao
 
diff --git a/lawnchair/src/app/lawnchair/overview/LawnchairOverviewActionsView.kt b/lawnchair/src/app/lawnchair/overview/LawnchairOverviewActionsView.kt
deleted file mode 100644
index 1b9757ec47..0000000000
--- a/lawnchair/src/app/lawnchair/overview/LawnchairOverviewActionsView.kt
+++ /dev/null
@@ -1,160 +0,0 @@
-package app.lawnchair.overview
-
-import android.content.Context
-import android.util.AttributeSet
-import android.view.View
-import android.widget.Button
-import android.widget.LinearLayout
-import android.widget.Space
-import androidx.core.content.ContextCompat
-import androidx.core.view.ViewCompat
-import androidx.core.view.isVisible
-import app.lawnchair.preferences.PreferenceManager
-import app.lawnchair.util.RecentHelper
-import app.lawnchair.util.isDefaultLauncher
-import app.lawnchair.util.isOnePlusStock
-import com.android.launcher3.Launcher
-import com.android.launcher3.LauncherState
-import com.android.launcher3.R
-import com.android.launcher3.statemanager.StateManager
-import com.android.quickstep.views.OverviewActionsView
-import com.android.quickstep.views.RecentsView
-import com.android.systemui.shared.recents.model.Task
-
-class LawnchairOverviewActionsView @JvmOverloads constructor(
-    context: Context,
-    attrs: AttributeSet? = null,
-    defStyleAttr: Int = 0,
-) : OverviewActionsView<TaskOverlayFactoryImpl.OverlayUICallbacks>(context, attrs, defStyleAttr) {
-
-    private val prefs = PreferenceManager.getInstance(context)
-    private val launcher: Launcher? = if (context.isDefaultLauncher()) Launcher.getLauncher(context) else null
-    private lateinit var container: LinearLayout
-    private lateinit var screenshotAction: Button
-    private lateinit var shareAction: Button
-    private lateinit var lensAction: Button
-    private lateinit var clearAllAction: Button
-    private lateinit var lockedAction: Button
-    private var rv: RecentsView<Launcher, *>? = null
-
-    private val lockedTaskStateLister = object : StateManager.StateListener<LauncherState> {
-        override fun onStateTransitionStart(toState: LauncherState) {
-            rv = launcher?.getOverviewPanel()
-        }
-
-        override fun onStateTransitionComplete(finalState: LauncherState) {
-            if (finalState.overviewUi && context.isDefaultLauncher()) {
-                rv?.addOnScrollChangedListener {
-                    val task = rv?.getCurrentPageTaskView()?.task
-                    task?.let { updateLockedActionState(it) }
-                }
-            }
-        }
-    }
-
-    override fun onFinishInflate() {
-        super.onFinishInflate()
-
-        container = ViewCompat.requireViewById(this, R.id.action_buttons)
-        clearAllAction = ViewCompat.requireViewById(this, R.id.action_clear_all)
-        shareAction = ViewCompat.requireViewById(this, R.id.action_share)
-        lensAction = ViewCompat.requireViewById(this, R.id.action_lens)
-        screenshotAction = ViewCompat.requireViewById(this, R.id.action_screenshot)
-        lockedAction = ViewCompat.requireViewById(this, R.id.action_locked)
-
-        shareAction.setOnClickListener { mCallbacks?.onShare() }
-        lensAction.setOnClickListener { mCallbacks?.onLens() }
-        if (context.isDefaultLauncher()) {
-            lockedAction.setOnClickListener {
-                rv = launcher?.getOverviewPanel()
-                val task = rv?.getCurrentPageTaskView()?.task
-                if (task != null) {
-                    mCallbacks?.onLocked(context, task)
-                    updateLockedActionState(task)
-                }
-            }
-        }
-
-        prefs.recentsActionClearAll.subscribeChanges(this, ::updateVisibilities)
-        prefs.recentsActionLens.subscribeChanges(this, ::updateVisibilities)
-        prefs.recentsActionScreenshot.subscribeChanges(this, ::updateVisibilities)
-        prefs.recentsActionShare.subscribeChanges(this, ::updateVisibilities)
-        prefs.recentsActionLocked.subscribeChanges(this, ::updateVisibilities)
-        prefs.recentActionOrder.subscribeChanges(this, ::updateVisibilities)
-
-        updateVisibilities()
-    }
-
-    private fun updateVisibilities() {
-        val order = prefs.recentActionOrder.get().split(",").map { it.toInt() }
-
-        val buttonMap = mutableMapOf<Int, View>()
-        if (prefs.recentsActionScreenshot.get() && !isOnePlusStock) {
-            buttonMap[0] = screenshotAction
-        }
-        if (prefs.recentsActionShare.get()) {
-            buttonMap[1] = shareAction
-        }
-        if (prefs.recentsActionLens.get() && isLensAvailable()) {
-            buttonMap[2] = lensAction
-        }
-        if (prefs.recentsActionLocked.get()) {
-            buttonMap[3] = lockedAction
-        }
-        if (prefs.recentsActionClearAll.get()) {
-            buttonMap[4] = clearAllAction
-        }
-
-        val buttonsInOrder = order.mapNotNull { buttonMap[it] }
-
-        container.removeAllViews()
-        container.addView(createSpace())
-        buttonsInOrder.forEach { view ->
-            view.isVisible = true
-            container.addView(view)
-            container.addView(createSpace())
-        }
-    }
-
-    private fun isLensAvailable(): Boolean {
-        val lensIntent = context.packageManager.getLaunchIntentForPackage("com.google.ar.lens")
-        return lensIntent != null
-    }
-
-    private fun updateLockedActionState(task: Task) {
-        lockedAction.post {
-            val isLocked = RecentHelper.isAppLocked(task.key.packageName, context)
-            val drawableResId = if (isLocked) R.drawable.ic_unlocked_recents else R.drawable.ic_locked_recents
-            val textResId = if (isLocked) R.string.action_unlock else R.string.action_lock
-
-            val drawable = ContextCompat.getDrawable(context, drawableResId)
-            lockedAction.setCompoundDrawablesWithIntrinsicBounds(drawable, null, null, null)
-            lockedAction.setText(textResId)
-        }
-    }
-
-    private fun createSpace(): View {
-        return Space(context).apply {
-            layoutParams = LinearLayout.LayoutParams(0, 1).apply { weight = 1f }
-        }
-    }
-
-    override fun setClearAllClickListener(clearAllClickListener: OnClickListener?) {
-        clearAllAction.setOnClickListener(clearAllClickListener)
-    }
-
-    override fun removeOnAttachStateChangeListener(listener: OnAttachStateChangeListener?) {
-        super.removeOnAttachStateChangeListener(listener)
-        if (context.isDefaultLauncher() && prefs.recentsActionLocked.get()) {
-            launcher?.stateManager?.removeStateListener(lockedTaskStateLister)
-        }
-    }
-
-    @Synchronized
-    override fun addOnAttachStateChangeListener(listener: OnAttachStateChangeListener?) {
-        super.addOnAttachStateChangeListener(listener)
-        if (context.isDefaultLauncher() && prefs.recentsActionLocked.get()) {
-            launcher?.stateManager?.addStateListener(lockedTaskStateLister)
-        }
-    }
-}
diff --git a/lawnchair/src/app/lawnchair/overview/TaskOverlayFactoryImpl.kt b/lawnchair/src/app/lawnchair/overview/TaskOverlayFactoryImpl.kt
deleted file mode 100644
index 67685ca0b7..0000000000
--- a/lawnchair/src/app/lawnchair/overview/TaskOverlayFactoryImpl.kt
+++ /dev/null
@@ -1,82 +0,0 @@
-package app.lawnchair.overview
-
-import android.content.Context
-import android.graphics.Matrix
-import androidx.annotation.Keep
-import app.lawnchair.util.RecentHelper
-import app.lawnchair.util.TaskUtilLockState
-import com.android.quickstep.TaskOverlayFactory
-import com.android.quickstep.task.thumbnail.TaskThumbnailView
-import com.android.quickstep.views.OverviewActionsView
-import com.android.systemui.shared.recents.model.Task
-import com.android.systemui.shared.recents.model.ThumbnailData
-
-@Keep
-class TaskOverlayFactoryImpl(@Suppress("UNUSED_PARAMETER") context: Context) : TaskOverlayFactory() {
-
-    override fun createOverlay(thumbnailView: TaskThumbnailView) = TaskOverlay(thumbnailView)
-
-    class TaskOverlay(
-        taskThumbnailView: TaskThumbnailView,
-    ) : TaskOverlayFactory.TaskOverlay<LawnchairOverviewActionsView>(taskThumbnailView) {
-
-        override fun initOverlay(
-            task: Task?,
-            thumbnail: ThumbnailData?,
-            matrix: Matrix,
-            rotated: Boolean,
-        ) {
-            actionsView.updateDisabledFlags(
-                OverviewActionsView.DISABLED_NO_THUMBNAIL,
-                thumbnail == null,
-            )
-
-            if (thumbnail != null) {
-                actionsView.updateDisabledFlags(OverviewActionsView.DISABLED_ROTATED, rotated)
-                val isAllowedByPolicy = mThumbnailView.isRealSnapshot
-                actionsView.setCallbacks(OverlayUICallbacksImpl(isAllowedByPolicy, task))
-            }
-        }
-
-        private inner class OverlayUICallbacksImpl(
-            isAllowedByPolicy: Boolean,
-            task: Task?,
-        ) : TaskOverlayFactory.TaskOverlay<LawnchairOverviewActionsView>.OverlayUICallbacksImpl(
-            isAllowedByPolicy,
-            task,
-        ),
-            OverlayUICallbacks {
-
-            override fun onShare() {
-                if (mIsAllowedByPolicy) {
-                    endLiveTileMode { mImageApi.startShareActivity(null) }
-                } else {
-                    showBlockedByPolicyMessage()
-                }
-            }
-
-            override fun onLens() {
-                if (mIsAllowedByPolicy) {
-                    endLiveTileMode { mImageApi.startLensActivity() }
-                } else {
-                    showBlockedByPolicyMessage()
-                }
-            }
-            override fun onLocked(context: Context, task: Task) {
-                val isLocked = !RecentHelper.isAppLocked(task.key.packageName, context)
-                TaskUtilLockState.setTaskLockState(
-                    context,
-                    task.key.component,
-                    isLocked,
-                    task.key,
-                )
-            }
-        }
-    }
-
-    sealed interface OverlayUICallbacks : TaskOverlayFactory.OverlayUICallbacks {
-        fun onShare()
-        fun onLens()
-        fun onLocked(context: Context, task: Task)
-    }
-}
diff --git a/lawnchair/src/app/lawnchair/overview/TaskShortcutFactory.kt b/lawnchair/src/app/lawnchair/overview/TaskShortcutFactory.kt
index bc89b3a06c..0d6e94fc7d 100644
--- a/lawnchair/src/app/lawnchair/overview/TaskShortcutFactory.kt
+++ b/lawnchair/src/app/lawnchair/overview/TaskShortcutFactory.kt
@@ -1,206 +1,5 @@
 package app.lawnchair.overview
 
-import android.app.ActivityManagerNative
-import android.app.ActivityOptions
-import android.graphics.Color
-import android.graphics.Rect
-import android.os.Handler
-import android.os.Looper
-import android.os.RemoteException
-import android.os.UserHandle
-import android.util.Log
-import android.view.Display
-import android.view.View
-import android.view.WindowManagerGlobal
-import android.widget.Toast
-import app.lawnchair.LawnchairLauncher
-import app.lawnchair.compat.LawnchairQuickstepCompat
-import app.lawnchair.compatlib.eleven.WindowManagerCompatVR
-import com.android.launcher3.BaseDraggingActivity
-import com.android.launcher3.R
-import com.android.launcher3.logging.StatsLogManager.LauncherEvent
-import com.android.launcher3.popup.SystemShortcut
-import com.android.quickstep.TaskShortcutFactory
-import com.android.quickstep.task.thumbnail.TaskThumbnailView
-import com.android.quickstep.views.RecentsView
-import com.android.quickstep.views.TaskView
-import com.android.quickstep.views.TaskView.TaskIdAttributeContainer
-import com.android.systemui.shared.recents.view.AppTransitionAnimationSpecCompat
-import com.android.systemui.shared.recents.view.AppTransitionAnimationSpecsFuture
-import com.android.systemui.shared.recents.view.RecentsTransition
-import com.android.systemui.shared.system.ActivityManagerWrapper
-
 object TaskShortcutFactory {
 
-    class LegacySplitSystemShortcut(
-        iconRes: Int,
-        textRes: Int,
-        activity: BaseDraggingActivity,
-        taskContainer: TaskView.TaskContainer,
-        private val mLauncherEvent: LauncherEvent,
-    ) : SystemShortcut<BaseDraggingActivity?>(
-        iconRes,
-        textRes,
-        activity,
-        taskContainer.itemInfo,
-        taskContainer.taskView,
-    ) {
-        private val mHandler: Handler = Handler(Looper.getMainLooper())
-        private val mRecentsView: RecentsView<*, *> = activity.getOverviewPanel()
-        private val mThumbnailView: TaskThumbnailView = taskContainer.thumbnailView
-        private val mTaskView: TaskView = taskContainer.taskView
-
-        private fun makeLaunchOptions(activity: BaseDraggingActivity): ActivityOptions? {
-            val navBarPosition: Int = WindowManagerCompatVR.getNavBarPosition(activity.displayId)
-            if (navBarPosition == WindowManagerCompatVR.NAV_BAR_POS_INVALID) {
-                return null
-            }
-            val options = ActivityOptions.makeBasic()
-            options.launchWindowingMode = WindowManagerCompatVR.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY
-            return options
-        }
-
-        override fun onClick(view: View) {
-            val taskKey = mTaskView.task!!.key
-            val taskId = taskKey.id
-            dismissTaskMenuView(mTarget)
-            val options = makeLaunchOptions(mTarget!!)
-            if (options != null && ActivityManagerWrapper.getInstance().startActivityFromRecents(taskId, options)) {
-                val animStartedListener =
-                    Runnable { mRecentsView.dismissTask(mTaskView, false, false) }
-                val position = IntArray(2)
-                mThumbnailView.getLocationOnScreen(position)
-                val width = (mThumbnailView.width * mTaskView.scaleX).toInt()
-                val height = (mThumbnailView.height * mTaskView.scaleY).toInt()
-                val taskBounds = Rect(
-                    position[0],
-                    position[1],
-                    position[0] + width,
-                    position[1] + height,
-                )
-
-                // Take the thumbnail of the task without a scrim and apply it back after
-                val alpha = mThumbnailView.dimAlpha
-                mThumbnailView.dimAlpha = 0f
-                val thumbnail = RecentsTransition.drawViewIntoHardwareBitmap(
-                    taskBounds.width(),
-                    taskBounds.height(),
-                    mThumbnailView,
-                    1f,
-                    Color.BLACK,
-                )
-                mThumbnailView.dimAlpha = alpha
-                val future: AppTransitionAnimationSpecsFuture = object : AppTransitionAnimationSpecsFuture(mHandler) {
-                    override fun composeSpecs(): List<AppTransitionAnimationSpecCompat> {
-                        return listOf(
-                            AppTransitionAnimationSpecCompat(
-                                taskId,
-                                thumbnail,
-                                taskBounds,
-                            ),
-                        )
-                    }
-                }
-                try {
-                    WindowManagerGlobal.getWindowManagerService()
-                        .overridePendingAppTransitionMultiThumbFuture(
-                            future.future,
-                            RecentsTransition.wrapStartedListener(
-                                mHandler,
-                                animStartedListener,
-                            ),
-                            true,
-                            taskKey.displayId,
-                        )
-                } catch (e: RemoteException) {
-                    Log.w("TAG", "Failed to override pending app transition (multi-thumbnail future): ", e)
-                }
-                mTarget.statsLogManager.logger().withItemInfo(mTaskView.itemInfo).log(mLauncherEvent)
-            }
-        }
-    }
-
-    @JvmField
-    var legacySplit: TaskShortcutFactory = object : TaskShortcutFactory {
-
-        override fun getShortcuts(
-            activity: BaseDraggingActivity,
-            taskContainer: TaskIdAttributeContainer,
-        ): List<SystemShortcut<*>>? {
-            val task = taskContainer.task
-            if (!task.isDockable) {
-                return null
-            }
-            return if (isAvailable(activity, task.key.displayId)) {
-                listOf(
-                    LegacySplitSystemShortcut(
-                        R.drawable.ic_split_vertical,
-                        R.string.recent_task_option_split_screen,
-                        activity,
-                        taskContainer,
-                        LauncherEvent.LAUNCHER_SYSTEM_SHORTCUT_SPLIT_SCREEN_TAP,
-                    ),
-                )
-            } else {
-                null
-            }
-        }
-
-        private fun isAvailable(activity: BaseDraggingActivity, displayId: Int): Boolean {
-            return if (LawnchairQuickstepCompat.ATLEAST_T) {
-                false
-            } else {
-                (
-                    !activity.deviceProfile.isMultiWindowMode &&
-                        (displayId == -1 || displayId == Display.DEFAULT_DISPLAY)
-                    )
-            }
-        }
-    }
-
-    class KillSystemShortcut(
-        activity: BaseDraggingActivity,
-        taskContainer: TaskIdAttributeContainer,
-    ) : SystemShortcut<BaseDraggingActivity>(
-        R.drawable.ic_close,
-        R.string.task_menu_force_stop,
-        activity,
-        taskContainer.itemInfo,
-        taskContainer.taskView,
-    ) {
-        private val mTaskView: TaskView = taskContainer.taskView
-        private val mActivity: BaseDraggingActivity = activity
-        override fun onClick(view: View) {
-            val iam = ActivityManagerNative.getDefault()
-            val task = mTaskView.task
-            if (task != null) {
-                try {
-                    iam.forceStopPackage(task.key.packageName, UserHandle.USER_CURRENT)
-                    val appKilled = Toast.makeText(
-                        mActivity,
-                        R.string.task_menu_force_stop,
-                        Toast.LENGTH_SHORT,
-                    )
-                    appKilled.show()
-                    val rv: RecentsView<LawnchairLauncher, *> = mActivity.getOverviewPanel()
-                    rv.dismissTask(mTaskView, true, true)
-                } catch (e: RemoteException) {
-                    Log.e("KillSystemShortcut", "onClick: ", e.cause)
-                }
-            }
-            dismissTaskMenuView(mActivity)
-        }
-    }
-
-    @JvmField
-    var killApp: TaskShortcutFactory = object : TaskShortcutFactory {
-        override fun getShortcuts(
-            activity: BaseDraggingActivity,
-            taskContainer: TaskIdAttributeContainer,
-        ): List<SystemShortcut<*>> {
-            return listOf(
-                KillSystemShortcut(activity, taskContainer),
-            )
-        }
-    }
 }
diff --git a/lawnchair/src/app/lawnchair/preferences/PreferenceManager.kt b/lawnchair/src/app/lawnchair/preferences/PreferenceManager.kt
index d7f4e1a0cc..c79636f007 100644
--- a/lawnchair/src/app/lawnchair/preferences/PreferenceManager.kt
+++ b/lawnchair/src/app/lawnchair/preferences/PreferenceManager.kt
@@ -23,6 +23,7 @@ import app.lawnchair.LawnchairLauncher
 import app.lawnchair.font.FontCache
 import app.lawnchair.util.isOnePlusStock
 import com.android.launcher3.InvariantDeviceProfile
+import com.android.launcher3.InvariantDeviceProfile.INDEX_DEFAULT
 import com.android.launcher3.model.DeviceGridState
 import com.android.launcher3.util.ComponentKey
 import com.android.launcher3.util.MainThreadInitializedObject
@@ -49,7 +50,7 @@ class PreferenceManager private constructor(private val context: Context) : Base
     val workspaceColumns = IntPref("pref_workspaceColumns", 4)
     val workspaceRows = IntPref("pref_workspaceRows", 5)
     val workspaceIncreaseMaxGridSize = BoolPref("pref_workspace_increase_max_grid_size", false)
-    val folderRows = IdpIntPref("pref_folderRows", { numFolderRows }, reloadGrid)
+    val folderRows = IdpIntPref("pref_folderRows", { numFolderRows[INDEX_DEFAULT] }, reloadGrid)
 
     val drawerOpacity = FloatPref("pref_drawerOpacity", 1F, recreate)
     val coloredBackgroundLightness = FloatPref("pref_coloredBackgroundLightness", 0.9F, recreate)
diff --git a/lawnchair/src/app/lawnchair/preferences2/PreferenceManager2.kt b/lawnchair/src/app/lawnchair/preferences2/PreferenceManager2.kt
index 0eadc972cf..5c6dae168d 100644
--- a/lawnchair/src/app/lawnchair/preferences2/PreferenceManager2.kt
+++ b/lawnchair/src/app/lawnchair/preferences2/PreferenceManager2.kt
@@ -32,7 +32,6 @@ import app.lawnchair.hotseat.HotseatMode
 import app.lawnchair.icons.CustomAdaptiveIconDrawable
 import app.lawnchair.icons.shape.IconShape
 import app.lawnchair.icons.shape.IconShapeManager
-import app.lawnchair.preferences.PreferenceManager as LawnchairPreferenceManager
 import app.lawnchair.qsb.providers.QsbSearchProvider
 import app.lawnchair.search.algorithms.LawnchairSearchAlgorithm
 import app.lawnchair.search.algorithms.data.WebSearchProvider
@@ -45,9 +44,9 @@ import app.lawnchair.theme.color.ColorStyle
 import app.lawnchair.ui.preferences.components.HiddenAppsInSearch
 import app.lawnchair.util.kotlinxJson
 import com.android.launcher3.InvariantDeviceProfile
+import com.android.launcher3.InvariantDeviceProfile.INDEX_DEFAULT
 import com.android.launcher3.LauncherAppState
 import com.android.launcher3.R
-import com.android.launcher3.graphics.IconShape as L3IconShape
 import com.android.launcher3.util.DynamicResource
 import com.android.launcher3.util.MainThreadInitializedObject
 import com.android.launcher3.util.SafeCloseable
@@ -60,6 +59,8 @@ import kotlinx.coroutines.flow.drop
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.serialization.encodeToString
+import app.lawnchair.preferences.PreferenceManager as LawnchairPreferenceManager
+import com.android.launcher3.graphics.IconShape as L3IconShape
 
 class PreferenceManager2 private constructor(private val context: Context) : PreferenceManager, SafeCloseable {
 
@@ -504,7 +505,7 @@ class PreferenceManager2 private constructor(private val context: Context) : Pre
 
     val folderColumns = idpPreference(
         key = intPreferencesKey(name = "folder_columns"),
-        defaultSelector = { numFolderColumns },
+        defaultSelector = { numFolderColumns[INDEX_DEFAULT] },
         onSet = { reloadHelper.reloadGrid() },
     )
 
@@ -626,7 +627,7 @@ class PreferenceManager2 private constructor(private val context: Context) : Pre
             .distinctUntilChanged()
             .onEach { shape ->
                 initializeIconShape(shape)
-                L3IconShape.init(context)
+                L3IconShape.INSTANCE.get(context)
                 LauncherAppState.getInstance(context).reloadIcons()
             }
             .launchIn(scope)
diff --git a/lawnchair/src/app/lawnchair/preferences2/ReloadHelper.kt b/lawnchair/src/app/lawnchair/preferences2/ReloadHelper.kt
index db8ff450b8..096df8a8a2 100644
--- a/lawnchair/src/app/lawnchair/preferences2/ReloadHelper.kt
+++ b/lawnchair/src/app/lawnchair/preferences2/ReloadHelper.kt
@@ -48,7 +48,7 @@ class ReloadHelper(private val context: Context) {
 
     fun reloadTaskbar() {
         tisBinder.runOnBindToTouchInteractionService {
-            tis?.taskbarManager?.onUserPreferenceChanged()
+            tis?.taskbarManager?.recreateTaskbar()
         }
     }
 }
diff --git a/lawnchair/src/app/lawnchair/qsb/LawnQsbLayout.kt b/lawnchair/src/app/lawnchair/qsb/LawnQsbLayout.kt
index 359f8662e7..27d1a49f0e 100644
--- a/lawnchair/src/app/lawnchair/qsb/LawnQsbLayout.kt
+++ b/lawnchair/src/app/lawnchair/qsb/LawnQsbLayout.kt
@@ -110,7 +110,7 @@ class LawnQsbLayout(context: Context, attrs: AttributeSet?) : FrameLayout(contex
             val launcher = context.launcher
             launcher.lifecycleScope.launch {
                 if (preferenceManager2.matchHotseatQsbStyle.firstBlocking()) {
-                    launcher.appsView.searchUiManager.editText?.showKeyboard(true)
+                    launcher.appsView.searchUiManager.editText?.showKeyboard()
                     launcher.animateToAllApps()
                 } else {
                     searchProvider.launch(launcher)
diff --git a/lawnchair/src/app/lawnchair/qsb/providers/AppSearch.kt b/lawnchair/src/app/lawnchair/qsb/providers/AppSearch.kt
index f79d810880..7ca0685472 100644
--- a/lawnchair/src/app/lawnchair/qsb/providers/AppSearch.kt
+++ b/lawnchair/src/app/lawnchair/qsb/providers/AppSearch.kt
@@ -16,6 +16,6 @@ data object AppSearch : QsbSearchProvider(
 ) {
     override suspend fun launch(launcher: Launcher, forceWebsite: Boolean) {
         launcher.animateToAllApps()
-        launcher.appsView.searchUiManager.editText?.showKeyboard(true)
+        launcher.appsView.searchUiManager.editText?.showKeyboard()
     }
 }
diff --git a/lawnchair/src/app/lawnchair/qsb/providers/Startpage.kt b/lawnchair/src/app/lawnchair/qsb/providers/Startpage.kt
index cc3cac1929..4f1a874bc0 100644
--- a/lawnchair/src/app/lawnchair/qsb/providers/Startpage.kt
+++ b/lawnchair/src/app/lawnchair/qsb/providers/Startpage.kt
@@ -22,7 +22,7 @@ data object Startpage : QsbSearchProvider(
 
         if (useWebSuggestions) {
             launcher.animateToAllApps()
-            launcher.appsView.searchUiManager.editText?.showKeyboard(true)
+            launcher.appsView.searchUiManager.editText?.showKeyboard()
         } else {
             super.launch(launcher, forceWebsite)
         }
diff --git a/lawnchair/src/app/lawnchair/root/RootHelperManager.kt b/lawnchair/src/app/lawnchair/root/RootHelperManager.kt
index 973d5dcbec..01e7365174 100644
--- a/lawnchair/src/app/lawnchair/root/RootHelperManager.kt
+++ b/lawnchair/src/app/lawnchair/root/RootHelperManager.kt
@@ -6,11 +6,9 @@ import android.content.Intent
 import android.content.ServiceConnection
 import android.os.IBinder
 import app.lawnchair.preferences.PreferenceManager
-import com.android.launcher3.util.MainThreadInitializedObject
+import app.lawnchair.util.MainThreadInitializedObject
 import com.topjohnwu.superuser.Shell
 import com.topjohnwu.superuser.ipc.RootService
-import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
 import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Dispatchers
@@ -18,6 +16,8 @@ import kotlinx.coroutines.MainScope
 import kotlinx.coroutines.async
 import kotlinx.coroutines.plus
 import kotlinx.coroutines.withContext
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
 
 class RootHelperManager(private val context: Context) {
     private val scope = MainScope() + CoroutineName("RootHelperManager")
diff --git a/lawnchair/src/app/lawnchair/search/adapter/SearchTargetCompat.kt b/lawnchair/src/app/lawnchair/search/adapter/SearchTargetCompat.kt
index 0c46b6fe47..a7489193b9 100644
--- a/lawnchair/src/app/lawnchair/search/adapter/SearchTargetCompat.kt
+++ b/lawnchair/src/app/lawnchair/search/adapter/SearchTargetCompat.kt
@@ -138,7 +138,7 @@ data class SearchTargetCompat(
             from.isHidden(),
             from.getPackageName(),
             from.getUserHandle(),
-            SearchActionCompat.wrap(from.getSearchAction()),
+            from.getSearchAction()?.let { SearchActionCompat.wrap(it) },
             from.getShortcutInfo(),
             from.getSliceUri(),
             from.getAppWidgetProviderInfo(),
diff --git a/lawnchair/src/app/lawnchair/search/algorithms/LawnchairASISearchAlgorithm.kt b/lawnchair/src/app/lawnchair/search/algorithms/LawnchairASISearchAlgorithm.kt
index f4e4b4e5a6..bd9be574bd 100644
--- a/lawnchair/src/app/lawnchair/search/algorithms/LawnchairASISearchAlgorithm.kt
+++ b/lawnchair/src/app/lawnchair/search/algorithms/LawnchairASISearchAlgorithm.kt
@@ -46,8 +46,8 @@ class LawnchairASISearchAlgorithm(context: Context) :
         activeQuery?.cancel()
         searchSession ?: return
         activeQuery = PendingQuery(query, callback)
-        val searchQuery = Query(query, System.currentTimeMillis(), null)
-        searchSession!!.query(searchQuery, Executors.MAIN_EXECUTOR, activeQuery)
+        val searchQuery = Query(query, System.currentTimeMillis())
+//        searchSession!!.query(searchQuery, Executors.MAIN_EXECUTOR, null)
     }
 
     override fun cancel(interruptActiveRequests: Boolean) {
@@ -130,7 +130,7 @@ class LawnchairASISearchAlgorithm(context: Context) :
                 val searchContext = SearchContext(1 or 2, 200, Bundle())
                 val searchManager = context.requireSystemService<SearchUiManager>()
                 val searchSession: SearchSession = searchManager.createSearchSession(searchContext)
-                val searchQuery = Query("dummy", System.currentTimeMillis(), null)
+                val searchQuery = Query("dummy", System.currentTimeMillis())
                 val prefs = PreferenceManager.getInstance(context)
                 val checkDone = AtomicBoolean(false)
                 searchSession.query(searchQuery, Executors.MAIN_EXECUTOR) { targets ->
diff --git a/lawnchair/src/app/lawnchair/search/algorithms/LawnchairAppSearchAlgorithm.kt b/lawnchair/src/app/lawnchair/search/algorithms/LawnchairAppSearchAlgorithm.kt
index ec2ac6231f..68480507fe 100644
--- a/lawnchair/src/app/lawnchair/search/algorithms/LawnchairAppSearchAlgorithm.kt
+++ b/lawnchair/src/app/lawnchair/search/algorithms/LawnchairAppSearchAlgorithm.kt
@@ -8,10 +8,11 @@ import app.lawnchair.search.adapter.SearchTargetCompat
 import app.lawnchair.search.adapter.SearchTargetFactory
 import app.lawnchair.util.isDefaultLauncher
 import com.android.launcher3.LauncherAppState
+import com.android.launcher3.LauncherModel
 import com.android.launcher3.allapps.BaseAllAppsAdapter
 import com.android.launcher3.model.AllAppsList
-import com.android.launcher3.model.BaseModelUpdateTask
 import com.android.launcher3.model.BgDataModel
+import com.android.launcher3.model.ModelTaskController
 import com.android.launcher3.model.data.AppInfo
 import com.android.launcher3.search.SearchCallback
 import com.android.launcher3.util.Executors
@@ -54,8 +55,8 @@ class LawnchairAppSearchAlgorithm(context: Context) : LawnchairSearchAlgorithm(c
     }
 
     override fun doSearch(query: String, callback: SearchCallback<BaseAllAppsAdapter.AdapterItem>) {
-        appState.model.enqueueModelUpdateTask(object : BaseModelUpdateTask() {
-            override fun execute(app: LauncherAppState, dataModel: BgDataModel, apps: AllAppsList) {
+        appState.model.enqueueModelUpdateTask(object: LauncherModel.ModelUpdateTask {
+            override fun execute(app: ModelTaskController, dataModel: BgDataModel, apps: AllAppsList) {
                 coroutineScope.launch(Dispatchers.Main) {
                     val results = getResult(apps.data, query)
                     callback.onSearchResult(query, results)
diff --git a/lawnchair/src/app/lawnchair/smartspace/BcSmartspaceView.kt b/lawnchair/src/app/lawnchair/smartspace/BcSmartspaceView.kt
index 15395a9be4..323a8270e4 100644
--- a/lawnchair/src/app/lawnchair/smartspace/BcSmartspaceView.kt
+++ b/lawnchair/src/app/lawnchair/smartspace/BcSmartspaceView.kt
@@ -16,9 +16,9 @@ import app.lawnchair.smartspace.model.SmartspaceTarget
 import app.lawnchair.smartspace.provider.SmartspaceProvider
 import app.lawnchair.util.repeatOnAttached
 import com.android.launcher3.R
-import kotlin.math.roundToInt
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
+import kotlin.math.roundToInt
 
 class BcSmartspaceView @JvmOverloads constructor(
     context: Context,
@@ -37,9 +37,9 @@ class BcSmartspaceView @JvmOverloads constructor(
 
     override fun onFinishInflate() {
         super.onFinishInflate()
-        viewPager = findViewById(R.id.smartspace_card_pager)
+        viewPager = findViewById<ViewPager>(R.id.smartspace_card_pager)!!
         viewPager.isSaveEnabled = false
-        indicator = findViewById(R.id.smartspace_page_indicator)
+        indicator = findViewById<PageIndicator>(R.id.smartspace_page_indicator)!!
 
         viewPager.addOnPageChangeListener(object : ViewPager.OnPageChangeListener {
             override fun onPageScrolled(
diff --git a/lawnchair/src/app/lawnchair/ui/popup/LawnchairShortcut.kt b/lawnchair/src/app/lawnchair/ui/popup/LawnchairShortcut.kt
index ac3fe064f3..e119b4498c 100644
--- a/lawnchair/src/app/lawnchair/ui/popup/LawnchairShortcut.kt
+++ b/lawnchair/src/app/lawnchair/ui/popup/LawnchairShortcut.kt
@@ -23,13 +23,13 @@ import com.android.launcher3.LauncherSettings.Favorites.ITEM_TYPE_TASK
 import com.android.launcher3.R
 import com.android.launcher3.Utilities
 import com.android.launcher3.icons.BitmapInfo
-import com.android.launcher3.model.data.AppInfo as ModelAppInfo
 import com.android.launcher3.model.data.ItemInfo
 import com.android.launcher3.popup.SystemShortcut
 import com.android.launcher3.util.ComponentKey
 import com.android.launcher3.util.PackageManagerHelper
 import com.patrykmichalik.opto.core.firstBlocking
 import java.net.URISyntaxException
+import com.android.launcher3.model.data.AppInfo as ModelAppInfo
 
 class LawnchairShortcut {
 
@@ -121,7 +121,7 @@ class LawnchairShortcut {
             if (intent != null) {
                 val info: LauncherActivityInfo? =
                     context.getSystemService(LauncherApps::class.java)
-                        .resolveActivity(intent, user)
+                        ?.resolveActivity(intent, user)
                 if (info != null && (info.applicationInfo.flags and ApplicationInfo.FLAG_SYSTEM) == 0) {
                     return info.componentName
                 }
diff --git a/lawnchair/src/app/lawnchair/ui/preferences/components/NotificationDotsPreference.kt b/lawnchair/src/app/lawnchair/ui/preferences/components/NotificationDotsPreference.kt
index 7bb273dbd5..fbf85375ee 100644
--- a/lawnchair/src/app/lawnchair/ui/preferences/components/NotificationDotsPreference.kt
+++ b/lawnchair/src/app/lawnchair/ui/preferences/components/NotificationDotsPreference.kt
@@ -48,8 +48,8 @@ import app.lawnchair.ui.util.bottomSheetHandler
 import app.lawnchair.util.lifecycleState
 import com.android.launcher3.R
 import com.android.launcher3.notification.NotificationListener
-import com.android.launcher3.settings.SettingsActivity.EXTRA_FRAGMENT_ARG_KEY
-import com.android.launcher3.settings.SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGS
+import com.android.launcher3.settings.SettingsActivity.EXTRA_FRAGMENT_ARGS
+import com.android.launcher3.settings.SettingsActivity.EXTRA_FRAGMENT_HIGHLIGHT_KEY
 import com.android.launcher3.util.SettingsCache
 import com.android.launcher3.util.SettingsCache.NOTIFICATION_BADGING_URI
 import kotlinx.coroutines.channels.awaitClose
@@ -96,9 +96,9 @@ fun NotificationDotsPreference(
                         }
                     }
                 } else {
-                    val extras = bundleOf(EXTRA_FRAGMENT_ARG_KEY to "notification_badging")
+                    val extras = bundleOf(EXTRA_FRAGMENT_HIGHLIGHT_KEY to "notification_badging")
                     val intent = Intent("android.settings.NOTIFICATION_SETTINGS")
-                        .putExtra(EXTRA_SHOW_FRAGMENT_ARGS, extras)
+                        .putExtra(EXTRA_FRAGMENT_ARGS, extras)
                     context.startActivity(intent)
                 }
             },
@@ -133,14 +133,14 @@ fun NotificationAccessConfirmation(
                     val cn = ComponentName(context, NotificationListener::class.java)
                     val showFragmentArgs = Bundle()
                     showFragmentArgs.putString(
-                        EXTRA_FRAGMENT_ARG_KEY,
+                        EXTRA_FRAGMENT_HIGHLIGHT_KEY,
                         cn.flattenToString(),
                     )
 
                     val intent = Intent(Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS)
                         .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                        .putExtra(EXTRA_FRAGMENT_ARG_KEY, cn.flattenToString())
-                        .putExtra(EXTRA_SHOW_FRAGMENT_ARGS, showFragmentArgs)
+                        .putExtra(EXTRA_FRAGMENT_HIGHLIGHT_KEY, cn.flattenToString())
+                        .putExtra(EXTRA_FRAGMENT_ARGS, showFragmentArgs)
                     context.startActivity(intent)
                 },
             ) {
diff --git a/lawnchair/src/app/lawnchair/ui/preferences/components/colorpreference/ColorPreferenceModelList.kt b/lawnchair/src/app/lawnchair/ui/preferences/components/colorpreference/ColorPreferenceModelList.kt
index 222c23431f..a4417b6db1 100644
--- a/lawnchair/src/app/lawnchair/ui/preferences/components/colorpreference/ColorPreferenceModelList.kt
+++ b/lawnchair/src/app/lawnchair/ui/preferences/components/colorpreference/ColorPreferenceModelList.kt
@@ -2,8 +2,8 @@ package app.lawnchair.ui.preferences.components.colorpreference
 
 import android.content.Context
 import app.lawnchair.preferences2.PreferenceManager2
+import app.lawnchair.util.MainThreadInitializedObject
 import com.android.launcher3.R
-import com.android.launcher3.util.MainThreadInitializedObject
 
 class ColorPreferenceModelList(context: Context) {
     private val models = mutableMapOf<String, ColorPreferenceModel>()
diff --git a/lawnchair/src/app/lawnchair/ui/preferences/data/liveinfo/LiveInformationManager.kt b/lawnchair/src/app/lawnchair/ui/preferences/data/liveinfo/LiveInformationManager.kt
index 55d3104afa..b55aadac06 100644
--- a/lawnchair/src/app/lawnchair/ui/preferences/data/liveinfo/LiveInformationManager.kt
+++ b/lawnchair/src/app/lawnchair/ui/preferences/data/liveinfo/LiveInformationManager.kt
@@ -8,8 +8,8 @@ import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
 import app.lawnchair.ui.preferences.data.liveinfo.model.AnnouncementId
 import app.lawnchair.ui.preferences.data.liveinfo.model.LiveInformation
+import app.lawnchair.util.MainThreadInitializedObject
 import com.android.launcher3.R
-import com.android.launcher3.util.MainThreadInitializedObject
 import com.patrykmichalik.opto.core.PreferenceManager
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
diff --git a/lawnchair/src/app/lawnchair/ui/preferences/destinations/DebugMenuPreferences.kt b/lawnchair/src/app/lawnchair/ui/preferences/destinations/DebugMenuPreferences.kt
index 99ae4a046a..cf74bf841d 100644
--- a/lawnchair/src/app/lawnchair/ui/preferences/destinations/DebugMenuPreferences.kt
+++ b/lawnchair/src/app/lawnchair/ui/preferences/destinations/DebugMenuPreferences.kt
@@ -21,7 +21,7 @@ import app.lawnchair.ui.preferences.components.layout.PreferenceLayout
 import app.lawnchair.ui.preferences.data.liveinfo.liveInformationManager
 import app.lawnchair.ui.preferences.data.liveinfo.model.LiveInformation
 import com.android.launcher3.settings.SettingsActivity
-import com.android.launcher3.uioverrides.flags.DeveloperOptionsFragment
+import com.android.launcher3.uioverrides.flags.DevOptionsUiHelper
 import com.patrykmichalik.opto.domain.Preference
 import kotlinx.coroutines.runBlocking
 
@@ -55,7 +55,7 @@ fun DebugMenuPreferences(
                         Intent(context, SettingsActivity::class.java)
                             .putExtra(
                                 ":settings:fragment",
-                                DeveloperOptionsFragment::class.java.name,
+                                DevOptionsUiHelper::class.java.name,
                             )
                             .also { context.startActivity(it) }
                     },
diff --git a/lawnchair/src/app/lawnchair/util/AppsList.kt b/lawnchair/src/app/lawnchair/util/AppsList.kt
index 4127be08a1..dca4b0c945 100644
--- a/lawnchair/src/app/lawnchair/util/AppsList.kt
+++ b/lawnchair/src/app/lawnchair/util/AppsList.kt
@@ -48,12 +48,14 @@ fun appsState(
         Utilities.postAsyncCallback(Handler(MODEL_EXECUTOR.looper)) {
             val launcherApps = context.getSystemService(LauncherApps::class.java)
 
-            appsState.value = UserCache.INSTANCE.get(context).userProfiles.asSequence()
-                .flatMap { launcherApps.getActivityList(null, it) }
-                .filter { filter.shouldShowApp(it.componentName) }
-                .map { App(context, it) }
-                .sortedWith(comparator)
-                .toList()
+            if (launcherApps != null) {
+                appsState.value = UserCache.INSTANCE.get(context).userProfiles.asSequence()
+                    .flatMap { launcherApps.getActivityList(null, it) }
+                    .filter { filter.shouldShowApp(it.componentName) }
+                    .map { App(context, it) }
+                    .sortedWith(comparator)
+                    .toList()
+            }
         }
         onDispose { }
     }
diff --git a/lawnchair/src/app/lawnchair/util/LawnchairUtils.kt b/lawnchair/src/app/lawnchair/util/LawnchairUtils.kt
index 2839a1ed4d..37c12827c6 100644
--- a/lawnchair/src/app/lawnchair/util/LawnchairUtils.kt
+++ b/lawnchair/src/app/lawnchair/util/LawnchairUtils.kt
@@ -53,13 +53,13 @@ import com.android.launcher3.util.Themes
 import com.android.systemui.shared.system.QuickStepContract
 import com.google.android.renderscript.Toolkit
 import com.patrykmichalik.opto.core.firstBlocking
+import kotlinx.serialization.json.Json
+import org.json.JSONArray
 import java.util.concurrent.Callable
 import java.util.concurrent.ExecutionException
 import kotlin.math.max
 import kotlin.math.roundToInt
 import kotlin.system.exitProcess
-import kotlinx.serialization.json.Json
-import org.json.JSONArray
 
 fun <T, A> ensureOnMainThread(creator: (A) -> T): (A) -> T = { it ->
     if (Looper.myLooper() == Looper.getMainLooper()) {
@@ -184,9 +184,9 @@ fun getAllAppsScrimColor(context: Context): Int {
 fun Context.checkPackagePermission(packageName: String, permissionName: String): Boolean {
     try {
         val info = packageManager.getPackageInfo(packageName, PackageManager.GET_PERMISSIONS)
-        info.requestedPermissions.forEachIndexed { index, s ->
+        info.requestedPermissions?.forEachIndexed { index, s ->
             if (s == permissionName) {
-                return info.requestedPermissionsFlags[index].hasFlag(REQUESTED_PERMISSION_GRANTED)
+                return info.requestedPermissionsFlags?.get(index)?.hasFlag(REQUESTED_PERMISSION_GRANTED)!!
             }
         }
     } catch (_: PackageManager.NameNotFoundException) {
diff --git a/lawnchair/src/app/lawnchair/util/LawnchairWindowManagerProxy.kt b/lawnchair/src/app/lawnchair/util/LawnchairWindowManagerProxy.kt
index 2a424cecc8..cd1ded4c53 100644
--- a/lawnchair/src/app/lawnchair/util/LawnchairWindowManagerProxy.kt
+++ b/lawnchair/src/app/lawnchair/util/LawnchairWindowManagerProxy.kt
@@ -35,7 +35,7 @@ class LawnchairWindowManagerProxy(context: Context) : WindowManagerProxy(Utiliti
             val result = ArrayMap<CachedDisplayInfo, List<WindowBounds>>()
             val windowManager = displayInfoContext.getSystemService(WindowManager::class.java)
             val possibleMaximumWindowMetrics =
-                windowManager.getPossibleMaximumWindowMetrics(DEFAULT_DISPLAY)
+                windowManager!!.getPossibleMaximumWindowMetrics(DEFAULT_DISPLAY)
             for (windowMetrics in possibleMaximumWindowMetrics) {
                 val info = getDisplayInfo(windowMetrics, Surface.ROTATION_0)
                 val bounds = estimateWindowBounds(displayInfoContext, info)
diff --git a/lawnchair/src/app/lawnchair/util/MainThreadInitializedObject.java b/lawnchair/src/app/lawnchair/util/MainThreadInitializedObject.java
new file mode 100644
index 0000000000..ac48d829e5
--- /dev/null
+++ b/lawnchair/src/app/lawnchair/util/MainThreadInitializedObject.java
@@ -0,0 +1,162 @@
+package app.lawnchair.util;
+
+import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
+
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.os.Looper;
+import android.util.Log;
+
+import androidx.annotation.UiThread;
+import androidx.annotation.VisibleForTesting;
+
+import com.android.launcher3.util.ResourceBasedOverride;
+import com.android.launcher3.util.ResourceBasedOverride.Overrides;
+import com.android.launcher3.util.SafeCloseable;
+import com.android.launcher3.util.TraceHelper;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+
+/**
+ * Utility class for defining singletons which are initiated on main thread.
+ */
+public class MainThreadInitializedObject<T> {
+
+    private final ObjectProvider<T> mProvider;
+    private T mValue;
+
+    public MainThreadInitializedObject(ObjectProvider<T> provider) {
+        mProvider = provider;
+    }
+
+    public T get(Context context) {
+        if (context instanceof SandboxContext sc) {
+            return sc.getObject(this);
+        }
+
+        if (mValue == null) {
+            if (Looper.myLooper() == Looper.getMainLooper()) {
+                mValue = TraceHelper.allowIpcs("main.thread.object",
+                        () -> mProvider.get(context.getApplicationContext()));
+                onPostInit(context);
+            } else {
+                try {
+                    return MAIN_EXECUTOR.submit(() -> get(context)).get();
+                } catch (InterruptedException | ExecutionException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+        return mValue;
+    }
+
+    protected void onPostInit(Context context) {
+    }
+
+    public T getNoCreate() {
+        return mValue;
+    }
+
+    @VisibleForTesting
+    public void initializeForTesting(T value) {
+        mValue = value;
+    }
+
+    /**
+     * Initializes a provider based on resource overrides
+     */
+    public static <T extends ResourceBasedOverride> MainThreadInitializedObject<T> forOverride(
+            Class<T> clazz, int resourceId) {
+        return new MainThreadInitializedObject<>(c -> Overrides.getObject(clazz, c, resourceId));
+    }
+
+    public interface ObjectProvider<T> {
+
+        T get(Context context);
+    }
+
+    /**
+     * Abstract Context which allows custom implementations for
+     * {@link MainThreadInitializedObject} providers
+     */
+    public static abstract class SandboxContext extends ContextWrapper {
+
+        private static final String TAG = "SandboxContext";
+
+        protected final Set<MainThreadInitializedObject> mAllowedObjects;
+        protected final Map<MainThreadInitializedObject, Object> mObjectMap = new HashMap<>();
+        protected final ArrayList<Object> mOrderedObjects = new ArrayList<>();
+
+        private final Object mDestroyLock = new Object();
+        private boolean mDestroyed = false;
+
+        public SandboxContext(Context base, MainThreadInitializedObject... allowedObjects) {
+            super(base);
+            mAllowedObjects = new HashSet<>(Arrays.asList(allowedObjects));
+        }
+
+        @Override
+        public Context getApplicationContext() {
+            return this;
+        }
+
+        public void onDestroy() {
+            synchronized (mDestroyLock) {
+                // Destroy in reverse order
+                for (int i = mOrderedObjects.size() - 1; i >= 0; i--) {
+                    Object o = mOrderedObjects.get(i);
+                    if (o instanceof SafeCloseable) {
+                        ((SafeCloseable) o).close();
+                    }
+                }
+                mDestroyed = true;
+            }
+        }
+
+        /**
+         * Find a cached object from mObjectMap if we have already created one. If not,
+         * generate
+         * an object using the provider.
+         */
+        protected <T> T getObject(MainThreadInitializedObject<T> object) {
+            synchronized (mDestroyLock) {
+                if (mDestroyed) {
+                    Log.e(TAG, "Static object access with a destroyed context");
+                }
+                T t = (T) mObjectMap.get(object);
+                if (t != null) {
+                    return t;
+                }
+                if (Looper.myLooper() == Looper.getMainLooper()) {
+                    t = createObject(object);
+                    // Check if we've explicitly allowed the object or if it's a SafeCloseable,
+                    // it will get destroyed in onDestroy()
+                    if (!mAllowedObjects.contains(object) && !(t instanceof SafeCloseable)) {
+                        throw new IllegalStateException("Leaking unknown objects "
+                                + object + "  " + object.mProvider + " " + t);
+                    }
+                    mObjectMap.put(object, t);
+                    mOrderedObjects.add(t);
+                    return t;
+                }
+            }
+
+            try {
+                return MAIN_EXECUTOR.submit(() -> getObject(object)).get();
+            } catch (InterruptedException | ExecutionException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        @UiThread
+        protected <T> T createObject(MainThreadInitializedObject<T> object) {
+            return object.mProvider.get(this);
+        }
+    }
+}
diff --git a/lawnchair/src/app/lawnchair/util/TaskUtilLockState.kt b/lawnchair/src/app/lawnchair/util/TaskUtilLockState.kt
index e2b3b1cb77..0e82aaa794 100644
--- a/lawnchair/src/app/lawnchair/util/TaskUtilLockState.kt
+++ b/lawnchair/src/app/lawnchair/util/TaskUtilLockState.kt
@@ -67,7 +67,7 @@ object TaskUtilLockState {
             .getTaskLockState(componentName.toShortString(), taskKey.userId)
         Log.d(TAG, "updateSpecifiedTaskLockState: Checking if the task is locked: $taskLockState")
         if (taskLockState) {
-            setTaskLockState(context, taskKey.baseIntent.component, taskLockState, taskKey)
+            taskKey.baseIntent.component?.let { setTaskLockState(context, it, taskLockState, taskKey) }
             Log.i(TAG, "updateSpecifiedTaskLockState: Task is locked, clearing the lock state.")
         }
         return taskLockState
diff --git a/lawnchair/src/app/lawnchair/views/LauncherPreviewView.kt b/lawnchair/src/app/lawnchair/views/LauncherPreviewView.kt
index e910f75483..85430493dc 100644
--- a/lawnchair/src/app/lawnchair/views/LauncherPreviewView.kt
+++ b/lawnchair/src/app/lawnchair/views/LauncherPreviewView.kt
@@ -15,9 +15,9 @@ import com.android.launcher3.InvariantDeviceProfile
 import com.android.launcher3.LauncherAppState
 import com.android.launcher3.R
 import com.android.launcher3.graphics.LauncherPreviewRenderer
+import com.android.launcher3.model.BaseLauncherBinder
 import com.android.launcher3.model.BgDataModel
 import com.android.launcher3.model.GridSizeMigrationUtil
-import com.android.launcher3.model.LauncherBinder
 import com.android.launcher3.model.LoaderTask
 import com.android.launcher3.model.ModelDelegate
 import com.android.launcher3.util.ComponentKey
@@ -89,8 +89,8 @@ class LauncherPreviewView(
                 LauncherAppState.getInstance(previewContext),
                 null,
                 BgDataModel(),
-                ModelDelegate(),
-                LauncherBinder(
+                ModelDelegate(context),
+                BaseLauncherBinder(
                     LauncherAppState.getInstance(previewContext),
                     BgDataModel(),
                     null,
@@ -102,6 +102,7 @@ class LauncherPreviewView(
                         emptyList(),
                         "",
                         null,
+                        null
                     )
                     MAIN_EXECUTOR.execute {
                         renderView(previewContext, mBgDataModel, mWidgetProvidersMap)
diff --git a/lawnchair/src/app/lawnchair/wallpaper/WallpaperManagerCompat.kt b/lawnchair/src/app/lawnchair/wallpaper/WallpaperManagerCompat.kt
index 0f75358a94..2aa6ac266e 100644
--- a/lawnchair/src/app/lawnchair/wallpaper/WallpaperManagerCompat.kt
+++ b/lawnchair/src/app/lawnchair/wallpaper/WallpaperManagerCompat.kt
@@ -2,13 +2,12 @@ package app.lawnchair.wallpaper
 
 import android.app.WallpaperManager
 import android.content.Context
+import app.lawnchair.util.MainThreadInitializedObject
 import app.lawnchair.util.requireSystemService
 import app.lawnchair.wallpaper.WallpaperColorsCompat.Companion.HINT_SUPPORTS_DARK_THEME
 import com.android.launcher3.Utilities
-import com.android.launcher3.util.MainThreadInitializedObject
-import com.android.launcher3.util.SafeCloseable
 
-sealed class WallpaperManagerCompat(val context: Context) : SafeCloseable {
+sealed class WallpaperManagerCompat(val context: Context) {
 
     private val listeners = mutableListOf<OnColorsChangedListener>()
     private val colorHints: Int get() = wallpaperColors?.colorHints ?: 0
diff --git a/lawnchair/src/com/android/launcher3/BuildConfigs.java b/lawnchair/src/com/android/launcher3/BuildConfigs.java
new file mode 100644
index 0000000000..24e7296e5b
--- /dev/null
+++ b/lawnchair/src/com/android/launcher3/BuildConfigs.java
@@ -0,0 +1,43 @@
+package com.android.launcher3;
+
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public final class BuildConfigs {
+    public static final String APPLICATION_ID = "com.android.launcher3";
+
+    public static final boolean IS_STUDIO_BUILD = false;
+    /**
+     * Flag to state if the QSB is on the first screen and placed on the top,
+     * this can be overwritten in other launchers with a different value, if needed.
+     */
+    public static final boolean QSB_ON_FIRST_SCREEN = true;
+
+    /**
+     * Flag to state if the widget on the top of the first screen should be shown.
+     */
+    public static final boolean WIDGET_ON_FIRST_SCREEN = false;
+
+    /**
+     * Flag to control various developer centric features
+     */
+    public static final boolean IS_DEBUG_DEVICE = false;
+
+    // Flag to control widgets support in Launcher
+    public static final boolean WIDGETS_ENABLED = false;
+    // Flag to control notification dots support in Launcher
+    public static final boolean NOTIFICATION_DOTS_ENABLED = false;
+}
diff --git a/lawnchair/src/com/android/systemui/shared/system/TonalCompat.java b/lawnchair/src/com/android/systemui/shared/system/TonalCompat.java
new file mode 100644
index 0000000000..4a0f89b7dc
--- /dev/null
+++ b/lawnchair/src/com/android/systemui/shared/system/TonalCompat.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.systemui.shared.system;
+
+import android.app.WallpaperColors;
+import android.content.Context;
+
+import com.android.internal.colorextraction.ColorExtractor.GradientColors;
+import com.android.internal.colorextraction.types.Tonal;
+
+public class TonalCompat {
+
+    private final Tonal mTonal;
+
+    public TonalCompat(Context context) {
+        mTonal = new Tonal(context);
+    }
+
+    public ExtractionInfo extractDarkColors(WallpaperColors colors) {
+        GradientColors darkColors = new GradientColors();
+        mTonal.extractInto(colors, new GradientColors(), darkColors, new GradientColors());
+
+        ExtractionInfo result = new ExtractionInfo();
+        result.mainColor = darkColors.getMainColor();
+        result.secondaryColor = darkColors.getSecondaryColor();
+        result.supportsDarkText = darkColors.supportsDarkText();
+        if (colors != null) {
+            result.supportsDarkTheme =
+                    (colors.getColorHints() & WallpaperColors.HINT_SUPPORTS_DARK_THEME) != 0;
+        }
+        return result;
+    }
+
+    public static class ExtractionInfo {
+        public int mainColor;
+        public int secondaryColor;
+        public boolean supportsDarkText;
+        public boolean supportsDarkTheme;
+    }
+}
diff --git a/platform_frameworks_libs_systemui b/platform_frameworks_libs_systemui
index c6838df075..77fb07282f 160000
--- a/platform_frameworks_libs_systemui
+++ b/platform_frameworks_libs_systemui
@@ -1 +1 @@
-Subproject commit c6838df07590593b7961db6251dd34c269017a3b
+Subproject commit 77fb07282fdbd6f6ac9117f1dd097ebf5f2b4ceb
diff --git a/prebuilts/libs/SystemUI-statsd-15.jar b/prebuilts/libs/SystemUI-statsd-15.jar
new file mode 100644
index 0000000000..1b068ff89c
Binary files /dev/null and b/prebuilts/libs/SystemUI-statsd-15.jar differ
diff --git a/proguard.flags b/proguard.flags
index 31edd8d88c..d0f40eb31f 100644
--- a/proguard.flags
+++ b/proguard.flags
@@ -57,3 +57,11 @@
 -keep class com.android.quickstep.** {
   *;
 }
+
+-keep interface androidx.dynamicanimation.animation.AnimationHandler.** {
+  *;
+}
+
+-keep class androidx.dynamicanimation.animation.** {
+  *;
+}
diff --git a/quickstep/src/com/android/launcher3/LauncherAnimationRunner.java b/quickstep/src/com/android/launcher3/LauncherAnimationRunner.java
index db900728b9..f30cebc8f8 100644
--- a/quickstep/src/com/android/launcher3/LauncherAnimationRunner.java
+++ b/quickstep/src/com/android/launcher3/LauncherAnimationRunner.java
@@ -25,6 +25,7 @@ import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
 import android.content.Context;
+import android.os.Build;
 import android.os.Handler;
 import android.os.RemoteException;
 import android.view.IRemoteAnimationFinishedCallback;
diff --git a/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java b/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java
index c4ec714aa5..a90bd9b809 100644
--- a/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java
+++ b/quickstep/src/com/android/launcher3/QuickstepTransitionManager.java
@@ -22,6 +22,8 @@ import static android.app.WindowConfiguration.WINDOWING_MODE_MULTI_WINDOW;
 import static android.provider.Settings.Secure.LAUNCHER_TASKBAR_EDUCATION_SHOWING;
 import static android.view.RemoteAnimationTarget.MODE_CLOSING;
 import static android.view.RemoteAnimationTarget.MODE_OPENING;
+import static android.view.Surface.ROTATION_0;
+import static android.view.Surface.ROTATION_180;
 import static android.view.WindowManager.TRANSIT_CLOSE;
 import static android.view.WindowManager.TRANSIT_FLAG_KEYGUARD_GOING_AWAY;
 import static android.view.WindowManager.TRANSIT_OPEN;
@@ -41,6 +43,7 @@ import static com.android.launcher3.BaseActivity.INVISIBLE_ALL;
 import static com.android.launcher3.BaseActivity.INVISIBLE_BY_APP_TRANSITIONS;
 import static com.android.launcher3.BaseActivity.INVISIBLE_BY_PENDING_FLAGS;
 import static com.android.launcher3.BaseActivity.PENDING_INVISIBLE_BY_WALLPAPER_ANIMATION;
+import static com.android.launcher3.Flags.enableScalingRevealHomeAnimation;
 import static com.android.launcher3.LauncherAnimUtils.SCALE_PROPERTY;
 import static com.android.launcher3.LauncherAnimUtils.VIEW_BACKGROUND_COLOR;
 import static com.android.launcher3.LauncherState.ALL_APPS;
@@ -53,15 +56,18 @@ import static com.android.launcher3.config.FeatureFlags.ENABLE_SCRIM_FOR_APP_LAU
 import static com.android.launcher3.config.FeatureFlags.KEYGUARD_ANIMATION;
 import static com.android.launcher3.config.FeatureFlags.SEPARATE_RECENTS_ACTIVITY;
 import static com.android.launcher3.model.data.ItemInfo.NO_MATCHING_ID;
+import static com.android.launcher3.testing.shared.TestProtocol.WALLPAPER_OPEN_ANIMATION_FINISHED_MESSAGE;
 import static com.android.launcher3.util.DisplayController.isTransientTaskbar;
+import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
+import static com.android.launcher3.util.Executors.ORDERED_BG_EXECUTOR;
 import static com.android.launcher3.util.MultiPropertyFactory.MULTI_PROPERTY_VALUE;
 import static com.android.launcher3.util.window.RefreshRateTracker.getSingleFrameMs;
 import static com.android.launcher3.views.FloatingIconView.SHAPE_PROGRESS_DURATION;
 import static com.android.launcher3.views.FloatingIconView.getFloatingIconView;
 import static com.android.quickstep.TaskAnimationManager.ENABLE_SHELL_TRANSITIONS;
 import static com.android.quickstep.TaskViewUtils.findTaskViewToLaunch;
-import static com.android.systemui.shared.system.InteractionJankMonitorWrapper.CUJ_APP_CLOSE_TO_HOME;
-import static com.android.systemui.shared.system.InteractionJankMonitorWrapper.CUJ_APP_CLOSE_TO_HOME_FALLBACK;
+import static com.android.quickstep.util.AnimUtils.clampToDuration;
+import static com.android.quickstep.util.AnimUtils.completeRunnableListCallback;
 import static com.android.systemui.shared.system.QuickStepContract.getWindowCornerRadius;
 import static com.android.systemui.shared.system.QuickStepContract.supportsRoundedCornersOnWindows;
 
@@ -74,8 +80,8 @@ import android.app.ActivityOptions;
 import android.app.WindowConfiguration;
 import android.content.ComponentName;
 import android.content.Context;
-import android.content.pm.PackageManager;
 import android.content.res.Resources;
+import android.database.ContentObserver;
 import android.graphics.Color;
 import android.graphics.Matrix;
 import android.graphics.Point;
@@ -86,10 +92,12 @@ import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
 import android.os.Handler;
 import android.os.IBinder;
+import android.os.IRemoteCallback;
 import android.os.Looper;
 import android.os.SystemProperties;
 import android.os.UserHandle;
 import android.provider.Settings;
+import android.provider.Settings.Global;
 import android.util.Pair;
 import android.util.Size;
 import android.view.CrossWindowBlurListeners;
@@ -112,10 +120,12 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.core.graphics.ColorUtils;
 
+import com.android.internal.jank.Cuj;
 import com.android.launcher3.DeviceProfile.OnDeviceProfileChangeListener;
 import com.android.launcher3.LauncherAnimationRunner.RemoteAnimationFactory;
 import com.android.launcher3.anim.AnimationSuccessListener;
 import com.android.launcher3.anim.AnimatorListeners;
+import com.android.launcher3.compat.AccessibilityManagerCompat;
 import com.android.launcher3.dragndrop.DragLayer;
 import com.android.launcher3.icons.FastBitmapDrawable;
 import com.android.launcher3.model.data.ItemInfo;
@@ -129,6 +139,7 @@ import com.android.launcher3.util.ActivityOptionsWrapper;
 import com.android.launcher3.util.DynamicResource;
 import com.android.launcher3.util.ObjectWrapper;
 import com.android.launcher3.util.RunnableList;
+import com.android.launcher3.util.Themes;
 import com.android.launcher3.views.FloatingIconView;
 import com.android.launcher3.views.ScrimView;
 import com.android.launcher3.widget.LauncherAppWidgetHostView;
@@ -140,6 +151,7 @@ import com.android.quickstep.util.MultiValueUpdateListener;
 import com.android.quickstep.util.RectFSpringAnim;
 import com.android.quickstep.util.RectFSpringAnim.DefaultSpringConfig;
 import com.android.quickstep.util.RectFSpringAnim.TaskbarHotseatSpringConfig;
+import com.android.quickstep.util.ScalingWorkspaceRevealAnim;
 import com.android.quickstep.util.StaggeredWorkspaceAnim;
 import com.android.quickstep.util.SurfaceTransaction;
 import com.android.quickstep.util.SurfaceTransaction.SurfaceProperties;
@@ -148,46 +160,39 @@ import com.android.quickstep.util.TaskRestartedDuringLaunchListener;
 import com.android.quickstep.util.WorkspaceRevealAnim;
 import com.android.quickstep.views.FloatingWidgetView;
 import com.android.quickstep.views.RecentsView;
-import com.android.systemui.animation.ActivityLaunchAnimator;
-import com.android.systemui.animation.DelegateLaunchAnimatorController;
+import com.android.systemui.animation.ActivityTransitionAnimator;
+import com.android.systemui.animation.DelegateTransitionAnimatorController;
 import com.android.systemui.animation.LaunchableView;
 import com.android.systemui.animation.RemoteAnimationDelegate;
+import com.android.systemui.animation.RemoteAnimationRunnerCompat;
 import com.android.systemui.shared.system.BlurUtils;
 import com.android.systemui.shared.system.InteractionJankMonitorWrapper;
 import com.android.systemui.shared.system.QuickStepContract;
-import com.android.systemui.shared.system.RemoteAnimationRunnerCompat;
 import com.android.wm.shell.startingsurface.IStartingWindowListener;
 
 import java.io.PrintWriter;
+import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 
-import app.lawnchair.LawnchairApp;
-import app.lawnchair.compat.LawnchairQuickstepCompat;
-import app.lawnchair.icons.shape.IconShapeManager;
-import app.lawnchair.theme.color.tokens.ColorTokens;
-
 /**
  * Manages the opening and closing app transitions from Launcher
  */
 public class QuickstepTransitionManager implements OnDeviceProfileChangeListener {
 
-    private static final boolean ENABLE_SHELL_STARTING_SURFACE = SystemProperties
-            .getBoolean("persist.debug.shell_starting_surface", true);
+    private static final boolean ENABLE_SHELL_STARTING_SURFACE =
+            SystemProperties.getBoolean("persist.debug.shell_starting_surface", true);
 
     /** Duration of status bar animations. */
     public static final int STATUS_BAR_TRANSITION_DURATION = 120;
 
     /**
-     * Since our animations decelerate heavily when finishing, we want to start
-     * status bar
+     * Since our animations decelerate heavily when finishing, we want to start status bar
      * animations x ms before the ending.
      */
     public static final int STATUS_BAR_TRANSITION_PRE_DELAY = 96;
 
-    private static final String CONTROL_REMOTE_APP_TRANSITION_PERMISSION = "android.permission.CONTROL_REMOTE_APP_TRANSITION_ANIMATIONS";
-
     public static final long APP_LAUNCH_DURATION = 500;
 
     private static final long APP_LAUNCH_ALPHA_DURATION = 50;
@@ -195,9 +200,12 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
 
     public static final int ANIMATION_NAV_FADE_IN_DURATION = 266;
     public static final int ANIMATION_NAV_FADE_OUT_DURATION = 133;
-    public static final long ANIMATION_DELAY_NAV_FADE_IN = APP_LAUNCH_DURATION - ANIMATION_NAV_FADE_IN_DURATION;
-    public static final Interpolator NAV_FADE_IN_INTERPOLATOR = new PathInterpolator(0f, 0f, 0f, 1f);
-    public static final Interpolator NAV_FADE_OUT_INTERPOLATOR = new PathInterpolator(0.2f, 0f, 1f, 1f);
+    public static final long ANIMATION_DELAY_NAV_FADE_IN =
+            APP_LAUNCH_DURATION - ANIMATION_NAV_FADE_IN_DURATION;
+    public static final Interpolator NAV_FADE_IN_INTERPOLATOR =
+            new PathInterpolator(0f, 0f, 0f, 1f);
+    public static final Interpolator NAV_FADE_OUT_INTERPOLATOR =
+            new PathInterpolator(0.2f, 0f, 1f, 1f);
 
     public static final int RECENTS_LAUNCH_DURATION = 336;
     private static final int LAUNCHER_RESUME_START_DELAY = 100;
@@ -208,10 +216,10 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     public static final int CONTENT_ALPHA_DURATION = 217;
     public static final int TRANSIENT_TASKBAR_TRANSITION_DURATION = 417;
     public static final int TASKBAR_TO_APP_DURATION = 600;
-    // TODO(b/236145847): Tune TASKBAR_TO_HOME_DURATION to 383 after conflict with
-    // unlock animation
+    // TODO(b/236145847): Tune TASKBAR_TO_HOME_DURATION to 383 after conflict with unlock animation
     // is solved.
-    public static final int TASKBAR_TO_HOME_DURATION = 300;
+    private static final int TASKBAR_TO_HOME_DURATION_FAST = 300;
+    private static final int TASKBAR_TO_HOME_DURATION_SLOW = 1000;
     protected static final int CONTENT_SCALE_DURATION = 350;
     protected static final int CONTENT_SCRIM_DURATION = 350;
 
@@ -228,12 +236,22 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     private final float mClosingWindowTransY;
     private final float mMaxShadowRadius;
 
-    private final StartingWindowListener mStartingWindowListener = new StartingWindowListener();
+    private final StartingWindowListener mStartingWindowListener =
+            new StartingWindowListener(this);
+    private ContentObserver mAnimationRemovalObserver = new ContentObserver(
+            ORDERED_BG_EXECUTOR.getHandler()) {
+        @Override
+        public void onChange(boolean selfChange) {
+            mAreAnimationsEnabled = Global.getFloat(mLauncher.getContentResolver(),
+                    Global.ANIMATOR_DURATION_SCALE, 1f) > 0
+                    || Global.getFloat(mLauncher.getContentResolver(),
+                    Global.TRANSITION_ANIMATION_SCALE, 1f) > 0;
+        }
+    };
 
     private DeviceProfile mDeviceProfile;
 
-    // Strong refs to runners which are cleared when the launcher activity is
-    // destroyed
+    // Strong refs to runners which are cleared when the launcher activity is destroyed
     private RemoteAnimationFactory mWallpaperOpenRunner;
     private RemoteAnimationFactory mAppLaunchRunner;
     private RemoteAnimationFactory mKeyguardGoingAwayRunner;
@@ -241,6 +259,8 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     private RemoteAnimationFactory mWallpaperOpenTransitionRunner;
     private RemoteTransition mLauncherOpenTransition;
 
+    private final RemoteAnimationCoordinateTransfer mCoordinateTransfer;
+
     private LauncherBackAnimationController mBackAnimationController;
     private final AnimatorListenerAdapter mForceInvisibleListener = new AnimatorListenerAdapter() {
         @Override
@@ -254,10 +274,10 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         }
     };
 
-    // Pairs of window starting type and starting window background color for
-    // starting tasks
+    // Pairs of window starting type and starting window background color for starting tasks
     // Will never be larger than MAX_NUM_TASKS
     private LinkedHashMap<Integer, Pair<Integer, Integer>> mTaskStartParams;
+    private boolean mAreAnimationsEnabled = true;
 
     private final Interpolator mOpeningXInterpolator;
     private final Interpolator mOpeningInterpolator;
@@ -267,32 +287,31 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         mDragLayer = mLauncher.getDragLayer();
         mHandler = new Handler(Looper.getMainLooper());
         mDeviceProfile = mLauncher.getDeviceProfile();
-        mBackAnimationController = LawnchairApp.isAtleastT() ? new LauncherBackAnimationController(mLauncher, this)
-                : null;
+        mBackAnimationController = new LauncherBackAnimationController(mLauncher, this);
+        checkAndMonitorIfAnimationsAreEnabled();
+
         Resources res = mLauncher.getResources();
         mClosingWindowTransY = res.getDimensionPixelSize(R.dimen.closing_window_trans_y);
         mMaxShadowRadius = res.getDimensionPixelSize(R.dimen.max_shadow_radius);
 
         mLauncher.addOnDeviceProfileChangeListener(this);
 
-        if (supportsSSplashScreen()) {
-            mTaskStartParams = new LinkedHashMap<Integer, Pair<Integer, Integer>>(MAX_NUM_TASKS) {
+        if (ENABLE_SHELL_STARTING_SURFACE) {
+            mTaskStartParams = new LinkedHashMap<>(MAX_NUM_TASKS) {
                 @Override
                 protected boolean removeEldestEntry(Entry<Integer, Pair<Integer, Integer>> entry) {
                     return size() > MAX_NUM_TASKS;
                 }
             };
 
-            if (Utilities.ATLEAST_T) {
-                mStartingWindowListener.setTransitionManager(this);
-                SystemUiProxy.INSTANCE.get(mLauncher).setStartingWindowListener(
-                        mStartingWindowListener);
-            }
+            SystemUiProxy.INSTANCE.get(mLauncher).setStartingWindowListener(
+                    mStartingWindowListener);
         }
 
         mOpeningXInterpolator = AnimationUtils.loadInterpolator(context, R.interpolator.app_open_x);
         mOpeningInterpolator = AnimationUtils.loadInterpolator(context,
                 R.interpolator.emphasized_interpolator);
+        mCoordinateTransfer = new RemoteAnimationCoordinateTransfer(mLauncher);
     }
 
     @Override
@@ -301,9 +320,8 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     }
 
     /**
-     * @return ActivityOptions with remote animations that controls how the window
-     *         of the opening
-     *         targets are displayed.
+     * @return ActivityOptions with remote animations that controls how the window of the opening
+     * targets are displayed.
      */
     public ActivityOptionsWrapper getActivityLaunchOptions(View v) {
         boolean fromRecents = isLaunchingFromRecents(v, null /* targets */);
@@ -318,8 +336,8 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         mAppLaunchRunner = new AppLaunchAnimationRunner(v, onEndCallback);
         ItemInfo tag = (ItemInfo) v.getTag();
         if (tag != null && tag.shouldUseBackgroundAnimation()) {
-            ContainerAnimationRunner containerAnimationRunner = ContainerAnimationRunner.from(v,
-                    mStartingWindowListener, onEndCallback);
+            ContainerAnimationRunner containerAnimationRunner = ContainerAnimationRunner.from(
+                    v, mLauncher, mStartingWindowListener, onEndCallback);
             if (containerAnimationRunner != null) {
                 mAppLaunchRunner = containerAnimationRunner;
             }
@@ -327,8 +345,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         RemoteAnimationRunnerCompat runner = new LauncherAnimationRunner(
                 mHandler, mAppLaunchRunner, true /* startAtFrontOfQueue */);
 
-        // Note that this duration is a guess as we do not know if the animation will be
-        // a
+        // Note that this duration is a guess as we do not know if the animation will be a
         // recents launch or not for sure until we know the opening app targets.
         long duration = fromRecents
                 ? RECENTS_LAUNCH_DURATION
@@ -336,32 +353,29 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
 
         long statusBarTransitionDelay = duration - STATUS_BAR_TRANSITION_DURATION
                 - STATUS_BAR_TRANSITION_PRE_DELAY;
-        ActivityOptions options = LawnchairQuickstepCompat.getActivityOptionsCompat().makeRemoteAnimation(
+        ActivityOptions options = ActivityOptions.makeRemoteAnimation(
                 new RemoteAnimationAdapter(runner, duration, statusBarTransitionDelay),
-                LawnchairQuickstepCompat.getRemoteTransitionCompat().getRemoteTransition(runner.toRemoteTransition(),
-                        mLauncher.getIApplicationThread(), "QuickstepLaunch"),
-                "Lawnchair");
-
+                new RemoteTransition(runner.toRemoteTransition(),
+                        mLauncher.getIApplicationThread(), "QuickstepLaunch"));
+        IRemoteCallback endCallback = completeRunnableListCallback(onEndCallback);
+        options.setOnAnimationAbortListener(endCallback);
+        options.setOnAnimationFinishedListener(endCallback);
         return new ActivityOptionsWrapper(options, onEndCallback);
     }
 
     /**
-     * Whether the launch is a recents app transition and we should do a launch
-     * animation
-     * from the recents view. Note that if the remote animation targets are not
-     * provided, this
-     * may not always be correct as we may resolve the opening app to a task when
-     * the animation
+     * Whether the launch is a recents app transition and we should do a launch animation
+     * from the recents view. Note that if the remote animation targets are not provided, this
+     * may not always be correct as we may resolve the opening app to a task when the animation
      * starts.
      *
      * @param v       the view to launch from
      * @param targets apps that are opening/closing
-     * @return true if the app is launching from recents, false if it most likely is
-     *         not
+     * @return true if the app is launching from recents, false if it most likely is not
      */
     protected boolean isLaunchingFromRecents(@NonNull View v,
                                              @Nullable RemoteAnimationTarget[] targets) {
-        return mLauncher.getStateManager().getState().overviewUi
+        return mLauncher.getStateManager().getState().isRecentsViewVisible
                 && findTaskViewToLaunch(mLauncher.getOverviewPanel(), v, targets) != null;
     }
 
@@ -389,8 +403,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
             if (target.mode == MODE_OPENING) {
                 isAllOpeningTargetTrs &= target.isTranslucent;
             }
-            if (!isAllOpeningTargetTrs)
-                break;
+            if (!isAllOpeningTargetTrs) break;
         }
         return isAllOpeningTargetTrs;
     }
@@ -420,8 +433,8 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         anim.play(windowAnimator);
         if (launcherClosing) {
             // Delay animation by a frame to avoid jank.
-            Pair<AnimatorSet, Runnable> launcherContentAnimator = getLauncherContentAnimator(true /* isAppOpening */,
-                    startDelay, false);
+            Pair<AnimatorSet, Runnable> launcherContentAnimator =
+                    getLauncherContentAnimator(true /* isAppOpening */, startDelay, false);
             anim.play(launcherContentAnimator.first);
             anim.addListener(new AnimatorListenerAdapter() {
                 @Override
@@ -446,23 +459,20 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
 
     /**
      * Return the window bounds of the opening target.
-     * In multiwindow mode, we need to get the final size of the opening app window
-     * target to help
+     * In multiwindow mode, we need to get the final size of the opening app window target to help
      * figure out where the floating view should animate to.
      */
     private Rect getWindowTargetBounds(@NonNull RemoteAnimationTarget[] appTargets,
                                        int rotationChange) {
         RemoteAnimationTarget target = null;
         for (RemoteAnimationTarget t : appTargets) {
-            if (t.mode != MODE_OPENING)
-                continue;
+            if (t.mode != MODE_OPENING) continue;
             target = t;
             break;
         }
-        if (target == null)
-            return new Rect(0, 0, mDeviceProfile.widthPx, mDeviceProfile.heightPx);
+        if (target == null) return new Rect(0, 0, mDeviceProfile.widthPx, mDeviceProfile.heightPx);
         final Rect bounds = new Rect(target.screenSpaceBounds);
-        if (Utilities.ATLEAST_R && target.localBounds != null) {
+        if (target.localBounds != null) {
             bounds.set(target.localBounds);
         } else {
             bounds.offsetTo(target.position.x, target.position.y);
@@ -487,12 +497,10 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     }
 
     /** Dump debug logs to bug report. */
-    public void dump(@NonNull String prefix, @NonNull PrintWriter printWriter) {
-    }
+    public void dump(@NonNull String prefix, @NonNull PrintWriter printWriter) {}
 
     /**
-     * Content is everything on screen except the background and the floating view
-     * (if any).
+     * Content is everything on screen except the background and the floating view (if any).
      *
      * @param isAppOpening     True when this is called when an app is opening.
      *                         False when this is called when an app is closing.
@@ -505,26 +513,24 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         Runnable endListener;
 
         float[] alphas = isAppOpening
-                ? new float[] { 1, 0 }
-                : new float[] { 0, 1 };
+                ? new float[]{1, 0}
+                : new float[]{0, 1};
 
         float[] scales = isAppOpening
-                ? new float[] { 1, mDeviceProfile.workspaceContentScale }
-                : new float[] { mDeviceProfile.workspaceContentScale, 1 };
+                ? new float[]{1, mDeviceProfile.workspaceContentScale}
+                : new float[]{mDeviceProfile.workspaceContentScale, 1};
 
-        // Pause expensive view updates as they can lead to layer thrashing and skipped
-        // frames.
+        // Pause expensive view updates as they can lead to layer thrashing and skipped frames.
         mLauncher.pauseExpensiveViewUpdates();
 
         if (mLauncher.isInState(ALL_APPS)) {
-            // All Apps in portrait mode is full screen, so we only animate
-            // AllAppsContainerView.
+            // All Apps in portrait mode is full screen, so we only animate AllAppsContainerView.
             final View appsView = mLauncher.getAppsView();
             final float startAlpha = appsView.getAlpha();
             final float startScale = SCALE_PROPERTY.get(appsView);
             if (mDeviceProfile.isTablet) {
                 // AllApps should not fade at all in tablets.
-                alphas = new float[] { 1, 1 };
+                alphas = new float[]{1, 1};
             }
             appsView.setAlpha(alphas[0]);
 
@@ -563,8 +569,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
             workspace.forEachVisiblePage(
                     view -> viewsToAnimate.add(((CellLayout) view).getShortcutsAndWidgets()));
 
-            // Do not scale hotseat as a whole when taskbar is present, and scale QSB only
-            // if it's
+            // Do not scale hotseat as a whole when taskbar is present, and scale QSB only if it's
             // not inline.
             if (mDeviceProfile.isTaskbarPresent) {
                 if (!mDeviceProfile.isQsbInline) {
@@ -585,14 +590,11 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
 
             final boolean scrimEnabled = ENABLE_SCRIM_FOR_APP_LAUNCH.get();
             if (scrimEnabled) {
-                boolean useTaskbarColor = mDeviceProfile.isTaskbarPresentInApps;
-                int scrimColor = useTaskbarColor
-                        ? mLauncher.getResources().getColor(R.color.taskbar_background)
-                        : ColorTokens.OverviewScrim.resolveColor(mLauncher);
+                int scrimColor = Themes.getAttrColor(mLauncher, R.attr.overviewScrimColor);
                 int scrimColorTrans = ColorUtils.setAlphaComponent(scrimColor, 0);
                 int[] colors = isAppOpening
-                        ? new int[] { scrimColorTrans, scrimColor }
-                        : new int[] { scrimColor, scrimColorTrans };
+                        ? new int[]{scrimColorTrans, scrimColor}
+                        : new int[]{scrimColor, scrimColorTrans};
                 ScrimView scrimView = mLauncher.getScrimView();
                 if (scrimView.getBackground() instanceof ColorDrawable) {
                     scrimView.setBackgroundColor(colors[0]);
@@ -623,8 +625,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     }
 
     /**
-     * Compose recents view alpha and translation Y animation when launcher
-     * opens/closes apps.
+     * Compose recents view alpha and translation Y animation when launcher opens/closes apps.
      *
      * @param anim   the animator set to add to
      * @param alphas the alphas to animate to over time
@@ -655,8 +656,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     }
 
     /**
-     * @return Animator that controls the window of the opening targets from app
-     *         icons.
+     * @return Animator that controls the window of the opening targets from app icons.
      */
     private Animator getOpeningWindowAnimators(View v,
                                                RemoteAnimationTarget[] appTargets,
@@ -679,7 +679,8 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
 
         RemoteAnimationTargets openingTargets = new RemoteAnimationTargets(appTargets,
                 wallpaperTargets, nonAppTargets, MODE_OPENING);
-        SurfaceTransactionApplier surfaceApplier = new SurfaceTransactionApplier(floatingView);
+        SurfaceTransactionApplier surfaceApplier =
+                new SurfaceTransactionApplier(floatingView);
         openingTargets.addReleaseCheck(surfaceApplier);
         RemoteAnimationTarget navBarTarget = openingTargets.getNavBarRemoteAnimationTarget();
 
@@ -687,10 +688,11 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         mDragLayer.getLocationOnScreen(dragLayerBounds);
 
         final boolean hasSplashScreen;
-        if (supportsSSplashScreen()) {
+        if (ENABLE_SHELL_STARTING_SURFACE) {
             int taskId = openingTargets.getFirstAppTargetTaskId();
             Pair<Integer, Integer> defaultParams = Pair.create(STARTING_WINDOW_TYPE_NONE, 0);
-            Pair<Integer, Integer> taskParams = mTaskStartParams.getOrDefault(taskId, defaultParams);
+            Pair<Integer, Integer> taskParams =
+                    mTaskStartParams.getOrDefault(taskId, defaultParams);
             mTaskStartParams.remove(taskId);
             hasSplashScreen = taskParams.first == STARTING_WINDOW_TYPE_SPLASH_SCREEN;
         } else {
@@ -743,42 +745,42 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         });
 
         final float initialWindowRadius = supportsRoundedCornersOnWindows(mLauncher.getResources())
-                ? Math.max(crop.width(), crop.height()) / 2f * IconShapeManager.getWindowTransitionRadius(mLauncher)
+                ? Math.max(crop.width(), crop.height()) / 2f
                 : 0f;
         final float finalWindowRadius = mDeviceProfile.isMultiWindowMode
-                ? 0
-                : getWindowCornerRadius(mLauncher);
+                ? 0 : getWindowCornerRadius(mLauncher);
         final float finalShadowRadius = appTargetsAreTranslucent ? 0 : mMaxShadowRadius;
 
         MultiValueUpdateListener listener = new MultiValueUpdateListener() {
-            FloatProp mDx = new FloatProp(0, prop.dX, 0, APP_LAUNCH_DURATION,
-                    mOpeningXInterpolator);
-            FloatProp mDy = new FloatProp(0, prop.dY, 0, APP_LAUNCH_DURATION,
-                    mOpeningInterpolator);
+            FloatProp mDx = new FloatProp(0, prop.dX, mOpeningXInterpolator);
+            FloatProp mDy = new FloatProp(0, prop.dY, mOpeningInterpolator);
 
             FloatProp mIconScaleToFitScreen = new FloatProp(prop.initialAppIconScale,
-                    prop.finalAppIconScale, 0, APP_LAUNCH_DURATION, mOpeningInterpolator);
+                    prop.finalAppIconScale, mOpeningInterpolator);
             FloatProp mIconAlpha = new FloatProp(prop.iconAlphaStart, 0f,
-                    APP_LAUNCH_ALPHA_START_DELAY, APP_LAUNCH_ALPHA_DURATION, LINEAR);
+                    clampToDuration(LINEAR, APP_LAUNCH_ALPHA_START_DELAY, APP_LAUNCH_ALPHA_DURATION,
+                            APP_LAUNCH_DURATION));
 
-            FloatProp mWindowRadius = new FloatProp(initialWindowRadius, finalWindowRadius, 0,
-                    APP_LAUNCH_DURATION, mOpeningInterpolator);
-            FloatProp mShadowRadius = new FloatProp(0, finalShadowRadius, 0,
-                    APP_LAUNCH_DURATION, mOpeningInterpolator);
+            FloatProp mWindowRadius = new FloatProp(initialWindowRadius, finalWindowRadius,
+                    mOpeningInterpolator);
+            FloatProp mShadowRadius = new FloatProp(0, finalShadowRadius,
+                    mOpeningInterpolator);
 
             FloatProp mCropRectCenterX = new FloatProp(prop.cropCenterXStart, prop.cropCenterXEnd,
-                    0, APP_LAUNCH_DURATION, mOpeningInterpolator);
+                    mOpeningInterpolator);
             FloatProp mCropRectCenterY = new FloatProp(prop.cropCenterYStart, prop.cropCenterYEnd,
-                    0, APP_LAUNCH_DURATION, mOpeningInterpolator);
-            FloatProp mCropRectWidth = new FloatProp(prop.cropWidthStart, prop.cropWidthEnd, 0,
-                    APP_LAUNCH_DURATION, mOpeningInterpolator);
-            FloatProp mCropRectHeight = new FloatProp(prop.cropHeightStart, prop.cropHeightEnd, 0,
-                    APP_LAUNCH_DURATION, mOpeningInterpolator);
+                    mOpeningInterpolator);
+            FloatProp mCropRectWidth = new FloatProp(prop.cropWidthStart, prop.cropWidthEnd,
+                    mOpeningInterpolator);
+            FloatProp mCropRectHeight = new FloatProp(prop.cropHeightStart, prop.cropHeightEnd,
+                    mOpeningInterpolator);
 
-            FloatProp mNavFadeOut = new FloatProp(1f, 0f, 0, ANIMATION_NAV_FADE_OUT_DURATION,
-                    NAV_FADE_OUT_INTERPOLATOR);
-            FloatProp mNavFadeIn = new FloatProp(0f, 1f, ANIMATION_DELAY_NAV_FADE_IN,
-                    ANIMATION_NAV_FADE_IN_DURATION, NAV_FADE_IN_INTERPOLATOR);
+            FloatProp mNavFadeOut = new FloatProp(1f, 0f, clampToDuration(
+                    NAV_FADE_OUT_INTERPOLATOR, 0, ANIMATION_NAV_FADE_OUT_DURATION,
+                    APP_LAUNCH_DURATION));
+            FloatProp mNavFadeIn = new FloatProp(0f, 1f, clampToDuration(
+                    NAV_FADE_IN_INTERPOLATOR, ANIMATION_DELAY_NAV_FADE_IN,
+                    ANIMATION_NAV_FADE_IN_DURATION, APP_LAUNCH_DURATION));
 
             @Override
             public void onUpdate(float percent, boolean initOnly) {
@@ -869,7 +871,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
                         } else {
                             tmpPos.set(target.position.x, target.position.y);
                         }
-                        final Rect crop = new Rect(Utilities.ATLEAST_R ? target.screenSpaceBounds : target.sourceContainerBounds);
+                        final Rect crop = new Rect(target.screenSpaceBounds);
                         crop.offsetTo(0, 0);
 
                         if ((rotationChange % 2) == 1) {
@@ -888,7 +890,8 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
                 }
 
                 if (navBarTarget != null) {
-                    SurfaceProperties navBuilder = transaction.forSurface(navBarTarget.leash);
+                    SurfaceProperties navBuilder =
+                            transaction.forSurface(navBarTarget.leash);
                     if (mNavFadeIn.value > mNavFadeIn.getStartValue()) {
                         matrix.setScale(scale, scale);
                         matrix.postTranslate(windowTransX0, windowTransY0);
@@ -903,12 +906,10 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
             }
         };
         appAnimator.addUpdateListener(listener);
-        // Since we added a start delay, call update here to init the FloatingIconView
-        // properly.
+        // Since we added a start delay, call update here to init the FloatingIconView properly.
         listener.onUpdate(0, true /* initOnly */);
 
-        // If app targets are translucent, do not animate the background as it causes a
-        // visible
+        // If app targets are translucent, do not animate the background as it causes a visible
         // flicker when it resets itself at the end of its animation.
         if (appTargetsAreTranslucent || !launcherClosing) {
             animatorSet.play(appAnimator);
@@ -933,26 +934,24 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
 
         RemoteAnimationTarget openingTarget = openingTargets.getFirstAppTarget();
         int fallbackBackgroundColor = 0;
-        if (openingTarget != null && supportsSSplashScreen()) {
+        if (openingTarget != null && ENABLE_SHELL_STARTING_SURFACE) {
             fallbackBackgroundColor = mTaskStartParams.containsKey(openingTarget.taskId)
-                    ? mTaskStartParams.get(openingTarget.taskId).second
-                    : 0;
+                    ? mTaskStartParams.get(openingTarget.taskId).second : 0;
             mTaskStartParams.remove(openingTarget.taskId);
         }
         if (fallbackBackgroundColor == 0) {
-            fallbackBackgroundColor = FloatingWidgetView.getDefaultBackgroundColor(mLauncher, openingTarget);
+            fallbackBackgroundColor =
+                    FloatingWidgetView.getDefaultBackgroundColor(mLauncher, openingTarget);
         }
 
         final float finalWindowRadius = mDeviceProfile.isMultiWindowMode
-                ? 0
-                : getWindowCornerRadius(mLauncher);
+                ? 0 : getWindowCornerRadius(mLauncher);
         final FloatingWidgetView floatingView = FloatingWidgetView.getFloatingWidgetView(mLauncher,
                 v, widgetBackgroundBounds,
                 new Size(windowTargetBounds.width(), windowTargetBounds.height()),
                 finalWindowRadius, appTargetsAreTranslucent, fallbackBackgroundColor);
         final float initialWindowRadius = supportsRoundedCornersOnWindows(mLauncher.getResources())
-                ? floatingView.getInitialCornerRadius()
-                : 0;
+                ? floatingView.getInitialCornerRadius() : 0;
 
         SurfaceTransactionApplier surfaceApplier = new SurfaceTransactionApplier(floatingView);
         openingTargets.addReleaseCheck(surfaceApplier);
@@ -974,37 +973,36 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
 
         appAnimator.addUpdateListener(new MultiValueUpdateListener() {
             float mAppWindowScale = 1;
-            final FloatProp mWidgetForegroundAlpha = new FloatProp(1 /* start */,
-                    0 /* end */, 0 /* delay */,
-                    WIDGET_CROSSFADE_DURATION_MILLIS / 2 /* duration */, LINEAR);
-            final FloatProp mWidgetFallbackBackgroundAlpha = new FloatProp(0 /* start */,
-                    1 /* end */, 0 /* delay */, 75 /* duration */, LINEAR);
-            final FloatProp mPreviewAlpha = new FloatProp(0 /* start */, 1 /* end */,
+            final FloatProp mWidgetForegroundAlpha = new FloatProp(1, 0, clampToDuration(
+                    LINEAR, 0, WIDGET_CROSSFADE_DURATION_MILLIS / 2, APP_LAUNCH_DURATION));
+
+            final FloatProp mWidgetFallbackBackgroundAlpha = new FloatProp(0, 1,
+                    clampToDuration(LINEAR, 0, 75, APP_LAUNCH_DURATION));
+            final FloatProp mPreviewAlpha = new FloatProp(0, 1, clampToDuration(
+                    LINEAR,
                     WIDGET_CROSSFADE_DURATION_MILLIS / 2 /* delay */,
-                    WIDGET_CROSSFADE_DURATION_MILLIS / 2 /* duration */, LINEAR);
+                    WIDGET_CROSSFADE_DURATION_MILLIS / 2 /* duration */,
+                    APP_LAUNCH_DURATION));
             final FloatProp mWindowRadius = new FloatProp(initialWindowRadius, finalWindowRadius,
-                    0 /* start */, APP_LAUNCH_DURATION, mOpeningInterpolator);
-            final FloatProp mCornerRadiusProgress = new FloatProp(0, 1, 0, APP_LAUNCH_DURATION,
                     mOpeningInterpolator);
+            final FloatProp mCornerRadiusProgress = new FloatProp(0, 1, mOpeningInterpolator);
 
             // Window & widget background positioning bounds
             final FloatProp mDx = new FloatProp(widgetBackgroundBounds.centerX(),
-                    windowTargetBounds.centerX(), 0 /* delay */, APP_LAUNCH_DURATION,
-                    mOpeningXInterpolator);
+                    windowTargetBounds.centerX(), mOpeningXInterpolator);
             final FloatProp mDy = new FloatProp(widgetBackgroundBounds.centerY(),
-                    windowTargetBounds.centerY(), 0 /* delay */, APP_LAUNCH_DURATION,
-                    mOpeningInterpolator);
+                    windowTargetBounds.centerY(), mOpeningInterpolator);
             final FloatProp mWidth = new FloatProp(widgetBackgroundBounds.width(),
-                    windowTargetBounds.width(), 0 /* delay */, APP_LAUNCH_DURATION,
-                    mOpeningInterpolator);
+                    windowTargetBounds.width(), mOpeningInterpolator);
             final FloatProp mHeight = new FloatProp(widgetBackgroundBounds.height(),
-                    windowTargetBounds.height(), 0 /* delay */, APP_LAUNCH_DURATION,
-                    mOpeningInterpolator);
+                    windowTargetBounds.height(), mOpeningInterpolator);
 
-            final FloatProp mNavFadeOut = new FloatProp(1f, 0f, 0, ANIMATION_NAV_FADE_OUT_DURATION,
-                    NAV_FADE_OUT_INTERPOLATOR);
-            final FloatProp mNavFadeIn = new FloatProp(0f, 1f, ANIMATION_DELAY_NAV_FADE_IN,
-                    ANIMATION_NAV_FADE_IN_DURATION, NAV_FADE_IN_INTERPOLATOR);
+            final FloatProp mNavFadeOut = new FloatProp(1f, 0f, clampToDuration(
+                    NAV_FADE_OUT_INTERPOLATOR, 0, ANIMATION_NAV_FADE_OUT_DURATION,
+                    APP_LAUNCH_DURATION));
+            final FloatProp mNavFadeIn = new FloatProp(0f, 1f, clampToDuration(
+                    NAV_FADE_IN_INTERPOLATOR, ANIMATION_DELAY_NAV_FADE_IN,
+                    ANIMATION_NAV_FADE_IN_DURATION, APP_LAUNCH_DURATION));
 
             @Override
             public void onUpdate(float percent, boolean initOnly) {
@@ -1051,8 +1049,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
             }
         });
 
-        // If app targets are translucent, do not animate the background as it causes a
-        // visible
+        // If app targets are translucent, do not animate the background as it causes a visible
         // flicker when it resets itself at the end of its animation.
         if (appTargetsAreTranslucent || !launcherClosing) {
             animatorSet.play(appAnimator);
@@ -1066,8 +1063,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
      * Returns animator that controls depth/blur of the background.
      */
     private ObjectAnimator getBackgroundAnimator() {
-        // When launching an app from overview that doesn't map to a task, we still want
-        // to just
+        // When launching an app from overview that doesn't map to a task, we still want to just
         // blur the wallpaper instead of the launcher surface as well
         boolean allowBlurringLauncher = mLauncher.getStateManager().getState() != OVERVIEW
                 && BlurUtils.supportsBlursOnWindows();
@@ -1078,14 +1074,12 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
                 .setDuration(APP_LAUNCH_DURATION);
 
         if (allowBlurringLauncher) {
-            // Create a temporary effect layer, that lives on top of launcher, so we can
-            // apply
-            // the blur to it. The EffectLayer will be fullscreen, which will help with
-            // caching
+            // Create a temporary effect layer, that lives on top of launcher, so we can apply
+            // the blur to it. The EffectLayer will be fullscreen, which will help with caching
             // optimizations on the SurfaceFlinger side:
             // - Results would be able to be cached as a texture
             // - There won't be texture allocation overhead, because EffectLayers don't have
-            // buffers
+            //   buffers
             ViewRootImpl viewRootImpl = mLauncher.getDragLayer().getViewRootImpl();
             SurfaceControl parent = viewRootImpl != null
                     ? viewRootImpl.getSurfaceControl()
@@ -1098,12 +1092,17 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
                     .setEffectLayer()
                     .build();
 
-            backgroundRadiusAnim.addListener(
-                    AnimatorListeners.forEndCallback(() -> new SurfaceControl.Transaction().remove(dimLayer).apply()));
+            backgroundRadiusAnim.addListener(AnimatorListeners.forEndCallback(() ->
+                    new SurfaceControl.Transaction().remove(dimLayer).apply()));
         }
 
         backgroundRadiusAnim.addListener(
-                AnimatorListeners.forEndCallback(depthController::dispose));
+                AnimatorListeners.forEndCallback(() -> {
+                    // reset the depth to match the main depth controller's depth
+                    depthController.stateDepth
+                            .setValue(mLauncher.getDepthController().stateDepth.getValue());
+                    depthController.dispose();
+                }));
 
         return backgroundRadiusAnim;
     }
@@ -1112,17 +1111,16 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
      * Registers remote animations used when closing apps to home screen.
      */
     public void registerRemoteAnimations() {
-        if (SEPARATE_RECENTS_ACTIVITY.get() || !Utilities.ATLEAST_S) return;
-        if (hasControlRemoteAppTransitionPermission()) {
-            RemoteAnimationDefinition definition = new RemoteAnimationDefinition();
-            addRemoteAnimations(definition);
-            mLauncher.registerRemoteAnimations(definition);
+        if (SEPARATE_RECENTS_ACTIVITY.get()) {
+            return;
         }
+        RemoteAnimationDefinition definition = new RemoteAnimationDefinition();
+        addRemoteAnimations(definition);
+        mLauncher.registerRemoteAnimations(definition);
     }
 
     /**
-     * Adds remote animations to a {@link RemoteAnimationDefinition}. May be
-     * overridden to add
+     * Adds remote animations to a {@link RemoteAnimationDefinition}. May be overridden to add
      * additional animations.
      */
     private void addRemoteAnimations(RemoteAnimationDefinition definition) {
@@ -1150,32 +1148,35 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
      * Registers remote animations used when closing apps to home screen.
      */
     public void registerRemoteTransitions() {
-        if (SEPARATE_RECENTS_ACTIVITY.get() || !Utilities.ATLEAST_T) return;
-
-        if (ENABLE_SHELL_TRANSITIONS && LawnchairQuickstepCompat.ATLEAST_U)
+        if (ENABLE_SHELL_TRANSITIONS) {
             SystemUiProxy.INSTANCE.get(mLauncher).shareTransactionQueue();
-        if (hasControlRemoteAppTransitionPermission() && LawnchairQuickstepCompat.ATLEAST_Q) {
-            mWallpaperOpenTransitionRunner = createWallpaperOpenRunner(false /* fromUnlock */);
-            mLauncherOpenTransition = LawnchairQuickstepCompat.getRemoteTransitionCompat().getRemoteTransition(
-                    new LauncherAnimationRunner(mHandler, mWallpaperOpenTransitionRunner,
-                            false /* startAtFrontOfQueue */).toRemoteTransition(),
-                    mLauncher.getIApplicationThread(), "QuickstepLaunchHome");
-
-            TransitionFilter homeCheck = new TransitionFilter();
-            // No need to handle the transition that also dismisses keyguard.
-            homeCheck.mNotFlags = TRANSIT_FLAG_KEYGUARD_GOING_AWAY;
-            homeCheck.mRequirements = new TransitionFilter.Requirement[] { new TransitionFilter.Requirement(),
-                    new TransitionFilter.Requirement() };
-            homeCheck.mRequirements[0].mActivityType = ACTIVITY_TYPE_HOME;
-            homeCheck.mRequirements[0].mTopActivity = mLauncher.getComponentName();
-            homeCheck.mRequirements[0].mModes = new int[] { TRANSIT_OPEN, TRANSIT_TO_FRONT };
-            homeCheck.mRequirements[0].mOrder = CONTAINER_ORDER_TOP;
-            homeCheck.mRequirements[1].mActivityType = ACTIVITY_TYPE_STANDARD;
-            homeCheck.mRequirements[1].mModes = new int[] { TRANSIT_CLOSE, TRANSIT_TO_BACK };
-            SystemUiProxy.INSTANCE.get(mLauncher)
-                    .registerRemoteTransition(mLauncherOpenTransition, homeCheck);
         }
+        if (SEPARATE_RECENTS_ACTIVITY.get()) {
+            return;
+        }
+
+        mWallpaperOpenTransitionRunner = createWallpaperOpenRunner(false /* fromUnlock */);
+        mLauncherOpenTransition = new RemoteTransition(
+                new LauncherAnimationRunner(mHandler, mWallpaperOpenTransitionRunner,
+                        false /* startAtFrontOfQueue */).toRemoteTransition(),
+                mLauncher.getIApplicationThread(), "QuickstepLaunchHome");
+
+        TransitionFilter homeCheck = new TransitionFilter();
+        // No need to handle the transition that also dismisses keyguard.
+        homeCheck.mNotFlags = TRANSIT_FLAG_KEYGUARD_GOING_AWAY;
+        homeCheck.mRequirements =
+                new TransitionFilter.Requirement[]{new TransitionFilter.Requirement(),
+                        new TransitionFilter.Requirement()};
+        homeCheck.mRequirements[0].mActivityType = ACTIVITY_TYPE_HOME;
+        homeCheck.mRequirements[0].mTopActivity = mLauncher.getComponentName();
+        homeCheck.mRequirements[0].mModes = new int[]{TRANSIT_OPEN, TRANSIT_TO_FRONT};
+        homeCheck.mRequirements[0].mOrder = CONTAINER_ORDER_TOP;
+        homeCheck.mRequirements[1].mActivityType = ACTIVITY_TYPE_STANDARD;
+        homeCheck.mRequirements[1].mModes = new int[]{TRANSIT_CLOSE, TRANSIT_TO_BACK};
+        SystemUiProxy.INSTANCE.get(mLauncher)
+                .registerRemoteTransition(mLauncherOpenTransition, homeCheck);
         if (mBackAnimationController != null) {
+            mBackAnimationController.registerComponentCallbacks();
             mBackAnimationController.registerBackCallbacks(mHandler);
         }
     }
@@ -1183,27 +1184,23 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     public void onActivityDestroyed() {
         unregisterRemoteAnimations();
         unregisterRemoteTransitions();
-        if (Utilities.ATLEAST_T) {
-            mStartingWindowListener.setTransitionManager(null);
-            SystemUiProxy.INSTANCE.get(mLauncher).setStartingWindowListener(null);
-        }
+        mLauncher.removeOnDeviceProfileChangeListener(this);
+        SystemUiProxy.INSTANCE.get(mLauncher).setStartingWindowListener(null);
+        ORDERED_BG_EXECUTOR.execute(() -> mLauncher.getContentResolver()
+                .unregisterContentObserver(mAnimationRemovalObserver));
     }
 
     private void unregisterRemoteAnimations() {
         if (SEPARATE_RECENTS_ACTIVITY.get()) {
             return;
         }
-        if (hasControlRemoteAppTransitionPermission()) {
-            if (Utilities.ATLEAST_R) {
-                mLauncher.unregisterRemoteAnimations();
-            }
-            // Also clear strong references to the runners registered with the remote
-            // animation
-            // definition so we don't have to wait for the system gc
-            mWallpaperOpenRunner = null;
-            mAppLaunchRunner = null;
-            mKeyguardGoingAwayRunner = null;
-        }
+        mLauncher.unregisterRemoteAnimations();
+
+        // Also clear strong references to the runners registered with the remote animation
+        // definition so we don't have to wait for the system gc
+        mWallpaperOpenRunner = null;
+        mAppLaunchRunner = null;
+        mKeyguardGoingAwayRunner = null;
     }
 
     protected void unregisterRemoteTransitions() {
@@ -1213,24 +1210,31 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         if (SEPARATE_RECENTS_ACTIVITY.get()) {
             return;
         }
-        if (hasControlRemoteAppTransitionPermission()) {
-            if (mLauncherOpenTransition == null) return;
-            SystemUiProxy.INSTANCE.get(mLauncher).unregisterRemoteTransition(
-                    mLauncherOpenTransition);
-            mLauncherOpenTransition = null;
-            mWallpaperOpenTransitionRunner = null;
-        }
+        if (mLauncherOpenTransition == null) return;
+        SystemUiProxy.INSTANCE.get(mLauncher).unregisterRemoteTransition(
+                mLauncherOpenTransition);
+        mLauncherOpenTransition = null;
+        mWallpaperOpenTransitionRunner = null;
         if (mBackAnimationController != null) {
             mBackAnimationController.unregisterBackCallbacks();
+            mBackAnimationController.unregisterComponentCallbacks();
             mBackAnimationController = null;
         }
     }
 
+    private void checkAndMonitorIfAnimationsAreEnabled() {
+        ORDERED_BG_EXECUTOR.execute(() -> {
+            mAnimationRemovalObserver.onChange(true);
+            mLauncher.getContentResolver().registerContentObserver(Global.getUriFor(
+                    Global.ANIMATOR_DURATION_SCALE), false, mAnimationRemovalObserver);
+            mLauncher.getContentResolver().registerContentObserver(Global.getUriFor(
+                    Global.TRANSITION_ANIMATION_SCALE), false, mAnimationRemovalObserver);
+
+        });
+    }
+
     private boolean launcherIsATargetWithMode(RemoteAnimationTarget[] targets, int mode) {
         for (RemoteAnimationTarget target : targets) {
-            if (!Utilities.ATLEAST_S) {
-                return target.mode == mode && target.taskId == mLauncher.getTaskId();
-            }
             if (target.mode == mode && target.taskInfo != null
                     // Compare component name instead of task-id because transitions will promote
                     // the target up to the root task while getTaskId returns the leaf.
@@ -1258,22 +1262,22 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
 
     /**
      * @return Runner that plays when user goes to Launcher
-     *         ie. pressing home, swiping up from nav bar.
+     * ie. pressing home, swiping up from nav bar.
      */
     RemoteAnimationFactory createWallpaperOpenRunner(boolean fromUnlock) {
         return new WallpaperOpenLauncherAnimationRunner(fromUnlock);
     }
 
     /**
-     * Animator that controls the transformations of the windows when unlocking the
-     * device.
+     * Animator that controls the transformations of the windows when unlocking the device.
      */
     private Animator getUnlockWindowAnimator(RemoteAnimationTarget[] appTargets,
                                              RemoteAnimationTarget[] wallpaperTargets) {
         SurfaceTransactionApplier surfaceApplier = new SurfaceTransactionApplier(mDragLayer);
         ValueAnimator unlockAnimator = ValueAnimator.ofFloat(0, 1);
         unlockAnimator.setDuration(CLOSING_TRANSITION_DURATION_MS);
-        float cornerRadius = mDeviceProfile.isMultiWindowMode ? 0 : QuickStepContract.getWindowCornerRadius(mLauncher);
+        float cornerRadius = mDeviceProfile.isMultiWindowMode ? 0 :
+                QuickStepContract.getWindowCornerRadius(mLauncher);
         unlockAnimator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationStart(Animator animation) {
@@ -1282,7 +1286,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
                     RemoteAnimationTarget target = appTargets[i];
                     transaction.forSurface(target.leash)
                             .setAlpha(1f)
-                            .setWindowCrop(Utilities.ATLEAST_R ? target.screenSpaceBounds : target.sourceContainerBounds)
+                            .setWindowCrop(target.screenSpaceBounds)
                             .setCornerRadius(cornerRadius);
                 }
                 surfaceApplier.scheduleApply(transaction);
@@ -1294,22 +1298,17 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     private static int getRotationChange(RemoteAnimationTarget[] appTargets) {
         int rotationChange = 0;
         for (RemoteAnimationTarget target : appTargets) {
-            try {
-                if (Math.abs(target.rotationChange) > Math.abs(rotationChange)) {
-                    rotationChange = target.rotationChange;
-                }
-            } catch (NoSuchFieldError ignored) {
+            if (Math.abs(target.rotationChange) > Math.abs(rotationChange)) {
+                rotationChange = target.rotationChange;
             }
         }
         return rotationChange;
     }
 
     /**
-     * Returns view on launcher that corresponds to the closing app in the list of
-     * app targets
+     * Returns view on launcher that corresponds to the closing app in the list of app targets
      */
-    private @Nullable View findLauncherView(RemoteAnimationTarget[] appTargets) {
-        if (!Utilities.ATLEAST_S) return null;
+    public @Nullable View findLauncherView(RemoteAnimationTarget[] appTargets) {
         for (RemoteAnimationTarget appTarget : appTargets) {
             if (appTarget.mode == MODE_CLOSING) {
                 View launcherView = findLauncherView(appTarget);
@@ -1329,11 +1328,11 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
             return null;
         }
 
-        final ComponentName[] taskInfoActivities = new ComponentName[] {
+        final ComponentName[] taskInfoActivities = new ComponentName[]{
                 runningTaskTarget.taskInfo.baseActivity,
                 runningTaskTarget.taskInfo.origActivity,
                 runningTaskTarget.taskInfo.realActivity,
-                runningTaskTarget.taskInfo.topActivity };
+                runningTaskTarget.taskInfo.topActivity};
 
         String packageName = null;
         for (ComponentName component : taskInfoActivities) {
@@ -1347,8 +1346,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
             return null;
         }
 
-        // Find the associated item info for the launch cookie (if available), note that
-        // predicted
+        // Find the associated item info for the launch cookie (if available), note that predicted
         // apps actually have an id of -1, so use another default id here
         final ArrayList<IBinder> launchCookies = runningTaskTarget.taskInfo.launchCookies == null
                 ? new ArrayList<>()
@@ -1383,12 +1381,11 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     }
 
     /**
-     * Closing animator that animates the window into its final location on the
-     * workspace.
+     * Closing animator that animates the window into its final location on the workspace.
      */
     protected RectFSpringAnim getClosingWindowAnimators(AnimatorSet animation,
                                                         RemoteAnimationTarget[] targets, View launcherView, PointF velocityPxPerS,
-                                                        RectF closingWindowStartRect, float startWindowCornerRadius) {
+                                                        RectF closingWindowStartRectF, float startWindowCornerRadius) {
         FloatingIconView floatingIconView = null;
         FloatingWidgetView floatingWidget = null;
         RectF targetRect = new RectF();
@@ -1408,12 +1405,13 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         if (launcherView instanceof LauncherAppWidgetHostView) {
             Size windowSize = new Size(mDeviceProfile.availableWidthPx,
                     mDeviceProfile.availableHeightPx);
-            int fallbackBackgroundColor = FloatingWidgetView.getDefaultBackgroundColor(mLauncher, runningTaskTarget);
+            int fallbackBackgroundColor =
+                    FloatingWidgetView.getDefaultBackgroundColor(mLauncher, runningTaskTarget);
             floatingWidget = FloatingWidgetView.getFloatingWidgetView(mLauncher,
                     (LauncherAppWidgetHostView) launcherView, targetRect, windowSize,
                     mDeviceProfile.isMultiWindowMode ? 0 : getWindowCornerRadius(mLauncher),
                     isTransluscent, fallbackBackgroundColor);
-        } else if (launcherView != null) {
+        } else if (launcherView != null && mAreAnimationsEnabled) {
             floatingIconView = getFloatingIconView(mLauncher, launcherView, null,
                     mLauncher.getTaskbarUIController() == null
                             ? null
@@ -1427,13 +1425,16 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
 
         boolean useTaskbarHotseatParams = mDeviceProfile.isTaskbarPresent && isInHotseat;
         RectFSpringAnim anim = new RectFSpringAnim(useTaskbarHotseatParams
-                ? new TaskbarHotseatSpringConfig(mLauncher, closingWindowStartRect, targetRect)
-                : new DefaultSpringConfig(mLauncher, mDeviceProfile, closingWindowStartRect,
+                ? new TaskbarHotseatSpringConfig(mLauncher, closingWindowStartRectF, targetRect)
+                : new DefaultSpringConfig(mLauncher, mDeviceProfile, closingWindowStartRectF,
                 targetRect));
 
         // Hook up floating views to the closing window animators.
-        final int rotationChange = getRotationChange(targets);
-        Rect windowTargetBounds = getWindowTargetBounds(targets, rotationChange);
+        // note the coordinate of closingWindowStartRect is based on launcher
+        Rect closingWindowStartRect = new Rect();
+        closingWindowStartRectF.round(closingWindowStartRect);
+        Rect closingWindowOriginalRect =
+                new Rect(0, 0, mDeviceProfile.widthPx, mDeviceProfile.heightPx);
         if (floatingIconView != null) {
             anim.addAnimatorListener(floatingIconView);
             floatingIconView.setOnTargetChangeListener(anim::onTargetPositionChanged);
@@ -1445,7 +1446,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
             final float windowAlphaThreshold = 1f - SHAPE_PROGRESS_DURATION;
 
             RectFSpringAnim.OnUpdateListener runner = new SpringAnimRunner(targets, targetRect,
-                    windowTargetBounds, startWindowCornerRadius) {
+                    closingWindowStartRect, closingWindowOriginalRect, startWindowCornerRadius) {
                 @Override
                 public void onUpdate(RectF currentRectF, float progress) {
                     finalFloatingIconView.update(1f, currentRectF, progress, windowAlphaThreshold,
@@ -1463,12 +1464,13 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
             final float floatingWidgetAlpha = isTransluscent ? 0 : 1;
             FloatingWidgetView finalFloatingWidget = floatingWidget;
             RectFSpringAnim.OnUpdateListener runner = new SpringAnimRunner(targets, targetRect,
-                    windowTargetBounds, startWindowCornerRadius) {
+                    closingWindowStartRect, closingWindowOriginalRect, startWindowCornerRadius) {
                 @Override
                 public void onUpdate(RectF currentRectF, float progress) {
-                    final float fallbackBackgroundAlpha = 1
-                            - mapBoundToRange(progress, 0.8f, 1, 0, 1, EXAGGERATED_EASE);
-                    final float foregroundAlpha = mapBoundToRange(progress, 0.5f, 1, 0, 1, EXAGGERATED_EASE);
+                    final float fallbackBackgroundAlpha =
+                            1 - mapBoundToRange(progress, 0.8f, 1, 0, 1, EXAGGERATED_EASE);
+                    final float foregroundAlpha =
+                            mapBoundToRange(progress, 0.5f, 1, 0, 1, EXAGGERATED_EASE);
                     finalFloatingWidget.update(currentRectF, floatingWidgetAlpha, foregroundAlpha,
                             fallbackBackgroundAlpha, 1 - progress);
 
@@ -1480,7 +1482,8 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
             // If no floating icon or widget is present, animate the to the default window
             // target rect.
             anim.addOnUpdateListener(new SpringAnimRunner(
-                    targets, targetRect, windowTargetBounds, startWindowCornerRadius));
+                    targets, targetRect, closingWindowStartRect, closingWindowOriginalRect,
+                    startWindowCornerRadius));
         }
 
         // Use a fixed velocity to start the animation.
@@ -1505,16 +1508,14 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         ValueAnimator closingAnimator = ValueAnimator.ofFloat(0, 1);
         int duration = CLOSING_TRANSITION_DURATION_MS;
         float windowCornerRadius = mDeviceProfile.isMultiWindowMode
-                ? 0
-                : getWindowCornerRadius(mLauncher);
+                ? 0 : getWindowCornerRadius(mLauncher);
         float startShadowRadius = areAllTargetsTranslucent(appTargets) ? 0 : mMaxShadowRadius;
         closingAnimator.setDuration(duration);
         closingAnimator.addUpdateListener(new MultiValueUpdateListener() {
-            FloatProp mDy = new FloatProp(0, mClosingWindowTransY, 0, duration, DECELERATE_1_7);
-            FloatProp mScale = new FloatProp(1f, 1f, 0, duration, DECELERATE_1_7);
-            FloatProp mAlpha = new FloatProp(1f, 0f, 25, 125, LINEAR);
-            FloatProp mShadowRadius = new FloatProp(startShadowRadius, 0, 0, duration,
-                    DECELERATE_1_7);
+            FloatProp mDy = new FloatProp(0, mClosingWindowTransY, DECELERATE_1_7);
+            FloatProp mScale = new FloatProp(1f, 1f, DECELERATE_1_7);
+            FloatProp mAlpha = new FloatProp(1f, 0f, clampToDuration(LINEAR, 25, 125, duration));
+            FloatProp mShadowRadius = new FloatProp(startShadowRadius, 0, DECELERATE_1_7);
 
             @Override
             public void onUpdate(float percent, boolean initOnly) {
@@ -1562,22 +1563,6 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         return closingAnimator;
     }
 
-    private boolean supportsSSplashScreen() {
-        return hasControlRemoteAppTransitionPermission()
-                && Utilities.ATLEAST_S
-                && ENABLE_SHELL_STARTING_SURFACE;
-    }
-
-    /**
-     * Returns true if we have permission to control remote app transisions
-     */
-    public boolean hasControlRemoteAppTransitionPermission() {
-        if (!LawnchairApp.isRecentsEnabled())
-            return false;
-        return mLauncher
-                .checkSelfPermission(CONTROL_REMOTE_APP_TRANSITION_PERMISSION) == PackageManager.PERMISSION_GRANTED;
-    }
-
     private void addCujInstrumentation(Animator anim, int cuj) {
         anim.addListener(new AnimationSuccessListener() {
             @Override
@@ -1595,8 +1580,9 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
 
                                 InteractionJankMonitorWrapper.begin(mDragLayer, cuj);
 
-                                mDragLayer.post(() -> mDragLayer.getViewTreeObserver().removeOnDrawListener(
-                                        this));
+                                mDragLayer.post(() ->
+                                        mDragLayer.getViewTreeObserver().removeOnDrawListener(
+                                                this));
                             }
                         });
                 super.onAnimationStart(animation);
@@ -1616,8 +1602,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     }
 
     /**
-     * Creates the {@link RectFSpringAnim} and {@link AnimatorSet} required to
-     * animate
+     * Creates the {@link RectFSpringAnim} and {@link AnimatorSet} required to animate
      * the transition.
      */
     public Pair<RectFSpringAnim, AnimatorSet> createWallpaperOpenAnimations(
@@ -1639,16 +1624,21 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
                 || mLauncher.getWorkspace().isOverlayShown()
                 || shouldPlayFallbackClosingAnimation(appTargets);
 
-        boolean playWorkspaceReveal = true;
+        boolean playWorkspaceReveal = !fromPredictiveBack;
         boolean skipAllAppsScale = false;
         if (fromUnlock) {
             anim.play(getUnlockWindowAnimator(appTargets, wallpaperTargets));
         } else if (ENABLE_BACK_SWIPE_HOME_ANIMATION.get()
                 && !playFallBackAnimation) {
-            // Use a fixed velocity to start the animation.
-            float velocityPxPerS = DynamicResource.provider(mLauncher)
-                    .getDimension(R.dimen.unlock_staggered_velocity_dp_per_s);
-            PointF velocity = new PointF(0, -velocityPxPerS);
+            PointF velocity;
+            if (enableScalingRevealHomeAnimation()) {
+                velocity = new PointF();
+            } else {
+                // Use a fixed velocity to start the animation.
+                float velocityPxPerS = DynamicResource.provider(mLauncher)
+                        .getDimension(R.dimen.unlock_staggered_velocity_dp_per_s);
+                velocity = new PointF(0, -velocityPxPerS);
+            }
             rectFSpringAnim = getClosingWindowAnimators(
                     anim, appTargets, launcherView, velocity, startRect,
                     startWindowCornerRadius);
@@ -1657,8 +1647,15 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
                 // layout bounds.
                 skipAllAppsScale = true;
             } else if (!fromPredictiveBack) {
-                anim.play(new StaggeredWorkspaceAnim(mLauncher, velocity.y,
-                        true /* animateOverviewScrim */, launcherView).getAnimators());
+                if (enableScalingRevealHomeAnimation()) {
+                    anim.play(
+                            new ScalingWorkspaceRevealAnim(
+                                    mLauncher, rectFSpringAnim,
+                                    rectFSpringAnim.getTargetRect()).getAnimators());
+                } else {
+                    anim.play(new StaggeredWorkspaceAnim(mLauncher, velocity.y,
+                            true /* animateOverviewScrim */, launcherView).getAnimators());
+                }
 
                 if (!areAllTargetsTranslucent(appTargets)) {
                     anim.play(ObjectAnimator.ofFloat(mLauncher.getDepthController().stateDepth,
@@ -1681,17 +1678,33 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         // targets list because it is already visible). In that case, we force
         // invisibility on touch down, and only reset it after the animation to home
         // is initialized.
-        if (launcherIsForceInvisibleOrOpening) {
+        if (launcherIsForceInvisibleOrOpening || fromPredictiveBack) {
             addCujInstrumentation(anim, playFallBackAnimation
-                    ? CUJ_APP_CLOSE_TO_HOME_FALLBACK
-                    : CUJ_APP_CLOSE_TO_HOME);
+                    ? Cuj.CUJ_LAUNCHER_APP_CLOSE_TO_HOME_FALLBACK
+                    : Cuj.CUJ_LAUNCHER_APP_CLOSE_TO_HOME);
+
+            AnimatorListenerAdapter endListener = new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    super.onAnimationEnd(animation);
+                    AccessibilityManagerCompat.sendTestProtocolEventToTest(
+                            mLauncher, WALLPAPER_OPEN_ANIMATION_FINISHED_MESSAGE);
+                }
+            };
+
+            if (fromPredictiveBack && rectFSpringAnim != null) {
+                rectFSpringAnim.addAnimatorListener(endListener);
+            } else {
+                anim.addListener(endListener);
+            }
+
             // Only register the content animation for cancellation when state changes
             mLauncher.getStateManager().setCurrentAnimation(anim);
 
-            if (mLauncher.isInState(LauncherState.ALL_APPS)) {
-                Pair<AnimatorSet, Runnable> contentAnimator = getLauncherContentAnimator(false,
-                        LAUNCHER_RESUME_START_DELAY,
-                        skipAllAppsScale);
+            if (mLauncher.isInState(LauncherState.ALL_APPS) && !fromPredictiveBack) {
+                Pair<AnimatorSet, Runnable> contentAnimator =
+                        getLauncherContentAnimator(false, LAUNCHER_RESUME_START_DELAY,
+                                skipAllAppsScale);
                 anim.play(contentAnimator.first);
                 anim.addListener(new AnimatorListenerAdapter() {
                     @Override
@@ -1699,19 +1712,24 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
                         contentAnimator.second.run();
                     }
                 });
-            } else {
-                if (playWorkspaceReveal) {
-                    anim.play(new WorkspaceRevealAnim(mLauncher, false).getAnimators());
-                }
+            } else if (playWorkspaceReveal) {
+                anim.play(new WorkspaceRevealAnim(mLauncher, false).getAnimators());
             }
         }
 
         return new Pair(rectFSpringAnim, anim);
     }
 
+    public static int getTaskbarToHomeDuration() {
+        if (enableScalingRevealHomeAnimation()) {
+            return TASKBAR_TO_HOME_DURATION_SLOW;
+        } else {
+            return TASKBAR_TO_HOME_DURATION_FAST;
+        }
+    }
+
     /**
-     * Remote animation runner for animation from the app to Launcher, including
-     * recents.
+     * Remote animation runner for animation from the app to Launcher, including recents.
      */
     protected class WallpaperOpenLauncherAnimationRunner implements RemoteAnimationFactory {
 
@@ -1739,9 +1757,20 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
                 mLauncher.getStateManager().moveToRestState();
             }
 
-            RectF windowTargetBounds = new RectF(getWindowTargetBounds(appTargets, getRotationChange(appTargets)));
+            RectF windowTargetBounds =
+                    new RectF(getWindowTargetBounds(appTargets, getRotationChange(appTargets)));
+
+            final RectF resolveRectF = new RectF(windowTargetBounds);
+            for (RemoteAnimationTarget t : appTargets) {
+                if (t.mode == MODE_CLOSING) {
+                    transferRectToTargetCoordinate(
+                            t, windowTargetBounds, true, resolveRectF);
+                    break;
+                }
+            }
+
             Pair<RectFSpringAnim, AnimatorSet> pair = createWallpaperOpenAnimations(
-                    appTargets, wallpaperTargets, mFromUnlock, windowTargetBounds,
+                    appTargets, wallpaperTargets, mFromUnlock, resolveRectF,
                     QuickStepContract.getWindowCornerRadius(mLauncher),
                     false /* fromPredictiveBack */);
 
@@ -1771,7 +1800,8 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
                                      RemoteAnimationTarget[] nonAppTargets,
                                      LauncherAnimationRunner.AnimationResult result) {
             AnimatorSet anim = new AnimatorSet();
-            boolean launcherClosing = launcherIsATargetWithMode(appTargets, MODE_CLOSING);
+            boolean launcherClosing =
+                    launcherIsATargetWithMode(appTargets, MODE_CLOSING);
 
             final boolean launchingFromWidget = mV instanceof LauncherAppWidgetHostView;
             final boolean launchingFromRecents = isLaunchingFromRecents(mV, appTargets);
@@ -1779,19 +1809,18 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
             if (launchingFromWidget) {
                 composeWidgetLaunchAnimator(anim, (LauncherAppWidgetHostView) mV, appTargets,
                         wallpaperTargets, nonAppTargets, launcherClosing);
-                addCujInstrumentation(
-                        anim, InteractionJankMonitorWrapper.CUJ_APP_LAUNCH_FROM_WIDGET);
+                addCujInstrumentation(anim, Cuj.CUJ_LAUNCHER_APP_LAUNCH_FROM_WIDGET);
                 skipFirstFrame = true;
             } else if (launchingFromRecents) {
                 composeRecentsLaunchAnimator(anim, mV, appTargets, wallpaperTargets, nonAppTargets,
                         launcherClosing);
                 addCujInstrumentation(
-                        anim, InteractionJankMonitorWrapper.CUJ_APP_LAUNCH_FROM_RECENTS);
+                        anim, Cuj.CUJ_LAUNCHER_APP_LAUNCH_FROM_RECENTS);
                 skipFirstFrame = true;
             } else {
                 composeIconLaunchAnimator(anim, mV, appTargets, wallpaperTargets, nonAppTargets,
                         launcherClosing);
-                addCujInstrumentation(anim, InteractionJankMonitorWrapper.CUJ_APP_LAUNCH_FROM_ICON);
+                addCujInstrumentation(anim, Cuj.CUJ_LAUNCHER_APP_LAUNCH_FROM_ICON);
                 skipFirstFrame = false;
             }
 
@@ -1809,9 +1838,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         }
     }
 
-    /**
-     * Remote animation runner to launch an app using System UI's animation library.
-     */
+    /** Remote animation runner to launch an app using System UI's animation library. */
     private static class ContainerAnimationRunner implements RemoteAnimationFactory {
 
         /** The delegate runner that handles the actual animation. */
@@ -1823,50 +1850,55 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         }
 
         @Nullable
-        private static ContainerAnimationRunner from(
-                View v, StartingWindowListener startingWindowListener, RunnableList onEndCallback) {
+        private static ContainerAnimationRunner from(View v, Launcher launcher,
+                                                     StartingWindowListener startingWindowListener, RunnableList onEndCallback) {
             View viewToUse = findLaunchableViewWithBackground(v);
             if (viewToUse == null) {
-                viewToUse = v;
+                return null;
             }
 
-            // The CUJ is logged by the click handler, so we don't log it inside the
-            // animation
+            // The CUJ is logged by the click handler, so we don't log it inside the animation
             // library.
-            ActivityLaunchAnimator.Controller controllerDelegate = ActivityLaunchAnimator.Controller.fromView(viewToUse,
-                    null /* cujType */);
+            ActivityTransitionAnimator.Controller controllerDelegate =
+                    ActivityTransitionAnimator.Controller.fromView(viewToUse, null /* cujType */);
 
             if (controllerDelegate == null) {
                 return null;
             }
 
-            // This wrapper allows us to override the default value, telling the controller
-            // that the
+            // This wrapper allows us to override the default value, telling the controller that the
             // current window is below the animating window.
-            ActivityLaunchAnimator.Controller controller = new DelegateLaunchAnimatorController(controllerDelegate) {
-                @Override
-                public boolean isBelowAnimatingWindow() {
-                    return true;
-                }
+            ActivityTransitionAnimator.Controller controller =
+                    new DelegateTransitionAnimatorController(controllerDelegate) {
+                        @Override
+                        public boolean isBelowAnimatingWindow() {
+                            return true;
+                        }
+                    };
+
+            ActivityTransitionAnimator.Callback callback = task -> {
+                final int backgroundColor =
+                        startingWindowListener.mBackgroundColor == Color.TRANSPARENT
+                                ? launcher.getScrimView().getBackgroundColor()
+                                : startingWindowListener.mBackgroundColor;
+                return ColorUtils.setAlphaComponent(backgroundColor, 255);
             };
 
-            ActivityLaunchAnimator.Callback callback = task -> ColorUtils.setAlphaComponent(
-                    startingWindowListener.getBackgroundColor(), 255);
-
-            ActivityLaunchAnimator.Listener listener = new ActivityLaunchAnimator.Listener() {
-                @Override
-                public void onLaunchAnimationEnd() {
-                    onEndCallback.executeAllAndDestroy();
-                }
-            };
+            ActivityTransitionAnimator.Listener listener =
+                    new ActivityTransitionAnimator.Listener() {
+                        @Override
+                        public void onTransitionAnimationEnd() {
+                            onEndCallback.executeAllAndDestroy();
+                        }
+                    };
 
             return new ContainerAnimationRunner(
-                    new ActivityLaunchAnimator.AnimationDelegate(controller, callback, listener));
+                    new ActivityTransitionAnimator.AnimationDelegate(
+                            MAIN_EXECUTOR, controller, callback, listener));
         }
 
         /**
-         * Finds the closest parent of [view] (inclusive) that implements
-         * {@link LaunchableView} and
+         * Finds the closest parent of [view] (inclusive) that implements {@link LaunchableView} and
          * has a background drawable.
          */
         @Nullable
@@ -1924,8 +1956,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         AnimOpenProperties(Resources r, DeviceProfile dp, Rect windowTargetBounds,
                            RectF launcherIconBounds, View view, int dragLayerLeft, int dragLayerTop,
                            boolean hasSplashScreen, boolean hasDifferentAppIcon) {
-            // Scale the app icon to take up the entire screen. This simplifies the math
-            // when
+            // 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();
@@ -1941,8 +1972,7 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
             initialAppIconScale = iconStartScale;
             finalAppIconScale = Math.max(maxScaleX, maxScaleY);
 
-            // Animate the app icon to the center of the window bounds in screen
-            // coordinates.
+            // Animate the app icon to the center of the window bounds in screen coordinates.
             float centerX = windowTargetBounds.centerX() - dragLayerLeft;
             float centerY = windowTargetBounds.centerY() - dragLayerTop;
 
@@ -1968,24 +1998,68 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         }
     }
 
-    private class StartingWindowListener extends IStartingWindowListener.Stub {
-        private QuickstepTransitionManager mTransitionManager;
+    private static class StartingWindowListener extends IStartingWindowListener.Stub {
+        private final WeakReference<QuickstepTransitionManager> mTransitionManagerRef;
         private int mBackgroundColor;
 
-        public void setTransitionManager(QuickstepTransitionManager transitionManager) {
-            mTransitionManager = transitionManager;
+        private StartingWindowListener(QuickstepTransitionManager transitionManager) {
+            mTransitionManagerRef = new WeakReference<>(transitionManager);
         }
 
         @Override
         public void onTaskLaunching(int taskId, int supportedType, int color) {
-            mTransitionManager.mTaskStartParams.put(taskId, Pair.create(supportedType, color));
+            QuickstepTransitionManager transitionManager = mTransitionManagerRef.get();
+            if (transitionManager != null) {
+                transitionManager.mTaskStartParams.put(taskId, Pair.create(supportedType, color));
+            }
             mBackgroundColor = color;
         }
+    }
 
-        public int getBackgroundColor() {
-            return mBackgroundColor == Color.TRANSPARENT
-                    ? mLauncher.getScrimView().getBackgroundColor()
-                    : mBackgroundColor;
+    /**
+     * Transfer the rectangle to another coordinate if needed.
+     *
+     * @param toLauncher which one is the anchor of this transfer, if true then transfer from
+     *                   animation target to launcher, false transfer from launcher to animation
+     *                   target.
+     */
+    public void transferRectToTargetCoordinate(RemoteAnimationTarget target, RectF currentRect,
+                                               boolean toLauncher, RectF resultRect) {
+        mCoordinateTransfer.transferRectToTargetCoordinate(
+                target, currentRect, toLauncher, resultRect);
+    }
+
+    private static class RemoteAnimationCoordinateTransfer {
+        private final QuickstepLauncher mLauncher;
+        private final Rect mDisplayRect = new Rect();
+        private final Rect mTmpResult = new Rect();
+
+        RemoteAnimationCoordinateTransfer(QuickstepLauncher launcher) {
+            mLauncher = launcher;
+        }
+
+        void transferRectToTargetCoordinate(RemoteAnimationTarget target, RectF currentRect,
+                                            boolean toLauncher, RectF resultRect) {
+            final int taskRotation = target.windowConfiguration.getRotation();
+            final DeviceProfile profile = mLauncher.getDeviceProfile();
+
+            final int rotationDelta = toLauncher
+                    ? android.util.RotationUtils.deltaRotation(taskRotation, profile.rotationHint)
+                    : android.util.RotationUtils.deltaRotation(profile.rotationHint, taskRotation);
+            if (rotationDelta != ROTATION_0) {
+                // Get original display size when task is on top but with different rotation
+                if (rotationDelta % 2 != 0 && toLauncher && (profile.rotationHint == ROTATION_0
+                        || profile.rotationHint == ROTATION_180)) {
+                    mDisplayRect.set(0, 0, profile.heightPx, profile.widthPx);
+                } else {
+                    mDisplayRect.set(0, 0, profile.widthPx, profile.heightPx);
+                }
+                currentRect.round(mTmpResult);
+                android.util.RotationUtils.rotateBounds(mTmpResult, mDisplayRect, rotationDelta);
+                resultRect.set(mTmpResult);
+            } else {
+                resultRect.set(currentRect);
+            }
         }
     }
 
@@ -1996,21 +2070,53 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
         private final RemoteAnimationTarget[] mAppTargets;
         private final Matrix mMatrix = new Matrix();
         private final Point mTmpPos = new Point();
-        private final Rect mCurrentRect = new Rect();
+        private final RectF mCurrentRectF = new RectF();
         private final float mStartRadius;
         private final float mEndRadius;
         private final SurfaceTransactionApplier mSurfaceApplier;
-        private final Rect mWindowTargetBounds = new Rect();
+        private final Rect mWindowStartBounds = new Rect();
+        private final Rect mWindowOriginalBounds = new Rect();
 
         private final Rect mTmpRect = new Rect();
 
+        /**
+         * Constructor for SpringAnimRunner
+         *
+         * @param appTargets                the list of opening/closing apps
+         * @param targetRect                target rectangle
+         * @param closingWindowStartRect    start position of the window when the spring animation
+         *                                  is started. In the predictive back to home case this
+         *                                  will be smaller than closingWindowOriginalRect because
+         *                                  the window is already scaled by the user gesture
+         * @param closingWindowOriginalRect Original unscaled window rect
+         * @param startWindowCornerRadius   corner radius of window at the start position
+         */
         SpringAnimRunner(RemoteAnimationTarget[] appTargets, RectF targetRect,
-                         Rect windowTargetBounds, float startWindowCornerRadius) {
+                         Rect closingWindowStartRect, Rect closingWindowOriginalRect,
+                         float startWindowCornerRadius) {
             mAppTargets = appTargets;
             mStartRadius = startWindowCornerRadius;
             mEndRadius = Math.max(1, targetRect.width()) / 2f;
             mSurfaceApplier = new SurfaceTransactionApplier(mDragLayer);
-            mWindowTargetBounds.set(windowTargetBounds);
+            mWindowStartBounds.set(closingWindowStartRect);
+            mWindowOriginalBounds.set(closingWindowOriginalRect);
+
+            // transfer the coordinate based on animation target.
+            if (mAppTargets != null) {
+                for (RemoteAnimationTarget t : mAppTargets) {
+                    if (t.mode == MODE_CLOSING) {
+                        final RectF transferRect = new RectF(mWindowStartBounds);
+                        final RectF result = new RectF();
+                        transferRectToTargetCoordinate(t, transferRect, false, result);
+                        result.round(mWindowStartBounds);
+
+                        transferRect.set(closingWindowOriginalRect);
+                        transferRectToTargetCoordinate(t, transferRect, false, result);
+                        result.round(mWindowOriginalBounds);
+                        break;
+                    }
+                }
+            }
         }
 
         public float getCornerRadius(float progress) {
@@ -2024,38 +2130,39 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
                 RemoteAnimationTarget target = mAppTargets[i];
                 SurfaceProperties builder = transaction.forSurface(target.leash);
 
-                if (Utilities.ATLEAST_R && target.localBounds != null) {
+                if (target.localBounds != null) {
                     mTmpPos.set(target.localBounds.left, target.localBounds.top);
                 } else {
                     mTmpPos.set(target.position.x, target.position.y);
                 }
 
                 if (target.mode == MODE_CLOSING) {
-                    currentRectF.round(mCurrentRect);
+                    transferRectToTargetCoordinate(target, currentRectF, false, mCurrentRectF);
 
                     // Scale the target window to match the currentRectF.
                     final float scale;
 
                     // We need to infer the crop (we crop the window to match the currentRectF).
-                    if (mWindowTargetBounds.height() > mWindowTargetBounds.width()) {
-                        scale = Math.min(1f, currentRectF.width() / mWindowTargetBounds.width());
+                    if (mWindowStartBounds.height() > mWindowStartBounds.width()) {
+                        scale = Math.min(1f, mCurrentRectF.width() / mWindowOriginalBounds.width());
 
-                        int unscaledHeight = (int) (mCurrentRect.height() * (1f / scale));
-                        int croppedHeight = mWindowTargetBounds.height() - unscaledHeight;
-                        mTmpRect.set(0, 0, mWindowTargetBounds.width(),
-                                mWindowTargetBounds.height() - croppedHeight);
+                        int unscaledHeight = (int) (mCurrentRectF.height() * (1f / scale));
+                        int croppedHeight = mWindowStartBounds.height() - unscaledHeight;
+                        mTmpRect.set(0, 0, mWindowOriginalBounds.width(),
+                                mWindowStartBounds.height() - croppedHeight);
                     } else {
-                        scale = Math.min(1f, currentRectF.height() / mWindowTargetBounds.height());
+                        scale = Math.min(1f, mCurrentRectF.height()
+                                / mWindowOriginalBounds.height());
 
-                        int unscaledWidth = (int) (mCurrentRect.width() * (1f / scale));
-                        int croppedWidth = mWindowTargetBounds.width() - unscaledWidth;
-                        mTmpRect.set(0, 0, mWindowTargetBounds.width() - croppedWidth,
-                                mWindowTargetBounds.height());
+                        int unscaledWidth = (int) (mCurrentRectF.width() * (1f / scale));
+                        int croppedWidth = mWindowStartBounds.width() - unscaledWidth;
+                        mTmpRect.set(0, 0, mWindowStartBounds.width() - croppedWidth,
+                                mWindowOriginalBounds.height());
                     }
 
                     // Match size and position of currentRect.
                     mMatrix.setScale(scale, scale);
-                    mMatrix.postTranslate(mCurrentRect.left, mCurrentRect.top);
+                    mMatrix.postTranslate(mCurrentRectF.left, mCurrentRectF.top);
 
                     builder.setMatrix(mMatrix)
                             .setWindowCrop(mTmpRect)
@@ -2088,13 +2195,11 @@ public class QuickstepTransitionManager implements OnDeviceProfileChangeListener
     private static class LaunchDepthController extends DepthController {
         LaunchDepthController(QuickstepLauncher launcher) {
             super(launcher);
-            if (LawnchairApp.isAtleastT()) {
-                setCrossWindowBlursEnabled(
-                        CrossWindowBlurListeners.getInstance().isCrossWindowBlurEnabled());
-            }
+            setCrossWindowBlursEnabled(
+                    CrossWindowBlurListeners.getInstance().isCrossWindowBlurEnabled());
             // Make sure that the starting value matches the current depth set by the main
             // controller.
             stateDepth.setValue(launcher.getDepthController().stateDepth.getValue());
         }
     }
-}
+}
\ No newline at end of file
diff --git a/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java b/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java
index 0705b7fc6b..f2c6cc9774 100644
--- a/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/NavbarButtonsViewController.java
@@ -96,6 +96,7 @@ import com.android.launcher3.taskbar.navbutton.NavButtonLayoutFactory;
 import com.android.launcher3.taskbar.navbutton.NavButtonLayoutFactory.NavButtonLayoutter;
 import com.android.launcher3.taskbar.navbutton.NearestTouchFrame;
 import com.android.launcher3.util.DimensionUtils;
+import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.util.MultiPropertyFactory.MultiProperty;
 import com.android.launcher3.util.MultiValueAlpha;
 import com.android.launcher3.util.TouchController;
@@ -260,7 +261,7 @@ public class NavbarButtonsViewController implements TaskbarControllers.LoggableT
         mIsImeRenderingNavButtons = app.lawnchair.LawnchairApp.isAtleastT()
                 ? InputMethodService.canImeRenderGesturalNavButtons() && mContext.imeDrawsImeNavBar()
                 : mContext.imeDrawsImeNavBar();
-        mDisplayController = DisplayController.INSTANCE.get(mContext);
+//        mDisplayController = DisplayController.INSTANCE.get(mContext);
 
         if (!mIsImeRenderingNavButtons) {
             // IME switcher
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayer.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayer.java
index a43a511ecd..046bb54419 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayer.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarDragLayer.java
@@ -38,7 +38,7 @@ import androidx.annotation.Nullable;
 import androidx.core.graphics.Insets;
 import androidx.core.view.WindowInsetsCompat;
 
-import com.android.app.viewcapture.ViewCaptureFactory;
+//import com.android.app.viewcapture.ViewCaptureFactory;
 import com.android.launcher3.AbstractFloatingView;
 import com.android.launcher3.Utilities;
 import com.android.launcher3.testing.TestLogging;
@@ -156,10 +156,10 @@ public class TaskbarDragLayer extends BaseDragLayer<TaskbarActivityContext> {
     protected void onAttachedToWindow() {
         super.onAttachedToWindow();
         getViewTreeObserver().addOnComputeInternalInsetsListener(mTaskbarInsetsComputer);
-        if (Utilities.ATLEAST_U) {
-            mViewCaptureCloseable = SettingsAwareViewCapture.getInstance(getContext())
-                    .startCapture(getRootView(), ".Taskbar");
-        }
+//        if (Utilities.ATLEAST_U) {
+//            mViewCaptureCloseable = SettingsAwareViewCapture.getInstance(getContext())
+//                    .startCapture(getRootView(), ".Taskbar");
+//        }
     }
 
     @Override
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarEduTooltip.kt b/quickstep/src/com/android/launcher3/taskbar/TaskbarEduTooltip.kt
index 84150483b8..5adb25821d 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarEduTooltip.kt
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarEduTooltip.kt
@@ -102,8 +102,8 @@ constructor(
     override fun onFinishInflate() {
         super.onFinishInflate()
 
-        content = requireViewById(R.id.content)
-        arrow = requireViewById(R.id.arrow)
+        content = requireViewById<android.widget.FrameLayout>(R.id.content)
+        arrow = requireViewById<View>(R.id.arrow)
         arrow.background =
             RoundedArrowDrawable(
                 arrowWidth,
@@ -151,13 +151,13 @@ constructor(
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
-        findOnBackInvokedDispatcher()
-            ?.registerOnBackInvokedCallback(OnBackInvokedDispatcher.PRIORITY_DEFAULT, this)
+//        findOnBackInvokedDispatcher()
+//            ?.registerOnBackInvokedCallback(OnBackInvokedDispatcher.PRIORITY_DEFAULT, this)
     }
 
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
-        findOnBackInvokedDispatcher()?.unregisterOnBackInvokedCallback(this)
+//        findOnBackInvokedDispatcher()?.unregisterOnBackInvokedCallback(this)
         Settings.Secure.putInt(mContext.contentResolver, LAUNCHER_TASKBAR_EDUCATION_SHOWING, 0)
     }
 
diff --git a/quickstep/src/com/android/launcher3/taskbar/TaskbarManager.java b/quickstep/src/com/android/launcher3/taskbar/TaskbarManager.java
index 7d1180152c..02deb231eb 100644
--- a/quickstep/src/com/android/launcher3/taskbar/TaskbarManager.java
+++ b/quickstep/src/com/android/launcher3/taskbar/TaskbarManager.java
@@ -80,8 +80,6 @@ import com.android.systemui.unfold.util.ScopedUnfoldTransitionProgressProvider;
 import java.io.PrintWriter;
 import java.util.StringJoiner;
 
-import app.lawnchair.compat.LawnchairQuickstepCompat;
-
 /**
  * Class to manage taskbar lifecycle
  */
@@ -105,9 +103,6 @@ public class TaskbarManager {
             | ActivityInfo.CONFIG_SCREEN_LAYOUT
             | ActivityInfo.CONFIG_SMALLEST_SCREEN_SIZE;
 
-    public static final boolean FLAG_HIDE_NAVBAR_WINDOW = SystemProperties
-            .getBoolean("persist.wm.debug.hide_navbar_window", false);
-
     private static final Uri USER_SETUP_COMPLETE_URI = Settings.Secure.getUriFor(
             Settings.Secure.USER_SETUP_COMPLETE);
 
@@ -122,28 +117,26 @@ public class TaskbarManager {
     private final TaskbarNavButtonController mNavButtonController;
     private final ComponentCallbacks mComponentCallbacks;
 
-    private final SimpleBroadcastReceiver mShutdownReceiver = new SimpleBroadcastReceiver(
-            i -> destroyExistingTaskbar());
+    private final SimpleBroadcastReceiver mShutdownReceiver =
+            new SimpleBroadcastReceiver(i -> destroyExistingTaskbar());
 
     // The source for this provider is set when Launcher is available
-    // We use 'non-destroyable' version here so the original provider won't be
-    // destroyed
+    // We use 'non-destroyable' version here so the original provider won't be destroyed
     // as it is tied to the activity lifecycle, not the taskbar lifecycle.
     // It's destruction/creation will be managed by the activity.
-    private final ScopedUnfoldTransitionProgressProvider mUnfoldProgressProvider = new NonDestroyableScopedUnfoldTransitionProgressProvider();
+    private final ScopedUnfoldTransitionProgressProvider mUnfoldProgressProvider =
+            new NonDestroyableScopedUnfoldTransitionProgressProvider();
 
     private TaskbarActivityContext mTaskbarActivityContext;
     private StatefulActivity mActivity;
     /**
-     * Cache a copy here so we can initialize state whenever taskbar is recreated,
-     * since
+     * Cache a copy here so we can initialize state whenever taskbar is recreated, since
      * this class does not get re-initialized w/ new taskbars.
      */
     private final TaskbarSharedState mSharedState = new TaskbarSharedState();
 
     /**
-     * We use WindowManager's ComponentCallbacks() for internal UI changes (similar
-     * to an Activity)
+     * We use WindowManager's ComponentCallbacks() for internal UI changes (similar to an Activity)
      * which comes via a different channel
      */
     private final RecreationListener mRecreationListener = new RecreationListener();
@@ -157,13 +150,12 @@ public class TaskbarManager {
             }
         }
     }
-
     private final SettingsCache.OnChangeListener mOnSettingsChangeListener = c -> recreateTaskbar();
 
     private boolean mUserUnlocked = false;
 
-    private final SimpleBroadcastReceiver mTaskbarBroadcastReceiver = new SimpleBroadcastReceiver(
-            this::showTaskbarFromBroadcast);
+    private final SimpleBroadcastReceiver mTaskbarBroadcastReceiver =
+            new SimpleBroadcastReceiver(this::showTaskbarFromBroadcast);
 
     private final AllAppsActionManager mAllAppsActionManager;
 
@@ -187,33 +179,34 @@ public class TaskbarManager {
         }
     };
 
-    UnfoldTransitionProgressProvider.TransitionProgressListener mUnfoldTransitionProgressListener = new UnfoldTransitionProgressProvider.TransitionProgressListener() {
-        @Override
-        public void onTransitionStarted() {
-            Log.d(TASKBAR_NOT_DESTROYED_TAG,
-                    "fold/unfold transition started getting called.");
-        }
+    UnfoldTransitionProgressProvider.TransitionProgressListener mUnfoldTransitionProgressListener =
+            new UnfoldTransitionProgressProvider.TransitionProgressListener() {
+                @Override
+                public void onTransitionStarted() {
+                    Log.d(TASKBAR_NOT_DESTROYED_TAG,
+                            "fold/unfold transition started getting called.");
+                }
 
-        @Override
-        public void onTransitionProgress(float progress) {
-            Log.d(TASKBAR_NOT_DESTROYED_TAG,
-                    "fold/unfold transition progress : " + progress);
-        }
+                @Override
+                public void onTransitionProgress(float progress) {
+                    Log.d(TASKBAR_NOT_DESTROYED_TAG,
+                            "fold/unfold transition progress : " + progress);
+                }
 
-        @Override
-        public void onTransitionFinishing() {
-            Log.d(TASKBAR_NOT_DESTROYED_TAG,
-                    "fold/unfold transition finishing getting called.");
+                @Override
+                public void onTransitionFinishing() {
+                    Log.d(TASKBAR_NOT_DESTROYED_TAG,
+                            "fold/unfold transition finishing getting called.");
 
-        }
+                }
 
-        @Override
-        public void onTransitionFinished() {
-            Log.d(TASKBAR_NOT_DESTROYED_TAG,
-                    "fold/unfold transition finished getting called.");
+                @Override
+                public void onTransitionFinished() {
+                    Log.d(TASKBAR_NOT_DESTROYED_TAG,
+                            "fold/unfold transition finished getting called.");
 
-        }
-    };
+                }
+            };
 
     @SuppressLint("WrongConstant")
     public TaskbarManager(
@@ -221,14 +214,11 @@ public class TaskbarManager {
             AllAppsActionManager allAppsActionManager,
             TaskbarNavButtonCallbacks navCallbacks) {
 
-        Display display = context.getSystemService(DisplayManager.class).getDisplay(DEFAULT_DISPLAY);
-        mContext = (LawnchairQuickstepCompat.ATLEAST_T)
-                ? service.createWindowContext(display, TYPE_NAVIGATION_BAR_PANEL, null)
-                : (LawnchairQuickstepCompat.ATLEAST_S)
-                        ? service.createWindowContext(display, TYPE_APPLICATION_OVERLAY, null)
-                        : (LawnchairQuickstepCompat.ATLEAST_R)
-                                ? service.createWindowContext(TYPE_APPLICATION_OVERLAY, null)
-                                : service;
+        Display display =
+                context.getSystemService(DisplayManager.class).getDisplay(DEFAULT_DISPLAY);
+        mContext = context.createWindowContext(display,
+                ENABLE_TASKBAR_NAVBAR_UNIFICATION ? TYPE_NAVIGATION_BAR : TYPE_NAVIGATION_BAR_PANEL,
+                null);
         mAllAppsActionManager = allAppsActionManager;
         mNavigationBarPanelContext = ENABLE_TASKBAR_NAVBAR_UNIFICATION
                 ? context.createWindowContext(display, TYPE_NAVIGATION_BAR_PANEL, null)
@@ -259,10 +249,8 @@ public class TaskbarManager {
 
             @Override
             public void onConfigurationChanged(Configuration newConfig) {
-                if (LawnchairQuickstepCompat.ATLEAST_T) {
-                    Trace.instantForTrack(Trace.TRACE_TAG_APP, "TaskbarManager",
-                            "onConfigurationChanged: " + newConfig);
-                }
+                Trace.instantForTrack(Trace.TRACE_TAG_APP, "TaskbarManager",
+                        "onConfigurationChanged: " + newConfig);
                 debugWhyTaskbarNotDestroyed(
                         "TaskbarManager#mComponentCallbacks.onConfigurationChanged: " + newConfig);
                 DeviceProfile dp = mUserUnlocked
@@ -302,15 +290,13 @@ public class TaskbarManager {
                     }
                 }
                 mOldConfig = new Configuration(newConfig);
-                // reset taskbar was pinned value, so we don't automatically unstash taskbar
-                // upon
+                // reset taskbar was pinned value, so we don't automatically unstash taskbar upon
                 // user unfolding the device.
                 mSharedState.setTaskbarWasPinned(false);
             }
 
             @Override
-            public void onLowMemory() {
-            }
+            public void onLowMemory() { }
         };
         SettingsCache.INSTANCE.get(mContext)
                 .register(USER_SETUP_COMPLETE_URI, mOnSettingsChangeListener);
@@ -343,7 +329,8 @@ public class TaskbarManager {
                 mTaskbarActivityContext = null;
             }
         }
-        DeviceProfile dp = mUserUnlocked ? LauncherAppState.getIDP(mContext).getDeviceProfile(mContext) : null;
+        DeviceProfile dp = mUserUnlocked ?
+                LauncherAppState.getIDP(mContext).getDeviceProfile(mContext) : null;
         if (dp == null || !isTaskbarEnabled(dp)) {
             removeTaskbarRootViewFromWindow();
         }
@@ -363,11 +350,9 @@ public class TaskbarManager {
      */
     public void toggleAllApps() {
         if (mTaskbarActivityContext == null || mTaskbarActivityContext.canToggleHomeAllApps()) {
-            // Home All Apps should be toggled from this class, because the controllers are
-            // not
+            // Home All Apps should be toggled from this class, because the controllers are not
             // initialized when Taskbar is disabled (i.e. TaskbarActivityContext is null).
-            if (mActivity instanceof Launcher l)
-                l.toggleAllAppsSearch();
+            if (mActivity instanceof Launcher l) l.toggleAllAppsSearch();
         } else {
             mTaskbarActivityContext.toggleAllAppsSearch();
         }
@@ -376,14 +361,12 @@ public class TaskbarManager {
     /**
      * Displays a frame of the first Launcher reveal animation.
      *
-     * This should be used to run a first Launcher reveal animation whose progress
-     * matches a swipe
+     * This should be used to run a first Launcher reveal animation whose progress matches a swipe
      * progress.
      */
     public AnimatorPlaybackController createLauncherStartFromSuwAnim(int duration) {
         return mTaskbarActivityContext == null
-                ? null
-                : mTaskbarActivityContext.createLauncherStartFromSuwAnim(duration);
+                ? null : mTaskbarActivityContext.createLauncherStartFromSuwAnim(duration);
     }
 
     /**
@@ -396,10 +379,6 @@ public class TaskbarManager {
         addTaskbarRootViewToWindow();
     }
 
-    public void onUserPreferenceChanged() {
-        recreateTaskbar();
-    }
-
     /**
      * Sets a {@link StatefulActivity} to act as taskbar callback
      */
@@ -414,8 +393,8 @@ public class TaskbarManager {
         Log.d(TASKBAR_NOT_DESTROYED_TAG,
                 "registering activity lifecycle callbacks from setActivity().");
         mActivity.addEventCallback(EVENT_DESTROYED, mActivityOnDestroyCallback);
-        UnfoldTransitionProgressProvider unfoldTransitionProgressProvider = getUnfoldTransitionProgressProviderForActivity(
-                activity);
+        UnfoldTransitionProgressProvider unfoldTransitionProgressProvider =
+                getUnfoldTransitionProgressProviderForActivity(activity);
         if (unfoldTransitionProgressProvider != null) {
             unfoldTransitionProgressProvider.addCallback(mUnfoldTransitionProgressListener);
         }
@@ -428,8 +407,7 @@ public class TaskbarManager {
     }
 
     /**
-     * Returns an {@link UnfoldTransitionProgressProvider} to use while the given
-     * StatefulActivity
+     * Returns an {@link UnfoldTransitionProgressProvider} to use while the given StatefulActivity
      * is active.
      */
     private UnfoldTransitionProgressProvider getUnfoldTransitionProgressProviderForActivity(
@@ -445,8 +423,7 @@ public class TaskbarManager {
     }
 
     /**
-     * Creates a {@link TaskbarUIController} to use while the given StatefulActivity
-     * is active.
+     * Creates a {@link TaskbarUIController} to use while the given StatefulActivity is active.
      */
     private TaskbarUIController createTaskbarUIControllerForActivity(StatefulActivity activity) {
         if (activity instanceof QuickstepLauncher) {
@@ -459,8 +436,7 @@ public class TaskbarManager {
     }
 
     /**
-     * This method is called multiple times (ex. initial init, then when user
-     * unlocks) in which case
+     * This method is called multiple times (ex. initial init, then when user unlocks) in which case
      * we fully want to destroy an existing taskbar and create a new one.
      * In other case (folding/unfolding) we don't need to remove and add window.
      */
@@ -468,10 +444,10 @@ public class TaskbarManager {
     public synchronized void recreateTaskbar() {
         Trace.beginSection("recreateTaskbar");
         try {
-            DeviceProfile dp = mUserUnlocked ? LauncherAppState.getIDP(mContext).getDeviceProfile(mContext) : null;
+            DeviceProfile dp = mUserUnlocked ?
+                    LauncherAppState.getIDP(mContext).getDeviceProfile(mContext) : null;
 
-            // All Apps action is unrelated to navbar unification, so we only need to check
-            // DP.
+            // All Apps action is unrelated to navbar unification, so we only need to check DP.
             final boolean isLargeScreenTaskbar = dp != null && dp.isTaskbarPresent;
             mAllAppsActionManager.setTaskbarPresent(isLargeScreenTaskbar);
 
@@ -495,7 +471,8 @@ public class TaskbarManager {
             } else {
                 mTaskbarActivityContext.updateDeviceProfile(dp);
             }
-            mSharedState.startTaskbarVariantIsTransient = DisplayController.isTransientTaskbar(mTaskbarActivityContext);
+            mSharedState.startTaskbarVariantIsTransient =
+                    DisplayController.isTransientTaskbar(mTaskbarActivityContext);
             mSharedState.allAppsVisible = mSharedState.allAppsVisible && isLargeScreenTaskbar;
             mTaskbarActivityContext.init(mSharedState);
 
@@ -513,10 +490,6 @@ public class TaskbarManager {
         } finally {
             Trace.endSection();
         }
-
-        // We to wait until user unlocks the device to attach listener.
-        LauncherPrefs.get(mContext).addListener(mTaskbarPinningPreferenceChangeListener,
-                TASKBAR_PINNING);
     }
 
     public void onSystemUiFlagsChanged(@SystemUiStateFlags long systemUiStateFlags) {
@@ -595,8 +568,8 @@ public class TaskbarManager {
                     "unregistering activity lifecycle callbacks from "
                             + "removeActivityCallbackAndListeners().");
             mActivity.removeEventCallback(EVENT_DESTROYED, mActivityOnDestroyCallback);
-            UnfoldTransitionProgressProvider unfoldTransitionProgressProvider = getUnfoldTransitionProgressProviderForActivity(
-                    mActivity);
+            UnfoldTransitionProgressProvider unfoldTransitionProgressProvider =
+                    getUnfoldTransitionProgressProviderForActivity(mActivity);
             if (unfoldTransitionProgressProvider != null) {
                 unfoldTransitionProgressProvider.removeCallback(mUnfoldTransitionProgressListener);
             }
@@ -694,6 +667,6 @@ public class TaskbarManager {
         Log.d(TASKBAR_NOT_DESTROYED_TAG, log.toString());
     }
 
-    private final DeviceProfile.OnDeviceProfileChangeListener mDebugActivityDeviceProfileChanged = dp -> debugWhyTaskbarNotDestroyed(
-            "mActivity onDeviceProfileChanged");
-}
+    private final DeviceProfile.OnDeviceProfileChangeListener mDebugActivityDeviceProfileChanged =
+            dp -> debugWhyTaskbarNotDestroyed("mActivity onDeviceProfileChanged");
+}
\ No newline at end of file
diff --git a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarController.java b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarController.java
index f0471b89c9..707ab8f1d6 100644
--- a/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarController.java
+++ b/quickstep/src/com/android/launcher3/taskbar/bubbles/BubbleBarController.java
@@ -650,7 +650,7 @@ public class BubbleBarController extends IBubblesListener.Stub {
         Drawable drawable = new AdaptiveIconDrawable(new ColorDrawable(overflowBackgroundColor),
                 foreground);
 
-        return mIconFactory.createBadgedIconBitmap(drawable, Process.myUserHandle(), true).icon;
+        return mIconFactory.createBadgedIconBitmap(drawable).icon;
     }
 
     private void onBubbleBarBoundsChanged() {
diff --git a/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java b/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java
index 2168f7a318..89faba85be 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/QuickstepLauncher.java
@@ -111,6 +111,7 @@ import com.android.launcher3.InvariantDeviceProfile;
 import com.android.launcher3.Launcher;
 import com.android.launcher3.LauncherSettings.Favorites;
 import com.android.launcher3.LauncherState;
+import com.android.launcher3.OnBackPressedHandler;
 import com.android.launcher3.QuickstepAccessibilityDelegate;
 import com.android.launcher3.QuickstepTransitionManager;
 import com.android.launcher3.R;
@@ -309,7 +310,7 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer
 
     @Override
     public void logAppLaunch(StatsLogManager statsLogManager, ItemInfo info,
-            InstanceId instanceId) {
+                             InstanceId instanceId) {
         // If the app launch is from any of the surfaces in AllApps then add the InstanceId from
         // LiveSearchManager to recreate the AllApps session on the server side.
         if (mAllAppsSessionLogId != null && ALL_APPS.equals(
@@ -341,7 +342,7 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer
 
     @Override
     protected void completeAddShortcut(Intent data, int container, int screenId, int cellX,
-            int cellY, PendingRequestArgs args) {
+                                       int cellY, PendingRequestArgs args) {
         if (container == CONTAINER_HOTSEAT) {
             mHotseatPredictionController.onDeferredDrop(cellX, cellY);
         }
@@ -879,7 +880,7 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer
             return false;
         }
 
-        getOnBackAnimationCallback().onBackInvoked();
+//        getOnBackAnimationCallback().onBackInvoked();
         return true;
     }
 
@@ -893,51 +894,50 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer
                 OnBackInvokedDispatcher.PRIORITY_DEFAULT,
                 new OnBackAnimationCallback() {
 
-                    @Nullable OnBackAnimationCallback mActiveOnBackAnimationCallback;
+                    @Nullable
+                    OnBackPressedHandler mActiveOnBackPressedHandler;
 
                     @Override
                     public void onBackStarted(@NonNull BackEvent backEvent) {
-                        if (mActiveOnBackAnimationCallback != null) {
-                            mActiveOnBackAnimationCallback.onBackCancelled();
+                        if (mActiveOnBackPressedHandler != null) {
+                            mActiveOnBackPressedHandler.onBackCancelled();
                         }
-                        mActiveOnBackAnimationCallback = getOnBackAnimationCallback();
-                        mActiveOnBackAnimationCallback.onBackStarted(backEvent);
+                        mActiveOnBackPressedHandler = getOnBackPressedHandler();
+                        mActiveOnBackPressedHandler.onBackStarted();
                     }
 
-                    @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
                     @Override
                     public void onBackInvoked() {
-                        // Recreate mActiveOnBackAnimationCallback if necessary to avoid NPE
+                        // Recreate mActiveOnBackPressedHandler if necessary to avoid NPE
                         // because:
                         // 1. b/260636433: In 3-button-navigation mode, onBackStarted() is not
                         // called on ACTION_DOWN before onBackInvoked() is called in ACTION_UP.
                         // 2. Launcher#onBackPressed() will call onBackInvoked() without calling
                         // onBackInvoked() beforehand.
-                        if (mActiveOnBackAnimationCallback == null) {
-                            mActiveOnBackAnimationCallback = getOnBackAnimationCallback();
+                        if (mActiveOnBackPressedHandler == null) {
+                            mActiveOnBackPressedHandler = getOnBackPressedHandler();
                         }
-                        mActiveOnBackAnimationCallback.onBackInvoked();
-                        mActiveOnBackAnimationCallback = null;
+                        mActiveOnBackPressedHandler.onBackInvoked();
+                        mActiveOnBackPressedHandler = null;
                         TestLogging.recordEvent(TestProtocol.SEQUENCE_MAIN, "onBackInvoked");
                     }
-
                     @Override
                     public void onBackProgressed(@NonNull BackEvent backEvent) {
                         if (!FeatureFlags.IS_STUDIO_BUILD
-                                && mActiveOnBackAnimationCallback == null) {
+                                && mActiveOnBackPressedHandler == null) {
                             return;
                         }
-                        mActiveOnBackAnimationCallback.onBackProgressed(backEvent);
+                        mActiveOnBackPressedHandler.onBackProgressed(backEvent.getProgress());
                     }
 
                     @Override
                     public void onBackCancelled() {
                         if (!FeatureFlags.IS_STUDIO_BUILD
-                                && mActiveOnBackAnimationCallback == null) {
+                                && mActiveOnBackPressedHandler == null) {
                             return;
                         }
-                        mActiveOnBackAnimationCallback.onBackCancelled();
-                        mActiveOnBackAnimationCallback = null;
+                        mActiveOnBackPressedHandler.onBackCancelled();
+                        mActiveOnBackPressedHandler = null;
                     }
                 });
     }
@@ -954,7 +954,7 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer
 
     @Override
     public void startIntentSenderForResult(IntentSender intent, int requestCode,
-            Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options) {
+                                           Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, Bundle options) {
         if (requestCode != -1) {
             mPendingActivityRequestCode = requestCode;
             StartActivityParams params = new StartActivityParams(this, requestCode);
@@ -1071,7 +1071,7 @@ public class QuickstepLauncher extends Launcher implements RecentsViewContainer
     }
 
     private void initUnfoldAnimationController(UnfoldTransitionProgressProvider progressProvider,
-            @UnfoldMain RotationChangeProvider rotationChangeProvider) {
+                                               @UnfoldMain RotationChangeProvider rotationChangeProvider) {
         mLauncherUnfoldAnimationController = new LauncherUnfoldAnimationController(
                 /* launcher= */ this,
                 getWindowManager(),
diff --git a/quickstep/src/com/android/launcher3/uioverrides/QuickstepWidgetHolder.java b/quickstep/src/com/android/launcher3/uioverrides/QuickstepWidgetHolder.java
index 17f5d0cc62..45398b0267 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/QuickstepWidgetHolder.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/QuickstepWidgetHolder.java
@@ -15,7 +15,7 @@
  */
 package com.android.launcher3.uioverrides;
 
-import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.BuildConfigs.WIDGETS_ENABLED;
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 import static com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR;
 
diff --git a/quickstep/src/com/android/launcher3/uioverrides/SystemApiWrapper.kt b/quickstep/src/com/android/launcher3/uioverrides/SystemApiWrapper.kt
deleted file mode 100644
index 04696364e0..0000000000
--- a/quickstep/src/com/android/launcher3/uioverrides/SystemApiWrapper.kt
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Copyright (C) 2024 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.uioverrides
-
-import android.app.ActivityOptions
-import android.app.PendingIntent
-import android.app.role.RoleManager
-import android.content.Context
-import android.content.IIntentReceiver
-import android.content.IIntentSender
-import android.content.Intent
-import android.content.pm.ActivityInfo
-import android.content.pm.LauncherActivityInfo
-import android.content.pm.LauncherApps
-import android.content.pm.ShortcutInfo
-import android.os.Bundle
-import android.os.Flags.allowPrivateProfile
-import android.os.IBinder
-import android.os.UserHandle
-import android.os.UserManager
-import android.util.ArrayMap
-import android.widget.Toast
-import android.window.RemoteTransition
-import com.android.launcher3.Flags.enablePrivateSpace
-import com.android.launcher3.Flags.enablePrivateSpaceInstallShortcut
-import com.android.launcher3.Flags.privateSpaceAppInstallerButton
-import com.android.launcher3.Flags.privateSpaceSysAppsSeparation
-import com.android.launcher3.R
-import com.android.launcher3.Utilities
-import com.android.launcher3.proxy.ProxyActivityStarter
-import com.android.launcher3.util.ApiWrapper
-import com.android.launcher3.util.Executors
-import com.android.launcher3.util.StartActivityParams
-import com.android.launcher3.util.UserIconInfo
-import com.android.quickstep.util.FadeOutRemoteTransition
-
-/** A wrapper for the hidden API calls */
-open class SystemApiWrapper(context: Context?) : ApiWrapper(context) {
-
-    override fun getPersons(si: ShortcutInfo) = si.persons ?: Utilities.EMPTY_PERSON_ARRAY
-
-    override fun getActivityOverrides(): Map<String, LauncherActivityInfo> =
-        mContext.getSystemService(LauncherApps::class.java)!!.activityOverrides
-
-    override fun createFadeOutAnimOptions(): ActivityOptions =
-        ActivityOptions.makeBasic().apply {
-            remoteTransition = RemoteTransition(FadeOutRemoteTransition())
-        }
-
-    override fun queryAllUsers(): Map<UserHandle, UserIconInfo> {
-        if (!allowPrivateProfile() || !enablePrivateSpace()) {
-            return super.queryAllUsers()
-        }
-        val users = ArrayMap<UserHandle, UserIconInfo>()
-        mContext.getSystemService(UserManager::class.java)!!.userProfiles?.forEach { user ->
-            mContext.getSystemService(LauncherApps::class.java)!!.getLauncherUserInfo(user)?.apply {
-                users[user] =
-                    UserIconInfo(
-                        user,
-                        when (userType) {
-                            UserManager.USER_TYPE_PROFILE_MANAGED -> UserIconInfo.TYPE_WORK
-                            UserManager.USER_TYPE_PROFILE_CLONE -> UserIconInfo.TYPE_CLONED
-                            UserManager.USER_TYPE_PROFILE_PRIVATE -> UserIconInfo.TYPE_PRIVATE
-                            else -> UserIconInfo.TYPE_MAIN
-                        },
-                        userSerialNumber.toLong()
-                    )
-            }
-        }
-        return users
-    }
-
-    override fun getPreInstalledSystemPackages(user: UserHandle): List<String> =
-        if (allowPrivateProfile() && enablePrivateSpace() && privateSpaceSysAppsSeparation())
-            mContext
-                .getSystemService(LauncherApps::class.java)!!
-                .getPreInstalledSystemPackages(user)
-        else ArrayList()
-
-    override fun getAppMarketActivityIntent(packageName: String, user: UserHandle): Intent =
-        if (
-            allowPrivateProfile() &&
-                enablePrivateSpace() &&
-                (privateSpaceAppInstallerButton() || enablePrivateSpaceInstallShortcut())
-        )
-            ProxyActivityStarter.getLaunchIntent(
-                mContext,
-                StartActivityParams(null as PendingIntent?, 0).apply {
-                    intentSender =
-                        mContext
-                            .getSystemService(LauncherApps::class.java)!!
-                            .getAppMarketActivityIntent(packageName, user)
-                    options =
-                        ActivityOptions.makeBasic()
-                            .setPendingIntentBackgroundActivityStartMode(
-                                ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED
-                            )
-                            .toBundle()
-                    requireActivityResult = false
-                }
-            )
-        else super.getAppMarketActivityIntent(packageName, user)
-
-    /** Returns an intent which can be used to open Private Space Settings. */
-    override fun getPrivateSpaceSettingsIntent(): Intent? =
-        if (allowPrivateProfile() && enablePrivateSpace())
-            ProxyActivityStarter.getLaunchIntent(
-                mContext,
-                StartActivityParams(null as PendingIntent?, 0).apply {
-                    intentSender =
-                        mContext
-                            .getSystemService(LauncherApps::class.java)
-                            ?.privateSpaceSettingsIntent ?: return null
-                    options =
-                        ActivityOptions.makeBasic()
-                            .setPendingIntentBackgroundActivityStartMode(
-                                ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED
-                            )
-                            .toBundle()
-                    requireActivityResult = false
-                }
-            )
-        else null
-
-    override fun isNonResizeableActivity(lai: LauncherActivityInfo) =
-        lai.activityInfo.resizeMode == ActivityInfo.RESIZE_MODE_UNRESIZEABLE
-
-    /**
-     * Starts an Activity which can be used to set this Launcher as the HOME app, via a consent
-     * screen. In case the consent screen cannot be shown, or the user does not set current Launcher
-     * as HOME app, a toast asking the user to do the latter is shown.
-     */
-    override fun assignDefaultHomeRole(context: Context) {
-        val roleManager = context.getSystemService(RoleManager::class.java)
-        if (
-            (roleManager!!.isRoleAvailable(RoleManager.ROLE_HOME) &&
-                !roleManager.isRoleHeld(RoleManager.ROLE_HOME))
-        ) {
-            val roleRequestIntent = roleManager.createRequestRoleIntent(RoleManager.ROLE_HOME)
-            val pendingIntent =
-                PendingIntent(
-                    object : IIntentSender.Stub() {
-                        override fun send(
-                            code: Int,
-                            intent: Intent,
-                            resolvedType: String?,
-                            allowlistToken: IBinder?,
-                            finishedReceiver: IIntentReceiver?,
-                            requiredPermission: String?,
-                            options: Bundle?
-                        ) {
-                            if (code != -1) {
-                                Executors.MAIN_EXECUTOR.execute {
-                                    Toast.makeText(
-                                            context,
-                                            context.getString(
-                                                R.string.set_default_home_app,
-                                                context.getString(R.string.derived_app_name)
-                                            ),
-                                            Toast.LENGTH_LONG
-                                        )
-                                        .show()
-                                }
-                            }
-                        }
-                    }
-                )
-            val params = StartActivityParams(pendingIntent, 0)
-            params.intent = roleRequestIntent
-            context.startActivity(ProxyActivityStarter.getLaunchIntent(context, params))
-        }
-    }
-}
diff --git a/quickstep/src/com/android/launcher3/uioverrides/plugins/PluginManagerWrapperImpl.java b/quickstep/src/com/android/launcher3/uioverrides/plugins/PluginManagerWrapperImpl.java
index bc919c80d6..83f66b1f1f 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/plugins/PluginManagerWrapperImpl.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/plugins/PluginManagerWrapperImpl.java
@@ -28,6 +28,7 @@ import android.content.pm.ResolveInfo;
 
 import androidx.core.content.ContextCompat;
 
+import com.android.launcher3.BuildConfigs;
 import com.android.launcher3.Utilities;
 import com.android.launcher3.util.MainThreadInitializedObject;
 import com.android.launcher3.BuildConfig;
@@ -61,14 +62,14 @@ public class PluginManagerWrapperImpl extends PluginManagerWrapper {
         PluginInstance.Factory instanceFactory = new PluginInstance.Factory(
                 getClass().getClassLoader(), new PluginInstance.InstanceFactory<>(),
                 new PluginInstance.VersionCheckerImpl(), privilegedPlugins,
-                BuildConfig.IS_DEBUG_DEVICE);
+                BuildConfigs.IS_DEBUG_DEVICE);
         PluginActionManager.Factory instanceManagerFactory = new PluginActionManager.Factory(
                 c, c.getPackageManager(), ContextCompat.getMainExecutor(c), MODEL_EXECUTOR,
                 c.getSystemService(NotificationManager.class), mPluginEnabler,
                 privilegedPlugins, instanceFactory);
 
         mPluginManager = new PluginManagerImpl(c, instanceManagerFactory,
-                BuildConfig.IS_DEBUG_DEVICE,
+                BuildConfigs.IS_DEBUG_DEVICE,
                 UNCAUGHT_EXCEPTION_PRE_HANDLER_MANAGER, mPluginEnabler,
                 new PluginPrefs(c), privilegedPlugins);
     }
diff --git a/quickstep/src/com/android/launcher3/uioverrides/touchcontrollers/TaskViewTouchController.java b/quickstep/src/com/android/launcher3/uioverrides/touchcontrollers/TaskViewTouchController.java
index 574adedb6c..205da70513 100644
--- a/quickstep/src/com/android/launcher3/uioverrides/touchcontrollers/TaskViewTouchController.java
+++ b/quickstep/src/com/android/launcher3/uioverrides/touchcontrollers/TaskViewTouchController.java
@@ -47,8 +47,6 @@ import com.android.quickstep.views.RecentsView;
 import com.android.quickstep.views.RecentsViewContainer;
 import com.android.quickstep.views.TaskView;
 
-import app.lawnchair.util.RecentHelper;
-
 /**
  * Touch controller for handling task view card swipes
  */
@@ -60,9 +58,11 @@ public abstract class TaskViewTouchController<CONTAINER extends Context & Recent
     private static final long MIN_TASK_DISMISS_ANIMATION_DURATION = 300;
     private static final long MAX_TASK_DISMISS_ANIMATION_DURATION = 600;
 
-    public static final int TASK_DISMISS_VIBRATION_PRIMITIVE = VibrationEffect.Composition.PRIMITIVE_TICK;
+    public static final int TASK_DISMISS_VIBRATION_PRIMITIVE =
+            VibrationEffect.Composition.PRIMITIVE_TICK;
     public static final float TASK_DISMISS_VIBRATION_PRIMITIVE_SCALE = 1f;
-    public static final VibrationEffect TASK_DISMISS_VIBRATION_FALLBACK = VibrationConstants.EFFECT_TEXTURE_TICK;
+    public static final VibrationEffect TASK_DISMISS_VIBRATION_FALLBACK =
+            VibrationConstants.EFFECT_TEXTURE_TICK;
 
     protected final CONTAINER mContainer;
     private final SingleAxisSwipeDetector mDetector;
@@ -92,7 +92,8 @@ public abstract class TaskViewTouchController<CONTAINER extends Context & Recent
         mContainer = container;
         mRecentsView = container.getOverviewPanel();
         mIsRtl = Utilities.isRtl(container.getResources());
-        SingleAxisSwipeDetector.Direction dir = mRecentsView.getPagedOrientationHandler().getUpDownSwipeDirection();
+        SingleAxisSwipeDetector.Direction dir =
+                mRecentsView.getPagedOrientationHandler().getUpDownSwipeDirection();
         mDetector = new SingleAxisSwipeDetector(container, this, dir);
     }
 
@@ -225,15 +226,15 @@ public abstract class TaskViewTouchController<CONTAINER extends Context & Recent
             mCurrentAnimation.dispatchOnCancel();
         }
 
-        RecentsPagedOrientationHandler orientationHandler = mRecentsView.getPagedOrientationHandler();
+        RecentsPagedOrientationHandler orientationHandler =
+                mRecentsView.getPagedOrientationHandler();
         mCurrentAnimationIsGoingUp = goingUp;
         BaseDragLayer dl = mContainer.getDragLayer();
         final int secondaryLayerDimension = orientationHandler.getSecondaryDimension(dl);
         long maxDuration = 2 * secondaryLayerDimension;
         int verticalFactor = orientationHandler.getTaskDragDisplacementFactor(mIsRtl);
         int secondaryTaskDimension = orientationHandler.getSecondaryDimension(mTaskBeingDragged);
-        // The interpolator controlling the most prominent visual movement. We use this
-        // to determine
+        // The interpolator controlling the most prominent visual movement. We use this to determine
         // whether we passed SUCCESS_TRANSITION_PROGRESS.
         final Interpolator currentInterpolator;
         PendingAnimation pa;
@@ -242,7 +243,7 @@ public abstract class TaskViewTouchController<CONTAINER extends Context & Recent
             pa = new PendingAnimation(maxDuration);
             mRecentsView.createTaskDismissAnimation(pa, mTaskBeingDragged,
                     true /* animateTaskView */, true /* removeTask */, maxDuration,
-                    false /* dismissingForSplitSelection */);
+                    false /* dismissingForSplitSelection*/);
 
             mEndDisplacement = -secondaryTaskDimension;
         } else {
@@ -250,8 +251,7 @@ public abstract class TaskViewTouchController<CONTAINER extends Context & Recent
             pa = mRecentsView.createTaskLaunchAnimation(
                     mTaskBeingDragged, maxDuration, currentInterpolator);
 
-            // Since the thumbnail is what is filling the screen, based the end displacement
-            // on it.
+            // Since the thumbnail is what is filling the screen, based the end displacement on it.
             View thumbnailView = mTaskBeingDragged.getFirstThumbnailViewDeprecated();
             mTempCords[1] = orientationHandler.getSecondaryDimension(thumbnailView);
             dl.getDescendantCoordRelativeToSelf(thumbnailView, mTempCords);
@@ -260,8 +260,7 @@ public abstract class TaskViewTouchController<CONTAINER extends Context & Recent
         mEndDisplacement *= verticalFactor;
         mCurrentAnimation = pa.createPlaybackController();
 
-        // Setting this interpolator doesn't affect the visual motion, but is used to
-        // determine
+        // Setting this interpolator doesn't affect the visual motion, but is used to determine
         // whether we successfully reached the target state in onDragEnd().
         mCurrentAnimation.getTarget().setInterpolator(currentInterpolator);
         onUserControlledAnimationCreated(mCurrentAnimation);
@@ -272,10 +271,10 @@ public abstract class TaskViewTouchController<CONTAINER extends Context & Recent
 
     @Override
     public void onDragStart(boolean start, float startDisplacement) {
-        if (!mDraggingEnabled)
-            return;
+        if (!mDraggingEnabled) return;
 
-        RecentsPagedOrientationHandler orientationHandler = mRecentsView.getPagedOrientationHandler();
+        RecentsPagedOrientationHandler orientationHandler =
+                mRecentsView.getPagedOrientationHandler();
         if (mCurrentAnimation == null) {
             reInitAnimationController(orientationHandler.isGoingUp(startDisplacement, mIsRtl));
             mDisplacementShift = 0;
@@ -289,13 +288,13 @@ public abstract class TaskViewTouchController<CONTAINER extends Context & Recent
 
     @Override
     public boolean onDrag(float displacement) {
-        if (!mDraggingEnabled)
-            return true;
+        if (!mDraggingEnabled) return true;
 
-        RecentsPagedOrientationHandler orientationHandler = mRecentsView.getPagedOrientationHandler();
+        RecentsPagedOrientationHandler orientationHandler =
+                mRecentsView.getPagedOrientationHandler();
         float totalDisplacement = displacement + mDisplacementShift;
-        boolean isGoingUp = totalDisplacement == 0 ? mCurrentAnimationIsGoingUp
-                : orientationHandler.isGoingUp(totalDisplacement, mIsRtl);
+        boolean isGoingUp = totalDisplacement == 0 ? mCurrentAnimationIsGoingUp :
+                orientationHandler.isGoingUp(totalDisplacement, mIsRtl);
         if (isGoingUp != mCurrentAnimationIsGoingUp) {
             reInitAnimationController(isGoingUp);
             mFlingBlockCheck.blockFling();
@@ -314,7 +313,8 @@ public abstract class TaskViewTouchController<CONTAINER extends Context & Recent
                 int velocityDimenId = R.dimen.default_task_dismiss_drag_velocity;
                 if (mRecentsView.showAsGrid()) {
                     if (mTaskBeingDragged.isFocusedTask()) {
-                        velocityDimenId = R.dimen.default_task_dismiss_drag_velocity_grid_focus_task;
+                        velocityDimenId =
+                                R.dimen.default_task_dismiss_drag_velocity_grid_focus_task;
                     } else {
                         velocityDimenId = R.dimen.default_task_dismiss_drag_velocity_grid;
                     }
@@ -351,9 +351,9 @@ public abstract class TaskViewTouchController<CONTAINER extends Context & Recent
         if (blockedFling) {
             fling = false;
         }
-        PagedOrientationHandler orientationHandler = mRecentsView.getPagedOrientationHandler();
-        boolean goingUp = orientationHandler.isGoingUp(velocity, mIsRtl) && !RecentHelper.INSTANCE
-                .isAppLocked(mTaskBeingDragged.getTask().key.getPackageName(), mActivity.getBaseContext());
+        RecentsPagedOrientationHandler orientationHandler =
+                mRecentsView.getPagedOrientationHandler();
+        boolean goingUp = orientationHandler.isGoingUp(velocity, mIsRtl);
         float progress = mCurrentAnimation.getProgressFraction();
         float interpolatedProgress = mCurrentAnimation.getInterpolatedProgress();
         if (fling) {
@@ -366,10 +366,8 @@ public abstract class TaskViewTouchController<CONTAINER extends Context & Recent
         if (blockedFling && !goingToEnd) {
             animationDuration *= LauncherAnimUtils.blockedFlingDurationFactor(velocity);
         }
-        // Due to very high or low velocity dismissals, animation durations can be
-        // inconsistently
-        // long or short. Bound the duration for animation of task translations for a
-        // more
+        // Due to very high or low velocity dismissals, animation durations can be inconsistently
+        // long or short. Bound the duration for animation of task translations for a more
         // standardized feel.
         animationDuration = Utilities.boundToRange(animationDuration,
                 MIN_TASK_DISMISS_ANIMATION_DURATION, MAX_TASK_DISMISS_ANIMATION_DURATION);
@@ -394,4 +392,4 @@ public abstract class TaskViewTouchController<CONTAINER extends Context & Recent
         mCurrentAnimation = null;
         mIsDismissHapticRunning = false;
     }
-}
+}
\ No newline at end of file
diff --git a/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java b/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java
index a55edfcd47..1e2b812a3f 100644
--- a/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java
+++ b/quickstep/src/com/android/quickstep/AbsSwipeUpHandler.java
@@ -163,21 +163,18 @@ import java.util.Optional;
 import java.util.OptionalInt;
 import java.util.function.Consumer;
 
-import app.lawnchair.compat.LawnchairQuickstepCompat;
-import app.lawnchair.util.CompatibilityKt;
-
 /**
  * Handles the navigation gestures when Launcher is the default home activity.
  */
-public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extends RecentsView, S extends BaseState<S>>
+public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer,
+        Q extends RecentsView, S extends BaseState<S>>
         extends SwipeUpAnimationLogic implements OnApplyWindowInsetsListener,
         RecentsAnimationCallbacks.RecentsAnimationListener {
     private static final String TAG = "AbsSwipeUpHandler";
 
     private static final ArrayList<String> STATE_NAMES = new ArrayList<>();
 
-    // Fraction of the scroll and transform animation in which the current task
-    // fades out
+    // Fraction of the scroll and transform animation in which the current task fades out
     private static final float KQS_TASK_FADE_ANIMATION_FRACTION = 0.4f;
 
     protected final BaseContainerInterface<S, T> mContainerInterface;
@@ -187,8 +184,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     private final ArrayList<Runnable> mRecentsAnimationStartCallbacks = new ArrayList<>();
     private final OnScrollChangedListener mOnRecentsScrollListener = this::onRecentsViewScroll;
 
-    // Null if the recents animation hasn't started yet or has been canceled or
-    // finished.
+    // Null if the recents animation hasn't started yet or has been canceled or finished.
     protected @Nullable RecentsAnimationController mRecentsAnimationController;
     protected @Nullable RecentsAnimationController mDeferredCleanupRecentsAnimationController;
     protected RecentsAnimationTargets mRecentsAnimationTargets;
@@ -207,7 +203,6 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     };
 
     private static int FLAG_COUNT = 0;
-
     private static int getNextStateFlag(String name) {
         if (DEBUG_STATES) {
             STATE_NAMES.add(name);
@@ -218,70 +213,84 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     // Launcher UI related states
-    protected static final int STATE_LAUNCHER_PRESENT = getNextStateFlag("STATE_LAUNCHER_PRESENT");
-    protected static final int STATE_LAUNCHER_STARTED = getNextStateFlag("STATE_LAUNCHER_STARTED");
-    protected static final int STATE_LAUNCHER_DRAWN = getNextStateFlag("STATE_LAUNCHER_DRAWN");
-    // Called when the Launcher has connected to the touch interaction service (and
-    // the taskbar
+    protected static final int STATE_LAUNCHER_PRESENT =
+            getNextStateFlag("STATE_LAUNCHER_PRESENT");
+    protected static final int STATE_LAUNCHER_STARTED =
+            getNextStateFlag("STATE_LAUNCHER_STARTED");
+    protected static final int STATE_LAUNCHER_DRAWN =
+            getNextStateFlag("STATE_LAUNCHER_DRAWN");
+    // Called when the Launcher has connected to the touch interaction service (and the taskbar
     // ui controller is initialized)
-    protected static final int STATE_LAUNCHER_BIND_TO_SERVICE = getNextStateFlag("STATE_LAUNCHER_BIND_TO_SERVICE");
+    protected static final int STATE_LAUNCHER_BIND_TO_SERVICE =
+            getNextStateFlag("STATE_LAUNCHER_BIND_TO_SERVICE");
 
     // Internal initialization states
-    private static final int STATE_APP_CONTROLLER_RECEIVED = getNextStateFlag("STATE_APP_CONTROLLER_RECEIVED");
+    private static final int STATE_APP_CONTROLLER_RECEIVED =
+            getNextStateFlag("STATE_APP_CONTROLLER_RECEIVED");
 
     // Interaction finish states
-    private static final int STATE_SCALED_CONTROLLER_HOME = getNextStateFlag("STATE_SCALED_CONTROLLER_HOME");
-    private static final int STATE_SCALED_CONTROLLER_RECENTS = getNextStateFlag("STATE_SCALED_CONTROLLER_RECENTS");
+    private static final int STATE_SCALED_CONTROLLER_HOME =
+            getNextStateFlag("STATE_SCALED_CONTROLLER_HOME");
+    private static final int STATE_SCALED_CONTROLLER_RECENTS =
+            getNextStateFlag("STATE_SCALED_CONTROLLER_RECENTS");
 
-    protected static final int STATE_HANDLER_INVALIDATED = getNextStateFlag("STATE_HANDLER_INVALIDATED");
-    private static final int STATE_GESTURE_STARTED = getNextStateFlag("STATE_GESTURE_STARTED");
-    private static final int STATE_GESTURE_CANCELLED = getNextStateFlag("STATE_GESTURE_CANCELLED");
-    private static final int STATE_GESTURE_COMPLETED = getNextStateFlag("STATE_GESTURE_COMPLETED");
+    protected static final int STATE_HANDLER_INVALIDATED =
+            getNextStateFlag("STATE_HANDLER_INVALIDATED");
+    private static final int STATE_GESTURE_STARTED =
+            getNextStateFlag("STATE_GESTURE_STARTED");
+    private static final int STATE_GESTURE_CANCELLED =
+            getNextStateFlag("STATE_GESTURE_CANCELLED");
+    private static final int STATE_GESTURE_COMPLETED =
+            getNextStateFlag("STATE_GESTURE_COMPLETED");
 
-    private static final int STATE_CAPTURE_SCREENSHOT = getNextStateFlag("STATE_CAPTURE_SCREENSHOT");
-    protected static final int STATE_SCREENSHOT_CAPTURED = getNextStateFlag("STATE_SCREENSHOT_CAPTURED");
-    private static final int STATE_SCREENSHOT_VIEW_SHOWN = getNextStateFlag("STATE_SCREENSHOT_VIEW_SHOWN");
+    private static final int STATE_CAPTURE_SCREENSHOT =
+            getNextStateFlag("STATE_CAPTURE_SCREENSHOT");
+    protected static final int STATE_SCREENSHOT_CAPTURED =
+            getNextStateFlag("STATE_SCREENSHOT_CAPTURED");
+    private static final int STATE_SCREENSHOT_VIEW_SHOWN =
+            getNextStateFlag("STATE_SCREENSHOT_VIEW_SHOWN");
 
-    private static final int STATE_RESUME_LAST_TASK = getNextStateFlag("STATE_RESUME_LAST_TASK");
-    private static final int STATE_START_NEW_TASK = getNextStateFlag("STATE_START_NEW_TASK");
-    private static final int STATE_CURRENT_TASK_FINISHED = getNextStateFlag("STATE_CURRENT_TASK_FINISHED");
-    private static final int STATE_FINISH_WITH_NO_END = getNextStateFlag("STATE_FINISH_WITH_NO_END");
-    private static final int STATE_SETTLED_ON_ALL_APPS = getNextStateFlag("STATE_SETTLED_ON_ALL_APPS");
+    private static final int STATE_RESUME_LAST_TASK =
+            getNextStateFlag("STATE_RESUME_LAST_TASK");
+    private static final int STATE_START_NEW_TASK =
+            getNextStateFlag("STATE_START_NEW_TASK");
+    private static final int STATE_CURRENT_TASK_FINISHED =
+            getNextStateFlag("STATE_CURRENT_TASK_FINISHED");
+    private static final int STATE_FINISH_WITH_NO_END =
+            getNextStateFlag("STATE_FINISH_WITH_NO_END");
+    private static final int STATE_SETTLED_ON_ALL_APPS =
+            getNextStateFlag("STATE_SETTLED_ON_ALL_APPS");
 
-    private static final int LAUNCHER_UI_STATES = STATE_LAUNCHER_PRESENT | STATE_LAUNCHER_DRAWN | STATE_LAUNCHER_STARTED
-            |
-            STATE_LAUNCHER_BIND_TO_SERVICE;
+    private static final int LAUNCHER_UI_STATES =
+            STATE_LAUNCHER_PRESENT | STATE_LAUNCHER_DRAWN | STATE_LAUNCHER_STARTED |
+                    STATE_LAUNCHER_BIND_TO_SERVICE;
 
     public static final long MAX_SWIPE_DURATION = 350;
 
     public static final float MIN_PROGRESS_FOR_OVERVIEW = 0.7f;
-    private static final float SWIPE_DURATION_MULTIPLIER = Math.min(1 / MIN_PROGRESS_FOR_OVERVIEW,
-            1 / (1 - MIN_PROGRESS_FOR_OVERVIEW));
+    private static final float SWIPE_DURATION_MULTIPLIER =
+            Math.min(1 / MIN_PROGRESS_FOR_OVERVIEW, 1 / (1 - MIN_PROGRESS_FOR_OVERVIEW));
     private static final String SCREENSHOT_CAPTURED_EVT = "ScreenshotCaptured";
 
     public static final long RECENTS_ATTACH_DURATION = 300;
 
     private static final float MAX_QUICK_SWITCH_RECENTS_SCALE_PROGRESS = 0.07f;
 
-    // Controls task thumbnail splash's reveal animation after landing on a task
-    // from quickswitch.
-    // These values match WindowManager/Shell starting_window_app_reveal_* config
-    // values.
+    // Controls task thumbnail splash's reveal animation after landing on a task from quickswitch.
+    // These values match WindowManager/Shell starting_window_app_reveal_* config values.
     private static final int SPLASH_FADE_OUT_DURATION = 133;
     private static final int SPLASH_APP_REVEAL_DELAY = 83;
     private static final int SPLASH_APP_REVEAL_DURATION = 266;
     private static final int SPLASH_ANIMATION_DURATION = 349;
 
     /**
-     * Used as the page index for logging when we return to the last task at the end
-     * of the gesture.
+     * Used as the page index for logging when we return to the last task at the end of the gesture.
      */
     private static final int LOG_NO_OP_PAGE_INDEX = -1;
 
     protected final TaskAnimationManager mTaskAnimationManager;
 
-    // Either RectFSpringAnim (if animating home) or ObjectAnimator (from
-    // mCurrentShift) otherwise
+    // Either RectFSpringAnim (if animating home) or ObjectAnimator (from mCurrentShift) otherwise
     private RunningWindowAnim[] mRunningWindowAnim;
     // Possible second animation running at the same time as mRunningWindowAnim
     private Animator mParallelRunningAnim;
@@ -297,8 +306,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     private AnimatorControllerWithResistance mLauncherTransitionController;
     private boolean mHasEndedLauncherTransition;
 
-    private AnimationFactory mAnimationFactory = (t) -> {
-    };
+    private AnimationFactory mAnimationFactory = (t) -> { };
 
     private boolean mWasLauncherAlreadyVisible;
 
@@ -315,15 +323,14 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     private final Runnable mOnDeferredActivityLaunch = this::onDeferredActivityLaunch;
     private final Runnable mLauncherOnStartCallback = this::onLauncherStart;
 
-    @Nullable
-    private SwipePipToHomeAnimator mSwipePipToHomeAnimator;
+    @Nullable private SwipePipToHomeAnimator mSwipePipToHomeAnimator;
     protected boolean mIsSwipingPipToHome;
     // TODO(b/195473090) no split PIP for now, remove once we have more clarity
-    // can try to have RectFSpringAnim evaluate multiple rects at once
-    private final SwipePipToHomeAnimator[] mSwipePipToHomeAnimators = new SwipePipToHomeAnimator[2];
+    //  can try to have RectFSpringAnim evaluate multiple rects at once
+    private final SwipePipToHomeAnimator[] mSwipePipToHomeAnimators =
+            new SwipePipToHomeAnimator[2];
 
-    // Interpolate RecentsView scale from start of quick switch scroll until this
-    // scroll threshold
+    // Interpolate RecentsView scale from start of quick switch scroll until this scroll threshold
     private final float mQuickSwitchScaleScrollThreshold;
 
     private final int mTaskbarAppWindowThreshold;
@@ -334,8 +341,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     private final boolean mIsTransientTaskbar;
     // May be set to false when mIsTransientTaskbar is true.
     private boolean mCanSlowSwipeGoHome = true;
-    // Indicates whether the divider is shown, only used when split screen is
-    // activated.
+    // Indicates whether the divider is shown, only used when split screen is activated.
     private boolean mIsDividerShown = true;
     private boolean mStartMovingTasks;
 
@@ -343,21 +349,23 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     private RemoteAnimationTargets.ReleaseCheck mSwipePipToHomeReleaseCheck = null;
 
     public AbsSwipeUpHandler(Context context, RecentsAnimationDeviceState deviceState,
-            TaskAnimationManager taskAnimationManager, GestureState gestureState,
-            long touchTimeMs, boolean continuingLastGesture,
-            InputConsumerController inputConsumer) {
+                             TaskAnimationManager taskAnimationManager, GestureState gestureState,
+                             long touchTimeMs, boolean continuingLastGesture,
+                             InputConsumerController inputConsumer) {
         super(context, deviceState, gestureState);
         mContainerInterface = gestureState.getContainerInterface();
-        mActivityInitListener = mContainerInterface.createActivityInitListener(this::onActivityInit);
-        mInputConsumerProxy = new InputConsumerProxy(context, /* rotationSupplier = */ () -> {
-            if (mRecentsView == null) {
-                return ROTATION_0;
-            }
-            return mRecentsView.getPagedViewOrientedState().getRecentsActivityRotation();
-        }, inputConsumer, /* onTouchDownCallback = */ () -> {
-            endRunningWindowAnim(mGestureState.getEndTarget() == HOME /* cancel */);
-            endLauncherTransitionController();
-        }, new InputProxyHandlerFactory(mContainerInterface, mGestureState));
+        mActivityInitListener =
+                mContainerInterface.createActivityInitListener(this::onActivityInit);
+        mInputConsumerProxy =
+                new InputConsumerProxy(context, /* rotationSupplier = */ () -> {
+                    if (mRecentsView == null) {
+                        return ROTATION_0;
+                    }
+                    return mRecentsView.getPagedViewOrientedState().getRecentsActivityRotation();
+                }, inputConsumer, /* onTouchDownCallback = */ () -> {
+                    endRunningWindowAnim(mGestureState.getEndTarget() == HOME /* cancel */);
+                    endLauncherTransitionController();
+                }, new InputProxyHandlerFactory(mContainerInterface, mGestureState));
         mTaskAnimationManager = taskAnimationManager;
         mTouchTimeMs = touchTimeMs;
         mContinuingLastGesture = continuingLastGesture;
@@ -378,7 +386,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         TaskbarUIController controller = mContainerInterface.getTaskbarController();
         mTaskbarAlreadyOpen = controller != null && !controller.isTaskbarStashed();
         mIsTaskbarAllAppsOpen = controller != null && controller.isTaskbarAllAppsOpen();
-        mTaskbarAppWindowThreshold = TaskbarThresholdUtils.getAppWindowThreshold(res, mDp);
+        mTaskbarAppWindowThreshold =
+                TaskbarThresholdUtils.getAppWindowThreshold(res, mDp);
         boolean swipeWillNotShowTaskbar = mTaskbarAlreadyOpen || mGestureState.isTrackpadGesture();
         mTaskbarHomeOverviewThreshold = swipeWillNotShowTaskbar
                 ? 0
@@ -420,7 +429,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 this::launcherFrameDrawn);
 
         mStateCallback.runOnceAtState(STATE_LAUNCHER_PRESENT | STATE_LAUNCHER_STARTED
-                | STATE_GESTURE_CANCELLED,
+                        | STATE_GESTURE_CANCELLED,
                 this::resetStateForAnimationCancel);
 
         mStateCallback.runOnceAtState(STATE_RESUME_LAST_TASK | STATE_APP_CONTROLLER_RECEIVED,
@@ -429,32 +438,32 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 this::startNewTask);
 
         mStateCallback.runOnceAtState(STATE_LAUNCHER_PRESENT | STATE_APP_CONTROLLER_RECEIVED
-                | STATE_LAUNCHER_DRAWN | STATE_CAPTURE_SCREENSHOT,
+                        | STATE_LAUNCHER_DRAWN | STATE_CAPTURE_SCREENSHOT,
                 this::switchToScreenshot);
 
         mStateCallback.runOnceAtState(STATE_SCREENSHOT_CAPTURED | STATE_GESTURE_COMPLETED
-                | STATE_SCALED_CONTROLLER_RECENTS,
+                        | STATE_SCALED_CONTROLLER_RECENTS,
                 this::finishCurrentTransitionToRecents);
 
         mStateCallback.runOnceAtState(STATE_SCREENSHOT_CAPTURED | STATE_GESTURE_COMPLETED
-                | STATE_SCALED_CONTROLLER_HOME,
+                        | STATE_SCALED_CONTROLLER_HOME,
                 this::finishCurrentTransitionToHome);
         mStateCallback.runOnceAtState(STATE_SCALED_CONTROLLER_HOME | STATE_CURRENT_TASK_FINISHED,
                 this::reset);
         mStateCallback.runOnceAtState(STATE_SETTLED_ON_ALL_APPS | STATE_SCREENSHOT_CAPTURED
-                | STATE_GESTURE_COMPLETED,
+                        | STATE_GESTURE_COMPLETED,
                 this::finishCurrentTransitionToAllApps);
 
         mStateCallback.runOnceAtState(STATE_LAUNCHER_PRESENT | STATE_APP_CONTROLLER_RECEIVED
-                | STATE_LAUNCHER_DRAWN | STATE_SCALED_CONTROLLER_RECENTS
-                | STATE_CURRENT_TASK_FINISHED | STATE_GESTURE_COMPLETED
-                | STATE_GESTURE_STARTED,
+                        | STATE_LAUNCHER_DRAWN | STATE_SCALED_CONTROLLER_RECENTS
+                        | STATE_CURRENT_TASK_FINISHED | STATE_GESTURE_COMPLETED
+                        | STATE_GESTURE_STARTED,
                 this::setupLauncherUiAfterSwipeUpToRecentsAnimation);
 
         mGestureState.runOnceAtState(STATE_END_TARGET_ANIMATION_FINISHED,
                 this::continueComputingRecentsScrollIfNecessary);
         mGestureState.runOnceAtState(STATE_END_TARGET_ANIMATION_FINISHED
-                | STATE_RECENTS_SCROLLING_FINISHED,
+                        | STATE_RECENTS_SCROLLING_FINISHED,
                 this::onSettledOnEndTarget);
 
         mStateCallback.runOnceAtState(STATE_HANDLER_INVALIDATED, this::invalidateHandler);
@@ -482,8 +491,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
 
         if (mContainer != null) {
             if (mStateCallback.hasStates(STATE_GESTURE_COMPLETED)) {
-                // If the activity has restarted between setting the page scroll settling
-                // callback
+                // If the activity has restarted between setting the page scroll settling callback
                 // and actually receiving the callback, just mark the gesture completed
                 mGestureState.setState(STATE_RECENTS_SCROLLING_FINISHED);
                 return true;
@@ -497,8 +505,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         }
         mWasLauncherAlreadyVisible = alreadyOnHome;
         mContainer = container;
-        // Override the visibility of the activity until the gesture actually starts and
-        // we swipe
+        // Override the visibility of the activity until the gesture actually starts and we swipe
         // up, or until we transition home and the home animation is composed
         if (alreadyOnHome) {
             mContainer.clearForceInvisibleFlag(STATE_HANDLER_INVISIBILITY_FLAGS);
@@ -516,14 +523,13 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
             container.addEventCallback(EVENT_STARTED, mLauncherOnStartCallback);
         }
 
-        // Set up a entire animation lifecycle callback to notify the current recents
-        // view when
+        // Set up a entire animation lifecycle callback to notify the current recents view when
         // the animation is canceled
         mGestureState.runOnceAtState(STATE_RECENTS_ANIMATION_CANCELED, () -> {
-            if (mRecentsView == null)
-                return;
+            if (mRecentsView == null) return;
 
-            HashMap<Integer, ThumbnailData> snapshots = mGestureState.consumeRecentsAnimationCanceledSnapshot();
+            HashMap<Integer, ThumbnailData> snapshots =
+                    mGestureState.consumeRecentsAnimationCanceledSnapshot();
             if (snapshots != null) {
                 mRecentsView.switchToScreenshot(snapshots, () -> {
                     if (mRecentsAnimationController != null) {
@@ -545,8 +551,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Return true if the window should be translated horizontally if the recents
-     * view scrolls
+     * Return true if the window should be translated horizontally if the recents view scrolls
      */
     protected boolean moveWindowWithRecentsScroll() {
         return mGestureState.getEndTarget() != HOME;
@@ -566,10 +571,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         runActionOnRemoteHandles(remoteTargetHandle -> remoteTargetHandle.getTaskViewSimulator()
                 .setOrientationState(mRecentsView.getPagedViewOrientedState()));
 
-        // If we've already ended the gesture and are going home, don't prepare recents
-        // UI,
-        // as that will set the state as BACKGROUND_APP, overriding the animation to
-        // NORMAL.
+        // If we've already ended the gesture and are going home, don't prepare recents UI,
+        // as that will set the state as BACKGROUND_APP, overriding the animation to NORMAL.
         if (mGestureState.getEndTarget() != HOME) {
             Runnable initAnimFactory = () -> {
                 mAnimationFactory = mContainerInterface.prepareRecentsUI(mDeviceState,
@@ -608,7 +611,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                     mHandled = true;
 
                     traceToken.close();
-                    dragLayer.post(() -> dragLayer.getViewTreeObserver().removeOnDrawListener(this));
+                    dragLayer.post(() ->
+                            dragLayer.getViewTreeObserver().removeOnDrawListener(this));
                     if (container != mContainer) {
                         return;
                     }
@@ -628,13 +632,11 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     private void onLauncherPresentAndGestureStarted() {
-        // Re-setup the recents UI when gesture starts, as the state could have been
-        // changed during
+        // Re-setup the recents UI when gesture starts, as the state could have been changed during
         // that time by a previous window transition.
         setupRecentsViewUi();
 
-        // For the duration of the gesture, in cases where an activity is launched while
-        // the
+        // For the duration of the gesture, in cases where an activity is launched while the
         // activity is not yet resumed, finish the animation to ensure we get resumed
         mGestureState.getContainerInterface().setOnDeferredActivityLaunchCallback(
                 mOnDeferredActivityLaunch);
@@ -674,10 +676,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
             runningTasks = cachedTaskInfo.getPlaceholderTasks();
         }
 
-        // Safeguard against any null tasks being sent to recents view, happens when
-        // quickswitching
-        // very quickly w/ split tasks because TopTaskTracker provides stale information
-        // compared to
+        // Safeguard against any null tasks being sent to recents view, happens when quickswitching
+        // very quickly w/ split tasks because TopTaskTracker provides stale information compared to
         // actual running tasks in the recents animation.
         // TODO(b/236226779), Proper fix (ag/22237143)
         if (Arrays.stream(runningTasks).anyMatch(Objects::isNull)) {
@@ -697,19 +697,14 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         buildAnimationController();
 
         try (SafeCloseable c = TraceHelper.INSTANCE.allowIpcs("logToggleRecents")) {
-            if (Utilities.ATLEAST_S) {
-                LatencyTracker.getInstance(mContext).logAction(LatencyTracker.ACTION_TOGGLE_RECENTS,
-                        (int) (mLauncherFrameDrawnTime - mTouchTimeMs));
-            }
+            LatencyTracker.getInstance(mContext).logAction(LatencyTracker.ACTION_TOGGLE_RECENTS,
+                    (int) (mLauncherFrameDrawnTime - mTouchTimeMs));
         }
 
-        // This method is only called when STATE_GESTURE_STARTED is set, so we can
-        // enable the
-        // high-res thumbnail loader here once we are sure that we will end up in an
-        // overview state
+        // This method is only called when STATE_GESTURE_STARTED is set, so we can enable the
+        // high-res thumbnail loader here once we are sure that we will end up in an overview state
         RecentsModel.INSTANCE.get(mContext).getThumbnailCache()
                 .getHighResLoadingState().setVisible(true);
-
     }
 
     public MotionPauseDetector.OnMotionPauseListener getMotionPauseListener() {
@@ -746,8 +741,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
      * RecentsView is shown, it will appear to be attached to the window.
      *
      * Note this method has no effect unless the navigation mode is NO_BUTTON.
-     *
-     * @param animate         whether to animate when attaching RecentsView
+     * @param animate whether to animate when attaching RecentsView
      * @param moveRunningTask whether to move running task to front when attaching
      */
     private void maybeUpdateRecentsAttachedState(boolean animate, boolean moveRunningTask) {
@@ -759,7 +753,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         // have their "isInRecents" field set? (that's what this is used for below)
         RemoteAnimationTarget runningTaskTarget = mRecentsAnimationTargets != null
                 ? mRecentsAnimationTargets
-                        .findTask(mGestureState.getTopRunningTaskId())
+                .findTask(mGestureState.getTopRunningTaskId())
                 : null;
         final boolean recentsAttachedToAppWindow;
         if (mIsInAllAppsRegion) {
@@ -777,15 +771,13 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         }
         if (moveRunningTask && !mAnimationFactory.hasRecentsEverAttachedToAppWindow()
                 && recentsAttachedToAppWindow) {
-            // Only move running task if RecentsView has never been attached before, to
-            // avoid
+            // Only move running task if RecentsView has never been attached before, to avoid
             // TaskView jumping to new position as we move the tasks.
             mRecentsView.moveRunningTaskToFront();
         }
         mAnimationFactory.setRecentsAttachedToAppWindow(recentsAttachedToAppWindow, animate);
 
-        // Reapply window transform throughout the attach animation, as the animation
-        // affects how
+        // Reapply window transform throughout the attach animation, as the animation affects how
         // much the window is bound by overscroll (vs moving freely).
         if (animate) {
             ValueAnimator reapplyWindowTransformAnim = ValueAnimator.ofFloat(0, 1);
@@ -803,8 +795,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Returns threshold that needs to be met in order for motion pause to be
-     * allowed.
+     * Returns threshold that needs to be met in order for motion pause to be allowed.
      */
     public float getThresholdToAllowMotionPause() {
         return mIsTransientTaskbar
@@ -824,8 +815,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Update whether user is currently dragging in a region that will trigger all
-     * apps.
+     * Update whether user is currently dragging in a region that will trigger all apps.
      */
     private void setIsInAllAppsRegion(boolean isInAllAppsRegion) {
         if (mIsInAllAppsRegion == isInAllAppsRegion
@@ -844,10 +834,11 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         }
 
         // Draw active task below Launcher so that All Apps can appear over it.
-        runActionOnRemoteHandles(remoteTargetHandle -> remoteTargetHandle.getTaskViewSimulator()
-                .setDrawsBelowRecents(isInAllAppsRegion));
+        runActionOnRemoteHandles(remoteTargetHandle ->
+                remoteTargetHandle.getTaskViewSimulator().setDrawsBelowRecents(isInAllAppsRegion));
     }
 
+
     private void buildAnimationController() {
         if (!canCreateNewOrUpdateExistingLauncherTransitionController()) {
             return;
@@ -857,10 +848,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * We don't want to change mLauncherTransitionController if
-     * mGestureState.getEndTarget() == HOME
+     * We don't want to change mLauncherTransitionController if mGestureState.getEndTarget() == HOME
      * (it has its own animation) or if we explicitly ended the controller already.
-     *
      * @return Whether we can create the launcher controller or update its progress.
      */
     private boolean canCreateNewOrUpdateExistingLauncherTransitionController() {
@@ -871,18 +860,15 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     @Override
     public WindowInsets onApplyWindowInsets(View view, WindowInsets windowInsets) {
         WindowInsets result = view.onApplyWindowInsets(windowInsets);
-        // Don't rebuild animation when we are animating the IME, because it will cause
-        // a loop
-        // where the insets change -> animation changes (updating ime) -> insets change
-        // -> ...
+        // Don't rebuild animation when we are animating the IME, because it will cause a loop
+        // where the insets change -> animation changes (updating ime) -> insets change -> ...
         if (windowInsets.isVisible(WindowInsets.Type.ime())) {
             return result;
         }
         if (mGestureState.getEndTarget() == null) {
             buildAnimationController();
         }
-        // Reapply the current shift to ensure it takes new insets into account, e.g.
-        // when long
+        // Reapply the current shift to ensure it takes new insets into account, e.g. when long
         // pressing to stash taskbar without moving the finger.
         onCurrentShiftUpdated();
         return result;
@@ -893,10 +879,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         mLauncherTransitionController = anim;
         if (isFirstCreation) {
             mStateCallback.runOnceAtState(STATE_GESTURE_STARTED, () -> {
-                // Wait until the gesture is started (touch slop was passed) to start in sync
-                // with
-                // mWindowTransitionController. This ensures we don't hide the taskbar
-                // background
+                // Wait until the gesture is started (touch slop was passed) to start in sync with
+                // mWindowTransitionController. This ensures we don't hide the taskbar background
                 // when long pressing to stash it, for instance.
                 mLauncherTransitionController.getNormalController().dispatchOnStart();
                 updateLauncherTransitionProgress();
@@ -930,8 +914,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         mLauncherTransitionController.setProgress(
                 // Immediately finish the grid transition
                 isKeyboardTaskFocusPending()
-                        ? 1f
-                        : Math.max(mCurrentShift.value, getScaleProgressDueToScroll()),
+                        ? 1f : Math.max(mCurrentShift.value, getScaleProgressDueToScroll()),
                 mDragLengthFactor);
     }
 
@@ -949,15 +932,13 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
 
             // We will handle the sysui flags based on the centermost task view.
             mRecentsAnimationController.setUseLauncherSystemBarFlags(swipeUpThresholdPassed
-                    || (quickswitchThresholdPassed && centermostTaskFlags != 0));
+                    ||  (quickswitchThresholdPassed && centermostTaskFlags != 0));
             mRecentsAnimationController.setSplitScreenMinimized(mContext, swipeUpThresholdPassed);
-            // Provide a hint to WM the direction that we will be settling in case the
-            // animation
+            // Provide a hint to WM the direction that we will be settling in case the animation
             // needs to be canceled
             mRecentsAnimationController.setWillFinishToHome(swipeUpThresholdPassed);
 
-            if (mContainer == null)
-                return;
+            if (mContainer == null) return;
             if (swipeUpThresholdPassed) {
                 mContainer.getSystemUiController().updateUiState(UI_STATE_FULLSCREEN_TASK, 0);
             } else {
@@ -969,7 +950,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
 
     @Override
     public void onRecentsAnimationStart(RecentsAnimationController controller,
-            RecentsAnimationTargets targets) {
+                                        RecentsAnimationTargets targets) {
         super.onRecentsAnimationStart(controller, targets);
         if (targets.hasDesktopTasks()) {
             mRemoteTargetHandles = mTargetGluer.assignTargetsForDesktop(targets);
@@ -987,15 +968,12 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         mSwipePipToHomeReleaseCheck.setCanRelease(true);
         mRecentsAnimationTargets.addReleaseCheck(mSwipePipToHomeReleaseCheck);
 
-        // Only initialize the device profile, if it has not been initialized before, as
-        // in some
+        // Only initialize the device profile, if it has not been initialized before, as in some
         // configurations targets.homeContentInsets may not be correct.
         if (mContainer == null) {
             RemoteAnimationTarget primaryTaskTarget = targets.apps[0];
-            // orientation state is independent of which remote target handle we use since
-            // both
-            // should be pointing to the same one. Just choose index 0 for now since that
-            // works for
+            // orientation state is independent of which remote target handle we use since both
+            // should be pointing to the same one. Just choose index 0 for now since that works for
             // both split and non-split
             RecentsOrientedState orientationState = mRemoteTargetHandles[0].getTaskViewSimulator()
                     .getOrientationState();
@@ -1006,8 +984,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 dp = dp.getMultiWindowProfile(mContext,
                         new WindowBounds(overviewStackBounds, targets.homeContentInsets));
             } else {
-                // If we are not in multi-window mode, home insets should be same as system
-                // insets.
+                // If we are not in multi-window mode, home insets should be same as system insets.
                 dp = dp.copy(mContext);
             }
             dp.updateInsets(targets.homeContentInsets);
@@ -1019,8 +996,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         // Notify when the animation starts
         flushOnRecentsAnimationAndLauncherBound();
 
-        // Only add the callback to enable the input consumer after we actually have the
-        // controller
+        // Only add the callback to enable the input consumer after we actually have the controller
         mStateCallback.runOnceAtState(STATE_APP_CONTROLLER_RECEIVED | STATE_GESTURE_STARTED,
                 this::startInterceptingTouchesForGesture);
         mStateCallback.setStateOnUiThread(STATE_APP_CONTROLLER_RECEIVED);
@@ -1032,13 +1008,11 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 /* event= */ "cancelRecentsAnimation",
                 /* gestureEvent= */ CANCEL_RECENTS_ANIMATION);
         mActivityInitListener.unregister("AbsSwipeUpHandler.onRecentsAnimationCanceled");
-        // Cache the recents animation controller so we can defer its cleanup to after
-        // having
+        // Cache the recents animation controller so we can defer its cleanup to after having
         // properly cleaned up the screenshot without accidentally using it.
         mDeferredCleanupRecentsAnimationController = mRecentsAnimationController;
         mStateCallback.setStateOnUiThread(STATE_GESTURE_CANCELLED | STATE_HANDLER_INVALIDATED);
-        // Defer clearing the controller and the targets until after we've updated the
-        // state
+        // Defer clearing the controller and the targets until after we've updated the state
         mRecentsAnimationController = null;
         mRecentsAnimationTargets = null;
         if (mRecentsView != null) {
@@ -1087,9 +1061,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     /**
      * Sets whether or not we should clamp the scroll offset.
      * This is used to avoid x-axis movement when swiping up transient taskbar.
-     *
-     * @param clampScrollOffset When true, we clamp the scroll to 0 before the clamp
-     *                          threshold is
+     * @param clampScrollOffset When true, we clamp the scroll to 0 before the clamp threshold is
      *                          met.
      */
     private void setClampScrollOffset(boolean clampScrollOffset) {
@@ -1104,16 +1076,15 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         mRecentsView.setClampScrollOffset(clampScrollOffset);
     }
 
+
     /**
-     * Notifies the launcher that the swipe gesture has started. This can be called
-     * multiple times.
+     * Notifies the launcher that the swipe gesture has started. This can be called multiple times.
      */
     @UiThread
     private void notifyGestureStarted() {
         final T curActivity = mContainer;
         if (curActivity != null) {
-            // Once the gesture starts, we can no longer transition home through the button,
-            // so
+            // Once the gesture starts, we can no longer transition home through the button, so
             // reset the force override of the activity visibility
             mContainer.clearForceInvisibleFlag(STATE_HANDLER_INVISIBILITY_FLAGS);
         }
@@ -1130,11 +1101,9 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * @param endVelocityPxPerMs The velocity in the direction of the nav bar to the
-     *                           middle of the
+     * @param endVelocityPxPerMs The velocity in the direction of the nav bar to the middle of the
      *                           screen.
-     * @param velocityPxPerMs    The x and y components of the velocity when the
-     *                           gesture ends.
+     * @param velocityPxPerMs The x and y components of the velocity when the gesture ends.
      */
     @UiThread
     public void onGestureEnded(float endVelocityPxPerMs, PointF velocityPxPerMs) {
@@ -1175,8 +1144,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
             }
         }
         if (mParallelRunningAnim != null) {
-            // Unlike the above animation, the parallel animation won't have anything to
-            // take up
+            // Unlike the above animation, the parallel animation won't have anything to take up
             // the work if it's canceled, so just end it instead.
             mParallelRunningAnim.end();
         }
@@ -1236,10 +1204,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 /* gestureEvent= */ ON_SETTLED_ON_END_TARGET);
     }
 
-    /**
-     * @return Whether this was the task we were waiting to appear, and thus handled
-     *         it.
-     */
+    /** @return Whether this was the task we were waiting to appear, and thus handled it. */
     protected boolean handleTaskAppeared(RemoteAnimationTarget[] appearedTaskTarget) {
         if (mStateCallback.hasStates(STATE_HANDLER_INVALIDATED)) {
             return false;
@@ -1260,9 +1225,10 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     private GestureEndTarget calculateEndTarget(
             PointF velocityPxPerMs, float endVelocityPxPerMs, boolean isFlingY, boolean isCancel) {
 
-        ActiveGestureErrorDetector.GestureEvent gestureEvent = velocityPxPerMs.x == 0 && velocityPxPerMs.y == 0
-                ? INVALID_VELOCITY_ON_SWIPE_UP
-                : null;
+        ActiveGestureErrorDetector.GestureEvent gestureEvent =
+                velocityPxPerMs.x == 0 && velocityPxPerMs.y == 0
+                        ? INVALID_VELOCITY_ON_SWIPE_UP
+                        : null;
         ActiveGestureLog.INSTANCE.addLog(
                 new ActiveGestureLog.CompoundString("calculateEndTarget: velocities=(x=")
                         .append(dpiFromPx(velocityPxPerMs.x))
@@ -1270,8 +1236,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                         .append(dpiFromPx(velocityPxPerMs.y))
                         .append("dp/ms), angle=")
                         .append(Math.toDegrees(Math.atan2(
-                                -velocityPxPerMs.y, velocityPxPerMs.x))),
-                gestureEvent);
+                                -velocityPxPerMs.y, velocityPxPerMs.x))), gestureEvent);
 
         if (mGestureState.isHandlingAtomicEvent()) {
             // Button mode, this is only used to go to recents.
@@ -1292,15 +1257,13 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         }
 
         TaskView nextPageTaskView = mRecentsView != null
-                ? mRecentsView.getNextPageTaskView()
-                : null;
+                ? mRecentsView.getNextPageTaskView() : null;
         TaskView currentPageTaskView = mRecentsView != null
-                ? mRecentsView.getCurrentPageTaskView()
-                : null;
+                ? mRecentsView.getCurrentPageTaskView() : null;
 
         if (Flags.enableDesktopWindowingMode()
                 && !(Flags.enableDesktopWindowingWallpaperActivity()
-                        && Flags.enableDesktopWindowingQuickSwitch())) {
+                && Flags.enableDesktopWindowingQuickSwitch())) {
             if ((nextPageTaskView instanceof DesktopTaskView
                     || currentPageTaskView instanceof DesktopTaskView)
                     && endTarget == NEW_TASK) {
@@ -1312,7 +1275,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
 
     private GestureEndTarget calculateEndTargetForFlingY(PointF velocity, float endVelocity) {
         // If swiping at a diagonal, base end target on the faster velocity direction.
-        final boolean willGoToNewTask = isScrollingToNewTask() && Math.abs(velocity.x) > Math.abs(endVelocity);
+        final boolean willGoToNewTask =
+                isScrollingToNewTask() && Math.abs(velocity.x) > Math.abs(endVelocity);
         final boolean isSwipeUp = endVelocity < 0;
         if (mIsInAllAppsRegion) {
             return isSwipeUp ? ALL_APPS : LAST_TASK;
@@ -1351,8 +1315,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
             return false;
         }
         if (!hasTargets()) {
-            // If there are no running tasks, then we can assume that this is a continuation
-            // of
+            // If there are no running tasks, then we can assume that this is a continuation of
             // the last gesture, but after the recents animation has finished.
             return true;
         }
@@ -1361,14 +1324,12 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Sets whether a slow swipe can go to the HOME end target when the user lets
-     * go. A slow swipe
+     * Sets whether a slow swipe can go to the HOME end target when the user lets go. A slow swipe
      * for this purpose must meet two criteria:
-     * 1) y-velocity is less than quickstep_fling_threshold_speed
-     * AND
-     * 2) motion pause has not been detected (possibly because
-     * {@link MotionPauseDetector#setDisallowPause} has been called with
-     * disallowPause == true)
+     *   1) y-velocity is less than quickstep_fling_threshold_speed
+     *   AND
+     *   2) motion pause has not been detected (possibly because
+     *   {@link MotionPauseDetector#setDisallowPause} has been called with disallowPause == true)
      */
     public void setCanSlowSwipeGoHome(boolean canSlowSwipeGoHome) {
         mCanSlowSwipeGoHome = canSlowSwipeGoHome;
@@ -1466,8 +1427,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
             mRecentsView.snapToPage(mRecentsView.getRunningTaskIndex(), Math.toIntExact(duration));
         }
 
-        // Let RecentsView handle the scrolling to the task, which we launch in
-        // startNewTask()
+        // Let RecentsView handle the scrolling to the task, which we launch in startNewTask()
         // or resumeLastTask().
         Runnable onPageTransitionEnd = () -> {
             mGestureState.setState(STATE_RECENTS_SCROLLING_FINISHED);
@@ -1476,11 +1436,11 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
 
         if (Flags.enableDesktopWindowingMode()
                 && !(Flags.enableDesktopWindowingWallpaperActivity()
-                        && Flags.enableDesktopWindowingQuickSwitch())) {
+                && Flags.enableDesktopWindowingQuickSwitch())) {
             if (mRecentsView != null && (mRecentsView.getCurrentPageTaskView() != null
                     && !(mRecentsView.getCurrentPageTaskView() instanceof DesktopTaskView))) {
-                ActiveGestureLog.INSTANCE
-                        .trackEvent(ActiveGestureErrorDetector.GestureEvent.SET_ON_PAGE_TRANSITION_END_CALLBACK);
+                ActiveGestureLog.INSTANCE.trackEvent(ActiveGestureErrorDetector.GestureEvent
+                        .SET_ON_PAGE_TRANSITION_END_CALLBACK);
                 mRecentsView.setOnPageTransitionEndCallback(onPageTransitionEnd);
             } else {
                 onPageTransitionEnd.run();
@@ -1488,7 +1448,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         } else {
             if (mRecentsView != null) {
                 ActiveGestureLog.INSTANCE.trackEvent(
-                        ActiveGestureErrorDetector.GestureEvent.SET_ON_PAGE_TRANSITION_END_CALLBACK);
+                        ActiveGestureErrorDetector
+                                .GestureEvent.SET_ON_PAGE_TRANSITION_END_CALLBACK);
                 mRecentsView.setOnPageTransitionEndCallback(onPageTransitionEnd);
             } else {
                 onPageTransitionEnd.run();
@@ -1521,7 +1482,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 event = IGNORE;
         }
         StatsLogger logger = StatsLogManager.newInstance(
-                mContainer != null ? mContainer.asContext() : mContext).logger()
+                        mContainer != null ? mContainer.asContext() : mContext).logger()
                 .withSrcState(LAUNCHER_STATE_BACKGROUND)
                 .withDstState(endTarget.containerType)
                 .withInputType(mGestureState.isTrackpadGesture()
@@ -1538,12 +1499,10 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         logger.log(event);
     }
 
-    /**
-     * Animates to the given progress, where 0 is the current app and 1 is overview.
-     */
+    /** Animates to the given progress, where 0 is the current app and 1 is overview. */
     @UiThread
     private void animateToProgress(float start, float end, long duration, Interpolator interpolator,
-            GestureEndTarget target, PointF velocityPxPerMs) {
+                                   GestureEndTarget target, PointF velocityPxPerMs) {
         runOnRecentsAnimationAndLauncherBound(() -> animateToProgressInternal(start, end, duration,
                 interpolator, target, velocityPxPerMs));
     }
@@ -1558,19 +1517,19 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
 
     private final TaskStackChangeListener mActivityRestartListener = new TaskStackChangeListener() {
         @Override
-        public void onActivityRestartAttempt(ActivityManager.RunningTaskInfo task, boolean homeTaskVisible,
-                boolean clearedTask, boolean wasVisible) {
-            boolean taskRunningAndNotHome = Arrays.stream(mGestureState.getRunningTaskIds(true /*
-                                                                                                * getMultipleTasks
-                                                                                                */))
+        public void onActivityRestartAttempt(ActivityManager.RunningTaskInfo task,
+                                             boolean homeTaskVisible, boolean clearedTask, boolean wasVisible) {
+            boolean taskRunningAndNotHome = Arrays.stream(mGestureState
+                            .getRunningTaskIds(true /*getMultipleTasks*/))
                     .anyMatch(taskId -> task.taskId == taskId
-                            && task.configuration.windowConfiguration.getActivityType() != ACTIVITY_TYPE_HOME);
+                            && task.configuration.windowConfiguration.getActivityType()
+                            != ACTIVITY_TYPE_HOME);
             if (taskRunningAndNotHome) {
                 // Since this is an edge case, just cancel and relaunch with default activity
-                // options (since we don't know if there's an associated app icon to launch
-                // from)
+                // options (since we don't know if there's an associated app icon to launch from)
                 endRunningWindowAnim(true /* cancel */);
-                TaskStackChangeListeners.getInstance().unregisterTaskStackListener(mActivityRestartListener);
+                TaskStackChangeListeners.getInstance().unregisterTaskStackListener(
+                        mActivityRestartListener);
                 ActivityManagerWrapper.getInstance().startActivityFromRecents(task.taskId, null);
             }
         }
@@ -1578,15 +1537,13 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
 
     @UiThread
     private void animateToProgressInternal(float start, float end, long duration,
-            Interpolator interpolator, GestureEndTarget target, PointF velocityPxPerMs) {
+                                           Interpolator interpolator, GestureEndTarget target, PointF velocityPxPerMs) {
         maybeUpdateRecentsAttachedState();
 
-        // If we are transitioning to launcher, then listen for the activity to be
-        // restarted while
+        // If we are transitioning to launcher, then listen for the activity to be restarted while
         // the transition is in progress
         if (mGestureState.getEndTarget().isLauncher) {
-            // This is also called when the launcher is resumed, in order to clear the
-            // pending
+            // This is also called when the launcher is resumed, in order to clear the pending
             // widgets that have yet to be configured.
             if (mContainer != null) {
                 DragView.removeAllViews(mContainer);
@@ -1612,25 +1569,21 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         if (mGestureState.getEndTarget() == HOME) {
             getOrientationHandler().adjustFloatingIconStartVelocity(velocityPxPerMs);
             // Take first task ID, if there are multiple we don't have any special home
-            // animation so doesn't matter for splitscreen.. though the "allowEnterPip"
-            // might change
+            // animation so doesn't matter for splitscreen.. though the "allowEnterPip" might change
             // depending on which task it is..
             final RemoteAnimationTarget runningTaskTarget = mRecentsAnimationTargets != null
                     ? mRecentsAnimationTargets
-                            .findTask(mGestureState.getTopRunningTaskId())
+                    .findTask(mGestureState.getTopRunningTaskId())
                     : null;
-            var taskInfo = mGestureState.getRunningTask().mAllCachedTasks.get(0);
-            final ArrayList<IBinder> cookies = Utilities.ATLEAST_S && runningTaskTarget != null
-                    && taskInfo != null
-                            ? taskInfo.launchCookies
-                            : new ArrayList<>();
+            final ArrayList<IBinder> cookies = runningTaskTarget != null
+                    ? runningTaskTarget.taskInfo.launchCookies
+                    : new ArrayList<>();
             boolean isTranslucent = runningTaskTarget != null && runningTaskTarget.isTranslucent;
             boolean hasValidLeash = runningTaskTarget != null
                     && runningTaskTarget.leash != null
                     && runningTaskTarget.leash.isValid();
             boolean appCanEnterPip = !mDeviceState.isPipActive()
                     && hasValidLeash
-                    && Utilities.ATLEAST_T
                     && runningTaskTarget.allowEnterPip
                     && runningTaskTarget.taskInfo.pictureInPictureParams != null
                     && runningTaskTarget.taskInfo.pictureInPictureParams.isAutoEnterEnabled();
@@ -1643,8 +1596,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                     !enableAdditionalHomeAnimations()
                             || mRecentsView == null
                             || mRecentsView.getCurrentPage() == mRecentsView.getRunningTaskIndex()
-                                    ? null
-                                    : mRecentsView.getCurrentPageTaskView());
+                            ? null : mRecentsView.getCurrentPageTaskView());
             SwipePipToHomeAnimator swipePipToHomeAnimator = !mIsSwipeForSplit && appCanEnterPip
                     ? createWindowAnimationToPip(homeAnimFactory, runningTaskTarget, start)
                     : null;
@@ -1657,8 +1609,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                     mSwipePipToHomeReleaseCheck.setCanRelease(false);
                 }
 
-                // grab a screenshot before the PipContentOverlay gets parented on top of the
-                // task
+                // grab a screenshot before the PipContentOverlay gets parented on top of the task
                 UI_HELPER_EXECUTOR.execute(() -> {
                     if (mRecentsAnimationController == null) {
                         return;
@@ -1669,9 +1620,6 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                             mRecentsAnimationController.screenshotTask(taskId));
                 });
 
-                if (mSwipePipToHomeAnimator == null)
-                    return;
-
                 // let SystemUi reparent the overlay leash as soon as possible
                 SystemUiProxy.INSTANCE.get(mContext).stopSwipePipToHome(
                         mSwipePipToHomeAnimator.getTaskId(),
@@ -1691,7 +1639,6 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 windowAnim = createWindowAnimationToHome(start, homeAnimFactory);
 
                 windowAnim[0].addAnimatorListener(new AnimationSuccessListener() {
-
                     @Override
                     public void onAnimationSuccess(Animator animator) {
                         if (mRecentsAnimationController == null) {
@@ -1769,35 +1716,30 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
             }
             animatorSet.setDuration(duration).setInterpolator(interpolator);
             animatorSet.start();
-            mRunningWindowAnim = new RunningWindowAnim[] { RunningWindowAnim.wrap(animatorSet) };
+            mRunningWindowAnim = new RunningWindowAnim[]{RunningWindowAnim.wrap(animatorSet)};
         }
     }
 
     private int calculateWindowRotation(RemoteAnimationTarget runningTaskTarget,
-            RecentsOrientedState orientationState) {
-        try {
-            if (runningTaskTarget.rotationChange != 0
-                    && TaskAnimationManager.ENABLE_SHELL_TRANSITIONS) {
-                return Math.abs(runningTaskTarget.rotationChange) == ROTATION_90
-                        ? ROTATION_270
-                        : ROTATION_90;
-            } else {
-                return orientationState.getDisplayRotation();
-            }
-        } catch (NoSuchFieldError ignored) {
+                                        RecentsOrientedState orientationState) {
+        if (runningTaskTarget.rotationChange != 0
+                && TaskAnimationManager.ENABLE_SHELL_TRANSITIONS) {
+            return Math.abs(runningTaskTarget.rotationChange) == ROTATION_90
+                    ? ROTATION_270 : ROTATION_90;
+        } else {
             return orientationState.getDisplayRotation();
         }
     }
 
     @Nullable
     private SwipePipToHomeAnimator createWindowAnimationToPip(HomeAnimationFactory homeAnimFactory,
-            RemoteAnimationTarget runningTaskTarget, float startProgress) {
+                                                              RemoteAnimationTarget runningTaskTarget, float startProgress) {
         if (mRecentsView == null) {
             // Overview was destroyed, bail early.
             return null;
         }
         // Directly animate the app to PiP (picture-in-picture) mode
-        final ActivityManager.RunningTaskInfo taskInfo = mGestureState.getRunningTask().mAllCachedTasks.get(0);
+        final ActivityManager.RunningTaskInfo taskInfo = runningTaskTarget.taskInfo;
         final RecentsOrientedState orientationState = mRemoteTargetHandles[0].getTaskViewSimulator()
                 .getOrientationState();
         final int windowRotation = calculateWindowRotation(runningTaskTarget, orientationState);
@@ -1813,14 +1755,11 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         windowToHomePositionMap.mapRect(startRect);
 
         final Rect hotseatKeepClearArea = getKeepClearAreaForHotseat();
-        if (taskInfo == null)
-            return null;
         final Rect destinationBounds = SystemUiProxy.INSTANCE.get(mContext)
                 .startSwipePipToHome(taskInfo.topActivity,
                         taskInfo.topActivityInfo,
-                        taskInfo.pictureInPictureParams,
+                        runningTaskTarget.taskInfo.pictureInPictureParams,
                         homeRotation,
-                        mDp.hotseatBarSizePx,
                         hotseatKeepClearArea);
         if (destinationBounds == null) {
             // No destination bounds returned from SystemUI, bail early.
@@ -1829,8 +1768,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         final Rect appBounds = new Rect();
         final WindowConfiguration winConfig = taskInfo.configuration.windowConfiguration;
         // Adjust the appBounds for TaskBar by using the calculated window crop Rect
-        // from TaskViewSimulator and fallback to the bounds in TaskInfo when it's
-        // originated
+        // from TaskViewSimulator and fallback to the bounds in TaskInfo when it's originated
         // from windowing modes other than full-screen.
         if (winConfig.getWindowingMode() == WindowConfiguration.WINDOWING_MODE_FULLSCREEN) {
             mRemoteTargetHandles[0].getTaskViewSimulator().getCurrentCropRect().round(appBounds);
@@ -1844,7 +1782,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 .setAppIconSizePx(mDp.iconSizePx)
                 .setLeash(runningTaskTarget.leash)
                 .setSourceRectHint(
-                        taskInfo.pictureInPictureParams.getSourceRectHint())
+                        runningTaskTarget.taskInfo.pictureInPictureParams.getSourceRectHint())
                 .setAppBounds(appBounds)
                 .setHomeToWindowPositionMap(homeToWindowPositionMap)
                 .setStartBounds(startRect)
@@ -1852,32 +1790,28 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 .setCornerRadius(mRecentsView.getPipCornerRadius())
                 .setShadowRadius(mRecentsView.getPipShadowRadius())
                 .setAttachedView(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).
+        // 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
                 && (windowRotation == ROTATION_90 || windowRotation == ROTATION_270)) {
             builder.setFromRotation(mRemoteTargetHandles[0].getTaskViewSimulator(), windowRotation,
                     taskInfo.displayCutoutInsets);
         }
         final SwipePipToHomeAnimator swipePipToHomeAnimator = builder.build();
-        AnimatorPlaybackController activityAnimationToHome = homeAnimFactory.createActivityAnimationToHome();
+        AnimatorPlaybackController activityAnimationToHome =
+                homeAnimFactory.createActivityAnimationToHome();
         swipePipToHomeAnimator.addAnimatorListener(new AnimatorListenerAdapter() {
             private boolean mHasAnimationEnded;
-
             @Override
             public void onAnimationStart(Animator animation) {
-                if (mHasAnimationEnded)
-                    return;
+                if (mHasAnimationEnded) return;
                 // Ensure Launcher ends in NORMAL state
                 activityAnimationToHome.dispatchOnStart();
             }
 
             @Override
             public void onAnimationEnd(Animator animation) {
-                if (mHasAnimationEnded)
-                    return;
+                if (mHasAnimationEnded) return;
                 mHasAnimationEnded = true;
                 activityAnimationToHome.getAnimationPlayer().end();
                 if (mRecentsAnimationController == null) {
@@ -1890,7 +1824,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 mGestureState.setState(STATE_END_TARGET_ANIMATION_FINISHED);
             }
         });
-        setupWindowAnimation(new RectFSpringAnim[] { swipePipToHomeAnimator });
+        setupWindowAnimation(new RectFSpringAnim[]{swipePipToHomeAnimator});
         return swipePipToHomeAnimator;
     }
 
@@ -1919,9 +1853,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Notifies to start intercepting touches in the app window and hide the divider
-     * bar if needed.
-     * 
+     * Notifies to start intercepting touches in the app window and hide the divider bar if needed.
      * @see RecentsAnimationController#enableInputConsumer()
      */
     private void startInterceptingTouchesForGesture() {
@@ -1954,17 +1886,15 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Creates an animation that transforms the current app window into the home
-     * app.
-     *
-     * @param startProgress        The progress of {@link #mCurrentShift} to start
-     *                             the window from.
+     * Creates an animation that transforms the current app window into the home app.
+     * @param startProgress The progress of {@link #mCurrentShift} to start the window from.
      * @param homeAnimationFactory The home animation factory.
      */
     @Override
     protected RectFSpringAnim[] createWindowAnimationToHome(float startProgress,
-            HomeAnimationFactory homeAnimationFactory) {
-        RectFSpringAnim[] anim = super.createWindowAnimationToHome(startProgress, homeAnimationFactory);
+                                                            HomeAnimationFactory homeAnimationFactory) {
+        RectFSpringAnim[] anim =
+                super.createWindowAnimationToHome(startProgress, homeAnimationFactory);
         setupWindowAnimation(anim);
         return anim;
     }
@@ -1990,8 +1920,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     public void onConsumerAboutToBeSwitched() {
-        // In the off chance that the gesture ends before Launcher is started, we should
-        // clear
+        // In the off chance that the gesture ends before Launcher is started, we should clear
         // the callback here so that it doesn't update with the wrong state
         resetLauncherListeners();
         if (mGestureState.isRecentsAnimationRunning() && mGestureState.getEndTarget() != null
@@ -2020,17 +1949,6 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     @UiThread
     private void startNewTask() {
         TaskView taskToLaunch = mRecentsView == null ? null : mRecentsView.getNextPageTaskView();
-        if (CompatibilityKt.isOnePlusStock()) {
-            reset();
-            if (mRecentsAnimationController != null) {
-                mRecentsAnimationController.finish(true, () -> startNewTaskInternal(taskToLaunch));
-            }
-        } else {
-            startNewTaskInternal(taskToLaunch);
-        }
-    }
-
-    private void startNewTaskInternal(TaskView taskToLaunch) {
         startNewTask(success -> {
             if (!success) {
                 reset();
@@ -2044,18 +1962,14 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Called when we successfully startNewTask() on the task that was previously
-     * running. Normally
-     * we call resumeLastTask() when returning to the previously running task, but
-     * this handles a
-     * specific edge case: if we switch from A to B, and back to A before B appears,
-     * we need to
+     * Called when we successfully startNewTask() on the task that was previously running. Normally
+     * we call resumeLastTask() when returning to the previously running task, but this handles a
+     * specific edge case: if we switch from A to B, and back to A before B appears, we need to
      * start A again to ensure it stays on top.
      */
     @androidx.annotation.CallSuper
     protected void onRestartPreviouslyAppearedTask() {
-        // Finish the controller here, since we won't get onTaskAppeared() for a task
-        // that already
+        // Finish the controller here, since we won't get onTaskAppeared() for a task that already
         // appeared.
         if (mRecentsAnimationController != null) {
             mRecentsAnimationController.finish(false, null);
@@ -2077,8 +1991,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Cancels any running animation so that the active target can be overriden by a
-     * new swipe
+     * Cancels any running animation so that the active target can be overriden by a new swipe
      * handler (in case of quick switch).
      */
     private void cancelCurrentAnimation() {
@@ -2140,10 +2053,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Unlike invalidateHandlerWithLauncher, this is called even when switching
-     * consumers, e.g. on
-     * continued quick switch gesture, which cancels the previous handler but
-     * doesn't invalidate it.
+     * Unlike invalidateHandlerWithLauncher, this is called even when switching consumers, e.g. on
+     * continued quick switch gesture, which cancels the previous handler but doesn't invalidate it.
      */
     private void resetLauncherListeners() {
         if (mContainer != null) {
@@ -2161,8 +2072,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         boolean wasVisible = mWasLauncherAlreadyVisible || mGestureStarted;
         mContainerInterface.onTransitionCancelled(wasVisible, mGestureState.getEndTarget());
 
-        // Leave the pending invisible flag, as it may be used by wallpaper open
-        // animation.
+        // Leave the pending invisible flag, as it may be used by wallpaper open animation.
         if (mContainer != null) {
             mContainer.clearForceInvisibleFlag(INVISIBLE_BY_STATE_HANDLER);
         }
@@ -2188,9 +2098,9 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 // Update the screenshot of the task
                 if (shouldUpdate) {
                     UI_HELPER_EXECUTOR.execute(() -> {
-                        RecentsAnimationController recentsAnimationController = mRecentsAnimationController;
-                        if (recentsAnimationController == null)
-                            return;
+                        RecentsAnimationController recentsAnimationController =
+                                mRecentsAnimationController;
+                        if (recentsAnimationController == null) return;
                         for (int id : runningTaskIds) {
                             mTaskSnapshotCache.put(
                                     id, recentsAnimationController.screenshotTask(id));
@@ -2220,10 +2130,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 || mGestureState.getEndTarget() == NEW_TASK
                 || mGestureState.getEndTarget() == ALL_APPS
                 || mRecentsView == null) {
-            // Capture the screenshot before finishing the transition to home or
-            // quickswitching to
-            // ensure it's taken in the correct orientation, but no need to update the
-            // thumbnail.
+            // Capture the screenshot before finishing the transition to home or quickswitching to
+            // ensure it's taken in the correct orientation, but no need to update the thumbnail.
             return false;
         }
 
@@ -2256,8 +2164,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
 
     private void finishCurrentTransitionToHome() {
         if (!hasTargets() || mRecentsAnimationController == null) {
-            // If there are no targets or the animation not started, then there is nothing
-            // to finish
+            // If there are no targets or the animation not started, then there is nothing to finish
             mStateCallback.setStateOnUiThread(STATE_CURRENT_TASK_FINISHED);
             maybeAbortSwipePipToHome();
         } else {
@@ -2273,8 +2180,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Notifies SysUI that transition is aborted if applicable and also pass leash
-     * transactions
+     * Notifies SysUI that transition is aborted if applicable and also pass leash transactions
      * from Launcher to WM.
      */
     private void maybeAbortSwipePipToHome() {
@@ -2287,8 +2193,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Notifies SysUI that transition is finished if applicable and also pass leash
-     * transactions
+     * Notifies SysUI that transition is finished if applicable and also pass leash transactions
      * from Launcher to WM.
      * This should happen before {@link #finishRecentsControllerToHome(Runnable)}.
      */
@@ -2303,24 +2208,16 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                     mSwipePipToHomeAnimator.getContentOverlay());
             mIsSwipingPipToHome = false;
         } else if (mIsSwipeForSplit) {
-            // Transaction to hide the task to avoid flicker for entering PiP from
-            // split-screen.
-            try {
-                PictureInPictureSurfaceTransaction tx = new PictureInPictureSurfaceTransaction.Builder()
-                        .setAlpha(0f)
-                        .build();
-                try {
-                    tx.setShouldDisableCanAffectSystemUiFlags(false);
-                } catch (NoSuchMethodError error) {
-                    Log.w(TAG, "not android 13 qpr1 : ", error);
-                }
-                int[] taskIds = TopTaskTracker.INSTANCE.get(mContext).getRunningSplitTaskIds();
-                for (int taskId : taskIds) {
-                    mRecentsAnimationController.setFinishTaskTransaction(taskId,
-                            tx, null /* overlay */);
-                }
-            } catch (Throwable t) {
-                Log.w(TAG, "Failed PictureInPictureSurfaceTransaction: ", t);
+            // Transaction to hide the task to avoid flicker for entering PiP from split-screen.
+            PictureInPictureSurfaceTransaction tx =
+                    new PictureInPictureSurfaceTransaction.Builder()
+                            .setAlpha(0f)
+                            .build();
+            tx.setShouldDisableCanAffectSystemUiFlags(false);
+            int[] taskIds = TopTaskTracker.INSTANCE.get(mContext).getRunningSplitTaskIds();
+            for (int taskId : taskIds) {
+                mRecentsAnimationController.setFinishTaskTransaction(taskId,
+                        tx, null /* overlay */);
             }
         }
     }
@@ -2368,7 +2265,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         SurfaceTransactionApplier applier = new SurfaceTransactionApplier(mRecentsView);
         runActionOnRemoteHandles(remoteTargetHandle -> remoteTargetHandle.getTransformParams()
                 .setSyncTransactionApplier(applier));
-        runOnRecentsAnimationAndLauncherBound(() -> mRecentsAnimationTargets.addReleaseCheck(applier));
+        runOnRecentsAnimationAndLauncherBound(() ->
+                mRecentsAnimationTargets.addReleaseCheck(applier));
 
         mRecentsView.addOnScrollChangedListener(mOnRecentsScrollListener);
         runOnRecentsAnimationAndLauncherBound(() -> {
@@ -2381,7 +2279,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
 
         if (Flags.enableDesktopWindowingMode()
                 && !(Flags.enableDesktopWindowingWallpaperActivity()
-                        && Flags.enableDesktopWindowingQuickSwitch())) {
+                && Flags.enableDesktopWindowingQuickSwitch())) {
             if (mRecentsView.getNextPageTaskView() instanceof DesktopTaskView
                     || mRecentsView.getCurrentPageTaskView() instanceof DesktopTaskView) {
                 mRecentsViewScrollLinked = false;
@@ -2462,10 +2360,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Runs the given {@param action} if the recents animation has already started
-     * and Launcher has
-     * been created and bound to the TouchInteractionService, or queues it to be run
-     * when it this
+     * Runs the given {@param action} if the recents animation has already started and Launcher has
+     * been created and bound to the TouchInteractionService, or queues it to be run when it this
      * next happens.
      */
     private void runOnRecentsAnimationAndLauncherBound(Runnable action) {
@@ -2488,11 +2384,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * TODO can we remove this now that we don't finish the controller until
-     * onTaskAppeared()?
-     *
-     * @return whether the recents animation has started and there are valid app
-     *         targets.
+     * TODO can we remove this now that we don't finish the controller until onTaskAppeared()?
+     * @return whether the recents animation has started and there are valid app targets.
      */
     protected boolean hasTargets() {
         return mRecentsAnimationTargets != null && mRecentsAnimationTargets.hasTargets();
@@ -2515,8 +2408,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         boolean hasStartedTaskBefore = Arrays.stream(appearedTaskTargets).anyMatch(
                 mGestureState.mLastStartedTaskIdPredicate);
         if (!mStateCallback.hasStates(STATE_GESTURE_COMPLETED) && !hasStartedTaskBefore) {
-            // This is a special case, if a task is started mid-gesture that wasn't a part
-            // of a
+            // This is a special case, if a task is started mid-gesture that wasn't a part of a
             // previous quickswitch task launch, then cancel the animation back to the app
             RemoteAnimationTarget appearedTaskTarget = appearedTaskTargets[0];
             TaskInfo taskInfo = appearedTaskTarget.taskInfo;
@@ -2532,9 +2424,10 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         if (!handleTaskAppeared(appearedTaskTargets)) {
             return;
         }
-        Optional<RemoteAnimationTarget> taskTargetOptional = Arrays.stream(appearedTaskTargets)
-                .filter(mGestureState.mLastStartedTaskIdPredicate)
-                .findFirst();
+        Optional<RemoteAnimationTarget> taskTargetOptional =
+                Arrays.stream(appearedTaskTargets)
+                        .filter(mGestureState.mLastStartedTaskIdPredicate)
+                        .findFirst();
         if (!taskTargetOptional.isPresent()) {
             ActiveGestureLog.INSTANCE.addLog("No appeared task matching started task id");
             finishRecentsAnimationOnTasksAppeared(null /* onFinishComplete */);
@@ -2542,8 +2435,7 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         }
         RemoteAnimationTarget taskTarget = taskTargetOptional.get();
         TaskView taskView = mRecentsView == null
-                ? null
-                : mRecentsView.getTaskViewByTaskId(taskTarget.taskId);
+                ? null : mRecentsView.getTaskViewByTaskId(taskTarget.taskId);
         if (taskView == null
                 || !taskView.getFirstThumbnailViewDeprecated().shouldShowSplashView()) {
             ActiveGestureLog.INSTANCE.addLog("Invalid task view splash state");
@@ -2564,15 +2456,15 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
             @NonNull SurfaceControl leash) {
         ViewGroup splashView = activity.getDragLayer();
         final QuickstepLauncher quickstepLauncher = activity instanceof QuickstepLauncher
-                ? (QuickstepLauncher) activity
-                : null;
+                ? (QuickstepLauncher) activity : null;
         if (quickstepLauncher != null) {
             quickstepLauncher.getDepthController().pauseBlursOnWindows(true);
         }
 
         // When revealing the app with launcher splash screen, make the app visible
         // and behind the splash view before the splash is animated away.
-        SurfaceTransactionApplier surfaceApplier = new SurfaceTransactionApplier(splashView);
+        SurfaceTransactionApplier surfaceApplier =
+                new SurfaceTransactionApplier(splashView);
         SurfaceTransaction transaction = new SurfaceTransaction();
         for (RemoteAnimationTarget target : appearedTaskTargets) {
             transaction.forSurface(target.leash).setAlpha(1).setLayer(-1).setShow();
@@ -2609,9 +2501,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * @return The index of the TaskView in RecentsView whose taskId matches the
-     *         task that will
-     *         resume if we finish the controller.
+     * @return The index of the TaskView in RecentsView whose taskId matches the task that will
+     * resume if we finish the controller.
      */
     protected int getLastAppearedTaskIndex() {
         if (mRecentsView == null) {
@@ -2627,9 +2518,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * @return Whether we are continuing a gesture that already landed on a new
-     *         task,
-     *         but before that task appeared.
+     * @return Whether we are continuing a gesture that already landed on a new task,
+     * but before that task appeared.
      */
     protected boolean hasStartedNewTask() {
         return mGestureState.getLastStartedTaskIds()[0] != -1;
@@ -2664,7 +2554,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
         if (!fadeAppTargets || Float.compare(fadeProgress, 1f) == 0) {
             return false;
         }
-        SurfaceTransaction surfaceTransaction = transformParams.createSurfaceParams(taskViewSimulator);
+        SurfaceTransaction surfaceTransaction =
+                transformParams.createSurfaceParams(taskViewSimulator);
         SurfaceControl.Transaction transaction = surfaceTransaction.getTransaction();
 
         for (RemoteAnimationTarget app : targets.apps) {
@@ -2672,10 +2563,11 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
             transaction.setPosition(app.leash,
                     /* x= */ app.startBounds.left
                             + (mContainer.getDeviceProfile().overviewPageSpacing
-                                    * (mRecentsView.isRtl() ? fadeProgress : -fadeProgress)),
+                            * (mRecentsView.isRtl() ? fadeProgress : -fadeProgress)),
                     /* y= */ 0f);
             transaction.setScale(app.leash, 1f, 1f);
-            taskViewSimulator.taskPrimaryTranslation.value = mRecentsView.getScrollOffsetForKeyboardTaskFocus();
+            taskViewSimulator.taskPrimaryTranslation.value =
+                    mRecentsView.getScrollOffsetForKeyboardTaskFocus();
             taskViewSimulator.apply(transformParams, surfaceTransaction);
         }
         return true;
@@ -2686,8 +2578,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
      */
     protected void applyScrollAndTransform() {
         // No need to apply any transform if there is ongoing swipe-to-home animator
-        // swipe-to-pip handles the leash solely
-        // swipe-to-icon animation is handled by RectFSpringAnim anim
+        //    swipe-to-pip handles the leash solely
+        //    swipe-to-icon animation is handled by RectFSpringAnim anim
         boolean notSwipingToHome = mRecentsAnimationTargets != null
                 && mGestureState.getEndTarget() != HOME;
         boolean setRecentsScroll = shouldLinkRecentsViewScroll() && mRecentsView != null;
@@ -2698,15 +2590,14 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
             startInterceptingTouchesForGesture();
         }
         for (RemoteTargetHandle remoteHandle : mRemoteTargetHandles) {
-            float scrollScale = setRecentsScroll ? mRecentsView.getScrollScale(remoteHandle) : 1f;
-            AnimatorControllerWithResistance playbackController = remoteHandle.getPlaybackController();
+            AnimatorControllerWithResistance playbackController =
+                    remoteHandle.getPlaybackController();
             if (playbackController != null) {
                 playbackController.setProgress(progress, mDragLengthFactor);
             }
 
             if (notSwipingToHome) {
                 TaskViewSimulator taskViewSimulator = remoteHandle.getTaskViewSimulator();
-                taskViewSimulator.scrollScale.value = scrollScale;
                 if (setRecentsScroll) {
                     taskViewSimulator.setScroll(scrollOffset);
                 }
@@ -2735,7 +2626,8 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
                 carouselTaskSize.width(), carouselTaskSize.height());
         maxScrollOffset += mRecentsView.getPageSpacing();
 
-        float maxScaleProgress = MAX_QUICK_SWITCH_RECENTS_SCALE_PROGRESS * mRecentsView.getMaxScaleForFullScreen();
+        float maxScaleProgress =
+                MAX_QUICK_SWITCH_RECENTS_SCALE_PROGRESS * mRecentsView.getMaxScaleForFullScreen();
         float scaleProgress = maxScaleProgress;
 
         if (scrollOffset < mQuickSwitchScaleScrollThreshold) {
@@ -2751,12 +2643,10 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     }
 
     /**
-     * Overrides the gesture displacement to keep the app window at the bottom of
-     * the screen while
+     * Overrides the gesture displacement to keep the app window at the bottom of the screen while
      * the transient taskbar is being swiped in.
      *
-     * There is also a catch up period so that the window can start moving 1:1 with
-     * the swipe.
+     * There is also a catch up period so that the window can start moving 1:1 with the swipe.
      */
     @Override
     protected float overrideDisplacementForTransientTaskbar(float displacement) {
@@ -2793,4 +2683,4 @@ public abstract class AbsSwipeUpHandler<T extends RecentsViewContainer, Q extend
     public interface Factory {
         AbsSwipeUpHandler newHandler(GestureState gestureState, long touchTimeMs);
     }
-}
+}
\ No newline at end of file
diff --git a/quickstep/src/com/android/quickstep/OrientationTouchTransformer.java b/quickstep/src/com/android/quickstep/OrientationTouchTransformer.java
index 2fa5078947..84f6b5514f 100644
--- a/quickstep/src/com/android/quickstep/OrientationTouchTransformer.java
+++ b/quickstep/src/com/android/quickstep/OrientationTouchTransformer.java
@@ -32,11 +32,11 @@ import android.view.MotionEvent;
 import android.view.Surface;
 
 import com.android.launcher3.R;
+import com.android.launcher3.testing.shared.ResourceUtils;
 import com.android.launcher3.testing.shared.TestProtocol;
 import com.android.launcher3.util.DisplayController.Info;
 import com.android.launcher3.util.NavigationMode;
 import com.android.launcher3.util.window.CachedDisplayInfo;
-import com.android.systemui.shared.testing.ResourceUtils;
 
 import java.io.PrintWriter;
 import java.util.HashMap;
diff --git a/quickstep/src/com/android/quickstep/QuickstepTestInformationHandler.java b/quickstep/src/com/android/quickstep/QuickstepTestInformationHandler.java
deleted file mode 100644
index b4b8c5b82c..0000000000
--- a/quickstep/src/com/android/quickstep/QuickstepTestInformationHandler.java
+++ /dev/null
@@ -1,272 +0,0 @@
-package com.android.quickstep;
-
-import static com.android.launcher3.taskbar.TaskbarThresholdUtils.getFromNavThreshold;
-import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
-
-import android.app.Activity;
-import android.content.Context;
-import android.content.res.Resources;
-import android.graphics.Rect;
-import android.os.Bundle;
-
-import androidx.annotation.Nullable;
-
-import com.android.launcher3.taskbar.TaskbarActivityContext;
-import com.android.launcher3.testing.TestInformationHandler;
-import com.android.launcher3.testing.shared.TestProtocol;
-import com.android.launcher3.util.DisplayController;
-import com.android.quickstep.orientation.RecentsPagedOrientationHandler;
-import com.android.quickstep.util.GroupTask;
-import com.android.quickstep.util.LayoutUtils;
-import com.android.quickstep.util.TISBindHelper;
-import com.android.quickstep.views.RecentsView;
-
-import java.util.ArrayList;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-public class QuickstepTestInformationHandler extends TestInformationHandler {
-
-    protected final Context mContext;
-
-    public QuickstepTestInformationHandler(Context context) {
-        mContext = context;
-    }
-
-    @Override
-    public Bundle call(String method, String arg, @Nullable Bundle extras) {
-        final Bundle response = new Bundle();
-        switch (method) {
-            case TestProtocol.REQUEST_RECENT_TASKS_LIST: {
-                ArrayList<String> taskBaseIntentComponents = new ArrayList<>();
-                CountDownLatch latch = new CountDownLatch(1);
-                RecentsModel.INSTANCE.get(mContext).getTasks((taskGroups) -> {
-                    for (GroupTask group : taskGroups) {
-                        taskBaseIntentComponents.add(
-                                group.task1.key.baseIntent.getComponent().flattenToString());
-                        if (group.task2 != null) {
-                            taskBaseIntentComponents.add(
-                                    group.task2.key.baseIntent.getComponent().flattenToString());
-                        }
-                    }
-                    latch.countDown();
-                });
-                try {
-                    latch.await(2, TimeUnit.SECONDS);
-                } catch (InterruptedException e) {
-                    throw new RuntimeException(e);
-                }
-                response.putStringArrayList(TestProtocol.TEST_INFO_RESPONSE_FIELD,
-                        taskBaseIntentComponents);
-                return response;
-            }
-
-            case TestProtocol.REQUEST_HOME_TO_OVERVIEW_SWIPE_HEIGHT: {
-                final float swipeHeight =
-                        LayoutUtils.getDefaultSwipeHeight(mContext, mDeviceProfile);
-                response.putInt(TestProtocol.TEST_INFO_RESPONSE_FIELD, (int) swipeHeight);
-                return response;
-            }
-
-            case TestProtocol.REQUEST_BACKGROUND_TO_OVERVIEW_SWIPE_HEIGHT: {
-                final float swipeHeight = mDeviceProfile.heightPx / 2f;
-                response.putInt(TestProtocol.TEST_INFO_RESPONSE_FIELD, (int) swipeHeight);
-                return response;
-            }
-
-            case TestProtocol.REQUEST_GET_FOCUSED_TASK_HEIGHT_FOR_TABLET: {
-                if (!mDeviceProfile.isTablet) {
-                    return null;
-                }
-                Rect focusedTaskRect = new Rect();
-                LauncherActivityInterface.INSTANCE.calculateTaskSize(mContext, mDeviceProfile,
-                        focusedTaskRect, RecentsPagedOrientationHandler.PORTRAIT);
-                response.putInt(TestProtocol.TEST_INFO_RESPONSE_FIELD, focusedTaskRect.height());
-                return response;
-            }
-
-            case TestProtocol.REQUEST_GET_GRID_TASK_SIZE_RECT_FOR_TABLET: {
-                if (!mDeviceProfile.isTablet) {
-                    return null;
-                }
-                Rect gridTaskRect = new Rect();
-                LauncherActivityInterface.INSTANCE.calculateGridTaskSize(mContext, mDeviceProfile,
-                        gridTaskRect, RecentsPagedOrientationHandler.PORTRAIT);
-                response.putParcelable(TestProtocol.TEST_INFO_RESPONSE_FIELD, gridTaskRect);
-                return response;
-            }
-
-            case TestProtocol.REQUEST_GET_OVERVIEW_PAGE_SPACING: {
-                response.putInt(TestProtocol.TEST_INFO_RESPONSE_FIELD,
-                        mDeviceProfile.overviewPageSpacing);
-                return response;
-            }
-
-            case TestProtocol.REQUEST_GET_OVERVIEW_CURRENT_PAGE_INDEX: {
-                return getLauncherUIProperty(Bundle::putInt,
-                        launcher -> launcher.<RecentsView>getOverviewPanel().getCurrentPage());
-            }
-
-            case TestProtocol.REQUEST_HAS_TIS: {
-                response.putBoolean(TestProtocol.TEST_INFO_RESPONSE_FIELD, true);
-                return response;
-            }
-
-            case TestProtocol.REQUEST_UNSTASH_TASKBAR_IF_STASHED:
-                runOnTISBinder(tisBinder -> {
-                    // Allow null-pointer to catch illegal states.
-                    tisBinder.getTaskbarManager().getCurrentActivityContext()
-                            .unstashTaskbarIfStashed();
-                });
-                return response;
-
-            case TestProtocol.REQUEST_TASKBAR_FROM_NAV_THRESHOLD: {
-                final Resources resources = mContext.getResources();
-                response.putInt(TestProtocol.TEST_INFO_RESPONSE_FIELD,
-                        getFromNavThreshold(resources, mDeviceProfile));
-                return response;
-            }
-
-            case TestProtocol.REQUEST_STASHED_TASKBAR_SCALE: {
-                runOnTISBinder(tisBinder -> {
-                    response.putFloat(TestProtocol.TEST_INFO_RESPONSE_FIELD,
-                            tisBinder.getTaskbarManager()
-                                    .getCurrentActivityContext()
-                                    .getStashedTaskbarScale());
-                });
-                return response;
-            }
-
-            case TestProtocol.REQUEST_TASKBAR_ALL_APPS_TOP_PADDING: {
-                return getTISBinderUIProperty(Bundle::putInt, tisBinder ->
-                        tisBinder.getTaskbarManager()
-                                .getCurrentActivityContext()
-                                .getTaskbarAllAppsTopPadding());
-            }
-
-            case TestProtocol.REQUEST_TASKBAR_APPS_LIST_SCROLL_Y: {
-                return getTISBinderUIProperty(Bundle::putInt, tisBinder ->
-                        tisBinder.getTaskbarManager()
-                                .getCurrentActivityContext()
-                                .getTaskbarAllAppsScroll());
-            }
-
-            case TestProtocol.REQUEST_ENABLE_BLOCK_TIMEOUT:
-                runOnTISBinder(tisBinder -> {
-                    enableBlockingTimeout(tisBinder, true);
-                });
-                return response;
-
-            case TestProtocol.REQUEST_DISABLE_BLOCK_TIMEOUT:
-                runOnTISBinder(tisBinder -> {
-                    enableBlockingTimeout(tisBinder, false);
-                });
-                return response;
-
-            case TestProtocol.REQUEST_ENABLE_TRANSIENT_TASKBAR:
-                enableTransientTaskbar(true);
-                return response;
-
-            case TestProtocol.REQUEST_DISABLE_TRANSIENT_TASKBAR:
-                enableTransientTaskbar(false);
-                return response;
-
-            case TestProtocol.REQUEST_SHELL_DRAG_READY:
-                response.putBoolean(TestProtocol.TEST_INFO_RESPONSE_FIELD,
-                        SystemUiProxy.INSTANCE.get(mContext).isDragAndDropReady());
-                return response;
-
-            case TestProtocol.REQUEST_REFRESH_OVERVIEW_TARGET:
-                runOnTISBinder(TouchInteractionService.TISBinder::refreshOverviewTarget);
-                return response;
-
-            case TestProtocol.REQUEST_RECREATE_TASKBAR:
-                // Allow null-pointer to catch illegal states.
-                runOnTISBinder(tisBinder -> tisBinder.getTaskbarManager().recreateTaskbar());
-                return response;
-            case TestProtocol.REQUEST_TASKBAR_IME_DOCKED:
-                return getTISBinderUIProperty(Bundle::putBoolean, tisBinder ->
-                        tisBinder.getTaskbarManager()
-                                .getCurrentActivityContext().isImeDocked());
-            case TestProtocol.REQUEST_UNSTASH_BUBBLE_BAR_IF_STASHED:
-                runOnTISBinder(tisBinder -> {
-                    // Allow null-pointer to catch illegal states.
-                    tisBinder.getTaskbarManager().getCurrentActivityContext()
-                            .unstashBubbleBarIfStashed();
-                });
-                return response;
-            case TestProtocol.REQUEST_INJECT_FAKE_TRACKPAD:
-                runOnTISBinder(tisBinder -> tisBinder.injectFakeTrackpadForTesting());
-                return response;
-            case TestProtocol.REQUEST_EJECT_FAKE_TRACKPAD:
-                runOnTISBinder(tisBinder -> tisBinder.ejectFakeTrackpadForTesting());
-                return response;
-        }
-
-        return super.call(method, arg, extras);
-    }
-
-    @Override
-    protected Activity getCurrentActivity() {
-        RecentsAnimationDeviceState rads = new RecentsAnimationDeviceState(mContext);
-        OverviewComponentObserver observer = new OverviewComponentObserver(mContext, rads);
-        try {
-            return observer.getActivityInterface().getCreatedContainer();
-        } finally {
-            observer.onDestroy();
-            rads.destroy();
-        }
-    }
-
-    @Override
-    protected boolean isLauncherInitialized() {
-        return super.isLauncherInitialized() && TouchInteractionService.isInitialized();
-    }
-
-    private void enableBlockingTimeout(
-            TouchInteractionService.TISBinder tisBinder, boolean enable) {
-        TaskbarActivityContext context = tisBinder.getTaskbarManager().getCurrentActivityContext();
-        if (context == null) {
-            return;
-        }
-        context.enableBlockingTimeoutDuringTests(enable);
-    }
-
-    private void enableTransientTaskbar(boolean enable) {
-        DisplayController.INSTANCE.get(mContext).enableTransientTaskbarForTests(enable);
-    }
-
-    /**
-     * Runs the given command on the UI thread, after ensuring we are connected to
-     * TouchInteractionService.
-     */
-    protected void runOnTISBinder(Consumer<TouchInteractionService.TISBinder> connectionCallback) {
-        try {
-            CountDownLatch countDownLatch = new CountDownLatch(1);
-            TISBindHelper helper = MAIN_EXECUTOR.submit(() ->
-                    new TISBindHelper(mContext, tisBinder -> {
-                        connectionCallback.accept(tisBinder);
-                        countDownLatch.countDown();
-                    })).get();
-            countDownLatch.await();
-            MAIN_EXECUTOR.execute(helper::onDestroy);
-        } catch (ExecutionException | InterruptedException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    private <T> Bundle getTISBinderUIProperty(
-            BundleSetter<T> bundleSetter, Function<TouchInteractionService.TISBinder, T> provider) {
-        Bundle response = new Bundle();
-
-        runOnTISBinder(tisBinder -> bundleSetter.set(
-                response,
-                TestProtocol.TEST_INFO_RESPONSE_FIELD,
-                provider.apply(tisBinder)));
-
-        return response;
-    }
-}
diff --git a/quickstep/src/com/android/quickstep/RecentTasksList.java b/quickstep/src/com/android/quickstep/RecentTasksList.java
index c2d45b0d2c..6280f1a33d 100644
--- a/quickstep/src/com/android/quickstep/RecentTasksList.java
+++ b/quickstep/src/com/android/quickstep/RecentTasksList.java
@@ -110,6 +110,20 @@ public class RecentTasksList {
                             RecentTasksList.this.onRunningTaskVanished(taskInfo);
                         });
                     }
+
+                    @Override
+                    public void onRunningTaskChanged(ActivityManager.RunningTaskInfo taskInfo){
+                        mMainThreadExecutor.execute(() -> {
+                            RecentTasksList.this.onRunningTaskChanged(taskInfo);
+                        });
+                    }
+
+                    @Override
+                    public void onTaskMovedToFront(ActivityManager.RunningTaskInfo taskInfo){
+                        mMainThreadExecutor.execute(() -> {
+                            RecentTasksList.this.onRunningTaskAppeared(taskInfo);
+                        });
+                    }
                 });
             } else if (LawnchairQuickstepCompat.ATLEAST_Q) {
                 TaskStackChangeListeners.getInstance().registerTaskStackListener(new TaskStackChangeListener() {
diff --git a/quickstep/src/com/android/quickstep/RecentsAnimationCallbacks.java b/quickstep/src/com/android/quickstep/RecentsAnimationCallbacks.java
index 40bd92d109..6bad0391d6 100644
--- a/quickstep/src/com/android/quickstep/RecentsAnimationCallbacks.java
+++ b/quickstep/src/com/android/quickstep/RecentsAnimationCallbacks.java
@@ -113,7 +113,7 @@ public class RecentsAnimationCallbacks implements
         if (transaction != null) {
             transaction.apply();
         }
-        onAnimationStart(controller, apps, wallpapers, homeContentInsets, minimizedHomeBounds);
+//        onAnimationStart(controller, apps, wallpapers, homeContentInsets, minimizedHomeBounds);
     }
 
     // Called only in R+ platform
diff --git a/quickstep/src/com/android/quickstep/RecentsAnimationDeviceState.java b/quickstep/src/com/android/quickstep/RecentsAnimationDeviceState.java
index cbf7ea12e4..739f10ff3c 100644
--- a/quickstep/src/com/android/quickstep/RecentsAnimationDeviceState.java
+++ b/quickstep/src/com/android/quickstep/RecentsAnimationDeviceState.java
@@ -262,9 +262,6 @@ public class RecentsAnimationDeviceState implements DisplayInfoChangeListener, E
             ActiveGestureLog.INSTANCE.setIsFullyGesturalNavMode(isFullyGesturalNavMode());
             mNavBarPosition = new NavBarPosition(mMode, info);
 
-            if (mExclusionListener == null)
-                return;
-
             if (mMode == NO_BUTTON) {
                 registerExclusionListener();
             } else {
diff --git a/quickstep/src/com/android/quickstep/SystemUiProxy.java b/quickstep/src/com/android/quickstep/SystemUiProxy.java
index bb395428f3..cabe40c2f3 100644
--- a/quickstep/src/com/android/quickstep/SystemUiProxy.java
+++ b/quickstep/src/com/android/quickstep/SystemUiProxy.java
@@ -17,9 +17,14 @@ package com.android.quickstep;
 
 import static android.app.ActivityManager.RECENT_IGNORE_UNAVAILABLE;
 
+import static com.android.launcher3.Flags.enableUnfoldStateAnimation;
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 import static com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR;
+import static com.android.launcher3.util.SplitConfigurationOptions.StagePosition;
+import static com.android.quickstep.util.ActiveGestureErrorDetector.GestureEvent.RECENT_TASKS_MISSING;
 import static com.android.quickstep.util.LogUtils.splitFailureMessage;
+import static com.android.window.flags.Flags.enableDesktopWindowingMode;
+import static com.android.window.flags.Flags.enableDesktopWindowingTaskbarRunningApps;
 
 import android.app.ActivityManager;
 import android.app.ActivityOptions;
@@ -30,8 +35,7 @@ import android.content.Context;
 import android.content.Intent;
 import android.content.pm.ActivityInfo;
 import android.content.pm.ShortcutInfo;
-import android.graphics.Bitmap;
-import android.graphics.Insets;
+import android.graphics.Point;
 import android.graphics.Rect;
 import android.os.Bundle;
 import android.os.Handler;
@@ -52,7 +56,6 @@ import android.window.IOnBackInvokedCallback;
 import android.window.RemoteTransition;
 import android.window.TaskSnapshot;
 import android.window.TransitionFilter;
-import android.window.TransitionInfo;
 
 import androidx.annotation.MainThread;
 import androidx.annotation.Nullable;
@@ -61,58 +64,59 @@ import androidx.annotation.WorkerThread;
 import com.android.internal.logging.InstanceId;
 import com.android.internal.util.ScreenshotRequest;
 import com.android.internal.view.AppearanceRegion;
-import com.android.launcher3.Utilities;
 import com.android.launcher3.util.MainThreadInitializedObject;
 import com.android.launcher3.util.Preconditions;
-import com.android.launcher3.util.SplitConfigurationOptions;
+import com.android.launcher3.util.SafeCloseable;
+import com.android.quickstep.util.ActiveGestureLog;
 import com.android.quickstep.util.AssistUtils;
+import com.android.quickstep.util.unfold.ProxyUnfoldTransitionProvider;
 import com.android.systemui.shared.recents.ISystemUiProxy;
-import com.android.systemui.shared.recents.model.Task;
 import com.android.systemui.shared.recents.model.ThumbnailData;
-import com.android.systemui.shared.system.ActivityManagerWrapper;
+import com.android.systemui.shared.system.QuickStepContract.SystemUiStateFlags;
 import com.android.systemui.shared.system.RecentsAnimationControllerCompat;
 import com.android.systemui.shared.system.RecentsAnimationListener;
 import com.android.systemui.shared.system.smartspace.ILauncherUnlockAnimationController;
 import com.android.systemui.shared.system.smartspace.ISysuiUnlockAnimationController;
 import com.android.systemui.shared.system.smartspace.SmartspaceState;
+import com.android.systemui.unfold.config.ResourceUnfoldTransitionConfig;
 import com.android.systemui.unfold.progress.IUnfoldAnimation;
 import com.android.systemui.unfold.progress.IUnfoldTransitionListener;
 import com.android.wm.shell.back.IBackAnimation;
 import com.android.wm.shell.bubbles.IBubbles;
 import com.android.wm.shell.bubbles.IBubblesListener;
+import com.android.wm.shell.common.bubbles.BubbleBarLocation;
+import com.android.wm.shell.common.desktopmode.DesktopModeTransitionSource;
+import com.android.wm.shell.common.pip.IPip;
+import com.android.wm.shell.common.pip.IPipAnimationListener;
+import com.android.wm.shell.common.split.SplitScreenConstants.PersistentSnapPosition;
 import com.android.wm.shell.desktopmode.IDesktopMode;
 import com.android.wm.shell.desktopmode.IDesktopTaskListener;
 import com.android.wm.shell.draganddrop.IDragAndDrop;
 import com.android.wm.shell.onehanded.IOneHanded;
-import com.android.wm.shell.pip.PipData;
-import com.android.wm.shell.pip.IPip;
-import com.android.wm.shell.pip.IPipAnimationListener;
 import com.android.wm.shell.recents.IRecentTasks;
 import com.android.wm.shell.recents.IRecentTasksListener;
+import com.android.wm.shell.shared.IShellTransitions;
 import com.android.wm.shell.splitscreen.ISplitScreen;
 import com.android.wm.shell.splitscreen.ISplitScreenListener;
 import com.android.wm.shell.splitscreen.ISplitSelectListener;
 import com.android.wm.shell.startingsurface.IStartingWindow;
 import com.android.wm.shell.startingsurface.IStartingWindowListener;
-import com.android.wm.shell.transition.IShellTransitions;
 import com.android.wm.shell.util.GroupedRecentTaskInfo;
 
+import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.stream.Collectors;
-
-import app.lawnchair.compat.LawnchairQuickstepCompat;
 
 /**
  * Holds the reference to SystemUI.
  */
-public class SystemUiProxy implements ISystemUiProxy {
-    private static final String TAG = SystemUiProxy.class.getSimpleName();
+public class SystemUiProxy implements ISystemUiProxy, NavHandle, SafeCloseable {
+    private static final String TAG = "SystemUiProxy";
 
-    public static final MainThreadInitializedObject<SystemUiProxy> INSTANCE = new MainThreadInitializedObject<>(
-            SystemUiProxy::new);
+    public static final MainThreadInitializedObject<SystemUiProxy> INSTANCE =
+            new MainThreadInitializedObject<>(SystemUiProxy::new);
 
     private static final int MSG_SET_SHELF_HEIGHT = 1;
     private static final int MSG_SET_LAUNCHER_KEEP_CLEAR_AREA_HEIGHT = 2;
@@ -133,12 +137,9 @@ public class SystemUiProxy implements ISystemUiProxy {
         MAIN_EXECUTOR.execute(() -> clearProxy());
     };
 
-    // Save the listeners passed into the proxy since OverviewProxyService may not
-    // have been bound
-    // yet, and we'll need to set/register these listeners with SysUI when they do.
-    // Note that it is
-    // up to the caller to clear the listeners to prevent leaks as these can be held
-    // indefinitely
+    // Save the listeners passed into the proxy since OverviewProxyService may not have been bound
+    // yet, and we'll need to set/register these listeners with SysUI when they do.  Note that it is
+    // up to the caller to clear the listeners to prevent leaks as these can be held indefinitely
     // in case SysUI needs to rebind.
     private IPipAnimationListener mPipAnimationListener;
     private IBubblesListener mBubblesListener;
@@ -146,14 +147,20 @@ public class SystemUiProxy implements ISystemUiProxy {
     private ISplitSelectListener mSplitSelectListener;
     private IStartingWindowListener mStartingWindowListener;
     private ILauncherUnlockAnimationController mLauncherUnlockAnimationController;
+    private String mLauncherActivityClass;
     private IRecentTasksListener mRecentTasksListener;
     private IUnfoldTransitionListener mUnfoldAnimationListener;
     private IDesktopTaskListener mDesktopTaskListener;
-    private final LinkedHashMap<RemoteTransition, TransitionFilter> mRemoteTransitions = new LinkedHashMap<>();
+    private final LinkedHashMap<RemoteTransition, TransitionFilter> mRemoteTransitions =
+            new LinkedHashMap<>();
+
+    private final List<Runnable> mStateChangeCallbacks = new ArrayList<>();
+
     private IBinder mOriginalTransactionToken = null;
     private IOnBackInvokedCallback mBackToLauncherCallback;
     private IRemoteAnimationRunner mBackToLauncherRunner;
     private IDragAndDrop mDragAndDrop;
+    private final HomeVisibilityState mHomeVisibilityState = new HomeVisibilityState();
 
     // Used to dedupe calls to SystemUI
     private int mLastShelfHeight;
@@ -167,26 +174,38 @@ public class SystemUiProxy implements ISystemUiProxy {
     private final Handler mAsyncHandler;
 
     // TODO(141886704): Find a way to remove this
-    private int mLastSystemUiStateFlags;
+    @SystemUiStateFlags
+    private long mLastSystemUiStateFlags;
 
     /**
-     * This is a singleton pending intent that is used to start recents via Shell
-     * (which is a
-     * different process). It is bare-bones, so it's expected that the component and
-     * options will
+     * This is a singleton pending intent that is used to start recents via Shell (which is a
+     * different process). It is bare-bones, so it's expected that the component and options will
      * be provided via fill-in intent.
      */
     private final PendingIntent mRecentsPendingIntent;
 
-    public SystemUiProxy(Context context) {
+    @Nullable
+    private final ProxyUnfoldTransitionProvider mUnfoldTransitionProvider;
+
+    private SystemUiProxy(Context context) {
         mContext = context;
         mAsyncHandler = new Handler(UI_HELPER_EXECUTOR.getLooper(), this::handleMessageAsync);
         final Intent baseIntent = new Intent().setPackage(mContext.getPackageName());
+        final ActivityOptions options = ActivityOptions.makeBasic()
+                .setPendingIntentCreatorBackgroundActivityStartMode(
+                        ActivityOptions.MODE_BACKGROUND_ACTIVITY_START_ALLOWED);
         mRecentsPendingIntent = PendingIntent.getActivity(mContext, 0, baseIntent,
                 PendingIntent.FLAG_MUTABLE | PendingIntent.FLAG_ALLOW_UNSAFE_IMPLICIT_INTENT
-                        | Intent.FILL_IN_COMPONENT);
+                        | Intent.FILL_IN_COMPONENT, options.toBundle());
+
+        mUnfoldTransitionProvider =
+                (enableUnfoldStateAnimation() && new ResourceUnfoldTransitionConfig().isEnabled())
+                        ? new ProxyUnfoldTransitionProvider() : null;
     }
 
+    @Override
+    public void close() { }
+
     @Override
     public void onBackPressed() {
         if (mSystemUiProxy != null) {
@@ -227,21 +246,20 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     /**
-     * Sets proxy state, including death linkage, various listeners, and other
-     * configuration objects
+     * Sets proxy state, including death linkage, various listeners, and other configuration objects
      */
     @MainThread
     public void setProxy(ISystemUiProxy proxy, IPip pip, IBubbles bubbles, ISplitScreen splitScreen,
-            IOneHanded oneHanded, IShellTransitions shellTransitions,
-            IStartingWindow startingWindow, IRecentTasks recentTasks,
-            ISysuiUnlockAnimationController sysuiUnlockAnimationController,
-            IBackAnimation backAnimation, IDesktopMode desktopMode,
-            IUnfoldAnimation unfoldAnimation, IDragAndDrop dragAndDrop) {
+                         IOneHanded oneHanded, IShellTransitions shellTransitions,
+                         IStartingWindow startingWindow, IRecentTasks recentTasks,
+                         ISysuiUnlockAnimationController sysuiUnlockAnimationController,
+                         IBackAnimation backAnimation, IDesktopMode desktopMode,
+                         IUnfoldAnimation unfoldAnimation, IDragAndDrop dragAndDrop) {
         Preconditions.assertUIThread();
         unlinkToDeath();
         mSystemUiProxy = proxy;
         mPip = pip;
-        mBubbles = Utilities.ATLEAST_U ? bubbles : null;
+        mBubbles = bubbles;
         mSplitScreen = splitScreen;
         mOneHanded = oneHanded;
         mShellTransitions = shellTransitions;
@@ -250,17 +268,18 @@ public class SystemUiProxy implements ISystemUiProxy {
         mRecentTasks = recentTasks;
         mBackAnimation = backAnimation;
         mDesktopMode = desktopMode;
-        mUnfoldAnimation = unfoldAnimation;
-        mDragAndDrop = Utilities.ATLEAST_U ? dragAndDrop : null;
+        mUnfoldAnimation = enableUnfoldStateAnimation() ? null : unfoldAnimation;
+        mDragAndDrop = dragAndDrop;
         linkToDeath();
-        // re-attach the listeners once missing due to setProxy has not been initialized
-        // yet.
+        // re-attach the listeners once missing due to setProxy has not been initialized yet.
         setPipAnimationListener(mPipAnimationListener);
         setBubblesListener(mBubblesListener);
         registerSplitScreenListener(mSplitScreenListener);
         registerSplitSelectListener(mSplitSelectListener);
+        mHomeVisibilityState.init(mShellTransitions);
         setStartingWindowListener(mStartingWindowListener);
-        setLauncherUnlockAnimationController(mLauncherUnlockAnimationController);
+        setLauncherUnlockAnimationController(
+                mLauncherActivityClass, mLauncherUnlockAnimationController);
         new LinkedHashMap<>(mRemoteTransitions).forEach(this::registerRemoteTransition);
         setupTransactionQueue();
         registerRecentTasksListener(mRecentTasksListener);
@@ -269,24 +288,52 @@ public class SystemUiProxy implements ISystemUiProxy {
         setDesktopTaskListener(mDesktopTaskListener);
         setAssistantOverridesRequested(
                 AssistUtils.newInstance(mContext).getSysUiAssistOverrideInvocationTypes());
+        mStateChangeCallbacks.forEach(Runnable::run);
+
+        if (mUnfoldTransitionProvider != null) {
+            if (unfoldAnimation != null) {
+                try {
+                    unfoldAnimation.setListener(mUnfoldTransitionProvider);
+                    mUnfoldTransitionProvider.setActive(true);
+                } catch (RemoteException e) {
+                    // Ignore
+                }
+            } else {
+                mUnfoldTransitionProvider.setActive(false);
+            }
+        }
     }
 
     /**
-     * Clear the proxy to release held resources and turn the majority of its
-     * operations into no-ops
+     * Clear the proxy to release held resources and turn the majority of its operations into no-ops
      */
     @MainThread
     public void clearProxy() {
         setProxy(null, null, null, null, null, null, null, null, null, null, null, null, null);
     }
 
+    /**
+     * Adds a callback to be notified whenever the active state changes
+     */
+    public void addOnStateChangeListener(Runnable callback) {
+        mStateChangeCallbacks.add(callback);
+    }
+
+    /**
+     * Removes a previously added state change callback
+     */
+    public void removeOnStateChangeListener(Runnable callback) {
+        mStateChangeCallbacks.remove(callback);
+    }
+
     // TODO(141886704): Find a way to remove this
-    public void setLastSystemUiStateFlags(int stateFlags) {
+    public void setLastSystemUiStateFlags(@SystemUiStateFlags long stateFlags) {
         mLastSystemUiStateFlags = stateFlags;
     }
 
     // TODO(141886704): Find a way to remove this
-    public int getLastSystemUiStateFlags() {
+    @SystemUiStateFlags
+    public long getLastSystemUiStateFlags() {
         return mLastSystemUiStateFlags;
     }
 
@@ -326,17 +373,6 @@ public class SystemUiProxy implements ISystemUiProxy {
         onOverviewShown(fromHome, TAG);
     }
 
-    @Override
-    public void onStatusBarTouchEvent(MotionEvent event) {
-        if (mSystemUiProxy != null) {
-            try {
-                mSystemUiProxy.onStatusBarTouchEvent(event);
-            } catch (RemoteException e) {
-                Log.w(TAG, "Failed call onStatusBarTouchEvent", e);
-            }
-        }
-    }
-
     public void onOverviewShown(boolean fromHome, String tag) {
         if (mSystemUiProxy != null) {
             try {
@@ -348,6 +384,29 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     @MainThread
+    @Override
+    public void onStatusBarTouchEvent(MotionEvent event) {
+        Preconditions.assertUIThread();
+        if (mSystemUiProxy != null) {
+            try {
+                mSystemUiProxy.onStatusBarTouchEvent(event);
+            } catch (RemoteException e) {
+                Log.w(TAG, "Failed call onStatusBarTouchEvent with arg: " + event, e);
+            }
+        }
+    }
+
+    @Override
+    public void onStatusBarTrackpadEvent(MotionEvent event) {
+        if (mSystemUiProxy != null) {
+            try {
+                mSystemUiProxy.onStatusBarTrackpadEvent(event);
+            } catch (RemoteException e) {
+                Log.w(TAG, "Failed call onStatusBarTrackpadEvent with arg: " + event, e);
+            }
+        }
+    }
+
     @Override
     public void onAssistantProgress(float progress) {
         if (mSystemUiProxy != null) {
@@ -370,11 +429,6 @@ public class SystemUiProxy implements ISystemUiProxy {
         }
     }
 
-    @Override
-    public Rect getNonMinimizedSplitScreenSecondaryBounds() {
-        return null;
-    }
-
     @Override
     public void startAssistant(Bundle args) {
         if (mSystemUiProxy != null) {
@@ -398,15 +452,26 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     @Override
-    public Bundle monitorGestureInput(String name, int displayId) {
+    public void animateNavBarLongPress(boolean isTouchDown, boolean shrink, long durationMs) {
         if (mSystemUiProxy != null) {
             try {
-                return mSystemUiProxy.monitorGestureInput(name, displayId);
+                mSystemUiProxy.animateNavBarLongPress(isTouchDown, shrink, durationMs);
             } catch (RemoteException e) {
-                Log.w(TAG, "Failed call monitorGestureInput: " + name, e);
+                Log.w(TAG, "Failed call animateNavBarLongPress", e);
+            }
+        }
+    }
+
+    @Override
+    public void setOverrideHomeButtonLongPress(long duration, float slopMultiplier,
+                                               boolean haptic) {
+        if (mSystemUiProxy != null) {
+            try {
+                mSystemUiProxy.setOverrideHomeButtonLongPress(duration, slopMultiplier, haptic);
+            } catch (RemoteException e) {
+                Log.w(TAG, "Failed call setOverrideHomeButtonLongPress", e);
             }
         }
-        return null;
     }
 
     @Override
@@ -453,6 +518,7 @@ public class SystemUiProxy implements ISystemUiProxy {
         }
     }
 
+    @Override
     public void notifyTaskbarStatus(boolean visible, boolean stashed) {
         if (mSystemUiProxy != null) {
             try {
@@ -466,9 +532,7 @@ public class SystemUiProxy implements ISystemUiProxy {
 
     /**
      * NOTE: If called to suspend, caller MUST call this method to also un-suspend
-     * 
-     * @param suspend should be true to stop auto-hide, false to resume normal
-     *                behavior
+     * @param suspend should be true to stop auto-hide, false to resume normal behavior
      */
     @Override
     public void notifyTaskbarAutohideSuspend(boolean suspend) {
@@ -493,40 +557,6 @@ public class SystemUiProxy implements ISystemUiProxy {
         }
     }
 
-    @Override
-    public void handleImageBundleAsScreenshot(Bundle screenImageBundle, Rect locationInScreen,
-                                              Insets visibleInsets, Task.TaskKey task) {
-        if (mSystemUiProxy != null) {
-            try {
-                mSystemUiProxy.handleImageBundleAsScreenshot(screenImageBundle, locationInScreen,
-                        visibleInsets, task);
-            } catch (RemoteException e) {
-                Log.w(TAG, "Failed call handleImageBundleAsScreenshot");
-            }
-        }
-    }
-
-    public void handleImageAsScreenshot(Bitmap bitmap, Rect rect, Insets insets, int i) {
-        if (mSystemUiProxy != null) {
-            try {
-                mSystemUiProxy.handleImageAsScreenshot(bitmap, rect, insets, i);
-            } catch (RemoteException e) {
-                Log.w(TAG, "Failed call handleImageAsScreenshot", e);
-            }
-        }
-    }
-
-    @Override
-    public void onStatusBarTrackpadEvent(MotionEvent event)  {
-        if (mSystemUiProxy != null) {
-            try {
-                mSystemUiProxy.onStatusBarTrackpadEvent(event);
-            } catch (RemoteException e) {
-                Log.w(TAG, "Failed call onStatusBarTrackpadEvent");
-            }
-        }
-    }
-
     @Override
     public void expandNotificationPanel() {
         if (mSystemUiProxy != null) {
@@ -549,6 +579,17 @@ public class SystemUiProxy implements ISystemUiProxy {
         }
     }
 
+    @Override
+    public void toggleQuickSettingsPanel() {
+        if (mSystemUiProxy != null) {
+            try {
+                mSystemUiProxy.toggleQuickSettingsPanel();
+            } catch (RemoteException e) {
+                Log.w(TAG, "Failed call toggleQuickSettingsPanel", e);
+            }
+        }
+    }
+
     //
     // Pip
     //
@@ -558,7 +599,7 @@ public class SystemUiProxy implements ISystemUiProxy {
      */
     public void setShelfHeight(boolean visible, int shelfHeight) {
         Message.obtain(mAsyncHandler, MSG_SET_SHELF_HEIGHT,
-                visible ? 1 : 0, shelfHeight).sendToTarget();
+                visible ? 1 : 0 , shelfHeight).sendToTarget();
     }
 
     @WorkerThread
@@ -566,7 +607,7 @@ public class SystemUiProxy implements ISystemUiProxy {
         boolean visible = visibleInt != 0;
         boolean changed = visible != mLastShelfVisible || shelfHeight != mLastShelfHeight;
         IPip pip = mPip;
-        if (pip != null && changed && Utilities.ATLEAST_T) {
+        if (pip != null && changed) {
             mLastShelfVisible = visible;
             mLastShelfHeight = shelfHeight;
             try {
@@ -583,10 +624,8 @@ public class SystemUiProxy implements ISystemUiProxy {
      * the Launcher for the Hotseat.
      */
     public void setLauncherKeepClearAreaHeight(boolean visible, int height) {
-        if (Utilities.ATLEAST_T) {
-            Message.obtain(mAsyncHandler, MSG_SET_LAUNCHER_KEEP_CLEAR_AREA_HEIGHT,
-                    visible ? 1 : 0, height).sendToTarget();
-        }
+        Message.obtain(mAsyncHandler, MSG_SET_LAUNCHER_KEEP_CLEAR_AREA_HEIGHT,
+                visible ? 1 : 0 , height).sendToTarget();
     }
 
     @WorkerThread
@@ -611,7 +650,7 @@ public class SystemUiProxy implements ISystemUiProxy {
      * Sets listener to get pip animation callbacks.
      */
     public void setPipAnimationListener(IPipAnimationListener listener) {
-        if (mPip != null && Utilities.ATLEAST_T) {
+        if (mPip != null) {
             try {
                 mPip.setPipAnimationListener(listener);
             } catch (RemoteException e) {
@@ -622,41 +661,34 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     /**
-     * @return Destination bounds of auto-pip animation, {@code null} if the
-     *         animation is not ready.
+     * @return Destination bounds of auto-pip animation, {@code null} if the animation is not ready.
      */
     @Nullable
     public Rect startSwipePipToHome(ComponentName componentName, ActivityInfo activityInfo,
-            PictureInPictureParams pictureInPictureParams, int launcherRotation, int hotseatBarSize,
-            Rect hotseatKeepClearArea) {
+                                    PictureInPictureParams pictureInPictureParams, int launcherRotation,
+                                    Rect hotseatKeepClearArea) {
         if (mPip != null) {
             try {
                 return mPip.startSwipePipToHome(componentName, activityInfo,
-                        pictureInPictureParams, launcherRotation, new PipData(hotseatBarSize));
-            } catch (Throwable e) {
-                try {
-                    return mPip.startSwipePipToHome(componentName, activityInfo,
-                            pictureInPictureParams, launcherRotation, new PipData(hotseatKeepClearArea));
-                } catch (Throwable t) {
-                    Log.w(TAG, "Failed call startSwipePipToHome", e);
-                }
+                        pictureInPictureParams, launcherRotation, hotseatKeepClearArea);
+            } catch (RemoteException e) {
+                Log.w(TAG, "Failed call startSwipePipToHome", e);
             }
         }
         return null;
     }
 
     /**
-     * Notifies WM Shell that launcher has finished the preparation of the animation
-     * for swipe to
-     * home. WM Shell can choose to fade out the overlay when entering PIP is
-     * finished, and WM Shell
+     * Notifies WM Shell that launcher has finished the preparation of the animation for swipe to
+     * home. WM Shell can choose to fade out the overlay when entering PIP is finished, and WM Shell
      * should be responsible for cleaning up the overlay.
      */
     public void stopSwipePipToHome(int taskId, ComponentName componentName, Rect destinationBounds,
-            SurfaceControl overlay) {
+                                   SurfaceControl overlay, Rect appBounds, Rect sourceRectHint) {
         if (mPip != null) {
             try {
-                mPip.stopSwipePipToHome(taskId, componentName, destinationBounds, overlay);
+                mPip.stopSwipePipToHome(taskId, componentName, destinationBounds, overlay,
+                        appBounds, sourceRectHint);
             } catch (RemoteException e) {
                 Log.w(TAG, "Failed call stopSwipePipToHome");
             }
@@ -664,8 +696,7 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     /**
-     * Notifies WM Shell that launcher has aborted all the animation for swipe to
-     * home. WM Shell
+     * Notifies WM Shell that launcher has aborted all the animation for swipe to home. WM Shell
      * can use this callback to clean up its internal states.
      */
     public void abortSwipePipToHome(int taskId, ComponentName componentName) {
@@ -682,16 +713,12 @@ public class SystemUiProxy implements ISystemUiProxy {
      * Sets the next pip animation type to be the alpha animation.
      */
     public void setPipAnimationTypeToAlpha() {
-        try {
-            if (mPip != null) {
-                try {
-                    mPip.setPipAnimationTypeToAlpha();
-                } catch (RemoteException e) {
-                    Log.w(TAG, "Failed call setPipAnimationTypeToAlpha", e);
-                }
+        if (mPip != null) {
+            try {
+                mPip.setPipAnimationTypeToAlpha();
+            } catch (RemoteException e) {
+                Log.w(TAG, "Failed call setPipAnimationTypeToAlpha", e);
             }
-        } catch (Throwable t) {
-            Log.w(TAG, "Failed call setPipAnimationTypeToAlpha not supported", t);
         }
     }
 
@@ -699,7 +726,7 @@ public class SystemUiProxy implements ISystemUiProxy {
      * Sets the app icon size in pixel used by Launcher all apps.
      */
     public void setLauncherAppIconSize(int iconSizePx) {
-        if (mPip != null && Utilities.ATLEAST_T) {
+        if (mPip != null) {
             try {
                 mPip.setLauncherAppIconSize(iconSizePx);
             } catch (RemoteException e) {
@@ -734,46 +761,24 @@ public class SystemUiProxy implements ISystemUiProxy {
 
     /**
      * Tells SysUI to show the bubble with the provided key.
-     * 
-     * @param key              the key of the bubble to show.
-     * @param bubbleBarOffsetX the offset of the bubble bar from the edge of the
-     *                         screen on the X
-     *                         axis.
-     * @param bubbleBarOffsetY the offset of the bubble bar from the edge of the
-     *                         screen on the Y
-     *                         axis.
+     * @param key the key of the bubble to show.
+     * @param top top coordinate of bubble bar on screen
      */
-    public void showBubble(String key, int bubbleBarOffsetX, int bubbleBarOffsetY) {
+    public void showBubble(String key, int top) {
         if (mBubbles != null) {
             try {
-                mBubbles.showBubble(key, bubbleBarOffsetX, bubbleBarOffsetY);
+                mBubbles.showBubble(key, top);
             } catch (RemoteException e) {
                 Log.w(TAG, "Failed call showBubble");
             }
         }
     }
 
-    /**
-     * Tells SysUI to remove the bubble with the provided key.
-     * 
-     * @param key the key of the bubble to show.
-     */
-    public void removeBubble(String key) {
-        if (mBubbles == null)
-            return;
-        try {
-            mBubbles.removeBubble(key);
-        } catch (RemoteException e) {
-            Log.w(TAG, "Failed call removeBubble");
-        }
-    }
-
     /**
      * Tells SysUI to remove all bubbles.
      */
     public void removeAllBubbles() {
-        if (mBubbles == null)
-            return;
+        if (mBubbles == null) return;
         try {
             mBubbles.removeAllBubbles();
         } catch (RemoteException e) {
@@ -797,17 +802,82 @@ public class SystemUiProxy implements ISystemUiProxy {
     /**
      * Tells SysUI when the bubble is being dragged.
      * Should be called only when the bubble bar is expanded.
-     * 
-     * @param bubbleKey      the key of the bubble to collapse/expand
-     * @param isBeingDragged whether the bubble is being dragged
+     * @param bubbleKey key of the bubble being dragged
      */
-    public void onBubbleDrag(@Nullable String bubbleKey, boolean isBeingDragged) {
-        if (mBubbles == null)
-            return;
+    public void startBubbleDrag(@Nullable String bubbleKey) {
+        if (mBubbles == null) return;
         try {
-            mBubbles.onBubbleDrag(bubbleKey, isBeingDragged);
+            mBubbles.startBubbleDrag(bubbleKey);
         } catch (RemoteException e) {
-            Log.w(TAG, "Failed call onBubbleDrag");
+            Log.w(TAG, "Failed call startBubbleDrag");
+        }
+    }
+
+    /**
+     * Tells SysUI when the bubble stops being dragged.
+     * Should be called only when the bubble bar is expanded.
+     *
+     * @param location location of the bubble bar
+     * @param top      new top coordinate for bubble bar on screen
+     */
+    public void stopBubbleDrag(BubbleBarLocation location, int top) {
+        if (mBubbles == null) return;
+        try {
+            mBubbles.stopBubbleDrag(location, top);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed call stopBubbleDrag");
+        }
+    }
+
+    /**
+     * Tells SysUI to dismiss the bubble with the provided key.
+     * @param key the key of the bubble to dismiss.
+     */
+    public void dragBubbleToDismiss(String key) {
+        if (mBubbles == null) return;
+        try {
+            mBubbles.dragBubbleToDismiss(key);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed call dragBubbleToDismiss");
+        }
+    }
+
+    /**
+     * Tells SysUI to show user education relative to the reference point provided.
+     * @param position the bubble bar top center position in Screen coordinates.
+     */
+    public void showUserEducation(Point position) {
+        try {
+            mBubbles.showUserEducation(position.x, position.y);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed call showUserEducation");
+        }
+    }
+
+    /**
+     * Tells SysUI to update the bubble bar location to the new location.
+     * @param location new location for the bubble bar
+     */
+    public void setBubbleBarLocation(BubbleBarLocation location) {
+        try {
+            mBubbles.setBubbleBarLocation(location);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed call setBubbleBarLocation");
+        }
+    }
+
+    /**
+     * Tells SysUI the top coordinate of bubble bar on screen
+     *
+     * @param topOnScreen top coordinate for bubble bar on screen
+     */
+    public void updateBubbleBarTopOnScreen(int topOnScreen) {
+        try {
+            if (mBubbles != null) {
+                mBubbles.updateBubbleBarTopOnScreen(topOnScreen);
+            }
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed call updateBubbleBarTopOnScreen");
         }
     }
 
@@ -816,18 +886,14 @@ public class SystemUiProxy implements ISystemUiProxy {
     //
 
     public void registerSplitScreenListener(ISplitScreenListener listener) {
-        try {
-            if (mSplitScreen != null) {
-                try {
-                    mSplitScreen.registerSplitScreenListener(listener);
-                } catch (RemoteException e) {
-                    Log.w(TAG, "Failed call registerSplitScreenListener");
-                }
+        if (mSplitScreen != null) {
+            try {
+                mSplitScreen.registerSplitScreenListener(listener);
+            } catch (RemoteException e) {
+                Log.w(TAG, "Failed call registerSplitScreenListener");
             }
-            mSplitScreenListener = listener;
-        } catch (Throwable t) {
-            Log.w (TAG , "Not supported: " , t);
         }
+        mSplitScreenListener = listener;
     }
 
     public void unregisterSplitScreenListener(ISplitScreenListener listener) {
@@ -865,12 +931,12 @@ public class SystemUiProxy implements ISystemUiProxy {
 
     /** Start multiple tasks in split-screen simultaneously. */
     public void startTasks(int taskId1, Bundle options1, int taskId2, Bundle options2,
-            @SplitConfigurationOptions.StagePosition int splitPosition, float splitRatio,
-            RemoteTransition remoteTransition, InstanceId instanceId) {
+                           @StagePosition int splitPosition, @PersistentSnapPosition int snapPosition,
+                           RemoteTransition remoteTransition, InstanceId instanceId) {
         if (mSystemUiProxy != null) {
             try {
                 mSplitScreen.startTasks(taskId1, options1, taskId2, options2, splitPosition,
-                        splitRatio, remoteTransition, instanceId);
+                        snapPosition, remoteTransition, instanceId);
             } catch (RemoteException e) {
                 Log.w(TAG, splitFailureMessage("startTasks", "RemoteException"), e);
             }
@@ -878,12 +944,13 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     public void startIntentAndTask(PendingIntent pendingIntent, int userId1, Bundle options1,
-            int taskId, Bundle options2, @SplitConfigurationOptions.StagePosition int splitPosition,
-            float splitRatio, RemoteTransition remoteTransition, InstanceId instanceId) {
+                                   int taskId, Bundle options2, @StagePosition int splitPosition,
+                                   @PersistentSnapPosition int snapPosition, RemoteTransition remoteTransition,
+                                   InstanceId instanceId) {
         if (mSystemUiProxy != null) {
             try {
                 mSplitScreen.startIntentAndTask(pendingIntent, userId1, options1, taskId, options2,
-                        splitPosition, splitRatio, remoteTransition, instanceId);
+                        splitPosition, snapPosition, remoteTransition, instanceId);
             } catch (RemoteException e) {
                 Log.w(TAG, splitFailureMessage("startIntentAndTask", "RemoteException"), e);
             }
@@ -891,15 +958,15 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     public void startIntents(PendingIntent pendingIntent1, int userId1,
-            @Nullable ShortcutInfo shortcutInfo1, Bundle options1, PendingIntent pendingIntent2,
-            int userId2, @Nullable ShortcutInfo shortcutInfo2, Bundle options2,
-            @SplitConfigurationOptions.StagePosition int splitPosition, float splitRatio,
-            RemoteTransition remoteTransition, InstanceId instanceId) {
+                             @Nullable ShortcutInfo shortcutInfo1, Bundle options1, PendingIntent pendingIntent2,
+                             int userId2, @Nullable ShortcutInfo shortcutInfo2, Bundle options2,
+                             @StagePosition int splitPosition, @PersistentSnapPosition int snapPosition,
+                             RemoteTransition remoteTransition, InstanceId instanceId) {
         if (mSystemUiProxy != null) {
             try {
                 mSplitScreen.startIntents(pendingIntent1, userId1, shortcutInfo1, options1,
-                        pendingIntent2, userId2, shortcutInfo2, options2, splitPosition, splitRatio,
-                        remoteTransition, instanceId);
+                        pendingIntent2, userId2, shortcutInfo2, options2, splitPosition,
+                        snapPosition, remoteTransition, instanceId);
             } catch (RemoteException e) {
                 Log.w(TAG, splitFailureMessage("startIntents", "RemoteException"), e);
             }
@@ -907,12 +974,13 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     public void startShortcutAndTask(ShortcutInfo shortcutInfo, Bundle options1, int taskId,
-            Bundle options2, @SplitConfigurationOptions.StagePosition int splitPosition,
-            float splitRatio, RemoteTransition remoteTransition, InstanceId instanceId) {
+                                     Bundle options2, @StagePosition int splitPosition,
+                                     @PersistentSnapPosition int snapPosition, RemoteTransition remoteTransition,
+                                     InstanceId instanceId) {
         if (mSystemUiProxy != null) {
             try {
                 mSplitScreen.startShortcutAndTask(shortcutInfo, options1, taskId, options2,
-                        splitPosition, splitRatio, remoteTransition, instanceId);
+                        splitPosition, snapPosition, remoteTransition, instanceId);
             } catch (RemoteException e) {
                 Log.w(TAG, splitFailureMessage("startShortcutAndTask", "RemoteException"), e);
             }
@@ -923,12 +991,13 @@ public class SystemUiProxy implements ISystemUiProxy {
      * Start multiple tasks in split-screen simultaneously.
      */
     public void startTasksWithLegacyTransition(int taskId1, Bundle options1, int taskId2,
-            Bundle options2, @SplitConfigurationOptions.StagePosition int splitPosition,
-            float splitRatio, RemoteAnimationAdapter adapter, InstanceId instanceId) {
-        if (mSystemUiProxy != null && Utilities.ATLEAST_T) {
+                                               Bundle options2, @StagePosition int splitPosition,
+                                               @PersistentSnapPosition int snapPosition, RemoteAnimationAdapter adapter,
+                                               InstanceId instanceId) {
+        if (mSystemUiProxy != null) {
             try {
                 mSplitScreen.startTasksWithLegacyTransition(taskId1, options1, taskId2, options2,
-                        splitPosition, splitRatio, adapter, instanceId);
+                        splitPosition, snapPosition, adapter, instanceId);
             } catch (RemoteException e) {
                 Log.w(TAG, splitFailureMessage(
                         "startTasksWithLegacyTransition", "RemoteException"), e);
@@ -937,13 +1006,14 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     public void startIntentAndTaskWithLegacyTransition(PendingIntent pendingIntent, int userId1,
-            Bundle options1, int taskId, Bundle options2,
-            @SplitConfigurationOptions.StagePosition int splitPosition, float splitRatio,
-            RemoteAnimationAdapter adapter, InstanceId instanceId) {
+                                                       Bundle options1, int taskId, Bundle options2, @StagePosition int splitPosition,
+                                                       @PersistentSnapPosition int snapPosition, RemoteAnimationAdapter adapter,
+                                                       InstanceId instanceId) {
         if (mSystemUiProxy != null) {
             try {
                 mSplitScreen.startIntentAndTaskWithLegacyTransition(pendingIntent, userId1,
-                        options1, taskId, options2, splitPosition, splitRatio, adapter, instanceId);
+                        options1, taskId, options2, splitPosition, snapPosition, adapter,
+                        instanceId);
             } catch (RemoteException e) {
                 Log.w(TAG, splitFailureMessage(
                         "startIntentAndTaskWithLegacyTransition", "RemoteException"), e);
@@ -952,12 +1022,13 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     public void startShortcutAndTaskWithLegacyTransition(ShortcutInfo shortcutInfo, Bundle options1,
-            int taskId, Bundle options2, @SplitConfigurationOptions.StagePosition int splitPosition,
-            float splitRatio, RemoteAnimationAdapter adapter, InstanceId instanceId) {
+                                                         int taskId, Bundle options2, @StagePosition int splitPosition,
+                                                         @PersistentSnapPosition int snapPosition, RemoteAnimationAdapter adapter,
+                                                         InstanceId instanceId) {
         if (mSystemUiProxy != null) {
             try {
                 mSplitScreen.startShortcutAndTaskWithLegacyTransition(shortcutInfo, options1,
-                        taskId, options2, splitPosition, splitRatio, adapter, instanceId);
+                        taskId, options2, splitPosition, snapPosition, adapter, instanceId);
             } catch (RemoteException e) {
                 Log.w(TAG, splitFailureMessage(
                         "startShortcutAndTaskWithLegacyTransition", "RemoteException"), e);
@@ -966,20 +1037,20 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     /**
-     * Starts a pair of intents or shortcuts in split-screen using legacy
-     * transition. Passing a
+     * Starts a pair of intents or shortcuts in split-screen using legacy transition. Passing a
      * non-null shortcut info means to start the app as a shortcut.
      */
     public void startIntentsWithLegacyTransition(PendingIntent pendingIntent1, int userId1,
-            @Nullable ShortcutInfo shortcutInfo1, @Nullable Bundle options1,
-            PendingIntent pendingIntent2, int userId2, @Nullable ShortcutInfo shortcutInfo2,
-            @Nullable Bundle options2, @SplitConfigurationOptions.StagePosition int sidePosition,
-            float splitRatio, RemoteAnimationAdapter adapter, InstanceId instanceId) {
+                                                 @Nullable ShortcutInfo shortcutInfo1, @Nullable Bundle options1,
+                                                 PendingIntent pendingIntent2, int userId2, @Nullable ShortcutInfo shortcutInfo2,
+                                                 @Nullable Bundle options2, @StagePosition int sidePosition,
+                                                 @PersistentSnapPosition int snapPosition, RemoteAnimationAdapter adapter,
+                                                 InstanceId instanceId) {
         if (mSystemUiProxy != null) {
             try {
                 mSplitScreen.startIntentsWithLegacyTransition(pendingIntent1, userId1,
                         shortcutInfo1, options1, pendingIntent2, userId2, shortcutInfo2, options2,
-                        sidePosition, splitRatio, adapter, instanceId);
+                        sidePosition, snapPosition, adapter, instanceId);
             } catch (RemoteException e) {
                 Log.w(TAG, splitFailureMessage(
                         "startIntentsWithLegacyTransition", "RemoteException"), e);
@@ -988,7 +1059,7 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     public void startShortcut(String packageName, String shortcutId, int position,
-            Bundle options, UserHandle user, InstanceId instanceId) {
+                              Bundle options, UserHandle user, InstanceId instanceId) {
         if (mSplitScreen != null) {
             try {
                 mSplitScreen.startShortcut(packageName, shortcutId, position, options,
@@ -1000,7 +1071,7 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     public void startIntent(PendingIntent intent, int userId, Intent fillInIntent, int position,
-            Bundle options, InstanceId instanceId) {
+                            Bundle options, InstanceId instanceId) {
         if (mSplitScreen != null) {
             try {
                 mSplitScreen.startIntent(intent, userId, fillInIntent, position, options,
@@ -1022,12 +1093,10 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     /**
-     * Call this when going to recents so that shell can set-up and provide
-     * appropriate leashes
+     * Call this when going to recents so that shell can set-up and provide appropriate leashes
      * for animation (eg. DividerBar).
      *
-     * @return RemoteAnimationTargets of windows that need to animate but only exist
-     *         in shell.
+     * @return RemoteAnimationTargets of windows that need to animate but only exist in shell.
      */
     @Nullable
     public RemoteAnimationTarget[] onGoingToRecentsLegacy(RemoteAnimationTarget[] apps) {
@@ -1046,7 +1115,7 @@ public class SystemUiProxy implements ISystemUiProxy {
         if (mSplitScreen != null) {
             try {
                 return mSplitScreen.onStartingSplitLegacy(apps);
-            } catch (Throwable e) {
+            } catch (RemoteException e) {
                 Log.w(TAG, "Failed call onStartingSplitLegacy");
             }
         }
@@ -1106,11 +1175,32 @@ public class SystemUiProxy implements ISystemUiProxy {
         mRemoteTransitions.remove(remoteTransition);
     }
 
+    public HomeVisibilityState getHomeVisibilityState() {
+        return mHomeVisibilityState;
+    }
+
     /**
-     * Use SystemUI's transaction-queue instead of Launcher's independent one. This
-     * is necessary
-     * if Launcher and SystemUI need to coordinate transactions (eg. for shell
-     * transitions).
+     * Returns a surface which can be used to attach overlays to home task or null if
+     * the task doesn't exist or sysui is not connected
+     */
+    @Nullable
+    public SurfaceControl getHomeTaskOverlayContainer() {
+        // Use a local reference as this method can be called on a worker thread, which can lead
+        // to NullPointer exceptions if mShellTransitions is modified on the main thread.
+        IShellTransitions shellTransitions = mShellTransitions;
+        if (shellTransitions != null) {
+            try {
+                return mShellTransitions.getHomeTaskOverlayContainer();
+            } catch (RemoteException e) {
+                Log.w(TAG, "Failed call getOverlayContainerForTask", e);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Use SystemUI's transaction-queue instead of Launcher's independent one. This is necessary
+     * if Launcher and SystemUI need to coordinate transactions (eg. for shell transitions).
      */
     public void shareTransactionQueue() {
         if (mOriginalTransactionToken == null) {
@@ -1175,20 +1265,17 @@ public class SystemUiProxy implements ISystemUiProxy {
     //
 
     /**
-     * Sets the instance of {@link ILauncherUnlockAnimationController} that System
-     * UI should use to
-     * control the launcher side of the unlock animation. This will also cause us to
-     * dispatch the
-     * current state of the smartspace to System UI (this will subsequently happen
-     * if the state
+     * Sets the instance of {@link ILauncherUnlockAnimationController} that System UI should use to
+     * control the launcher side of the unlock animation. This will also cause us to dispatch the
+     * current state of the smartspace to System UI (this will subsequently happen if the state
      * changes).
      */
     public void setLauncherUnlockAnimationController(
-            ILauncherUnlockAnimationController controller) {
+            String activityClass, ILauncherUnlockAnimationController controller) {
         if (mSysuiUnlockAnimationController != null) {
             try {
-                mSysuiUnlockAnimationController.setLauncherUnlockController(controller);
-
+                mSysuiUnlockAnimationController.setLauncherUnlockController(
+                        activityClass, controller);
                 if (controller != null) {
                     controller.dispatchSmartspaceStateToSysui();
                 }
@@ -1196,13 +1283,12 @@ public class SystemUiProxy implements ISystemUiProxy {
                 Log.w(TAG, "Failed call setLauncherUnlockAnimationController", e);
             }
         }
-
+        mLauncherActivityClass = activityClass;
         mLauncherUnlockAnimationController = controller;
     }
 
     /**
-     * Tells System UI that the Launcher's smartspace state has been updated, so
-     * that it can prepare
+     * Tells System UI that the Launcher's smartspace state has been updated, so that it can prepare
      * the unlock animation accordingly.
      */
     public void notifySysuiSmartspaceStateUpdated(SmartspaceState state) {
@@ -1248,7 +1334,7 @@ public class SystemUiProxy implements ISystemUiProxy {
 
     /** Sets the launcher {@link android.window.IOnBackInvokedCallback} to shell */
     public void setBackToLauncherCallback(IOnBackInvokedCallback callback,
-            IRemoteAnimationRunner runner) {
+                                          IRemoteAnimationRunner runner) {
         mBackToLauncherCallback = callback;
         mBackToLauncherRunner = runner;
         if (mBackAnimation == null || mBackToLauncherCallback == null) {
@@ -1256,13 +1342,12 @@ public class SystemUiProxy implements ISystemUiProxy {
         }
         try {
             mBackAnimation.setBackToLauncherCallback(callback, runner);
-        } catch (RemoteException e) {
+        } catch (RemoteException | SecurityException e) {
             Log.e(TAG, "Failed call setBackToLauncherCallback", e);
         }
     }
 
-    /**
-     * Clears the previously registered {@link IOnBackInvokedCallback}.
+    /** Clears the previously registered {@link IOnBackInvokedCallback}.
      *
      * @param callback The previously registered callback instance.
      */
@@ -1297,34 +1382,28 @@ public class SystemUiProxy implements ISystemUiProxy {
     }
 
     public ArrayList<GroupedRecentTaskInfo> getRecentTasks(int numTasks, int userId) {
-        if (!LawnchairQuickstepCompat.ATLEAST_U) {
-            return getRecentTasksFromWrapper(numTasks, userId);
+        if (mRecentTasks == null) {
+            Log.w(TAG, "getRecentTasks() failed due to null mRecentTasks");
+            return new ArrayList<>();
         }
         try {
-            if (mRecentTasks != null) {
-                final GroupedRecentTaskInfo[] rawTasks = mRecentTasks.getRecentTasks(numTasks,
-                        RECENT_IGNORE_UNAVAILABLE, userId);
-                return new ArrayList<>(Arrays.asList(rawTasks));
+            final GroupedRecentTaskInfo[] rawTasks = mRecentTasks.getRecentTasks(numTasks,
+                    RECENT_IGNORE_UNAVAILABLE, userId);
+            if (rawTasks == null) {
+                return new ArrayList<>();
             }
-        } catch (Throwable t) {
-            Log.w(TAG, "Failed call getRecentTasks ,may be android 13- ", t);
-            return getRecentTasksFromWrapper(numTasks, userId);
+            return new ArrayList<>(Arrays.asList(rawTasks));
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed call getRecentTasks", e);
+            return new ArrayList<>();
         }
-        return new ArrayList<>();
-    }
-
-    private ArrayList<GroupedRecentTaskInfo> getRecentTasksFromWrapper(int numTasks, int userId) {
-        List<ActivityManager.RecentTaskInfo> recentTaskInfoList = ActivityManagerWrapper.getInstance().getRecentTasks(numTasks, userId);
-        return recentTaskInfoList.stream()
-                .map(GroupedRecentTaskInfo::forSingleTask)
-                .collect(Collectors.toCollection(ArrayList::new));
     }
 
     /**
      * Gets the set of running tasks.
      */
     public ArrayList<ActivityManager.RunningTaskInfo> getRunningTasks(int numTasks) {
-        if (mRecentTasks != null) {
+        if (mRecentTasks != null && shouldEnableRunningTasksForDesktopMode()) {
             try {
                 return new ArrayList<>(Arrays.asList(mRecentTasks.getRunningTasks(numTasks)));
             } catch (RemoteException e) {
@@ -1334,6 +1413,11 @@ public class SystemUiProxy implements ISystemUiProxy {
         return new ArrayList<>();
     }
 
+    private boolean shouldEnableRunningTasksForDesktopMode() {
+        // TODO(b/335401172): unify DesktopMode checks in Launcher
+        return enableDesktopWindowingMode() && enableDesktopWindowingTaskbarRunningApps();
+    }
+
     private boolean handleMessageAsync(Message msg) {
         switch (msg.what) {
             case MSG_SET_SHELF_HEIGHT:
@@ -1352,38 +1436,16 @@ public class SystemUiProxy implements ISystemUiProxy {
     //
 
     /** Call shell to show all apps active on the desktop */
-    public void showDesktopApps(int displayId) {
+    public void showDesktopApps(int displayId, @Nullable RemoteTransition transition) {
         if (mDesktopMode != null) {
             try {
-                mDesktopMode.showDesktopApps(displayId);
+                mDesktopMode.showDesktopApps(displayId, transition);
             } catch (RemoteException e) {
                 Log.w(TAG, "Failed call showDesktopApps", e);
             }
         }
     }
 
-    /** Call shell to stash desktop apps */
-    public void stashDesktopApps(int displayId) {
-        if (mDesktopMode != null) {
-            try {
-                mDesktopMode.stashDesktopApps(displayId);
-            } catch (RemoteException e) {
-                Log.w(TAG, "Failed call stashDesktopApps", e);
-            }
-        }
-    }
-
-    /** Call shell to hide desktop apps that may be stashed */
-    public void hideStashedDesktopApps(int displayId) {
-        if (mDesktopMode != null) {
-            try {
-                mDesktopMode.hideStashedDesktopApps(displayId);
-            } catch (RemoteException e) {
-                Log.w(TAG, "Failed call hideStashedDesktopApps", e);
-            }
-        }
-    }
-
     /**
      * If task with the given id is on the desktop, bring it to front
      */
@@ -1432,6 +1494,17 @@ public class SystemUiProxy implements ISystemUiProxy {
         }
     }
 
+    /** Call shell to move a task with given `taskId` to desktop  */
+    public void moveToDesktop(int taskId, DesktopModeTransitionSource transitionSource) {
+        if (mDesktopMode != null) {
+            try {
+                mDesktopMode.moveToDesktop(taskId, transitionSource);
+            } catch (RemoteException e) {
+                Log.w(TAG, "Failed call moveToDesktop", e);
+            }
+        }
+    }
+
     //
     // Unfold transition
     //
@@ -1450,48 +1523,36 @@ public class SystemUiProxy implements ISystemUiProxy {
         }
     }
 
+    @Nullable
+    public ProxyUnfoldTransitionProvider getUnfoldTransitionProvider() {
+        return mUnfoldTransitionProvider;
+    }
+
     //
     // Recents
     //
 
     /**
-     * Starts the recents activity. The caller should manage the thread on which
-     * this is called.
+     * Starts the recents activity. The caller should manage the thread on which this is called.
      */
     public boolean startRecentsActivity(Intent intent, ActivityOptions options,
-            RecentsAnimationListener listener) {
+                                        RecentsAnimationListener listener) {
         if (mRecentTasks == null) {
+            ActiveGestureLog.INSTANCE.addLog("Null mRecentTasks", RECENT_TASKS_MISSING);
             return false;
         }
         final IRecentsAnimationRunner runner = new IRecentsAnimationRunner.Stub() {
             @Override
-            public void onAnimationStart(IRecentsAnimationController controller,
-                    RemoteAnimationTarget[] apps, RemoteAnimationTarget[] wallpapers,
-                    Rect homeContentInsets, Rect minimizedHomeBounds) {
-                listener.onAnimationStart(new RecentsAnimationControllerCompat(controller), apps,
-                        wallpapers, homeContentInsets, minimizedHomeBounds);
-            }
-
-            // Android 14 QPR2
             public void onAnimationStart(IRecentsAnimationController controller,
                                          RemoteAnimationTarget[] apps, RemoteAnimationTarget[] wallpapers,
-                                         Rect homeContentInsets, Rect minimizedHomeBounds, Bundle bundle) {
+                                         Rect homeContentInsets, Rect minimizedHomeBounds, Bundle extras) {
+                // Aidl bundles need to explicitly set class loader
+                // https://developer.android.com/guide/components/aidl#Bundles
+                if (extras != null) {
+                    extras.setClassLoader(getClass().getClassLoader());
+                }
                 listener.onAnimationStart(new RecentsAnimationControllerCompat(controller), apps,
-                        wallpapers, homeContentInsets, minimizedHomeBounds);
-            }
-
-            // NothingOS with Android 14 2.5.5
-            public void onAnimationStartWithSurfaceTransaction(
-                    IRecentsAnimationController controller,
-                    TransitionInfo transitionInfo,
-                    SurfaceControl.Transaction transaction,
-                    RemoteAnimationTarget[] apps,
-                    RemoteAnimationTarget[] wallpapers,
-                    Rect homeContentInsets,
-                    Rect minimizedHomeBounds) {
-                listener.onAnimationStart(new RecentsAnimationControllerCompat(controller),
-                        transitionInfo, transaction, apps, wallpapers,
-                        homeContentInsets, minimizedHomeBounds);
+                        wallpapers, homeContentInsets, minimizedHomeBounds, extras);
             }
 
             @Override
@@ -1521,8 +1582,7 @@ public class SystemUiProxy implements ISystemUiProxy {
     //
 
     /**
-     * For testing purposes. Returns `true` only if the shell drop target has shown
-     * and
+     * For testing purposes.  Returns `true` only if the shell drop target has shown and
      * drawn and is ready to handle drag events and the subsequent drop.
      */
     public boolean isDragAndDropReady() {
@@ -1536,4 +1596,35 @@ public class SystemUiProxy implements ISystemUiProxy {
             return false;
         }
     }
+
+    public void dump(PrintWriter pw) {
+        pw.println(TAG + ":");
+
+        pw.println("\tmSystemUiProxy=" + mSystemUiProxy);
+        pw.println("\tmPip=" + mPip);
+        pw.println("\tmPipAnimationListener=" + mPipAnimationListener);
+        pw.println("\tmBubbles=" + mBubbles);
+        pw.println("\tmBubblesListener=" + mBubblesListener);
+        pw.println("\tmSplitScreen=" + mSplitScreen);
+        pw.println("\tmSplitScreenListener=" + mSplitScreenListener);
+        pw.println("\tmSplitSelectListener=" + mSplitSelectListener);
+        pw.println("\tmOneHanded=" + mOneHanded);
+        pw.println("\tmShellTransitions=" + mShellTransitions);
+        pw.println("\tmHomeVisibilityState=" + mHomeVisibilityState);
+        pw.println("\tmStartingWindow=" + mStartingWindow);
+        pw.println("\tmStartingWindowListener=" + mStartingWindowListener);
+        pw.println("\tmSysuiUnlockAnimationController=" + mSysuiUnlockAnimationController);
+        pw.println("\tmLauncherActivityClass=" + mLauncherActivityClass);
+        pw.println("\tmLauncherUnlockAnimationController=" + mLauncherUnlockAnimationController);
+        pw.println("\tmRecentTasks=" + mRecentTasks);
+        pw.println("\tmRecentTasksListener=" + mRecentTasksListener);
+        pw.println("\tmBackAnimation=" + mBackAnimation);
+        pw.println("\tmBackToLauncherCallback=" + mBackToLauncherCallback);
+        pw.println("\tmBackToLauncherRunner=" + mBackToLauncherRunner);
+        pw.println("\tmDesktopMode=" + mDesktopMode);
+        pw.println("\tmDesktopTaskListener=" + mDesktopTaskListener);
+        pw.println("\tmUnfoldAnimation=" + mUnfoldAnimation);
+        pw.println("\tmUnfoldAnimationListener=" + mUnfoldAnimationListener);
+        pw.println("\tmDragAndDrop=" + mDragAndDrop);
+    }
 }
diff --git a/quickstep/src/com/android/quickstep/TaskAnimationManager.java b/quickstep/src/com/android/quickstep/TaskAnimationManager.java
index 6c74e1716d..f209920e95 100644
--- a/quickstep/src/com/android/quickstep/TaskAnimationManager.java
+++ b/quickstep/src/com/android/quickstep/TaskAnimationManager.java
@@ -17,13 +17,17 @@ package com.android.quickstep;
 
 import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
 
+import static com.android.launcher3.Flags.enableHandleDelayedGestureCallbacks;
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 import static com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR;
 import static com.android.launcher3.util.NavigationMode.NO_BUTTON;
 import static com.android.quickstep.GestureState.GestureEndTarget.RECENTS;
+import static com.android.quickstep.GestureState.STATE_END_TARGET_ANIMATION_FINISHED;
 import static com.android.quickstep.GestureState.STATE_RECENTS_ANIMATION_INITIALIZED;
 import static com.android.quickstep.GestureState.STATE_RECENTS_ANIMATION_STARTED;
 import static com.android.quickstep.util.ActiveGestureErrorDetector.GestureEvent.START_RECENTS_ANIMATION;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_QUICK_SETTINGS_EXPANDED;
 
 import android.app.ActivityManager;
 import android.app.ActivityOptions;
@@ -32,32 +36,33 @@ import android.content.Intent;
 import android.os.SystemProperties;
 import android.util.Log;
 import android.view.RemoteAnimationTarget;
-import android.window.RemoteTransition;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.UiThread;
 
+import com.android.internal.util.ArrayUtils;
 import com.android.launcher3.Utilities;
 import com.android.launcher3.config.FeatureFlags;
-import com.android.launcher3.testing.shared.TestProtocol;
 import com.android.launcher3.util.DisplayController;
-import com.android.quickstep.TopTaskTracker.CachedTaskInfo;
 import com.android.quickstep.util.ActiveGestureLog;
-import com.android.quickstep.views.DesktopTaskView;
+import com.android.quickstep.util.SystemUiFlagUtils;
 import com.android.quickstep.views.RecentsView;
 import com.android.systemui.shared.recents.model.ThumbnailData;
 import com.android.systemui.shared.system.ActivityManagerWrapper;
+import com.android.systemui.shared.system.QuickStepContract;
 import com.android.systemui.shared.system.TaskStackChangeListener;
 import com.android.systemui.shared.system.TaskStackChangeListeners;
 
+import java.io.PrintWriter;
 import java.util.HashMap;
 
 public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAnimationListener {
-    public static final boolean ENABLE_SHELL_TRANSITIONS = SystemProperties.getBoolean("persist.wm.debug.shell_transit",
-            Utilities.ATLEAST_T);
+    public static final boolean ENABLE_SHELL_TRANSITIONS = true;
     public static final boolean SHELL_TRANSITIONS_ROTATION = ENABLE_SHELL_TRANSITIONS
             && SystemProperties.getBoolean("persist.wm.debug.shell_transit_rotate", false);
 
+    private final Context mCtx;
     private RecentsAnimationController mController;
     private RecentsAnimationCallbacks mCallbacks;
     private RecentsAnimationTargets mTargets;
@@ -65,22 +70,28 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
     private GestureState mLastGestureState;
     private RemoteAnimationTarget[] mLastAppearedTaskTargets;
     private Runnable mLiveTileCleanUpHandler;
-    private Context mCtx;
+
+    private boolean mRecentsAnimationStartPending = false;
+    private boolean mShouldIgnoreMotionEvents = false;
 
     private final TaskStackChangeListener mLiveTileRestartListener = new TaskStackChangeListener() {
         @Override
-        public void onActivityRestartAttempt(ActivityManager.RunningTaskInfo task, boolean homeTaskVisible,
-                boolean clearedTask, boolean wasVisible) {
+        public void onActivityRestartAttempt(ActivityManager.RunningTaskInfo task,
+                                             boolean homeTaskVisible, boolean clearedTask, boolean wasVisible) {
             if (mLastGestureState == null) {
-                TaskStackChangeListeners.getInstance().unregisterTaskStackListener(mLiveTileRestartListener);
+                TaskStackChangeListeners.getInstance().unregisterTaskStackListener(
+                        mLiveTileRestartListener);
                 return;
             }
-            BaseActivityInterface activityInterface = mLastGestureState.getActivityInterface();
-            if (activityInterface.isInLiveTileMode() && activityInterface.getCreatedActivity() != null) {
-                RecentsView recentsView = activityInterface.getCreatedActivity().getOverviewPanel();
+            BaseContainerInterface containerInterface = mLastGestureState.getContainerInterface();
+            if (containerInterface.isInLiveTileMode()
+                    && containerInterface.getCreatedContainer() != null) {
+                RecentsView recentsView = containerInterface.getCreatedContainer()
+                        .getOverviewPanel();
                 if (recentsView != null) {
                     recentsView.launchSideTaskInLiveTileModeForRestartedApp(task.taskId);
-                    TaskStackChangeListeners.getInstance().unregisterTaskStackListener(mLiveTileRestartListener);
+                    TaskStackChangeListeners.getInstance().unregisterTaskStackListener(
+                            mLiveTileRestartListener);
                 }
             }
         }
@@ -89,7 +100,6 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
     TaskAnimationManager(Context ctx) {
         mCtx = ctx;
     }
-
     /**
      * Preloads the recents animation.
      */
@@ -99,13 +109,24 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
                 .startRecentsActivity(intent, 0, null, null, null));
     }
 
+    boolean shouldIgnoreMotionEvents() {
+        return mShouldIgnoreMotionEvents;
+    }
+
+    void notifyNewGestureStart() {
+        // If mRecentsAnimationStartPending is true at the beginning of a gesture, block all motion
+        // events for this new gesture so that this new gesture does not interfere with the
+        // previously-requested recents animation. Otherwise, clean up mShouldIgnoreMotionEvents.
+        // NOTE: this can lead to misleading logs
+        mShouldIgnoreMotionEvents = mRecentsAnimationStartPending;
+    }
+
     /**
-     * Starts a new recents animation for the activity with the given
-     * {@param intent}.
+     * Starts a new recents animation for the activity with the given {@param intent}.
      */
     @UiThread
-    public RecentsAnimationCallbacks startRecentsAnimation(GestureState gestureState,
-            Intent intent, RecentsAnimationCallbacks.RecentsAnimationListener listener) {
+    public RecentsAnimationCallbacks startRecentsAnimation(@NonNull GestureState gestureState,
+                                                           Intent intent, RecentsAnimationCallbacks.RecentsAnimationListener listener) {
         ActiveGestureLog.INSTANCE.addLog(
                 /* event= */ "startRecentsAnimation",
                 /* gestureEvent= */ START_RECENTS_ANIMATION);
@@ -119,27 +140,31 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
             }
         }
         // But force-finish it anyways
-        finishRunningRecentsAnimation(false /* toHome */, true /* forceFinish */);
+        finishRunningRecentsAnimation(false /* toHome */, true /* forceFinish */,
+                null /* forceFinishCb */);
 
         if (mCallbacks != null) {
-            // If mCallbacks still != null, that means we are getting this
-            // startRecentsAnimation()
-            // before the previous one got onRecentsAnimationStart(). In that case, cleanup
-            // the
-            // previous animation so it doesn't mess up/listen to state changes in this
-            // animation.
+            // If mCallbacks still != null, that means we are getting this startRecentsAnimation()
+            // before the previous one got onRecentsAnimationStart(). In that case, cleanup the
+            // previous animation so it doesn't mess up/listen to state changes in this animation.
             cleanUpRecentsAnimation(mCallbacks);
         }
 
-        final BaseActivityInterface activityInterface = gestureState.getActivityInterface();
+        final BaseContainerInterface containerInterface = gestureState.getContainerInterface();
         mLastGestureState = gestureState;
         RecentsAnimationCallbacks newCallbacks = new RecentsAnimationCallbacks(
-                SystemUiProxy.INSTANCE.get(mCtx), activityInterface.allowMinimizeSplitScreen());
+                SystemUiProxy.INSTANCE.get(mCtx), containerInterface.allowMinimizeSplitScreen());
         mCallbacks = newCallbacks;
         mCallbacks.addListener(new RecentsAnimationCallbacks.RecentsAnimationListener() {
             @Override
             public void onRecentsAnimationStart(RecentsAnimationController controller,
-                    RecentsAnimationTargets targets) {
+                                                RecentsAnimationTargets targets) {
+                if (enableHandleDelayedGestureCallbacks() && mRecentsAnimationStartPending) {
+                    ActiveGestureLog.INSTANCE.addLog(new ActiveGestureLog.CompoundString(
+                            "TaskAnimationManager.startRecentsAnimation(onRecentsAnimationStart): ")
+                            .append("Setting mRecentsAnimationStartPending = false"));
+                    mRecentsAnimationStartPending = false;
+                }
                 if (mCallbacks == null) {
                     // It's possible for the recents animation to have finished and be cleaned up
                     // by the time we process the start callback, and in that case, just we can skip
@@ -148,9 +173,8 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
                 }
                 mController = controller;
                 mTargets = targets;
-                // TODO(b/236226779): We can probably get away w/ setting
-                // mLastAppearedTaskTargets
-                // to all appeared targets directly vs just looking at running ones
+                // TODO(b/236226779): We can probably get away w/ setting mLastAppearedTaskTargets
+                //  to all appeared targets directly vs just looking at running ones
                 int[] runningTaskIds = mLastGestureState.getRunningTaskIds(targets.apps.length > 1);
                 mLastAppearedTaskTargets = new RemoteAnimationTarget[runningTaskIds.length];
                 for (int i = 0; i < runningTaskIds.length; i++) {
@@ -158,32 +182,76 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
                     mLastAppearedTaskTargets[i] = task;
                 }
                 mLastGestureState.updateLastAppearedTaskTargets(mLastAppearedTaskTargets);
+
+                if (ENABLE_SHELL_TRANSITIONS && mTargets.hasRecents
+                        // The filtered (MODE_CLOSING) targets only contain 1 home activity.
+                        && mTargets.apps.length == 1
+                        && mTargets.apps[0].windowConfiguration.getActivityType()
+                        == ACTIVITY_TYPE_HOME) {
+                    // This is launching RecentsActivity on top of a 3p launcher. There are no
+                    // other apps need to keep visible so finish the animating state after the
+                    // enter animation of overview is done. Then 3p launcher can be stopped.
+                    mLastGestureState.runOnceAtState(STATE_END_TARGET_ANIMATION_FINISHED, () -> {
+                        if (mLastGestureState != gestureState) return;
+                        // Only finish if the end target is RECENTS. Otherwise, if the target is
+                        // NEW_TASK, startActivityFromRecents will be skipped.
+                        if (mLastGestureState.getEndTarget() == RECENTS) {
+                            finishRunningRecentsAnimation(false /* toHome */,
+                                    true /* forceFinish */, null /* forceFinishCb */);
+                        }
+                    });
+                }
             }
 
             @Override
             public void onRecentsAnimationCanceled(HashMap<Integer, ThumbnailData> thumbnailDatas) {
+                if (enableHandleDelayedGestureCallbacks() && mRecentsAnimationStartPending) {
+                    ActiveGestureLog.INSTANCE.addLog(new ActiveGestureLog.CompoundString(
+                            "TaskAnimationManager.startRecentsAnimation")
+                            .append("(onRecentsAnimationCanceled): ")
+                            .append("Setting mRecentsAnimationStartPending = false"));
+                    mRecentsAnimationStartPending = false;
+                }
                 cleanUpRecentsAnimation(newCallbacks);
             }
 
             @Override
             public void onRecentsAnimationFinished(RecentsAnimationController controller) {
+                if (enableHandleDelayedGestureCallbacks() && mRecentsAnimationStartPending) {
+                    ActiveGestureLog.INSTANCE.addLog(new ActiveGestureLog.CompoundString(
+                            "TaskAnimationManager.startRecentsAnimation")
+                            .append("(onRecentsAnimationFinished): ")
+                            .append("Setting mRecentsAnimationStartPending = false"));
+                    mRecentsAnimationStartPending = false;
+                }
                 cleanUpRecentsAnimation(newCallbacks);
             }
 
+            private boolean isNonRecentsStartedTasksAppeared(
+                    RemoteAnimationTarget[] appearedTaskTargets) {
+                // For example, right after swiping from task X to task Y (e.g. from
+                // AbsSwipeUpHandler#startNewTask), and then task Y starts X immediately
+                // (e.g. in Y's onResume). The case will be: lastStartedTask=Y and appearedTask=X.
+                return mLastGestureState.getEndTarget() == GestureState.GestureEndTarget.NEW_TASK
+                        && ArrayUtils.find(appearedTaskTargets,
+                        mLastGestureState.mLastStartedTaskIdPredicate) == null;
+            }
+
             @Override
             public void onTasksAppeared(RemoteAnimationTarget[] appearedTaskTargets) {
                 RemoteAnimationTarget appearedTaskTarget = appearedTaskTargets[0];
-                BaseActivityInterface activityInterface = mLastGestureState.getActivityInterface();
+                BaseContainerInterface containerInterface =
+                        mLastGestureState.getContainerInterface();
 
                 for (RemoteAnimationTarget compat : appearedTaskTargets) {
                     if (compat.windowConfiguration.getActivityType() == ACTIVITY_TYPE_HOME
-                            && activityInterface.getCreatedActivity() instanceof RecentsActivity
+                            && containerInterface.getCreatedContainer() instanceof RecentsActivity
                             && DisplayController.getNavigationMode(mCtx) != NO_BUTTON) {
                         // The only time we get onTasksAppeared() in button navigation with a
                         // 3p launcher is if the user goes to overview first, and in this case we
                         // can immediately finish the transition
                         RecentsView recentsView =
-                                activityInterface.getCreatedActivity().getOverviewPanel();
+                                containerInterface.getCreatedContainer().getOverviewPanel();
                         if (recentsView != null) {
                             recentsView.finishRecentsAnimation(true, null);
                         }
@@ -191,18 +259,22 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
                     }
                 }
 
-                RemoteAnimationTarget[] nonAppTargets = SystemUiProxy.INSTANCE.get(mCtx)
-                        .onStartingSplitLegacy(appearedTaskTargets);
+                RemoteAnimationTarget[] nonAppTargets = ENABLE_SHELL_TRANSITIONS
+                        ? null : SystemUiProxy.INSTANCE.get(mCtx).onStartingSplitLegacy(
+                        appearedTaskTargets);
                 if (nonAppTargets == null) {
                     nonAppTargets = new RemoteAnimationTarget[0];
                 }
-                if ((activityInterface.isInLiveTileMode()
-                        || mLastGestureState.getEndTarget() == RECENTS)
-                        && activityInterface.getCreatedActivity() != null) {
-                    RecentsView recentsView = activityInterface.getCreatedActivity().getOverviewPanel();
+                if ((containerInterface.isInLiveTileMode()
+                        || mLastGestureState.getEndTarget() == RECENTS
+                        || isNonRecentsStartedTasksAppeared(appearedTaskTargets))
+                        && containerInterface.getCreatedContainer() != null) {
+                    RecentsView recentsView =
+                            containerInterface.getCreatedContainer().getOverviewPanel();
                     if (recentsView != null) {
-                        ActiveGestureLog.INSTANCE.addLog("Launching side task id="
-                                + appearedTaskTarget.taskId);
+                        ActiveGestureLog.INSTANCE.addLog(
+                                new ActiveGestureLog.CompoundString("Launching side task id=")
+                                        .append(appearedTaskTarget.taskId));
                         recentsView.launchSideTaskInLiveTileMode(appearedTaskTarget.taskId,
                                 appearedTaskTargets,
                                 new RemoteAnimationTarget[0] /* wallpaper */,
@@ -213,7 +285,7 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
                     }
                 } else if (nonAppTargets.length > 0) {
                     TaskViewUtils.createSplitAuxiliarySurfacesAnimator(nonAppTargets /* nonApps */,
-                            true /* shown */, null /* animatorHandler */);
+                            true /*shown*/, null /* animatorHandler */);
                 }
                 if (mController != null) {
                     if (mLastAppearedTaskTargets != null) {
@@ -233,12 +305,13 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
 
             @Override
             public boolean onSwitchToScreenshot(Runnable onFinished) {
-                if (!activityInterface.isInLiveTileMode()
-                        || activityInterface.getCreatedActivity() == null) {
+                if (!containerInterface.isInLiveTileMode()
+                        || containerInterface.getCreatedContainer() == null) {
                     // No need to switch since tile is already a screenshot.
                     onFinished.run();
                 } else {
-                    final RecentsView recentsView = activityInterface.getCreatedActivity().getOverviewPanel();
+                    final RecentsView recentsView =
+                            containerInterface.getCreatedContainer().getOverviewPanel();
                     if (recentsView != null) {
                         recentsView.switchToScreenshot(onFinished);
                     } else {
@@ -254,37 +327,37 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
 
         if (ENABLE_SHELL_TRANSITIONS) {
             final ActivityOptions options = ActivityOptions.makeBasic();
-            // Allowing to pause Home if Home is top activity and Recents is not Home. So
-            // when user
-            // start home when recents animation is playing, the home activity can be
-            // resumed again
-            // to let the transition controller collect Home activity.
-            CachedTaskInfo cti = gestureState.getRunningTask();
-            boolean homeIsOnTop = cti != null && cti.isHomeTask();
-            if (DesktopTaskView.DESKTOP_MODE_SUPPORTED) {
-                if (cti != null && cti.isFreeformTask()) {
-                    // No transient launch when desktop task is on top
-                    homeIsOnTop = true;
-                }
-            }
-            if (activityInterface.allowAllAppsFromOverview()) {
-                homeIsOnTop = true;
-            }
-            if (!homeIsOnTop) {
+            // Use regular (non-transient) launch for all apps page to control IME.
+            if (!containerInterface.allowAllAppsFromOverview()) {
                 options.setTransientLaunch();
             }
-            if (Utilities.ATLEAST_S) {
-                options.setSourceInfo(ActivityOptions.SourceInfo.TYPE_RECENTS_ANIMATION, eventTime);
-                if (Utilities.ATLEAST_U) {
-                    SystemUiProxy.INSTANCE.getNoCreate().startRecentsActivity(intent, options, mCallbacks);
-                } else {
-                    UI_HELPER_EXECUTOR.execute(() -> ActivityManagerWrapper.getInstance()
-                            .startRecentsActivity(intent, eventTime, mCallbacks, null, null));
-                }
+            options.setSourceInfo(ActivityOptions.SourceInfo.TYPE_RECENTS_ANIMATION, eventTime);
+            mRecentsAnimationStartPending = SystemUiProxy.INSTANCE.get(mCtx)
+                    .startRecentsActivity(intent, options, mCallbacks);
+            if (enableHandleDelayedGestureCallbacks()) {
+                ActiveGestureLog.INSTANCE.addLog(new ActiveGestureLog.CompoundString(
+                        "TaskAnimationManager.startRecentsAnimation(shell transition path): ")
+                        .append("Setting mRecentsAnimationStartPending = ")
+                        .append(mRecentsAnimationStartPending));
             }
         } else {
-            UI_HELPER_EXECUTOR.execute(() -> ActivityManagerWrapper.getInstance()
-                    .startRecentsActivity(intent, eventTime, mCallbacks, null, null));
+            UI_HELPER_EXECUTOR.execute(
+                    () -> ActivityManagerWrapper.getInstance().startRecentsActivity(
+                            intent,
+                            eventTime,
+                            mCallbacks,
+                            result -> {
+                                if (enableHandleDelayedGestureCallbacks()) {
+                                    ActiveGestureLog.INSTANCE.addLog(
+                                            new ActiveGestureLog.CompoundString(
+                                                    "TaskAnimationManager.startRecentsAnimation")
+                                                    .append("(legacy path): Setting ")
+                                                    .append("mRecentsAnimationStartPending = ")
+                                                    .append(result));
+                                }
+                                mRecentsAnimationStartPending = result;
+                            },
+                            MAIN_EXECUTOR.getHandler()));
         }
         gestureState.setState(STATE_RECENTS_ANIMATION_INITIALIZED);
         return mCallbacks;
@@ -304,20 +377,54 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
         return mCallbacks;
     }
 
-    public void endLiveTile() {
-        if (mLastGestureState == null) {
-            return;
-        }
-        BaseActivityInterface activityInterface = mLastGestureState.getActivityInterface();
-        if (activityInterface.isInLiveTileMode()
-                && activityInterface.getCreatedActivity() != null) {
-            RecentsView recentsView = activityInterface.getCreatedActivity().getOverviewPanel();
-            if (recentsView != null) {
-                recentsView.switchToScreenshot(null,
-                        () -> recentsView.finishRecentsAnimation(true /* toRecents */,
-                                false /* shouldPip */, null));
+    public void onSystemUiFlagsChanged(@QuickStepContract.SystemUiStateFlags long lastSysUIFlags,
+                                       @QuickStepContract.SystemUiStateFlags long newSysUIFlags) {
+        long isShadeExpandedFlagMask =
+                SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED | SYSUI_STATE_QUICK_SETTINGS_EXPANDED;
+        boolean wasExpanded = hasAnyFlag(lastSysUIFlags, isShadeExpandedFlagMask);
+        boolean isExpanded = hasAnyFlag(newSysUIFlags, isShadeExpandedFlagMask);
+        if (wasExpanded != isExpanded && isExpanded) {
+            // End live tile when expanding the notification panel for the first time from
+            // overview.
+            if (endLiveTile()) {
+                return;
             }
         }
+
+        boolean wasLocked = SystemUiFlagUtils.isLocked(lastSysUIFlags);
+        boolean isLocked = SystemUiFlagUtils.isLocked(newSysUIFlags);
+        if (wasLocked != isLocked && isLocked) {
+            // Finish the running recents animation when locking the device.
+            finishRunningRecentsAnimation(
+                    mController != null && mController.getFinishTargetIsLauncher());
+        }
+    }
+
+    private boolean hasAnyFlag(long flags, long flagMask) {
+        return (flags & flagMask) != 0;
+    }
+
+    /**
+     * Switches the {@link RecentsView} to screenshot if in live tile mode.
+     *
+     * @return true iff the {@link RecentsView} was in live tile mode and was switched to screenshot
+     */
+    public boolean endLiveTile() {
+        if (mLastGestureState == null) {
+            return false;
+        }
+        BaseContainerInterface containerInterface = mLastGestureState.getContainerInterface();
+        if (!containerInterface.isInLiveTileMode()
+                || containerInterface.getCreatedContainer() == null) {
+            return false;
+        }
+        RecentsView recentsView = containerInterface.getCreatedContainer().getOverviewPanel();
+        if (recentsView == null) {
+            return false;
+        }
+        recentsView.switchToScreenshot(null, () -> recentsView.finishRecentsAnimation(
+                true /* toRecents */, false /* shouldPip */, null));
+        return true;
     }
 
     public void setLiveTileCleanUpHandler(Runnable cleanUpHandler) {
@@ -332,37 +439,32 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
      * Finishes the running recents animation.
      */
     public void finishRunningRecentsAnimation(boolean toHome) {
-        finishRunningRecentsAnimation(toHome, false /* forceFinish */);
+        finishRunningRecentsAnimation(toHome, false /* forceFinish */, null /* forceFinishCb */);
     }
 
     /**
      * Finishes the running recents animation.
-     * 
      * @param forceFinish will synchronously finish the controller
      */
-
-    public void finishRunningRecentsAnimation(boolean toHome, boolean forceFinish) {
+    public void finishRunningRecentsAnimation(boolean toHome, boolean forceFinish,
+                                              Runnable forceFinishCb) {
         if (mController != null) {
             ActiveGestureLog.INSTANCE.addLog(
                     /* event= */ "finishRunningRecentsAnimation", toHome);
-            mCallbacks.notifyAnimationCanceled();
             if (forceFinish) {
-                mController.finishController(toHome, null, false /* sendUserLeaveHint */,
+                mController.finishController(toHome, forceFinishCb, false /* sendUserLeaveHint */,
                         true /* forceFinish */);
             } else {
                 Utilities.postAsyncCallback(MAIN_EXECUTOR.getHandler(), toHome
                         ? mController::finishAnimationToHome
                         : mController::finishAnimationToApp);
             }
-            cleanUpRecentsAnimation(mCallbacks);
         }
     }
 
     /**
-     * Used to notify a listener of the current recents animation state (used if the
-     * listener was
-     * not yet added to the callbacks at the point that the listener callbacks would
-     * have been
+     * Used to notify a listener of the current recents animation state (used if the listener was
+     * not yet added to the callbacks at the point that the listener callbacks would have been
      * made).
      */
     public void notifyRecentsAnimationState(
@@ -418,7 +520,24 @@ public class TaskAnimationManager implements RecentsAnimationCallbacks.RecentsAn
         return mCallbacks;
     }
 
-    public void dump() {
-        // TODO
+    public void dump(String prefix, PrintWriter pw) {
+        pw.println(prefix + "TaskAnimationManager:");
+
+        if (enableHandleDelayedGestureCallbacks()) {
+            pw.println(prefix + "\tmRecentsAnimationStartPending=" + mRecentsAnimationStartPending);
+            pw.println(prefix + "\tmShouldIgnoreUpcomingGestures=" + mShouldIgnoreMotionEvents);
+        }
+        if (mController != null) {
+            mController.dump(prefix + '\t', pw);
+        }
+        if (mCallbacks != null) {
+            mCallbacks.dump(prefix + '\t', pw);
+        }
+        if (mTargets != null) {
+            mTargets.dump(prefix + '\t', pw);
+        }
+        if (mLastGestureState != null) {
+            mLastGestureState.dump(prefix + '\t', pw);
+        }
     }
 }
diff --git a/quickstep/src/com/android/quickstep/TaskIconCache.java b/quickstep/src/com/android/quickstep/TaskIconCache.java
index fbdbc3ff9a..f45bacb33b 100644
--- a/quickstep/src/com/android/quickstep/TaskIconCache.java
+++ b/quickstep/src/com/android/quickstep/TaskIconCache.java
@@ -15,7 +15,9 @@
  */
 package com.android.quickstep;
 
+import static com.android.launcher3.Flags.enableOverviewIconMenu;
 import static com.android.launcher3.util.DisplayController.CHANGE_DENSITY;
+import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 
 import android.annotation.Nullable;
 import android.app.ActivityManager;
@@ -30,39 +32,37 @@ import android.graphics.drawable.Drawable;
 import android.os.UserHandle;
 import android.text.TextUtils;
 import android.util.SparseArray;
-import android.view.accessibility.AccessibilityManager;
 
 import androidx.annotation.WorkerThread;
 
 import com.android.launcher3.R;
 import com.android.launcher3.Utilities;
 import com.android.launcher3.icons.BaseIconFactory;
+import com.android.launcher3.icons.BaseIconFactory.IconOptions;
 import com.android.launcher3.icons.BitmapInfo;
 import com.android.launcher3.icons.IconProvider;
+import com.android.launcher3.pm.UserCache;
+import com.android.launcher3.util.CancellableTask;
 import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.util.DisplayController.DisplayInfoChangeListener;
 import com.android.launcher3.util.DisplayController.Info;
+import com.android.launcher3.util.FlagOp;
 import com.android.launcher3.util.Preconditions;
-import com.android.quickstep.util.CancellableTask;
 import com.android.quickstep.util.TaskKeyLruCache;
 import com.android.quickstep.util.TaskVisualsChangeListener;
 import com.android.systemui.shared.recents.model.Task;
 import com.android.systemui.shared.recents.model.Task.TaskKey;
 import com.android.systemui.shared.system.PackageManagerWrapper;
-import com.android.systemui.shared.system.TaskDescriptionCompat;
 
 import java.util.concurrent.Executor;
 import java.util.function.Consumer;
 
-import app.lawnchair.util.TaskIconUtils;
-
 /**
  * Manages the caching of task icons and related data.
  */
 public class TaskIconCache implements DisplayInfoChangeListener {
 
     private final Executor mBgExecutor;
-    private final AccessibilityManager mAccessibilityManager;
 
     private final Context mContext;
     private final TaskKeyLruCache<TaskCacheEntry> mIconCache;
@@ -79,7 +79,6 @@ public class TaskIconCache implements DisplayInfoChangeListener {
     public TaskIconCache(Context context, Executor bgExecutor, IconProvider iconProvider) {
         mContext = context;
         mBgExecutor = bgExecutor;
-        mAccessibilityManager = context.getSystemService(AccessibilityManager.class);
         mIconProvider = iconProvider;
 
         Resources res = context.getResources();
@@ -100,9 +99,8 @@ public class TaskIconCache implements DisplayInfoChangeListener {
     /**
      * Asynchronously fetches the icon and other task data.
      *
-     * @param task     The task to fetch the data for
-     * @param callback The callback to receive the task after its data has been
-     *                 populated.
+     * @param task The task to fetch the data for
+     * @param callback The callback to receive the task after its data has been populated.
      * @return A cancelable handle to the request
      */
     public CancellableTask updateIconInBackground(Task task, Consumer<Task> callback) {
@@ -112,20 +110,17 @@ public class TaskIconCache implements DisplayInfoChangeListener {
             callback.accept(task);
             return null;
         }
-        CancellableTask<TaskCacheEntry> request = new CancellableTask<TaskCacheEntry>() {
-            @Override
-            public TaskCacheEntry getResultOnBg() {
-                return getCacheEntry(task);
-            }
-
-            @Override
-            public void handleResult(TaskCacheEntry result) {
-                task.icon = result.icon;
-                task.titleDescription = result.contentDescription;
-                callback.accept(task);
-                dispatchIconUpdate(task.key.id);
-            }
-        };
+        CancellableTask<TaskCacheEntry> request = new CancellableTask<>(
+                () -> getCacheEntry(task),
+                MAIN_EXECUTOR,
+                result -> {
+                    task.icon = result.icon;
+                    task.titleDescription = result.contentDescription;
+                    task.title = result.title;
+                    callback.accept(task);
+                    dispatchIconUpdate(task.key.id);
+                }
+        );
         mBgExecutor.execute(request);
         return request;
     }
@@ -142,8 +137,8 @@ public class TaskIconCache implements DisplayInfoChangeListener {
     }
 
     void invalidateCacheEntries(String pkg, UserHandle handle) {
-        mBgExecutor.execute(() -> mIconCache
-                .removeAll(key -> pkg.equals(key.getPackageName()) && handle.getIdentifier() == key.userId));
+        mBgExecutor.execute(() -> mIconCache.removeAll(key ->
+                pkg.equals(key.getPackageName()) && handle.getIdentifier() == key.userId));
     }
 
     @WorkerThread
@@ -162,9 +157,8 @@ public class TaskIconCache implements DisplayInfoChangeListener {
 
         // Load icon
         // TODO: Load icon resource (b/143363444)
-        Bitmap icon = TaskDescriptionCompat.getIcon(desc, key.userId);
-        if (icon != null && TaskIconUtils.allowCustomIcon(task)) {
-            /* isInstantApp */
+        Bitmap icon = getIcon(desc, key.userId);
+        if (icon != null) {
             entry.icon = getBitmapInfo(
                     new BitmapDrawable(mContext.getResources(), icon),
                     key.userId,
@@ -193,6 +187,9 @@ public class TaskIconCache implements DisplayInfoChangeListener {
         if (activityInfo != null) {
             entry.contentDescription = getBadgedContentDescription(
                     activityInfo, task.key.userId, task.taskDescription);
+            if (enableOverviewIconMenu()) {
+                entry.title = Utilities.trim(activityInfo.loadLabel(mContext.getPackageManager()));
+            }
         }
 
         mIconCache.put(task.key, entry);
@@ -219,8 +216,7 @@ public class TaskIconCache implements DisplayInfoChangeListener {
                 ? pm.getUserBadgedLabel(applicationLabel, UserHandle.of(userId)).toString()
                 : applicationLabel;
         return applicationLabel.equals(taskLabel)
-                ? badgedApplicationLabel
-                : badgedApplicationLabel + " " + taskLabel;
+                ? badgedApplicationLabel : badgedApplicationLabel + " " + taskLabel;
     }
 
     @WorkerThread
@@ -228,7 +224,7 @@ public class TaskIconCache implements DisplayInfoChangeListener {
         synchronized (mDefaultIcons) {
             if (mDefaultIconBase == null) {
                 try (BaseIconFactory bif = getIconFactory()) {
-                    mDefaultIconBase = bif.makeDefaultIcon(UserHandle.getUserHandleForUid (userId));
+                    mDefaultIconBase = bif.makeDefaultIcon();
                 }
             }
 
@@ -236,11 +232,11 @@ public class TaskIconCache implements DisplayInfoChangeListener {
             if ((index = mDefaultIcons.indexOfKey(userId)) >= 0) {
                 return mDefaultIcons.valueAt(index).newIcon(mContext);
             } else {
-                try (BaseIconFactory li = getIconFactory()) {
-                    BitmapInfo info = li.makeDefaultIcon (UserHandle.getUserHandleForUid (userId));
-                    mDefaultIcons.put(userId, info);
-                    return info.newIcon(mContext);
-                }
+                BitmapInfo info = mDefaultIconBase.withFlags(
+                        UserCache.INSTANCE.get(mContext).getUserInfo(UserHandle.of(userId))
+                                .applyBitmapInfoFlags(FlagOp.NO_OP));
+                mDefaultIcons.put(userId, info);
+                return info.newIcon(mContext);
             }
         }
     }
@@ -251,9 +247,13 @@ public class TaskIconCache implements DisplayInfoChangeListener {
         try (BaseIconFactory bif = getIconFactory()) {
             bif.setWrapperBackgroundColor(primaryColor);
 
-            // User version code O, so that the icon is always wrapped in an adaptive icon
-            // container
-            return bif.createBadgedIconBitmap(drawable, UserHandle.getUserHandleForUid (userId), false);
+            // User version code O, so that the icon is always wrapped in an adaptive icon container
+            return bif.createBadgedIconBitmap(drawable,
+                    new IconOptions()
+                            .setUser(UserCache.INSTANCE.get(mContext)
+                                    .getUserInfo(UserHandle.of(userId)))
+                            .setInstantApp(isInstantApp)
+                            .setExtractedColor(0));
         }
     }
 
@@ -277,6 +277,7 @@ public class TaskIconCache implements DisplayInfoChangeListener {
     private static class TaskCacheEntry {
         public Drawable icon;
         public String contentDescription = "";
+        public String title = "";
     }
 
     void registerTaskVisualsChangeListener(TaskVisualsChangeListener newListener) {
@@ -292,4 +293,4 @@ public class TaskIconCache implements DisplayInfoChangeListener {
             mTaskVisualsChangeListener.onTaskIconChanged(taskId);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/quickstep/src/com/android/quickstep/TaskOverlayFactory.java b/quickstep/src/com/android/quickstep/TaskOverlayFactory.java
index da47bb8ff5..03183d02ad 100644
--- a/quickstep/src/com/android/quickstep/TaskOverlayFactory.java
+++ b/quickstep/src/com/android/quickstep/TaskOverlayFactory.java
@@ -117,8 +117,6 @@ public class TaskOverlayFactory implements ResourceBasedOverride {
      */
     private static final TaskShortcutFactory[] MENU_OPTIONS = new TaskShortcutFactory[] {
             TaskShortcutFactory.APP_INFO,
-            app.lawnchair.overview.TaskShortcutFactory.legacySplit,
-            app.lawnchair.overview.TaskShortcutFactory.killApp,
             TaskShortcutFactory.SPLIT_SELECT,
             TaskShortcutFactory.PIN,
             TaskShortcutFactory.INSTALL,
diff --git a/quickstep/src/com/android/quickstep/TaskShortcutFactory.java b/quickstep/src/com/android/quickstep/TaskShortcutFactory.java
index 5f91504637..4f0d90965a 100644
--- a/quickstep/src/com/android/quickstep/TaskShortcutFactory.java
+++ b/quickstep/src/com/android/quickstep/TaskShortcutFactory.java
@@ -18,10 +18,12 @@ package com.android.quickstep;
 
 import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
 import static android.content.Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
+import static android.view.Surface.ROTATION_0;
 
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_SYSTEM_SHORTCUT_FREE_FORM_TAP;
+import static com.android.launcher3.util.SplitConfigurationOptions.STAGE_POSITION_BOTTOM_OR_RIGHT;
+import static com.android.window.flags.Flags.enableDesktopWindowingMode;
 
-import android.app.Activity;
 import android.app.ActivityOptions;
 import android.graphics.Bitmap;
 import android.graphics.Color;
@@ -29,7 +31,7 @@ import android.graphics.Rect;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.RemoteException;
-import android.os.SystemProperties;
+import android.provider.Settings;
 import android.util.Log;
 import android.view.View;
 import android.view.WindowInsets;
@@ -38,22 +40,24 @@ import android.window.SplashScreen;
 
 import androidx.annotation.Nullable;
 
-import com.android.launcher3.BaseDraggingActivity;
 import com.android.launcher3.DeviceProfile;
+import com.android.launcher3.Flags;
 import com.android.launcher3.R;
-import com.android.launcher3.config.FeatureFlags;
 import com.android.launcher3.logging.StatsLogManager.LauncherEvent;
 import com.android.launcher3.model.WellbeingModel;
 import com.android.launcher3.popup.SystemShortcut;
 import com.android.launcher3.popup.SystemShortcut.AppInfo;
-import com.android.launcher3.touch.PagedOrientationHandler;
 import com.android.launcher3.util.InstantAppResolver;
 import com.android.launcher3.util.SplitConfigurationOptions.SplitPositionOption;
-import com.android.launcher3.util.PackageManagerHelper;
+import com.android.launcher3.views.ActivityContext;
+import com.android.quickstep.orientation.RecentsPagedOrientationHandler;
+import com.android.quickstep.util.RecentsOrientedState;
+import com.android.quickstep.views.GroupedTaskView;
 import com.android.quickstep.views.RecentsView;
-import com.android.quickstep.views.TaskThumbnailView;
+import com.android.quickstep.views.RecentsViewContainer;
+import com.android.quickstep.views.TaskThumbnailViewDeprecated;
 import com.android.quickstep.views.TaskView;
-import com.android.quickstep.views.TaskView.TaskIdAttributeContainer;
+import com.android.quickstep.views.TaskView.TaskContainer;
 import com.android.systemui.shared.recents.model.Task;
 import com.android.systemui.shared.recents.view.AppTransitionAnimationSpecCompat;
 import com.android.systemui.shared.recents.view.AppTransitionAnimationSpecsFuture;
@@ -65,27 +69,32 @@ import java.util.List;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-import app.lawnchair.compat.LawnchairQuickstepCompat;
-
 /**
- * Represents a system shortcut that can be shown for a recent task. Appears as
- * a single entry in
+ * Represents a system shortcut that can be shown for a recent task. Appears as a single entry in
  * the dropdown menu that shows up when you tap an app icon in Overview.
  */
 public interface TaskShortcutFactory {
     @Nullable
-    default List<SystemShortcut> getShortcuts(BaseDraggingActivity activity,
-            TaskIdAttributeContainer taskContainer) {
+    default List<SystemShortcut> getShortcuts(RecentsViewContainer container,
+                                              TaskContainer taskContainer) {
         return null;
     }
 
-    default boolean showForSplitscreen() {
+    /**
+     * Returns {@code true} if it should be shown for grouped task; {@code false} otherwise.
+     */
+    default boolean showForGroupedTask() {
         return false;
     }
 
     /**
-     * @return a singleton list if the provided shortcut is non-null, null otherwise
+     * Returns {@code true} if it should be shown for desktop task; {@code false} otherwise.
      */
+    default boolean showForDesktopTask() {
+        return false;
+    }
+
+    /** @return a singleton list if the provided shortcut is non-null, null otherwise */
     @Nullable
     default List<SystemShortcut> createSingletonShortcutList(@Nullable SystemShortcut shortcut) {
         if (shortcut != null) {
@@ -96,19 +105,24 @@ public interface TaskShortcutFactory {
 
     TaskShortcutFactory APP_INFO = new TaskShortcutFactory() {
         @Override
-        public List<SystemShortcut> getShortcuts(BaseDraggingActivity activity,
-                TaskIdAttributeContainer taskContainer) {
+        public List<SystemShortcut> getShortcuts(RecentsViewContainer container,
+                                                 TaskContainer taskContainer) {
             TaskView taskView = taskContainer.getTaskView();
-            AppInfo.SplitAccessibilityInfo accessibilityInfo = new AppInfo.SplitAccessibilityInfo(
-                    taskView.containsMultipleTasks(),
-                    TaskUtils.getTitle(taskView.getContext(), taskContainer.getTask()),
-                    taskContainer.getA11yNodeId());
-            return Collections.singletonList(new AppInfo(activity, taskContainer.getItemInfo(),
+            int actionId = taskContainer.getStagePosition() == STAGE_POSITION_BOTTOM_OR_RIGHT
+                    ? R.id.action_app_info_bottom_right
+                    : R.id.action_app_info_top_left;
+
+            AppInfo.SplitAccessibilityInfo accessibilityInfo =
+                    new AppInfo.SplitAccessibilityInfo(taskView.containsMultipleTasks(),
+                            TaskUtils.getTitle(taskView.getContext(), taskContainer.getTask()),
+                            actionId
+                    );
+            return Collections.singletonList(new AppInfo(container, taskContainer.getItemInfo(),
                     taskView, accessibilityInfo));
         }
 
         @Override
-        public boolean showForSplitscreen() {
+        public boolean showForGroupedTask() {
             return true;
         }
     };
@@ -117,9 +131,10 @@ public interface TaskShortcutFactory {
         private final TaskView mTaskView;
         private final SplitPositionOption mSplitPositionOption;
 
-        public SplitSelectSystemShortcut(BaseDraggingActivity target, TaskView taskView,
-                SplitPositionOption option) {
-            super(option.iconResId, option.textResId, target, taskView.getItemInfo(), taskView);
+        public SplitSelectSystemShortcut(RecentsViewContainer container, TaskView taskView,
+                                         SplitPositionOption option) {
+            super(option.iconResId, option.textResId, container, taskView.getFirstItemInfo(),
+                    taskView);
             mTaskView = taskView;
             mSplitPositionOption = option;
         }
@@ -131,55 +146,55 @@ public interface TaskShortcutFactory {
     }
 
     /**
-     * A menu item, "Save app pair", that allows the user to preserve the current
-     * app combination as
-     * a single persistent icon on the Home screen, allowing for quick split screen
-     * initialization.
+     * A menu item, "Save app pair", that allows the user to preserve the current app combination as
+     * one persistent icon on the Home screen, allowing for quick split screen launching.
      */
-    class SaveAppPairSystemShortcut extends SystemShortcut<BaseDraggingActivity> {
-        private final TaskView mTaskView;
+    class SaveAppPairSystemShortcut extends SystemShortcut<RecentsViewContainer> {
+        private final GroupedTaskView mTaskView;
 
-        public SaveAppPairSystemShortcut(BaseDraggingActivity activity, TaskView taskView) {
-            super(R.drawable.ic_save_app_pair, R.string.save_app_pair, activity,
-                    taskView.getItemInfo(), taskView);
+
+        public SaveAppPairSystemShortcut(RecentsViewContainer container, GroupedTaskView taskView,
+                                         int iconResId) {
+            super(iconResId, R.string.save_app_pair, container, taskView.getFirstItemInfo(),
+                    taskView);
             mTaskView = taskView;
         }
 
         @Override
         public void onClick(View view) {
-            dismissTaskMenuView(mTarget);
+            dismissTaskMenuView();
             ((RecentsView) mTarget.getOverviewPanel())
                     .getSplitSelectController().getAppPairsController().saveAppPair(mTaskView);
         }
     }
 
-    class FreeformSystemShortcut extends SystemShortcut<BaseDraggingActivity> {
+    class FreeformSystemShortcut extends SystemShortcut<RecentsViewContainer> {
         private static final String TAG = "FreeformSystemShortcut";
 
         private Handler mHandler;
 
         private final RecentsView mRecentsView;
-        private final TaskThumbnailView mThumbnailView;
+        private final TaskThumbnailViewDeprecated mThumbnailView;
         private final TaskView mTaskView;
         private final LauncherEvent mLauncherEvent;
 
-        public FreeformSystemShortcut(int iconRes, int textRes, BaseDraggingActivity activity,
-                TaskIdAttributeContainer taskContainer, LauncherEvent launcherEvent) {
-            super(iconRes, textRes, activity, taskContainer.getItemInfo(),
+        public FreeformSystemShortcut(int iconRes, int textRes, RecentsViewContainer container,
+                                      TaskContainer taskContainer, LauncherEvent launcherEvent) {
+            super(iconRes, textRes, container, taskContainer.getItemInfo(),
                     taskContainer.getTaskView());
             mLauncherEvent = launcherEvent;
             mHandler = new Handler(Looper.getMainLooper());
             mTaskView = taskContainer.getTaskView();
-            mRecentsView = activity.getOverviewPanel();
-            mThumbnailView = taskContainer.getThumbnailView();
+            mRecentsView = container.getOverviewPanel();
+            mThumbnailView = taskContainer.getThumbnailViewDeprecated();
         }
 
         @Override
         public void onClick(View view) {
-            dismissTaskMenuView(mTarget);
+            dismissTaskMenuView();
             RecentsView rv = mTarget.getOverviewPanel();
             rv.switchToScreenshot(() -> {
-                rv.finishRecentsAnimation(true /* toHome */, () -> {
+                rv.finishRecentsAnimation(true /* toRecents */, false /* shouldPip */, () -> {
                     mTarget.returnToHomescreen();
                     rv.getHandler().post(this::startActivity);
                 });
@@ -187,7 +202,7 @@ public interface TaskShortcutFactory {
         }
 
         private void startActivity() {
-            final Task.TaskKey taskKey = mTaskView.getTask().key;
+            final Task.TaskKey taskKey = mTaskView.getFirstTask().key;
             final int taskId = taskKey.id;
             final ActivityOptions options = makeLaunchOptions(mTarget);
             if (options != null) {
@@ -195,11 +210,11 @@ public interface TaskShortcutFactory {
             }
             if (options != null
                     && ActivityManagerWrapper.getInstance().startActivityFromRecents(taskId,
-                            options)) {
+                    options)) {
                 final Runnable animStartedListener = () -> {
                     // Hide the task view and wait for the window to be resized
                     // TODO: Consider animating in launcher and do an in-place start activity
-                    // afterwards
+                    //       afterwards
                     mRecentsView.setIgnoreResetTask(taskId);
                     mTaskView.setAlpha(0f);
                 };
@@ -219,17 +234,19 @@ public interface TaskShortcutFactory {
                         Color.BLACK);
                 mThumbnailView.setDimAlpha(alpha);
 
-                AppTransitionAnimationSpecsFuture future = new AppTransitionAnimationSpecsFuture(mHandler) {
-                    @Override
-                    public List<AppTransitionAnimationSpecCompat> composeSpecs() {
-                        return Collections.singletonList(new AppTransitionAnimationSpecCompat(
-                                taskId, thumbnail, taskBounds));
-                    }
-                };
+                AppTransitionAnimationSpecsFuture future =
+                        new AppTransitionAnimationSpecsFuture(mHandler) {
+                            @Override
+                            public List<AppTransitionAnimationSpecCompat> composeSpecs() {
+                                return Collections.singletonList(
+                                        new AppTransitionAnimationSpecCompat(
+                                                taskId, thumbnail, taskBounds));
+                            }
+                        };
                 overridePendingAppTransitionMultiThumbFuture(
                         future, animStartedListener, mHandler, true /* scaleUp */,
                         taskKey.displayId);
-                mTarget.getStatsLogManager().logger().withItemInfo(mTaskView.getItemInfo())
+                mTarget.getStatsLogManager().logger().withItemInfo(mTaskView.getFirstItemInfo())
                         .log(mLauncherEvent);
             }
         }
@@ -245,19 +262,18 @@ public interface TaskShortcutFactory {
                         .overridePendingAppTransitionMultiThumbFuture(
                                 animationSpecFuture.getFuture(),
                                 RecentsTransition.wrapStartedListener(animStartedCallbackHandler,
-                                        animStartedCallback),
-                                scaleUp, displayId);
+                                        animStartedCallback), scaleUp, displayId);
             } catch (RemoteException e) {
                 Log.w(TAG, "Failed to override pending app transition (multi-thumbnail future): ",
                         e);
             }
         }
 
-        private ActivityOptions makeLaunchOptions(Activity activity) {
+        private ActivityOptions makeLaunchOptions(RecentsViewContainer container) {
             ActivityOptions activityOptions = ActivityOptions.makeBasic();
             activityOptions.setLaunchWindowingMode(WINDOWING_MODE_FREEFORM);
             // Arbitrary bounds only because freeform is in dev mode right now
-            final View decorView = activity.getWindow().getDecorView();
+            final View decorView = container.getWindow().getDecorView();
             final WindowInsets insets = decorView.getRootWindowInsets();
             final Rect r = new Rect(0, 0, decorView.getWidth() / 2, decorView.getHeight() / 2);
             r.offsetTo(insets.getSystemWindowInsetLeft() + 50,
@@ -269,48 +285,43 @@ public interface TaskShortcutFactory {
 
     /**
      * Does NOT add split options in the following scenarios:
-     * * The taskView to add split options is already showing split screen tasks
-     * * There aren't at least 2 tasks in overview to show split options for
-     * * Split isn't supported by the task itself (non resizable activity)
-     * * We aren't currently in multi-window
-     * * The taskView to show split options for is the focused task AND we haven't
-     * started
-     * scrolling in overview (if we haven't scrolled, there's a split overview
-     * action button so
-     * we don't need this menu option)
+     * * 1. Taskbar is not present AND aren't at least 2 tasks in overview to show split options for
+     * * 2. Split isn't supported by the task itself (non resizable activity)
+     * * 3. We aren't currently in multi-window
+     * * 4. The taskView to show split options for is the focused task AND we haven't started
+     * * scrolling in overview (if we haven't scrolled, there's a split overview action button so
+     * * we don't need this menu option)
      */
     TaskShortcutFactory SPLIT_SELECT = new TaskShortcutFactory() {
         @Override
-        public List<SystemShortcut> getShortcuts(BaseDraggingActivity activity,
-                TaskIdAttributeContainer taskContainer) {
-            if (!LawnchairQuickstepCompat.ATLEAST_T) return null;
-            DeviceProfile deviceProfile = activity.getDeviceProfile();
+        public List<SystemShortcut> getShortcuts(RecentsViewContainer container,
+                                                 TaskContainer taskContainer) {
+            DeviceProfile deviceProfile = container.getDeviceProfile();
             final Task task = taskContainer.getTask();
             final int intentFlags = task.key.baseIntent.getFlags();
             final TaskView taskView = taskContainer.getTaskView();
             final RecentsView recentsView = taskView.getRecentsView();
-            final PagedOrientationHandler orientationHandler = recentsView.getPagedOrientationHandler();
+            final RecentsPagedOrientationHandler orientationHandler =
+                    recentsView.getPagedOrientationHandler();
 
-            boolean notEnoughTasksToSplit = recentsView.getTaskViewCount() < 2;
-            boolean isFocusedTask = deviceProfile.isTablet && taskView.isFocusedTask();
-            boolean isTaskInExpectedScrollPosition = recentsView
-                    .isTaskInExpectedScrollPosition(recentsView.indexOfChild(taskView));
+            boolean notEnoughTasksToSplit =
+                    !deviceProfile.isTaskbarPresent && recentsView.getTaskViewCount() < 2;
             boolean isTaskSplitNotSupported = !task.isDockable ||
                     (intentFlags & FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS) != 0;
-            boolean hideForExistingMultiWindow = activity.getDeviceProfile().isMultiWindowMode;
+            boolean hideForExistingMultiWindow = container.getDeviceProfile().isMultiWindowMode;
+            boolean isFocusedTask = deviceProfile.isTablet && taskView.isFocusedTask();
+            boolean isTaskInExpectedScrollPosition =
+                    recentsView.isTaskInExpectedScrollPosition(recentsView.indexOfChild(taskView));
 
-            if (taskView.containsMultipleTasks()
-                    || notEnoughTasksToSplit
-                    || isTaskSplitNotSupported
-                    || hideForExistingMultiWindow
+            if (notEnoughTasksToSplit || isTaskSplitNotSupported || hideForExistingMultiWindow
                     || (isFocusedTask && isTaskInExpectedScrollPosition)) {
                 return null;
             }
 
             return orientationHandler.getSplitPositionOptions(deviceProfile)
                     .stream()
-                    .map((Function<SplitPositionOption, SystemShortcut>) option -> new SplitSelectSystemShortcut(
-                            activity, taskView, option))
+                    .map((Function<SplitPositionOption, SystemShortcut>) option ->
+                            new SplitSelectSystemShortcut(container, taskView, option))
                     .collect(Collectors.toList());
         }
     };
@@ -318,53 +329,74 @@ public interface TaskShortcutFactory {
     TaskShortcutFactory SAVE_APP_PAIR = new TaskShortcutFactory() {
         @Nullable
         @Override
-        public List<SystemShortcut> getShortcuts(BaseDraggingActivity activity,
-                TaskIdAttributeContainer taskContainer) {
+        public List<SystemShortcut> getShortcuts(RecentsViewContainer container,
+                                                 TaskContainer taskContainer) {
+            DeviceProfile deviceProfile = container.getDeviceProfile();
             final TaskView taskView = taskContainer.getTaskView();
+            final RecentsView recentsView = taskView.getRecentsView();
+            boolean isLargeTileFocusedTask = deviceProfile.isTablet && taskView.isFocusedTask();
+            boolean isInExpectedScrollPosition =
+                    recentsView.isTaskInExpectedScrollPosition(recentsView.indexOfChild(taskView));
+            boolean shouldShowActionsButtonInstead =
+                    isLargeTileFocusedTask && isInExpectedScrollPosition;
 
-            if (!FeatureFlags.ENABLE_APP_PAIRS.get() || !taskView.containsMultipleTasks()) {
+            // No "save app pair" menu item if:
+            // - we are in 3p launcher
+            // - the Overview Actions Button should be visible
+            // - the task view is not a valid save-able split pair
+            if (!recentsView.supportsAppPairs()
+                    || shouldShowActionsButtonInstead
+                    || !recentsView.getSplitSelectController().getAppPairsController()
+                    .canSaveAppPair(taskView)) {
                 return null;
             }
 
-            return Collections.singletonList(new SaveAppPairSystemShortcut(activity, taskView));
+            int iconResId = deviceProfile.isLeftRightSplit
+                    ? R.drawable.ic_save_app_pair_left_right
+                    : R.drawable.ic_save_app_pair_up_down;
+
+            return Collections.singletonList(
+                    new SaveAppPairSystemShortcut(container,
+                            (GroupedTaskView) taskView, iconResId));
         }
 
         @Override
-        public boolean showForSplitscreen() {
+        public boolean showForGroupedTask() {
             return true;
         }
     };
 
     TaskShortcutFactory FREE_FORM = new TaskShortcutFactory() {
         @Override
-        public List<SystemShortcut> getShortcuts(BaseDraggingActivity activity,
-                TaskIdAttributeContainer taskContainer) {
+        public List<SystemShortcut> getShortcuts(RecentsViewContainer container,
+                                                 TaskContainer taskContainer) {
             final Task task = taskContainer.getTask();
             if (!task.isDockable) {
                 return null;
             }
-            if (!isAvailable(activity, task.key.displayId)) {
+            if (!isAvailable(container)) {
                 return null;
             }
 
             return Collections.singletonList(new FreeformSystemShortcut(
                     R.drawable.ic_caption_desktop_button_foreground,
-                    R.string.recent_task_option_freeform, activity, taskContainer,
+                    R.string.recent_task_option_freeform, container, taskContainer,
                     LAUNCHER_SYSTEM_SHORTCUT_FREE_FORM_TAP));
         }
 
-        private boolean isAvailable(BaseDraggingActivity activity, int displayId) {
-            return ActivityManagerWrapper.getInstance().supportsFreeformMultiWindow(activity)
-                    && !SystemProperties.getBoolean("persist.wm.debug.desktop_mode", false)
-                    && !SystemProperties.getBoolean("persist.wm.debug.desktop_mode_2", false);
+        private boolean isAvailable(RecentsViewContainer container) {
+            return Settings.Global.getInt(
+                    container.asContext().getContentResolver(),
+                    Settings.Global.DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT, 0) != 0
+                    && !enableDesktopWindowingMode();
         }
     };
 
     TaskShortcutFactory PIN = new TaskShortcutFactory() {
         @Override
-        public List<SystemShortcut> getShortcuts(BaseDraggingActivity activity,
-                TaskIdAttributeContainer taskContainer) {
-            if (!SystemUiProxy.INSTANCE.get(activity).isActive()) {
+        public List<SystemShortcut> getShortcuts(RecentsViewContainer container,
+                                                 TaskContainer taskContainer) {
+            if (!SystemUiProxy.INSTANCE.get(container.asContext()).isActive()) {
                 return null;
             }
             if (!ActivityManagerWrapper.getInstance().isScreenPinningEnabled()) {
@@ -374,18 +406,18 @@ public interface TaskShortcutFactory {
                 // We shouldn't be able to pin while an app is locked.
                 return null;
             }
-            return Collections.singletonList(new PinSystemShortcut(activity, taskContainer));
+            return Collections.singletonList(new PinSystemShortcut(container, taskContainer));
         }
     };
 
-    class PinSystemShortcut extends SystemShortcut<BaseDraggingActivity> {
+    class PinSystemShortcut extends SystemShortcut<RecentsViewContainer> {
 
         private static final String TAG = "PinSystemShortcut";
 
         private final TaskView mTaskView;
 
-        public PinSystemShortcut(BaseDraggingActivity target,
-                TaskIdAttributeContainer taskContainer) {
+        public PinSystemShortcut(RecentsViewContainer target,
+                                 TaskContainer taskContainer) {
             super(R.drawable.ic_pin, R.string.recent_task_option_pin, target,
                     taskContainer.getItemInfo(), taskContainer.getTaskView());
             mTaskView = taskContainer.getTaskView();
@@ -394,57 +426,80 @@ public interface TaskShortcutFactory {
         @Override
         public void onClick(View view) {
             if (mTaskView.launchTaskAnimated() != null) {
-                SystemUiProxy.INSTANCE.get(mTarget).startScreenPinning(mTaskView.getTask().key.id);
+                SystemUiProxy.INSTANCE.get(mTarget.asContext()).startScreenPinning(
+                        mTaskView.getFirstTask().key.id);
             }
-            dismissTaskMenuView(mTarget);
-            mTarget.getStatsLogManager().logger().withItemInfo(mTaskView.getItemInfo())
+            dismissTaskMenuView();
+            mTarget.getStatsLogManager().logger().withItemInfo(mTaskView.getFirstItemInfo())
                     .log(LauncherEvent.LAUNCHER_SYSTEM_SHORTCUT_PIN_TAP);
         }
     }
 
     TaskShortcutFactory INSTALL = new TaskShortcutFactory() {
         @Override
-        public List<SystemShortcut> getShortcuts(BaseDraggingActivity activity,
-                TaskIdAttributeContainer taskContainer) {
+        public List<SystemShortcut> getShortcuts(RecentsViewContainer container,
+                                                 TaskContainer taskContainer) {
             Task t = taskContainer.getTask();
-            return InstantAppResolver.newInstance(activity).isInstantApp(
+            return InstantAppResolver.newInstance(container.asContext()).isInstantApp(
                     t.getTopComponent().getPackageName(), t.getKey().userId)
-                            ? Collections.singletonList(new SystemShortcut.Install(activity,
-                                    taskContainer.getItemInfo(), taskContainer.getTaskView()))
-                            : null;
+                    ? Collections.singletonList(new SystemShortcut.Install(container,
+                    taskContainer.getItemInfo(), taskContainer.getTaskView()))
+                    : null;
         }
     };
 
     TaskShortcutFactory WELLBEING = new TaskShortcutFactory() {
         @Override
-        public List<SystemShortcut> getShortcuts(BaseDraggingActivity activity,
-                TaskIdAttributeContainer taskContainer) {
-            SystemShortcut<BaseDraggingActivity> wellbeingShortcut = WellbeingModel.SHORTCUT_FACTORY.getShortcut(
-                    activity,
-                    taskContainer.getItemInfo(), taskContainer.getTaskView());
+        public List<SystemShortcut> getShortcuts(RecentsViewContainer container,
+                                                 TaskContainer taskContainer) {
+            SystemShortcut<ActivityContext> wellbeingShortcut =
+                    WellbeingModel.SHORTCUT_FACTORY.getShortcut(container,
+                            taskContainer.getItemInfo(), taskContainer.getTaskView());
             return createSingletonShortcutList(wellbeingShortcut);
         }
     };
 
     TaskShortcutFactory SCREENSHOT = new TaskShortcutFactory() {
         @Override
-        public List<SystemShortcut> getShortcuts(BaseDraggingActivity activity,
-                TaskIdAttributeContainer taskContainer) {
-            SystemShortcut screenshotShortcut = taskContainer.getThumbnailView().getTaskOverlay()
-                    .getScreenshotShortcut(activity, taskContainer.getItemInfo(),
-                            taskContainer.getTaskView());
+        public List<SystemShortcut> getShortcuts(RecentsViewContainer container,
+                                                 TaskContainer taskContainer) {
+            boolean isTablet = container.getDeviceProfile().isTablet;
+            boolean isGridOnlyOverview = isTablet && Flags.enableGridOnlyOverview();
+            // Extra conditions if it's not grid-only overview
+            if (!isGridOnlyOverview) {
+                RecentsOrientedState orientedState = taskContainer.getTaskView().getOrientedState();
+                boolean isFakeLandscape = !orientedState.isRecentsActivityRotationAllowed()
+                        && orientedState.getTouchRotation() != ROTATION_0;
+                if (!isFakeLandscape) {
+                    return null;
+                }
+            }
+
+            SystemShortcut screenshotShortcut = taskContainer.getOverlay().getScreenshotShortcut(
+                    container, taskContainer.getItemInfo(), taskContainer.getTaskView());
             return createSingletonShortcutList(screenshotShortcut);
         }
+
+        @Override
+        public boolean showForDesktopTask() {
+            return true;
+        }
     };
 
     TaskShortcutFactory MODAL = new TaskShortcutFactory() {
         @Override
-        public List<SystemShortcut> getShortcuts(BaseDraggingActivity activity,
-                TaskIdAttributeContainer taskContainer) {
-            SystemShortcut modalStateSystemShortcut = taskContainer.getThumbnailView().getTaskOverlay()
-                    .getModalStateSystemShortcut(
+        public List<SystemShortcut> getShortcuts(RecentsViewContainer container,
+                                                 TaskContainer taskContainer) {
+            boolean isTablet = container.getDeviceProfile().isTablet;
+            boolean isGridOnlyOverview = isTablet && Flags.enableGridOnlyOverview();
+            if (!isGridOnlyOverview) {
+                return null;
+            }
+
+            SystemShortcut modalStateSystemShortcut =
+                    taskContainer.getOverlay().getModalStateSystemShortcut(
                             taskContainer.getItemInfo(), taskContainer.getTaskView());
             return createSingletonShortcutList(modalStateSystemShortcut);
         }
     };
-}
+}
\ No newline at end of file
diff --git a/quickstep/src/com/android/quickstep/TaskViewUtils.java b/quickstep/src/com/android/quickstep/TaskViewUtils.java
index b8c9f1e9d6..6fb0f69416 100644
--- a/quickstep/src/com/android/quickstep/TaskViewUtils.java
+++ b/quickstep/src/com/android/quickstep/TaskViewUtils.java
@@ -18,8 +18,6 @@ package com.android.quickstep;
 import static android.view.RemoteAnimationTarget.MODE_CLOSING;
 import static android.view.RemoteAnimationTarget.MODE_OPENING;
 import static android.view.WindowManager.LayoutParams.TYPE_DOCK_DIVIDER;
-import static android.view.WindowManager.TRANSIT_OPEN;
-import static android.view.WindowManager.TRANSIT_TO_FRONT;
 
 import static com.android.app.animation.Interpolators.LINEAR;
 import static com.android.app.animation.Interpolators.TOUCH_RESPONSE;
@@ -38,23 +36,19 @@ import static com.android.launcher3.QuickstepTransitionManager.RECENTS_LAUNCH_DU
 import static com.android.launcher3.QuickstepTransitionManager.SPLIT_DIVIDER_ANIM_DURATION;
 import static com.android.launcher3.QuickstepTransitionManager.SPLIT_LAUNCH_DURATION;
 import static com.android.launcher3.Utilities.getDescendantCoordRelativeToAncestor;
-import static com.android.launcher3.testing.shared.TestProtocol.LAUNCH_SPLIT_PAIR;
-import static com.android.launcher3.testing.shared.TestProtocol.testLogD;
 import static com.android.launcher3.util.MultiPropertyFactory.MULTI_PROPERTY_VALUE;
-import static com.android.quickstep.views.DesktopTaskView.DESKTOP_MODE_SUPPORTED;
+import static com.android.quickstep.util.AnimUtils.clampToDuration;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
 import android.animation.ValueAnimator;
-import android.annotation.TargetApi;
 import android.content.ComponentName;
 import android.content.Context;
 import android.graphics.Matrix;
 import android.graphics.Matrix.ScaleToFit;
 import android.graphics.Rect;
 import android.graphics.RectF;
-import android.os.Build;
 import android.view.RemoteAnimationTarget;
 import android.view.SurfaceControl;
 import android.view.View;
@@ -64,6 +58,7 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
 import com.android.app.animation.Interpolators;
+import com.android.internal.jank.Cuj;
 import com.android.launcher3.BaseActivity;
 import com.android.launcher3.DeviceProfile;
 import com.android.launcher3.anim.AnimatedFloat;
@@ -73,6 +68,7 @@ import com.android.launcher3.anim.PendingAnimation;
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.statehandlers.DepthController;
 import com.android.launcher3.statemanager.StateManager;
+import com.android.launcher3.taskbar.TaskbarUIController;
 import com.android.launcher3.util.DisplayController;
 import com.android.quickstep.RemoteTargetGluer.RemoteTargetHandle;
 import com.android.quickstep.util.MultiValueUpdateListener;
@@ -84,36 +80,29 @@ import com.android.quickstep.util.TransformParams;
 import com.android.quickstep.views.DesktopTaskView;
 import com.android.quickstep.views.GroupedTaskView;
 import com.android.quickstep.views.RecentsView;
-import com.android.quickstep.views.TaskThumbnailView;
+import com.android.quickstep.views.TaskThumbnailViewDeprecated;
 import com.android.quickstep.views.TaskView;
+import com.android.systemui.animation.RemoteAnimationTargetCompat;
 import com.android.systemui.shared.recents.model.Task;
 import com.android.systemui.shared.system.InteractionJankMonitorWrapper;
-import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
 
 /**
- * Utility class for helpful methods related to {@link TaskView} objects and
- * their tasks.
+ * Utility class for helpful methods related to {@link TaskView} objects and their tasks.
  */
-@TargetApi(Build.VERSION_CODES.R)
 public final class TaskViewUtils {
 
-    private TaskViewUtils() {
-    }
+    private TaskViewUtils() {}
 
     /**
-     * Try to find a TaskView that corresponds with the component of the launched
-     * view.
+     * Try to find a TaskView that corresponds with the component of the launched view.
      *
-     * If this method returns a non-null TaskView, it will be used in
-     * composeRecentsLaunchAnimation.
-     * Otherwise, we will assume we are using a normal app transition, but it's
-     * possible that the
-     * opening remote target (which we don't get until onAnimationStart) will
-     * resolve to a TaskView.
+     * If this method returns a non-null TaskView, it will be used in composeRecentsLaunchAnimation.
+     * Otherwise, we will assume we are using a normal app transition, but it's possible that the
+     * opening remote target (which we don't get until onAnimationStart) will resolve to a TaskView.
      */
     public static TaskView findTaskViewToLaunch(
             RecentsView recentsView, View v, RemoteAnimationTarget[] targets) {
@@ -122,8 +111,7 @@ public final class TaskViewUtils {
             return recentsView.isTaskViewVisible(taskView) ? taskView : null;
         }
 
-        // It's possible that the launched view can still be resolved to a visible task
-        // view, check
+        // It's possible that the launched view can still be resolved to a visible task view, check
         // the task id of the opening task and see if we can find a match.
         if (v.getTag() instanceof ItemInfo) {
             ItemInfo itemInfo = (ItemInfo) v.getTag();
@@ -133,7 +121,7 @@ public final class TaskViewUtils {
                 for (int i = 0; i < recentsView.getTaskViewCount(); i++) {
                     TaskView taskView = recentsView.getTaskViewAt(i);
                     if (recentsView.isTaskViewVisible(taskView)) {
-                        Task.TaskKey key = taskView.getTask().key;
+                        Task.TaskKey key = taskView.getFirstTask().key;
                         if (componentName.equals(key.getComponent()) && userId == key.userId) {
                             return taskView;
                         }
@@ -154,14 +142,12 @@ public final class TaskViewUtils {
             }
         }
 
-        // If there is no opening task id, fall back to the normal app icon launch
-        // animation
+        // If there is no opening task id, fall back to the normal app icon launch animation
         if (openingTaskId == -1) {
             return null;
         }
 
-        // If the opening task id is not currently visible in overview, then fall back
-        // to normal app
+        // If the opening task id is not currently visible in overview, then fall back to normal app
         // icon launch animation
         TaskView taskView = recentsView.getTaskViewByTaskId(openingTaskId);
         if (taskView == null || !recentsView.isTaskViewVisible(taskView)) {
@@ -179,11 +165,12 @@ public final class TaskViewUtils {
             @NonNull RemoteAnimationTarget[] nonAppTargets,
             @Nullable DepthController depthController,
             PendingAnimation out) {
-        boolean isQuickSwitch = v.isEndQuickswitchCuj();
-        v.setEndQuickswitchCuj(false);
+        boolean isQuickSwitch = v.isEndQuickSwitchCuj();
+        v.setEndQuickSwitchCuj(false);
 
-        final RemoteAnimationTargets targets = new RemoteAnimationTargets(appTargets, wallpaperTargets, nonAppTargets,
-                MODE_OPENING);
+        final RemoteAnimationTargets targets =
+                new RemoteAnimationTargets(appTargets, wallpaperTargets, nonAppTargets,
+                        MODE_OPENING);
         final RemoteAnimationTarget navBarTarget = targets.getNavBarRemoteAnimationTarget();
 
         SurfaceTransactionApplier applier = new SurfaceTransactionApplier(v);
@@ -195,19 +182,25 @@ public final class TaskViewUtils {
             // Re-use existing handles
             remoteTargetHandles = recentsViewHandles;
         } else {
-            boolean forDesktop = DESKTOP_MODE_SUPPORTED && v instanceof DesktopTaskView;
+            boolean forDesktop = v instanceof DesktopTaskView;
             RemoteTargetGluer gluer = new RemoteTargetGluer(v.getContext(),
                     recentsView.getSizeStrategy(), targets, forDesktop);
             if (forDesktop) {
                 remoteTargetHandles = gluer.assignTargetsForDesktop(targets);
             } else if (v.containsMultipleTasks()) {
-                remoteTargetHandles = gluer.assignTargetsForSplitScreen(targets);
+                remoteTargetHandles = gluer.assignTargetsForSplitScreen(targets,
+                        ((GroupedTaskView) v).getSplitBoundsConfig());
             } else {
                 remoteTargetHandles = gluer.assignTargets(targets);
             }
         }
-        for (RemoteTargetHandle remoteTargetGluer : remoteTargetHandles) {
-            remoteTargetGluer.getTransformParams().setSyncTransactionApplier(applier);
+
+        final int recentsActivityRotation =
+                recentsView.getPagedViewOrientedState().getRecentsActivityRotation();
+        for (RemoteTargetHandle remoteTargetHandle : remoteTargetHandles) {
+            remoteTargetHandle.getTaskViewSimulator().getOrientationState()
+                    .setRecentsRotation(recentsActivityRotation);
+            remoteTargetHandle.getTransformParams().setSyncTransactionApplier(applier);
         }
 
         int taskIndex = recentsView.indexOfChild(v);
@@ -215,7 +208,8 @@ public final class TaskViewUtils {
         BaseActivity baseActivity = BaseActivity.fromContext(context);
         DeviceProfile dp = baseActivity.getDeviceProfile();
         boolean showAsGrid = dp.isTablet;
-        boolean parallaxCenterAndAdjacentTask = taskIndex != recentsView.getCurrentPage();
+        boolean parallaxCenterAndAdjacentTask =
+                !showAsGrid && taskIndex != recentsView.getCurrentPage();
         int taskRectTranslationPrimary = recentsView.getScrollOffset(taskIndex);
         int taskRectTranslationSecondary = showAsGrid ? (int) v.getGridTranslationY() : 0;
 
@@ -227,8 +221,7 @@ public final class TaskViewUtils {
                 TaskViewSimulator tvsLocal = targetHandle.getTaskViewSimulator();
                 tvsLocal.setDp(dp);
 
-                // RecentsView never updates the display rotation until swipe-up so the value
-                // may
+                // RecentsView never updates the display rotation until swipe-up so the value may
                 // be stale. Use the display value instead.
                 int displayRotation = DisplayController.INSTANCE.get(context).getInfo().rotation;
                 tvsLocal.getOrientationState().update(displayRotation, displayRotation);
@@ -274,18 +267,26 @@ public final class TaskViewUtils {
             if (navBarTarget != null) {
                 final Rect cropRect = new Rect();
                 out.addOnFrameListener(new MultiValueUpdateListener() {
-                    FloatProp mNavFadeOut = new FloatProp(1f, 0f, 0,
-                            ANIMATION_NAV_FADE_OUT_DURATION, NAV_FADE_OUT_INTERPOLATOR);
-                    FloatProp mNavFadeIn = new FloatProp(0f, 1f, ANIMATION_DELAY_NAV_FADE_IN,
-                            ANIMATION_NAV_FADE_IN_DURATION, NAV_FADE_IN_INTERPOLATOR);
+                    FloatProp mNavFadeOut = new FloatProp(1f, 0f, clampToDuration(
+                            NAV_FADE_OUT_INTERPOLATOR,
+                            0,
+                            ANIMATION_NAV_FADE_OUT_DURATION,
+                            out.getDuration()));
+                    FloatProp mNavFadeIn = new FloatProp(0f, 1f, clampToDuration(
+                            NAV_FADE_IN_INTERPOLATOR,
+                            ANIMATION_DELAY_NAV_FADE_IN,
+                            ANIMATION_NAV_FADE_IN_DURATION,
+                            out.getDuration()));
 
                     @Override
                     public void onUpdate(float percent, boolean initOnly) {
 
+
                         // TODO Do we need to operate over multiple TVSs for the navbar leash?
                         for (RemoteTargetHandle handle : remoteTargetHandles) {
                             SurfaceTransaction transaction = new SurfaceTransaction();
-                            SurfaceProperties navBuilder = transaction.forSurface(navBarTarget.leash);
+                            SurfaceProperties navBuilder =
+                                    transaction.forSurface(navBarTarget.leash);
 
                             if (mNavFadeIn.value > mNavFadeIn.getStartValue()) {
                                 TaskViewSimulator taskViewSimulator = handle.getTaskViewSimulator();
@@ -301,10 +302,10 @@ public final class TaskViewUtils {
                     }
                 });
             } else {
-                // There is no transition animation for app launch from recent in live tile mode
-                // so
+                // There is no transition animation for app launch from recent in live tile mode so
                 // we have to trigger the navigation bar animation from system here.
-                final RecentsAnimationController controller = recentsView.getRecentsAnimationController();
+                final RecentsAnimationController controller =
+                        recentsView.getRecentsAnimationController();
                 if (controller != null) {
                     controller.animateNavigationBarToApp(RECENTS_LAUNCH_DURATION);
                 }
@@ -323,37 +324,29 @@ public final class TaskViewUtils {
 
             // Mt represents the overall transformation on the thumbnailView relative to the
             // Launcher's rootView
-            // K(t) represents transformation on the running window by the taskViewSimulator
-            // at
+            // K(t) represents transformation on the running window by the taskViewSimulator at
             // any time t.
-            // at t = 0, we know that the simulator matches the thumbnailView. So if we
-            // apply K(0)`
-            // on the Launcher's rootView, the thumbnailView would match the full running
-            // task
-            // window. If we apply "K(0)` K(t)" thumbnailView will match the final
-            // transformed
+            // at t = 0, we know that the simulator matches the thumbnailView. So if we apply K(0)`
+            // on the Launcher's rootView, the thumbnailView would match the full running task
+            // window. If we apply "K(0)` K(t)" thumbnailView will match the final transformed
             // window at any time t. This gives the overall matrix on thumbnailView to be:
-            // Mt K(0)` K(t)
-            // During animation we apply transformation on the thumbnailView (and not the
-            // rootView)
-            // to follow the TaskViewSimulator. So the final matrix applied on the
-            // thumbnailView is:
-            // Mt K(0)` K(t) Mt`
-            TaskThumbnailView[] thumbnails = v.getThumbnails();
+            //    Mt K(0)` K(t)
+            // During animation we apply transformation on the thumbnailView (and not the rootView)
+            // to follow the TaskViewSimulator. So the final matrix applied on the thumbnailView is:
+            //    Mt K(0)` K(t) Mt`
+            TaskThumbnailViewDeprecated[] thumbnails = v.getThumbnailViews();
 
-            // In case simulator copies and thumbnail size do no match, ensure we get the
-            // lesser.
-            // This ensures we do not create arrays with empty elements or attempt to
-            // references
+            // In case simulator copies and thumbnail size do no match, ensure we get the lesser.
+            // This ensures we do not create arrays with empty elements or attempt to references
             // indexes out of array bounds.
             final int matrixSize = Math.min(simulatorCopies.length, thumbnails.length);
 
             Matrix[] mt = new Matrix[matrixSize];
             Matrix[] mti = new Matrix[matrixSize];
             for (int i = 0; i < matrixSize; i++) {
-                TaskThumbnailView ttv = thumbnails[i];
-                RectF localBounds = new RectF(0, 0, ttv.getWidth(), ttv.getHeight());
-                float[] tvBoundsMapped = new float[] { 0, 0, ttv.getWidth(), ttv.getHeight() };
+                TaskThumbnailViewDeprecated ttv = thumbnails[i];
+                RectF localBounds = new RectF(0, 0,  ttv.getWidth(), ttv.getHeight());
+                float[] tvBoundsMapped = new float[]{0, 0,  ttv.getWidth(), ttv.getHeight()};
                 getDescendantCoordRelativeToAncestor(ttv, ttv.getRootView(), tvBoundsMapped, false);
                 RectF localBoundsInRoot = new RectF(
                         tvBoundsMapped[0], tvBoundsMapped[1],
@@ -366,12 +359,12 @@ public final class TaskViewUtils {
                 localMt.invert(localMti);
                 mti[i] = localMti;
 
-                // Translations for child thumbnails also get scaled as the parent taskView
-                // scales
+                // Translations for child thumbnails also get scaled as the parent taskView scales
                 // Add inverse scaling to keep translations the same
                 float translationY = ttv.getTranslationY();
                 float translationX = ttv.getTranslationX();
-                float fullScreenScale = topMostSimulators[i].getTaskViewSimulator().getFullScreenScale();
+                float fullScreenScale =
+                        topMostSimulators[i].getTaskViewSimulator().getFullScreenScale();
                 out.addFloat(ttv, VIEW_TRANSLATE_Y, translationY,
                         translationY / fullScreenScale, TOUCH_RESPONSE);
                 out.addFloat(ttv, VIEW_TRANSLATE_X, translationX,
@@ -398,7 +391,7 @@ public final class TaskViewUtils {
             out.addListener(new AnimatorListenerAdapter() {
                 @Override
                 public void onAnimationEnd(Animator animation) {
-                    for (TaskThumbnailView ttv : thumbnails) {
+                    for (TaskThumbnailViewDeprecated ttv : thumbnails) {
                         ttv.setAnimationMatrix(null);
                     }
                 }
@@ -406,11 +399,17 @@ public final class TaskViewUtils {
         }
 
         out.addListener(new AnimationSuccessListener() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+                for (RemoteTargetHandle remoteTargetHandle : remoteTargetHandles) {
+                    remoteTargetHandle.getTaskViewSimulator().setDrawsBelowRecents(false);
+                }
+            }
+
             @Override
             public void onAnimationSuccess(Animator animator) {
                 if (isQuickSwitch) {
-                    InteractionJankMonitorWrapper.end(
-                            InteractionJankMonitorWrapper.CUJ_QUICK_SWITCH);
+                    InteractionJankMonitorWrapper.end(Cuj.CUJ_LAUNCHER_QUICK_SWITCH);
                 }
             }
 
@@ -428,135 +427,52 @@ public final class TaskViewUtils {
     }
 
     /**
-     * If {@param launchingTaskView} is not null, then this will play the tasks
-     * launch animation
-     * from the position of the GroupedTaskView (when user taps on the TaskView to
-     * start it).
+     * If {@param launchingTaskView} is not null, then this will play the tasks launch animation
+     * from the position of the GroupedTaskView (when user taps on the TaskView to start it).
      * Technically this case should be taken care of by
-     * {@link #composeRecentsSplitLaunchAnimatorLegacy} below, but the way we launch
-     * tasks whether
+     * {@link #composeRecentsSplitLaunchAnimatorLegacy} below, but the way we launch tasks whether
      * it's a single task or multiple tasks results in different entry-points.
-     *
-     * If it is null, then it will simply fade in the starting apps and fade out
-     * launcher (for the
-     * case where launcher handles animating starting split tasks from app icon)
      */
     public static void composeRecentsSplitLaunchAnimator(GroupedTaskView launchingTaskView,
-            @NonNull StateManager stateManager, @Nullable DepthController depthController,
-            int initialTaskId, int secondTaskId, @NonNull TransitionInfo transitionInfo,
-            SurfaceControl.Transaction t, @NonNull Runnable finishCallback) {
-        if (launchingTaskView != null) {
-            testLogD(LAUNCH_SPLIT_PAIR, "composeRecentsSplitLaunchAnimator taskView not-null");
-            AnimatorSet animatorSet = new AnimatorSet();
-            animatorSet.addListener(new AnimatorListenerAdapter() {
-                @Override
-                public void onAnimationEnd(Animator animation) {
-                    finishCallback.run();
-                }
-            });
-
-            final RemoteAnimationTarget[] appTargets = RemoteAnimationTargetCompat.wrapApps(transitionInfo, t,
-                    null /* leashMap */);
-            final RemoteAnimationTarget[] wallpaperTargets = RemoteAnimationTargetCompat.wrapNonApps(
-                    transitionInfo, true /* wallpapers */, t, null /* leashMap */);
-            final RemoteAnimationTarget[] nonAppTargets = RemoteAnimationTargetCompat.wrapNonApps(
-                    transitionInfo, false /* wallpapers */, t, null /* leashMap */);
-            final RecentsView recentsView = launchingTaskView.getRecentsView();
-            composeRecentsLaunchAnimator(animatorSet, launchingTaskView,
-                    appTargets, wallpaperTargets, nonAppTargets,
-                    true, stateManager,
-                    recentsView, depthController);
-
-            t.apply();
-            animatorSet.start();
-            return;
-        }
-
-        TransitionInfo.Change splitRoot1 = null;
-        TransitionInfo.Change splitRoot2 = null;
-        final ArrayList<SurfaceControl> openingTargets = new ArrayList<>();
-        for (int i = 0; i < transitionInfo.getChanges().size(); ++i) {
-            final TransitionInfo.Change change = transitionInfo.getChanges().get(i);
-            if (change.getTaskInfo() == null) {
-                testLogD(LAUNCH_SPLIT_PAIR, "changeTaskInfo null; change: " + change);
-                continue;
-            }
-            final int taskId = change.getTaskInfo().taskId;
-            final int mode = change.getMode();
-
-            // Find the target tasks' root tasks since those are the split stages that need
-            // to
-            // be animated (the tasks themselves are children and thus inherit animation).
-            if (taskId == initialTaskId || taskId == secondTaskId) {
-                if (!(mode == TRANSIT_OPEN || mode == TRANSIT_TO_FRONT)) {
-                    throw new IllegalStateException(
-                            "Expected task to be showing, but it is " + mode);
-                }
-            }
-            if (taskId == initialTaskId) {
-                splitRoot1 = change.getParent() == null ? change :
-                        transitionInfo.getChange(change.getParent());
-                openingTargets.add(splitRoot1.getLeash());
-            }
-            if (taskId == secondTaskId) {
-                splitRoot2 = change.getParent() == null ? change :
-                        transitionInfo.getChange(change.getParent());
-                openingTargets.add(splitRoot2.getLeash());
-            }
-        }
-
-        SurfaceControl.Transaction animTransaction = new SurfaceControl.Transaction();
-        ValueAnimator animator = ValueAnimator.ofFloat(0f, 1f);
-        animator.setDuration(SPLIT_LAUNCH_DURATION);
-        animator.addUpdateListener(valueAnimator -> {
-            float progress = valueAnimator.getAnimatedFraction();
-            for (SurfaceControl leash : openingTargets) {
-                animTransaction.setAlpha(leash, progress);
-            }
-            animTransaction.apply();
-        });
-        animator.addListener(new AnimatorListenerAdapter() {
-            @Override
-            public void onAnimationStart(Animator animation) {
-                for (SurfaceControl leash : openingTargets) {
-                    animTransaction.show(leash)
-                            .setAlpha(leash, 0.0f);
-                }
-                animTransaction.apply();
-            }
-
+                                                         @NonNull StateManager stateManager, @Nullable DepthController depthController,
+                                                         @NonNull TransitionInfo transitionInfo, SurfaceControl.Transaction t,
+                                                         @NonNull Runnable finishCallback) {
+        AnimatorSet animatorSet = new AnimatorSet();
+        animatorSet.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
                 finishCallback.run();
             }
         });
 
-        if (splitRoot1 != null && splitRoot1.getParent() != null) {
-            // Set the highest level split root alpha; we could technically use the parent
-            // of either
-            // splitRoot1 or splitRoot2
-            t.setAlpha(transitionInfo.getChange(splitRoot1.getParent()).getLeash(), 1f);
-        }
+        final RemoteAnimationTarget[] appTargets =
+                RemoteAnimationTargetCompat.wrapApps(transitionInfo, t, null /* leashMap */);
+        final RemoteAnimationTarget[] wallpaperTargets =
+                RemoteAnimationTargetCompat.wrapNonApps(
+                        transitionInfo, true /* wallpapers */, t, null /* leashMap */);
+        final RemoteAnimationTarget[] nonAppTargets =
+                RemoteAnimationTargetCompat.wrapNonApps(
+                        transitionInfo, false /* wallpapers */, t, null /* leashMap */);
+        final RecentsView recentsView = launchingTaskView.getRecentsView();
+        composeRecentsLaunchAnimator(animatorSet, launchingTaskView, appTargets, wallpaperTargets,
+                nonAppTargets, /* launcherClosing */ true, stateManager, recentsView,
+                depthController);
+
         t.apply();
-        animator.start();
+        animatorSet.start();
     }
 
     /**
      * Legacy version (until shell transitions are enabled)
      *
-     * If {@param launchingTaskView} is not null, then this will play the tasks
-     * launch animation
-     * from the position of the GroupedTaskView (when user taps on the TaskView to
-     * start it).
+     * If {@param launchingTaskView} is not null, then this will play the tasks launch animation
+     * from the position of the GroupedTaskView (when user taps on the TaskView to start it).
      * Technically this case should be taken care of by
-     * {@link #composeRecentsSplitLaunchAnimatorLegacy} below, but the way we launch
-     * tasks whether
+     * {@link #composeRecentsSplitLaunchAnimatorLegacy} below, but the way we launch tasks whether
      * it's a single task or multiple tasks results in different entry-points.
      *
-     * If it is null, then it will simply fade in the starting apps and fade out
-     * launcher (for the
+     * If it is null, then it will simply fade in the starting apps and fade out launcher (for the
      * case where launcher handles animating starting split tasks from app icon)
-     * 
      * @deprecated with shell transitions
      */
     public static void composeRecentsSplitLaunchAnimatorLegacy(
@@ -615,7 +531,7 @@ public final class TaskViewUtils {
         animator.setDuration(SPLIT_LAUNCH_DURATION);
         animator.addUpdateListener(valueAnimator -> {
             float progress = valueAnimator.getAnimatedFraction();
-            for (SurfaceControl leash : openingTargets) {
+            for (SurfaceControl leash: openingTargets) {
                 t.setAlpha(leash, progress);
             }
             t.apply();
@@ -623,7 +539,7 @@ public final class TaskViewUtils {
         animator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationStart(Animator animation) {
-                for (SurfaceControl leash : openingTargets) {
+                for (SurfaceControl leash: openingTargets) {
                     t.show(leash).setAlpha(leash, 0.0f);
                 }
                 t.apply();
@@ -631,7 +547,7 @@ public final class TaskViewUtils {
 
             @Override
             public void onAnimationEnd(Animator animation) {
-                for (SurfaceControl leash : closingTargets) {
+                for (SurfaceControl leash: closingTargets) {
                     t.hide(leash);
                 }
                 finishCallback.run();
@@ -640,23 +556,57 @@ public final class TaskViewUtils {
         animator.start();
     }
 
+    /**
+     * Start recents to desktop animation
+     */
+    public static void composeRecentsDesktopLaunchAnimator(
+            @NonNull DesktopTaskView launchingTaskView,
+            @NonNull StateManager stateManager, @Nullable DepthController depthController,
+            @NonNull TransitionInfo transitionInfo,
+            SurfaceControl.Transaction t, @NonNull Runnable finishCallback) {
+
+        AnimatorSet animatorSet = new AnimatorSet();
+        animatorSet.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+                t.apply();
+            }
+
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                finishCallback.run();
+            }
+        });
+
+        final RemoteAnimationTarget[] apps = RemoteAnimationTargetCompat.wrapApps(
+                transitionInfo, t, null /* leashMap */);
+        final RemoteAnimationTarget[] wallpaper = RemoteAnimationTargetCompat.wrapNonApps(
+                transitionInfo, true /* wallpapers */, t, null /* leashMap */);
+        final RemoteAnimationTarget[] nonApps = RemoteAnimationTargetCompat.wrapNonApps(
+                transitionInfo, false /* wallpapers */, t, null /* leashMap */);
+
+        composeRecentsLaunchAnimator(animatorSet, launchingTaskView, apps, wallpaper, nonApps,
+                true /* launcherClosing */, stateManager, launchingTaskView.getRecentsView(),
+                depthController);
+
+        animatorSet.start();
+    }
+
     public static void composeRecentsLaunchAnimator(@NonNull AnimatorSet anim, @NonNull View v,
-            @NonNull RemoteAnimationTarget[] appTargets,
-            @NonNull RemoteAnimationTarget[] wallpaperTargets,
-            @NonNull RemoteAnimationTarget[] nonAppTargets, boolean launcherClosing,
-            @NonNull StateManager stateManager, @NonNull RecentsView recentsView,
-            @Nullable DepthController depthController) {
+                                                    @NonNull RemoteAnimationTarget[] appTargets,
+                                                    @NonNull RemoteAnimationTarget[] wallpaperTargets,
+                                                    @NonNull RemoteAnimationTarget[] nonAppTargets, boolean launcherClosing,
+                                                    @NonNull StateManager stateManager, @NonNull RecentsView recentsView,
+                                                    @Nullable DepthController depthController) {
         boolean skipLauncherChanges = !launcherClosing;
 
         TaskView taskView = findTaskViewToLaunch(recentsView, v, appTargets);
-        if (taskView == null) return;
         PendingAnimation pa = new PendingAnimation(RECENTS_LAUNCH_DURATION);
         createRecentsWindowAnimator(recentsView, taskView, skipLauncherChanges, appTargets,
                 wallpaperTargets, nonAppTargets, depthController, pa);
         if (launcherClosing) {
-            // TODO(b/182592057): differentiate between "restore split" vs "launch
-            // fullscreen app"
-            TaskViewUtils.createSplitAuxiliarySurfacesAnimator(nonAppTargets, true /* shown */,
+            // TODO(b/182592057): differentiate between "restore split" vs "launch fullscreen app"
+            TaskViewUtils.createSplitAuxiliarySurfacesAnimator(nonAppTargets, true /*shown*/,
                     (dividerAnimator) -> {
                         // If split apps are launching, we want to delay showing the divider bar
                         // until the very end once the apps are mostly in place. This is because we
@@ -669,19 +619,16 @@ public final class TaskViewUtils {
         }
 
         Animator childStateAnimation = null;
-        // Found a visible recents task that matches the opening app, lets launch the
-        // app from there
+        // Found a visible recents task that matches the opening app, lets launch the app from there
         Animator launcherAnim;
         final AnimatorListenerAdapter windowAnimEndListener;
         if (launcherClosing) {
-            // Since Overview is in launcher, just opening overview sets willFinishToHome to
-            // true.
-            // Now that we are closing the launcher, we need to (re)set willFinishToHome
-            // back to
-            // false. Otherwise, RecentsAnimationController can't differentiate between
-            // closing
+            // Since Overview is in launcher, just opening overview sets willFinishToHome to true.
+            // Now that we are closing the launcher, we need to (re)set willFinishToHome back to
+            // false. Otherwise, RecentsAnimationController can't differentiate between closing
             // overview to 3p home vs closing overview to app.
-            final RecentsAnimationController raController = recentsView.getRecentsAnimationController();
+            final RecentsAnimationController raController =
+                    recentsView.getRecentsAnimationController();
             if (raController != null) {
                 raController.setWillFinishToHome(false);
             }
@@ -689,26 +636,55 @@ public final class TaskViewUtils {
             launcherAnim.setInterpolator(Interpolators.TOUCH_RESPONSE);
             launcherAnim.setDuration(RECENTS_LAUNCH_DURATION);
 
-            windowAnimEndListener = new AnimatorListenerAdapter() {
+            windowAnimEndListener = new AnimationSuccessListener() {
                 @Override
                 public void onAnimationStart(Animator animation) {
                     recentsView.onTaskLaunchedInLiveTileMode();
                 }
 
                 // Make sure recents gets fixed up by resetting task alphas and scales, etc.
+                // This should only be run onAnimationSuccess, otherwise finishRecentsAnimation will
+                // interfere with a rapid swipe up to home in the live tile + running task case.
                 @Override
-                public void onAnimationEnd(Animator animation) {
+                public void onAnimationSuccess(Animator animation) {
                     recentsView.finishRecentsAnimation(false /* toRecents */, () -> {
                         recentsView.post(() -> {
                             stateManager.moveToRestState();
                             stateManager.reapplyState();
+
+                            // We may have notified launcher is not visible so that taskbar can
+                            // stash immediately. Now that the animation is over, we can update
+                            // that launcher is still visible.
+                            TaskbarUIController controller = recentsView.getSizeStrategy()
+                                    .getTaskbarController();
+                            if (controller != null) {
+                                boolean launcherVisible = true;
+                                for (RemoteAnimationTarget target : appTargets) {
+                                    launcherVisible &= target.isTranslucent;
+                                }
+                                if (launcherVisible) {
+                                    controller.onLauncherVisibilityChanged(true);
+                                }
+                            }
                         });
                     });
                 }
+
+                @Override
+                public void onAnimationCancel(Animator animation) {
+                    super.onAnimationCancel(animation);
+                    recentsView.onTaskLaunchedInLiveTileModeCancelled();
+                }
+
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    super.onAnimationEnd(animation);
+                    recentsView.setTaskLaunchCancelledRunnable(null);
+                }
             };
         } else {
-            AnimatorPlaybackController controller = stateManager.createAnimationToNewWorkspace(NORMAL,
-                    RECENTS_LAUNCH_DURATION);
+            AnimatorPlaybackController controller =
+                    stateManager.createAnimationToNewWorkspace(NORMAL, RECENTS_LAUNCH_DURATION);
             controller.dispatchOnStart();
             childStateAnimation = controller.getTarget();
             launcherAnim = controller.getAnimationPlayer().setDuration(RECENTS_LAUNCH_DURATION);
@@ -726,18 +702,15 @@ public final class TaskViewUtils {
         }
         anim.play(pa.buildAnim());
 
-        // Set the current animation first, before adding windowAnimEndListener. Setting
-        // current
-        // animation adds some listeners which need to be called before
-        // windowAnimEndListener
+        // Set the current animation first, before adding windowAnimEndListener. Setting current
+        // animation adds some listeners which need to be called before windowAnimEndListener
         // (the ordering of listeners matter in this case).
         stateManager.setCurrentAnimation(anim, childStateAnimation);
         anim.addListener(windowAnimEndListener);
     }
 
     /**
-     * Creates an animation to show/hide the auxiliary surfaces (aka. divider bar),
-     * only calling
+     * Creates an animation to show/hide the auxiliary surfaces (aka. divider bar), only calling
      * {@param animatorHandler} if there are valid surfaces to animate.
      * Passing null handler to apply the visibility immediately.
      *
@@ -812,4 +785,4 @@ public final class TaskViewUtils {
         animatorHandler.accept(dockFadeAnimator);
         return dockFadeAnimator;
     }
-}
+}
\ 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 b0361f793e..96055e4b8d 100644
--- a/quickstep/src/com/android/quickstep/TouchInteractionService.java
+++ b/quickstep/src/com/android/quickstep/TouchInteractionService.java
@@ -23,11 +23,17 @@ import static android.view.MotionEvent.ACTION_POINTER_DOWN;
 import static android.view.MotionEvent.ACTION_POINTER_UP;
 import static android.view.MotionEvent.ACTION_UP;
 
+import static com.android.launcher3.Flags.enableCursorHoverStates;
+import static com.android.launcher3.Flags.enableHandleDelayedGestureCallbacks;
+import static com.android.launcher3.Flags.useActivityOverlay;
 import static com.android.launcher3.Launcher.INTENT_ACTION_ALL_APPS_TOGGLE;
+import static com.android.launcher3.LauncherPrefs.backedUpItem;
 import static com.android.launcher3.MotionEventsUtils.isTrackpadMotionEvent;
 import static com.android.launcher3.MotionEventsUtils.isTrackpadMultiFingerSwipe;
 import static com.android.launcher3.config.FeatureFlags.ENABLE_TRACKPAD_GESTURE;
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
+import static com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR;
+import static com.android.launcher3.util.OnboardingPrefs.HOME_BOUNCE_SEEN;
 import static com.android.launcher3.util.window.WindowManagerProxy.MIN_TABLET_WIDTH;
 import static com.android.quickstep.GestureState.DEFAULT_STATE;
 import static com.android.quickstep.GestureState.TrackpadGestureType.getTrackpadGestureType;
@@ -36,12 +42,12 @@ import static com.android.quickstep.util.ActiveGestureErrorDetector.GestureEvent
 import static com.android.quickstep.util.ActiveGestureErrorDetector.GestureEvent.MOTION_DOWN;
 import static com.android.quickstep.util.ActiveGestureErrorDetector.GestureEvent.MOTION_MOVE;
 import static com.android.quickstep.util.ActiveGestureErrorDetector.GestureEvent.MOTION_UP;
+import static com.android.quickstep.util.ActiveGestureErrorDetector.GestureEvent.RECENTS_ANIMATION_START_PENDING;
 import static com.android.systemui.shared.system.ActivityManagerWrapper.CLOSE_SYSTEM_WINDOWS_REASON_RECENTS;
 import static com.android.systemui.shared.system.QuickStepContract.KEY_EXTRA_SYSUI_PROXY;
 import static com.android.systemui.shared.system.QuickStepContract.KEY_EXTRA_UNFOLD_ANIMATION_FORWARDER;
 import static com.android.systemui.shared.system.QuickStepContract.KEY_EXTRA_UNLOCK_ANIMATION_CONTROLLER;
-import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED;
-import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_QUICK_SETTINGS_EXPANDED;
+import static com.android.wm.shell.Flags.enableBubblesLongPressNavHandle;
 import static com.android.wm.shell.sysui.ShellSharedConstants.KEY_EXTRA_SHELL_BACK_ANIMATION;
 import static com.android.wm.shell.sysui.ShellSharedConstants.KEY_EXTRA_SHELL_BUBBLES;
 import static com.android.wm.shell.sysui.ShellSharedConstants.KEY_EXTRA_SHELL_DESKTOP_MODE;
@@ -53,57 +59,51 @@ import static com.android.wm.shell.sysui.ShellSharedConstants.KEY_EXTRA_SHELL_SH
 import static com.android.wm.shell.sysui.ShellSharedConstants.KEY_EXTRA_SHELL_SPLIT_SCREEN;
 import static com.android.wm.shell.sysui.ShellSharedConstants.KEY_EXTRA_SHELL_STARTING_WINDOW;
 
-import android.annotation.TargetApi;
 import android.app.PendingIntent;
-import android.app.RemoteAction;
 import android.app.Service;
 import android.content.IIntentReceiver;
 import android.content.IIntentSender;
 import android.content.Intent;
-import android.content.SharedPreferences;
 import android.content.res.Configuration;
 import android.graphics.Region;
-import android.graphics.drawable.Icon;
-import android.os.Build;
+import android.hardware.input.InputManager;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.os.Looper;
-import android.os.RemoteException;
 import android.os.SystemClock;
 import android.os.Trace;
+import android.util.ArraySet;
 import android.util.Log;
 import android.view.Choreographer;
 import android.view.InputDevice;
 import android.view.InputEvent;
 import android.view.MotionEvent;
-import android.view.SurfaceControl;
-import android.view.accessibility.AccessibilityManager;
 
 import androidx.annotation.BinderThread;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.UiThread;
+import androidx.annotation.VisibleForTesting;
 
 import com.android.launcher3.BaseDraggingActivity;
-import com.android.launcher3.DeviceProfile;
+import com.android.launcher3.ConstantItem;
+import com.android.launcher3.EncryptionType;
 import com.android.launcher3.LauncherPrefs;
-import com.android.launcher3.R;
-import com.android.launcher3.Utilities;
 import com.android.launcher3.anim.AnimatedFloat;
 import com.android.launcher3.config.FeatureFlags;
 import com.android.launcher3.provider.RestoreDbTask;
 import com.android.launcher3.statemanager.StatefulActivity;
 import com.android.launcher3.taskbar.TaskbarActivityContext;
 import com.android.launcher3.taskbar.TaskbarManager;
+import com.android.launcher3.taskbar.TaskbarNavButtonController.TaskbarNavButtonCallbacks;
 import com.android.launcher3.testing.TestLogging;
 import com.android.launcher3.testing.shared.ResourceUtils;
 import com.android.launcher3.testing.shared.TestProtocol;
-import com.android.launcher3.uioverrides.flags.FlagsFactory;
-import com.android.launcher3.uioverrides.plugins.PluginManagerWrapper;
 import com.android.launcher3.util.DisplayController;
 import com.android.launcher3.util.LockedUserState;
-import com.android.launcher3.util.OnboardingPrefs;
+import com.android.launcher3.util.PluginManagerWrapper;
 import com.android.launcher3.util.SafeCloseable;
+import com.android.launcher3.util.ScreenOnTracker;
 import com.android.launcher3.util.TraceHelper;
 import com.android.quickstep.inputconsumers.AccessibilityInputConsumer;
 import com.android.quickstep.inputconsumers.AssistantInputConsumer;
@@ -123,38 +123,37 @@ import com.android.quickstep.util.ActiveGestureLog;
 import com.android.quickstep.util.ActiveGestureLog.CompoundString;
 import com.android.quickstep.util.AssistStateManager;
 import com.android.quickstep.util.AssistUtils;
+import com.android.quickstep.views.RecentsViewContainer;
 import com.android.systemui.shared.recents.IOverviewProxy;
 import com.android.systemui.shared.recents.ISystemUiProxy;
 import com.android.systemui.shared.system.ActivityManagerWrapper;
 import com.android.systemui.shared.system.InputChannelCompat.InputEventReceiver;
 import com.android.systemui.shared.system.InputConsumerController;
 import com.android.systemui.shared.system.InputMonitorCompat;
+import com.android.systemui.shared.system.QuickStepContract.SystemUiStateFlags;
 import com.android.systemui.shared.system.smartspace.ISysuiUnlockAnimationController;
 import com.android.systemui.unfold.progress.IUnfoldAnimation;
 import com.android.wm.shell.back.IBackAnimation;
 import com.android.wm.shell.bubbles.IBubbles;
+import com.android.wm.shell.common.pip.IPip;
 import com.android.wm.shell.desktopmode.IDesktopMode;
 import com.android.wm.shell.draganddrop.IDragAndDrop;
 import com.android.wm.shell.onehanded.IOneHanded;
-import com.android.wm.shell.pip.IPip;
 import com.android.wm.shell.recents.IRecentTasks;
+import com.android.wm.shell.shared.IShellTransitions;
 import com.android.wm.shell.splitscreen.ISplitScreen;
 import com.android.wm.shell.startingsurface.IStartingWindow;
-import com.android.wm.shell.transition.IShellTransitions;
 
 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.lang.ref.WeakReference;
+import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
-import app.lawnchair.LawnchairApp;
-import app.lawnchair.compat.LawnchairQuickstepCompat;
-
 /**
  * Service connected by system-UI for handling touch interaction.
  */
-@TargetApi(Build.VERSION_CODES.R)
 public class TouchInteractionService extends Service {
 
     private static final String SUBSTRING_PREFIX = "; ";
@@ -162,9 +161,10 @@ public class TouchInteractionService extends Service {
 
     private static final String TAG = "TouchInteractionService";
 
-    private static final String HAS_ENABLED_QUICKSTEP_ONCE = "launcher.has_enabled_quickstep_once";
+    private static final ConstantItem<Boolean> HAS_ENABLED_QUICKSTEP_ONCE = backedUpItem(
+            "launcher.has_enabled_quickstep_once", false, EncryptionType.ENCRYPTED);
 
-    private final TISBinder mTISBinder = LawnchairApp.isRecentsEnabled() ? new TISBinder(this) : null;
+    private final TISBinder mTISBinder = new TISBinder(this);
 
     /**
      * Local IOverviewProxy implementation with some methods for local components
@@ -173,8 +173,7 @@ public class TouchInteractionService extends Service {
 
         private final WeakReference<TouchInteractionService> mTis;
 
-        @Nullable
-        private Runnable mOnOverviewTargetChangeListener = null;
+        @Nullable private Runnable mOnOverviewTargetChangeListener = null;
 
         private TISBinder(TouchInteractionService tis) {
             mTis = new WeakReference<>(tis);
@@ -194,8 +193,8 @@ public class TouchInteractionService extends Service {
                     bundle.getBinder(KEY_EXTRA_SHELL_SHELL_TRANSITIONS));
             IStartingWindow startingWindow = IStartingWindow.Stub.asInterface(
                     bundle.getBinder(KEY_EXTRA_SHELL_STARTING_WINDOW));
-            ISysuiUnlockAnimationController launcherUnlockAnimationController = ISysuiUnlockAnimationController.Stub
-                    .asInterface(
+            ISysuiUnlockAnimationController launcherUnlockAnimationController =
+                    ISysuiUnlockAnimationController.Stub.asInterface(
                             bundle.getBinder(KEY_EXTRA_UNLOCK_ANIMATION_CONTROLLER));
             IRecentTasks recentTasks = IRecentTasks.Stub.asInterface(
                     bundle.getBinder(KEY_EXTRA_SHELL_RECENT_TASKS));
@@ -208,16 +207,12 @@ public class TouchInteractionService extends Service {
             IDragAndDrop dragAndDrop = IDragAndDrop.Stub.asInterface(
                     bundle.getBinder(KEY_EXTRA_SHELL_DRAG_AND_DROP));
             MAIN_EXECUTOR.execute(() -> executeForTouchInteractionService(tis -> {
-                try {
-                    SystemUiProxy.INSTANCE.get(tis).setProxy(proxy, pip,
-                            bubbles, splitscreen, onehanded, shellTransitions, startingWindow,
-                            recentTasks, launcherUnlockAnimationController, backAnimation, desktopMode,
-                            unfoldTransition, dragAndDrop);
-                    tis.initInputMonitor("TISBinder#onInitialize()");
-                    tis.preloadOverview(true /* fromInit */);
-                } catch (Throwable t) {
-                    // Ignore
-                }
+                SystemUiProxy.INSTANCE.get(tis).setProxy(proxy, pip,
+                        bubbles, splitscreen, onehanded, shellTransitions, startingWindow,
+                        recentTasks, launcherUnlockAnimationController, backAnimation, desktopMode,
+                        unfoldTransition, dragAndDrop);
+                tis.initInputMonitor("TISBinder#onInitialize()");
+                tis.preloadOverview(true /* fromInit */);
             }));
             sIsInitialized = true;
         }
@@ -225,10 +220,10 @@ public class TouchInteractionService extends Service {
         @BinderThread
         @Override
         public void onTaskbarToggled() {
-            if (!FeatureFlags.ENABLE_KEYBOARD_TASKBAR_TOGGLE.get() || !LawnchairQuickstepCompat.ATLEAST_S)
-                return;
+            if (!FeatureFlags.ENABLE_KEYBOARD_TASKBAR_TOGGLE.get()) return;
             MAIN_EXECUTOR.execute(() -> executeForTouchInteractionService(tis -> {
-                TaskbarActivityContext activityContext = tis.mTaskbarManager.getCurrentActivityContext();
+                TaskbarActivityContext activityContext =
+                        tis.mTaskbarManager.getCurrentActivityContext();
 
                 if (activityContext != null) {
                     activityContext.toggleTaskbarStash();
@@ -295,10 +290,8 @@ public class TouchInteractionService extends Service {
         }
 
         /**
-         * Sent when the assistant has been invoked with the given type (defined in
-         * AssistManager)
-         * and should be shown. This method is used if
-         * SystemUiProxy#setAssistantOverridesRequested
+         * Sent when the assistant has been invoked with the given type (defined in AssistManager)
+         * and should be shown. This method is used if SystemUiProxy#setAssistantOverridesRequested
          * was previously called including this invocation type.
          */
         @Override
@@ -310,15 +303,10 @@ public class TouchInteractionService extends Service {
             });
         }
 
-        @Override
-        public void onNavigationBarSurface(SurfaceControl surface) {
-            // TODO: implement
-        }
-
         @BinderThread
-        public void onSystemUiStateChanged(int stateFlags) {
+        public void onSystemUiStateChanged(@SystemUiStateFlags long stateFlags) {
             MAIN_EXECUTOR.execute(() -> executeForTouchInteractionService(tis -> {
-                int lastFlags = tis.mDeviceState.getSystemUiStateFlags();
+                long lastFlags = tis.mDeviceState.getSystemUiStateFlags();
                 tis.mDeviceState.setSystemUiFlags(stateFlags);
                 tis.onSystemUiFlagsChanged(lastFlags);
             }));
@@ -334,7 +322,8 @@ public class TouchInteractionService extends Service {
         @Override
         public void enterStageSplitFromRunningApp(boolean leftOrTop) {
             executeForTouchInteractionService(tis -> {
-                StatefulActivity activity = tis.mOverviewComponentObserver.getActivityInterface().getCreatedActivity();
+                StatefulActivity activity =
+                        tis.mOverviewComponentObserver.getActivityInterface().getCreatedContainer();
                 if (activity != null) {
                     activity.enterStageSplitFromRunningApp(leftOrTop);
                 }
@@ -344,8 +333,7 @@ public class TouchInteractionService extends Service {
         /**
          * Preloads the Overview activity.
          * <p>
-         * This method should only be used when the All Set page of the SUW is reached
-         * to safely
+         * This method should only be used when the All Set page of the SUW is reached to safely
          * preload the Launcher for the SUW first reveal.
          */
         public void preloadOverviewForSUWAllSet() {
@@ -354,31 +342,38 @@ public class TouchInteractionService extends Service {
 
         @Override
         public void onRotationProposal(int rotation, boolean isValid) {
-            executeForTaskbarManager(taskbarManager -> taskbarManager.onRotationProposal(rotation, isValid));
+            executeForTaskbarManager(taskbarManager ->
+                    taskbarManager.onRotationProposal(rotation, isValid));
         }
 
         @Override
         public void disable(int displayId, int state1, int state2, boolean animate) {
-            executeForTaskbarManager(
-                    taskbarManager -> taskbarManager.disableNavBarElements(displayId, state1, state2, animate));
+            executeForTaskbarManager(taskbarManager ->
+                    taskbarManager.disableNavBarElements(displayId, state1, state2, animate));
         }
 
         @Override
         public void onSystemBarAttributesChanged(int displayId, int behavior) {
-            executeForTaskbarManager(
-                    taskbarManager -> taskbarManager.onSystemBarAttributesChanged(displayId, behavior));
+            executeForTaskbarManager(taskbarManager ->
+                    taskbarManager.onSystemBarAttributesChanged(displayId, behavior));
         }
 
         @Override
         public void onNavButtonsDarkIntensityChanged(float darkIntensity) {
-            executeForTaskbarManager(taskbarManager -> taskbarManager.onNavButtonsDarkIntensityChanged(darkIntensity));
+            executeForTaskbarManager(taskbarManager ->
+                    taskbarManager.onNavButtonsDarkIntensityChanged(darkIntensity));
+        }
+
+        @Override
+        public void onNavigationBarLumaSamplingEnabled(int displayId, boolean enable) {
+            executeForTaskbarManager(taskbarManager ->
+                    taskbarManager.onNavigationBarLumaSamplingEnabled(displayId, enable));
         }
 
         private void executeForTouchInteractionService(
                 @NonNull Consumer<TouchInteractionService> tisConsumer) {
             TouchInteractionService tis = mTis.get();
-            if (tis == null)
-                return;
+            if (tis == null) return;
             tisConsumer.accept(tis);
         }
 
@@ -386,8 +381,7 @@ public class TouchInteractionService extends Service {
                 @NonNull Consumer<TaskbarManager> taskbarManagerConsumer) {
             MAIN_EXECUTOR.execute(() -> executeForTouchInteractionService(tis -> {
                 TaskbarManager taskbarManager = tis.mTaskbarManager;
-                if (taskbarManager == null)
-                    return;
+                if (taskbarManager == null) return;
                 taskbarManagerConsumer.accept(taskbarManager);
             }));
         }
@@ -400,11 +394,37 @@ public class TouchInteractionService extends Service {
         @Nullable
         public TaskbarManager getTaskbarManager() {
             TouchInteractionService tis = mTis.get();
-            if (tis == null || !LawnchairQuickstepCompat.ATLEAST_S)
-                return null;
+            if (tis == null) return null;
             return tis.mTaskbarManager;
         }
 
+        @VisibleForTesting
+        public void injectFakeTrackpadForTesting() {
+            TouchInteractionService tis = mTis.get();
+            if (tis == null) return;
+            tis.mTrackpadsConnected.add(1000);
+            tis.initInputMonitor("tapl testing");
+        }
+
+        @VisibleForTesting
+        public void ejectFakeTrackpadForTesting() {
+            TouchInteractionService tis = mTis.get();
+            if (tis == null) return;
+            tis.mTrackpadsConnected.clear();
+            // This method destroys the current input monitor if set up, and only init a new one
+            // in 3-button mode if {@code mTrackpadsConnected} is not empty. So in other words,
+            // it will destroy the input monitor.
+            tis.initInputMonitor("tapl testing");
+        }
+
+        /**
+         * Sets whether a predictive back-to-home animation is in progress in the device state
+         */
+        public void setPredictiveBackToHomeInProgress(boolean isInProgress) {
+            executeForTouchInteractionService(tis ->
+                    tis.mDeviceState.setPredictiveBackToHomeInProgress(isInProgress));
+        }
+
         /**
          * Returns the {@link OverviewCommandHelper}.
          * <p>
@@ -413,8 +433,7 @@ public class TouchInteractionService extends Service {
         @Nullable
         public OverviewCommandHelper getOverviewCommandHelper() {
             TouchInteractionService tis = mTis.get();
-            if (tis == null)
-                return null;
+            if (tis == null) return null;
             return tis.mOverviewCommandHelper;
         }
 
@@ -422,20 +441,16 @@ public class TouchInteractionService extends Service {
          * Sets a proxy to bypass swipe up behavior
          */
         public void setSwipeUpProxy(Function<GestureState, AnimatedFloat> proxy) {
-            TouchInteractionService tis = mTis.get();
-            if (tis == null)
-                return;
-            tis.mSwipeUpProxyProvider = proxy != null ? proxy : (i -> null);
+            executeForTouchInteractionService(
+                    tis -> tis.mSwipeUpProxyProvider = proxy != null ? proxy : (i -> null));
         }
 
         /**
          * Sets the task id where gestures should be blocked
          */
         public void setGestureBlockedTaskId(int taskId) {
-            TouchInteractionService tis = mTis.get();
-            if (tis == null)
-                return;
-            tis.mDeviceState.setGestureBlockingTaskId(taskId);
+            executeForTouchInteractionService(
+                    tis -> tis.mDeviceState.setGestureBlockingTaskId(taskId));
         }
 
         /** Sets a listener to be run on Overview Target updates. */
@@ -449,8 +464,60 @@ public class TouchInteractionService extends Service {
                 mOnOverviewTargetChangeListener = null;
             }
         }
+
+        /** Refreshes the current overview target. */
+        public void refreshOverviewTarget() {
+            executeForTouchInteractionService(tis -> {
+                tis.mAllAppsActionManager.onDestroy();
+                tis.onOverviewTargetChange(tis.mOverviewComponentObserver.isHomeAndOverviewSame());
+            });
+        }
     }
 
+    private final InputManager.InputDeviceListener mInputDeviceListener =
+            new InputManager.InputDeviceListener() {
+                @Override
+                public void onInputDeviceAdded(int deviceId) {
+                    if (isTrackpadDevice(deviceId)) {
+                        boolean wasEmpty = mTrackpadsConnected.isEmpty();
+                        mTrackpadsConnected.add(deviceId);
+                        if (wasEmpty) {
+                            update();
+                        }
+                    }
+                }
+
+                @Override
+                public void onInputDeviceChanged(int deviceId) {
+                }
+
+                @Override
+                public void onInputDeviceRemoved(int deviceId) {
+                    mTrackpadsConnected.remove(deviceId);
+                    if (mTrackpadsConnected.isEmpty()) {
+                        update();
+                    }
+                }
+
+                private void update() {
+                    if (mInputMonitorCompat != null && !mTrackpadsConnected.isEmpty()) {
+                        // Don't destroy and reinitialize input monitor due to trackpad
+                        // connecting when it's already set up.
+                        return;
+                    }
+                    initInputMonitor("onTrackpadConnected()");
+                }
+
+                private boolean isTrackpadDevice(int deviceId) {
+                    InputDevice inputDevice = mInputManager.getInputDevice(deviceId);
+                    if (inputDevice == null) {
+                        return false;
+                    }
+                    return inputDevice.getSources() == (InputDevice.SOURCE_MOUSE
+                            | InputDevice.SOURCE_TOUCHPAD);
+                }
+            };
+
     private static boolean sConnected = false;
     private static boolean sIsInitialized = false;
     private RotationTouchHelper mRotationTouchHelper;
@@ -463,8 +530,24 @@ public class TouchInteractionService extends Service {
         return sIsInitialized;
     }
 
-    private final AbsSwipeUpHandler.Factory mLauncherSwipeHandlerFactory = this::createLauncherSwipeHandler;
-    private final AbsSwipeUpHandler.Factory mFallbackSwipeHandlerFactory = this::createFallbackSwipeHandler;
+    private final AbsSwipeUpHandler.Factory mLauncherSwipeHandlerFactory =
+            this::createLauncherSwipeHandler;
+    private final AbsSwipeUpHandler.Factory mFallbackSwipeHandlerFactory =
+            this::createFallbackSwipeHandler;
+
+    private final ScreenOnTracker.ScreenOnListener mScreenOnListener = this::onScreenOnChanged;
+
+    private final TaskbarNavButtonCallbacks mNavCallbacks = new TaskbarNavButtonCallbacks() {
+        @Override
+        public void onNavigateHome() {
+            mOverviewCommandHelper.addCommand(OverviewCommandHelper.TYPE_HOME);
+        }
+
+        @Override
+        public void onToggleOverview() {
+            mOverviewCommandHelper.addCommand(OverviewCommandHelper.TYPE_TOGGLE);
+        }
+    };
 
     private ActivityManagerWrapper mAM;
     private OverviewCommandHelper mOverviewCommandHelper;
@@ -484,29 +567,40 @@ public class TouchInteractionService extends Service {
 
     private TaskbarManager mTaskbarManager;
     private Function<GestureState, AnimatedFloat> mSwipeUpProxyProvider = i -> null;
+    private AllAppsActionManager mAllAppsActionManager;
+    private InputManager mInputManager;
+    private final Set<Integer> mTrackpadsConnected = new ArraySet<>();
 
     @Override
     public void onCreate() {
         super.onCreate();
-        if (!LawnchairApp.isRecentsEnabled())
-            return;
         // Initialize anything here that is needed in direct boot mode.
         // Everything else should be initialized in onUserUnlocked() below.
         mMainChoreographer = Choreographer.getInstance();
         mAM = ActivityManagerWrapper.getInstance();
         mDeviceState = new RecentsAnimationDeviceState(this, true);
-        mTaskbarManager = LawnchairQuickstepCompat.ATLEAST_S ? new TaskbarManager(this) : null;
         mRotationTouchHelper = mDeviceState.getRotationTouchHelper();
-        BootAwarePreloader.start(this);
-
-        // Call runOnUserUnlocked() before any other callbacks to ensure everything is
-        // initialized.
-        LockedUserState.get(this).runOnUserUnlocked(this::onUserUnlocked);
-        if (LawnchairQuickstepCompat.ATLEAST_S) {
-            LockedUserState.get(this).runOnUserUnlocked(mTaskbarManager::onUserUnlocked);
+        mAllAppsActionManager = new AllAppsActionManager(
+                this, UI_HELPER_EXECUTOR, this::createAllAppsPendingIntent);
+        mInputManager = getSystemService(InputManager.class);
+        if (ENABLE_TRACKPAD_GESTURE.get()) {
+            mInputManager.registerInputDeviceListener(mInputDeviceListener,
+                    UI_HELPER_EXECUTOR.getHandler());
+            int [] inputDevices = mInputManager.getInputDeviceIds();
+            for (int inputDeviceId : inputDevices) {
+                mInputDeviceListener.onInputDeviceAdded(inputDeviceId);
+            }
         }
+        mTaskbarManager = new TaskbarManager(this, mAllAppsActionManager, mNavCallbacks);
+        mInputConsumer = InputConsumerController.getRecentsAnimationInputConsumer();
+
+        // Call runOnUserUnlocked() before any other callbacks to ensure everything is initialized.
+        LockedUserState.get(this).runOnUserUnlocked(this::onUserUnlocked);
+        LockedUserState.get(this).runOnUserUnlocked(mTaskbarManager::onUserUnlocked);
         mDeviceState.addNavigationModeChangedCallback(this::onNavigationModeChanged);
         sConnected = true;
+
+        ScreenOnTracker.INSTANCE.get(this).addListener(mScreenOnListener);
     }
 
     private void disposeEventHandlers(String reason) {
@@ -524,20 +618,12 @@ public class TouchInteractionService extends Service {
     private void initInputMonitor(String reason) {
         disposeEventHandlers("Initializing input monitor due to: " + reason);
 
-        if (mDeviceState.isButtonNavMode() && !ENABLE_TRACKPAD_GESTURE.get()) {
+        if (mDeviceState.isButtonNavMode() && (!ENABLE_TRACKPAD_GESTURE.get()
+                || mTrackpadsConnected.isEmpty())) {
             return;
         }
 
-        if (LawnchairQuickstepCompat.ATLEAST_S) {
-            mInputMonitorCompat = new InputMonitorCompat("swipe-up", mDeviceState.getDisplayId());
-        } else {
-            if (!SystemUiProxy.INSTANCE.get(this).isActive()) {
-                return;
-            }
-            Bundle bundle = SystemUiProxy.INSTANCE.get(this).monitorGestureInput("swipe-up",
-                    mDeviceState.getDisplayId());
-            mInputMonitorCompat = InputMonitorCompat.fromBundle(bundle, "extra_input_monitor");
-        }
+        mInputMonitorCompat = new InputMonitorCompat("swipe-up", mDeviceState.getDisplayId());
         mInputEventReceiver = mInputMonitorCompat.getInputReceiver(Looper.getMainLooper(),
                 mMainChoreographer, this::onInputEvent);
 
@@ -545,8 +631,7 @@ public class TouchInteractionService extends Service {
     }
 
     /**
-     * Called when the navigation mode changes, guaranteed to be after the device
-     * state has updated.
+     * Called when the navigation mode changes, guaranteed to be after the device state has updated.
      */
     private void onNavigationModeChanged() {
         initInputMonitor("onNavigationModeChanged()");
@@ -555,20 +640,14 @@ public class TouchInteractionService extends Service {
 
     @UiThread
     public void onUserUnlocked() {
+        Log.d(TAG, "onUserUnlocked: userId=" + getUserId());
         mTaskAnimationManager = new TaskAnimationManager(this);
         mOverviewComponentObserver = new OverviewComponentObserver(this, mDeviceState);
         mOverviewCommandHelper = new OverviewCommandHelper(this,
                 mOverviewComponentObserver, mTaskAnimationManager);
-        if (LawnchairQuickstepCompat.ATLEAST_S && mTaskbarManager != null) {
-            mResetGestureInputConsumer = new ResetGestureInputConsumer(
-                    mTaskAnimationManager, mTaskbarManager::getCurrentActivityContext);
-        }
-        mInputConsumer = InputConsumerController.getRecentsAnimationInputConsumer();
-        try {
-            mInputConsumer.registerInputConsumer();
-        } catch (Exception e) {
-            Log.e(TAG, "Failure registering InputConsumer", e);
-        }
+        mResetGestureInputConsumer = new ResetGestureInputConsumer(
+                mTaskAnimationManager, mTaskbarManager::getCurrentActivityContext);
+        mInputConsumer.registerInputConsumer();
         onSystemUiFlagsChanged(mDeviceState.getSystemUiStateFlags());
         onAssistantVisibilityChanged();
 
@@ -589,92 +668,59 @@ public class TouchInteractionService extends Service {
 
     private void resetHomeBounceSeenOnQuickstepEnabledFirstTime() {
         if (!LockedUserState.get(this).isUserUnlocked() || mDeviceState.isButtonNavMode()) {
-            // Skip if not yet unlocked (can't read user shared prefs) or if the current
-            // navigation
+            // Skip if not yet unlocked (can't read user shared prefs) or if the current navigation
             // mode doesn't have gestures
             return;
         }
 
-        try {
-            // Reset home bounce seen on quick step enabled for first time
-            SharedPreferences sharedPrefs = LauncherPrefs.getPrefs(this);
-            if (!sharedPrefs.getBoolean(HAS_ENABLED_QUICKSTEP_ONCE, true)) {
-                sharedPrefs.edit()
-                        .putBoolean(HAS_ENABLED_QUICKSTEP_ONCE, true)
-                        .putBoolean(OnboardingPrefs.HOME_BOUNCE_SEEN, false)
-                        .apply();
-            }
-        } catch (Throwable t) {
-            // Ignore
+        // Reset home bounce seen on quick step enabled for first time
+        LauncherPrefs prefs = LauncherPrefs.get(this);
+        if (!prefs.get(HAS_ENABLED_QUICKSTEP_ONCE)) {
+            prefs.put(
+                    HAS_ENABLED_QUICKSTEP_ONCE.to(true),
+                    HOME_BOUNCE_SEEN.to(false));
         }
     }
 
     private void onOverviewTargetChange(boolean isHomeAndOverviewSame) {
-        AccessibilityManager am = getSystemService(AccessibilityManager.class);
-
-        if (LawnchairQuickstepCompat.ATLEAST_R) {
-            if (isHomeAndOverviewSame) {
-                am.registerSystemAction(createAllAppsAction(), GLOBAL_ACTION_ACCESSIBILITY_ALL_APPS);
-            } else {
-                am.unregisterSystemAction(GLOBAL_ACTION_ACCESSIBILITY_ALL_APPS);
-            }
-        }
+        mAllAppsActionManager.setHomeAndOverviewSame(isHomeAndOverviewSame);
 
         StatefulActivity newOverviewActivity = mOverviewComponentObserver.getActivityInterface()
-                .getCreatedActivity();
-        if (newOverviewActivity != null && mTaskbarManager != null) {
+                .getCreatedContainer();
+        if (newOverviewActivity != null) {
             mTaskbarManager.setActivity(newOverviewActivity);
         }
         mTISBinder.onOverviewTargetChange();
     }
 
-    private RemoteAction createAllAppsAction() {
-        final Intent homeIntent = new Intent(mOverviewComponentObserver.getHomeIntent())
-                .setAction(INTENT_ACTION_ALL_APPS_TOGGLE);
-        final PendingIntent actionPendingIntent;
-
-        if (FeatureFlags.ENABLE_ALL_APPS_SEARCH_IN_TASKBAR.get() && mTaskbarManager != null) {
-            actionPendingIntent = new PendingIntent(new IIntentSender.Stub() {
+    private PendingIntent createAllAppsPendingIntent() {
+        if (FeatureFlags.ENABLE_ALL_APPS_SEARCH_IN_TASKBAR.get()) {
+            return new PendingIntent(new IIntentSender.Stub() {
                 @Override
                 public void send(int code, Intent intent, String resolvedType,
-                        IBinder allowlistToken, IIntentReceiver finishedReceiver,
-                        String requiredPermission, Bundle options) {
-                    MAIN_EXECUTOR.execute(() -> mTaskbarManager.toggleAllApps(homeIntent));
+                                 IBinder allowlistToken, IIntentReceiver finishedReceiver,
+                                 String requiredPermission, Bundle options) {
+                    MAIN_EXECUTOR.execute(() -> mTaskbarManager.toggleAllApps());
                 }
             });
         } else {
-            actionPendingIntent = PendingIntent.getActivity(
+            return PendingIntent.getActivity(
                     this,
                     GLOBAL_ACTION_ACCESSIBILITY_ALL_APPS,
-                    homeIntent,
+                    new Intent(mOverviewComponentObserver.getHomeIntent())
+                            .setAction(INTENT_ACTION_ALL_APPS_TOGGLE),
                     PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
         }
-
-        return new RemoteAction(
-                Icon.createWithResource(this, R.drawable.ic_apps),
-                getString(R.string.all_apps_label),
-                getString(R.string.all_apps_label),
-                actionPendingIntent);
     }
 
     @UiThread
-    private void onSystemUiFlagsChanged(int lastSysUIFlags) {
+    private void onSystemUiFlagsChanged(@SystemUiStateFlags long lastSysUIFlags) {
         if (LockedUserState.get(this).isUserUnlocked()) {
-            int systemUiStateFlags = mDeviceState.getSystemUiStateFlags();
+            long systemUiStateFlags = mDeviceState.getSystemUiStateFlags();
             SystemUiProxy.INSTANCE.get(this).setLastSystemUiStateFlags(systemUiStateFlags);
             mOverviewComponentObserver.onSystemUiStateChanged();
-            if (mTaskbarManager != null) {
-                mTaskbarManager.onSystemUiFlagsChanged(systemUiStateFlags);
-            }
-
-            int isShadeExpandedFlag = SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED | SYSUI_STATE_QUICK_SETTINGS_EXPANDED;
-            boolean wasExpanded = (lastSysUIFlags & isShadeExpandedFlag) != 0;
-            boolean isExpanded = (systemUiStateFlags & isShadeExpandedFlag) != 0;
-            if (wasExpanded != isExpanded && isExpanded) {
-                // End live tile when expanding the notification panel for the first time from
-                // overview.
-                mTaskAnimationManager.endLiveTile();
-            }
+            mTaskbarManager.onSystemUiFlagsChanged(systemUiStateFlags);
+            mTaskAnimationManager.onSystemUiFlagsChanged(lastSysUIFlags, systemUiStateFlags);
         }
     }
 
@@ -688,10 +734,6 @@ public class TouchInteractionService extends Service {
 
     @Override
     public void onDestroy() {
-        if (!LawnchairApp.isRecentsEnabled()) {
-            super.onDestroy();
-            return;
-        }
         Log.d(TAG, "Touch service destroyed: user=" + getUserId());
         sIsInitialized = false;
         if (LockedUserState.get(this).isUserUnlocked()) {
@@ -702,15 +744,15 @@ public class TouchInteractionService extends Service {
         mDeviceState.destroy();
         SystemUiProxy.INSTANCE.get(this).clearProxy();
 
-        if (LawnchairQuickstepCompat.ATLEAST_R) {
-            getSystemService(AccessibilityManager.class)
-                    .unregisterSystemAction(GLOBAL_ACTION_ACCESSIBILITY_ALL_APPS);
-        }
+        mAllAppsActionManager.onDestroy();
 
-        if (mTaskbarManager != null) {
-            mTaskbarManager.destroy();
-        }
+        mInputManager.unregisterInputDeviceListener(mInputDeviceListener);
+        mTrackpadsConnected.clear();
+
+        mTaskbarManager.destroy();
         sConnected = false;
+
+        ScreenOnTracker.INSTANCE.get(this).removeListener(mScreenOnListener);
         super.onDestroy();
     }
 
@@ -720,9 +762,22 @@ public class TouchInteractionService extends Service {
         return mTISBinder;
     }
 
+    protected void onScreenOnChanged(boolean isOn) {
+        if (isOn) {
+            return;
+        }
+        long currentTime = SystemClock.uptimeMillis();
+        MotionEvent cancelEvent = MotionEvent.obtain(
+                currentTime, currentTime, ACTION_CANCEL, 0f, 0f, 0);
+        onInputEvent(cancelEvent);
+        cancelEvent.recycle();
+    }
+
     private void onInputEvent(InputEvent ev) {
         if (!(ev instanceof MotionEvent)) {
-            Log.e(TAG, "Unknown event " + ev);
+            ActiveGestureLog.INSTANCE.addLog(new CompoundString("TIS.onInputEvent: ")
+                    .append("Cannot process input event: received unknown event ")
+                    .append(ev.toString()));
             return;
         }
         MotionEvent event = (MotionEvent) ev;
@@ -730,39 +785,75 @@ public class TouchInteractionService extends Service {
         TestLogging.recordMotionEvent(
                 TestProtocol.SEQUENCE_TIS, "TouchInteractionService.onInputEvent", event);
 
-        if (!LockedUserState.get(this).isUserUnlocked() || (mDeviceState.isButtonNavMode()
+        boolean isUserUnlocked = LockedUserState.get(this).isUserUnlocked();
+        if (!isUserUnlocked || (mDeviceState.isButtonNavMode()
                 && !isTrackpadMotionEvent(event))) {
+            ActiveGestureLog.INSTANCE.addLog(new CompoundString("TIS.onInputEvent: ")
+                    .append("Cannot process input event: ")
+                    .append(!isUserUnlocked
+                            ? "user is locked"
+                            : "using 3-button nav and event is not a trackpad event"));
             return;
         }
 
+        final int action = event.getActionMasked();
+        // Note this will create a new consumer every mouse click, as after ACTION_UP from the click
+        // an ACTION_HOVER_ENTER will fire as well.
+        boolean isHoverActionWithoutConsumer = enableCursorHoverStates()
+                && isHoverActionWithoutConsumer(event);
+
+        if (enableHandleDelayedGestureCallbacks()) {
+            if (action == ACTION_DOWN || isHoverActionWithoutConsumer) {
+                mTaskAnimationManager.notifyNewGestureStart();
+            }
+            if (mTaskAnimationManager.shouldIgnoreMotionEvents()) {
+                if (action == ACTION_DOWN || isHoverActionWithoutConsumer) {
+                    ActiveGestureLog.INSTANCE.addLog(
+                            new CompoundString("TIS.onMotionEvent: A new gesture has been ")
+                                    .append("started, but a previously-requested recents ")
+                                    .append("animation hasn't started. Ignoring all following ")
+                                    .append("motion events."),
+                            RECENTS_ANIMATION_START_PENDING);
+                }
+                return;
+            }
+        }
+
         SafeCloseable traceToken = TraceHelper.INSTANCE.allowIpcs("TIS.onInputEvent");
 
-        final int action = event.getActionMasked();
-        // Note this will create a new consumer every mouse click, as after ACTION_UP
-        // from the click
-        // an ACTION_HOVER_ENTER will fire as well.
-        boolean isHoverActionWithoutConsumer = isHoverEvent(action)
-                && (mUncheckedConsumer.getType() & TYPE_CURSOR_HOVER) == 0;
+        CompoundString reasonString = action == ACTION_DOWN
+                ? new CompoundString("TIS.onMotionEvent: ") : CompoundString.NO_OP;
         if (action == ACTION_DOWN || isHoverActionWithoutConsumer) {
             mRotationTouchHelper.setOrientationTransformIfNeeded(event);
 
-            if ((!mDeviceState.isOneHandedModeActive()
-                    && mRotationTouchHelper.isInSwipeUpTouchRegion(event))
+            boolean isOneHandedModeActive = mDeviceState.isOneHandedModeActive();
+            boolean isInSwipeUpTouchRegion = mRotationTouchHelper.isInSwipeUpTouchRegion(event);
+            TaskbarActivityContext tac = mTaskbarManager.getCurrentActivityContext();
+            if (isInSwipeUpTouchRegion && tac != null) {
+                tac.closeKeyboardQuickSwitchView();
+            }
+            if ((!isOneHandedModeActive && isInSwipeUpTouchRegion)
                     || isHoverActionWithoutConsumer) {
-                // Clone the previous gesture state since onConsumerAboutToBeSwitched might
-                // trigger
+                reasonString.append(!isOneHandedModeActive && isInSwipeUpTouchRegion
+                                ? "one handed mode is not active and event is in swipe up region"
+                                : "isHoverActionWithoutConsumer == true")
+                        .append(", creating new input consumer");
+                // Clone the previous gesture state since onConsumerAboutToBeSwitched might trigger
                 // onConsumerInactive and wipe the previous gesture state
                 GestureState prevGestureState = new GestureState(mGestureState);
                 GestureState newGestureState = createGestureState(mGestureState,
                         getTrackpadGestureType(event));
-                newGestureState.setSwipeUpStartTimeMs(SystemClock.uptimeMillis());
                 mConsumer.onConsumerAboutToBeSwitched();
                 mGestureState = newGestureState;
                 mConsumer = newConsumer(prevGestureState, mGestureState, event);
                 mUncheckedConsumer = mConsumer;
-            } else if (LockedUserState.get(this).isUserUnlocked()
-                    && (mDeviceState.isFullyGesturalNavMode() || isTrackpadMultiFingerSwipe(event))
+            } else if ((mDeviceState.isFullyGesturalNavMode() || isTrackpadMultiFingerSwipe(event))
                     && mDeviceState.canTriggerAssistantAction(event)) {
+                reasonString.append(mDeviceState.isFullyGesturalNavMode()
+                                ? "using fully gestural nav"
+                                : "event is a trackpad multi-finger swipe")
+                        .append(" and event can trigger assistant action")
+                        .append(", consuming gesture for assistant action");
                 mGestureState = createGestureState(mGestureState,
                         getTrackpadGestureType(event));
                 // Do not change mConsumer as if there is an ongoing QuickSwitch gesture, we
@@ -770,6 +861,8 @@ public class TouchInteractionService extends Service {
                 // happen if the next gesture is also quick switch.
                 mUncheckedConsumer = tryCreateAssistantInputConsumer(mGestureState, event);
             } else if (mDeviceState.canTriggerOneHandedAction(event)) {
+                reasonString.append("event can trigger one-handed action")
+                        .append(", consuming gesture for one-handed action");
                 // Consume gesture event for triggering one handed feature.
                 mUncheckedConsumer = new OneHandedModeInputConsumer(this, mDeviceState,
                         InputConsumer.NO_OP, mInputMonitorCompat);
@@ -785,35 +878,49 @@ public class TouchInteractionService extends Service {
         }
 
         if (mUncheckedConsumer != InputConsumer.NO_OP) {
-            switch (event.getActionMasked()) {
+            switch (action) {
                 case ACTION_DOWN:
+                    ActiveGestureLog.INSTANCE.addLog(reasonString);
                     // fall through
                 case ACTION_UP:
                     ActiveGestureLog.INSTANCE.addLog(
-                            /* event= */ "onMotionEvent(" + (int) event.getRawX() + ", "
-                                    + (int) event.getRawY() + "): "
-                                    + MotionEvent.actionToString(event.getActionMasked()) + ", "
-                                    + MotionEvent.classificationToString(event.getClassification()),
-                            /* gestureEvent= */ event.getActionMasked() == ACTION_DOWN
+                            new CompoundString("onMotionEvent(")
+                                    .append((int) event.getRawX())
+                                    .append(", ")
+                                    .append((int) event.getRawY())
+                                    .append("): ")
+                                    .append(MotionEvent.actionToString(action))
+                                    .append(", ")
+                                    .append(MotionEvent.classificationToString(
+                                            event.getClassification())),
+                            /* gestureEvent= */ action == ACTION_DOWN
                                     ? MOTION_DOWN
                                     : MOTION_UP);
                     break;
                 case ACTION_MOVE:
-                    ActiveGestureLog.INSTANCE.addLog("onMotionEvent: "
-                            + MotionEvent.actionToString(event.getActionMasked()) + ","
-                            + MotionEvent.classificationToString(event.getClassification())
-                            + ", pointerCount: " + event.getPointerCount(), MOTION_MOVE);
+                    ActiveGestureLog.INSTANCE.addLog(
+                            new CompoundString("onMotionEvent: ")
+                                    .append(MotionEvent.actionToString(action))
+                                    .append(",")
+                                    .append(MotionEvent.classificationToString(
+                                            event.getClassification()))
+                                    .append(", pointerCount: ")
+                                    .append(event.getPointerCount()),
+                            MOTION_MOVE);
                     break;
                 default: {
-                    ActiveGestureLog.INSTANCE.addLog("onMotionEvent: "
-                            + MotionEvent.actionToString(event.getActionMasked()) + ","
-                            + MotionEvent.classificationToString(event.getClassification()));
+                    ActiveGestureLog.INSTANCE.addLog(
+                            new CompoundString("onMotionEvent: ")
+                                    .append(MotionEvent.actionToString(action))
+                                    .append(",")
+                                    .append(MotionEvent.classificationToString(
+                                            event.getClassification())));
                 }
             }
         }
 
-        boolean cancelGesture = mGestureState.getActivityInterface() != null
-                && mGestureState.getActivityInterface().shouldCancelCurrentGesture();
+        boolean cancelGesture = mGestureState.getContainerInterface() != null
+                && mGestureState.getContainerInterface().shouldCancelCurrentGesture();
         boolean cleanUpConsumer = (action == ACTION_UP || action == ACTION_CANCEL || cancelGesture)
                 && mConsumer != null
                 && !mConsumer.getActiveConsumerInHierarchy().isConsumerDetachedFromGesture();
@@ -836,15 +943,18 @@ public class TouchInteractionService extends Service {
         traceToken.close();
     }
 
-    private boolean isHoverEvent(int action) {
-        return action == MotionEvent.ACTION_HOVER_ENTER
-                || action == MotionEvent.ACTION_HOVER_MOVE
-                || action == MotionEvent.ACTION_HOVER_EXIT;
+    private boolean isHoverActionWithoutConsumer(MotionEvent event) {
+        // Only process these events when taskbar is present.
+        TaskbarActivityContext tac = mTaskbarManager.getCurrentActivityContext();
+        boolean isTaskbarPresent = tac != null && tac.getDeviceProfile().isTaskbarPresent
+                && !tac.isPhoneMode();
+        return event.isHoverEvent() && (mUncheckedConsumer.getType() & TYPE_CURSOR_HOVER) == 0
+                && isTaskbarPresent;
     }
 
     // Talkback generates hover events on touch, which we do not want to consume.
     private boolean isCursorHoverEvent(MotionEvent event) {
-        return isHoverEvent(event.getActionMasked()) && event.getSource() == InputDevice.SOURCE_MOUSE;
+        return event.isHoverEvent() && event.getSource() == InputDevice.SOURCE_MOUSE;
     }
 
     private InputConsumer tryCreateAssistantInputConsumer(
@@ -870,13 +980,17 @@ public class TouchInteractionService extends Service {
     }
 
     public GestureState createGestureState(GestureState previousGestureState,
-            GestureState.TrackpadGestureType trackpadGestureType) {
+                                           GestureState.TrackpadGestureType trackpadGestureType) {
         final GestureState gestureState;
         TopTaskTracker.CachedTaskInfo taskInfo;
         if (mTaskAnimationManager.isRecentsAnimationRunning()) {
             gestureState = new GestureState(mOverviewComponentObserver,
                     ActiveGestureLog.INSTANCE.getLogId());
-            taskInfo = previousGestureState.getRunningTask();
+            TopTaskTracker.CachedTaskInfo previousTaskInfo = previousGestureState.getRunningTask();
+            // previousTaskInfo can be null iff previousGestureState == GestureState.DEFAULT_STATE
+            taskInfo = previousTaskInfo != null
+                    ? previousTaskInfo
+                    : TopTaskTracker.INSTANCE.get(this).getCachedTopTask(false);
             gestureState.updateRunningTask(taskInfo);
             gestureState.updateLastStartedTaskIds(previousGestureState.getLastStartedTaskIds());
             gestureState.updatePreviouslyAppearedTaskIds(
@@ -891,7 +1005,7 @@ public class TouchInteractionService extends Service {
 
         // Log initial state for the gesture.
         ActiveGestureLog.INSTANCE.addLog(new CompoundString("Current running task package name=")
-                .append(taskInfo == null ? "no running task" : taskInfo.getPackageName()));
+                .append(taskInfo.getPackageName()));
         ActiveGestureLog.INSTANCE.addLog(new CompoundString("Current SystemUi state flags=")
                 .append(mDeviceState.getSystemUiStateString()));
         return gestureState;
@@ -910,16 +1024,16 @@ public class TouchInteractionService extends Service {
             return consumer;
         }
 
-        boolean canStartSystemGesture = mGestureState.isTrackpadGesture() ? mDeviceState.canStartTrackpadGesture()
-                : mDeviceState.canStartSystemGesture();
+        boolean canStartSystemGesture =
+                mGestureState.isTrackpadGesture() ? mDeviceState.canStartTrackpadGesture()
+                        : mDeviceState.canStartSystemGesture();
 
         if (!LockedUserState.get(this).isUserUnlocked()) {
             CompoundString reasonString = newCompoundString("device locked");
             InputConsumer consumer;
             if (canStartSystemGesture) {
                 // This handles apps launched in direct boot mode (e.g. dialer) as well as apps
-                // launched while device is locked even after exiting direct boot mode (e.g.
-                // camera).
+                // launched while device is locked even after exiting direct boot mode (e.g. camera).
                 consumer = createDeviceLockedInputConsumer(
                         newGestureState, reasonString.append(SUBSTRING_PREFIX)
                                 .append("can start system gesture"));
@@ -934,13 +1048,11 @@ public class TouchInteractionService extends Service {
 
         CompoundString reasonString;
         InputConsumer base;
-        // When there is an existing recents animation running, bypass systemState check
-        // as this is
+        // When there is an existing recents animation running, bypass systemState check as this is
         // a followup gesture and the first gesture started in a valid system state.
         if (canStartSystemGesture || previousGestureState.isRecentsAnimationRunning()) {
             reasonString = newCompoundString(canStartSystemGesture
-                    ? "can start system gesture"
-                    : "recents animation was running")
+                    ? "can start system gesture" : "recents animation was running")
                     .append(", trying to use base consumer");
             base = newBaseConsumer(previousGestureState, newGestureState, event, reasonString);
         } else {
@@ -953,8 +1065,8 @@ public class TouchInteractionService extends Service {
             handleOrientationSetup(base);
         }
         if (mDeviceState.isFullyGesturalNavMode() || newGestureState.isTrackpadGesture()) {
-            String reasonPrefix = "device is in gesture navigation mode or 3-button mode with a"
-                    + " trackpad gesture";
+            String reasonPrefix =
+                    "device is in gesture navigation mode or 3-button mode with a trackpad gesture";
             if (mDeviceState.canTriggerAssistantAction(event)) {
                 reasonString.append(NEWLINE_PREFIX)
                         .append(reasonPrefix)
@@ -964,39 +1076,60 @@ public class TouchInteractionService extends Service {
                 base = tryCreateAssistantInputConsumer(base, newGestureState, event, reasonString);
             }
 
-            // If Taskbar is present, we listen for swipe or cursor hover events to unstash
-            // it.
-            TaskbarActivityContext tac = mTaskbarManager != null ? mTaskbarManager.getCurrentActivityContext() : null;
+            // If Taskbar is present, we listen for swipe or cursor hover events to unstash it.
+            TaskbarActivityContext tac = mTaskbarManager.getCurrentActivityContext();
             if (tac != null && !(base instanceof AssistantInputConsumer)) {
                 // Present always on large screen or on small screen w/ flag
-                DeviceProfile dp = tac.getDeviceProfile();
-                boolean useTaskbarConsumer = dp.isTaskbarPresent && !TaskbarManager.isPhoneMode(dp)
+                boolean useTaskbarConsumer = tac.getDeviceProfile().isTaskbarPresent
+                        && !tac.isPhoneMode()
                         && !tac.isInStashedLauncherState();
                 if (canStartSystemGesture && useTaskbarConsumer) {
                     reasonString.append(NEWLINE_PREFIX)
                             .append(reasonPrefix)
                             .append(SUBSTRING_PREFIX)
-                            .append("TaskbarActivityContext != null, "
-                                    + "using TaskbarUnstashInputConsumer");
+                            .append("TaskbarActivityContext != null, ")
+                            .append("using TaskbarUnstashInputConsumer");
                     base = new TaskbarUnstashInputConsumer(this, base, mInputMonitorCompat, tac,
-                            mOverviewCommandHelper);
+                            mOverviewCommandHelper, mGestureState);
                 }
-            } else if (canStartSystemGesture && FeatureFlags.ENABLE_LONG_PRESS_NAV_HANDLE.get()
-                    && !previousGestureState.isRecentsAnimationRunning()) {
+            }
+            if (enableBubblesLongPressNavHandle()) {
+                // Create bubbles input consumer before NavHandleLongPressInputConsumer.
+                // This allows for nav handle to fall back to bubbles.
+                if (mDeviceState.isBubblesExpanded()) {
+                    reasonString = newCompoundString(reasonPrefix)
+                            .append(SUBSTRING_PREFIX)
+                            .append("bubbles expanded, trying to use default input consumer");
+                    // Bubbles can handle home gesture itself.
+                    base = getDefaultInputConsumer(reasonString);
+                }
+            }
+
+            NavHandle navHandle = tac != null ? tac.getNavHandle()
+                    : SystemUiProxy.INSTANCE.get(this);
+            if (canStartSystemGesture && !previousGestureState.isRecentsAnimationRunning()
+                    && navHandle.canNavHandleBeLongPressed()) {
                 reasonString.append(NEWLINE_PREFIX)
                         .append(reasonPrefix)
                         .append(SUBSTRING_PREFIX)
-                        .append("Long press nav handle enabled, "
-                                + "using NavHandleLongPressInputConsumer");
-                base = new NavHandleLongPressInputConsumer(this, base, mInputMonitorCompat);
+                        .append("Not running recents animation, ");
+                if (tac != null && tac.getNavHandle().canNavHandleBeLongPressed()) {
+                    reasonString.append("stashed handle is long-pressable, ");
+                }
+                reasonString.append("using NavHandleLongPressInputConsumer");
+                base = new NavHandleLongPressInputConsumer(this, base, mInputMonitorCompat,
+                        mDeviceState, navHandle, mGestureState);
             }
 
-            if (mDeviceState.isBubblesExpanded()) {
-                reasonString = newCompoundString(reasonPrefix)
-                        .append(SUBSTRING_PREFIX)
-                        .append("bubbles expanded, trying to use default input consumer");
-                // Bubbles can handle home gesture itself.
-                base = getDefaultInputConsumer(reasonString);
+            if (!enableBubblesLongPressNavHandle()) {
+                // Continue overriding nav handle input consumer with bubbles
+                if (mDeviceState.isBubblesExpanded()) {
+                    reasonString = newCompoundString(reasonPrefix)
+                            .append(SUBSTRING_PREFIX)
+                            .append("bubbles expanded, trying to use default input consumer");
+                    // Bubbles can handle home gesture itself.
+                    base = getDefaultInputConsumer(reasonString);
+                }
             }
 
             if (mDeviceState.isSystemUiDialogShowing()) {
@@ -1021,8 +1154,7 @@ public class TouchInteractionService extends Service {
                         .append(SUBSTRING_PREFIX)
                         .append("screen pinning is active, using ScreenPinnedInputConsumer");
                 // Note: we only allow accessibility to wrap this, and it replaces the previous
-                // base input consumer (which should be NO_OP anyway since topTaskLocked ==
-                // true).
+                // base input consumer (which should be NO_OP anyway since topTaskLocked == true).
                 base = new ScreenPinnedInputConsumer(this, newGestureState);
             }
 
@@ -1103,32 +1235,43 @@ public class TouchInteractionService extends Service {
 
         reasonString.append(SUBSTRING_PREFIX).append("keyguard is not showing occluded");
 
+        TopTaskTracker.CachedTaskInfo runningTask = gestureState.getRunningTask();
         // Use overview input consumer for sharesheets on top of home.
-        boolean forceOverviewInputConsumer = gestureState.getActivityInterface().isStarted()
-                && gestureState.getRunningTask() != null
-                && gestureState.getRunningTask().isRootChooseActivity();
+        boolean forceOverviewInputConsumer = gestureState.getContainerInterface().isStarted()
+                && runningTask != null
+                && runningTask.isRootChooseActivity();
 
-        // In the case where we are in an excluded, translucent overlay, ignore it and
-        // treat the
+        // In the case where we are in an excluded, translucent overlay, ignore it and treat the
         // running activity as the task behind the overlay.
-        TopTaskTracker.CachedTaskInfo otherVisibleTask = gestureState.getRunningTask() == null
+        TopTaskTracker.CachedTaskInfo otherVisibleTask = runningTask == null
                 ? null
-                : gestureState.getRunningTask().otherVisibleTaskThisIsExcludedOver();
+                : runningTask.getVisibleNonExcludedTask();
         if (otherVisibleTask != null) {
             ActiveGestureLog.INSTANCE.addLog(new CompoundString("Changing active task to ")
                     .append(otherVisibleTask.getPackageName())
                     .append(" because the previous task running on top of this one (")
-                    .append(gestureState.getRunningTask().getPackageName())
+                    .append(runningTask.getPackageName())
                     .append(") was excluded from recents"));
             gestureState.updateRunningTask(otherVisibleTask);
         }
 
-        boolean previousGestureAnimatedToLauncher = previousGestureState.isRunningAnimationToLauncher();
+        boolean previousGestureAnimatedToLauncher =
+                previousGestureState.isRunningAnimationToLauncher()
+                        || mDeviceState.isPredictiveBackToHomeInProgress();
         // with shell-transitions, home is resumed during recents animation, so
         // explicitly check against recents animation too.
-        boolean launcherResumedThroughShellTransition = gestureState.getActivityInterface().isResumed()
+        boolean launcherResumedThroughShellTransition =
+                gestureState.getContainerInterface().isResumed()
+                        && !previousGestureState.isRecentsAnimationRunning();
+        // If a task fragment within Launcher is resumed
+        boolean launcherChildActivityResumed = useActivityOverlay()
+                && runningTask != null
+                && runningTask.isHomeTask()
+                && mOverviewComponentObserver.isHomeAndOverviewSame()
+                && !launcherResumedThroughShellTransition
                 && !previousGestureState.isRecentsAnimationRunning();
-        if (gestureState.getActivityInterface().isInLiveTileMode()) {
+
+        if (gestureState.getContainerInterface().isInLiveTileMode()) {
             return createOverviewInputConsumer(
                     previousGestureState,
                     gestureState,
@@ -1136,7 +1279,7 @@ public class TouchInteractionService extends Service {
                     forceOverviewInputConsumer,
                     reasonString.append(SUBSTRING_PREFIX)
                             .append("is in live tile mode, trying to use overview input consumer"));
-        } else if (gestureState.getRunningTask() == null) {
+        } else if (runningTask == null) {
             return getDefaultInputConsumer(reasonString.append(SUBSTRING_PREFIX)
                     .append("running task == null"));
         } else if (previousGestureAnimatedToLauncher
@@ -1151,12 +1294,14 @@ public class TouchInteractionService extends Service {
                             .append(previousGestureAnimatedToLauncher
                                     ? "previous gesture animated to launcher"
                                     : (launcherResumedThroughShellTransition
-                                            ? "launcher resumed through a shell transition"
-                                            : "forceOverviewInputConsumer == true"))
+                                    ? "launcher resumed through a shell transition"
+                                    : "forceOverviewInputConsumer == true"))
                             .append(", trying to use overview input consumer"));
-        } else if (mDeviceState.isGestureBlockedTask(gestureState.getRunningTask())) {
+        } else if (mDeviceState.isGestureBlockedTask(runningTask) || launcherChildActivityResumed) {
             return getDefaultInputConsumer(reasonString.append(SUBSTRING_PREFIX)
-                    .append("is gesture-blocked task, trying to use default input consumer"));
+                    .append(launcherChildActivityResumed
+                            ? "is launcher child-task, trying to use default input consumer"
+                            : "is gesture-blocked task, trying to use default input consumer"));
         } else {
             reasonString.append(SUBSTRING_PREFIX)
                     .append("using OtherActivityInputConsumer");
@@ -1166,16 +1311,15 @@ public class TouchInteractionService extends Service {
 
     public AbsSwipeUpHandler.Factory getSwipeUpHandlerFactory() {
         return !mOverviewComponentObserver.isHomeAndOverviewSame()
-                ? mFallbackSwipeHandlerFactory
-                : mLauncherSwipeHandlerFactory;
+                ? mFallbackSwipeHandlerFactory : mLauncherSwipeHandlerFactory;
     }
 
     private InputConsumer createOtherActivityInputConsumer(GestureState gestureState,
-            MotionEvent event) {
+                                                           MotionEvent event) {
 
         final AbsSwipeUpHandler.Factory factory = getSwipeUpHandlerFactory();
         final boolean shouldDefer = !mOverviewComponentObserver.isHomeAndOverviewSame()
-                || gestureState.getActivityInterface().deferStartingActivity(mDeviceState, event);
+                || gestureState.getContainerInterface().deferStartingActivity(mDeviceState, event);
         final boolean disableHorizontalSwipe = mDeviceState.isInExclusionRegion(event);
         return new OtherActivityInputConsumer(this, mDeviceState, mTaskAnimationManager,
                 gestureState, shouldDefer, this::onConsumerInactive,
@@ -1187,8 +1331,8 @@ public class TouchInteractionService extends Service {
         if ((mDeviceState.isFullyGesturalNavMode() || gestureState.isTrackpadGesture())
                 && gestureState.getRunningTask() != null) {
             reasonString.append(SUBSTRING_PREFIX)
-                    .append("device is in gesture nav mode or 3-button mode with a trackpad gesture"
-                            + "and running task != null")
+                    .append("device is in gesture nav mode or 3-button mode with a trackpad")
+                    .append(" gesture and running task != null")
                     .append(", using DeviceLockedInputConsumer");
             return new DeviceLockedInputConsumer(
                     this, mDeviceState, mTaskAnimationManager, gestureState, mInputMonitorCompat);
@@ -1197,8 +1341,8 @@ public class TouchInteractionService extends Service {
                     .append(SUBSTRING_PREFIX)
                     .append((mDeviceState.isFullyGesturalNavMode()
                             || gestureState.isTrackpadGesture())
-                                    ? "running task == null"
-                                    : "device is not in gesture nav mode and it's not a trackpad gesture")
+                            ? "running task == null"
+                            : "device is not in gesture nav mode and it's not a trackpad gesture")
                     .append(", trying to use default input consumer"));
         }
     }
@@ -1209,45 +1353,46 @@ public class TouchInteractionService extends Service {
             MotionEvent event,
             boolean forceOverviewInputConsumer,
             CompoundString reasonString) {
-        StatefulActivity activity = gestureState.getActivityInterface().getCreatedActivity();
-        if (activity == null) {
+        RecentsViewContainer container = gestureState.getContainerInterface().getCreatedContainer();
+        if (container == null) {
             return getDefaultInputConsumer(
                     reasonString.append(SUBSTRING_PREFIX)
                             .append("activity == null, trying to use default input consumer"));
         }
 
-        boolean hasWindowFocus = activity.getRootView().hasWindowFocus();
-        boolean isPreviousGestureAnimatingToLauncher = previousGestureState.isRunningAnimationToLauncher();
-        boolean isInLiveTileMode = gestureState.getActivityInterface().isInLiveTileMode();
+        boolean hasWindowFocus = container.getRootView().hasWindowFocus();
+        boolean isPreviousGestureAnimatingToLauncher =
+                previousGestureState.isRunningAnimationToLauncher()
+                        || mDeviceState.isPredictiveBackToHomeInProgress();
+        boolean isInLiveTileMode = gestureState.getContainerInterface().isInLiveTileMode();
+
         reasonString.append(SUBSTRING_PREFIX)
                 .append(hasWindowFocus
                         ? "activity has window focus"
                         : (isPreviousGestureAnimatingToLauncher
-                                ? "previous gesture is still animating to launcher"
-                                : isInLiveTileMode
-                                        ? "device is in live mode"
-                                        : "all overview focus conditions failed"));
+                        ? "previous gesture is still animating to launcher"
+                        : isInLiveTileMode
+                        ? "device is in live mode"
+                        : "all overview focus conditions failed"));
         if (hasWindowFocus
                 || isPreviousGestureAnimatingToLauncher
                 || isInLiveTileMode) {
             reasonString.append(SUBSTRING_PREFIX)
                     .append("overview should have focus, using OverviewInputConsumer");
-            return new OverviewInputConsumer(gestureState, activity, mInputMonitorCompat,
+            return new OverviewInputConsumer(gestureState, container, mInputMonitorCompat,
                     false /* startingInActivityBounds */);
         } else {
             reasonString.append(SUBSTRING_PREFIX).append(
                     "overview shouldn't have focus, using OverviewWithoutFocusInputConsumer");
             final boolean disableHorizontalSwipe = mDeviceState.isInExclusionRegion(event);
-            return new OverviewWithoutFocusInputConsumer(activity, mDeviceState, gestureState,
-                    mInputMonitorCompat, disableHorizontalSwipe);
+            return new OverviewWithoutFocusInputConsumer(container.asContext(), mDeviceState,
+                    gestureState, mInputMonitorCompat, disableHorizontalSwipe);
         }
     }
 
     /**
-     * To be called by the consumer when it's no longer active. This can be called
-     * by any consumer
-     * in the hierarchy at any point during the gesture (ie. if a delegate consumer
-     * starts
+     * To be called by the consumer when it's no longer active. This can be called by any consumer
+     * in the hierarchy at any point during the gesture (ie. if a delegate consumer starts
      * intercepting touches, the base consumer can try to call this).
      */
     private void onConsumerInactive(InputConsumer caller) {
@@ -1259,8 +1404,7 @@ public class TouchInteractionService extends Service {
     private void reset() {
         mConsumer = mUncheckedConsumer = getDefaultInputConsumer();
         mGestureState = DEFAULT_STATE;
-        // By default, use batching of the input events, but check receiver before using
-        // in the rare
+        // By default, use batching of the input events, but check receiver before using in the rare
         // case that the monitor was disposed before the swipe settled
         if (mInputEventReceiver != null) {
             mInputEventReceiver.setBatchingEnabled(true);
@@ -1272,8 +1416,7 @@ public class TouchInteractionService extends Service {
     }
 
     /**
-     * Returns the {@link ResetGestureInputConsumer} if user is unlocked, else
-     * NO_OP.
+     * Returns the {@link ResetGestureInputConsumer} if user is unlocked, else NO_OP.
      */
     private @NonNull InputConsumer getDefaultInputConsumer(@NonNull CompoundString reasonString) {
         if (mResetGestureInputConsumer != null) {
@@ -1283,8 +1426,7 @@ public class TouchInteractionService extends Service {
         } else {
             reasonString.append(SUBSTRING_PREFIX).append(
                     "mResetGestureInputConsumer not initialized, using no-op input consumer");
-            // mResetGestureInputConsumer isn't initialized until onUserUnlocked(), so reset
-            // to
+            // mResetGestureInputConsumer isn't initialized until onUserUnlocked(), so reset to
             // NO_OP until then (we never want these to be null).
             return InputConsumer.NO_OP;
         }
@@ -1313,14 +1455,13 @@ public class TouchInteractionService extends Service {
             return;
         }
 
-        final BaseActivityInterface activityInterface = mOverviewComponentObserver.getActivityInterface();
+        final BaseActivityInterface activityInterface =
+                mOverviewComponentObserver.getActivityInterface();
         final Intent overviewIntent = new Intent(
                 mOverviewComponentObserver.getOverviewIntentIgnoreSysUiState());
-        if (activityInterface.getCreatedActivity() != null && fromInit) {
-            // The activity has been created before the initialization of overview service.
-            // It is
-            // usually happens when booting or launcher is the top activity, so we should
-            // already
+        if (activityInterface.getCreatedContainer() != null && fromInit) {
+            // The activity has been created before the initialization of overview service. It is
+            // usually happens when booting or launcher is the top activity, so we should already
             // have the latest state.
             return;
         }
@@ -1329,6 +1470,7 @@ public class TouchInteractionService extends Service {
         Log.i(TAG, "preloadOverview: forSUWAllSet=" + forSUWAllSet
                 + ", isHomeAndOverviewSame=" + mOverviewComponentObserver.isHomeAndOverviewSame());
 
+        ActiveGestureLog.INSTANCE.addLog("preloadRecentsAnimation");
         mTaskAnimationManager.preloadRecentsAnimation(overviewIntent);
     }
 
@@ -1337,8 +1479,9 @@ public class TouchInteractionService extends Service {
         if (!LockedUserState.get(this).isUserUnlocked()) {
             return;
         }
-        final BaseActivityInterface activityInterface = mOverviewComponentObserver.getActivityInterface();
-        final BaseDraggingActivity activity = activityInterface.getCreatedActivity();
+        final BaseActivityInterface activityInterface =
+                mOverviewComponentObserver.getActivityInterface();
+        final BaseDraggingActivity activity = activityInterface.getCreatedContainer();
         if (activity == null || activity.isStarted()) {
             // We only care about the existing background activity.
             return;
@@ -1368,7 +1511,6 @@ public class TouchInteractionService extends Service {
     @Override
     protected void dump(FileDescriptor fd, PrintWriter pw, String[] rawArgs) {
         // Dump everything
-        FlagsFactory.dump(pw);
         if (LockedUserState.get(this).isUserUnlocked()) {
             PluginManagerWrapper.INSTANCE.get(getBaseContext()).dump(pw);
         }
@@ -1380,28 +1522,34 @@ public class TouchInteractionService extends Service {
             mOverviewCommandHelper.dump(pw);
         }
         if (mGestureState != null) {
-            mGestureState.dump(pw);
+            mGestureState.dump("", pw);
         }
         pw.println("Input state:");
-        pw.println("  mInputMonitorCompat=" + mInputMonitorCompat);
-        pw.println("  mInputEventReceiver=" + mInputEventReceiver);
+        pw.println("\tmInputMonitorCompat=" + mInputMonitorCompat);
+        pw.println("\tmInputEventReceiver=" + mInputEventReceiver);
         DisplayController.INSTANCE.get(this).dump(pw);
         pw.println("TouchState:");
         BaseDraggingActivity createdOverviewActivity = mOverviewComponentObserver == null ? null
-                : mOverviewComponentObserver.getActivityInterface().getCreatedActivity();
+                : mOverviewComponentObserver.getActivityInterface().getCreatedContainer();
         boolean resumed = mOverviewComponentObserver != null
                 && mOverviewComponentObserver.getActivityInterface().isResumed();
-        pw.println("  createdOverviewActivity=" + createdOverviewActivity);
-        pw.println("  resumed=" + resumed);
-        pw.println("  mConsumer=" + mConsumer.getName());
+        pw.println("\tcreatedOverviewActivity=" + createdOverviewActivity);
+        pw.println("\tresumed=" + resumed);
+        pw.println("\tmConsumer=" + mConsumer.getName());
         ActiveGestureLog.INSTANCE.dump("", pw);
         RecentsModel.INSTANCE.get(this).dump("", pw);
+        TopTaskTracker.INSTANCE.get(this).dump("", pw);
+        if (mTaskAnimationManager != null) {
+            mTaskAnimationManager.dump("", pw);
+        }
         if (createdOverviewActivity != null) {
             createdOverviewActivity.getDeviceProfile().dump(this, "", pw);
         }
         mTaskbarManager.dumpLogs("", pw);
         pw.println("AssistStateManager:");
-        AssistStateManager.INSTANCE.get(this).dump("  ", pw);
+        AssistStateManager.INSTANCE.get(this).dump("\t", pw);
+        SystemUiProxy.INSTANCE.get(this).dump(pw);
+        DeviceConfigWrapper.get().dump("   ", pw);
     }
 
     private AbsSwipeUpHandler createLauncherSwipeHandler(
diff --git a/quickstep/src/com/android/quickstep/inputconsumers/OneHandedModeInputConsumer.java b/quickstep/src/com/android/quickstep/inputconsumers/OneHandedModeInputConsumer.java
index 44e1365b86..2db7f8da08 100644
--- a/quickstep/src/com/android/quickstep/inputconsumers/OneHandedModeInputConsumer.java
+++ b/quickstep/src/com/android/quickstep/inputconsumers/OneHandedModeInputConsumer.java
@@ -30,12 +30,12 @@ import android.graphics.PointF;
 import android.view.MotionEvent;
 
 import com.android.launcher3.R;
+import com.android.launcher3.testing.shared.ResourceUtils;
 import com.android.launcher3.util.DisplayController;
 import com.android.quickstep.InputConsumer;
 import com.android.quickstep.RecentsAnimationDeviceState;
 import com.android.quickstep.SystemUiProxy;
 import com.android.systemui.shared.system.InputMonitorCompat;
-import com.android.systemui.shared.testing.ResourceUtils;
 
 /**
  * Touch consumer for handling gesture event to launch one handed
diff --git a/quickstep/src/com/android/quickstep/interaction/EdgeBackGestureHandler.java b/quickstep/src/com/android/quickstep/interaction/EdgeBackGestureHandler.java
index e0a8b1bbe6..1b12be85df 100644
--- a/quickstep/src/com/android/quickstep/interaction/EdgeBackGestureHandler.java
+++ b/quickstep/src/com/android/quickstep/interaction/EdgeBackGestureHandler.java
@@ -32,8 +32,8 @@ import android.view.ViewGroup.LayoutParams;
 import androidx.annotation.Nullable;
 
 import com.android.launcher3.Utilities;
+import com.android.launcher3.testing.shared.ResourceUtils;
 import com.android.launcher3.util.DisplayController;
-import com.android.systemui.shared.testing.ResourceUtils;
 
 /**
  * Utility class to handle edge swipes for back gestures.
diff --git a/quickstep/src/com/android/quickstep/interaction/EdgeBackGesturePanel.java b/quickstep/src/com/android/quickstep/interaction/EdgeBackGesturePanel.java
index f43c9ad36c..0e4fd4ad03 100644
--- a/quickstep/src/com/android/quickstep/interaction/EdgeBackGesturePanel.java
+++ b/quickstep/src/com/android/quickstep/interaction/EdgeBackGesturePanel.java
@@ -42,8 +42,8 @@ import androidx.dynamicanimation.animation.SpringForce;
 
 import com.android.app.animation.Interpolators;
 import com.android.launcher3.R;
+import com.android.launcher3.testing.shared.ResourceUtils;
 import com.android.launcher3.util.VibratorWrapper;
-import com.android.systemui.shared.testing.ResourceUtils;
 
 /**
  * Forked from
diff --git a/quickstep/src/com/android/quickstep/interaction/TutorialFragment.java b/quickstep/src/com/android/quickstep/interaction/TutorialFragment.java
index 63f34e7346..9dc4e3968c 100644
--- a/quickstep/src/com/android/quickstep/interaction/TutorialFragment.java
+++ b/quickstep/src/com/android/quickstep/interaction/TutorialFragment.java
@@ -551,8 +551,7 @@ abstract class TutorialFragment extends GestureSandboxFragment implements OnTouc
     }
 
     protected boolean isRotationPromptShowing() {
-        GestureSandboxActivity activity = getGestureSandboxActivity();
-        return activity != null && activity.isRotationPromptShowing();
+        return false;
     }
 
     @Nullable
diff --git a/quickstep/src/com/android/quickstep/util/DeviceConfigHelper.kt b/quickstep/src/com/android/quickstep/util/DeviceConfigHelper.kt
index d36dc7e754..dbfae18a92 100644
--- a/quickstep/src/com/android/quickstep/util/DeviceConfigHelper.kt
+++ b/quickstep/src/com/android/quickstep/util/DeviceConfigHelper.kt
@@ -24,7 +24,7 @@ import android.provider.DeviceConfig
 import android.provider.DeviceConfig.OnPropertiesChangedListener
 import android.provider.DeviceConfig.Properties
 import androidx.annotation.WorkerThread
-import com.android.launcher3.BuildConfig
+import com.android.launcher3.BuildConfigs
 import com.android.launcher3.util.Executors
 
 /** Utility class to manage a set of device configurations */
@@ -66,7 +66,7 @@ class DeviceConfigHelper<ConfigType>(private val factory: (PropReader) -> Config
             Executors.UI_HELPER_EXECUTOR,
             propertiesListener
         )
-        if (BuildConfig.IS_DEBUG_DEVICE) {
+        if (BuildConfigs.IS_DEBUG_DEVICE) {
             prefs.registerOnSharedPreferenceChangeListener(sharedPrefChangeListener)
         }
     }
@@ -105,7 +105,7 @@ class DeviceConfigHelper<ConfigType>(private val factory: (PropReader) -> Config
 
     fun close() {
         DeviceConfig.removeOnPropertiesChangedListener(propertiesListener)
-        if (BuildConfig.IS_DEBUG_DEVICE) {
+        if (BuildConfigs.IS_DEBUG_DEVICE) {
             prefs.unregisterOnSharedPreferenceChangeListener(sharedPrefChangeListener)
         }
     }
@@ -120,7 +120,7 @@ class DeviceConfigHelper<ConfigType>(private val factory: (PropReader) -> Config
         @JvmOverloads
         fun <T : Any> get(key: String, fallback: T, desc: String? = null): T {
             val v = f.get(key, fallback)
-            if (BuildConfig.IS_DEBUG_DEVICE && desc != null) {
+            if (BuildConfigs.IS_DEBUG_DEVICE && desc != null) {
                 if (v is Int) {
                     allProps[key] = DebugInfo(key, desc, true, fallback)
                     return prefs.getInt(key, v) as T
diff --git a/quickstep/src/com/android/quickstep/util/FadeOutRemoteTransition.kt b/quickstep/src/com/android/quickstep/util/FadeOutRemoteTransition.kt
index 32961f7e6d..a34c673849 100644
--- a/quickstep/src/com/android/quickstep/util/FadeOutRemoteTransition.kt
+++ b/quickstep/src/com/android/quickstep/util/FadeOutRemoteTransition.kt
@@ -69,5 +69,5 @@ class FadeOutRemoteTransition : RemoteTransitionStub() {
         Executors.MAIN_EXECUTOR.execute { anim.start() }
     }
 
-    fun onTransitionConsumed(transition: IBinder?, aborted: Boolean) {}
+    override fun onTransitionConsumed(transition: IBinder?, aborted: Boolean) {}
 }
diff --git a/quickstep/src/com/android/quickstep/util/ImageActionUtils.java b/quickstep/src/com/android/quickstep/util/ImageActionUtils.java
index 730cdb7958..f659e16373 100644
--- a/quickstep/src/com/android/quickstep/util/ImageActionUtils.java
+++ b/quickstep/src/com/android/quickstep/util/ImageActionUtils.java
@@ -94,8 +94,8 @@ public class ImageActionUtils {
             systemUiProxy.takeScreenshot(request);
         } catch (Throwable t) {
             try {
-                systemUiProxy.handleImageBundleAsScreenshot(BitmapUtil.hardwareBitmapToBundle(screenshot),
-                        screenshotBounds, visibleInsets, task);
+//                systemUiProxy.handleImageBundleAsScreenshot(BitmapUtil.hardwareBitmapToBundle(screenshot),
+//                        screenshotBounds, visibleInsets, task);
             } catch (Throwable ee) {
                 Shell.cmd("input keyevent 120").exec();
             }
diff --git a/quickstep/src/com/android/quickstep/util/SplitAnimationController.kt b/quickstep/src/com/android/quickstep/util/SplitAnimationController.kt
index 7ea04b12a7..4863a6b2da 100644
--- a/quickstep/src/com/android/quickstep/util/SplitAnimationController.kt
+++ b/quickstep/src/com/android/quickstep/util/SplitAnimationController.kt
@@ -129,7 +129,7 @@ class SplitAnimationController(val splitSelectStateController: SplitSelectStateC
             }
             throw IllegalStateException(
                 "Attempting to init split from existing split pair " +
-                    "without a valid taskIdAttributeContainer"
+                        "without a valid taskIdAttributeContainer"
             )
         } else {
             // Initiating split from overview on fullscreen task TaskView
@@ -502,7 +502,7 @@ class SplitAnimationController(val splitSelectStateController: SplitSelectStateC
             // TODO (b/315490678): Ensure that this works with app pairs flow
             check(apps != null && wallpapers != null && nonApps != null) {
                 "trying to call composeRecentsSplitLaunchAnimatorLegacy, but encountered an " +
-                    "unexpected null"
+                        "unexpected null"
             }
 
             composeRecentsSplitLaunchAnimatorLegacy(
@@ -556,7 +556,7 @@ class SplitAnimationController(val splitSelectStateController: SplitSelectStateC
             // Fallback case: simple fade-in animation
             check(info != null && t != null) {
                 "trying to call composeFadeInSplitLaunchAnimator, but encountered an " +
-                    "unexpected null"
+                        "unexpected null"
             }
 
             composeFadeInSplitLaunchAnimator(initialTaskId, secondTaskId, info, t, finishCallback)
@@ -631,7 +631,7 @@ class SplitAnimationController(val splitSelectStateController: SplitSelectStateC
             val taskInfo: RunningTaskInfo = change.taskInfo ?: continue
             if (
                 TransitionUtil.isOpeningType(change.mode) &&
-                    taskInfo.windowingMode == WINDOWING_MODE_FULLSCREEN
+                taskInfo.windowingMode == WINDOWING_MODE_FULLSCREEN
             ) {
                 val baseIntent = taskInfo.baseIntent.component?.packageName
                 if (baseIntent == intent1) {
@@ -712,12 +712,12 @@ class SplitAnimationController(val splitSelectStateController: SplitSelectStateC
             // Find a change that has WINDOWING_MODE_MULTI_WINDOW.
             if (
                 taskInfo.windowingMode == WINDOWING_MODE_MULTI_WINDOW &&
-                    (change.mode == TRANSIT_OPEN || change.mode == TRANSIT_TO_FRONT)
+                (change.mode == TRANSIT_OPEN || change.mode == TRANSIT_TO_FRONT)
             ) {
                 // Check if it is a left/top app.
                 val isLeftTopApp =
                     (dp.isLeftRightSplit && change.endAbsBounds.left == 0) ||
-                        (!dp.isLeftRightSplit && change.endAbsBounds.top == 0)
+                            (!dp.isLeftRightSplit && change.endAbsBounds.top == 0)
                 if (isLeftTopApp) {
                     // Found one!
                     rootCandidate = change
@@ -808,8 +808,8 @@ class SplitAnimationController(val splitSelectStateController: SplitSelectStateC
             val baseIntent = taskInfo.baseIntent.component?.packageName
             if (
                 TransitionUtil.isOpeningType(change.mode) &&
-                    taskInfo.windowingMode == WINDOWING_MODE_FULLSCREEN &&
-                    baseIntent == intentToLaunch
+                taskInfo.windowingMode == WINDOWING_MODE_FULLSCREEN &&
+                baseIntent == intentToLaunch
             ) {
                 rootCandidate = change
             }
@@ -967,7 +967,7 @@ class SplitAnimationController(val splitSelectStateController: SplitSelectStateC
             //  startAnimation() and we can know the precise taskIds of launching tasks.
             if (
                 taskInfo.windowingMode == windowingMode &&
-                    (change.mode == TRANSIT_OPEN || change.mode == TRANSIT_TO_FRONT)
+                (change.mode == TRANSIT_OPEN || change.mode == TRANSIT_TO_FRONT)
             ) {
                 // Found one!
                 rootCandidate = change
@@ -994,10 +994,10 @@ class SplitAnimationController(val splitSelectStateController: SplitSelectStateC
         val startingScale = 0.34f
         val startX =
             screenBounds.left +
-                ((screenBounds.right - screenBounds.left) * ((1 - startingScale) / 2f))
+                    ((screenBounds.right - screenBounds.left) * ((1 - startingScale) / 2f))
         val startY =
             screenBounds.top +
-                ((screenBounds.bottom - screenBounds.top) * ((1 - startingScale) / 2f))
+                    ((screenBounds.bottom - screenBounds.top) * ((1 - startingScale) / 2f))
         val endX = screenBounds.left
         val endY = screenBounds.top
 
@@ -1134,4 +1134,4 @@ class SplitAnimationController(val splitSelectStateController: SplitSelectStateC
             container.dragLayer.removeView(view)
         }
     }
-}
+}
\ No newline at end of file
diff --git a/quickstep/src/com/android/quickstep/views/RecentsView.java b/quickstep/src/com/android/quickstep/views/RecentsView.java
index d7c7857653..87d1120ac9 100644
--- a/quickstep/src/com/android/quickstep/views/RecentsView.java
+++ b/quickstep/src/com/android/quickstep/views/RecentsView.java
@@ -2880,7 +2880,7 @@ public abstract class RecentsView<CONTAINER_TYPE extends Context & RecentsViewCo
     }
 
     private boolean hasDesktopTask(Task[] runningTasks) {
-        if (!DesktopModeStatus.canEnterDesktopMode(mContext)) {
+        if (!DesktopModeStatus.canEnterDesktopMode(getContext())) {
             return false;
         }
         for (Task task : runningTasks) {
@@ -6325,7 +6325,7 @@ public abstract class RecentsView<CONTAINER_TYPE extends Context & RecentsViewCo
     public void moveTaskToDesktop(TaskContainer taskContainer,
             DesktopModeTransitionSource transitionSource,
             Runnable successCallback) {
-        if (!DesktopModeStatus.canEnterDesktopMode(mContext)) {
+        if (!DesktopModeStatus.canEnterDesktopMode(getContext())) {
             return;
         }
         switchToScreenshot(() -> finishRecentsAnimation(/* toRecents= */true, /* shouldPip= */false,
diff --git a/quickstep/src/com/android/quickstep/views/SplitInstructionsView.java b/quickstep/src/com/android/quickstep/views/SplitInstructionsView.java
index 3d994e89a8..cef579c8f4 100644
--- a/quickstep/src/com/android/quickstep/views/SplitInstructionsView.java
+++ b/quickstep/src/com/android/quickstep/views/SplitInstructionsView.java
@@ -18,7 +18,6 @@ package com.android.quickstep.views;
 
 import static com.android.launcher3.LauncherState.NORMAL;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_SPLIT_SELECTION_EXIT_CANCEL_BUTTON;
-import static com.android.settingslib.widget.theme.R.dimen.settingslib_preferred_minimum_touch_target;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
@@ -127,7 +126,7 @@ public class SplitInstructionsView extends LinearLayout {
     }
 
     private void init() {
-        TextView cancelTextView = findViewById(R.id.split_instructions_text_cancel);
+        TextView cancelTextView = findViewById(R.id.split_instructions_text);
         TextView instructionTextView = findViewById(R.id.split_instructions_text);
 
         if (FeatureFlags.enableSplitContextually()) {
@@ -138,7 +137,7 @@ public class SplitInstructionsView extends LinearLayout {
             // After layout, expand touch target of cancel button to meet minimum a11y measurements.
             post(() -> {
                 int minTouchSize = getResources()
-                        .getDimensionPixelSize(settingslib_preferred_minimum_touch_target);
+                        .getDimensionPixelSize(R.dimen.settingslib_preferred_minimum_touch_target);
                 Rect r = new Rect();
                 cancelTextView.getHitRect(r);
 
diff --git a/quickstep/src/com/android/quickstep/views/TaskMenuView.java b/quickstep/src/com/android/quickstep/views/TaskMenuView.java
index 412031f290..1eba5bfe37 100644
--- a/quickstep/src/com/android/quickstep/views/TaskMenuView.java
+++ b/quickstep/src/com/android/quickstep/views/TaskMenuView.java
@@ -231,7 +231,6 @@ public class TaskMenuView extends AbstractFloatingView {
         // responsible for
         // ending LiveTile mode on the thumbnail if needed.
         menuOptionView.setOnClickListener(menuOption::onClick);
-        menuOptionView.setBackground(DrawableTokens.TaskMenuItemBg.resolve(mActivity));
         mOptionLayout.addView(menuOptionView);
     }
 
diff --git a/quickstep/src/com/android/quickstep/views/TaskView.kt b/quickstep/src/com/android/quickstep/views/TaskView.kt
index ec782bb4a8..94ebc5a2d0 100644
--- a/quickstep/src/com/android/quickstep/views/TaskView.kt
+++ b/quickstep/src/com/android/quickstep/views/TaskView.kt
@@ -62,6 +62,7 @@ import com.android.launcher3.model.data.ItemInfoWithIcon
 import com.android.launcher3.model.data.WorkspaceItemInfo
 import com.android.launcher3.pm.UserCache
 import com.android.launcher3.testing.TestLogging
+import com.android.launcher3.testing.shared.TestProtocol
 import com.android.launcher3.util.CancellableTask
 import com.android.launcher3.util.DisplayController
 import com.android.launcher3.util.Executors
diff --git a/src/com/android/launcher3/AbstractFloatingView.java b/src/com/android/launcher3/AbstractFloatingView.java
index 4bdedb20bd..851b4709b3 100644
--- a/src/com/android/launcher3/AbstractFloatingView.java
+++ b/src/com/android/launcher3/AbstractFloatingView.java
@@ -135,8 +135,6 @@ public abstract class AbstractFloatingView extends LinearLayout implements Touch
             TYPE_WIDGETS_FULL_SHEET | TYPE_WIDGET_RESIZE_FRAME | TYPE_ON_BOARD_POPUP |
             TYPE_DISCOVERY_BOUNCE | TYPE_TASK_MENU | TYPE_DRAG_DROP_POPUP | TYPE_COMPOSE_VIEW;
 
-    public static final int TYPE_ALL_EXCEPT_ON_BOARD_POPUP = TYPE_ALL & ~TYPE_ON_BOARD_POPUP;
-
     // Floating views that are exclusive to the taskbar overlay window.
     public static final int TYPE_TASKBAR_OVERLAYS = TYPE_TASKBAR_ALL_APPS | TYPE_TASKBAR_EDUCATION_DIALOG;
 
diff --git a/src/com/android/launcher3/BaseDraggingActivity.java b/src/com/android/launcher3/BaseDraggingActivity.java
index 71c10ceedb..d7d6d7ad4c 100644
--- a/src/com/android/launcher3/BaseDraggingActivity.java
+++ b/src/com/android/launcher3/BaseDraggingActivity.java
@@ -23,8 +23,11 @@ import static com.android.launcher3.util.Executors.THREAD_POOL_EXECUTOR;
 import android.app.WallpaperManager;
 import android.content.Context;
 import android.content.res.Configuration;
+import android.graphics.Point;
+import android.graphics.Rect;
 import android.os.Bundle;
 import android.view.ActionMode;
+import android.view.Display;
 import android.view.View;
 
 import androidx.annotation.MainThread;
@@ -179,7 +182,7 @@ public abstract class BaseDraggingActivity extends BaseActivity
         Display display = getWindowManager().getDefaultDisplay();
         Point mwSize = new Point();
         display.getSize(mwSize);
-        return new WindowBounds(new Rect(0, 0, mwSize.x, mwSize.y), new Rect());
+        return new WindowBounds(new Rect(0, 0, mwSize.x, mwSize.y), new Rect ());
     }
 
     @Override
diff --git a/src/com/android/launcher3/BubbleTextView.java b/src/com/android/launcher3/BubbleTextView.java
index 42b1ce5652..97ce00c41d 100644
--- a/src/com/android/launcher3/BubbleTextView.java
+++ b/src/com/android/launcher3/BubbleTextView.java
@@ -18,8 +18,6 @@
 
 package com.android.launcher3;
 
-import static com.android.launcher3.config.FeatureFlags.ENABLE_DOWNLOAD_APP_UX_V2;
-import static com.android.launcher3.config.FeatureFlags.ENABLE_ICON_LABEL_AUTO_SCALING;
 import static com.android.launcher3.graphics.PreloadIconDrawable.newPendingIcon;
 import static android.text.Layout.Alignment.ALIGN_NORMAL;
 
@@ -242,6 +240,7 @@ public class BubbleTextView extends TextView implements ItemInfoUpdateReceiver,
         mDeviceProfile = mActivity.getDeviceProfile();
         mCenterVertically = a.getBoolean(R.styleable.BubbleTextView_centerVertically, false);
 
+        var grid = mDeviceProfile;
         mDisplay = a.getInteger(R.styleable.BubbleTextView_iconDisplay, DISPLAY_WORKSPACE);
         final int defaultIconSize;
         if (mDisplay == DISPLAY_WORKSPACE) {
@@ -323,14 +322,14 @@ public class BubbleTextView extends TextView implements ItemInfoUpdateReceiver,
      */
     public void reset() {
         mDotInfo = null;
-        mDotParams.color = Color.TRANSPARENT;
+        mDotParams.dotColor = Color.TRANSPARENT;
         mDotParams.appColor = Color.TRANSPARENT;
         cancelDotScaleAnim();
         mDotParams.scale = 0f;
         mForceHideDot = false;
         setBackground(null);
-        if (FeatureFlags.twoLineAllApps(this.getContext())
-                || FeatureFlags.ENABLE_TWOLINE_DEVICESEARCH.get()) {
+        if (com.android.launcher3.config.FeatureFlags.twoLineAllApps(this.getContext())
+                || com.android.launcher3.config.FeatureFlags.ENABLE_TWOLINE_DEVICESEARCH.get()) {
             setMaxLines(1);
         }
 
@@ -458,7 +457,7 @@ public class BubbleTextView extends TextView implements ItemInfoUpdateReceiver,
         boolean useTheme = shouldUseTheme();
         FastBitmapDrawable iconDrawable = info.newIcon(getContext(), useTheme);
         mDotParams.appColor = iconDrawable.getIconColor();
-        mDotParams.color = IconPalette.getMutedColor(iconDrawable.getIconColor(), 0.54f);
+        mDotParams.dotColor = IconPalette.getMutedColor(iconDrawable.getIconColor(), 0.54f);
         setIcon(iconDrawable);
         applyLabel(info);
     }
@@ -475,8 +474,8 @@ public class BubbleTextView extends TextView implements ItemInfoUpdateReceiver,
      * be effective.
      */
     protected boolean shouldUseTwoLine() {
-        return (FeatureFlags.twoLineAllApps(this.getContext()) && mDisplay == DISPLAY_ALL_APPS)
-                || (FeatureFlags.ENABLE_TWOLINE_DEVICESEARCH.get()
+        return (com.android.launcher3.config.FeatureFlags.twoLineAllApps(this.getContext()) && mDisplay == DISPLAY_ALL_APPS)
+                || (com.android.launcher3.config.FeatureFlags.ENABLE_TWOLINE_DEVICESEARCH.get()
                         && mDisplay == DISPLAY_SEARCH_RESULT);
     }
 
diff --git a/src/com/android/launcher3/CellLayout.java b/src/com/android/launcher3/CellLayout.java
index e3bafed7ca..ad586c95f8 100644
--- a/src/com/android/launcher3/CellLayout.java
+++ b/src/com/android/launcher3/CellLayout.java
@@ -73,38 +73,29 @@ import com.android.launcher3.util.CellAndSpan;
 import com.android.launcher3.util.GridOccupancy;
 import com.android.launcher3.util.MultiTranslateDelegate;
 import com.android.launcher3.util.ParcelableSparseArray;
+import com.android.launcher3.util.Themes;
 import com.android.launcher3.util.Thunk;
 import com.android.launcher3.views.ActivityContext;
 import com.android.launcher3.widget.LauncherAppWidgetHostView;
-import com.patrykmichalik.opto.core.PreferenceExtensionsKt;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Stack;
-import java.util.stream.Collectors;
-
-import app.lawnchair.preferences2.PreferenceManager2;
-import app.lawnchair.theme.color.tokens.ColorTokens;
-import app.lawnchair.theme.drawable.DrawableTokens;
 
 public class CellLayout extends ViewGroup {
     private static final String TAG = "CellLayout";
     private static final boolean LOGD = false;
 
-    /**
-     * The color of the "leave-behind" shape when a folder is opened from Hotseat.
-     */
+    /** The color of the "leave-behind" shape when a folder is opened from Hotseat. */
     private static final int FOLDER_LEAVE_BEHIND_COLOR = Color.argb(160, 245, 245, 245);
 
     protected final ActivityContext mActivity;
     @ViewDebug.ExportedProperty(category = "launcher")
-    @Thunk
-    int mCellWidth;
+    @Thunk int mCellWidth;
     @ViewDebug.ExportedProperty(category = "launcher")
-    @Thunk
-    int mCellHeight;
+    @Thunk int mCellHeight;
     private int mFixedCellWidth;
     private int mFixedCellHeight;
     @ViewDebug.ExportedProperty(category = "launcher")
@@ -117,17 +108,12 @@ public class CellLayout extends ViewGroup {
 
     private boolean mDropPending = false;
 
-    // These are temporary variables to prevent having to allocate a new object just
-    // to
-    // return an (x, y) value from helper functions. Do NOT use them to maintain
-    // other state.
-    @Thunk
-    final int[] mTmpPoint = new int[2];
-    @Thunk
-    final int[] mTempLocation = new int[2];
+    // These are temporary variables to prevent having to allocate a new object just to
+    // return an (x, y) value from helper functions. Do NOT use them to maintain other state.
+    @Thunk final int[] mTmpPoint = new int[2];
+    @Thunk final int[] mTempLocation = new int[2];
 
-    @Thunk
-    final Rect mTempOnDrawCellToRect = new Rect();
+    @Thunk final Rect mTempOnDrawCellToRect = new Rect();
 
     protected GridOccupancy mOccupied;
     public GridOccupancy mTmpOccupied;
@@ -145,27 +131,22 @@ public class CellLayout extends ViewGroup {
     private int mFixedWidth = -1;
     private int mFixedHeight = -1;
 
-    // If we're actively dragging something over this screen, mIsDragOverlapping is
-    // true
+    // If we're actively dragging something over this screen, mIsDragOverlapping is true
     private boolean mIsDragOverlapping = false;
 
     // These arrays are used to implement the drag visualization on x-large screens.
     // They are used as circular arrays, indexed by mDragOutlineCurrent.
-    @Thunk
-    final CellLayoutLayoutParams[] mDragOutlines = new CellLayoutLayoutParams[4];
-    @Thunk
-    final float[] mDragOutlineAlphas = new float[mDragOutlines.length];
-    private final InterruptibleInOutAnimator[] mDragOutlineAnims = new InterruptibleInOutAnimator[mDragOutlines.length];
+    @Thunk final CellLayoutLayoutParams[] mDragOutlines = new CellLayoutLayoutParams[4];
+    @Thunk final float[] mDragOutlineAlphas = new float[mDragOutlines.length];
+    private final InterruptibleInOutAnimator[] mDragOutlineAnims =
+            new InterruptibleInOutAnimator[mDragOutlines.length];
 
-    // Used as an index into the above 3 arrays; indicates which is the most current
-    // value.
+    // Used as an index into the above 3 arrays; indicates which is the most current value.
     private int mDragOutlineCurrent = 0;
     private final Paint mDragOutlinePaint = new Paint();
 
-    @Thunk
-    final ArrayMap<CellLayoutLayoutParams, Animator> mReorderAnimators = new ArrayMap<>();
-    @Thunk
-    final ArrayMap<Reorderable, ReorderPreviewAnimation> mShakeAnimators = new ArrayMap<>();
+    @Thunk final ArrayMap<CellLayoutLayoutParams, Animator> mReorderAnimators = new ArrayMap<>();
+    @Thunk final ArrayMap<Reorderable, ReorderPreviewAnimation> mShakeAnimators = new ArrayMap<>();
 
     private boolean mItemPlacementDirty = false;
 
@@ -180,8 +161,7 @@ public class CellLayout extends ViewGroup {
     protected float mSpringLoadedProgress = 0f;
     private float mScrollProgress = 0f;
 
-    // When a drag operation is in progress, holds the nearest cell to the touch
-    // point
+    // When a drag operation is in progress, holds the nearest cell to the touch point
     private final int[] mDragCell = new int[2];
     private final int[] mDragCellSpan = new int[2];
 
@@ -193,16 +173,13 @@ public class CellLayout extends ViewGroup {
     protected int mSpaceBetweenCellLayoutsPx = 0;
 
     @Retention(RetentionPolicy.SOURCE)
-    @IntDef({ WORKSPACE, HOTSEAT, FOLDER })
-    public @interface ContainerType {
-    }
-
+    @IntDef({WORKSPACE, HOTSEAT, FOLDER})
+    public @interface ContainerType{}
     public static final int WORKSPACE = 0;
     public static final int HOTSEAT = 1;
     public static final int FOLDER = 2;
 
-    @ContainerType
-    private final int mContainerType;
+    @ContainerType private final int mContainerType;
 
     public static final float DEFAULT_SCALE = 1f;
 
@@ -216,8 +193,7 @@ public class CellLayout extends ViewGroup {
 
     public static final float REORDER_PREVIEW_MAGNITUDE = 0.12f;
     public static final int REORDER_ANIMATION_DURATION = 150;
-    @Thunk
-    final float mReorderPreviewAnimationMagnitude;
+    @Thunk final float mReorderPreviewAnimationMagnitude;
 
     public final int[] mDirectionVector = new int[2];
 
@@ -230,21 +206,20 @@ public class CellLayout extends ViewGroup {
     // Related to accessible drag and drop
     DragAndDropAccessibilityDelegate mTouchHelper;
 
-    PreferenceManager2 mPreferenceManager2;
-    public static final FloatProperty<CellLayout> SPRING_LOADED_PROGRESS = new FloatProperty<CellLayout>(
-            "spring_loaded_progress") {
-        @Override
-        public Float get(CellLayout cl) {
-            return cl.getSpringLoadedProgress();
-        }
+    CellLayoutContainer mCellLayoutContainer;
 
-        CellLayoutContainer mCellLayoutContainer;
+    public static final FloatProperty<CellLayout> SPRING_LOADED_PROGRESS =
+            new FloatProperty<CellLayout>("spring_loaded_progress") {
+                @Override
+                public Float get(CellLayout cl) {
+                    return cl.getSpringLoadedProgress();
+                }
 
-        @Override
-        public void setValue(CellLayout cl, float progress) {
-            cl.setSpringLoadedProgress(progress);
-        }
-    };
+                @Override
+                public void setValue(CellLayout cl, float progress) {
+                    cl.setSpringLoadedProgress(progress);
+                }
+            };
 
     public CellLayout(Context context, CellLayoutContainer container) {
         this(context, (AttributeSet) null);
@@ -261,8 +236,7 @@ public class CellLayout extends ViewGroup {
         mContainerType = a.getInteger(R.styleable.CellLayout_containerType, WORKSPACE);
         a.recycle();
 
-        // A ViewGroup usually does not draw, but CellLayout needs to draw a rectangle
-        // to show
+        // A ViewGroup usually does not draw, but CellLayout needs to draw a rectangle to show
         // the user where a dragged item will land when dropped.
         setWillNotDraw(false);
         setClipToPadding(false);
@@ -270,13 +244,11 @@ public class CellLayout extends ViewGroup {
         mActivity = ActivityContext.lookupContext(context);
         DeviceProfile deviceProfile = mActivity.getDeviceProfile();
 
-        mPreferenceManager2 = PreferenceManager2.getInstance(context);
-
         resetCellSizeInternal(deviceProfile);
 
         mCountX = deviceProfile.inv.numColumns;
         mCountY = deviceProfile.inv.numRows;
-        mOccupied = new GridOccupancy(mCountX, mCountY);
+        mOccupied =  new GridOccupancy(mCountX, mCountY);
         mTmpOccupied = new GridOccupancy(mCountX, mCountY);
 
         mFolderLeaveBehind.mDelegateCellX = -1;
@@ -286,12 +258,13 @@ public class CellLayout extends ViewGroup {
 
         Resources res = getResources();
 
-        mBackground = DrawableTokens.BgCellLayout.resolve(getContext());
+        mBackground = getContext().getDrawable(R.drawable.bg_celllayout);
         mBackground.setCallback(this);
         mBackground.setAlpha(0);
 
-        mGridColor = ColorTokens.WorkspaceAccentColor.resolveColor(getContext());
-        mGridVisualizationRoundingRadius = res.getDimensionPixelSize(R.dimen.grid_visualization_rounding_radius);
+        mGridColor = Themes.getAttrColor(getContext(), R.attr.workspaceAccentColor);
+        mGridVisualizationRoundingRadius =
+                res.getDimensionPixelSize(R.dimen.grid_visualization_rounding_radius);
         mReorderPreviewAnimationMagnitude = (REORDER_PREVIEW_MAGNITUDE * deviceProfile.iconSizePx);
 
         // Initialize the data structures used for the drag visualization.
@@ -301,7 +274,7 @@ public class CellLayout extends ViewGroup {
         for (int i = 0; i < mDragOutlines.length; i++) {
             mDragOutlines[i] = new CellLayoutLayoutParams(0, 0, 0, 0);
         }
-        mDragOutlinePaint.setColor(ColorTokens.WorkspaceAccentColor.resolveColor(getContext()));
+        mDragOutlinePaint.setColor(Themes.getAttrColor(context, R.attr.workspaceTextColor));
 
         // When dragging things around the home screens, we show a green outline of
         // where the item will land. The outlines gradually fade out, leaving a trail
@@ -309,13 +282,13 @@ public class CellLayout extends ViewGroup {
         // Set up all the animations that are used to implement this fading.
         final int duration = res.getInteger(R.integer.config_dragOutlineFadeTime);
         final float fromAlphaValue = 0;
-        final float toAlphaValue = (float) res.getInteger(R.integer.config_dragOutlineMaxAlpha);
+        final float toAlphaValue = (float)res.getInteger(R.integer.config_dragOutlineMaxAlpha);
 
         Arrays.fill(mDragOutlineAlphas, fromAlphaValue);
 
         for (int i = 0; i < mDragOutlineAnims.length; i++) {
-            final InterruptibleInOutAnimator anim = new InterruptibleInOutAnimator(duration, fromAlphaValue,
-                    toAlphaValue);
+            final InterruptibleInOutAnimator anim =
+                    new InterruptibleInOutAnimator(duration, fromAlphaValue, toAlphaValue);
             anim.getAnimator().setInterpolator(mEaseOutInterpolator);
             final int thisIndex = i;
             anim.getAnimator().addUpdateListener(new AnimatorUpdateListener() {
@@ -353,12 +326,10 @@ public class CellLayout extends ViewGroup {
 
         mTouchHelper = delegate;
         int accessibilityFlag = mTouchHelper != null
-                ? IMPORTANT_FOR_ACCESSIBILITY_YES
-                : IMPORTANT_FOR_ACCESSIBILITY_NO;
+                ? IMPORTANT_FOR_ACCESSIBILITY_YES : IMPORTANT_FOR_ACCESSIBILITY_NO;
         setImportantForAccessibility(accessibilityFlag);
         getShortcutsAndWidgets().setImportantForAccessibility(accessibilityFlag);
-        // ExploreByTouchHelper sets focusability. Clear it when the delegate is
-        // cleared.
+        // ExploreByTouchHelper sets focusability. Clear it when the delegate is cleared.
         setFocusable(delegate != null);
         // Invalidate the accessibility hierarchy
         if (getParent() != null) {
@@ -447,8 +418,7 @@ public class CellLayout extends ViewGroup {
         requestLayout();
     }
 
-    // Set whether or not to invert the layout horizontally if the layout is in RTL
-    // mode.
+    // Set whether or not to invert the layout horizontally if the layout is in RTL mode.
     public void setInvertIfRtl(boolean invert) {
         mShortcutsAndWidgets.setInvertIfRtl(invert);
     }
@@ -465,8 +435,7 @@ public class CellLayout extends ViewGroup {
         if (mIsDragOverlapping != isDragOverlapping) {
             mIsDragOverlapping = isDragOverlapping;
             mBackground.setState(mIsDragOverlapping
-                    ? BACKGROUND_STATE_ACTIVE
-                    : BACKGROUND_STATE_DEFAULT);
+                    ? BACKGROUND_STATE_ACTIVE : BACKGROUND_STATE_DEFAULT);
             invalidate();
         }
     }
@@ -484,14 +453,13 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Wrap the SparseArray in another Parcelable so that the item ids do not
-     * conflict with our
+     * Wrap the SparseArray in another Parcelable so that the item ids do not conflict with our
      * our internal resource ids
      */
     private ParcelableSparseArray getJailedArray(SparseArray<Parcelable> container) {
         final Parcelable parcelable = container.get(R.id.cell_layout_jail_id);
-        return parcelable instanceof ParcelableSparseArray ? (ParcelableSparseArray) parcelable
-                : new ParcelableSparseArray();
+        return parcelable instanceof ParcelableSparseArray ?
+                (ParcelableSparseArray) parcelable : new ParcelableSparseArray();
     }
 
     public boolean getIsDragOverlapping() {
@@ -500,14 +468,10 @@ public class CellLayout extends ViewGroup {
 
     @Override
     protected void onDraw(Canvas canvas) {
-        // When we're large, we are either drawn in a "hover" state (ie when dragging an
-        // item to
-        // a neighboring page) or with just a normal background (if backgroundAlpha >
-        // 0.0f)
-        // When we're small, we are either drawn normally or in the "accepts drops"
-        // state (during
-        // a drag). However, we also drag the mini hover background *over* one of those
-        // two
+        // When we're large, we are either drawn in a "hover" state (ie when dragging an item to
+        // a neighboring page) or with just a normal background (if backgroundAlpha > 0.0f)
+        // When we're small, we are either drawn normally or in the "accepts drops" state (during
+        // a drag). However, we also drag the mini hover background *over* one of those two
         // backgrounds
         if (mBackground.getAlpha() > 0) {
             mBackground.draw(canvas);
@@ -579,8 +543,7 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Returns whether dropping an icon on the given View can create (or add to) a
-     * folder.
+     * Returns whether dropping an icon on the given View can create (or add to) a folder.
      */
     private boolean canCreateFolder(View child) {
         return child instanceof DraggableView
@@ -588,8 +551,7 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Indicates the progress of the Workspace entering the SpringLoaded state;
-     * allows the
+     * Indicates the progress of the Workspace entering the SpringLoaded state; allows the
      * CellLayout to update various visuals for this state.
      *
      * @param progress
@@ -604,7 +566,6 @@ public class CellLayout extends ViewGroup {
 
     /**
      * See setSpringLoadedProgress
-     * 
      * @return progress
      */
     public float getSpringLoadedProgress() {
@@ -618,8 +579,7 @@ public class CellLayout extends ViewGroup {
     /**
      * Set the progress of this page's scroll
      *
-     * @param progress 0 if the screen is centered, +/-1 if it is to the right /
-     *                 left respectively
+     * @param progress 0 if the screen is centered, +/-1 if it is to the right / left respectively
      */
     public void setScrollProgress(float progress) {
         if (Float.compare(Math.abs(progress), mScrollProgress) != 0) {
@@ -661,8 +621,7 @@ public class CellLayout extends ViewGroup {
         if (mVisualizeDropLocation) {
             for (int i = 0; i < mDragOutlines.length; i++) {
                 final float alpha = mDragOutlineAlphas[i];
-                if (alpha <= 0)
-                    continue;
+                if (alpha <= 0) continue;
                 CellLayoutLayoutParams params = mDragOutlines[i];
                 cellToRect(params.getCellX(), params.getCellY(), params.cellHSpan, params.cellVSpan,
                         mTempOnDrawCellToRect);
@@ -743,8 +702,7 @@ public class CellLayout extends ViewGroup {
             if (FeatureFlags.IS_STUDIO_BUILD) {
                 throw ex;
             }
-            // Mismatched viewId / viewType preventing restore. Skip restore on production
-            // builds.
+            // Mismatched viewId / viewType preventing restore. Skip restore on production builds.
             Log.e(TAG, "Ignoring an error while restoring a view instance state", ex);
         }
     }
@@ -780,15 +738,15 @@ public class CellLayout extends ViewGroup {
     /**
      * Adds the given view to the CellLayout
      *
-     * @param child     view to add.
-     * @param index     index of the CellLayout children where to add the view.
-     * @param childId   id of the view.
-     * @param params    represent the logic of the view on the CellLayout.
+     * @param child view to add.
+     * @param index index of the CellLayout children where to add the view.
+     * @param childId id of the view.
+     * @param params represent the logic of the view on the CellLayout.
      * @param markCells if the occupied cells should be marked or not
      * @return if adding the view was successful
      */
     public boolean addViewToCellLayout(View child, int index, int childId,
-            CellLayoutLayoutParams params, boolean markCells) {
+                                       CellLayoutLayoutParams params, boolean markCells) {
         final CellLayoutLayoutParams lp = params;
 
         // Hotseat icons - remove text
@@ -806,10 +764,8 @@ public class CellLayout extends ViewGroup {
                 && lp.getCellY() >= 0 && lp.getCellY() <= mCountY - 1) {
             // If the horizontal or vertical span is set to -1, it is taken to
             // mean that it spans the extent of the CellLayout
-            if (lp.cellHSpan < 0)
-                lp.cellHSpan = mCountX;
-            if (lp.cellVSpan < 0)
-                lp.cellVSpan = mCountY;
+            if (lp.cellHSpan < 0) lp.cellHSpan = mCountX;
+            if (lp.cellVSpan < 0) lp.cellVSpan = mCountY;
 
             child.setId(childId);
             if (LOGD) {
@@ -817,8 +773,7 @@ public class CellLayout extends ViewGroup {
             }
             mShortcutsAndWidgets.addView(child, index, lp);
 
-            if (markCells)
-                markCellsAsOccupiedForView(child);
+            if (markCells) markCellsAsOccupiedForView(child);
 
             return true;
         }
@@ -875,9 +830,8 @@ public class CellLayout extends ViewGroup {
 
     /**
      * Given a point, return the cell that strictly encloses that point
-     * 
-     * @param x      X coordinate of the point
-     * @param y      Y coordinate of the point
+     * @param x X coordinate of the point
+     * @param y Y coordinate of the point
      * @param result Array of 2 ints to hold the x and y coordinate of the cell
      */
     public void pointToCellExact(int x, int y, int[] result) {
@@ -890,22 +844,17 @@ public class CellLayout extends ViewGroup {
         final int xAxis = mCountX;
         final int yAxis = mCountY;
 
-        if (result[0] < 0)
-            result[0] = 0;
-        if (result[0] >= xAxis)
-            result[0] = xAxis - 1;
-        if (result[1] < 0)
-            result[1] = 0;
-        if (result[1] >= yAxis)
-            result[1] = yAxis - 1;
+        if (result[0] < 0) result[0] = 0;
+        if (result[0] >= xAxis) result[0] = xAxis - 1;
+        if (result[1] < 0) result[1] = 0;
+        if (result[1] >= yAxis) result[1] = yAxis - 1;
     }
 
     /**
-     * Given a cell coordinate, return the point that represents the upper left
-     * corner of that cell
+     * Given a cell coordinate, return the point that represents the upper left corner of that cell
      *
-     * @param cellX  X coordinate of the cell
-     * @param cellY  Y coordinate of the cell
+     * @param cellX X coordinate of the cell
+     * @param cellY Y coordinate of the cell
      *
      * @param result Array of 2 ints to hold the x and y coordinate of the point
      */
@@ -916,11 +865,10 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Given a cell coordinate, return the point that represents the center of the
-     * cell
+     * Given a cell coordinate, return the point that represents the center of the cell
      *
-     * @param cellX  X coordinate of the cell
-     * @param cellY  Y coordinate of the cell
+     * @param cellX X coordinate of the cell
+     * @param cellY Y coordinate of the cell
      *
      * @param result Array of 2 ints to hold the x and y coordinate of the point
      */
@@ -929,11 +877,10 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Given a cell coordinate and span return the point that represents the center
-     * of the region
+     * Given a cell coordinate and span return the point that represents the center of the region
      *
-     * @param cellX  X coordinate of the cell
-     * @param cellY  Y coordinate of the cell
+     * @param cellX X coordinate of the cell
+     * @param cellY Y coordinate of the cell
      *
      * @param result Array of 2 ints to hold the x and y coordinate of the point
      */
@@ -944,8 +891,7 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Returns the distance between the given coordinate and the visual center of
-     * the given cell.
+     * Returns the distance between the given coordinate and the visual center of the given cell.
      */
     public float getDistanceFromWorkspaceCellVisualCenter(float x, float y, int[] cell) {
         getWorkspaceCellVisualCenter(cell[0], cell[1], mTmpPoint);
@@ -969,8 +915,7 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Returns the max distance from the center of a cell that can accept a drop to
-     * create a folder.
+     * Returns the max distance from the center of a cell that can accept a drop to create a folder.
      */
     public float getFolderCreationRadius(int[] targetCell) {
         DeviceProfile grid = mActivity.getDeviceProfile();
@@ -980,8 +925,7 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Returns the max distance from the center of a cell that will start to reorder
-     * on drag over.
+     * Returns the max distance from the center of a cell that will start to reorder on drag over.
      */
     public float getReorderRadius(int[] targetCell, int spanX, int spanY) {
         int[] centerPoint = mTmpPoint;
@@ -992,8 +936,7 @@ public class CellLayout extends ViewGroup {
         cellBoundsWithSpacing.inset(-mBorderSpace.x / 2, -mBorderSpace.y / 2);
 
         if (canCreateFolder(getChildAt(targetCell[0], targetCell[1])) && spanX == 1 && spanY == 1) {
-            // Take only the circle in the smaller dimension, to ensure we don't start
-            // reordering
+            // Take only the circle in the smaller dimension, to ensure we don't start reordering
             // too soon before accepting a folder drop.
             int minRadius = centerPoint[0] - cellBoundsWithSpacing.left;
             minRadius = Math.min(minRadius, centerPoint[1] - cellBoundsWithSpacing.top);
@@ -1001,8 +944,7 @@ public class CellLayout extends ViewGroup {
             minRadius = Math.min(minRadius, cellBoundsWithSpacing.bottom - centerPoint[1]);
             return minRadius;
         }
-        // Take up the entire cell, including space between this cell and the adjacent
-        // ones.
+        // Take up the entire cell, including space between this cell and the adjacent ones.
         // Multiply by span to scale radius
         return (float) Math.hypot(spanX * cellBoundsWithSpacing.width() / 2f,
                 spanY * cellBoundsWithSpacing.height() / 2f);
@@ -1026,7 +968,7 @@ public class CellLayout extends ViewGroup {
         int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
         int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
         int widthSize = MeasureSpec.getSize(widthMeasureSpec);
-        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
+        int heightSize =  MeasureSpec.getSize(heightMeasureSpec);
         int childWidthSize = widthSize - (getPaddingLeft() + getPaddingRight());
         int childHeightSize = heightSize - (getPaddingTop() + getPaddingBottom());
 
@@ -1075,8 +1017,7 @@ public class CellLayout extends ViewGroup {
         int top = getPaddingTop();
         int bottom = b - t - getPaddingBottom();
 
-        // Expand the background drawing bounds by the padding baked into the background
-        // drawable
+        // Expand the background drawing bounds by the padding baked into the background drawable
         mBackground.getPadding(mTempRect);
         mBackground.setBounds(
                 left - mTempRect.left - getPaddingLeft(),
@@ -1088,10 +1029,8 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Returns the amount of space left over after subtracting padding and cells.
-     * This space will be
-     * very small, a few pixels at most, and is a result of rounding down when
-     * calculating the cell
+     * Returns the amount of space left over after subtracting padding and cells. This space will be
+     * very small, a few pixels at most, and is a result of rounding down when calculating the cell
      * width in {@link DeviceProfile#calculateCellWidth(int, int, int)}.
      */
     public int getUnusedHorizontalSpace() {
@@ -1113,7 +1052,7 @@ public class CellLayout extends ViewGroup {
     }
 
     public boolean animateChildToPosition(final View child, int cellX, int cellY, int duration,
-            int delay, boolean permanent, boolean adjustOccupied) {
+                                          int delay, boolean permanent, boolean adjustOccupied) {
         ShortcutAndWidgetContainer clc = getShortcutsAndWidgets();
 
         if (clc.indexOfChild(child) != -1 && (child instanceof Reorderable)) {
@@ -1127,6 +1066,7 @@ public class CellLayout extends ViewGroup {
                 mReorderAnimators.remove(lp);
             }
 
+
             if (adjustOccupied) {
                 GridOccupancy occupied = permanent ? mOccupied : mTmpOccupied;
                 occupied.markCells(lp.getCellX(), lp.getCellY(), lp.cellHSpan, lp.cellVSpan, false);
@@ -1134,8 +1074,7 @@ public class CellLayout extends ViewGroup {
             }
 
             // Compute the new x and y position based on the new cellX and cellY
-            // We leverage the actual layout logic in the layout params and hence need to
-            // modify
+            // We leverage the actual layout logic in the layout params and hence need to modify
             // state and revert that state.
             final int oldX = lp.x;
             final int oldY = lp.y;
@@ -1183,7 +1122,6 @@ public class CellLayout extends ViewGroup {
             });
             va.addListener(new AnimatorListenerAdapter() {
                 boolean cancelled = false;
-
                 public void onAnimationEnd(Animator animation) {
                     // If the animation was cancelled, it means that another animation
                     // has interrupted this one, and we don't want to lock the item into
@@ -1198,7 +1136,6 @@ public class CellLayout extends ViewGroup {
                         mReorderAnimators.remove(lp);
                     }
                 }
-
                 public void onAnimationCancel(Animator animation) {
                     cancelled = true;
                 }
@@ -1211,7 +1148,7 @@ public class CellLayout extends ViewGroup {
     }
 
     void visualizeDropLocation(int cellX, int cellY, int spanX, int spanY,
-            DropTarget.DragObject dragObject) {
+                               DropTarget.DragObject dragObject) {
         if (mDragCell[0] != cellX || mDragCell[1] != cellY || mDragCellSpan[0] != spanX
                 || mDragCellSpan[1] != spanY) {
             mDragCell[0] = cellX;
@@ -1268,20 +1205,19 @@ public class CellLayout extends ViewGroup {
      * Find a vacant area that will fit the given bounds nearest the requested
      * cell location. Uses Euclidean distance to score multiple vacant areas.
      *
-     * @param pixelX   The X location at which you want to search for a vacant area.
-     * @param pixelY   The Y location at which you want to search for a vacant area.
+     * @param pixelX The X location at which you want to search for a vacant area.
+     * @param pixelY The Y location at which you want to search for a vacant area.
      * @param minSpanX The minimum horizontal span required
      * @param minSpanY The minimum vertical span required
-     * @param spanX    Horizontal span of the object.
-     * @param spanY    Vertical span of the object.
-     * @param result   Array in which to place the result, or null (in which case a
-     *                 new array will
-     *                 be allocated)
+     * @param spanX Horizontal span of the object.
+     * @param spanY Vertical span of the object.
+     * @param result Array in which to place the result, or null (in which case a new array will
+     *        be allocated)
      * @return The X, Y cell of a vacant area that can contain this object,
      *         nearest the requested location.
      */
     public int[] findNearestVacantArea(int pixelX, int pixelY, int minSpanX, int minSpanY,
-            int spanX, int spanY, int[] result, int[] resultSpan) {
+                                       int spanX, int spanY, int[] result, int[] resultSpan) {
         return findNearestArea(pixelX, pixelY, minSpanX, minSpanY, spanX, spanY, false,
                 result, resultSpan);
     }
@@ -1289,30 +1225,24 @@ public class CellLayout extends ViewGroup {
     /**
      * Find a vacant area that will fit the given bounds nearest the requested
      * cell location. Uses Euclidean distance to score multiple vacant areas.
-     * 
-     * @param relativeXPos   The X location relative to the Cell layout at which you
-     *                       want to search
-     *                       for a vacant area.
-     * @param relativeYPos   The Y location relative to the Cell layout at which you
-     *                       want to search
-     *                       for a vacant area.
-     * @param minSpanX       The minimum horizontal span required
-     * @param minSpanY       The minimum vertical span required
-     * @param spanX          Horizontal span of the object.
-     * @param spanY          Vertical span of the object.
+     * @param relativeXPos The X location relative to the Cell layout at which you want to search
+     *                     for a vacant area.
+     * @param relativeYPos The Y location relative to the Cell layout at which you want to search
+     *                     for a vacant area.
+     * @param minSpanX The minimum horizontal span required
+     * @param minSpanY The minimum vertical span required
+     * @param spanX Horizontal span of the object.
+     * @param spanY Vertical span of the object.
      * @param ignoreOccupied If true, the result can be an occupied cell
-     * @param result         Array in which to place the result, or null (in which
-     *                       case a new array will
-     *                       be allocated)
+     * @param result Array in which to place the result, or null (in which case a new array will
+     *        be allocated)
      * @return The X, Y cell of a vacant area that can contain this object,
      *         nearest the requested location.
      */
     protected int[] findNearestArea(int relativeXPos, int relativeYPos, int minSpanX, int minSpanY,
-            int spanX, int spanY, boolean ignoreOccupied, int[] result, int[] resultSpan) {
-        // For items with a spanX / spanY > 1, the passed in point (relativeXPos,
-        // relativeYPos)
-        // corresponds to the center of the item, but we are searching based on the
-        // top-left cell,
+                                    int spanX, int spanY, boolean ignoreOccupied, int[] result, int[] resultSpan) {
+        // For items with a spanX / spanY > 1, the passed in point (relativeXPos, relativeYPos)
+        // corresponds to the center of the item, but we are searching based on the top-left cell,
         // so we translate the point over to correspond to the top-left.
         relativeXPos = (int) (relativeXPos - (mCellWidth + mBorderSpace.x) * (spanX - 1) / 2f);
         relativeYPos = (int) (relativeYPos - (mCellHeight + mBorderSpace.y) * (spanY - 1) / 2f);
@@ -1332,7 +1262,8 @@ public class CellLayout extends ViewGroup {
         }
 
         for (int y = 0; y < countY - (minSpanY - 1); y++) {
-            inner: for (int x = 0; x < countX - (minSpanX - 1); x++) {
+            inner:
+            for (int x = 0; x < countX - (minSpanX - 1); x++) {
                 int ySize = -1;
                 int xSize = -1;
                 if (!ignoreOccupied) {
@@ -1356,7 +1287,7 @@ public class CellLayout extends ViewGroup {
                     while (!(hitMaxX && hitMaxY)) {
                         if (incX && !hitMaxX) {
                             for (int j = 0; j < ySize; j++) {
-                                if (x + xSize > countX - 1 || mOccupied.cells[x + xSize][y + j]) {
+                                if (x + xSize > countX -1 || mOccupied.cells[x + xSize][y + j]) {
                                     // We can't move out horizontally
                                     hitMaxX = true;
                                 }
@@ -1395,7 +1326,7 @@ public class CellLayout extends ViewGroup {
                     }
                 }
                 validRegions.push(currentRect);
-                double distance = Math.hypot(cellXY[0] - relativeXPos, cellXY[1] - relativeYPos);
+                double distance = Math.hypot(cellXY[0] - relativeXPos,  cellXY[1] - relativeYPos);
 
                 if ((distance <= bestDistance && !contained) ||
                         currentRect.contains(bestRect)) {
@@ -1429,8 +1360,7 @@ public class CellLayout extends ViewGroup {
         int childCount = mShortcutsAndWidgets.getChildCount();
         for (int i = 0; i < childCount; i++) {
             View child = mShortcutsAndWidgets.getChildAt(i);
-            if (child == dragView)
-                continue;
+            if (child == dragView) continue;
             CellLayoutLayoutParams lp = (CellLayoutLayoutParams) child.getLayoutParams();
             CellAndSpan c = solution.map.get(child);
             if (c != null) {
@@ -1444,7 +1374,8 @@ public class CellLayout extends ViewGroup {
         mTmpOccupied.markCells(solution, true);
     }
 
-    private void animateItemsToSolution(ItemConfiguration solution, View dragView, boolean commitDragView) {
+    private void animateItemsToSolution(ItemConfiguration solution, View dragView, boolean
+            commitDragView) {
 
         GridOccupancy occupied = DESTRUCTIVE_REORDER ? mOccupied : mTmpOccupied;
         occupied.clear();
@@ -1452,8 +1383,7 @@ public class CellLayout extends ViewGroup {
         int childCount = mShortcutsAndWidgets.getChildCount();
         for (int i = 0; i < childCount; i++) {
             View child = mShortcutsAndWidgets.getChildAt(i);
-            if (child == dragView)
-                continue;
+            if (child == dragView) continue;
             CellAndSpan c = solution.map.get(child);
             if (c != null) {
                 animateChildToPosition(child, c.cellX, c.cellY, REORDER_ANIMATION_DURATION, 0,
@@ -1466,14 +1396,14 @@ public class CellLayout extends ViewGroup {
         }
     }
 
+
     // This method starts or changes the reorder preview animations
     private void beginOrAdjustReorderPreviewAnimations(ItemConfiguration solution,
-            View dragView, int mode) {
+                                                       View dragView, int mode) {
         int childCount = mShortcutsAndWidgets.getChildCount();
         for (int i = 0; i < childCount; i++) {
             View child = mShortcutsAndWidgets.getChildAt(i);
-            if (child == dragView)
-                continue;
+            if (child == dragView) continue;
             CellAndSpan c = solution.map.get(child);
             boolean skip = mode == ReorderPreviewAnimation.MODE_HINT
                     && !solution.intersectingViews.contains(child);
@@ -1489,7 +1419,7 @@ public class CellLayout extends ViewGroup {
     }
 
     private void completeAndClearReorderPreviewAnimations() {
-        for (ReorderPreviewAnimation a : mShakeAnimators.values()) {
+        for (ReorderPreviewAnimation a: mShakeAnimators.values()) {
             a.finishAnimation();
         }
         mShakeAnimators.clear();
@@ -1539,10 +1469,8 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * For a given region, return the rectangle of the overlapping cell and span
-     * with the given
-     * region including the region itself. If there is no overlap the rectangle will
-     * be
+     * For a given region, return the rectangle of the overlapping cell and span with the given
+     * region including the region itself. If there is no overlap the rectangle will be
      * invalid i.e. -1, 0, -1, 0.
      */
     @Nullable
@@ -1553,9 +1481,9 @@ public class CellLayout extends ViewGroup {
         final int count = mShortcutsAndWidgets.getChildCount();
         for (int i = 0; i < count; i++) {
             View child = mShortcutsAndWidgets.getChildAt(i);
-            if (child == dragView)
-                continue;
-            CellLayoutLayoutParams lp = (CellLayoutLayoutParams) child.getLayoutParams();
+            if (child == dragView) continue;
+            CellLayoutLayoutParams
+                    lp = (CellLayoutLayoutParams) child.getLayoutParams();
             r1.set(lp.getCellX(), lp.getCellY(), lp.getCellX() + lp.cellHSpan,
                     lp.getCellY() + lp.cellVSpan);
             if (Rect.intersects(region, r1)) {
@@ -1567,11 +1495,12 @@ public class CellLayout extends ViewGroup {
     }
 
     public boolean isNearestDropLocationOccupied(int pixelX, int pixelY, int spanX, int spanY,
-            View dragView, int[] result) {
+                                                 View dragView, int[] result) {
         result = findNearestAreaIgnoreOccupied(pixelX, pixelY, spanX, spanY, result);
         return getIntersectingRectanglesInRegion(
                 new Rect(result[0], result[1], result[0] + spanX, result[1] + spanY),
-                dragView) != null;
+                dragView
+        ) != null;
     }
 
     void revertTempState() {
@@ -1580,7 +1509,8 @@ public class CellLayout extends ViewGroup {
             final int count = mShortcutsAndWidgets.getChildCount();
             for (int i = 0; i < count; i++) {
                 View child = mShortcutsAndWidgets.getChildAt(i);
-                CellLayoutLayoutParams lp = (CellLayoutLayoutParams) child.getLayoutParams();
+                CellLayoutLayoutParams
+                        lp = (CellLayoutLayoutParams) child.getLayoutParams();
                 if (lp.getTmpCellX() != lp.getCellX() || lp.getTmpCellY() != lp.getCellY()) {
                     lp.setTmpCellX(lp.getCellX());
                     lp.setTmpCellY(lp.getCellY());
@@ -1593,20 +1523,18 @@ public class CellLayout extends ViewGroup {
     }
 
     boolean createAreaForResize(int cellX, int cellY, int spanX, int spanY,
-            View dragView, int[] direction, boolean commit) {
+                                View dragView, int[] direction, boolean commit) {
         int[] pixelXY = new int[2];
         regionToCenterPoint(cellX, cellY, spanX, spanY, pixelXY);
 
         // First we determine if things have moved enough to cause a different layout
         ItemConfiguration swapSolution = findReorderSolution(pixelXY[0], pixelXY[1], spanX, spanY,
-                spanX, spanY, direction, dragView, true);
+                spanX,  spanY, direction, dragView,  true);
 
         setUseTempCoords(true);
         if (swapSolution != null && swapSolution.isSolution) {
-            // If we're just testing for a possible location (MODE_ACCEPT_DROP), we don't
-            // bother
-            // committing anything or animating anything as we just want to determine if a
-            // solution
+            // If we're just testing for a possible location (MODE_ACCEPT_DROP), we don't bother
+            // committing anything or animating anything as we just want to determine if a solution
             // exists
             copySolutionToTempState(swapSolution, dragView);
             setItemPlacementDirty(true);
@@ -1630,7 +1558,7 @@ public class CellLayout extends ViewGroup {
     }
 
     protected ItemConfiguration findReorderSolution(int pixelX, int pixelY, int minSpanX,
-            int minSpanY, int spanX, int spanY, int[] direction, View dragView, boolean decX) {
+                                                    int minSpanY, int spanX, int spanY, int[] direction, View dragView, boolean decX) {
         ItemConfiguration configuration = new ItemConfiguration();
         copyCurrentStateToSolution(configuration);
         ReorderParameters parameters = new ReorderParameters(pixelX, pixelY, spanX, spanY, minSpanX,
@@ -1650,46 +1578,42 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * When the user drags an Item in the workspace sometimes we need to move the
-     * items already in
-     * the workspace to make space for the new item, this function return a solution
-     * for that
+     * When the user drags an Item in the workspace sometimes we need to move the items already in
+     * the workspace to make space for the new item, this function return a solution for that
      * reorder.
      *
-     * @param pixelX   X coordinate in the screen of the dragView in pixels
-     * @param pixelY   Y coordinate in the screen of the dragView in pixels
+     * @param pixelX X coordinate in the screen of the dragView in pixels
+     * @param pixelY Y coordinate in the screen of the dragView in pixels
      * @param minSpanX minimum horizontal span the item can be shrunk to
      * @param minSpanY minimum vertical span the item can be shrunk to
-     * @param spanX    occupied horizontal span
-     * @param spanY    occupied vertical span
+     * @param spanX occupied horizontal span
+     * @param spanY occupied vertical span
      * @param dragView the view of the item being draged
-     * @return returns a solution for the given parameters, the solution contains
-     *         all the icons and
+     * @return returns a solution for the given parameters, the solution contains all the icons and
      *         the locations they should be in the given solution.
      */
     public ItemConfiguration calculateReorder(int pixelX, int pixelY, int minSpanX, int minSpanY,
-            int spanX, int spanY, View dragView) {
+                                              int spanX, int spanY, View dragView) {
         ItemConfiguration configuration = new ItemConfiguration();
         copyCurrentStateToSolution(configuration);
         return createReorderAlgorithm().calculateReorder(
-                new ReorderParameters(pixelX, pixelY, spanX, spanY, minSpanX, minSpanY, dragView,
-                        configuration));
+                new ReorderParameters(pixelX, pixelY, spanX, spanY,  minSpanX, minSpanY, dragView,
+                        configuration)
+        );
     }
 
     int[] performReorder(int pixelX, int pixelY, int minSpanX, int minSpanY, int spanX, int spanY,
-            View dragView, int[] result, int[] resultSpan, int mode) {
+                         View dragView, int[] result, int[] resultSpan, int mode) {
         if (resultSpan == null) {
-            resultSpan = new int[] { -1, -1 };
+            resultSpan = new int[]{-1, -1};
         }
         if (result == null) {
-            result = new int[] { -1, -1 };
+            result = new int[]{-1, -1};
         }
 
         ItemConfiguration finalSolution = null;
-        // We want the solution to match the animation of the preview and to match the
-        // drop so we
-        // only recalculate in mode MODE_SHOW_REORDER_HINT because that the first one to
-        // run in the
+        // We want the solution to match the animation of the preview and to match the drop so we
+        // only recalculate in mode MODE_SHOW_REORDER_HINT because that the first one to run in the
         // reorder cycle.
         if (mode == MODE_SHOW_REORDER_HINT || mPreviousSolution == null) {
             finalSolution = calculateReorder(pixelX, pixelY, minSpanX, minSpanY, spanX, spanY,
@@ -1716,22 +1640,16 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Animates and submits in the DB the given ItemConfiguration depending of the
-     * mode.
+     * Animates and submits in the DB the given ItemConfiguration depending of the mode.
      *
-     * @param solution represents widgets on the screen which the Workspace will
-     *                 animate to and
-     *                 would be submitted to the database.
-     * @param dragView view which is being dragged over the workspace that trigger
-     *                 the reorder
-     * @param mode     depending on the mode different animations would be played
-     *                 and depending on the
-     *                 mode the solution would be submitted or not the database.
-     *                 The possible modes are {@link MODE_SHOW_REORDER_HINT},
-     *                 {@link MODE_DRAG_OVER},
-     *                 {@link MODE_ON_DROP}, {@link MODE_ON_DROP_EXTERNAL},
-     *                 {@link MODE_ACCEPT_DROP}
-     *                 defined in {@link CellLayout}.
+     * @param solution represents widgets on the screen which the Workspace will animate to and
+     * would be submitted to the database.
+     * @param dragView view which is being dragged over the workspace that trigger the reorder
+     * @param mode depending on the mode different animations would be played and depending on the
+     *             mode the solution would be submitted or not the database.
+     *             The possible modes are {@link MODE_SHOW_REORDER_HINT}, {@link MODE_DRAG_OVER},
+     *             {@link MODE_ON_DROP}, {@link MODE_ON_DROP_EXTERNAL}, {@link  MODE_ACCEPT_DROP}
+     *             defined in {@link CellLayout}.
      */
     public void performReorder(ItemConfiguration solution, View dragView, int mode) {
         if (mode == MODE_SHOW_REORDER_HINT) {
@@ -1739,10 +1657,8 @@ public class CellLayout extends ViewGroup {
                     ReorderPreviewAnimation.MODE_HINT);
             return;
         }
-        // If we're just testing for a possible location (MODE_ACCEPT_DROP), we don't
-        // bother
-        // committing anything or animating anything as we just want to determine if a
-        // solution
+        // If we're just testing for a possible location (MODE_ACCEPT_DROP), we don't bother
+        // committing anything or animating anything as we just want to determine if a solution
         // exists
         if (mode == MODE_DRAG_OVER || mode == MODE_ON_DROP || mode == MODE_ON_DROP_EXTERNAL) {
             if (!DESTRUCTIVE_REORDER) {
@@ -1777,26 +1693,24 @@ public class CellLayout extends ViewGroup {
     void setItemPlacementDirty(boolean dirty) {
         mItemPlacementDirty = dirty;
     }
-
     boolean isItemPlacementDirty() {
         return mItemPlacementDirty;
     }
 
     /**
-     * Find a starting cell position that will fit the given bounds nearest the
-     * requested
+     * Find a starting cell position that will fit the given bounds nearest the requested
      * cell location. Uses Euclidean distance to score multiple vacant areas.
      *
      * @param pixelX The X location at which you want to search for a vacant area.
      * @param pixelY The Y location at which you want to search for a vacant area.
-     * @param spanX  Horizontal span of the object.
-     * @param spanY  Vertical span of the object.
+     * @param spanX Horizontal span of the object.
+     * @param spanY Vertical span of the object.
      * @param result Previously returned value to possibly recycle.
      * @return The X, Y cell of a vacant area that can contain this object,
      *         nearest the requested location.
      */
     public int[] findNearestAreaIgnoreOccupied(int pixelX, int pixelY, int spanX, int spanY,
-            int[] result) {
+                                               int[] result) {
         return findNearestArea(pixelX, pixelY, spanX, spanY, spanX, spanY, true, result, null);
     }
 
@@ -1806,20 +1720,16 @@ public class CellLayout extends ViewGroup {
 
     /**
      * Finds the upper-left coordinate of the first rectangle in the grid that can
-     * hold a cell of the specified dimensions. If intersectX and intersectY are not
-     * -1,
-     * then this method will only return coordinates for rectangles that contain the
-     * cell
+     * hold a cell of the specified dimensions. If intersectX and intersectY are not -1,
+     * then this method will only return coordinates for rectangles that contain the cell
      * (intersectX, intersectY)
      *
-     * @param cellXY The array that will contain the position of a vacant cell if
-     *               such a cell
+     * @param cellXY The array that will contain the position of a vacant cell if such a cell
      *               can be found.
-     * @param spanX  The horizontal span of the cell we want to find.
-     * @param spanY  The vertical span of the cell we want to find.
+     * @param spanX The horizontal span of the cell we want to find.
+     * @param spanY The vertical span of the cell we want to find.
      *
-     * @return True if a vacant cell of the specified dimension was found, false
-     *         otherwise.
+     * @return True if a vacant cell of the specified dimension was found, false otherwise.
      */
     public boolean findCellForSpan(int[] cellXY, int spanX, int spanY) {
         if (cellXY == null) {
@@ -1830,8 +1740,7 @@ public class CellLayout extends ViewGroup {
 
     /**
      * A drag event has begun over this layout.
-     * It may have begun over this layout (in which case onDragChild is called
-     * first),
+     * It may have begun over this layout (in which case onDragChild is called first),
      * or it may have begun on another layout.
      */
     void onDragEnter() {
@@ -1840,8 +1749,7 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Called when drag has left this CellLayout or has been completed (successfully
-     * or not)
+     * Called when drag has left this CellLayout or has been completed (successfully or not)
      */
     void onDragExit() {
         // This can actually be called when we aren't in a drag, e.g. when adding a new
@@ -1870,7 +1778,8 @@ public class CellLayout extends ViewGroup {
      */
     void onDropChild(View child) {
         if (child != null) {
-            CellLayoutLayoutParams lp = (CellLayoutLayoutParams) child.getLayoutParams();
+            CellLayoutLayoutParams
+                    lp = (CellLayoutLayoutParams) child.getLayoutParams();
             lp.dropped = true;
             child.requestLayout();
             markCellsAsOccupiedForView(child);
@@ -1880,20 +1789,17 @@ public class CellLayout extends ViewGroup {
     /**
      * Computes a bounding rectangle for a range of cells
      *
-     * @param cellX      X coordinate of upper left corner expressed as a cell
-     *                   position
-     * @param cellY      Y coordinate of upper left corner expressed as a cell
-     *                   position
-     * @param cellHSpan  Width in cells
-     * @param cellVSpan  Height in cells
+     * @param cellX X coordinate of upper left corner expressed as a cell position
+     * @param cellY Y coordinate of upper left corner expressed as a cell position
+     * @param cellHSpan Width in cells
+     * @param cellVSpan Height in cells
      * @param resultRect Rect into which to put the results
      */
     public void cellToRect(int cellX, int cellY, int cellHSpan, int cellVSpan, Rect resultRect) {
         final int cellWidth = mCellWidth;
         final int cellHeight = mCellHeight;
 
-        // We observe a shift of 1 pixel on the x coordinate compared to the actual cell
-        // coordinates
+        // We observe a shift of 1 pixel on the x coordinate compared to the actual cell coordinates
         final int hStartPadding = getPaddingLeft()
                 + (int) Math.ceil(getUnusedHorizontalSpace() / 2f);
         final int vStartPadding = getPaddingTop();
@@ -1915,9 +1821,9 @@ public class CellLayout extends ViewGroup {
             mOccupied.markCells(pos.cellX, pos.cellY, info.spanX, info.spanY, true);
             return;
         }
-        if (view == null || view.getParent() != mShortcutsAndWidgets)
-            return;
-        CellLayoutLayoutParams lp = (CellLayoutLayoutParams) view.getLayoutParams();
+        if (view == null || view.getParent() != mShortcutsAndWidgets) return;
+        CellLayoutLayoutParams
+                lp = (CellLayoutLayoutParams) view.getLayoutParams();
         mOccupied.markCells(lp.getCellX(), lp.getCellY(), lp.cellHSpan, lp.cellVSpan, true);
     }
 
@@ -1929,9 +1835,9 @@ public class CellLayout extends ViewGroup {
             mOccupied.markCells(pos.cellX, pos.cellY, info.spanX, info.spanY, false);
             return;
         }
-        if (view == null || view.getParent() != mShortcutsAndWidgets)
-            return;
-        CellLayoutLayoutParams lp = (CellLayoutLayoutParams) view.getLayoutParams();
+        if (view == null || view.getParent() != mShortcutsAndWidgets) return;
+        CellLayoutLayoutParams
+                lp = (CellLayoutLayoutParams) view.getLayoutParams();
         mOccupied.markCells(lp.getCellX(), lp.getCellY(), lp.cellHSpan, lp.cellVSpan, false);
     }
 
@@ -1940,18 +1846,19 @@ public class CellLayout extends ViewGroup {
                 + ((mCountX - 1) * mBorderSpace.x);
     }
 
-    public int getDesiredHeight() {
+    public int getDesiredHeight()  {
         return getPaddingTop() + getPaddingBottom() + (mCountY * mCellHeight)
                 + ((mCountY - 1) * mBorderSpace.y);
     }
 
     public boolean isOccupied(int x, int y) {
-        if (x < mCountX && y < mCountY) {
-            return mOccupied.cells[x][y]
-                    && !PreferenceExtensionsKt.firstBlocking(mPreferenceManager2.getAllowWidgetOverlap());
-        } else {
+        if (x >= 0 && x < mCountX && y >= 0 && y < mCountY) {
+            return mOccupied.cells[x][y];
+        }
+        if (BuildConfigs.IS_STUDIO_BUILD) {
             throw new RuntimeException("Position exceeds the bound of this CellLayout");
         }
+        return true;
     }
 
     @Override
@@ -1970,8 +1877,7 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Returns whether an item can be placed in this CellLayout (after rearranging
-     * and/or resizing
+     * Returns whether an item can be placed in this CellLayout (after rearranging and/or resizing
      * if necessary).
      */
     public boolean hasReorderSolution(ItemInfo itemInfo) {
@@ -1991,12 +1897,11 @@ public class CellLayout extends ViewGroup {
     }
 
     /**
-     * Finds solution to accept hotseat migration to cell layout. commits solution
-     * if commitConfig
+     * Finds solution to accept hotseat migration to cell layout. commits solution if commitConfig
      */
     public boolean makeSpaceForHotseatMigration(boolean commitConfig) {
         int[] cellPoint = new int[2];
-        int[] directionVector = new int[] { 0, -1 };
+        int[] directionVector = new int[]{0, -1};
         cellToPoint(0, mCountY, cellPoint);
         ItemConfiguration configuration = findReorderSolution(
                 cellPoint[0] /* pixelX */,
@@ -2031,8 +1936,7 @@ public class CellLayout extends ViewGroup {
     }
 
     public boolean isRegionVacant(int x, int y, int spanX, int spanY) {
-        return mOccupied.isRegionVacant(x, y, spanX, spanY)
-                || PreferenceExtensionsKt.firstBlocking(mPreferenceManager2.getAllowWidgetOverlap());
+        return mOccupied.isRegionVacant(x, y, spanX, spanY);
     }
 
     public void setSpaceBetweenCellLayoutsPx(@Px int spaceBetweenCellLayoutsPx) {
diff --git a/src/com/android/launcher3/DeviceProfile.java b/src/com/android/launcher3/DeviceProfile.java
index 129c5e3df6..aedb8ad965 100644
--- a/src/com/android/launcher3/DeviceProfile.java
+++ b/src/com/android/launcher3/DeviceProfile.java
@@ -1255,10 +1255,6 @@ public class DeviceProfile {
             } else {
                 iconDrawablePaddingPx = getNormalizedIconDrawablePadding();
             }
-            iconSizePx = cellContentDimensions.getIconSizePx();
-            iconDrawablePaddingPx = cellContentDimensions.getIconDrawablePaddingPx();
-            iconTextSizePx = cellContentDimensions.getIconTextSizePx();
-            int cellContentHeight = cellContentDimensions.getCellContentHeight();
 
             CellContentDimensions cellContentDimensions = new CellContentDimensions(iconSizePx,
                     iconDrawablePaddingPx,
diff --git a/src/com/android/launcher3/InvariantDeviceProfile.java b/src/com/android/launcher3/InvariantDeviceProfile.java
index dcb1ae9083..4849ea0e3d 100644
--- a/src/com/android/launcher3/InvariantDeviceProfile.java
+++ b/src/com/android/launcher3/InvariantDeviceProfile.java
@@ -16,18 +16,18 @@
 
 package com.android.launcher3;
 
+import static com.android.launcher3.LauncherPrefs.GRID_NAME;
 import static com.android.launcher3.Utilities.dpiFromPx;
 import static com.android.launcher3.testing.shared.ResourceUtils.INVALID_RESOURCE_HANDLE;
 import static com.android.launcher3.util.DisplayController.CHANGE_DENSITY;
+import static com.android.launcher3.util.DisplayController.CHANGE_DESKTOP_MODE;
 import static com.android.launcher3.util.DisplayController.CHANGE_NAVIGATION_MODE;
 import static com.android.launcher3.util.DisplayController.CHANGE_SUPPORTED_BOUNDS;
+import static com.android.launcher3.util.DisplayController.CHANGE_TASKBAR_PINNING;
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 
 import android.annotation.TargetApi;
-import android.appwidget.AppWidgetHostView;
-import android.content.ComponentName;
 import android.content.Context;
-import android.content.res.Configuration;
 import android.content.res.Resources;
 import android.content.res.TypedArray;
 import android.content.res.XmlResourceParser;
@@ -63,6 +63,7 @@ import com.android.launcher3.util.Partner;
 import com.android.launcher3.util.SafeCloseable;
 import com.android.launcher3.util.WindowBounds;
 import com.android.launcher3.util.window.WindowManagerProxy;
+
 import org.xmlpull.v1.XmlPullParser;
 import org.xmlpull.v1.XmlPullParserException;
 
@@ -73,6 +74,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
 import app.lawnchair.DeviceProfileOverrides;
@@ -84,11 +86,6 @@ public class InvariantDeviceProfile implements SafeCloseable {
         public static final MainThreadInitializedObject<InvariantDeviceProfile> INSTANCE =
                 new MainThreadInitializedObject<>(InvariantDeviceProfile::new);
 
-        @Override
-        public void close() {
-
-        }
-
         @Retention(RetentionPolicy.SOURCE)
         @IntDef({TYPE_PHONE, TYPE_MULTI_DISPLAY, TYPE_TABLET})
         public @interface DeviceType {}
@@ -109,18 +106,16 @@ public class InvariantDeviceProfile implements SafeCloseable {
 
         // Used for arrays to specify different sizes (e.g. border spaces, width/height) in different
         // constraints
-        static final int COUNT_SIZES = 4;
+        public static final int COUNT_SIZES = 4;
         public static final int INDEX_DEFAULT = 0;
         public static final int INDEX_LANDSCAPE = 1;
         public static final int INDEX_TWO_PANEL_PORTRAIT = 2;
         public static final int INDEX_TWO_PANEL_LANDSCAPE = 3;
 
-        /** These resources are used to override the device profile  */
-        public static final String RES_GRID_NUM_ROWS = "grid_num_rows";
-        public static final String RES_GRID_NUM_COLUMNS = "grid_num_columns";
-        public static final String RES_GRID_ICON_SIZE_DP = "grid_icon_size_dp";
-
-        private static final String KEY_IDP_GRID_NAME = "idp_grid_name";
+        /** These resources are used to override the device profile */
+        private static final String RES_GRID_NUM_ROWS = "grid_num_rows";
+        private static final String RES_GRID_NUM_COLUMNS = "grid_num_columns";
+        private static final String RES_GRID_ICON_SIZE_DP = "grid_icon_size_dp";
 
         /**
          * Number of icons per row and column in the workspace.
@@ -129,16 +124,11 @@ public class InvariantDeviceProfile implements SafeCloseable {
         public int numColumns;
         public int numSearchContainerColumns;
 
-        /**
-         * Original profile before preference overrides
-         */
-        public GridOption closestProfile;
-
         /**
          * Number of icons per row and column in the folder.
          */
-        public int numFolderRows;
-        public int numFolderColumns;
+        public int[] numFolderRows;
+        public int[] numFolderColumns;
         public float[] iconSize;
         public float[] iconTextSize;
         public int iconBitmapSize;
@@ -165,6 +155,11 @@ public class InvariantDeviceProfile implements SafeCloseable {
 
         public boolean[] startAlignTaskbar;
 
+        /**
+         * Original profile before preference overrides
+         */
+        public GridOption closestProfile;
+
         /**
          * Number of icons inside the hotseat area.
          */
@@ -177,7 +172,6 @@ public class InvariantDeviceProfile implements SafeCloseable {
          */
         public int numDatabaseHotseatIcons;
 
-        public int[] hotseatColumnSpan;
         public float[] hotseatBarBottomSpace;
         public float[] hotseatQsbSpace;
 
@@ -185,6 +179,7 @@ public class InvariantDeviceProfile implements SafeCloseable {
          * Number of columns in the all apps list.
          */
         public int numAllAppsColumns;
+        public int numAllAppsRowsForCellHeightCalculation;
         public int numDatabaseAllAppsColumns;
         public @StyleRes int allAppsStyle;
 
@@ -194,16 +189,10 @@ public class InvariantDeviceProfile implements SafeCloseable {
         protected boolean isScalable;
         @XmlRes
         public int devicePaddingId = INVALID_RESOURCE_HANDLE;
-
-        public String dbFile;
-        public int defaultLayoutId;
-
         @XmlRes
         public int workspaceSpecsId = INVALID_RESOURCE_HANDLE;
-
         @XmlRes
         public int workspaceSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
-
         @XmlRes
         public int allAppsSpecsId = INVALID_RESOURCE_HANDLE;
         @XmlRes
@@ -216,7 +205,6 @@ public class InvariantDeviceProfile implements SafeCloseable {
         public int hotseatSpecsId = INVALID_RESOURCE_HANDLE;
         @XmlRes
         public int hotseatSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
-
         @XmlRes
         public int workspaceCellSpecsId = INVALID_RESOURCE_HANDLE;
         @XmlRes
@@ -225,6 +213,9 @@ public class InvariantDeviceProfile implements SafeCloseable {
         public int allAppsCellSpecsId = INVALID_RESOURCE_HANDLE;
         @XmlRes
         public int allAppsCellSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
+
+        public String dbFile;
+        public int defaultLayoutId;
         public int demoModeLayoutId;
         public boolean[] inlineQsb = new boolean[COUNT_SIZES];
 
@@ -234,7 +225,6 @@ public class InvariantDeviceProfile implements SafeCloseable {
         public List<DeviceProfile> supportedProfiles = Collections.EMPTY_LIST;
 
         public Point defaultWallpaperSize;
-        public Rect defaultWidgetPadding;
 
         private final ArrayList<OnIDPChangeListener> mChangeListeners = new ArrayList<>();
 
@@ -246,16 +236,16 @@ public class InvariantDeviceProfile implements SafeCloseable {
                 String gridName = getCurrentGridName(context);
                 String newGridName = initGrid(context, gridName);
                 if (!newGridName.equals(gridName)) {
-                        Utilities.getPrefs(context).edit().putString(KEY_IDP_GRID_NAME, newGridName).apply();
+                        LauncherPrefs.get(context).put(GRID_NAME, newGridName);
                 }
-                LockedUserState.get(context).runOnUserUnlocked(() -> {
-                        new DeviceGridState(this).writeToPrefs(context);
-                });
+                LockedUserState.get(context).runOnUserUnlocked(() ->
+                        new DeviceGridState(this).writeToPrefs(context));
 
                 DisplayController.INSTANCE.get(context).setPriorityListener(
                         (displayContext, info, flags) -> {
                                 if ((flags & (CHANGE_DENSITY | CHANGE_SUPPORTED_BOUNDS
-                                        | CHANGE_NAVIGATION_MODE)) != 0) {
+                                        | CHANGE_NAVIGATION_MODE | CHANGE_TASKBAR_PINNING
+                                        | CHANGE_DESKTOP_MODE)) != 0) {
                                         onConfigChanged(displayContext);
                                 }
                         });
@@ -265,7 +255,10 @@ public class InvariantDeviceProfile implements SafeCloseable {
          * This constructor should NOT have any monitors by design.
          */
         public InvariantDeviceProfile(Context context, String gridName) {
-                this(context, DeviceProfileOverrides.INSTANCE.get(context).getGridInfo(gridName));
+                String newName = initGrid(context, gridName);
+                if (newName == null || !newName.equals(gridName)) {
+                        throw new IllegalArgumentException("Unknown grid name: " + gridName);
+                }
         }
 
         public InvariantDeviceProfile(Context context, DeviceProfileOverrides.DBGridInfo dbGridInfo) {
@@ -273,6 +266,19 @@ public class InvariantDeviceProfile implements SafeCloseable {
                 initGrid(context, gridName, dbGridInfo);
         }
 
+        private String initGrid(Context context, String gridName, DeviceProfileOverrides.DBGridInfo dbGridInfo) {
+                Info displayInfo = DisplayController.INSTANCE.get(context).getInfo();
+                @DeviceType int deviceType = displayInfo.getDeviceType();
+
+                ArrayList<DisplayOption> allOptions =
+                        getPredefinedDeviceProfiles(context, gridName, deviceType,
+                                RestoreDbTask.isPending(context));
+                DisplayOption displayOption =
+                        invDistWeightedInterpolate(displayInfo, allOptions, deviceType);
+                initGrid(context, displayInfo, displayOption, deviceType, dbGridInfo);
+                return displayOption.grid.name;
+        }
+
         /**
          * This constructor should NOT have any monitors by design.
          */
@@ -283,7 +289,7 @@ public class InvariantDeviceProfile implements SafeCloseable {
 
                 // Get the display info based on default display and interpolate it to existing display
                 Info defaultInfo = DisplayController.INSTANCE.get(context).getInfo();
-                @DeviceType int defaultDeviceType = getDeviceType(defaultInfo);
+                @DeviceType int defaultDeviceType = defaultInfo.getDeviceType();
                 DisplayOption defaultDisplayOption = invDistWeightedInterpolate(
                         defaultInfo,
                         getPredefinedDeviceProfiles(context, gridName, defaultDeviceType,
@@ -292,7 +298,7 @@ public class InvariantDeviceProfile implements SafeCloseable {
 
                 Context displayContext = context.createDisplayContext(display);
                 Info myInfo = new Info(displayContext);
-                @DeviceType int deviceType = getDeviceType(myInfo);
+                @DeviceType int deviceType = myInfo.getDeviceType();
                 DisplayOption myDisplayOption = invDistWeightedInterpolate(
                         myInfo,
                         getPredefinedDeviceProfiles(context, gridName, deviceType,
@@ -316,6 +322,18 @@ public class InvariantDeviceProfile implements SafeCloseable {
                 initGrid(context, myInfo, result, deviceType);
         }
 
+        private void initGrid(Context context, Info displayInfo, DisplayOption displayOption,
+                              @DeviceType int deviceType) {
+                DeviceProfileOverrides.DBGridInfo dbGridInfo = DeviceProfileOverrides.INSTANCE.get(context)
+                        .getGridInfo();
+                initGrid(context, displayInfo, displayOption, deviceType, dbGridInfo);
+        }
+
+        @Override
+        public void close() {
+                DisplayController.INSTANCE.executeIfCreated(dc -> dc.setPriorityListener(null));
+        }
+
         /**
          * Reinitialize the current grid after a restore, where some grids might now be disabled.
          */
@@ -324,8 +342,13 @@ public class InvariantDeviceProfile implements SafeCloseable {
                 String currentDbFile = dbFile;
                 String newGridName = initGrid(context, currentGridName);
                 String newDbFile = dbFile;
+                FileLog.d(TAG, "Reinitializing grid after restore."
+                        + " currentGridName=" + currentGridName
+                        + ", currentDbFile=" + currentDbFile
+                        + ", newGridName=" + newGridName
+                        + ", newDbFile=" + newDbFile);
                 if (!newDbFile.equals(currentDbFile)) {
-                        Log.d(TAG, "Restored grid is disabled : " + currentGridName
+                        FileLog.d(TAG, "Restored grid is disabled : " + currentGridName
                                 + ", migrating to: " + newGridName
                                 + ", removing all other grid db files");
                         for (String gridDbFile : LauncherFiles.GRID_DB_FILES) {
@@ -333,58 +356,37 @@ public class InvariantDeviceProfile implements SafeCloseable {
                                         continue;
                                 }
                                 if (context.getDatabasePath(gridDbFile).delete()) {
-                                        Log.d(TAG, "Removed old grid db file: " + gridDbFile);
+                                        FileLog.d(TAG, "Removed old grid db file: " + gridDbFile);
                                 }
                         }
                         setCurrentGrid(context, newGridName);
                 }
         }
 
-        public static @DeviceType int getDeviceType(Info displayInfo) {
-                int flagPhone = 1 << 0;
-                int flagTablet = 1 << 1;
-
-                int type = displayInfo.supportedBounds.stream()
-                        .mapToInt(bounds -> displayInfo.isTablet(bounds) ? flagTablet : flagPhone)
-                        .reduce(0, (a, b) -> a | b);
-                if ((type == (flagPhone | flagTablet))) {
-                        // device has profiles supporting both phone and table modes
-                        return TYPE_MULTI_DISPLAY;
-                } else if (type == flagTablet) {
-                        return TYPE_TABLET;
-                } else {
-                        return TYPE_PHONE;
-                }
-        }
-
         public static String getCurrentGridName(Context context) {
-                return DeviceProfileOverrides.INSTANCE.get(context).getCurrentGridName();
+                return LauncherPrefs.get(context).get(GRID_NAME);
         }
 
-        private String initGrid(Context context, String gridName, DeviceProfileOverrides.DBGridInfo dbGridInfo) {
+        private String initGrid(Context context, String gridName) {
                 Info displayInfo = DisplayController.INSTANCE.get(context).getInfo();
-                @DeviceType int deviceType = getDeviceType(displayInfo);
+                @DeviceType int deviceType = displayInfo.getDeviceType();
 
                 ArrayList<DisplayOption> allOptions =
                         getPredefinedDeviceProfiles(context, gridName, deviceType,
                                 RestoreDbTask.isPending(context));
                 DisplayOption displayOption =
                         invDistWeightedInterpolate(displayInfo, allOptions, deviceType);
-                initGrid(context, displayInfo, displayOption, deviceType, dbGridInfo);
+                initGrid(context, displayInfo, displayOption, deviceType);
                 return displayOption.grid.name;
         }
 
-        private void initGrid(Context context, Info displayInfo, DisplayOption displayOption,
-                              @DeviceType int deviceType) {
-                DeviceProfileOverrides.DBGridInfo dbGridInfo = DeviceProfileOverrides.INSTANCE.get(context)
-                        .getGridInfo();
-                initGrid(context, displayInfo, displayOption, deviceType, dbGridInfo);
-        }
-
-        private String initGrid(Context context, String gridName) {
-                DeviceProfileOverrides.DBGridInfo dbGridInfo = DeviceProfileOverrides.INSTANCE.get(context)
-                        .getGridInfo();
-                return initGrid(context, gridName, dbGridInfo);
+        /**
+         * @deprecated This is a temporary solution because on the backup and restore case we modify the
+         * IDP, this resets it. b/332974074
+         */
+        @Deprecated
+        public void reset(Context context) {
+                initGrid(context, getCurrentGridName(context));
         }
 
         @VisibleForTesting
@@ -398,10 +400,10 @@ public class InvariantDeviceProfile implements SafeCloseable {
                         .getOverrides(displayOption.grid);
                 DisplayMetrics metrics = context.getResources().getDisplayMetrics();
                 closestProfile = displayOption.grid;
-                numRows = dbGridInfo.getNumRows();
-                numColumns = dbGridInfo.getNumColumns();
+                numRows = closestProfile.numRows;
+                numColumns = closestProfile.numColumns;
                 numSearchContainerColumns = closestProfile.numSearchContainerColumns;
-                dbFile = dbGridInfo.getDbFile();
+                dbFile = closestProfile.dbFile;
                 defaultLayoutId = closestProfile.defaultLayoutId;
                 demoModeLayoutId = closestProfile.demoModeLayoutId;
 
@@ -425,7 +427,8 @@ public class InvariantDeviceProfile implements SafeCloseable {
                 workspaceCellSpecsTwoPanelId = closestProfile.mWorkspaceCellSpecsTwoPanelId;
                 allAppsCellSpecsId = closestProfile.mAllAppsCellSpecsId;
                 allAppsCellSpecsTwoPanelId = closestProfile.mAllAppsCellSpecsTwoPanelId;
-
+                numAllAppsRowsForCellHeightCalculation =
+                        closestProfile.mNumAllAppsRowsForCellHeightCalculation;
                 this.deviceType = deviceType;
 
                 inlineNavButtonsEndSpacing = closestProfile.inlineNavButtonsEndSpacing;
@@ -446,17 +449,16 @@ public class InvariantDeviceProfile implements SafeCloseable {
 
                 horizontalMargin = displayOption.horizontalMargin;
 
-                numShownHotseatIcons = deviceType == TYPE_MULTI_DISPLAY
-                        ? closestProfile.numHotseatIcons : dbGridInfo.getNumHotseatColumns();
+                numShownHotseatIcons = closestProfile.numHotseatIcons;
                 numDatabaseHotseatIcons = deviceType == TYPE_MULTI_DISPLAY
-                        ? closestProfile.numDatabaseHotseatIcons : numShownHotseatIcons;
-                hotseatColumnSpan = closestProfile.hotseatColumnSpan;
+                        ? closestProfile.numDatabaseHotseatIcons : closestProfile.numHotseatIcons;
                 hotseatBarBottomSpace = displayOption.hotseatBarBottomSpace;
                 hotseatQsbSpace = displayOption.hotseatQsbSpace;
 
                 allAppsStyle = closestProfile.allAppsStyle;
 
                 numAllAppsColumns = closestProfile.numAllAppsColumns;
+
                 numDatabaseAllAppsColumns = deviceType == TYPE_MULTI_DISPLAY
                         ? closestProfile.numDatabaseAllAppsColumns : closestProfile.numAllAppsColumns;
 
@@ -535,9 +537,8 @@ public class InvariantDeviceProfile implements SafeCloseable {
         }
 
         public void setCurrentGrid(Context context, String gridName) {
-                DeviceProfileOverrides.INSTANCE.get(context).setCurrentGrid(gridName);
-                Context appContext = context.getApplicationContext();
-                MAIN_EXECUTOR.execute(() -> onConfigChanged(appContext));
+                LauncherPrefs.get(context).put(GRID_NAME, gridName);
+                MAIN_EXECUTOR.execute(() -> onConfigChanged(context.getApplicationContext()));
         }
 
         private Object[] toModelState() {
@@ -546,7 +547,9 @@ public class InvariantDeviceProfile implements SafeCloseable {
                         iconBitmapSize, fillResIconDpi, numDatabaseAllAppsColumns, dbFile};
         }
 
-        private void onConfigChanged(Context context) {
+        /** Updates IDP using the provided context. Notifies listeners of change. */
+        @VisibleForTesting
+        public void onConfigChanged(Context context) {
                 Object[] oldState = toModelState();
 
                 // Re-init grid
@@ -613,6 +616,45 @@ public class InvariantDeviceProfile implements SafeCloseable {
                 return filteredProfiles;
         }
 
+        /**
+         * Returns the GridOption associated to the given file name or null if the fileName is not
+         * supported.
+         * Ej, launcher.db -> "normal grid", launcher_4_by_4.db -> "practical grid"
+         */
+        public GridOption getGridOptionFromFileName(Context context, String fileName) {
+                return parseAllGridOptions(context).stream()
+                        .filter(gridOption -> Objects.equals(gridOption.dbFile, fileName))
+                        .findFirst()
+                        .orElse(null);
+        }
+
+        /**
+         * Returns the name of the given size on the current device or empty string if the size is not
+         * supported. Ej. 4x4 -> normal, 5x4 -> practical, etc.
+         * (Note: the name of the grid can be different for the same grid size depending of
+         * the values of the InvariantDeviceProfile)
+         *
+         */
+        public String getGridNameFromSize(Context context, Point size) {
+                return parseAllGridOptions(context).stream()
+                        .filter(gridOption -> gridOption.numColumns == size.x
+                                && gridOption.numRows == size.y)
+                        .map(gridOption -> gridOption.name)
+                        .findFirst()
+                        .orElse("");
+        }
+
+        /**
+         * Returns the grid option for the given gridName on the current device (Note: the gridOption
+         * be different for the same gridName depending on the values of the InvariantDeviceProfile).
+         */
+        public GridOption getGridOptionFromName(Context context, String gridName) {
+                return parseAllGridOptions(context).stream()
+                        .filter(gridOption -> Objects.equals(gridOption.name, gridName))
+                        .findFirst()
+                        .orElse(null);
+        }
+
         /**
          * @return all the grid options that can be shown on the device
          */
@@ -758,14 +800,11 @@ public class InvariantDeviceProfile implements SafeCloseable {
         }
 
         public DeviceProfile getDeviceProfile(Context context) {
-                Resources res = context.getResources();
-                Configuration config = context.getResources().getConfiguration();
+                WindowManagerProxy windowManagerProxy = WindowManagerProxy.INSTANCE.get(context);
+                Rect bounds = windowManagerProxy.getCurrentBounds(context);
+                int rotation = windowManagerProxy.getRotation(context);
 
-                float screenWidth = config.screenWidthDp * res.getDisplayMetrics().density;
-                float screenHeight = config.screenHeightDp * res.getDisplayMetrics().density;
-                int rotation = WindowManagerProxy.INSTANCE.get(context).getRotation(context);
-
-                return getBestMatch(screenWidth, screenHeight, rotation);
+                return getBestMatch(bounds.width(), bounds.height(), rotation);
         }
 
         /**
@@ -857,28 +896,29 @@ public class InvariantDeviceProfile implements SafeCloseable {
                 public final int numSearchContainerColumns;
                 public final int deviceCategory;
 
-                public final int numFolderRows;
-                public final int numFolderColumns;
+                public final int[] numFolderRows = new int[COUNT_SIZES];
+                public final int[] numFolderColumns = new int[COUNT_SIZES];
                 private final @StyleRes int folderStyle;
                 private final @StyleRes int cellStyle;
 
                 private final @StyleRes int allAppsStyle;
                 public final int numAllAppsColumns;
-                public final int numDatabaseAllAppsColumns;
+                private final int mNumAllAppsRowsForCellHeightCalculation;
+                private final int numDatabaseAllAppsColumns;
                 public final int numHotseatIcons;
-                public final int numDatabaseHotseatIcons;
-
-                private final int[] hotseatColumnSpan = new int[COUNT_SIZES];
+                private final int numDatabaseHotseatIcons;
 
                 private final boolean[] inlineQsb = new boolean[COUNT_SIZES];
 
                 private @DimenRes int inlineNavButtonsEndSpacing;
-                public final String dbFile;
+                private final String dbFile;
 
                 private final int defaultLayoutId;
                 private final int demoModeLayoutId;
-                private final int mWorkspaceSpecsId;
 
+                private final boolean isScalable;
+                private final int devicePaddingId;
+                private final int mWorkspaceSpecsId;
                 private final int mWorkspaceSpecsTwoPanelId;
                 private final int mAllAppsSpecsId;
                 private final int mAllAppsSpecsTwoPanelId;
@@ -891,15 +931,12 @@ public class InvariantDeviceProfile implements SafeCloseable {
                 private final int mAllAppsCellSpecsId;
                 private final int mAllAppsCellSpecsTwoPanelId;
 
-                private final boolean isScalable;
-                private final int devicePaddingId;
-
                 public GridOption(Context context, AttributeSet attrs) {
                         TypedArray a = context.obtainStyledAttributes(
                                 attrs, R.styleable.GridDisplayOption);
                         name = a.getString(R.styleable.GridDisplayOption_name);
                         numRows = a.getInt(R.styleable.GridDisplayOption_numRows, 0);
-                        numColumns = a.getInt(R.styleable.GridDisplayOption_numColumns, 4);
+                        numColumns = a.getInt(R.styleable.GridDisplayOption_numColumns, 0);
                         numSearchContainerColumns = a.getInt(
                                 R.styleable.GridDisplayOption_numSearchContainerColumns, numColumns);
 
@@ -914,33 +951,50 @@ public class InvariantDeviceProfile implements SafeCloseable {
                         numAllAppsColumns = a.getInt(
                                 R.styleable.GridDisplayOption_numAllAppsColumns, numColumns);
                         numDatabaseAllAppsColumns = a.getInt(
-                                R.styleable.GridDisplayOption_numExtendedAllAppsColumns, numAllAppsColumns);
+                                R.styleable.GridDisplayOption_numExtendedAllAppsColumns, 2 * numAllAppsColumns);
 
                         numHotseatIcons = a.getInt(
                                 R.styleable.GridDisplayOption_numHotseatIcons, numColumns);
                         numDatabaseHotseatIcons = a.getInt(
                                 R.styleable.GridDisplayOption_numExtendedHotseatIcons, 2 * numHotseatIcons);
 
-                        hotseatColumnSpan[INDEX_DEFAULT] = a.getInt(
-                                R.styleable.GridDisplayOption_hotseatColumnSpan, numColumns);
-                        hotseatColumnSpan[INDEX_LANDSCAPE] = a.getInt(
-                                R.styleable.GridDisplayOption_hotseatColumnSpanLandscape, numColumns);
-                        hotseatColumnSpan[INDEX_TWO_PANEL_LANDSCAPE] = a.getInt(
-                                R.styleable.GridDisplayOption_hotseatColumnSpanTwoPanelLandscape,
-                                numColumns);
-                        hotseatColumnSpan[INDEX_TWO_PANEL_PORTRAIT] = a.getInt(
-                                R.styleable.GridDisplayOption_hotseatColumnSpanTwoPanelPortrait,
-                                numColumns);
-
                         inlineNavButtonsEndSpacing =
                                 a.getResourceId(R.styleable.GridDisplayOption_inlineNavButtonsEndSpacing,
                                         R.dimen.taskbar_button_margin_default);
 
-                        numFolderRows = a.getInt(
+                        numFolderRows[INDEX_DEFAULT] = a.getInt(
                                 R.styleable.GridDisplayOption_numFolderRows, numRows);
-                        numFolderColumns = a.getInt(
+                        numFolderColumns[INDEX_DEFAULT] = a.getInt(
                                 R.styleable.GridDisplayOption_numFolderColumns, numColumns);
 
+                        if (FeatureFlags.enableResponsiveWorkspace()) {
+                                numFolderRows[INDEX_LANDSCAPE] = a.getInt(
+                                        R.styleable.GridDisplayOption_numFolderRowsLandscape,
+                                        numFolderRows[INDEX_DEFAULT]);
+                                numFolderColumns[INDEX_LANDSCAPE] = a.getInt(
+                                        R.styleable.GridDisplayOption_numFolderColumnsLandscape,
+                                        numFolderColumns[INDEX_DEFAULT]);
+                                numFolderRows[INDEX_TWO_PANEL_PORTRAIT] = a.getInt(
+                                        R.styleable.GridDisplayOption_numFolderRowsTwoPanelPortrait,
+                                        numFolderRows[INDEX_DEFAULT]);
+                                numFolderColumns[INDEX_TWO_PANEL_PORTRAIT] = a.getInt(
+                                        R.styleable.GridDisplayOption_numFolderColumnsTwoPanelPortrait,
+                                        numFolderColumns[INDEX_DEFAULT]);
+                                numFolderRows[INDEX_TWO_PANEL_LANDSCAPE] = a.getInt(
+                                        R.styleable.GridDisplayOption_numFolderRowsTwoPanelLandscape,
+                                        numFolderRows[INDEX_DEFAULT]);
+                                numFolderColumns[INDEX_TWO_PANEL_LANDSCAPE] = a.getInt(
+                                        R.styleable.GridDisplayOption_numFolderColumnsTwoPanelLandscape,
+                                        numFolderColumns[INDEX_DEFAULT]);
+                        } else {
+                                numFolderRows[INDEX_LANDSCAPE] = numFolderRows[INDEX_DEFAULT];
+                                numFolderColumns[INDEX_LANDSCAPE] = numFolderColumns[INDEX_DEFAULT];
+                                numFolderRows[INDEX_TWO_PANEL_PORTRAIT] = numFolderRows[INDEX_DEFAULT];
+                                numFolderColumns[INDEX_TWO_PANEL_PORTRAIT] = numFolderColumns[INDEX_DEFAULT];
+                                numFolderRows[INDEX_TWO_PANEL_LANDSCAPE] = numFolderRows[INDEX_DEFAULT];
+                                numFolderColumns[INDEX_TWO_PANEL_LANDSCAPE] = numFolderColumns[INDEX_DEFAULT];
+                        }
+
                         folderStyle = a.getResourceId(R.styleable.GridDisplayOption_folderStyle,
                                 INVALID_RESOURCE_HANDLE);
 
@@ -954,39 +1008,42 @@ public class InvariantDeviceProfile implements SafeCloseable {
                         deviceCategory = a.getInt(R.styleable.GridDisplayOption_deviceCategory,
                                 DEVICE_CATEGORY_ALL);
 
-                        if (FeatureFlags.ENABLE_RESPONSIVE_WORKSPACE.get()) {
+                        if (FeatureFlags.enableResponsiveWorkspace()) {
                                 mWorkspaceSpecsId = a.getResourceId(
                                         R.styleable.GridDisplayOption_workspaceSpecsId, INVALID_RESOURCE_HANDLE);
                                 mWorkspaceSpecsTwoPanelId = a.getResourceId(
                                         R.styleable.GridDisplayOption_workspaceSpecsTwoPanelId,
-                                        INVALID_RESOURCE_HANDLE);
+                                        mWorkspaceSpecsId);
                                 mAllAppsSpecsId = a.getResourceId(
                                         R.styleable.GridDisplayOption_allAppsSpecsId, INVALID_RESOURCE_HANDLE);
                                 mAllAppsSpecsTwoPanelId = a.getResourceId(
                                         R.styleable.GridDisplayOption_allAppsSpecsTwoPanelId,
-                                        INVALID_RESOURCE_HANDLE);
+                                        mAllAppsSpecsId);
                                 mFolderSpecsId = a.getResourceId(
                                         R.styleable.GridDisplayOption_folderSpecsId, INVALID_RESOURCE_HANDLE);
                                 mFolderSpecsTwoPanelId = a.getResourceId(
                                         R.styleable.GridDisplayOption_folderSpecsTwoPanelId,
-                                        INVALID_RESOURCE_HANDLE);
+                                        mFolderSpecsId);
                                 mHotseatSpecsId = a.getResourceId(
                                         R.styleable.GridDisplayOption_hotseatSpecsId, INVALID_RESOURCE_HANDLE);
                                 mHotseatSpecsTwoPanelId = a.getResourceId(
                                         R.styleable.GridDisplayOption_hotseatSpecsTwoPanelId,
-                                        INVALID_RESOURCE_HANDLE);
+                                        mHotseatSpecsId);
                                 mWorkspaceCellSpecsId = a.getResourceId(
                                         R.styleable.GridDisplayOption_workspaceCellSpecsId,
                                         INVALID_RESOURCE_HANDLE);
                                 mWorkspaceCellSpecsTwoPanelId = a.getResourceId(
                                         R.styleable.GridDisplayOption_workspaceCellSpecsTwoPanelId,
-                                        INVALID_RESOURCE_HANDLE);
+                                        mWorkspaceCellSpecsId);
                                 mAllAppsCellSpecsId = a.getResourceId(
                                         R.styleable.GridDisplayOption_allAppsCellSpecsId,
                                         INVALID_RESOURCE_HANDLE);
                                 mAllAppsCellSpecsTwoPanelId = a.getResourceId(
                                         R.styleable.GridDisplayOption_allAppsCellSpecsTwoPanelId,
-                                        INVALID_RESOURCE_HANDLE);
+                                        mAllAppsCellSpecsId);
+                                mNumAllAppsRowsForCellHeightCalculation = a.getInt(
+                                        R.styleable.GridDisplayOption_numAllAppsRowsForCellHeightCalculation,
+                                        numRows);
                         } else {
                                 mWorkspaceSpecsId = INVALID_RESOURCE_HANDLE;
                                 mWorkspaceSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
@@ -1000,6 +1057,7 @@ public class InvariantDeviceProfile implements SafeCloseable {
                                 mWorkspaceCellSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
                                 mAllAppsCellSpecsId = INVALID_RESOURCE_HANDLE;
                                 mAllAppsCellSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
+                                mNumAllAppsRowsForCellHeightCalculation = numRows;
                         }
 
                         int inlineForRotation = a.getInt(R.styleable.GridDisplayOption_inlineQsb,
@@ -1014,6 +1072,7 @@ public class InvariantDeviceProfile implements SafeCloseable {
                         inlineQsb[INDEX_TWO_PANEL_LANDSCAPE] =
                                 (inlineForRotation & INLINE_QSB_FOR_TWO_PANEL_LANDSCAPE)
                                         == INLINE_QSB_FOR_TWO_PANEL_LANDSCAPE;
+
                         a.recycle();
                 }
 
@@ -1376,4 +1435,4 @@ public class InvariantDeviceProfile implements SafeCloseable {
                         return this;
                 }
         }
-}
\ No newline at end of file
+}
diff --git a/src/com/android/launcher3/Launcher.java b/src/com/android/launcher3/Launcher.java
index e1ea51fc4b..ad456a3f63 100644
--- a/src/com/android/launcher3/Launcher.java
+++ b/src/com/android/launcher3/Launcher.java
@@ -96,7 +96,6 @@ import static com.android.launcher3.model.ItemInstallQueue.FLAG_ACTIVITY_PAUSED;
 import static com.android.launcher3.model.ItemInstallQueue.FLAG_DRAG_AND_DROP;
 import static com.android.launcher3.popup.SystemShortcut.APP_INFO;
 import static com.android.launcher3.popup.SystemShortcut.INSTALL;
-import static com.android.launcher3.popup.SystemShortcut.UNINSTALL;
 import static com.android.launcher3.popup.SystemShortcut.WIDGETS;
 import static com.android.launcher3.states.RotationHelper.REQUEST_LOCK;
 import static com.android.launcher3.states.RotationHelper.REQUEST_NONE;
@@ -108,6 +107,7 @@ import static com.android.launcher3.util.SettingsCache.TOUCHPAD_NATURAL_SCROLLIN
 import android.animation.Animator;
 import android.animation.AnimatorSet;
 import android.animation.ValueAnimator;
+import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.app.Notification;
 import android.app.NotificationChannel;
@@ -168,7 +168,7 @@ import androidx.annotation.StringRes;
 import androidx.annotation.UiThread;
 import androidx.annotation.VisibleForTesting;
 import androidx.core.os.BuildCompat;
-import androidx.window.embedding.RuleController;
+//import androidx.window.embedding.RuleController;
 
 import com.android.launcher3.DeviceProfile;
 import com.android.launcher3.DropTarget.DragObject;
@@ -604,11 +604,11 @@ public class Launcher extends StatefulActivity<LauncherState>
         setTitle(R.string.home_screen);
         mStartupLatencyLogger.logEnd(LAUNCHER_LATENCY_STARTUP_ACTIVITY_ON_CREATE);
 
-        if (BuildCompat.isAtLeastV()
-                && com.android.launcher3.Flags.enableTwoPaneLauncherSettings()) {
-            RuleController.getInstance(this).setRules(
-                    RuleController.parseRules(this, R.xml.split_configuration));
-        }
+//        if (BuildCompat.isAtLeastV()
+//                && com.android.launcher3.Flags.enableTwoPaneLauncherSettings()) {
+//            RuleController.getInstance(this).setRules(
+//                    RuleController.parseRules(this, R.xml.split_configuration));
+//        }
     }
 
     protected ModelCallbacks createModelCallbacks() {
@@ -679,7 +679,7 @@ public class Launcher extends StatefulActivity<LauncherState>
         // #4 state handler
         return new OnBackPressedHandler() {
             @Override
-            public void onBackStarted(BackEvent backEvent) {
+            public void onBackStarted() {
                 Launcher.this.onBackStarted();
             }
 
@@ -1146,22 +1146,24 @@ public class Launcher extends StatefulActivity<LauncherState>
         mAppWidgetHolder.setActivityResumed(true);
 
         // Listen for IME changes to keep state up to date.
-        getRootView().setWindowInsetsAnimationCallback(
-                new WindowInsetsAnimation.Callback(DISPATCH_MODE_CONTINUE_ON_SUBTREE) {
-                    @Override
-                    public WindowInsets onProgress(WindowInsets windowInsets,
-                            List<WindowInsetsAnimation> windowInsetsAnimations) {
-                        return windowInsets;
-                    }
+        if (Utilities.ATLEAST_T) {
+            getRootView().setWindowInsetsAnimationCallback(
+                    new WindowInsetsAnimation.Callback(DISPATCH_MODE_CONTINUE_ON_SUBTREE) {
+                        @Override
+                        public WindowInsets onProgress(WindowInsets windowInsets,
+                                                       List<WindowInsetsAnimation> windowInsetsAnimations) {
+                            return windowInsets;
+                        }
 
-                    @Override
-                    public void onEnd(WindowInsetsAnimation animation) {
-                        WindowInsets insets = getRootView().getRootWindowInsets();
-                        boolean isImeVisible = insets != null && insets.isVisible(WindowInsets.Type.ime());
-                        getStatsLogManager().keyboardStateManager().setKeyboardState(
-                                isImeVisible ? SHOW : HIDE);
-                    }
-                });
+                        @Override
+                        public void onEnd(WindowInsetsAnimation animation) {
+                            WindowInsets insets = getRootView().getRootWindowInsets();
+                            boolean isImeVisible = insets != null && insets.isVisible(WindowInsets.Type.ime());
+                            getStatsLogManager().keyboardStateManager().setKeyboardState(
+                                    isImeVisible ? SHOW : HIDE);
+                        }
+                    });
+        }
     }
 
     private void logStopAndResume(boolean isResume) {
diff --git a/src/com/android/launcher3/LauncherPrefs.kt b/src/com/android/launcher3/LauncherPrefs.kt
index 13181e87f2..dbba548dfc 100644
--- a/src/com/android/launcher3/LauncherPrefs.kt
+++ b/src/com/android/launcher3/LauncherPrefs.kt
@@ -20,7 +20,7 @@ import android.content.Context.MODE_PRIVATE
 import android.content.SharedPreferences
 import android.content.SharedPreferences.OnSharedPreferenceChangeListener
 import androidx.annotation.VisibleForTesting
-import com.android.launcher3.BuildConfig.WIDGET_ON_FIRST_SCREEN
+import com.android.launcher3.BuildConfigs.WIDGET_ON_FIRST_SCREEN
 import com.android.launcher3.LauncherFiles.DEVICE_PREFERENCES_KEY
 import com.android.launcher3.LauncherFiles.SHARED_PREFERENCES_KEY
 import com.android.launcher3.model.DeviceGridState
diff --git a/src/com/android/launcher3/LauncherRootView.java b/src/com/android/launcher3/LauncherRootView.java
index a2931809d7..e20ed2af19 100644
--- a/src/com/android/launcher3/LauncherRootView.java
+++ b/src/com/android/launcher3/LauncherRootView.java
@@ -65,7 +65,7 @@ public class LauncherRootView extends InsettableFrameLayout {
         insets = WindowManagerProxy.INSTANCE.get(getContext())
                 .normalizeWindowInsets(getContext(), insets, mTempRect);
         handleSystemWindowInsets(mTempRect);
-        computeGestureExclusionRect();
+//        computeGestureExclusionRect();
         return insets;
     }
 
@@ -114,7 +114,7 @@ public class LauncherRootView extends InsettableFrameLayout {
     @Override
     protected void onLayout(boolean changed, int l, int t, int r, int b) {
         super.onLayout(changed, l, t, r, b);
-        computeGestureExclusionRect();
+//        computeGestureExclusionRect();
         mSysUiScrim.setSize(r - l, b - t);
     }
 
diff --git a/src/com/android/launcher3/LauncherState.java b/src/com/android/launcher3/LauncherState.java
index e96320d387..a3f4d350c3 100644
--- a/src/com/android/launcher3/LauncherState.java
+++ b/src/com/android/launcher3/LauncherState.java
@@ -465,6 +465,14 @@ public abstract class LauncherState implements BaseState<LauncherState> {
         // Do nothing. To be overridden by child class.
     }
 
+    public void onBackPressed(Launcher launcher) {
+        if (this != NORMAL) {
+            StateManager<LauncherState, Launcher> lsm = launcher.getStateManager();
+            LauncherState lastState = lsm.getLastState();
+            lsm.goToState(lastState);
+        }
+    }
+
     /**
      * Find {@link StateManager} and target {@link LauncherState} to handle back progress in
      * predictive back gesture.
diff --git a/src/com/android/launcher3/ModelCallbacks.kt b/src/com/android/launcher3/ModelCallbacks.kt
index 13062b6b1b..e22369cfb7 100644
--- a/src/com/android/launcher3/ModelCallbacks.kt
+++ b/src/com/android/launcher3/ModelCallbacks.kt
@@ -38,7 +38,7 @@ class ModelCallbacks(private var launcher: Launcher) : BgDataModel.Callbacks {
     var pagesToBindSynchronously = LIntSet()
 
     private var isFirstPagePinnedItemEnabled =
-        (BuildConfig.QSB_ON_FIRST_SCREEN && !enableSmartspaceRemovalToggle())
+        (!enableSmartspaceRemovalToggle())
 
     var stringCache: StringCache? = null
 
diff --git a/src/com/android/launcher3/SessionCommitReceiver.java b/src/com/android/launcher3/SessionCommitReceiver.java
index 861d9a6067..3145375073 100644
--- a/src/com/android/launcher3/SessionCommitReceiver.java
+++ b/src/com/android/launcher3/SessionCommitReceiver.java
@@ -58,7 +58,7 @@ public class SessionCommitReceiver extends BroadcastReceiver {
     @WorkerThread
     private static void processIntent(Context context, Intent intent) {
         UserHandle user = intent.getParcelableExtra(Intent.EXTRA_USER);
-        if (!isEnabled(context, user)) {
+        if (!isEnabled(context)) {
             // User has decided to not add icons on homescreen.
             return;
         }
diff --git a/src/com/android/launcher3/Utilities.java b/src/com/android/launcher3/Utilities.java
index 9d6bb5f64b..26e8253d49 100644
--- a/src/com/android/launcher3/Utilities.java
+++ b/src/com/android/launcher3/Utilities.java
@@ -16,10 +16,9 @@
 
 package com.android.launcher3;
 
-import static com.android.launcher3.model.data.ItemInfoWithIcon.FLAG_ICON_BADGED;
 import static android.graphics.drawable.AdaptiveIconDrawable.getExtraInsetFraction;
 
-import static com.android.launcher3.BuildConfig.WIDGET_ON_FIRST_SCREEN;
+import static com.android.launcher3.BuildConfigs.WIDGET_ON_FIRST_SCREEN;
 import static com.android.launcher3.Flags.enableSmartspaceAsAWidget;
 import static com.android.launcher3.icons.BitmapInfo.FLAG_THEMED;
 import static com.android.launcher3.util.SplitConfigurationOptions.STAGE_POSITION_BOTTOM_OR_RIGHT;
@@ -62,6 +61,7 @@ import android.os.DeadObjectException;
 import android.os.Handler;
 import android.os.Message;
 import android.os.TransactionTooLargeException;
+import android.provider.Settings;
 import android.text.Spannable;
 import android.text.SpannableString;
 import android.text.TextUtils;
@@ -206,6 +206,50 @@ public final class Utilities {
                 Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 0) != 0;
     }
 
+    public static Drawable loadFullDrawableWithoutTheme(Context context, ItemInfo info,
+                                                        int width, int height, Object[] outObj) {
+        ActivityContext activity = ActivityContext.lookupContext(context);
+        LauncherAppState appState = LauncherAppState.getInstance(context);
+        if (info instanceof PendingAddShortcutInfo) {
+            ShortcutConfigActivityInfo activityInfo = ((PendingAddShortcutInfo) info).getActivityInfo(context);
+            outObj[0] = activityInfo;
+            return activityInfo.getFullResIcon(appState.getIconCache());
+        }
+        if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_APPLICATION) {
+            LauncherActivityInfo activityInfo = context.getSystemService(LauncherApps.class)
+                    .resolveActivity(info.getIntent(), info.user);
+            outObj[0] = activityInfo;
+            return activityInfo == null ? null
+                    : LauncherAppState.getInstance(context)
+                    .getIconProvider().getIcon(
+                            activityInfo, activity.getDeviceProfile().inv.fillResIconDpi);
+        } else if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT) {
+            List<ShortcutInfo> si = ShortcutKey.fromItemInfo(info)
+                    .buildRequest(context)
+                    .query(ShortcutRequest.ALL);
+            if (si.isEmpty()) {
+                return null;
+            } else {
+                outObj[0] = si.get(0);
+                return ShortcutCachingLogic.getIcon(context, si.get(0),
+                        appState.getInvariantDeviceProfile().fillResIconDpi);
+            }
+        } else if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_FOLDER) {
+            FolderAdaptiveIcon icon = FolderAdaptiveIcon.createFolderAdaptiveIcon(
+                    activity, info.id, new Point(width, height));
+            if (icon == null) {
+                return null;
+            }
+            outObj[0] = icon;
+            return icon;
+        } else if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_SEARCH_ACTION
+                && info instanceof ItemInfoWithIcon) {
+            return ((ItemInfoWithIcon) info).bitmap.newIcon(context);
+        } else {
+            return null;
+        }
+    }
+
     private static boolean sIsRunningInTestHarness = ActivityManager.isRunningInTestHarness();
 
     public static boolean isRunningInTestHarness() {
diff --git a/src/com/android/launcher3/allapps/BaseAllAppsAdapter.java b/src/com/android/launcher3/allapps/BaseAllAppsAdapter.java
index 49335104f2..a5c54b41ad 100644
--- a/src/com/android/launcher3/allapps/BaseAllAppsAdapter.java
+++ b/src/com/android/launcher3/allapps/BaseAllAppsAdapter.java
@@ -43,6 +43,7 @@ import com.android.launcher3.Flags;
 import com.android.launcher3.LauncherPrefs;
 import com.android.launcher3.R;
 import com.android.launcher3.allapps.search.SearchAdapterProvider;
+import com.android.launcher3.config.FeatureFlags;
 import com.android.launcher3.model.data.AppInfo;
 import com.android.launcher3.util.Themes;
 import com.android.launcher3.views.ActivityContext;
@@ -68,10 +69,11 @@ public abstract class BaseAllAppsAdapter<T extends Context & ActivityContext> ex
     // 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_WORK_EDU_CARD = 1 << 4;
     public static final int VIEW_TYPE_WORK_DISABLED_CARD = 1 << 5;
     public static final int VIEW_TYPE_PRIVATE_SPACE_HEADER = 1 << 6;
     public static final int VIEW_TYPE_PRIVATE_SPACE_SYS_APPS_DIVIDER = 1 << 7;
+    public static final int VIEW_TYPE_WORK_EDU_CARD = 1 << 8;
+
     public static final int NEXT_ID = 8;
 
     // Common view type masks
@@ -239,9 +241,6 @@ public abstract class BaseAllAppsAdapter<T extends Context & ActivityContext> ex
                 icon.setOnLongClickListener(mOnIconLongClickListener);
                 // Ensure the all apps icon height matches the workspace icons in portrait mode.
                 icon.getLayoutParams().height = mActivityContext.getDeviceProfile().allAppsCellHeightPx;
-                if (FeatureFlags.twoLineAllApps(parent.getContext())) {
-                    icon.getLayoutParams().height += mExtraTextHeight;
-                }
                 return new ViewHolder(icon);
             case VIEW_TYPE_EMPTY_SEARCH:
                 return new ViewHolder(mLayoutInflater.inflate(R.layout.all_apps_empty_search,
diff --git a/src/com/android/launcher3/allapps/WorkModeSwitch.java b/src/com/android/launcher3/allapps/WorkModeSwitch.java
index 9b7df19f4f..20dfd8247f 100644
--- a/src/com/android/launcher3/allapps/WorkModeSwitch.java
+++ b/src/com/android/launcher3/allapps/WorkModeSwitch.java
@@ -23,7 +23,9 @@ import android.graphics.Insets;
 import android.graphics.Rect;
 import android.os.Build;
 import android.util.AttributeSet;
+import android.view.View;
 import android.view.WindowInsets;
+import android.widget.ImageView;
 import android.widget.LinearLayout;
 import android.widget.TextView;
 
@@ -63,6 +65,7 @@ public class WorkModeSwitch extends LinearLayout implements Insettable,
     // extend/collapse
     private final int mScrollThreshold;
     private TextView mTextView;
+    private ImageView mIcon;
 
     public WorkModeSwitch(@NonNull Context context) {
         this(context, null, 0);
diff --git a/src/com/android/launcher3/allapps/WorkProfileManager.java b/src/com/android/launcher3/allapps/WorkProfileManager.java
index c05d89c9b8..df7ed72be5 100644
--- a/src/com/android/launcher3/allapps/WorkProfileManager.java
+++ b/src/com/android/launcher3/allapps/WorkProfileManager.java
@@ -26,6 +26,7 @@ import static com.android.launcher3.model.BgDataModel.Callbacks.FLAG_HAS_SHORTCU
 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;
 import static com.android.launcher3.model.BgDataModel.Callbacks.FLAG_WORK_PROFILE_QUIET_MODE_ENABLED;
+import static com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR;
 
 import android.os.UserHandle;
 import android.os.UserManager;
@@ -77,7 +78,7 @@ public class WorkProfileManager extends UserProfileManager
         updateCurrentState(STATE_TRANSITION);
         UI_HELPER_EXECUTOR.post(() -> {
             for (UserHandle userProfile : mUserManager.getUserProfiles()) {
-                if (Process.myUserHandle().equals(userProfile)) {
+                if (android.os.Process.myUserHandle().equals(userProfile)) {
                     continue;
                 }
                 // https://github.com/LawnchairLauncher/lawnchair/issues/3145
diff --git a/src/com/android/launcher3/allapps/search/DefaultSearchAdapterProvider.java b/src/com/android/launcher3/allapps/search/DefaultSearchAdapterProvider.java
index 4a8c96b3bd..d954cf5c1b 100644
--- a/src/com/android/launcher3/allapps/search/DefaultSearchAdapterProvider.java
+++ b/src/com/android/launcher3/allapps/search/DefaultSearchAdapterProvider.java
@@ -19,6 +19,8 @@ import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 
+import androidx.recyclerview.widget.RecyclerView;
+
 import com.android.launcher3.BubbleTextView;
 import com.android.launcher3.allapps.AllAppsGridAdapter;
 import com.android.launcher3.model.data.ItemInfo;
@@ -34,6 +36,11 @@ public class DefaultSearchAdapterProvider extends SearchAdapterProvider<Activity
         super(launcher);
     }
 
+    @Override
+    public RecyclerView.ItemDecoration getDecorator() {
+        return null;
+    }
+
     @Override
     public void onBindView(AllAppsGridAdapter.ViewHolder holder, int position) {
         if (position == 0) {
diff --git a/src/com/android/launcher3/allapps/search/SearchAdapterProvider.java b/src/com/android/launcher3/allapps/search/SearchAdapterProvider.java
index 82c9c90f33..80b68b2412 100644
--- a/src/com/android/launcher3/allapps/search/SearchAdapterProvider.java
+++ b/src/com/android/launcher3/allapps/search/SearchAdapterProvider.java
@@ -20,6 +20,8 @@ import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 
+import androidx.recyclerview.widget.RecyclerView;
+
 import com.android.launcher3.allapps.AllAppsGridAdapter;
 import com.android.launcher3.views.ActivityContext;
 
@@ -36,6 +38,11 @@ public abstract class SearchAdapterProvider<T extends ActivityContext> {
         mLauncher = launcher;
     }
 
+    /**
+     * Returns the item decorator.
+     */
+    public abstract RecyclerView.ItemDecoration getDecorator();
+
     /**
      * Handles selection event on search adapter item. Returns false if provider can not handle
      * event
diff --git a/src/com/android/launcher3/config/FeatureFlags.java b/src/com/android/launcher3/config/FeatureFlags.java
index 623d8595a7..da275bac80 100644
--- a/src/com/android/launcher3/config/FeatureFlags.java
+++ b/src/com/android/launcher3/config/FeatureFlags.java
@@ -18,8 +18,8 @@ package com.android.launcher3.config;
 
 import static com.android.launcher3.config.FeatureFlags.BooleanFlag.DISABLED;
 import static com.android.launcher3.config.FeatureFlags.BooleanFlag.ENABLED;
-import static com.android.wm.shell.Flags.enableTaskbarNavbarUnification;
 
+import android.content.Context;
 import android.content.res.Resources;
 
 import androidx.annotation.VisibleForTesting;
@@ -27,8 +27,6 @@ import androidx.annotation.VisibleForTesting;
 import com.android.launcher3.Utilities;
 import com.patrykmichalik.opto.core.PreferenceExtensionsKt;
 
-import java.util.function.Predicate;
-import java.util.function.ToIntFunction;
 import com.android.launcher3.BuildConfig;
 import com.android.launcher3.Flags;
 
@@ -204,7 +202,7 @@ public final class FeatureFlags {
         public static final BooleanFlag NOTIFY_CRASHES = getDebugFlag(270393108, "NOTIFY_CRASHES",
                         DISABLED, "Sends a notification whenever launcher encounters an uncaught exception.");
 
-        public static final boolean ENABLE_TASKBAR_NAVBAR_UNIFICATION = enableTaskbarNavbarUnification() && !isPhone();
+        public static final boolean ENABLE_TASKBAR_NAVBAR_UNIFICATION = !isPhone();
 
         private static boolean isPhone() {
                 final boolean isPhone;
@@ -266,9 +264,6 @@ public final class FeatureFlags {
         public static final BooleanFlag INJECT_FALLBACK_APP_CORPUS_RESULTS = getReleaseFlag(270391706,
                         "INJECT_FALLBACK_APP_CORPUS_RESULTS", DISABLED,
                         "Inject fallback app corpus result when AiAi fails to return it.");
-        public static final BooleanFlag ENABLE_LONG_PRESS_NAV_HANDLE = getReleaseFlag(282993230,
-                        "ENABLE_LONG_PRESS_NAV_HANDLE_MPR", TEAMFOOD,
-                        "Enables long pressing on the bottom bar nav handle to trigger events.");
         // TODO(Block 17): Clean up flags
         // Aconfig migration complete for ENABLE_TASKBAR_PINNING.
         private static final BooleanFlag ENABLE_TASKBAR_PINNING = getDebugFlag(296231746,
diff --git a/src/com/android/launcher3/dragndrop/DragView.java b/src/com/android/launcher3/dragndrop/DragView.java
index bf0e57d42c..de457fc063 100644
--- a/src/com/android/launcher3/dragndrop/DragView.java
+++ b/src/com/android/launcher3/dragndrop/DragView.java
@@ -67,23 +67,15 @@ import com.android.launcher3.util.RunnableList;
 import com.android.launcher3.views.ActivityContext;
 import com.android.launcher3.views.BaseDragLayer;
 
-import app.lawnchair.icons.CustomAdaptiveIconDrawable;
-
-/**
- * A custom view for rendering an icon, folder, shortcut or widget during
- * drag-n-drop.
- */
+/** A custom view for rendering an icon, folder, shortcut or widget during drag-n-drop. */
 public abstract class DragView<T extends Context & ActivityContext> extends FrameLayout {
 
     public static final int VIEW_ZOOM_DURATION = 150;
 
     private final View mContent;
-    // The following are only used for rendering mContent directly during
-    // drag-n-drop.
-    @Nullable
-    private ViewGroup.LayoutParams mContentViewLayoutParams;
-    @Nullable
-    private ViewGroup mContentViewParent;
+    // The following are only used for rendering mContent directly during drag-n-drop.
+    @Nullable private ViewGroup.LayoutParams mContentViewLayoutParams;
+    @Nullable private ViewGroup mContentViewParent;
     private int mContentViewInParentViewIndex = -1;
     private final int mWidth;
     private final int mHeight;
@@ -107,8 +99,7 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
     final ValueAnimator mScaleAnim;
     final ValueAnimator mShiftAnim;
 
-    // Whether mAnim has started. Unlike mAnim.isStarted(), this is true even after
-    // mAnim ends.
+    // Whether mAnim has started. Unlike mAnim.isStarted(), this is true even after mAnim ends.
     private boolean mScaleAnimStarted;
     private boolean mShiftAnimStarted;
     private Runnable mOnScaleAnimEndCallback;
@@ -119,16 +110,15 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
     private int mAnimatedShiftX;
     private int mAnimatedShiftY;
 
-    // Below variable only needed IF FeatureFlags.LAUNCHER3_SPRING_ICONS is {@code
-    // true}
+    // Below variable only needed IF FeatureFlags.LAUNCHER3_SPRING_ICONS is {@code true}
     private Drawable mBgSpringDrawable, mFgSpringDrawable;
     private SpringFloatValue mTranslateX, mTranslateY;
     private Path mScaledMaskPath;
     private Drawable mBadge;
 
     public DragView(T launcher, Drawable drawable, int registrationX,
-            int registrationY, final float initialScale, final float scaleOnDrop,
-            final float finalScaleDps) {
+                    int registrationY, final float initialScale, final float scaleOnDrop,
+                    final float finalScaleDps) {
         this(launcher, getViewFromDrawable(launcher, drawable),
                 drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(),
                 registrationX, registrationY, initialScale, scaleOnDrop, finalScaleDps);
@@ -137,26 +127,21 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
     /**
      * Construct the drag view.
      * <p>
-     * The registration point is the point inside our view that the touch events
-     * should
+     * The registration point is the point inside our view that the touch events should
      * be centered upon.
-     * 
-     * @param activity      The Launcher instance/ActivityContext this DragView is
-     *                      in.
-     * @param content       the view content that is attached to the drag view.
-     * @param width         the width of the dragView
-     * @param height        the height of the dragView
-     * @param initialScale  The view that we're dragging around. We scale it up when
-     *                      we draw it.
+     * @param activity The Launcher instance/ActivityContext this DragView is in.
+     * @param content the view content that is attached to the drag view.
+     * @param width the width of the dragView
+     * @param height the height of the dragView
+     * @param initialScale The view that we're dragging around.  We scale it up when we draw it.
      * @param registrationX The x coordinate of the registration point.
      * @param registrationY The y coordinate of the registration point.
-     * @param scaleOnDrop   the scale used in the drop animation.
-     * @param finalScaleDps the scale used in the zoom out animation when the drag
-     *                      view is shown.
+     * @param scaleOnDrop the scale used in the drop animation.
+     * @param finalScaleDps the scale used in the zoom out animation when the drag view is shown.
      */
     public DragView(T activity, View content, int width, int height, int registrationX,
-            int registrationY, final float initialScale, final float scaleOnDrop,
-            final float finalScaleDps) {
+                    int registrationY, final float initialScale, final float scaleOnDrop,
+                    final float finalScaleDps) {
         super(activity);
         mActivity = activity;
         mDragLayer = activity.getDragLayer();
@@ -173,8 +158,7 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
 
         addView(content, new LayoutParams(width, height));
 
-        // If there is already a scale set on the content, we don't want to clip the
-        // children.
+        // If there is already a scale set on the content, we don't want to clip the children.
         if (content.getScaleX() != 1 || content.getScaleY() != 1) {
             setClipChildren(false);
             setClipToPadding(false);
@@ -197,7 +181,20 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
                 animation.cancel();
             }
         });
+        mScaleAnim.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+                mScaleAnimStarted = true;
+            }
 
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                super.onAnimationEnd(animation);
+                if (mOnScaleAnimEndCallback != null) {
+                    mOnScaleAnimEndCallback.run();
+                }
+            }
+        });
         // Set up the shift animator.
         mShiftAnim = ValueAnimator.ofFloat(0f, 1f);
         mShiftAnim.addListener(new AnimatorListenerAdapter() {
@@ -223,8 +220,7 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
         mInitialScale = initialScale;
         mScaleOnDrop = scaleOnDrop;
 
-        // Force a measure, because Workspace uses getMeasuredHeight() before the layout
-        // pass
+        // Force a measure, because Workspace uses getMeasuredHeight() before the layout pass
         measure(makeMeasureSpec(width, EXACTLY), makeMeasureSpec(height, EXACTLY));
 
         mBlurSizeOutline = getResources().getDimensionPixelSize(R.dimen.blur_size_medium_outline);
@@ -252,10 +248,10 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
         MODEL_EXECUTOR.getHandler().postAtFrontOfQueue(() -> {
             int w = mWidth;
             int h = mHeight;
-            Drawable dr = Utilities.getFullDrawable(mActivity, info, w, h,
-                    outObj, true /* shouldThemeIcon */ );
-
-            if (dr instanceof AdaptiveIconDrawable) {
+            Pair<AdaptiveIconDrawable, Drawable> fullDrawable = Utilities.getFullDrawable(
+                    mActivity, info, w, h, true /* shouldThemeIcon */);
+            if (fullDrawable != null) {
+                AdaptiveIconDrawable adaptiveIcon = fullDrawable.first;
                 int blurMargin = (int) mActivity.getResources()
                         .getDimension(R.dimen.blur_size_medium_outline) / 2;
 
@@ -267,19 +263,13 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
                 FastBitmapDrawable.setBadgeBounds(mBadge, bounds);
 
                 try (LauncherIcons li = LauncherIcons.obtain(mActivity)) {
-                    Drawable nDr; // drawable to be normalized
-                    if (shouldDrawBackground) {
-                        nDr = dr;
-                    } else {
-                        // Since we just want the scale, avoid heavy drawing operations
-                        nDr = new CustomAdaptiveIconDrawable(new ColorDrawable(Color.BLACK), null);
-                    }
-                    Utilities.scaleRectAboutCenter(bounds,
-                            li.getNormalizer().getScale(nDr, null, null, null));
+                    // Since we just want the scale, avoid heavy drawing operations
+                    Utilities.scaleRectAboutCenter(bounds, li.getNormalizer().getScale(
+                            new AdaptiveIconDrawable(new ColorDrawable(Color.BLACK), null),
+                            null, null, null));
                 }
 
-                // Shrink very tiny bit so that the clip path is smaller than the original
-                // bitmap
+                // Shrink very tiny bit so that the clip path is smaller than the original bitmap
                 // that has anti aliased edges and shadows.
                 Rect shrunkBounds = new Rect(bounds);
                 Utilities.scaleRectAboutCenter(shrunkBounds, 0.98f);
@@ -293,7 +283,8 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
 
                 bounds.inset(
                         (int) (-bounds.width() * AdaptiveIconDrawable.getExtraInsetFraction()),
-                        (int) (-bounds.height() * AdaptiveIconDrawable.getExtraInsetFraction()));
+                        (int) (-bounds.height() * AdaptiveIconDrawable.getExtraInsetFraction())
+                );
                 mBgSpringDrawable = adaptiveIcon.getBackground();
                 if (mBgSpringDrawable == null) {
                     mBgSpringDrawable = new ColorDrawable(Color.TRANSPARENT);
@@ -383,8 +374,7 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
             return;
         }
         ImageView newContent = getViewFromDrawable(getContext(), crossFadeDrawable);
-        // We need to fill the ImageView with the content, otherwise the shapes of the
-        // final view
+        // We need to fill the ImageView with the content, otherwise the shapes of the final view
         // and the drag view might not match exactly
         newContent.setScaleType(ImageView.ScaleType.FIT_XY);
         newContent.measure(makeMeasureSpec(mWidth, EXACTLY), makeMeasureSpec(mHeight, EXACTLY));
@@ -419,10 +409,8 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
         if (mContent != null) {
             // At the drag start, the source view visibility is set to invisible.
             if (getHasDragOffset()) {
-                // If there is any dragOffset, this means the content will show away of the
-                // original
-                // icon location, otherwise it's fine since original content would just show at
-                // the
+                // If there is any dragOffset, this means the content will show away of the original
+                // icon location, otherwise it's fine since original content would just show at the
                 // same spot.
                 mContent.setVisibility(INVISIBLE);
             } else {
@@ -472,16 +460,13 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
      * Animate this DragView to the given DragLayer coordinates and then remove it.
      */
     public abstract void animateTo(int toTouchX, int toTouchY, Runnable onCompleteRunnable,
-            int duration);
+                                   int duration);
 
     public void animateShift(final int shiftX, final int shiftY) {
-        if (mShiftAnim.isStarted())
-            return;
+        if (mShiftAnim.isStarted()) return;
 
-        // Set mContent visibility to visible to show icon regardless in case it is
-        // INVISIBLE.
-        if (mContent != null)
-            mContent.setVisibility(VISIBLE);
+        // Set mContent visibility to visible to show icon regardless in case it is INVISIBLE.
+        if (mContent != null) mContent.setVisibility(VISIBLE);
 
         mAnimatedShiftX = shiftX;
         mAnimatedShiftY = shiftY;
@@ -506,9 +491,7 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
     /**
      * Detaches {@link #mContent}, if previously attached, from this view.
      *
-     * <p>
-     * In the case of no change in the drop position, sets
-     * {@code reattachToPreviousParent} to
+     * <p>In the case of no change in the drop position, sets {@code reattachToPreviousParent} to
      * {@code true} to attach the {@link #mContent} back to its previous parent.
      */
     public void detachContentView(boolean reattachToPreviousParent) {
@@ -539,12 +522,9 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
     /**
      * Removes this view from the {@link DragLayer}.
      *
-     * <p>
-     * If the drag content is a {@link #mContent}, this call doesn't reattach the
-     * {@link #mContent} back to its previous parent. To reattach to previous
-     * parent, the caller
-     * should call {@link #detachContentView} with {@code reattachToPreviousParent}
-     * sets to true
+     * <p>If the drag content is a {@link #mContent}, this call doesn't reattach the
+     * {@link #mContent} back to its previous parent. To reattach to previous parent, the caller
+     * should call {@link #detachContentView} with {@code reattachToPreviousParent} sets to true
      * before this call.
      */
     public void remove() {
@@ -576,8 +556,7 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
     }
 
     /**
-     * Returns the previous {@link ViewGroup} parent of the {@link #mContent} before
-     * the drag
+     * Returns the previous {@link ViewGroup} parent of the {@link #mContent} before the drag
      * content is attached to this view.
      */
     @Nullable
@@ -592,19 +571,19 @@ public abstract class DragView<T extends Context & ActivityContext> extends Fram
 
     private static class SpringFloatValue {
 
-        private static final FloatPropertyCompat<SpringFloatValue> VALUE = new FloatPropertyCompat<SpringFloatValue>(
-                "value") {
-            @Override
-            public float getValue(SpringFloatValue object) {
-                return object.mValue;
-            }
+        private static final FloatPropertyCompat<SpringFloatValue> VALUE =
+                new FloatPropertyCompat<SpringFloatValue>("value") {
+                    @Override
+                    public float getValue(SpringFloatValue object) {
+                        return object.mValue;
+                    }
 
-            @Override
-            public void setValue(SpringFloatValue object, float value) {
-                object.mValue = value;
-                object.mView.invalidate();
-            }
-        };
+                    @Override
+                    public void setValue(SpringFloatValue object, float value) {
+                        object.mValue = value;
+                        object.mView.invalidate();
+                    }
+                };
 
         // Following three values are fine tuned with motion ux designer
         private static final int STIFFNESS = 4000;
diff --git a/src/com/android/launcher3/folder/FolderAnimationManager.java b/src/com/android/launcher3/folder/FolderAnimationManager.java
index aa9758a4fa..38c0544f7f 100644
--- a/src/com/android/launcher3/folder/FolderAnimationManager.java
+++ b/src/com/android/launcher3/folder/FolderAnimationManager.java
@@ -12,8 +12,6 @@
  * 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.
- *
- * Modifications copyright 2021, Lawnchair
  */
 
 package com.android.launcher3.folder;
@@ -37,8 +35,6 @@ import android.util.Property;
 import android.view.View;
 import android.view.animation.AnimationUtils;
 
-import androidx.core.graphics.ColorUtils;
-
 import com.android.launcher3.BubbleTextView;
 import com.android.launcher3.CellLayout;
 import com.android.launcher3.DeviceProfile;
@@ -55,9 +51,6 @@ import com.android.launcher3.views.BaseDragLayer;
 
 import java.util.List;
 
-import app.lawnchair.theme.color.tokens.ColorTokens;
-import app.lawnchair.util.LawnchairUtilsKt;
-
 /**
  * Manages the opening and closing animations for a {@link Folder}.
  *
@@ -186,9 +179,8 @@ public class FolderAnimationManager {
         final float yDistance = initialY - lp.y;
 
         // Set up the Folder background.
-        final int previewColor = ColorTokens.FolderPreviewColor.resolveColor(mContext);
-        final int initialColor = ColorUtils.setAlphaComponent(previewColor, LawnchairUtilsKt.getFolderPreviewAlpha(mContext));
-        final int finalColor = ColorTokens.FolderBackgroundColor.resolveColor(mContext);
+        final int initialColor = Themes.getAttrColor(mContext, R.attr.folderPreviewColor);
+        final int finalColor = Themes.getAttrColor(mContext, R.attr.folderBackgroundColor);
 
         mFolderBackground.mutate();
         mFolderBackground.setColor(mIsOpening ? initialColor : finalColor);
@@ -374,7 +366,7 @@ public class FolderAnimationManager {
      * Animate the items on the current page.
      */
     private void addPreviewItemAnimators(AnimatorSet animatorSet, final float folderScale,
-            int previewItemOffsetX, int previewItemOffsetY) {
+                                         int previewItemOffsetX, int previewItemOffsetY) {
         ClippedFolderIconLayoutRule rule = mFolderIcon.getLayoutRule();
         boolean isOnFirstPage = mFolder.mContent.getCurrentPage() == 0;
         final List<View> itemsInPreview = getPreviewIconsOnPage(
@@ -520,4 +512,4 @@ public class FolderAnimationManager {
                 ? ((AppPairIcon) v).getTitleTextView()
                 : (BubbleTextView) v;
     }
-}
+}
\ No newline at end of file
diff --git a/src/com/android/launcher3/folder/FolderIcon.java b/src/com/android/launcher3/folder/FolderIcon.java
index 3093640b9a..a455bd2633 100644
--- a/src/com/android/launcher3/folder/FolderIcon.java
+++ b/src/com/android/launcher3/folder/FolderIcon.java
@@ -648,7 +648,7 @@ public class FolderIcon extends FrameLayout implements FolderListener, IconLabel
 
             // If we are animating to the accepting state, animate the dot out.
             mDotParams.scale = Math.max(0, mDotScale - mBackground.getAcceptScaleProgress());
-            mDotParams.color = mBackground.getDotColor();
+            mDotParams.dotColor = mBackground.getDotColor();
             mDotRenderer.draw(canvas, mDotParams, mDotInfo == null ? -1 : mDotInfo.getNotificationCount());
         }
     }
diff --git a/src/com/android/launcher3/folder/LauncherDelegate.java b/src/com/android/launcher3/folder/LauncherDelegate.java
index e18a9ea522..df702bb9ab 100644
--- a/src/com/android/launcher3/folder/LauncherDelegate.java
+++ b/src/com/android/launcher3/folder/LauncherDelegate.java
@@ -93,8 +93,7 @@ public class LauncherDelegate {
                         // folder
                         CellLayout cellLayout = mLauncher.getCellLayout(info.container,
                                 mLauncher.getCellPosMapper().mapModelToPresenter(info).screenId);
-                        if (cellLayout == null)
-                            return finalItem = info.getContents().remove(0);
+                        finalItem =  info.getContents().remove(0);
                         newIcon = mLauncher.getItemInflater().inflateItem(
                                 finalItem, mLauncher.getModelWriter(), cellLayout);
                         mLauncher.getModelWriter().addOrMoveItemInDatabase(finalItem,
@@ -110,7 +109,7 @@ public class LauncherDelegate {
 
                     if (newIcon != null) {
                         // We add the child after removing the folder to prevent both from existing
-                        // at the same time in the CellLayout. We need to add the new item with
+                        // at the same time in the CellLayout.  We need to add the new item with
                         // addInScreenFromBind() to ensure that hotseat items are placed correctly.
                         mLauncher.getWorkspace().addInScreenFromBind(newIcon, info);
 
@@ -137,6 +136,7 @@ public class LauncherDelegate {
         return true;
     }
 
+
     boolean interceptOutsideTouch(MotionEvent ev, BaseDragLayer dl, Folder folder) {
         if (mLauncher.getAccessibilityDelegate().isInAccessibleDrag()) {
             // Do not close the container if in drag and drop.
@@ -172,8 +172,7 @@ public class LauncherDelegate {
         }
 
         @Override
-        void beginDragShared(View child, DragSource source, DragOptions options) {
-        }
+        void beginDragShared(View child, DragSource source, DragOptions options) { }
 
         @Override
         ModelWriter getModelWriter() {
@@ -185,8 +184,7 @@ public class LauncherDelegate {
         }
 
         @Override
-        void forEachVisibleWorkspacePage(Consumer<View> callback) {
-        }
+        void forEachVisibleWorkspacePage(Consumer<View> callback) { }
 
         @Override
         Launcher getLauncher() {
@@ -210,4 +208,4 @@ public class LauncherDelegate {
                 ? new LauncherDelegate((Launcher) context)
                 : new FallbackDelegate(context);
     }
-}
+}
\ No newline at end of file
diff --git a/src/com/android/launcher3/folder/PreviewItemManager.java b/src/com/android/launcher3/folder/PreviewItemManager.java
index 02a99a6c4d..ac0fb5be2f 100644
--- a/src/com/android/launcher3/folder/PreviewItemManager.java
+++ b/src/com/android/launcher3/folder/PreviewItemManager.java
@@ -22,6 +22,7 @@ import static com.android.launcher3.folder.ClippedFolderIconLayoutRule.EXIT_INDE
 import static com.android.launcher3.folder.ClippedFolderIconLayoutRule.MAX_NUM_ITEMS_IN_PREVIEW;
 import static com.android.launcher3.folder.FolderIcon.DROP_IN_ANIMATION_DURATION;
 import static com.android.launcher3.graphics.PreloadIconDrawable.newPendingIcon;
+import static com.android.launcher3.icons.BitmapInfo.FLAG_THEMED;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
diff --git a/src/com/android/launcher3/graphics/IconShape.java b/src/com/android/launcher3/graphics/IconShape.java
index 4b1e25ab62..14b4c2ef8f 100644
--- a/src/com/android/launcher3/graphics/IconShape.java
+++ b/src/com/android/launcher3/graphics/IconShape.java
@@ -67,14 +67,14 @@ public final class IconShape implements SafeCloseable {
     public static final MainThreadInitializedObject<IconShape> INSTANCE = new MainThreadInitializedObject<>(
             IconShape::new);
 
-    private ShapeDelegate mDelegate = new Circle();
+    private static ShapeDelegate mDelegate = new Circle();
     private float mNormalizationScale = ICON_VISIBLE_AREA_FACTOR;
 
     private IconShape(Context context) {
         pickBestShape(context);
     }
 
-    public ShapeDelegate getShape() {
+    public static ShapeDelegate getShape() {
         return mDelegate;
     }
 
diff --git a/src/com/android/launcher3/graphics/LauncherPreviewRenderer.java b/src/com/android/launcher3/graphics/LauncherPreviewRenderer.java
index 682d17b778..ccfd484842 100644
--- a/src/com/android/launcher3/graphics/LauncherPreviewRenderer.java
+++ b/src/com/android/launcher3/graphics/LauncherPreviewRenderer.java
@@ -24,7 +24,6 @@ import static com.android.launcher3.BubbleTextView.DISPLAY_TASKBAR;
 import static com.android.launcher3.BubbleTextView.DISPLAY_WORKSPACE;
 import static com.android.launcher3.DeviceProfile.DEFAULT_SCALE;
 import static com.android.launcher3.LauncherSettings.Favorites.CONTAINER_HOTSEAT_PREDICTION;
-import static com.android.launcher3.Utilities.SHOULD_SHOW_FIRST_PAGE_WIDGET;
 import static com.android.launcher3.model.ModelUtils.filterCurrentWorkspaceItems;
 import static com.android.launcher3.model.ModelUtils.getMissingHotseatRanks;
 
@@ -40,9 +39,9 @@ import android.content.res.Configuration;
 import android.content.res.TypedArray;
 import android.graphics.PointF;
 import android.graphics.Rect;
+import android.os.Build;
 import android.os.Handler;
 import android.os.Looper;
-import android.os.Process;
 import android.util.AttributeSet;
 import android.util.Size;
 import android.util.SparseArray;
@@ -79,6 +78,7 @@ import com.android.launcher3.celllayout.CellLayoutLayoutParams;
 import com.android.launcher3.celllayout.CellPosMapper;
 import com.android.launcher3.config.FeatureFlags;
 import com.android.launcher3.folder.FolderIcon;
+import com.android.launcher3.icons.LauncherIcons;
 import com.android.launcher3.model.BgDataModel;
 import com.android.launcher3.model.BgDataModel.FixedContainerItems;
 import com.android.launcher3.model.WidgetItem;
@@ -110,12 +110,12 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentLinkedQueue;
 
 import app.lawnchair.DeviceProfileOverrides;
 import app.lawnchair.data.iconoverride.IconOverrideRepository;
 import app.lawnchair.font.FontCache;
 import app.lawnchair.font.FontManager;
-import app.lawnchair.icons.CustomAdaptiveIconDrawable;
 import app.lawnchair.icons.IconPackProvider;
 import app.lawnchair.preferences.PreferenceManager;
 import app.lawnchair.preferences2.PreferenceManager2;
@@ -145,10 +145,7 @@ public class LauncherPreviewRenderer extends ContextWrapper
         private final ConcurrentLinkedQueue<LauncherIconsForPreview> mIconPool = new ConcurrentLinkedQueue<>();
 
         public PreviewContext(Context base, InvariantDeviceProfile idp) {
-            super(base, UserCache.INSTANCE, InstallSessionHelper.INSTANCE, LauncherPrefs.INSTANCE,
-                    LauncherAppState.INSTANCE, InvariantDeviceProfile.INSTANCE,
-                    CustomWidgetManager.INSTANCE, PluginManagerWrapper.INSTANCE,
-                    WindowManagerProxy.INSTANCE, DisplayController.INSTANCE);
+            super (base);
             mIdp = idp;
             putBaseInstance(PreferenceManager.INSTANCE);
             putBaseInstance(PreferenceManager2.INSTANCE);
@@ -165,27 +162,13 @@ public class LauncherPreviewRenderer extends ContextWrapper
         }
 
         private void putBaseInstance(MainThreadInitializedObject mainThreadInitializedObject) {
-            mAllowedObjects.add(mainThreadInitializedObject);
             mObjectMap.put(mainThreadInitializedObject, mainThreadInitializedObject.get(getBaseContext()));
         }
 
-        /**
-         * Creates a new LauncherIcons for the preview, skipping the global pool
-         */
-        public LauncherIcons newLauncherIcons(Context context) {
-            LauncherIconsForPreview launcherIconsForPreview = mIconPool.poll();
-            if (launcherIconsForPreview != null) {
-                return launcherIconsForPreview;
-            }
-            return new LauncherIconsForPreview(context, mIdp.fillResIconDpi, mIdp.iconBitmapSize,
-                    -1 /* poolId */);
-        }
-
         private final class LauncherIconsForPreview extends LauncherIcons {
 
-            private LauncherIconsForPreview(Context context, int fillResIconDpi, int iconBitmapSize,
-                    int poolId) {
-                super(context, fillResIconDpi, iconBitmapSize, poolId, true);
+            private LauncherIconsForPreview(Context context , int fillResIconDpi , int iconBitmapSize , ConcurrentLinkedQueue<LauncherIcons> pool) {
+                super (context , fillResIconDpi , iconBitmapSize , pool);
             }
 
             @Override
diff --git a/src/com/android/launcher3/graphics/PreviewSurfaceRenderer.java b/src/com/android/launcher3/graphics/PreviewSurfaceRenderer.java
index 23a8bdafc8..2b70f33f69 100644
--- a/src/com/android/launcher3/graphics/PreviewSurfaceRenderer.java
+++ b/src/com/android/launcher3/graphics/PreviewSurfaceRenderer.java
@@ -66,6 +66,8 @@ import java.util.ArrayList;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
+import app.lawnchair.AccentColorExtractor;
+
 /** Render preview using surface view. */
 @SuppressWarnings("NewApi")
 public class PreviewSurfaceRenderer {
@@ -216,7 +218,7 @@ public class PreviewSurfaceRenderer {
             return new ContextThemeWrapper(context,
                     Themes.getActivityThemeRes(context));
         }
-        LocalColorExtractor.newInstance(context)
+        AccentColorExtractor.newInstance(context)
                 .applyColorsOverride(context, mWallpaperColors);
         return new ContextThemeWrapper(context,
                 Themes.getActivityThemeRes(context, mWallpaperColors.getColorHints()));
diff --git a/src/com/android/launcher3/icons/ComponentWithLabelAndIcon.java b/src/com/android/launcher3/icons/ComponentWithLabelAndIcon.java
index db0a1d005a..320d551727 100644
--- a/src/com/android/launcher3/icons/ComponentWithLabelAndIcon.java
+++ b/src/com/android/launcher3/icons/ComponentWithLabelAndIcon.java
@@ -51,7 +51,7 @@ public interface ComponentWithLabelAndIcon extends ComponentWithLabel {
                 return super.loadIcon(context, object);
             }
             try (LauncherIcons li = LauncherIcons.obtain(context)) {
-                return li.createBadgedIconBitmap(d, Process.myUserHandle (), false);
+                return li.createBadgedIconBitmap(d);
             }
         }
     }
diff --git a/src/com/android/launcher3/icons/IconCache.java b/src/com/android/launcher3/icons/IconCache.java
index d9318dedcf..d591c82ecb 100644
--- a/src/com/android/launcher3/icons/IconCache.java
+++ b/src/com/android/launcher3/icons/IconCache.java
@@ -588,8 +588,7 @@ public class IconCache extends BaseIconCache {
 
         try (LauncherIcons li = LauncherIcons.obtain(mContext)) {
             final BitmapInfo tempBitmap = li.createBadgedIconBitmap(
-                    mContext.getDrawable(widgetSection.mSectionDrawable),
-                    Process.myUserHandle(), false);
+                    mContext.getDrawable(widgetSection.mSectionDrawable));
             mWidgetCategoryBitmapInfos.put(infoInOut.widgetCategory, tempBitmap);
             infoInOut.bitmap = getBadgedIcon(tempBitmap, infoInOut.user);
         } catch (Exception e) {
diff --git a/src/com/android/launcher3/icons/LauncherActivityCachingLogic.java b/src/com/android/launcher3/icons/LauncherActivityCachingLogic.java
index 07debb6940..fcb083bc87 100644
--- a/src/com/android/launcher3/icons/LauncherActivityCachingLogic.java
+++ b/src/com/android/launcher3/icons/LauncherActivityCachingLogic.java
@@ -67,8 +67,7 @@ public class LauncherActivityCachingLogic
     public BitmapInfo loadIcon(@NonNull Context context, @NonNull LauncherActivityInfo object) {
         try (LauncherIcons li = LauncherIcons.obtain(context)) {
             return li.createBadgedIconBitmap(LauncherAppState.getInstance(context)
-                            .getIconProvider().getIcon(object, li.mFillResIconDpi),
-                    object.getUser(), true);
+                            .getIconProvider().getIcon(object, li.mFillResIconDpi));
         }
     }
 }
diff --git a/src/com/android/launcher3/icons/ShortcutCachingLogic.java b/src/com/android/launcher3/icons/ShortcutCachingLogic.java
index ae8fc50f44..e0f8d59a29 100644
--- a/src/com/android/launcher3/icons/ShortcutCachingLogic.java
+++ b/src/com/android/launcher3/icons/ShortcutCachingLogic.java
@@ -16,7 +16,7 @@
 
 package com.android.launcher3.icons;
 
-import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.BuildConfigs.WIDGETS_ENABLED;
 
 import android.content.ComponentName;
 import android.content.Context;
@@ -80,7 +80,7 @@ public class ShortcutCachingLogic implements CachingLogic<ShortcutInfo> {
                     context, info, LauncherAppState.getIDP(context).fillResIconDpi);
             if (unbadgedDrawable == null)
                 return BitmapInfo.LOW_RES_INFO;
-            return li.createBadgedIconBitmap(unbadgedDrawable, Process.myUserHandle(), true);
+            return li.createBadgedIconBitmap(unbadgedDrawable);
         }
     }
 
diff --git a/src/com/android/launcher3/logging/ColdRebootStartupLatencyLogger.kt b/src/com/android/launcher3/logging/ColdRebootStartupLatencyLogger.kt
index bfc1d3a378..2c1675b0c9 100644
--- a/src/com/android/launcher3/logging/ColdRebootStartupLatencyLogger.kt
+++ b/src/com/android/launcher3/logging/ColdRebootStartupLatencyLogger.kt
@@ -7,7 +7,7 @@ import androidx.annotation.MainThread
 import androidx.annotation.VisibleForTesting
 import androidx.core.util.contains
 import androidx.core.util.isEmpty
-import com.android.launcher3.BuildConfig
+import com.android.launcher3.BuildConfigs
 import com.android.launcher3.logging.StatsLogManager.LauncherLatencyEvent
 import com.android.launcher3.util.Preconditions
 
@@ -137,7 +137,7 @@ open class ColdRebootStartupLatencyLogger : StartupLatencyLogger {
     /** @return true if we can log start of [LauncherLatencyEvent] and vice versa. */
     @MainThread
     private fun validateLoggingEventAtStart(event: LauncherLatencyEvent): Boolean {
-        if (!BuildConfig.IS_STUDIO_BUILD && !isInTest) {
+        if (!BuildConfigs.IS_STUDIO_BUILD && !isInTest) {
             return true
         }
         if (startTimeByEvent.contains(event.id)) {
@@ -161,7 +161,7 @@ open class ColdRebootStartupLatencyLogger : StartupLatencyLogger {
     /** @return true if we can log end of [LauncherLatencyEvent] and vice versa. */
     @MainThread
     private fun validateLoggingEventAtEnd(event: LauncherLatencyEvent): Boolean {
-        if (!BuildConfig.IS_STUDIO_BUILD && !isInTest) {
+        if (!BuildConfigs.IS_STUDIO_BUILD && !isInTest) {
             return true
         }
         if (!startTimeByEvent.contains(event.id)) {
diff --git a/src/com/android/launcher3/model/BaseLauncherBinder.java b/src/com/android/launcher3/model/BaseLauncherBinder.java
index 1eff7a1e01..7f7e174ad3 100644
--- a/src/com/android/launcher3/model/BaseLauncherBinder.java
+++ b/src/com/android/launcher3/model/BaseLauncherBinder.java
@@ -16,7 +16,7 @@
 
 package com.android.launcher3.model;
 
-import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.BuildConfigs.WIDGETS_ENABLED;
 import static com.android.launcher3.Flags.enableSmartspaceRemovalToggle;
 import static com.android.launcher3.Flags.enableWorkspaceInflation;
 import static com.android.launcher3.model.ItemInstallQueue.FLAG_LOADER_RUNNING;
diff --git a/src/com/android/launcher3/model/BgDataModel.java b/src/com/android/launcher3/model/BgDataModel.java
index 98eb6c90b6..ee3fe5ec76 100644
--- a/src/com/android/launcher3/model/BgDataModel.java
+++ b/src/com/android/launcher3/model/BgDataModel.java
@@ -17,8 +17,8 @@ package com.android.launcher3.model;
 
 import static android.content.pm.LauncherApps.ShortcutQuery.FLAG_GET_KEY_FIELDS_ONLY;
 
-import static com.android.launcher3.BuildConfig.QSB_ON_FIRST_SCREEN;
-import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.BuildConfigs.QSB_ON_FIRST_SCREEN;
+import static com.android.launcher3.BuildConfigs.WIDGETS_ENABLED;
 import static com.android.launcher3.Flags.enableSmartspaceRemovalToggle;
 import static com.android.launcher3.Utilities.SHOULD_SHOW_FIRST_PAGE_WIDGET;
 import static com.android.launcher3.shortcuts.ShortcutRequest.PINNED;
diff --git a/src/com/android/launcher3/model/LoaderCursor.java b/src/com/android/launcher3/model/LoaderCursor.java
index ee5e5ee53c..79dd80c959 100644
--- a/src/com/android/launcher3/model/LoaderCursor.java
+++ b/src/com/android/launcher3/model/LoaderCursor.java
@@ -121,6 +121,7 @@ public class LoaderCursor extends CursorWrapper {
     public int container;
     public int itemType;
     public int restoreFlag;
+    private PreferenceManager2 preferenceManager2;
 
     public LoaderCursor(Cursor cursor, LauncherAppState app, UserManagerState userManagerState,
             PackageManagerHelper pmHelper,
diff --git a/src/com/android/launcher3/model/LoaderTask.java b/src/com/android/launcher3/model/LoaderTask.java
index d679021bb3..58c0b961d9 100644
--- a/src/com/android/launcher3/model/LoaderTask.java
+++ b/src/com/android/launcher3/model/LoaderTask.java
@@ -16,12 +16,9 @@
 
 package com.android.launcher3.model;
 
-import static com.android.launcher3.BuildConfig.WIDGET_ON_FIRST_SCREEN;
 import static com.android.launcher3.Flags.enableLauncherBrMetricsFixed;
-import static com.android.launcher3.Flags.enableSmartspaceAsAWidget;
 import static com.android.launcher3.Flags.enableSmartspaceRemovalToggle;
 import static com.android.launcher3.LauncherPrefs.IS_FIRST_LOAD_AFTER_RESTORE;
-import static com.android.launcher3.LauncherPrefs.SHOULD_SHOW_SMARTSPACE;
 import static com.android.launcher3.LauncherSettings.Favorites.TABLE_NAME;
 import static com.android.launcher3.model.BgDataModel.Callbacks.FLAG_HAS_SHORTCUT_PERMISSION;
 import static com.android.launcher3.model.BgDataModel.Callbacks.FLAG_PRIVATE_PROFILE_QUIET_MODE_ENABLED;
@@ -29,10 +26,6 @@ import static com.android.launcher3.model.BgDataModel.Callbacks.FLAG_QUIET_MODE_
 import static com.android.launcher3.model.BgDataModel.Callbacks.FLAG_QUIET_MODE_ENABLED;
 import static com.android.launcher3.model.BgDataModel.Callbacks.FLAG_WORK_PROFILE_QUIET_MODE_ENABLED;
 import static com.android.launcher3.model.ModelUtils.filterCurrentWorkspaceItems;
-import static com.android.launcher3.model.data.ItemInfoWithIcon.FLAG_DISABLED_LOCKED_USER;
-import static com.android.launcher3.model.data.ItemInfoWithIcon.FLAG_DISABLED_SAFEMODE;
-import static com.android.launcher3.model.data.ItemInfoWithIcon.FLAG_DISABLED_SUSPENDED;
-import static com.android.launcher3.testing.shared.TestProtocol.testLogD;
 import static com.android.launcher3.model.data.ItemInfoWithIcon.FLAG_INSTALL_SESSION_ACTIVE;
 import static com.android.launcher3.util.Executors.MODEL_EXECUTOR;
 import static com.android.launcher3.util.PackageManagerHelper.hasShortcutsPermission;
@@ -73,7 +66,6 @@ import com.android.launcher3.folder.Folder;
 import com.android.launcher3.folder.FolderGridOrganizer;
 import com.android.launcher3.folder.FolderNameInfos;
 import com.android.launcher3.folder.FolderNameProvider;
-import com.android.launcher3.graphics.LauncherPreviewRenderer;
 import com.android.launcher3.icons.ComponentWithLabelAndIcon;
 import com.android.launcher3.icons.ComponentWithLabelAndIcon.ComponentWithIconCachingLogic;
 import com.android.launcher3.icons.IconCache;
@@ -115,7 +107,6 @@ import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.CancellationException;
 
-import app.lawnchair.LawnchairAppKt;
 import app.lawnchair.preferences.PreferenceManager;
 
 /**
@@ -348,17 +339,17 @@ public class LoaderTask implements Runnable {
             verifyNotStopped();
             LauncherPrefs prefs = LauncherPrefs.get(mApp.getContext());
 
-            if (enableSmartspaceAsAWidget() && prefs.get(SHOULD_SHOW_SMARTSPACE)) {
-                mLauncherBinder.bindSmartspaceWidget();
-                // Turn off pref.
-                prefs.putSync(SHOULD_SHOW_SMARTSPACE.to(false));
-                logASplit("bindSmartspaceWidget");
-                verifyNotStopped();
-            } else if (!enableSmartspaceAsAWidget() && WIDGET_ON_FIRST_SCREEN
-                    && !prefs.get(LauncherPrefs.SHOULD_SHOW_SMARTSPACE)) {
-                // Turn on pref.
-                prefs.putSync(SHOULD_SHOW_SMARTSPACE.to(true));
-            }
+//            if (enableSmartspaceAsAWidget() && prefs.get(SHOULD_SHOW_SMARTSPACE)) {
+//                mLauncherBinder.bindSmartspaceWidget();
+//                // Turn off pref.
+//                prefs.putSync(SHOULD_SHOW_SMARTSPACE.to(false));
+//                logASplit("bindSmartspaceWidget");
+//                verifyNotStopped();
+//            } else if (!enableSmartspaceAsAWidget() && WIDGET_ON_FIRST_SCREEN
+//                    && !prefs.get(LauncherPrefs.SHOULD_SHOW_SMARTSPACE)) {
+//                // Turn on pref.
+//                prefs.putSync(SHOULD_SHOW_SMARTSPACE.to(true));
+//            }
 
             if (FeatureFlags.CHANGE_MODEL_DELEGATE_LOADING_ORDER.get()) {
                 mModelDelegate.loadAndBindOtherItems(mLauncherBinder.mCallbacksList);
@@ -423,7 +414,7 @@ public class LoaderTask implements Runnable {
             mModelDelegate.markActive();
             logASplit("workspaceDelegateItems");
         }
-        mBgDataModel.isFirstPagePinnedItemEnabled = FeatureFlags.QSB_ON_FIRST_SCREEN
+        mBgDataModel.isFirstPagePinnedItemEnabled = com.android.launcher3.config.FeatureFlags.topQsbOnFirstScreenEnabled(mApp.getContext())
                 && (!enableSmartspaceRemovalToggle() || LauncherPrefs.getPrefs(
                         mApp.getContext()).getBoolean(SMARTSPACE_ON_HOME_SCREEN, true));
     }
diff --git a/src/com/android/launcher3/model/PackageUpdatedTask.java b/src/com/android/launcher3/model/PackageUpdatedTask.java
index bce7a1be7d..15024ce403 100644
--- a/src/com/android/launcher3/model/PackageUpdatedTask.java
+++ b/src/com/android/launcher3/model/PackageUpdatedTask.java
@@ -12,8 +12,6 @@
  * 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.
- *
- * Modifications copyright 2021, Lawnchair
  */
 package com.android.launcher3.model;
 
@@ -29,11 +27,11 @@ import android.content.Context;
 import android.content.Intent;
 import android.content.pm.LauncherActivityInfo;
 import android.content.pm.LauncherApps;
+import android.content.pm.PackageManager;
 import android.content.pm.ShortcutInfo;
 import android.os.UserHandle;
 import android.os.UserManager;
 import android.util.Log;
-import android.content.pm.PackageManager;
 
 import androidx.annotation.NonNull;
 
@@ -42,6 +40,7 @@ import com.android.launcher3.LauncherAppState;
 import com.android.launcher3.LauncherModel.ModelUpdateTask;
 import com.android.launcher3.LauncherSettings;
 import com.android.launcher3.LauncherSettings.Favorites;
+import com.android.launcher3.R;
 import com.android.launcher3.config.FeatureFlags;
 import com.android.launcher3.icons.IconCache;
 import com.android.launcher3.logging.FileLog;
@@ -58,7 +57,6 @@ import com.android.launcher3.util.ItemInfoMatcher;
 import com.android.launcher3.util.PackageManagerHelper;
 import com.android.launcher3.util.PackageUserKey;
 import com.android.launcher3.util.SafeCloseable;
-import com.android.launcher3.icons.R;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -73,8 +71,7 @@ import java.util.stream.Collectors;
 import app.lawnchair.preferences.PreferenceManager;
 
 /**
- * Handles updates due to changes in package manager (app
- * installed/updated/removed)
+ * Handles updates due to changes in package manager (app installed/updated/removed)
  * or when a user availability changes.
  */
 @SuppressWarnings("NewApi")
@@ -102,20 +99,15 @@ public class PackageUpdatedTask implements ModelUpdateTask {
     private final String[] mPackages;
 
     public PackageUpdatedTask(final int op, @NonNull final UserHandle user,
-            @NonNull final String... packages) {
+                              @NonNull final String... packages) {
         mOp = op;
         mUser = user;
         mPackages = packages;
-        if (TestProtocol.sDebugTracing) {
-            Log.d(TestProtocol.WORK_TAB_MISSING, "PackageUpdatedTask mOp: " + mOp +
-                    " packageCount: " + mPackages.length + " user: " + user);
-            DEBUG = true;
-        }
     }
 
     @Override
     public void execute(@NonNull ModelTaskController taskController, @NonNull BgDataModel dataModel,
-            @NonNull AllAppsList appsList) {
+                        @NonNull AllAppsList appsList) {
         final LauncherAppState app = taskController.getApp();
         final Context context = app.getContext();
         final IconCache iconCache = app.getIconCache();
@@ -129,6 +121,8 @@ public class PackageUpdatedTask implements ModelUpdateTask {
                 : ItemInfoMatcher.ofPackages(packageSet, mUser);
         final HashSet<ComponentName> removedComponents = new HashSet<>();
         final HashMap<String, List<LauncherActivityInfo>> activitiesLists = new HashMap<>();
+        final PackageManagerHelper packageManagerHelper = new PackageManagerHelper(context);
+
         if (DEBUG) {
             Log.d(TAG, "Package updated: mOp=" + getOpString()
                     + " packages=" + Arrays.toString(packages));
@@ -147,7 +141,7 @@ public class PackageUpdatedTask implements ModelUpdateTask {
                     activitiesLists.put(packages[i],
                             appsList.addPackage(context, packages[i], mUser));
                 }
-                flagOp = FlagOp.removeFlag(WorkspaceItemInfo.FLAG_DISABLED_NOT_AVAILABLE);
+                flagOp = FlagOp.NO_OP.removeFlag(WorkspaceItemInfo.FLAG_DISABLED_NOT_AVAILABLE);
                 break;
             }
             case OP_UPDATE:
@@ -165,7 +159,7 @@ public class PackageUpdatedTask implements ModelUpdateTask {
                     }
                 }
                 // Since package was just updated, the target must be available now.
-                flagOp = FlagOp.removeFlag(WorkspaceItemInfo.FLAG_DISABLED_NOT_AVAILABLE);
+                flagOp = FlagOp.NO_OP.removeFlag(WorkspaceItemInfo.FLAG_DISABLED_NOT_AVAILABLE);
                 break;
             case OP_REMOVE: {
                 for (int i = 0; i < N; i++) {
@@ -174,11 +168,9 @@ public class PackageUpdatedTask implements ModelUpdateTask {
                     if (packages[i].equals(pm.getIconPackPackage().get())) {
                         pm.getIconPackPackage().set("");
                     }
-                    ;
                     if (packages[i].equals(pm.getThemedIconPackPackage().get())) {
                         pm.getThemedIconPackPackage().set("");
                     }
-                    ;
                     final boolean isThemedIconsAvailable = context.getPackageManager()
                             .queryIntentActivityOptions(
                                     new ComponentName(context.getApplicationInfo().packageName,
@@ -201,7 +193,7 @@ public class PackageUpdatedTask implements ModelUpdateTask {
                     }
                     appsList.removePackage(packages[i], mUser);
                 }
-                flagOp = FlagOp.addFlag(WorkspaceItemInfo.FLAG_DISABLED_NOT_AVAILABLE);
+                flagOp = FlagOp.NO_OP.addFlag(WorkspaceItemInfo.FLAG_DISABLED_NOT_AVAILABLE);
                 break;
             case OP_SUSPEND:
             case OP_UNSUSPEND:
@@ -213,7 +205,7 @@ public class PackageUpdatedTask implements ModelUpdateTask {
                 UserManagerState ums = new UserManagerState();
                 UserManager userManager = context.getSystemService(UserManager.class);
                 ums.init(UserCache.INSTANCE.get(context), userManager);
-                boolean isUserQuiet = ums.isUserQuiet(mUser);
+                boolean isUserQuiet =  ums.isUserQuiet(mUser);
                 flagOp = FlagOp.NO_OP.setFlag(
                         WorkspaceItemInfo.FLAG_DISABLED_QUIET_USER, isUserQuiet);
                 appsList.updateDisabledFlags(matcher, flagOp);
@@ -270,10 +262,11 @@ public class PackageUpdatedTask implements ModelUpdateTask {
                             boolean isTargetValid = !cn.getClassName().equals(
                                     IconCache.EMPTY_CLASS_NAME);
                             if (si.itemType == Favorites.ITEM_TYPE_DEEP_SHORTCUT) {
-                                List<ShortcutInfo> shortcut = new ShortcutRequest(context, mUser)
-                                        .forPackage(cn.getPackageName(),
-                                                si.getDeepShortcutId())
-                                        .query(ShortcutRequest.PINNED);
+                                List<ShortcutInfo> shortcut =
+                                        new ShortcutRequest(context, mUser)
+                                                .forPackage(cn.getPackageName(),
+                                                        si.getDeepShortcutId())
+                                                .query(ShortcutRequest.PINNED);
                                 if (shortcut.isEmpty()) {
                                     isTargetValid = false;
                                     if (DEBUG) {
@@ -335,12 +328,12 @@ public class PackageUpdatedTask implements ModelUpdateTask {
                             List<LauncherActivityInfo> activities = activitiesLists.get(
                                     packageName);
                             // TODO: See if we can migrate this to
-                            // AppInfo#updateRuntimeFlagsForActivityTarget
+                            //  AppInfo#updateRuntimeFlagsForActivityTarget
                             si.setProgressLevel(
                                     activities == null || activities.isEmpty()
                                             ? 100
                                             : PackageManagerHelper.getLoadingProgress(
-                                                    activities.get(0)),
+                                            activities.get(0)),
                                     PackageInstallInfo.STATUS_INSTALLED_DOWNLOADING);
                             // In case an app is archived, we need to make sure that archived state
                             // in WorkspaceItemInfo is refreshed.
@@ -380,10 +373,11 @@ public class PackageUpdatedTask implements ModelUpdateTask {
                 for (LauncherAppWidgetInfo widgetInfo : dataModel.appWidgets) {
                     if (mUser.equals(widgetInfo.user)
                             && widgetInfo.hasRestoreFlag(
-                                    LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)
+                            LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY)
                             && packageSet.contains(widgetInfo.providerName.getPackageName())) {
-                        widgetInfo.restoreStatus &= ~LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY
-                                & ~LauncherAppWidgetInfo.FLAG_RESTORE_STARTED;
+                        widgetInfo.restoreStatus &=
+                                ~LauncherAppWidgetInfo.FLAG_PROVIDER_NOT_READY
+                                        & ~LauncherAppWidgetInfo.FLAG_RESTORE_STARTED;
 
                         // adding this flag ensures that launcher shows 'click to setup'
                         // if the widget has a config activity. In case there is no config
@@ -422,7 +416,7 @@ public class PackageUpdatedTask implements ModelUpdateTask {
         } else if (mOp == OP_UPDATE) {
             // Mark disabled packages in the broadcast to be removed
             final LauncherApps launcherApps = context.getSystemService(LauncherApps.class);
-            for (int i = 0; i < N; i++) {
+            for (int i=0; i<N; i++) {
                 if (!launcherApps.isPackageEnabled(packages[i], mUser)) {
                     if (DEBUG) {
                         Log.d(TAG, "OP_UPDATE:"
@@ -434,16 +428,17 @@ public class PackageUpdatedTask implements ModelUpdateTask {
         }
 
         if (!removedPackages.isEmpty() || !removedComponents.isEmpty()) {
-            Predicate<ItemInfo> removeMatch = ItemInfoMatcher.ofPackages(removedPackages, mUser)
-                    .or(ItemInfoMatcher.ofComponents(removedComponents, mUser))
-                    .and(ItemInfoMatcher.ofItemIds(forceKeepShortcuts).negate());
+            Predicate<ItemInfo> removeMatch =
+                    ItemInfoMatcher.ofPackages(removedPackages, mUser)
+                            .or(ItemInfoMatcher.ofComponents(removedComponents, mUser))
+                            .and(ItemInfoMatcher.ofItemIds(forceKeepShortcuts).negate());
             taskController.deleteAndBindComponentsRemoved(removeMatch,
                     "removed because the corresponding package or component is removed. "
                             + "mOp=" + mOp + " removedPackages=" + removedPackages.stream().collect(
-                                    Collectors.joining(",", "[", "]"))
+                            Collectors.joining(",", "[", "]"))
                             + " removedComponents=" + removedComponents.stream()
-                                    .filter(Objects::nonNull).map(ComponentName::toShortString)
-                                    .collect(Collectors.joining(",", "[", "]")));
+                            .filter(Objects::nonNull).map(ComponentName::toShortString)
+                            .collect(Collectors.joining(",", "[", "]")));
 
             // Remove any queued items from the install queue
             ItemInstallQueue.INSTANCE.get(context)
@@ -451,8 +446,7 @@ public class PackageUpdatedTask implements ModelUpdateTask {
         }
 
         if (mOp == OP_ADD) {
-            // Load widgets for the new package. Changes due to app updates are handled
-            // through
+            // Load widgets for the new package. Changes due to app updates are handled through
             // AppWidgetHost events, this is just to initialize the long-press options.
             for (int i = 0; i < N; i++) {
                 dataModel.widgetsModel.update(app, new PackageUserKey(packages[i], mUser));
@@ -463,14 +457,12 @@ public class PackageUpdatedTask implements ModelUpdateTask {
 
     /**
      * Updates {@param si}'s intent to point to a new ComponentName.
-     * 
      * @return Whether the shortcut intent was changed.
      */
     private boolean updateWorkspaceItemIntent(Context context,
-            WorkspaceItemInfo si, String packageName) {
+                                              WorkspaceItemInfo si, String packageName) {
         if (si.itemType == LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT) {
-            // Do not update intent for deep shortcuts as they contain additional
-            // information
+            // Do not update intent for deep shortcuts as they contain additional information
             // about the shortcut.
             return false;
         }
diff --git a/src/com/android/launcher3/model/UserLockStateChangedTask.java b/src/com/android/launcher3/model/UserLockStateChangedTask.java
index 336d5fca56..722d7bbf2b 100644
--- a/src/com/android/launcher3/model/UserLockStateChangedTask.java
+++ b/src/com/android/launcher3/model/UserLockStateChangedTask.java
@@ -16,7 +16,6 @@
 package com.android.launcher3.model;
 
 import static com.android.launcher3.model.data.ItemInfoWithIcon.FLAG_DISABLED_LOCKED_USER;
-import static com.android.launcher3.testing.shared.TestProtocol.WORK_TAB_MISSING;
 
 import android.content.Context;
 import android.content.pm.ShortcutInfo;
@@ -32,7 +31,6 @@ import com.android.launcher3.model.data.WorkspaceItemInfo;
 import com.android.launcher3.shortcuts.ShortcutKey;
 import com.android.launcher3.shortcuts.ShortcutRequest;
 import com.android.launcher3.shortcuts.ShortcutRequest.QueryResult;
-import com.android.launcher3.testing.shared.TestProtocol;
 import com.android.launcher3.util.ComponentKey;
 import com.android.launcher3.util.ItemInfoMatcher;
 
@@ -65,10 +63,6 @@ public class UserLockStateChangedTask implements ModelUpdateTask {
         if (mIsUserUnlocked) {
             QueryResult shortcuts = new ShortcutRequest(context, mUser)
                     .query(ShortcutRequest.PINNED);
-            if (TestProtocol.sDebugTracing) {
-                Log.d(WORK_TAB_MISSING, "shortcutQuery success? "
-                        + shortcuts.wasSuccess());
-            }
             if (shortcuts.wasSuccess()) {
                 for (ShortcutInfo shortcut : shortcuts) {
                     pinnedShortcuts.put(ShortcutKey.fromInfo(shortcut), shortcut);
@@ -91,9 +85,6 @@ public class UserLockStateChangedTask implements ModelUpdateTask {
                     if (mIsUserUnlocked) {
                         ShortcutKey key = ShortcutKey.fromItemInfo(si);
                         ShortcutInfo shortcut = pinnedShortcuts.get(key);
-                        if (TestProtocol.sDebugTracing) {
-                            Log.d(WORK_TAB_MISSING, "shortcutInfo: " + shortcut);
-                        }
                         // We couldn't verify the shortcut during loader. If its no longer available
                         // (probably due to clear data), delete the workspace item as well
                         if (shortcut == null) {
diff --git a/src/com/android/launcher3/model/WidgetsModel.java b/src/com/android/launcher3/model/WidgetsModel.java
index 2f3a059035..6ca14ec1c0 100644
--- a/src/com/android/launcher3/model/WidgetsModel.java
+++ b/src/com/android/launcher3/model/WidgetsModel.java
@@ -3,7 +3,7 @@ package com.android.launcher3.model;
 
 import static android.appwidget.AppWidgetProviderInfo.WIDGET_FEATURE_HIDE_FROM_PICKER;
 
-import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.BuildConfigs.WIDGETS_ENABLED;
 import static com.android.launcher3.pm.ShortcutConfigActivityInfo.queryList;
 import static com.android.launcher3.widget.WidgetSections.NO_CATEGORY;
 
diff --git a/src/com/android/launcher3/model/data/ItemInfoWithIcon.java b/src/com/android/launcher3/model/data/ItemInfoWithIcon.java
index 4236749478..a1b1c310d6 100644
--- a/src/com/android/launcher3/model/data/ItemInfoWithIcon.java
+++ b/src/com/android/launcher3/model/data/ItemInfoWithIcon.java
@@ -317,6 +317,15 @@ public abstract class ItemInfoWithIcon extends ItemInfo {
         return newIcon(context, PreferenceManager.getInstance(context).getThemedIcons().get());
     }
 
+    /**
+     * Returns a FastBitmapDrawable with the icon and context theme applied
+     */
+    public FastBitmapDrawable newIcon(Context context, @BitmapInfo.DrawableCreationFlags int creationFlags) {
+        FastBitmapDrawable drawable = bitmap.newIcon(context, creationFlags);
+        drawable.setIsDisabled(isDisabled());
+        return drawable;
+    }
+
     /**
      * Returns a FastBitmapDrawable with the icon and context theme applied
      */
diff --git a/src/com/android/launcher3/model/data/SearchActionItemInfo.java b/src/com/android/launcher3/model/data/SearchActionItemInfo.java
index c6e5e8a98f..86f3574445 100644
--- a/src/com/android/launcher3/model/data/SearchActionItemInfo.java
+++ b/src/com/android/launcher3/model/data/SearchActionItemInfo.java
@@ -32,8 +32,8 @@ import com.android.launcher3.icons.LauncherIcons;
 import com.android.launcher3.logger.LauncherAtom.ItemInfo;
 import com.android.launcher3.logger.LauncherAtom.SearchActionItem;
 import com.android.launcher3.model.AllAppsList;
-import com.android.launcher3.model.BaseModelUpdateTask;
 import com.android.launcher3.model.BgDataModel;
+import com.android.launcher3.model.ModelTaskController;
 
 /**
  * Represents a SearchAction with in launcher
@@ -135,7 +135,6 @@ public class SearchActionItemInfo extends ItemInfoWithIcon {
         return new SearchActionItemInfo(this);
     }
 
-    @Override
     public ItemInfo buildProto(FolderInfo fInfo) {
         SearchActionItem.Builder itemBuilder = SearchActionItem.newBuilder()
                 .setPackageName(mFallbackPackageName);
@@ -169,14 +168,14 @@ public class SearchActionItemInfo extends ItemInfoWithIcon {
             info.options |= WorkspaceItemInfo.FLAG_START_FOR_RESULT;
         }
 
-        model.enqueueModelUpdateTask(new BaseModelUpdateTask() {
+        model.enqueueModelUpdateTask(new LauncherModel.ModelUpdateTask() {
             @Override
-            public void execute(LauncherAppState app, BgDataModel dataModel, AllAppsList apps) {
+            public void execute(ModelTaskController app, BgDataModel dataModel, AllAppsList apps) {
 
                 model.updateAndBindWorkspaceItem(() -> {
                     PackageItemInfo pkgInfo = new PackageItemInfo(getIntentPackageName(), user);
-                    app.getIconCache().getTitleAndIconForApp(pkgInfo, false);
-                    try (LauncherIcons li = LauncherIcons.obtain(app.getContext())) {
+                    app.getApp().getIconCache().getTitleAndIconForApp(pkgInfo, false);
+                    try (LauncherIcons li = LauncherIcons.obtain(app.getApp().getContext())) {
                         info.bitmap = li.badgeBitmap(info.bitmap.icon, pkgInfo.bitmap);
                     }
                     return info;
diff --git a/src/com/android/launcher3/pm/InstallSessionHelper.java b/src/com/android/launcher3/pm/InstallSessionHelper.java
index e66f496b9d..6edc98a862 100644
--- a/src/com/android/launcher3/pm/InstallSessionHelper.java
+++ b/src/com/android/launcher3/pm/InstallSessionHelper.java
@@ -216,7 +216,7 @@ public class InstallSessionHelper implements SafeCloseable {
     @WorkerThread
     void tryQueuePromiseAppIcon(@Nullable final PackageInstaller.SessionInfo sessionInfo) {
         if (sessionInfo != null
-                && SessionCommitReceiver.isEnabled(mAppContext, getUserHandle(sessionInfo))
+                && SessionCommitReceiver.isEnabled(mAppContext)
                 && verifySessionInfo(sessionInfo)
                 && !promiseIconAddedForId(sessionInfo.getSessionId())) {
             // In case of unarchival, we do not want to add a workspace promise icon if one is
diff --git a/src/com/android/launcher3/popup/ArrowPopup.java b/src/com/android/launcher3/popup/ArrowPopup.java
index fb0e86dea5..b1b0512708 100644
--- a/src/com/android/launcher3/popup/ArrowPopup.java
+++ b/src/com/android/launcher3/popup/ArrowPopup.java
@@ -619,6 +619,24 @@ public abstract class ArrowPopup<T extends Context & ActivityContext>
         mOpenCloseAnimator.start();
     }
 
+    public int getExtraVerticalOffset() {
+        return getResources().getDimensionPixelSize(R.dimen.popup_vertical_padding);
+    }
+
+    /**
+     * Sets X and Y pivots for the view animation considering arrow position.
+     */
+    protected void setPivotForOpenCloseAnimation() {
+        int arrowCenter = mArrowOffsetHorizontal + mArrowWidth / 2;
+        if (mIsArrowRotated) {
+            setPivotX(mIsLeftAligned ? 0f : getMeasuredWidth());
+            setPivotY(arrowCenter);
+        } else {
+            setPivotX(mIsLeftAligned ? arrowCenter : getMeasuredWidth() - arrowCenter);
+            setPivotY(mIsAboveIcon ? getMeasuredHeight() : 0f);
+        }
+    }
+
     private AnimatorSet getOpenCloseAnimator(boolean isOpening, int totalDuration,
             int fadeStartDelay, int fadeDuration, int childFadeStartDelay,
             int childFadeDuration, Interpolator interpolator) {
diff --git a/src/com/android/launcher3/popup/PopupContainerWithArrow.java b/src/com/android/launcher3/popup/PopupContainerWithArrow.java
index 8f26d17a94..c6fb23a1e5 100644
--- a/src/com/android/launcher3/popup/PopupContainerWithArrow.java
+++ b/src/com/android/launcher3/popup/PopupContainerWithArrow.java
@@ -17,24 +17,18 @@
 package com.android.launcher3.popup;
 
 import static com.android.launcher3.LauncherSettings.Favorites.CONTAINER_SHORTCUTS;
-import static com.android.launcher3.Utilities.ATLEAST_P;
 import static com.android.launcher3.Utilities.squaredHypot;
 import static com.android.launcher3.Utilities.squaredTouchSlop;
-import static com.android.launcher3.config.FeatureFlags.ENABLE_MATERIAL_U_POPUP;
+import static com.android.launcher3.model.data.ItemInfoWithIcon.FLAG_NOT_PINNABLE;
 import static com.android.launcher3.popup.PopupPopulator.MAX_SHORTCUTS;
-import static com.android.launcher3.popup.PopupPopulator.MAX_SHORTCUTS_IF_NOTIFICATIONS;
 import static com.android.launcher3.util.Executors.MODEL_EXECUTOR;
 
-import static java.util.Collections.emptyList;
-
 import android.animation.AnimatorSet;
 import android.animation.LayoutTransition;
-import android.annotation.TargetApi;
 import android.content.Context;
 import android.graphics.Point;
 import android.graphics.PointF;
 import android.graphics.Rect;
-import android.os.Build;
 import android.os.Handler;
 import android.os.Looper;
 import android.util.AttributeSet;
@@ -51,12 +45,11 @@ import com.android.launcher3.BubbleTextView;
 import com.android.launcher3.DragSource;
 import com.android.launcher3.DropTarget;
 import com.android.launcher3.DropTarget.DragObject;
+import com.android.launcher3.Flags;
 import com.android.launcher3.Launcher;
 import com.android.launcher3.R;
 import com.android.launcher3.accessibility.LauncherAccessibilityDelegate;
 import com.android.launcher3.accessibility.ShortcutMenuAccessibilityDelegate;
-import com.android.launcher3.config.FeatureFlags;
-import com.android.launcher3.dot.DotInfo;
 import com.android.launcher3.dragndrop.DragController;
 import com.android.launcher3.dragndrop.DragOptions;
 import com.android.launcher3.dragndrop.DragView;
@@ -64,9 +57,6 @@ import com.android.launcher3.dragndrop.DraggableView;
 import com.android.launcher3.model.data.ItemInfo;
 import com.android.launcher3.model.data.ItemInfoWithIcon;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
-import com.android.launcher3.notification.NotificationContainer;
-import com.android.launcher3.notification.NotificationInfo;
-import com.android.launcher3.notification.NotificationKeyData;
 import com.android.launcher3.shortcuts.DeepShortcutView;
 import com.android.launcher3.shortcuts.ShortcutDragPreviewProvider;
 import com.android.launcher3.touch.ItemLongClickListener;
@@ -82,8 +72,7 @@ import java.util.Optional;
 import java.util.stream.Collectors;
 
 /**
- * A container for shortcuts to deep links and notifications associated with an
- * app.
+ * A container for shortcuts to deep links associated with an app.
  *
  * @param <T> The activity on with the popup shows
  */
@@ -100,8 +89,6 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
     private final float mShortcutHeight;
 
     private BubbleTextView mOriginalIcon;
-    private int mNumNotifications;
-    private NotificationContainer mNotificationContainer;
     private int mContainerWidth;
 
     private ViewGroup mWidgetContainer;
@@ -144,22 +131,9 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
         if (ev.getAction() == MotionEvent.ACTION_DOWN) {
             mInterceptTouchDown.set(ev.getX(), ev.getY());
         }
-        if (mNotificationContainer != null
-                && mNotificationContainer.onInterceptSwipeEvent(ev)) {
-            return true;
-        }
-        // Stop sending touch events to deep shortcut views if user moved beyond touch
-        // slop.
-        return squaredHypot(mInterceptTouchDown.x - ev.getX(),
-                mInterceptTouchDown.y - ev.getY()) > squaredTouchSlop(getContext());
-    }
-
-    @Override
-    public boolean onTouchEvent(MotionEvent ev) {
-        if (mNotificationContainer != null) {
-            return mNotificationContainer.onSwipeEvent(ev) || super.onTouchEvent(ev);
-        }
-        return super.onTouchEvent(ev);
+        // Stop sending touch events to deep shortcut views if user moved beyond touch slop.
+        return squaredHypot(mInterceptTouchDown.x - ev.getX(), mInterceptTouchDown.y - ev.getY())
+                > squaredTouchSlop(getContext());
     }
 
     @Override
@@ -197,14 +171,6 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
         return false;
     }
 
-    @Override
-    protected void setChildColor(View view, int color, AnimatorSet animatorSetOut) {
-        super.setChildColor(view, color, animatorSetOut);
-        if (view.getId() == R.id.notification_container && mNotificationContainer != null) {
-            mNotificationContainer.updateBackgroundColor(color, animatorSetOut);
-        }
-    }
-
     /**
      * Returns true if we can show the container.
      *
@@ -216,9 +182,8 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
     }
 
     /**
-     * Shows the notifications and deep shortcuts associated with a Launcher
-     * {@param icon}.
-     * 
+     * Shows a popup with shortcuts associated with a Launcher icon
+     * @param icon the app icon to show the popup for
      * @return the container if shown or null.
      */
     public static PopupContainerWithArrow<Launcher> showForIcon(BubbleTextView icon) {
@@ -240,189 +205,87 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
                 .map(s -> s.getShortcut(launcher, item, icon))
                 .filter(Objects::nonNull)
                 .collect(Collectors.toList());
-        if (FeatureFlags.showMaterialUPopup(launcher)) {
-            container = (PopupContainerWithArrow) launcher.getLayoutInflater().inflate(
-                    R.layout.popup_container_material_u, launcher.getDragLayer(), false);
-            container.configureForLauncher(launcher);
-            container.populateAndShowRowsMaterialU(icon, deepShortcutCount, systemShortcuts);
-        } else {
-            container = (PopupContainerWithArrow) launcher.getLayoutInflater().inflate(
-                    R.layout.popup_container, launcher.getDragLayer(), false);
-            container.configureForLauncher(launcher);
-            container.populateAndShow(
-                    icon,
-                    deepShortcutCount,
-                    popupDataProvider.getNotificationKeysForItem(item),
-                    systemShortcuts);
-        }
+        container = (PopupContainerWithArrow) launcher.getLayoutInflater().inflate(
+                R.layout.popup_container, launcher.getDragLayer(), false);
+        container.configureForLauncher(launcher, item);
+        container.populateAndShowRows(icon, deepShortcutCount, systemShortcuts);
         launcher.refreshAndBindWidgetsForPackageUser(PackageUserKey.fromItemInfo(item));
         container.requestFocus();
         return container;
     }
 
-    private void configureForLauncher(Launcher launcher) {
+    private void configureForLauncher(Launcher launcher, ItemInfo itemInfo) {
         addOnAttachStateChangeListener(new LauncherPopupLiveUpdateHandler(
                 launcher, (PopupContainerWithArrow<Launcher>) this));
-        mPopupItemDragHandler = new LauncherPopupItemDragHandler(launcher, this);
+        if (!Flags.privateSpaceRestrictItemDrag()
+                || !(itemInfo instanceof ItemInfoWithIcon itemInfoWithIcon)
+                || (itemInfoWithIcon.runtimeStatusFlags & FLAG_NOT_PINNABLE) == 0) {
+            mPopupItemDragHandler = new LauncherPopupItemDragHandler(launcher, this);
+        }
         mAccessibilityDelegate = new ShortcutMenuAccessibilityDelegate(launcher);
         launcher.getDragController().addDragListener(this);
     }
 
-    private void initializeSystemShortcuts(List<SystemShortcut> shortcuts) {
-        if (shortcuts.isEmpty()) {
-            return;
-        }
-        // If there is only 1 shortcut, add it to its own container so it can show text
-        // and icon
-        if (shortcuts.size() == 1) {
-            mSystemShortcutContainer = inflateAndAdd(R.layout.system_shortcut_rows_container,
-                    this, 0);
-            initializeSystemShortcut(R.layout.system_shortcut, mSystemShortcutContainer,
-                    shortcuts.get(0), false);
-            return;
-        }
-        addSystemShortcutsIconsOnly(shortcuts);
-    }
-
-    @TargetApi(Build.VERSION_CODES.P)
-    public void populateAndShow(final BubbleTextView originalIcon, int shortcutCount,
-            final List<NotificationKeyData> notificationKeys, List<SystemShortcut> shortcuts) {
-        mNumNotifications = notificationKeys.size();
-        mOriginalIcon = originalIcon;
-
-        boolean hasDeepShortcuts = shortcutCount > 0;
-        mContainerWidth = getResources().getDimensionPixelSize(R.dimen.bg_popup_item_width);
-
-        // Add views
-        if (mNumNotifications > 0) {
-            // Add notification entries
-            if (mNotificationContainer == null) {
-                mNotificationContainer = findViewById(R.id.notification_container);
-                mNotificationContainer.setVisibility(VISIBLE);
-                mNotificationContainer.setPopupView(this);
-            } else {
-                mNotificationContainer.setVisibility(GONE);
-            }
-            updateNotificationHeader();
-        }
-        mSystemShortcutContainer = this;
-        if (mDeepShortcutContainer == null) {
-            mDeepShortcutContainer = findViewById(R.id.deep_shortcuts_container);
-        }
-        if (hasDeepShortcuts) {
-            List<SystemShortcut> systemShortcuts = getNonWidgetSystemShortcuts(shortcuts);
-            // if there are deep shortcuts, we might want to increase the width of shortcuts
-            // to fit
-            // horizontally laid out system shortcuts.
-            mContainerWidth = Math.max(mContainerWidth,
-                    systemShortcuts.size() * getResources()
-                            .getDimensionPixelSize(R.dimen.system_shortcut_header_icon_touch_size));
-
-            mDeepShortcutContainer.setVisibility(View.VISIBLE);
-
-            for (int i = shortcutCount; i > 0; i--) {
-                DeepShortcutView v = inflateAndAdd(R.layout.deep_shortcut, mDeepShortcutContainer);
-                v.getLayoutParams().width = mContainerWidth;
-                mDeepShortcuts.add(v);
-            }
-            updateHiddenShortcuts();
-            Optional<SystemShortcut.Widgets> widgetShortcutOpt = getWidgetShortcut(shortcuts);
-            if (widgetShortcutOpt.isPresent()) {
-                if (mWidgetContainer == null) {
-                    mWidgetContainer = inflateAndAdd(R.layout.widget_shortcut_container, this, 0);
-                }
-                initializeWidgetShortcut(mWidgetContainer, widgetShortcutOpt.get());
-            }
-
-            initializeSystemShortcuts(systemShortcuts);
-        } else {
-            mDeepShortcutContainer.setVisibility(View.GONE);
-            mSystemShortcutContainer = inflateAndAdd(R.layout.system_shortcut_rows_container,
-                    this, 0);
-            mWidgetContainer = mSystemShortcutContainer;
-            if (!shortcuts.isEmpty()) {
-                for (int i = 0; i < shortcuts.size(); i++) {
-                    initializeSystemShortcut(
-                            R.layout.system_shortcut,
-                            mSystemShortcutContainer,
-                            shortcuts.get(i),
-                            i < shortcuts.size() - 1);
-                }
-            }
-        }
-        show();
-        loadAppShortcuts((ItemInfo) originalIcon.getTag(), notificationKeys);
-    }
-
     /**
      * Populate and show shortcuts for the Launcher U app shortcut design.
-     * Will inflate the container and shortcut View instances for the popup
-     * container.
-     * 
-     * @param originalIcon      App icon that the popup is shown for
-     * @param deepShortcutCount Number of DeepShortcutView instances to add to
-     *                          container
-     * @param systemShortcuts   List of SystemShortcuts to add to container
+     * Will inflate the container and shortcut View instances for the popup container.
+     * @param originalIcon App icon that the popup is shown for
+     * @param deepShortcutCount Number of DeepShortcutView instances to add to container
+     * @param systemShortcuts List of SystemShortcuts to add to container
      */
-    public void populateAndShowRowsMaterialU(final BubbleTextView originalIcon,
-            int deepShortcutCount, List<SystemShortcut> systemShortcuts) {
+    public void populateAndShowRows(final BubbleTextView originalIcon,
+                                    int deepShortcutCount, List<SystemShortcut> systemShortcuts) {
 
         mOriginalIcon = originalIcon;
         mContainerWidth = getResources().getDimensionPixelSize(R.dimen.bg_popup_item_width);
 
         if (deepShortcutCount > 0) {
-            addAllShortcutsMaterialU(deepShortcutCount, systemShortcuts);
+            addAllShortcuts(deepShortcutCount, systemShortcuts);
         } else if (!systemShortcuts.isEmpty()) {
-            addSystemShortcutsMaterialU(systemShortcuts,
-                    R.layout.system_shortcut_rows_container_material_u,
+            addSystemShortcuts(systemShortcuts,
+                    R.layout.system_shortcut_rows_container,
                     R.layout.system_shortcut);
         }
         show();
-        loadAppShortcuts((ItemInfo) originalIcon.getTag(), /* notificationKeys= */ emptyList());
+        loadAppShortcuts((ItemInfo) originalIcon.getTag());
     }
 
     /**
      * Animates and loads shortcuts on background thread for this popup container
      */
-    private void loadAppShortcuts(ItemInfo originalItemInfo,
-            List<NotificationKeyData> notificationKeys) {
-
-        if (ATLEAST_P) {
-            setAccessibilityPaneTitle(getTitleForAccessibility());
-        }
+    private void loadAppShortcuts(ItemInfo originalItemInfo) {
+        setAccessibilityPaneTitle(getTitleForAccessibility());
         mOriginalIcon.setForceHideDot(true);
         // All views are added. Animate layout from now on.
         setLayoutTransition(new LayoutTransition());
-        // Load the shortcuts on a background thread and update the container as it
-        // animates.
+        // Load the shortcuts on a background thread and update the container as it animates.
         MODEL_EXECUTOR.getHandler().postAtFrontOfQueue(PopupPopulator.createUpdateRunnable(
                 mActivityContext, originalItemInfo, new Handler(Looper.getMainLooper()),
-                this, mDeepShortcuts, notificationKeys));
+                this, mDeepShortcuts));
     }
 
     /**
-     * Adds any Deep Shortcuts, System Shortcuts and the Widget Shortcut to their
-     * respective
+     * Adds any Deep Shortcuts, System Shortcuts and the Widget Shortcut to their respective
      * containers
-     * 
      * @param deepShortcutCount number of DeepShortcutView instances
-     * @param systemShortcuts   List of SystemShortcuts
+     * @param systemShortcuts List of SystemShortcuts
      */
-    private void addAllShortcutsMaterialU(int deepShortcutCount,
-            List<SystemShortcut> systemShortcuts) {
+    private void addAllShortcuts(int deepShortcutCount,
+                                 List<SystemShortcut> systemShortcuts) {
         if (deepShortcutCount + systemShortcuts.size() <= SHORTCUT_COLLAPSE_THRESHOLD) {
             // add all system shortcuts including widgets shortcut to same container
-            addSystemShortcutsMaterialU(systemShortcuts,
-                    R.layout.system_shortcut_rows_container_material_u,
+            addSystemShortcuts(systemShortcuts,
+                    R.layout.system_shortcut_rows_container,
                     R.layout.system_shortcut);
             float currentHeight = (mShortcutHeight * systemShortcuts.size())
                     + mChildContainerMargin;
-            addDeepShortcutsMaterialU(deepShortcutCount, currentHeight);
+            addDeepShortcuts(deepShortcutCount, currentHeight);
             return;
         }
 
         float currentHeight = mShortcutHeight + mChildContainerMargin;
-        List<SystemShortcut> nonWidgetSystemShortcuts = getNonWidgetSystemShortcuts(systemShortcuts);
+        List<SystemShortcut> nonWidgetSystemShortcuts =
+                getNonWidgetSystemShortcuts(systemShortcuts);
         // If total shortcuts over threshold, collapse system shortcuts to single row
         addSystemShortcutsIconsOnly(nonWidgetSystemShortcuts);
         // May need to recalculate row width
@@ -437,12 +300,11 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
             initializeWidgetShortcut(mWidgetContainer, widgetShortcutOpt.get());
             currentHeight += mShortcutHeight + mChildContainerMargin;
         }
-        addDeepShortcutsMaterialU(deepShortcutCount, currentHeight);
+        addDeepShortcuts(deepShortcutCount, currentHeight);
     }
 
     /**
      * Finds the first instance of the Widgets Shortcut from the SystemShortcut List
-     * 
      * @param systemShortcuts List of SystemShortcut instances to search
      * @return Optional Widgets SystemShortcut
      */
@@ -456,9 +318,7 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
     }
 
     /**
-     * Returns list of [systemShortcuts] without the Widgets shortcut instance if
-     * found
-     * 
+     * Returns list of [systemShortcuts] without the Widgets shortcut instance if found
      * @param systemShortcuts list of SystemShortcuts to filter from
      * @return systemShortcuts without the Widgets Shortcut
      */
@@ -472,19 +332,14 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
     }
 
     /**
-     * Inflates the given systemShortcutContainerLayout as a container, and
-     * populates with
+     * Inflates the given systemShortcutContainerLayout as a container, and populates with
      * the systemShortcuts as views using the systemShortcutLayout
-     * 
-     * @param systemShortcuts               List of SystemShortcut to inflate as
-     *                                      Views
-     * @param systemShortcutContainerLayout Layout Resource for the Container of
-     *                                      shortcut Views
-     * @param systemShortcutLayout          Layout Resource for the individual
-     *                                      shortcut Views
+     * @param systemShortcuts List of SystemShortcut to inflate as Views
+     * @param systemShortcutContainerLayout Layout Resource for the Container of shortcut Views
+     * @param systemShortcutLayout Layout Resource for the individual shortcut Views
      */
-    private void addSystemShortcutsMaterialU(List<SystemShortcut> systemShortcuts,
-            @LayoutRes int systemShortcutContainerLayout, @LayoutRes int systemShortcutLayout) {
+    private void addSystemShortcuts(List<SystemShortcut> systemShortcuts,
+                                    @LayoutRes int systemShortcutContainerLayout, @LayoutRes int systemShortcutLayout) {
 
         if (systemShortcuts.size() == 0) {
             return;
@@ -505,13 +360,10 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
             return;
         }
 
-        mSystemShortcutContainer = FeatureFlags.showMaterialUPopup(getContext())
-                ? inflateAndAdd(R.layout.system_shortcut_icons_container_material_u, this)
-                : inflateAndAdd(R.layout.system_shortcut_icons_container, this, 0);
+        mSystemShortcutContainer = inflateAndAdd(R.layout.system_shortcut_icons_container, this);
 
         for (int i = 0; i < systemShortcuts.size(); i++) {
-            @LayoutRes
-            int shortcutIconLayout = R.layout.system_shortcut_icon_only;
+            @LayoutRes int shortcutIconLayout = R.layout.system_shortcut_icon_only;
             boolean shouldAppendSpacer = true;
 
             if (i == 0) {
@@ -529,20 +381,17 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
     }
 
     /**
-     * Inflates and adds [deepShortcutCount] number of DeepShortcutView for the to a
-     * new container
-     * 
+     * Inflates and adds [deepShortcutCount] number of DeepShortcutView for the  to a new container
      * @param deepShortcutCount number of DeepShortcutView instances to add
-     * @param currentHeight     height of popup before adding deep shortcuts
+     * @param currentHeight height of popup before adding deep shortcuts
      */
-    private void addDeepShortcutsMaterialU(int deepShortcutCount, float currentHeight) {
+    private void addDeepShortcuts(int deepShortcutCount, float currentHeight) {
         mDeepShortcutContainer = inflateAndAdd(R.layout.deep_shortcut_container, this);
         for (int i = deepShortcutCount; i > 0; i--) {
             currentHeight += mShortcutHeight;
             // when there is limited vertical screen space, limit total popup rows to fit
-            if (currentHeight >= mActivityContext.getDeviceProfile().availableHeightPx)
-                break;
-            DeepShortcutView v = inflateAndAdd(R.layout.deep_shortcut_material_u,
+            if (currentHeight >= mActivityContext.getDeviceProfile().availableHeightPx) break;
+            DeepShortcutView v = inflateAndAdd(R.layout.deep_shortcut,
                     mDeepShortcutContainer);
             v.getLayoutParams().width = mContainerWidth;
             mDeepShortcuts.add(v);
@@ -550,10 +399,6 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
         updateHiddenShortcuts();
     }
 
-    protected NotificationContainer getNotificationContainer() {
-        return mNotificationContainer;
-    }
-
     protected BubbleTextView getOriginalIcon() {
         return mOriginalIcon;
     }
@@ -571,8 +416,7 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
     }
 
     private String getTitleForAccessibility() {
-        return getContext().getString(mNumNotifications == 0 ? R.string.action_deep_shortcut
-                : R.string.shortcuts_menu_with_notifications_description);
+        return getContext().getString(R.string.action_deep_shortcut);
     }
 
     @Override
@@ -586,21 +430,11 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
                 : mOriginalIcon.getHeight());
     }
 
-    public void applyNotificationInfos(List<NotificationInfo> notificationInfos) {
-        if (mNotificationContainer != null) {
-            mNotificationContainer.applyNotificationInfos(notificationInfos);
-        }
-    }
-
     protected void updateHiddenShortcuts() {
-        int allowedCount = mNotificationContainer != null
-                ? MAX_SHORTCUTS_IF_NOTIFICATIONS
-                : MAX_SHORTCUTS;
-
         int total = mDeepShortcuts.size();
         for (int i = 0; i < total; i++) {
             DeepShortcutView view = mDeepShortcuts.get(i);
-            view.setVisibility(i >= allowedCount ? GONE : VISIBLE);
+            view.setVisibility(i >= MAX_SHORTCUTS ? GONE : VISIBLE);
         }
     }
 
@@ -611,19 +445,16 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
 
     /**
      * Initializes and adds View for given SystemShortcut to a container.
-     * 
-     * @param resId              Resource id to use for SystemShortcut View.
-     * @param container          ViewGroup to add the shortcut View to as a parent
-     * @param info               The SystemShortcut instance to create a View for.
-     * @param shouldAppendSpacer If True, will add a spacer after the shortcut, when
-     *                           showing the
-     *                           SystemShortcut as an icon only. Used to space the
-     *                           shortcut icons
-     *                           evenly.
+     * @param resId Resource id to use for SystemShortcut View.
+     * @param container ViewGroup to add the shortcut View to as a parent
+     * @param info The SystemShortcut instance to create a View for.
+     * @param shouldAppendSpacer If True, will add a spacer after the shortcut, when showing the
+     *                        SystemShortcut as an icon only. Used to space the shortcut icons
+     *                        evenly.
      * @return The view inflated for the SystemShortcut
      */
     protected View initializeSystemShortcut(int resId, ViewGroup container, SystemShortcut info,
-            boolean shouldAppendSpacer) {
+                                            boolean shouldAppendSpacer) {
         View view = inflateAndAdd(resId, container);
         if (view instanceof DeepShortcutView) {
             // System shortcut takes entire row with icon and text
@@ -632,8 +463,7 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
         } else if (view instanceof ImageView) {
             // System shortcut is just an icon
             info.setIconAndContentDescriptionFor((ImageView) view);
-            if (shouldAppendSpacer)
-                inflateAndAdd(R.layout.system_shortcut_spacer, container);
+            if (shouldAppendSpacer) inflateAndAdd(R.layout.system_shortcut_spacer, container);
             view.setTooltipText(view.getContentDescription());
         }
         view.setTag(info);
@@ -645,8 +475,7 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
      * Determines when the deferred drag should be started.
      *
      * Current behavior:
-     * - Start the drag if the touch passes a certain distance from the original
-     * touch down.
+     * - Start the drag if the touch passes a certain distance from the original touch down.
      */
     public DragOptions.PreDragCondition createPreDragCondition(boolean updateIconUi) {
         return new DragOptions.PreDragCondition() {
@@ -682,8 +511,8 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
                     mOriginalIcon.setVisibility(INVISIBLE);
                 } else {
                     // TODO: add WW logging if want to add logging for long press on popup
-                    // container.
-                    // mLauncher.getUserEventDispatcher().logDeepShortcutsOpen(mOriginalIcon);
+                    //  container.
+                    //  mLauncher.getUserEventDispatcher().logDeepShortcutsOpen(mOriginalIcon);
                     if (!mIsAboveIcon) {
                         // Show the icon but keep the text hidden.
                         mOriginalIcon.setVisibility(VISIBLE);
@@ -694,23 +523,13 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
         };
     }
 
-    protected void updateNotificationHeader() {
-        ItemInfoWithIcon itemInfo = (ItemInfoWithIcon) mOriginalIcon.getTag();
-        DotInfo dotInfo = mActivityContext.getDotInfoForItem(itemInfo);
-        if (mNotificationContainer != null && dotInfo != null) {
-            mNotificationContainer.updateHeader(dotInfo.getNotificationCount());
-        }
-    }
-
     @Override
-    public void onDropCompleted(View target, DragObject d, boolean success) {
-    }
+    public void onDropCompleted(View target, DragObject d, boolean success) {  }
 
     @Override
     public void onDragStart(DropTarget.DragObject dragObject, DragOptions options) {
         // Either the original icon or one of the shortcuts was dragged.
-        // Hide the container, but don't remove it yet because that interferes with
-        // touch events.
+        // Hide the container, but don't remove it yet because that interferes with touch events.
         mDeferContainerRemoval = true;
         animateClose();
     }
@@ -771,8 +590,7 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
     /**
      * Handler to control drag-and-drop for popup items
      */
-    public interface PopupItemDragHandler extends OnLongClickListener, OnTouchListener {
-    }
+    public interface PopupItemDragHandler extends OnLongClickListener, OnTouchListener { }
 
     /**
      * Drag and drop handler for popup items in Launcher activity
@@ -803,11 +621,9 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
 
         @Override
         public boolean onLongClick(View v) {
-            if (!ItemLongClickListener.canStartDrag(mLauncher))
-                return false;
+            if (!ItemLongClickListener.canStartDrag(mLauncher)) return false;
             // Return early if not the correct view
-            if (!(v.getParent() instanceof DeepShortcutView))
-                return false;
+            if (!(v.getParent() instanceof DeepShortcutView)) return false;
 
             // Long clicked on a shortcut.
             DeepShortcutView sv = (DeepShortcutView) v.getParent();
@@ -825,8 +641,6 @@ public class PopupContainerWithArrow<T extends Context & ActivityContext>
                     mContainer, itemInfo,
                     new ShortcutDragPreviewProvider(sv.getIconView(), iconShift),
                     new DragOptions());
-            // Don't handle shortcuts dropping after home screen locked.
-            if (dv == null) return false;
             dv.animateShift(-iconShift.x, -iconShift.y);
 
             // TODO: support dragging from within folder without having to close it
diff --git a/src/com/android/launcher3/provider/RestoreDbTask.java b/src/com/android/launcher3/provider/RestoreDbTask.java
index 4c9bbfeb32..47ce39e409 100644
--- a/src/com/android/launcher3/provider/RestoreDbTask.java
+++ b/src/com/android/launcher3/provider/RestoreDbTask.java
@@ -18,7 +18,7 @@ package com.android.launcher3.provider;
 
 import static android.os.Process.myUserHandle;
 
-import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.BuildConfigs.WIDGETS_ENABLED;
 import static com.android.launcher3.Flags.enableLauncherBrMetricsFixed;
 import static com.android.launcher3.InvariantDeviceProfile.TYPE_MULTI_DISPLAY;
 import static com.android.launcher3.LauncherPrefs.APP_WIDGET_IDS;
diff --git a/src/com/android/launcher3/secondarydisplay/SecondaryDragLayer.java b/src/com/android/launcher3/secondarydisplay/SecondaryDragLayer.java
index 2ecfec06ee..c36c9c9b59 100644
--- a/src/com/android/launcher3/secondarydisplay/SecondaryDragLayer.java
+++ b/src/com/android/launcher3/secondarydisplay/SecondaryDragLayer.java
@@ -64,8 +64,8 @@ public class SecondaryDragLayer extends BaseDragLayer<SecondaryDisplayLauncher>
 
     @Override
     public void recreateControllers() {
-        mControllers = new TouchController[] { new CloseAllAppsTouchController(),
-                mActivity.getDragController() };
+        mControllers = new TouchController[]{new CloseAllAppsTouchController(),
+                mActivity.getDragController()};
     }
 
     /**
@@ -119,12 +119,15 @@ public class SecondaryDragLayer extends BaseDragLayer<SecondaryDisplayLauncher>
             if (child == mAppsView) {
                 int horizontalPadding = (2 * grid.desiredWorkspaceHorizontalMarginPx)
                         + grid.cellLayoutPaddingPx.left + grid.cellLayoutPaddingPx.right;
-                int verticalPadding = grid.cellLayoutPaddingPx.top + grid.cellLayoutPaddingPx.bottom;
+                int verticalPadding =
+                        grid.cellLayoutPaddingPx.top + grid.cellLayoutPaddingPx.bottom;
 
-                int maxWidth = grid.allAppsCellWidthPx * grid.numShownAllAppsColumns + horizontalPadding;
+                int maxWidth =
+                        grid.allAppsCellWidthPx * grid.numShownAllAppsColumns + horizontalPadding;
                 int appsWidth = Math.min(width - getPaddingLeft() - getPaddingRight(), maxWidth);
 
-                int maxHeight = grid.allAppsCellHeightPx * grid.numShownAllAppsColumns + verticalPadding;
+                int maxHeight =
+                        grid.allAppsCellHeightPx * grid.numShownAllAppsColumns + verticalPadding;
                 int appsHeight = Math.min(height - getPaddingTop() - getPaddingBottom(), maxHeight);
 
                 mAppsView.measure(
@@ -198,20 +201,10 @@ public class SecondaryDragLayer extends BaseDragLayer<SecondaryDisplayLauncher>
         }
         int deepShortcutCount = popupDataProvider.getShortcutCountForItem(item);
         final PopupContainerWithArrow<SecondaryDisplayLauncher> container;
-        if (FeatureFlags.showMaterialUPopup(getContext())) {
-            container = (PopupContainerWithArrow) mActivity.getLayoutInflater().inflate(
-                    R.layout.popup_container_material_u, mActivity.getDragLayer(), false);
-            container.populateAndShowRowsMaterialU((BubbleTextView) v, deepShortcutCount,
-                    systemShortcuts);
-        } else {
-            container = (PopupContainerWithArrow) mActivity.getLayoutInflater().inflate(
-                    R.layout.popup_container, mActivity.getDragLayer(), false);
-            container.populateAndShow(
-                    (BubbleTextView) v,
-                    deepShortcutCount,
-                    Collections.emptyList(),
-                    systemShortcuts);
-        }
+        container = (PopupContainerWithArrow) mActivity.getLayoutInflater().inflate(
+                R.layout.popup_container, mActivity.getDragLayer(), false);
+        container.populateAndShowRows((BubbleTextView) v, deepShortcutCount,
+                systemShortcuts);
         container.requestFocus();
 
         if (!FeatureFlags.SECONDARY_DRAG_N_DROP_TO_PIN.get() || !mActivity.isAppDrawerShown()) {
@@ -235,8 +228,8 @@ public class SecondaryDragLayer extends BaseDragLayer<SecondaryDisplayLauncher>
                 public void onPreDragStart(DropTarget.DragObject dragObject) {
                     mDragView = dragObject.dragView;
                     if (!shouldStartDrag(0)) {
-                        mDragView.setOnScaleAnimEndCallback(
-                                () -> mActivity.beginDragShared(v, mActivity.getAppsView(), options));
+                        mDragView.setOnScaleAnimEndCallback(() ->
+                                mActivity.beginDragShared(v, mActivity.getAppsView(), options));
                     }
                 }
 
@@ -249,4 +242,4 @@ public class SecondaryDragLayer extends BaseDragLayer<SecondaryDisplayLauncher>
         mActivity.beginDragShared(v, mActivity.getAppsView(), options);
         return true;
     }
-}
+}
\ No newline at end of file
diff --git a/src/com/android/launcher3/settings/SettingsActivity.java b/src/com/android/launcher3/settings/SettingsActivity.java
index b584c06734..315231546c 100644
--- a/src/com/android/launcher3/settings/SettingsActivity.java
+++ b/src/com/android/launcher3/settings/SettingsActivity.java
@@ -20,8 +20,8 @@ import static android.provider.Settings.Global.DEVELOPMENT_SETTINGS_ENABLED;
 
 import static androidx.preference.PreferenceFragmentCompat.ARG_PREFERENCE_ROOT;
 
-import static com.android.launcher3.BuildConfig.IS_DEBUG_DEVICE;
-import static com.android.launcher3.BuildConfig.IS_STUDIO_BUILD;
+import static com.android.launcher3.BuildConfigs.IS_DEBUG_DEVICE;
+import static com.android.launcher3.BuildConfigs.IS_STUDIO_BUILD;
 import static com.android.launcher3.states.RotationHelper.ALLOW_ROTATION_PREFERENCE_KEY;
 
 import android.app.Activity;
@@ -49,6 +49,7 @@ import androidx.preference.PreferenceScreen;
 import androidx.recyclerview.widget.RecyclerView;
 
 import com.android.launcher3.BuildConfig;
+import com.android.launcher3.BuildConfigs;
 import com.android.launcher3.LauncherFiles;
 import com.android.launcher3.R;
 import com.android.launcher3.states.RotationHelper;
@@ -68,6 +69,7 @@ public class SettingsActivity extends FragmentActivity
     private static final String NOTIFICATION_DOTS_PREFERENCE_KEY = "pref_icon_badging";
 
     public static final String EXTRA_FRAGMENT_ARGS = ":settings:fragment_args";
+    public static final String EXTRA_SHOW_FRAGMENT_ARGS = ":settings:show_fragment_args";
 
     // Intent extra to indicate the pref-key to highlighted when opening the
     // settings activity
@@ -173,7 +175,7 @@ public class SettingsActivity extends FragmentActivity
 
         @Override
         public void onCreate(@Nullable Bundle savedInstanceState) {
-            if (BuildConfig.IS_DEBUG_DEVICE) {
+            if (BuildConfigs.IS_DEBUG_DEVICE) {
                 Uri devUri = Settings.Global.getUriFor(DEVELOPMENT_SETTINGS_ENABLED);
                 SettingsCache settingsCache = SettingsCache.INSTANCE.get(getContext());
                 mDeveloperOptionsEnabled = settingsCache.getValue(devUri);
@@ -239,7 +241,7 @@ public class SettingsActivity extends FragmentActivity
         protected boolean initPreference(Preference preference) {
             switch (preference.getKey()) {
                 case NOTIFICATION_DOTS_PREFERENCE_KEY:
-                    return BuildConfig.NOTIFICATION_DOTS_ENABLED;
+                    return BuildConfigs.NOTIFICATION_DOTS_ENABLED;
 
                 case ALLOW_ROTATION_PREFERENCE_KEY:
                     DisplayController.Info info = DisplayController.INSTANCE.get(getContext()).getInfo();
diff --git a/src/com/android/launcher3/shortcuts/DeepShortcutTextView.java b/src/com/android/launcher3/shortcuts/DeepShortcutTextView.java
index 79723bef9d..4aaa7ff8bf 100644
--- a/src/com/android/launcher3/shortcuts/DeepShortcutTextView.java
+++ b/src/com/android/launcher3/shortcuts/DeepShortcutTextView.java
@@ -26,24 +26,12 @@ import android.util.AttributeSet;
 import com.android.launcher3.BubbleTextView;
 import com.android.launcher3.R;
 import com.android.launcher3.Utilities;
-import com.patrykmichalik.opto.core.PreferenceExtensionsKt;
-
-import app.lawnchair.preferences2.PreferenceManager2;
 
 /**
- * A {@link BubbleTextView} that has the shortcut icon on the left and drag
- * handle on the right.
+ * A {@link BubbleTextView} that has the shortcut icon on the left and drag handle on the right.
  */
 public class DeepShortcutTextView extends BubbleTextView {
 
-    private final PreferenceManager2 mPreferenceManager2 = PreferenceManager2.getInstance(getContext());
-
-    private final Rect mDragHandleBounds = new Rect();
-    private int mDragHandleWidth;
-    private boolean mShowInstructionToast = false;
-
-    private Toast mInstructionToast;
-
     private boolean mShowLoadingState;
     private Drawable mLoadingStatePlaceholder;
     private final Rect mLoadingStateBounds = new Rect();
@@ -61,17 +49,6 @@ public class DeepShortcutTextView extends BubbleTextView {
         showLoadingState(true);
     }
 
-    @Override
-    protected void onFinishInflate() {
-        super.onFinishInflate();
-
-        if (PreferenceExtensionsKt.firstBlocking(mPreferenceManager2.getLockHomeScreen())) {
-            setCompoundDrawables(null, null, null, null);
-            mDragHandleWidth = 0;
-            mDragHandleBounds.set(0, 0, 0, 0);
-        }
-    }
-
     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
@@ -90,7 +67,8 @@ public class DeepShortcutTextView extends BubbleTextView {
         mLoadingStateBounds.offset(
                 Utilities.isRtl(getResources()) ? getPaddingEnd() : getPaddingStart(),
                 (int) ((getMeasuredHeight() - mLoadingStatePlaceholder.getIntrinsicHeight())
-                        / 2.0f));
+                        / 2.0f)
+        );
         mLoadingStatePlaceholder.setBounds(mLoadingStateBounds);
     }
 
@@ -126,10 +104,8 @@ public class DeepShortcutTextView extends BubbleTextView {
 
     @Override
     protected void drawDotIfNecessary(Canvas canvas) {
-        // This view (with the text label to the side of the icon) is not designed for a
-        // dot to be
-        // drawn on top of it, so never draw one even if a notification for this
-        // shortcut exists.
+        // This view (with the text label to the side of the icon) is not designed for a dot to be
+        // drawn on top of it, so never draw one even if a notification for this shortcut exists.
     }
 
     private void showLoadingState(boolean loading) {
@@ -149,4 +125,4 @@ public class DeepShortcutTextView extends BubbleTextView {
 
         invalidate();
     }
-}
+}
\ No newline at end of file
diff --git a/src/com/android/launcher3/shortcuts/ShortcutRequest.java b/src/com/android/launcher3/shortcuts/ShortcutRequest.java
index 015d54dd85..a8014202bd 100644
--- a/src/com/android/launcher3/shortcuts/ShortcutRequest.java
+++ b/src/com/android/launcher3/shortcuts/ShortcutRequest.java
@@ -16,7 +16,7 @@
 
 package com.android.launcher3.shortcuts;
 
-import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.BuildConfigs.WIDGETS_ENABLED;
 
 import android.content.ComponentName;
 import android.content.Context;
diff --git a/src/com/android/launcher3/testing/shared/TestProtocol.java b/src/com/android/launcher3/testing/shared/TestProtocol.java
new file mode 100644
index 0000000000..59d0de69ee
--- /dev/null
+++ b/src/com/android/launcher3/testing/shared/TestProtocol.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.launcher3.testing.shared;
+
+import android.util.Log;
+
+/**
+ * Protocol for custom accessibility events for communication with UI Automation tests.
+ */
+public final class TestProtocol {
+    public static final String STATE_FIELD = "state";
+    public static final String SWITCHED_TO_STATE_MESSAGE = "TAPL_SWITCHED_TO_STATE";
+    public static final String SCROLL_FINISHED_MESSAGE = "TAPL_SCROLL_FINISHED";
+    public static final String PAUSE_DETECTED_MESSAGE = "TAPL_PAUSE_DETECTED";
+    public static final String DISMISS_ANIMATION_ENDS_MESSAGE = "TAPL_DISMISS_ANIMATION_ENDS";
+    public static final String FOLDER_OPENED_MESSAGE = "TAPL_FOLDER_OPENED";
+    public static final String SEARCH_RESULT_COMPLETE = "SEARCH_RESULT_COMPLETE";
+    public static final String LAUNCHER_ACTIVITY_STOPPED_MESSAGE = "TAPL_LAUNCHER_ACTIVITY_STOPPED";
+    public static final String WALLPAPER_OPEN_ANIMATION_FINISHED_MESSAGE =
+            "TAPL_WALLPAPER_OPEN_ANIMATION_FINISHED";
+    public static final int NORMAL_STATE_ORDINAL = 0;
+    public static final int SPRING_LOADED_STATE_ORDINAL = 1;
+    public static final int OVERVIEW_STATE_ORDINAL = 2;
+    public static final int OVERVIEW_MODAL_TASK_STATE_ORDINAL = 3;
+    public static final int QUICK_SWITCH_STATE_ORDINAL = 4;
+    public static final int ALL_APPS_STATE_ORDINAL = 5;
+    public static final int BACKGROUND_APP_STATE_ORDINAL = 6;
+    public static final int HINT_STATE_ORDINAL = 7;
+    public static final int HINT_STATE_TWO_BUTTON_ORDINAL = 8;
+    public static final int OVERVIEW_SPLIT_SELECT_ORDINAL = 9;
+    public static final int EDIT_MODE_STATE_ORDINAL = 10;
+    public static final String SEQUENCE_MAIN = "Main";
+    public static final String SEQUENCE_TIS = "TIS";
+    public static final String SEQUENCE_PILFER = "Pilfer";
+
+    public static String stateOrdinalToString(int ordinal) {
+        switch (ordinal) {
+            case NORMAL_STATE_ORDINAL:
+                return "Normal";
+            case SPRING_LOADED_STATE_ORDINAL:
+                return "SpringLoaded";
+            case OVERVIEW_STATE_ORDINAL:
+                return "Overview";
+            case OVERVIEW_MODAL_TASK_STATE_ORDINAL:
+                return "OverviewModal";
+            case QUICK_SWITCH_STATE_ORDINAL:
+                return "QuickSwitch";
+            case ALL_APPS_STATE_ORDINAL:
+                return "AllApps";
+            case BACKGROUND_APP_STATE_ORDINAL:
+                return "Background";
+            case HINT_STATE_ORDINAL:
+                return "Hint";
+            case HINT_STATE_TWO_BUTTON_ORDINAL:
+                return "Hint2Button";
+            case OVERVIEW_SPLIT_SELECT_ORDINAL:
+                return "OverviewSplitSelect";
+            case EDIT_MODE_STATE_ORDINAL:
+                return "EditMode";
+            default:
+                return "Unknown";
+        }
+    }
+
+    public static final String TEST_INFO_REQUEST_FIELD = "request";
+    public static final String TEST_INFO_RESPONSE_FIELD = "response";
+
+    public static final String REQUEST_HOME_TO_OVERVIEW_SWIPE_HEIGHT =
+            "home-to-overview-swipe-height";
+    public static final String REQUEST_BACKGROUND_TO_OVERVIEW_SWIPE_HEIGHT =
+            "background-to-overview-swipe-height";
+    public static final String REQUEST_HOME_TO_ALL_APPS_SWIPE_HEIGHT =
+            "home-to-all-apps-swipe-height";
+    public static final String REQUEST_ICON_HEIGHT =
+            "icon-height";
+    public static final String REQUEST_IS_LAUNCHER_INITIALIZED = "is-launcher-initialized";
+    public static final String REQUEST_IS_LAUNCHER_LAUNCHER_ACTIVITY_STARTED =
+            "is-launcher-activity-started";
+    public static final String REQUEST_FREEZE_APP_LIST = "freeze-app-list";
+    public static final String REQUEST_UNFREEZE_APP_LIST = "unfreeze-app-list";
+    public static final String REQUEST_ENABLE_BLOCK_TIMEOUT = "enable-block-timeout";
+    public static final String REQUEST_DISABLE_BLOCK_TIMEOUT = "disable-block-timeout";
+    public static final String REQUEST_ENABLE_TRANSIENT_TASKBAR = "enable-transient-taskbar";
+    public static final String REQUEST_DISABLE_TRANSIENT_TASKBAR = "disable-transient-taskbar";
+    public static final String REQUEST_IS_TRANSIENT_TASKBAR = "is-transient-taskbar";
+    public static final String REQUEST_UNSTASH_TASKBAR_IF_STASHED = "unstash-taskbar-if-stashed";
+    public static final String REQUEST_TASKBAR_FROM_NAV_THRESHOLD = "taskbar-from-nav-threshold";
+    public static final String REQUEST_STASHED_TASKBAR_SCALE = "taskbar-stash-handle-scale";
+    public static final String REQUEST_RECREATE_TASKBAR = "recreate-taskbar";
+    public static final String REQUEST_TASKBAR_IME_DOCKED = "taskbar-ime-docked";
+    public static final String REQUEST_APP_LIST_FREEZE_FLAGS = "app-list-freeze-flags";
+    public static final String REQUEST_APPS_LIST_SCROLL_Y = "apps-list-scroll-y";
+    public static final String REQUEST_TASKBAR_APPS_LIST_SCROLL_Y = "taskbar-apps-list-scroll-y";
+    public static final String REQUEST_WIDGETS_SCROLL_Y = "widgets-scroll-y";
+    public static final String REQUEST_TARGET_INSETS = "target-insets";
+    public static final String REQUEST_WINDOW_INSETS = "window-insets";
+    public static final String REQUEST_SYSTEM_GESTURE_REGION = "gesture-region";
+    public static final String REQUEST_PID = "pid";
+    public static final String REQUEST_FORCE_GC = "gc";
+    public static final String REQUEST_RECENT_TASKS_LIST = "recent-tasks-list";
+    public static final String REQUEST_START_EVENT_LOGGING = "start-event-logging";
+    public static final String REQUEST_GET_TEST_EVENTS = "get-test-events";
+    public static final String REQUEST_GET_HAD_NONTEST_EVENTS = "get-had-nontest-events";
+    public static final String REQUEST_STOP_EVENT_LOGGING = "stop-event-logging";
+    public static final String REQUEST_REINITIALIZE_DATA = "reinitialize-data";
+    public static final String REQUEST_CLEAR_DATA = "clear-data";
+    public static final String REQUEST_HOTSEAT_ICON_NAMES = "get-hotseat-icon-names";
+    public static final String REQUEST_IS_TABLET = "is-tablet";
+    public static final String REQUEST_IS_PREDICTIVE_BACK_SWIPE_ENABLED =
+            "is-predictive-back-swipe-enabled";
+    public static final String REQUEST_ENABLE_TASKBAR_NAVBAR_UNIFICATION =
+            "enable-taskbar-navbar-unification";
+    public static final String REQUEST_NUM_ALL_APPS_COLUMNS = "num-all-apps-columns";
+    public static final String REQUEST_IS_TWO_PANELS = "is-two-panel";
+    public static final String REQUEST_CELL_LAYOUT_BOARDER_HEIGHT = "cell-layout-boarder-height";
+    public static final String REQUEST_START_DRAG_THRESHOLD = "start-drag-threshold";
+    public static final String REQUEST_SHELL_DRAG_READY = "shell-drag-ready";
+    public static final String REQUEST_GET_ACTIVITIES_CREATED_COUNT =
+            "get-activities-created-count";
+    public static final String REQUEST_GET_ACTIVITIES = "get-activities";
+    public static final String REQUEST_HAS_TIS = "has-touch-interaction-service";
+    public static final String REQUEST_TASKBAR_ALL_APPS_TOP_PADDING =
+            "taskbar-all-apps-top-padding";
+    public static final String REQUEST_ALL_APPS_TOP_PADDING = "all-apps-top-padding";
+    public static final String REQUEST_ALL_APPS_BOTTOM_PADDING = "all-apps-bottom-padding";
+    public static final String REQUEST_REFRESH_OVERVIEW_TARGET = "refresh-overview-target";
+
+    public static final String REQUEST_WORKSPACE_CELL_LAYOUT_SIZE = "workspace-cell-layout-size";
+    public static final String REQUEST_WORKSPACE_CELL_CENTER = "workspace-cell-center";
+    public static final String REQUEST_WORKSPACE_COLUMNS_ROWS = "workspace-columns-rows";
+
+    public static final String REQUEST_WORKSPACE_CURRENT_PAGE_INDEX =
+            "workspace-current-page-index";
+
+    public static final String REQUEST_HOTSEAT_CELL_CENTER = "hotseat-cell-center";
+
+    public static final String REQUEST_GET_FOCUSED_TASK_HEIGHT_FOR_TABLET =
+            "get-focused-task-height-for-tablet";
+    public static final String REQUEST_GET_GRID_TASK_SIZE_RECT_FOR_TABLET =
+            "get-grid-task-size-rect-for-tablet";
+    public static final String REQUEST_GET_OVERVIEW_PAGE_SPACING = "get-overview-page-spacing";
+    public static final String REQUEST_GET_OVERVIEW_CURRENT_PAGE_INDEX =
+            "get-overview-current-page-index";
+    public static final String REQUEST_GET_SPLIT_SELECTION_ACTIVE = "get-split-selection-active";
+    public static final String REQUEST_ENABLE_ROTATION = "enable_rotation";
+    public static final String REQUEST_ENABLE_SUGGESTION = "enable-suggestion";
+    public static final String REQUEST_MODEL_QUEUE_CLEARED = "model-queue-cleared";
+
+    public static boolean sDebugTracing = false;
+    public static final String REQUEST_ENABLE_DEBUG_TRACING = "enable-debug-tracing";
+    public static final String REQUEST_DISABLE_DEBUG_TRACING = "disable-debug-tracing";
+
+
+    public static boolean sDisableSensorRotation;
+    public static final String REQUEST_MOCK_SENSOR_ROTATION = "mock-sensor-rotation";
+
+    public static final String PERMANENT_DIAG_TAG = "TaplTarget";
+    public static final String ICON_MISSING = "b/282963545";
+    public static final String UIOBJECT_STALE_ELEMENT = "b/319501259";
+    public static final String TEST_DRAG_APP_ICON_TO_MULTIPLE_WORKSPACES_FAILURE = "b/326908466";
+    public static final String WIDGET_CONFIG_NULL_EXTRA_INTENT = "b/324419890";
+    public static final String OVERVIEW_SELECT_TOOLTIP_MISALIGNED = "b/332485341";
+
+    public static final String REQUEST_FLAG_ENABLE_GRID_ONLY_OVERVIEW = "enable-grid-only-overview";
+    public static final String REQUEST_FLAG_ENABLE_APP_PAIRS = "enable-app-pairs";
+
+    public static final String REQUEST_UNSTASH_BUBBLE_BAR_IF_STASHED =
+            "unstash-bubble-bar-if-stashed";
+
+    public static final String REQUEST_INJECT_FAKE_TRACKPAD = "inject-fake-trackpad";
+    public static final String REQUEST_EJECT_FAKE_TRACKPAD = "eject-fake-trackpad";
+
+    /** Logs {@link Log#d(String, String)} if {@link #sDebugTracing} is true. */
+    public static void testLogD(String tag, String message) {
+        if (!sDebugTracing) {
+            return;
+        }
+        Log.d(tag, message);
+    }
+}
diff --git a/src/com/android/launcher3/util/ApiWrapper.java b/src/com/android/launcher3/util/ApiWrapper.java
index 095518c8ea..24d1b6e49b 100644
--- a/src/com/android/launcher3/util/ApiWrapper.java
+++ b/src/com/android/launcher3/util/ApiWrapper.java
@@ -60,7 +60,7 @@ public class ApiWrapper implements ResourceBasedOverride, SafeCloseable {
     /**
      * Returns the list of persons associated with the provided shortcut info
      */
-    public Person[] getPersons(ShortcutInfo si) {
+    public static Person[] getPersons(ShortcutInfo si) {
         return Utilities.EMPTY_PERSON_ARRAY;
     }
 
diff --git a/src/com/android/launcher3/util/EdgeEffectCompat.java b/src/com/android/launcher3/util/EdgeEffectCompat.java
index dff0922cb8..2dade2e508 100644
--- a/src/com/android/launcher3/util/EdgeEffectCompat.java
+++ b/src/com/android/launcher3/util/EdgeEffectCompat.java
@@ -17,6 +17,7 @@ package com.android.launcher3.util;
 
 import android.content.Context;
 import android.view.MotionEvent;
+import android.view.View;
 import android.widget.EdgeEffect;
 
 import com.android.launcher3.Utilities;
@@ -47,6 +48,16 @@ public class EdgeEffectCompat extends EdgeEffect {
         }
     }
 
+    public float onPullDistance(float deltaDistance, float displacement, MotionEvent ev) {
+        return onPullDistance(deltaDistance, displacement);
+    }
+
+    public void onFlingVelocity(int velocity) { }
+
+    public void onRelease(MotionEvent ev) {
+        onRelease();
+    }
+
     public static EdgeEffectCompat create(Context context, View view) {
         if (Utilities.ATLEAST_S) {
             return new EdgeEffectCompat(context);
diff --git a/src/com/android/launcher3/util/MainThreadInitializedObject.java b/src/com/android/launcher3/util/MainThreadInitializedObject.java
index 84dcb739df..d2b1f4f328 100644
--- a/src/com/android/launcher3/util/MainThreadInitializedObject.java
+++ b/src/com/android/launcher3/util/MainThreadInitializedObject.java
@@ -31,7 +31,9 @@ import com.android.launcher3.util.ResourceBasedOverride.Overrides;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 
@@ -130,8 +132,8 @@ public class MainThreadInitializedObject<T extends SafeCloseable> {
 
         private static final String TAG = "SandboxContext";
 
-        private final Map<MainThreadInitializedObject, Object> mObjectMap = new HashMap<>();
-        private final ArrayList<SafeCloseable> mOrderedObjects = new ArrayList<>();
+        public final Map<MainThreadInitializedObject, Object> mObjectMap = new HashMap<>();
+        public final ArrayList<SafeCloseable> mOrderedObjects = new ArrayList<>();
 
         private final Object mDestroyLock = new Object();
         private boolean mDestroyed = false;
diff --git a/src/com/android/launcher3/util/OverlayEdgeEffect.java b/src/com/android/launcher3/util/OverlayEdgeEffect.java
index d09d801d66..0b6066bb01 100644
--- a/src/com/android/launcher3/util/OverlayEdgeEffect.java
+++ b/src/com/android/launcher3/util/OverlayEdgeEffect.java
@@ -22,6 +22,7 @@ import android.view.MotionEvent;
 import android.widget.EdgeEffect;
 
 import com.android.launcher3.BuildConfig;
+import com.android.launcher3.BuildConfigs;
 import com.android.launcher3.Utilities;
 import com.android.systemui.plugins.shared.LauncherOverlayManager.LauncherOverlayTouchProxy;
 
@@ -48,7 +49,7 @@ public class OverlayEdgeEffect extends EdgeEffectCompat {
 
     public float onPullDistance(float deltaDistance, float displacement) {
         // Fallback implementation, will never actually get called
-        if (BuildConfig.IS_DEBUG_DEVICE) {
+        if (BuildConfigs.IS_DEBUG_DEVICE) {
             throw new RuntimeException("Wrong method called");
         }
         MotionEvent mv = MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(),
@@ -85,7 +86,7 @@ public class OverlayEdgeEffect extends EdgeEffectCompat {
     @Override
     public void onRelease() {
         // Fallback implementation, will never actually get called
-        if (BuildConfig.IS_DEBUG_DEVICE) {
+        if (BuildConfigs.IS_DEBUG_DEVICE) {
             throw new RuntimeException("Wrong method called");
         }
         MotionEvent mv = MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(),
diff --git a/src/com/android/launcher3/util/PackageManagerHelper.java b/src/com/android/launcher3/util/PackageManagerHelper.java
index 81e4a23633..c2154fbd3a 100644
--- a/src/com/android/launcher3/util/PackageManagerHelper.java
+++ b/src/com/android/launcher3/util/PackageManagerHelper.java
@@ -20,6 +20,7 @@ import static android.view.WindowManager.PROPERTY_SUPPORTS_MULTI_INSTANCE_SYSTEM
 
 import static com.android.launcher3.model.data.ItemInfoWithIcon.FLAG_INSTALL_SESSION_ACTIVE;
 
+import android.annotation.SuppressLint;
 import android.content.ActivityNotFoundException;
 import android.content.ComponentName;
 import android.content.Context;
@@ -32,6 +33,7 @@ import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.content.pm.ResolveInfo;
 import android.graphics.Rect;
+import android.net.Uri;
 import android.os.Bundle;
 import android.os.Process;
 import android.os.UserHandle;
@@ -52,6 +54,7 @@ import com.android.launcher3.model.data.ItemInfoWithIcon;
 import com.android.launcher3.model.data.LauncherAppWidgetInfo;
 import com.android.launcher3.model.data.WorkspaceItemInfo;
 
+import java.net.URISyntaxException;
 import java.util.List;
 import java.util.Objects;
 
@@ -156,6 +159,7 @@ public class PackageManagerHelper implements SafeCloseable {
     /**
      * Returns the installing app package for the given package
      */
+    @SuppressLint("NewApi")
     public String getAppInstallerPackage(@NonNull final String packageName) {
         try {
             return mPm.getInstallSourceInfo(packageName).getInstallingPackageName();
@@ -246,13 +250,12 @@ public class PackageManagerHelper implements SafeCloseable {
     /**
      * Starts the details activity for {@code info}
      */
-    public void startDetailsActivityForInfo(ItemInfo info, Rect sourceBounds, Bundle opts) {
-        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()));
+    public static void startDetailsActivityForInfo(Context context, ItemInfo info,
+                                                   Rect sourceBounds, Bundle opts) {
+        if (info instanceof ItemInfoWithIcon appInfo
+                && (appInfo.runtimeStatusFlags & FLAG_INSTALL_SESSION_ACTIVE) != 0) {
+            context.startActivity(ApiWrapper.INSTANCE.get(context).getAppMarketActivityIntent(
+                    appInfo.getTargetComponent().getPackageName(), Process.myUserHandle()));
             return;
         }
         ComponentName componentName = null;
diff --git a/src/com/android/launcher3/util/ShortcutUtil.java b/src/com/android/launcher3/util/ShortcutUtil.java
index 07b7941036..2130dbfd8d 100644
--- a/src/com/android/launcher3/util/ShortcutUtil.java
+++ b/src/com/android/launcher3/util/ShortcutUtil.java
@@ -15,7 +15,7 @@
  */
 package com.android.launcher3.util;
 
-import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.BuildConfigs.WIDGETS_ENABLED;
 
 import com.android.launcher3.LauncherSettings;
 import com.android.launcher3.Utilities;
diff --git a/src/com/android/launcher3/views/AbstractSlideInView.java b/src/com/android/launcher3/views/AbstractSlideInView.java
index a697b65bb8..711dbbbe7a 100644
--- a/src/com/android/launcher3/views/AbstractSlideInView.java
+++ b/src/com/android/launcher3/views/AbstractSlideInView.java
@@ -302,14 +302,14 @@ public abstract class AbstractSlideInView<T extends Context & ActivityContext>
         return true;
     }
 
-    @Override
+//    @Override
     @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
     public void onBackStarted(BackEvent backEvent) {
-        super.onBackStarted(backEvent);
+        super.onBackStarted();
         mViewToAnimateInSwipeToDismiss = shouldAnimateContentViewInBackSwipe() ? mContent : this;
     }
 
-    @Override
+//    @Override
     @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
     public void onBackProgressed(BackEvent backEvent) {
         final float progress = backEvent.getProgress();
diff --git a/src/com/android/launcher3/views/ActivityContext.java b/src/com/android/launcher3/views/ActivityContext.java
index b1f628a778..9f454abeb9 100644
--- a/src/com/android/launcher3/views/ActivityContext.java
+++ b/src/com/android/launcher3/views/ActivityContext.java
@@ -17,9 +17,10 @@ package com.android.launcher3.views;
 
 import static android.window.SplashScreen.SPLASH_SCREEN_STYLE_SOLID_COLOR;
 
-import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.BuildConfigs.WIDGETS_ENABLED;
 import static com.android.launcher3.LauncherSettings.Animation.DEFAULT_NO_ICON;
 import static com.android.launcher3.Utilities.allowBGLaunch;
+import static com.android.launcher3.logging.KeyboardStateManager.KeyboardState.HIDE;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_ALLAPPS_KEYBOARD_CLOSED;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_APP_LAUNCH_PENDING_INTENT;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCHER_APP_LAUNCH_TAP;
diff --git a/src/com/android/launcher3/views/FloatingIconView.java b/src/com/android/launcher3/views/FloatingIconView.java
index 6580771200..cca2719ea4 100644
--- a/src/com/android/launcher3/views/FloatingIconView.java
+++ b/src/com/android/launcher3/views/FloatingIconView.java
@@ -64,8 +64,7 @@ import com.android.launcher3.shortcuts.DeepShortcutView;
 import java.util.function.Supplier;
 
 /**
- * A view that is created to look like another view with the purpose of creating
- * fluid animations.
+ * A view that is created to look like another view with the purpose of creating fluid animations.
  */
 public class FloatingIconView extends FrameLayout implements
         Animator.AnimatorListener, OnGlobalLayoutListener, FloatingView {
@@ -150,37 +149,28 @@ public class FloatingIconView extends FrameLayout implements
      * Positions this view to match the size and location of {@code rect}.
      */
     public void update(float alpha, RectF rect, float progress, float shapeProgressStart,
-            float cornerRadius, boolean isOpening) {
+                       float cornerRadius, boolean isOpening) {
         update(alpha, rect, progress, shapeProgressStart, cornerRadius, isOpening, 0);
     }
 
     /**
      * Positions this view to match the size and location of {@code rect}.
      * <p>
-     * 
-     * @param alpha              The alpha[0, 1] of the entire floating view.
-     * @param progress           A value from [0, 1] that represents the animation
-     *                           progress.
-     * @param shapeProgressStart The progress value at which to start the shape
-     *                           reveal.
-     * @param cornerRadius       The corner radius of {@code rect}.
-     * @param isOpening          True if view is used for app open animation, false
-     *                           for app close animation.
-     * @param taskViewDrawAlpha  the drawn
-     *                           {@link com.android.quickstep.views.TaskView} alpha
+     * @param alpha The alpha[0, 1] of the entire floating view.
+     * @param progress A value from [0, 1] that represents the animation progress.
+     * @param shapeProgressStart The progress value at which to start the shape reveal.
+     * @param cornerRadius The corner radius of {@code rect}.
+     * @param isOpening True if view is used for app open animation, false for app close animation.
+     * @param taskViewDrawAlpha the drawn {@link com.android.quickstep.views.TaskView} alpha
      */
     public void update(float alpha, RectF rect, float progress, float shapeProgressStart,
-            float cornerRadius, boolean isOpening, int taskViewDrawAlpha) {
-        // The non-running task home animation has some very funky first few frames
-        // because this
-        // FIV hasn't fully laid out. During those frames, hide this FIV and continue
-        // drawing the
-        // TaskView directly while transforming it in the place of this FIV. However, if
-        // we fade
+                       float cornerRadius, boolean isOpening, int taskViewDrawAlpha) {
+        // The non-running task home animation has some very funky first few frames because this
+        // FIV hasn't fully laid out. During those frames, hide this FIV and continue drawing the
+        // TaskView directly while transforming it in the place of this FIV. However, if we fade
         // the TaskView at all, we need to display this FIV regardless.
         setAlpha(!enableAdditionalHomeAnimations() || isLaidOut() || taskViewDrawAlpha < 255
-                ? alpha
-                : 0f);
+                ? alpha : 0f);
         mClipIconView.update(rect, progress, shapeProgressStart, cornerRadius, isOpening, this,
                 mLauncher.getDeviceProfile(), taskViewDrawAlpha);
 
@@ -192,8 +182,7 @@ public class FloatingIconView extends FrameLayout implements
 
     /**
      * Sets a {@link com.android.quickstep.views.TaskView} that will draw a
-     * {@link com.android.quickstep.views.TaskView} within the {@code mClipIconView}
-     * clip bounds
+     * {@link com.android.quickstep.views.TaskView} within the {@code mClipIconView} clip bounds
      */
     public void setOverlayArtist(ClipIconView.TaskViewArtist taskViewArtist) {
         mClipIconView.setTaskViewArtist(taskViewArtist);
@@ -215,8 +204,7 @@ public class FloatingIconView extends FrameLayout implements
     /**
      * Sets the size and position of this view to match {@code v}.
      * <p>
-     * 
-     * @param v           The view to copy
+     * @param v The view to copy
      * @param positionOut Rect that will hold the size and position of v.
      */
     private void matchPositionOf(Launcher launcher, View v, boolean isOpening, RectF positionOut) {
@@ -228,8 +216,7 @@ public class FloatingIconView extends FrameLayout implements
         setLayoutParams(lp);
 
         // For code simplicity, we always layout the child views using Gravity.LEFT
-        // and manually handle RTL for FloatingIconView when positioning it on the
-        // screen.
+        // and manually handle RTL for FloatingIconView when positioning it on the screen.
         mClipIconView.setLayoutParams(new FrameLayout.LayoutParams(lp.width, lp.height, LEFT));
         mBtvDrawable.setLayoutParams(new FrameLayout.LayoutParams(lp.width, lp.height, LEFT));
     }
@@ -244,8 +231,7 @@ public class FloatingIconView extends FrameLayout implements
         } else {
             lp.setMarginStart(Math.round(pos.left));
         }
-        // Set the properties here already to make sure they are available when running
-        // the first
+        // Set the properties here already to make sure they are available when running the first
         // animation frame.
         int left = mIsRtl
                 ? mLauncher.getDeviceProfile().widthPx - lp.getMarginStart() - lp.width
@@ -254,7 +240,7 @@ public class FloatingIconView extends FrameLayout implements
     }
 
     private static void getLocationBoundsForView(Launcher launcher, View v, boolean isOpening,
-            RectF outRect) {
+                                                 RectF outRect) {
         getLocationBoundsForView(launcher, v, isOpening, outRect, new Rect());
     }
 
@@ -264,7 +250,7 @@ public class FloatingIconView extends FrameLayout implements
      * - For BubbleTextView, we return the icon bounds.
      */
     public static void getLocationBoundsForView(Launcher launcher, View v, boolean isOpening,
-            RectF outRect, Rect outViewBounds) {
+                                                RectF outRect, Rect outViewBounds) {
         boolean ignoreTransform = !isOpening;
         if (v instanceof BubbleTextHolder) {
             v = ((BubbleTextHolder) v).getBubbleText();
@@ -286,31 +272,26 @@ public class FloatingIconView extends FrameLayout implements
         }
 
         Utilities.getBoundsForViewInDragLayer(launcher.getDragLayer(), v, outViewBounds,
-                ignoreTransform, null /** recycle */
-                , outRect);
+                ignoreTransform, null /** recycle */, outRect);
     }
 
     /**
      * Loads the icon and saves the results to {@link #sIconLoadResult}.
      * <p>
-     * Runs onIconLoaded callback (if any), which signifies that the
-     * FloatingIconView is
-     * ready to display the icon. Otherwise, the FloatingIconView will grab the
-     * results when its
+     * Runs onIconLoaded callback (if any), which signifies that the FloatingIconView is
+     * ready to display the icon. Otherwise, the FloatingIconView will grab the results when its
      * initialized.
      * <p>
-     * 
-     * @param originalView      The View that the FloatingIconView will replace.
-     * @param info              ItemInfo of the originalView
-     * @param pos               The position of the view.
-     * @param btvIcon           The drawable of the BubbleTextView. May be null if
-     *                          original view is not a BTV
+     * @param originalView The View that the FloatingIconView will replace.
+     * @param info ItemInfo of the originalView
+     * @param pos The position of the view.
+     * @param btvIcon The drawable of the BubbleTextView. May be null if original view is not a BTV
      * @param outIconLoadResult We store the icon results into this object.
      */
     @WorkerThread
     @SuppressWarnings("WrongThread")
     private static void getIconResult(Launcher l, View originalView, ItemInfo info, RectF pos,
-            @Nullable Drawable btvIcon, IconLoadResult outIconLoadResult) {
+                                      @Nullable Drawable btvIcon, IconLoadResult outIconLoadResult) {
         Drawable drawable;
         boolean supportsAdaptiveIcons = !info.isDisabled(); // Use original icon for disabled icons.
 
@@ -333,16 +314,16 @@ public class FloatingIconView extends FrameLayout implements
             int height = (int) pos.height();
             Pair<AdaptiveIconDrawable, Drawable> fullIcon = null;
             if (supportsAdaptiveIcons) {
-                boolean useTheme = originalView instanceof BubbleTextView
-                        && ((BubbleTextView) originalView).shouldUseTheme();
-                drawable = getFullDrawable(l, info, width, height, tmpObjArray, useTheme);
-                if (drawable instanceof AdaptiveIconDrawable) {
-                    badge = getBadge(l, info, tmpObjArray[0], outIsIconThemed[0]);
-                } else {
-                    // The drawable we get back is not an adaptive icon, so we need to use the
-                    // BubbleTextView icon that is already legacy treated.
-                    drawable = btvIcon;
-                }
+                boolean shouldThemeIcon = (btvIcon instanceof FastBitmapDrawable fbd)
+                        && fbd.isCreatedForTheme();
+                fullIcon = getFullDrawable(l, info, width, height, shouldThemeIcon);
+            } else if (!(originalView instanceof BubbleTextView)) {
+                fullIcon = getFullDrawable(l, info, width, height, true /* shouldThemeIcon */);
+            }
+
+            if (fullIcon != null) {
+                drawable = fullIcon.first;
+                badge = fullIcon.second;
             } else {
                 drawable = btvIcon;
             }
@@ -369,17 +350,16 @@ public class FloatingIconView extends FrameLayout implements
     /**
      * Sets the drawables of the {@code originalView} onto this view.
      * <p>
-     * 
-     * @param drawable   The drawable of the original view.
-     * @param badge      The badge of the original view.
-     * @param iconOffset The amount of offset needed to match this view with the
-     *                   original view.
+     * @param drawable The drawable of the original view.
+     * @param badge The badge of the original view.
+     * @param iconOffset The amount of offset needed to match this view with the original view.
      */
     @UiThread
     private void setIcon(@Nullable Drawable drawable, @Nullable Drawable badge,
-            @Nullable Supplier<Drawable> btvIcon, int iconOffset) {
+                         @Nullable Supplier<Drawable> btvIcon, int iconOffset) {
         final DeviceProfile dp = mLauncher.getDeviceProfile();
-        final InsettableFrameLayout.LayoutParams lp = (InsettableFrameLayout.LayoutParams) getLayoutParams();
+        final InsettableFrameLayout.LayoutParams lp =
+                (InsettableFrameLayout.LayoutParams) getLayoutParams();
         mBadge = badge;
         mClipIconView.setIcon(drawable, iconOffset, lp, mIsOpening, dp);
         if (drawable instanceof AdaptiveIconDrawable) {
@@ -417,8 +397,7 @@ public class FloatingIconView extends FrameLayout implements
      * - Have icon displayed while Adaptive Icon is loading
      * - Displays the built in shadow to ensure a clean handoff
      * <p>
-     * Allows nullable as this may be cleared when drawing is deferred to
-     * ClipIconView.
+     * Allows nullable as this may be cleared when drawing is deferred to ClipIconView.
      */
     private void setOriginalDrawableBackground(@Nullable Supplier<Drawable> btvIcon) {
         if (!mIsOpening) {
@@ -434,8 +413,7 @@ public class FloatingIconView extends FrameLayout implements
     }
 
     /**
-     * Checks if the icon result is loaded. If true, we set the icon immediately.
-     * Else, we add a
+     * Checks if the icon result is loaded. If true, we set the icon immediately. Else, we add a
      * callback to set the icon once the icon result is loaded.
      */
     private void checkIconResult() {
@@ -451,7 +429,7 @@ public class FloatingIconView extends FrameLayout implements
                 setIcon(mIconLoadResult.drawable, mIconLoadResult.badge,
                         mIconLoadResult.btvDrawable, mIconLoadResult.iconOffset);
                 setVisibility(VISIBLE);
-                updateViewsVisibility(false /* isVisible */);
+                updateViewsVisibility(false  /* isVisible */);
             } else {
                 mIconLoadResult.onIconLoaded = () -> {
                     if (cancellationSignal.isCanceled()) {
@@ -462,7 +440,7 @@ public class FloatingIconView extends FrameLayout implements
                             mIconLoadResult.btvDrawable, mIconLoadResult.iconOffset);
 
                     setVisibility(VISIBLE);
-                    updateViewsVisibility(false /* isVisible */);
+                    updateViewsVisibility(false  /* isVisible */);
                 };
                 mLoadIconSignal = cancellationSignal;
             }
@@ -475,7 +453,8 @@ public class FloatingIconView extends FrameLayout implements
         if (!(drawable instanceof AdaptiveIconDrawable)) {
             return 0;
         }
-        int blurSizeOutline = l.getResources().getDimensionPixelSize(R.dimen.blur_size_medium_outline);
+        int blurSizeOutline =
+                l.getResources().getDimensionPixelSize(R.dimen.blur_size_medium_outline);
 
         Rect bounds = new Rect(0, 0, (int) position.width() + blurSizeOutline,
                 (int) position.height() + blurSizeOutline);
@@ -488,7 +467,8 @@ public class FloatingIconView extends FrameLayout implements
 
         bounds.inset(
                 (int) (-bounds.width() * AdaptiveIconDrawable.getExtraInsetFraction()),
-                (int) (-bounds.height() * AdaptiveIconDrawable.getExtraInsetFraction()));
+                (int) (-bounds.height() * AdaptiveIconDrawable.getExtraInsetFraction())
+        );
 
         return bounds.left;
     }
@@ -528,24 +508,20 @@ public class FloatingIconView extends FrameLayout implements
     public void onAnimationStart(Animator animator) {
         if ((mIconLoadResult != null && mIconLoadResult.isIconLoaded)
                 || (!mIsOpening && mBtvDrawable.getBackground() != null)) {
-            // No need to wait for icon load since we can display the BubbleTextView
-            // drawable.
+            // No need to wait for icon load since we can display the BubbleTextView drawable.
             setVisibility(View.VISIBLE);
         }
         if (!mIsOpening) {
-            // When closing an app, we want the item on the workspace to be invisible
-            // immediately
-            updateViewsVisibility(false /* isVisible */);
+            // When closing an app, we want the item on the workspace to be invisible immediately
+            updateViewsVisibility(false  /* isVisible */);
         }
     }
 
     @Override
-    public void onAnimationCancel(Animator animator) {
-    }
+    public void onAnimationCancel(Animator animator) {}
 
     @Override
-    public void onAnimationRepeat(Animator animator) {
-    }
+    public void onAnimationRepeat(Animator animator) {}
 
     @Override
     public void setPositionOffsetY(float y) {
@@ -572,8 +548,7 @@ public class FloatingIconView extends FrameLayout implements
     }
 
     /**
-     * Loads the icon drawable on a worker thread to reduce latency between swapping
-     * views.
+     * Loads the icon drawable on a worker thread to reduce latency between swapping views.
      */
     @UiThread
     public static IconLoadResult fetchIcon(Launcher l, View v, ItemInfo info, boolean isOpening) {
@@ -586,7 +561,7 @@ public class FloatingIconView extends FrameLayout implements
             BubbleTextView btv = (BubbleTextView) v;
             if (info instanceof ItemInfoWithIcon
                     && (((ItemInfoWithIcon) info).runtimeStatusFlags
-                            & ItemInfoWithIcon.FLAG_SHOW_DOWNLOAD_PROGRESS_MASK) != 0) {
+                    & ItemInfoWithIcon.FLAG_SHOW_DOWNLOAD_PROGRESS_MASK) != 0) {
                 btvIcon = btv.makePreloadIcon();
                 btvDrawableSupplier = () -> btvIcon;
             } else {
@@ -615,8 +590,7 @@ public class FloatingIconView extends FrameLayout implements
     }
 
     /**
-     * Resets the static icon load result used for preloading the icon for a
-     * launching app.
+     * Resets the static icon load result used for preloading the icon for a launching app.
      */
     public static void resetIconLoadResult() {
         sIconLoadResult = null;
@@ -625,22 +599,17 @@ public class FloatingIconView extends FrameLayout implements
     /**
      * Creates a floating icon view for {@code originalView}.
      * <p>
-     * 
-     * @param originalView       The view to copy
-     * @param visibilitySyncView A view whose visibility should update in sync with
-     *                           originalView.
-     * @param fadeOutView        A view that will fade out as the animation
-     *                           progresses.
-     * @param hideOriginal       If true, it will hide {@code originalView} while
-     *                           this view is visible.
-     *                           Else, we will not draw anything in this view.
-     * @param positionOut        Rect that will hold the size and position of v.
-     * @param isOpening          True if this view replaces the icon for app open
-     *                           animation.
+     * @param originalView The view to copy
+     * @param visibilitySyncView A view whose visibility should update in sync with originalView.
+     * @param fadeOutView A view that will fade out as the animation progresses.
+     * @param hideOriginal If true, it will hide {@code originalView} while this view is visible.
+     *                     Else, we will not draw anything in this view.
+     * @param positionOut Rect that will hold the size and position of v.
+     * @param isOpening True if this view replaces the icon for app open animation.
      */
     public static FloatingIconView getFloatingIconView(Launcher launcher, View originalView,
-            @Nullable View visibilitySyncView, @Nullable View fadeOutView, boolean hideOriginal,
-            RectF positionOut, boolean isOpening) {
+                                                       @Nullable View visibilitySyncView, @Nullable View fadeOutView, boolean hideOriginal,
+                                                       RectF positionOut, boolean isOpening) {
         final DragLayer dragLayer = launcher.getDragLayer();
         ViewGroup parent = (ViewGroup) dragLayer.getParent();
         FloatingIconView view = launcher.getViewCache().getView(R.layout.floating_icon_view,
@@ -670,8 +639,7 @@ public class FloatingIconView extends FrameLayout implements
         // Match the position of the original view.
         view.matchPositionOf(launcher, originalView, isOpening, positionOut);
 
-        // We need to add it to the overlay, but keep it invisible until animation
-        // starts..
+        // We need to add it to the overlay, but keep it invisible until animation starts..
         view.setVisibility(View.INVISIBLE);
 
         parent.addView(view);
@@ -694,8 +662,7 @@ public class FloatingIconView extends FrameLayout implements
         };
 
         // Must be called after matchPositionOf so that we know what size to load.
-        // Must be called after the fastFinish listener and end runnable is created so
-        // that
+        // Must be called after the fastFinish listener and end runnable is created so that
         // the icon is not left in a hidden state.
         if (shouldLoadIcon) {
             view.checkIconResult();
@@ -763,4 +730,4 @@ public class FloatingIconView extends FrameLayout implements
             this.isThemed = isThemed;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/com/android/launcher3/views/OptionsPopupView.java b/src/com/android/launcher3/views/OptionsPopupView.java
index 65a3f6439e..7d8f95f80b 100644
--- a/src/com/android/launcher3/views/OptionsPopupView.java
+++ b/src/com/android/launcher3/views/OptionsPopupView.java
@@ -17,7 +17,7 @@ package com.android.launcher3.views;
 
 import static androidx.core.content.ContextCompat.getColorStateList;
 
-import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.BuildConfigs.WIDGETS_ENABLED;
 import static com.android.launcher3.LauncherState.EDIT_MODE;
 import static com.android.launcher3.config.FeatureFlags.MULTI_SELECT_EDIT_MODE;
 import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.IGNORE;
@@ -27,6 +27,7 @@ import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCH
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.content.Intent;
+import android.graphics.Color;
 import android.graphics.Rect;
 import android.graphics.RectF;
 import android.graphics.drawable.Drawable;
@@ -233,7 +234,7 @@ public class OptionsPopupView<T extends Context & ActivityContext> extends Arrow
                 R.drawable.ic_palette,
                 IGNORE,
                 OptionsPopupView::startWallpaperPicker));
-        if (!lockHomeScreen && !WidgetsModel.GO_DISABLE_WIDGETS) {
+        if (!lockHomeScreen) {
             options.add(new OptionItem(launcher,
                     R.string.widget_button_text,
                     R.drawable.ic_widget,
diff --git a/src/com/android/launcher3/views/Snackbar.java b/src/com/android/launcher3/views/Snackbar.java
index 10a3e9f2fe..6ecc43f4de 100644
--- a/src/com/android/launcher3/views/Snackbar.java
+++ b/src/com/android/launcher3/views/Snackbar.java
@@ -97,7 +97,7 @@ public class Snackbar extends AbstractFloatingView {
         snackbar.setElevation(res.getDimension(R.dimen.snackbar_elevation));
         int padding = res.getDimensionPixelSize(R.dimen.snackbar_padding);
         snackbar.setPadding(padding, padding, padding, padding);
-        snackbar.setBackground(DrawableTokens.RoundRectPrimary.resolve(activity));
+        snackbar.setBackground(DrawableTokens.RoundRectPrimary.resolve(((Context)activity).getApplicationContext()));
 
         snackbar.mIsOpen = true;
         BaseDragLayer dragLayer = activity.getDragLayer();
@@ -128,8 +128,8 @@ public class Snackbar extends AbstractFloatingView {
         labelView.setText(labelString);
 
         TextView actionView = snackbar.findViewById(R.id.action);
-        labelView.setTextColor(ColorTokens.TextColorPrimary.resolveColor(activity));
-        actionView.setTextColor(ColorTokens.ColorAccent.resolveColor(activity));
+        labelView.setTextColor(ColorTokens.TextColorPrimary.resolveColor(((Context) activity).getApplicationContext()));
+        actionView.setTextColor(ColorTokens.ColorAccent.resolveColor(((Context) activity).getApplicationContext()));
         float actionWidth;
         if (actionStringResId != NO_ID) {
             String actionText = res.getString(actionStringResId);
diff --git a/src/com/android/launcher3/widget/BaseWidgetSheet.java b/src/com/android/launcher3/widget/BaseWidgetSheet.java
index 93f9739fa0..6c9a8f97ec 100644
--- a/src/com/android/launcher3/widget/BaseWidgetSheet.java
+++ b/src/com/android/launcher3/widget/BaseWidgetSheet.java
@@ -48,6 +48,7 @@ import com.android.launcher3.model.WidgetItem;
 import com.android.launcher3.popup.PopupDataProvider;
 import com.android.launcher3.testing.TestLogging;
 import com.android.launcher3.testing.shared.TestProtocol;
+import com.android.launcher3.touch.ItemLongClickListener;
 import com.android.launcher3.util.SystemUiController;
 import com.android.launcher3.util.Themes;
 import com.android.launcher3.util.window.WindowManagerProxy;
@@ -281,7 +282,7 @@ public abstract class BaseWidgetSheet extends AbstractSlideInView<BaseActivity>
     public boolean onLongClick(View v) {
         TestLogging.recordEvent(TestProtocol.SEQUENCE_MAIN, "Widgets.onLongClick");
         v.cancelLongPress();
-        if (!ItemLongClickListener.canStartDrag(mActivityContext))
+        if (!ItemLongClickListener.canStartDrag(Launcher.getLauncher(mActivityContext)))
             return false;
 
         boolean result;
diff --git a/src/com/android/launcher3/widget/DatabaseWidgetPreviewLoader.java b/src/com/android/launcher3/widget/DatabaseWidgetPreviewLoader.java
index f1ef5d1f22..50556f026e 100644
--- a/src/com/android/launcher3/widget/DatabaseWidgetPreviewLoader.java
+++ b/src/com/android/launcher3/widget/DatabaseWidgetPreviewLoader.java
@@ -267,7 +267,7 @@ public class DatabaseWidgetPreviewLoader {
             LauncherIcons li = LauncherIcons.obtain(mContext);
             Drawable icon = li.createBadgedIconBitmap(
                     mutateOnMainThread(info.getFullResIcon(
-                            LauncherAppState.getInstance(mContext).getIconCache())), Process.myUserHandle (), false)
+                            LauncherAppState.getInstance(mContext).getIconCache())))
                     .newIcon(mContext);
             li.recycle();
 
diff --git a/src/com/android/launcher3/widget/LauncherWidgetHolder.java b/src/com/android/launcher3/widget/LauncherWidgetHolder.java
index 54b6cd9453..5d2f0559d0 100644
--- a/src/com/android/launcher3/widget/LauncherWidgetHolder.java
+++ b/src/com/android/launcher3/widget/LauncherWidgetHolder.java
@@ -17,7 +17,7 @@ package com.android.launcher3.widget;
 
 import static android.app.Activity.RESULT_CANCELED;
 
-import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.BuildConfigs.WIDGETS_ENABLED;
 import static com.android.launcher3.Flags.enableWorkspaceInflation;
 import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
 import static com.android.launcher3.widget.LauncherAppWidgetProviderInfo.fromProviderInfo;
diff --git a/src/com/android/launcher3/widget/PendingItemDragHelper.java b/src/com/android/launcher3/widget/PendingItemDragHelper.java
index f0f99d66c8..60ee2878ac 100644
--- a/src/com/android/launcher3/widget/PendingItemDragHelper.java
+++ b/src/com/android/launcher3/widget/PendingItemDragHelper.java
@@ -191,7 +191,7 @@ public class PendingItemDragHelper extends DragPreviewProvider {
                     .getFullResIcon(app.getIconCache());
             LauncherIcons li = LauncherIcons.obtain(launcher);
             preview = new FastBitmapDrawable(
-                    li.createScaledBitmapWithoutShadow(icon, true));
+                    li.createBadgedIconBitmap(icon));
             previewWidth = preview.getIntrinsicWidth();
             previewHeight = preview.getIntrinsicHeight();
             li.recycle();
diff --git a/src/com/android/launcher3/widget/WidgetInflater.kt b/src/com/android/launcher3/widget/WidgetInflater.kt
index 271c9c298e..c14942e921 100644
--- a/src/com/android/launcher3/widget/WidgetInflater.kt
+++ b/src/com/android/launcher3/widget/WidgetInflater.kt
@@ -17,7 +17,7 @@
 package com.android.launcher3.widget
 
 import android.content.Context
-import com.android.launcher3.BuildConfig
+import com.android.launcher3.BuildConfigs
 import com.android.launcher3.Launcher
 import com.android.launcher3.LauncherAppState
 import com.android.launcher3.backuprestore.LauncherRestoreEventLogger.RestoreError
@@ -55,7 +55,7 @@ class WidgetInflater(private val context: Context) {
             // The widget id is not valid. Try to find the widget based on the provider info.
             appWidgetInfo = widgetHelper.findProvider(item.providerName, item.user)
             if (appWidgetInfo == null) {
-                if (!BuildConfig.WIDGETS_ENABLED) {
+                if (!BuildConfigs.WIDGETS_ENABLED) {
                     removalReason = "widgets are disabled on go device."
                     logReason = RestoreError.WIDGETS_DISABLED
                 } else {
diff --git a/src/com/android/launcher3/widget/WidgetManagerHelper.java b/src/com/android/launcher3/widget/WidgetManagerHelper.java
index 9132b4f18c..2897e7aec2 100644
--- a/src/com/android/launcher3/widget/WidgetManagerHelper.java
+++ b/src/com/android/launcher3/widget/WidgetManagerHelper.java
@@ -16,7 +16,7 @@
 
 package com.android.launcher3.widget;
 
-import static com.android.launcher3.BuildConfig.WIDGETS_ENABLED;
+import static com.android.launcher3.BuildConfigs.WIDGETS_ENABLED;
 
 import android.annotation.TargetApi;
 import android.appwidget.AppWidgetManager;
diff --git a/src/com/android/launcher3/widget/picker/WidgetsFullSheet.java b/src/com/android/launcher3/widget/picker/WidgetsFullSheet.java
index 49289a1c36..27fb36624f 100644
--- a/src/com/android/launcher3/widget/picker/WidgetsFullSheet.java
+++ b/src/com/android/launcher3/widget/picker/WidgetsFullSheet.java
@@ -22,6 +22,7 @@ import static com.android.launcher3.logging.StatsLogManager.LauncherEvent.LAUNCH
 import static com.android.launcher3.testing.shared.TestProtocol.NORMAL_STATE_ORDINAL;
 
 import android.animation.Animator;
+import android.annotation.NonNull;
 import android.content.Context;
 import android.content.res.Resources;
 import android.graphics.Rect;
diff --git a/src/com/android/launcher3/widget/picker/WidgetsRecommendationTableLayout.java b/src/com/android/launcher3/widget/picker/WidgetsRecommendationTableLayout.java
index aaab2bf4df..47a98990bc 100644
--- a/src/com/android/launcher3/widget/picker/WidgetsRecommendationTableLayout.java
+++ b/src/com/android/launcher3/widget/picker/WidgetsRecommendationTableLayout.java
@@ -90,9 +90,6 @@ public final class WidgetsRecommendationTableLayout extends TableLayout {
     @Override
     protected void onFinishInflate() {
         super.onFinishInflate();
-
-        var mContent = ViewCompat.requireViewById(this, R.id.recommended_widget_table);
-        mContent.setBackground(DrawableTokens.WidgetsRecommendationBackground.resolve(getContext()));
     }
 
     /**
diff --git a/systemUIAnim/build.gradle b/systemUIAnim/build.gradle
index b54d23b517..6f7c1abd2b 100644
--- a/systemUIAnim/build.gradle
+++ b/systemUIAnim/build.gradle
@@ -22,8 +22,8 @@ addFrameworkJar('framework-15.jar')
 compileOnlyCommonJars()
 
 dependencies {
-    implementation 'androidx.core:core-animation:1.0.0-alpha02'
     implementation 'androidx.core:core-ktx:1.9.0'
+    implementation 'androidx.core:core-animation:1.0.0-alpha02'
     compileOnly projects.animationlib
     compileOnly projects.wmshell
     compileOnly projects.flags
diff --git a/systemUIShared/src/com/android/systemui/shared/system/ActivityManagerWrapper.java b/systemUIShared/src/com/android/systemui/shared/system/ActivityManagerWrapper.java
index 845ca5e8b9..8e4daf6172 100644
--- a/systemUIShared/src/com/android/systemui/shared/system/ActivityManagerWrapper.java
+++ b/systemUIShared/src/com/android/systemui/shared/system/ActivityManagerWrapper.java
@@ -57,6 +57,8 @@ import com.android.systemui.shared.recents.model.ThumbnailData;
 import java.util.List;
 import java.util.function.Consumer;
 
+import app.lawnchair.compat.LawnchairQuickstepCompat;
+
 public class ActivityManagerWrapper {
 
     private static final String TAG = "ActivityManagerWrapper";
@@ -97,6 +99,14 @@ public class ActivityManagerWrapper {
         return getRunningTask(false /* filterVisibleRecents */);
     }
 
+    /**
+     * @return a list of the recents tasks.
+     */
+    @NonNull
+    public List<ActivityManager.RecentTaskInfo> getRecentTasks(int numTasks, int userId) {
+        return LawnchairQuickstepCompat.getActivityManagerCompat().getRecentTasks(numTasks, userId);
+    }
+
     /**
      * @return the top running task filtering only for tasks that can be visible in the recent tasks
      * list (can be {@code null}).
diff --git a/systemUIViewCapture/src/com/android/app/viewcapture/NoOpViewCapture.kt b/systemUIViewCapture/src/com/android/app/viewcapture/NoOpViewCapture.kt
new file mode 100644
index 0000000000..743bdfcadb
--- /dev/null
+++ b/systemUIViewCapture/src/com/android/app/viewcapture/NoOpViewCapture.kt
@@ -0,0 +1,21 @@
+package com.android.app.viewcapture
+
+import android.media.permission.SafeCloseable
+import android.os.HandlerThread
+import android.view.View
+import android.view.Window
+
+/**
+ * We don't want to enable the ViewCapture for release builds, since it currently only serves
+ * 1p apps, and has memory / cpu load that we don't want to risk negatively impacting release builds
+ */
+class NoOpViewCapture: ViewCapture(0, 0,
+    createAndStartNewLooperExecutor("NoOpViewCapture", HandlerThread.MIN_PRIORITY)) {
+    override fun startCapture(view: View, name: String): SafeCloseable {
+        return SafeCloseable { }
+    }
+
+    override fun startCapture(window: Window): SafeCloseable {
+        return SafeCloseable { }
+    }
+}
\ No newline at end of file
diff --git a/systemUIViewCapture/src/com/android/app/viewcapture/PerfettoViewCapture.kt b/systemUIViewCapture/src/com/android/app/viewcapture/PerfettoViewCapture.kt
new file mode 100644
index 0000000000..ec7ef50bc0
--- /dev/null
+++ b/systemUIViewCapture/src/com/android/app/viewcapture/PerfettoViewCapture.kt
@@ -0,0 +1,335 @@
+/*
+ * Copyright (C) 2024 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.app.viewcapture
+
+import android.content.Context
+import android.internal.perfetto.protos.InternedDataOuterClass.InternedData
+import android.internal.perfetto.protos.ProfileCommon.InternedString
+import android.internal.perfetto.protos.TracePacketOuterClass.TracePacket
+import android.internal.perfetto.protos.Viewcapture.ViewCapture as ViewCaptureMessage
+import android.internal.perfetto.protos.WinscopeExtensionsImplOuterClass.WinscopeExtensionsImpl
+import android.os.Trace
+import android.tracing.perfetto.DataSourceParams
+import android.tracing.perfetto.InitArguments
+import android.tracing.perfetto.Producer
+import android.util.proto.ProtoOutputStream
+import androidx.annotation.WorkerThread
+import java.util.concurrent.Executor
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * ViewCapture that listens to Perfetto events (OnStart, OnStop, OnFlush) and continuously writes
+ * captured frames to the Perfetto service (traced).
+ */
+internal class PerfettoViewCapture
+internal constructor(private val context: Context, executor: Executor) :
+    ViewCapture(RING_BUFFER_SIZE, DEFAULT_INIT_POOL_SIZE, executor) {
+
+    private val mDataSource = ViewCaptureDataSource({ onStart() }, {}, { onStop() })
+
+    private val mActiveSessions = AtomicInteger(0)
+
+    private val mViewIdProvider = ViewIdProvider(context.getResources())
+
+    private var mSerializationCurrentId: Int = 0
+    private var mSerializationCurrentView: ViewPropertyRef? = null
+
+    inner class NewInternedStrings {
+        val packageNames = mutableListOf<String>()
+        val windowNames = mutableListOf<String>()
+        val viewIds = mutableListOf<String>()
+        val classNames = mutableListOf<String>()
+    }
+
+    init {
+        enableOrDisableWindowListeners(false)
+
+        Producer.init(InitArguments.DEFAULTS)
+
+        val dataSourceParams =
+            DataSourceParams.Builder()
+                .setBufferExhaustedPolicy(
+                    DataSourceParams.PERFETTO_DS_BUFFER_EXHAUSTED_POLICY_STALL_AND_ABORT
+                )
+                .setNoFlush(true)
+                .setWillNotifyOnStop(false)
+                .build()
+        mDataSource.register(dataSourceParams)
+    }
+
+    fun onStart() {
+        if (mActiveSessions.incrementAndGet() == 1) {
+            enableOrDisableWindowListeners(true)
+        }
+    }
+
+    fun onStop() {
+        if (mActiveSessions.decrementAndGet() == 0) {
+            enableOrDisableWindowListeners(false)
+        }
+    }
+
+    @WorkerThread
+    override fun onCapturedViewPropertiesBg(
+        elapsedRealtimeNanos: Long,
+        windowName: String,
+        startFlattenedTree: ViewPropertyRef
+    ) {
+        Trace.beginSection("vc#onCapturedViewPropertiesBg")
+
+        mDataSource.trace { ctx ->
+            val newInternedStrings = NewInternedStrings()
+            val os = ctx.newTracePacket()
+            os.write(TracePacket.TIMESTAMP, elapsedRealtimeNanos)
+            serializeViews(
+                os,
+                windowName,
+                startFlattenedTree,
+                ctx.incrementalState,
+                newInternedStrings
+            )
+            serializeIncrementalState(os, ctx.incrementalState, newInternedStrings)
+        }
+
+        Trace.endSection()
+    }
+
+    private fun serializeViews(
+        os: ProtoOutputStream,
+        windowName: String,
+        startFlattenedTree: ViewPropertyRef,
+        incrementalState: ViewCaptureDataSource.IncrementalState,
+        newInternedStrings: NewInternedStrings
+    ) {
+        mSerializationCurrentView = startFlattenedTree
+        mSerializationCurrentId = 0
+
+        val tokenExtensions = os.start(TracePacket.WINSCOPE_EXTENSIONS)
+        val tokenViewCapture = os.start(WinscopeExtensionsImpl.VIEWCAPTURE)
+        os.write(
+            ViewCaptureMessage.PACKAGE_NAME_IID,
+            internPackageName(context.packageName, incrementalState, newInternedStrings)
+        )
+        os.write(
+            ViewCaptureMessage.WINDOW_NAME_IID,
+            internWindowName(windowName, incrementalState, newInternedStrings)
+        )
+        serializeViewsRec(os, -1, incrementalState, newInternedStrings)
+        os.end(tokenViewCapture)
+        os.end(tokenExtensions)
+    }
+
+    private fun serializeViewsRec(
+        os: ProtoOutputStream,
+        parentId: Int,
+        incrementalState: ViewCaptureDataSource.IncrementalState,
+        newInternedStrings: NewInternedStrings
+    ) {
+        if (mSerializationCurrentView == null) {
+            return
+        }
+
+        val id = mSerializationCurrentId
+        val childCount = mSerializationCurrentView!!.childCount
+
+        serializeView(
+            os,
+            mSerializationCurrentView!!,
+            mSerializationCurrentId,
+            parentId,
+            incrementalState,
+            newInternedStrings
+        )
+
+        ++mSerializationCurrentId
+        mSerializationCurrentView = mSerializationCurrentView!!.next
+
+        for (i in 0..childCount - 1) {
+            serializeViewsRec(os, id, incrementalState, newInternedStrings)
+        }
+    }
+
+    private fun serializeView(
+        os: ProtoOutputStream,
+        view: ViewPropertyRef,
+        id: Int,
+        parentId: Int,
+        incrementalState: ViewCaptureDataSource.IncrementalState,
+        newInternedStrings: NewInternedStrings
+    ) {
+        val token = os.start(ViewCaptureMessage.VIEWS)
+
+        os.write(ViewCaptureMessage.View.ID, id)
+        os.write(ViewCaptureMessage.View.PARENT_ID, parentId)
+        os.write(ViewCaptureMessage.View.HASHCODE, view.hashCode)
+        os.write(
+            ViewCaptureMessage.View.VIEW_ID_IID,
+            internViewId(mViewIdProvider.getName(view.id), incrementalState, newInternedStrings)
+        )
+        os.write(
+            ViewCaptureMessage.View.CLASS_NAME_IID,
+            internClassName(view.clazz.name, incrementalState, newInternedStrings)
+        )
+
+        os.write(ViewCaptureMessage.View.LEFT, view.left)
+        os.write(ViewCaptureMessage.View.TOP, view.top)
+        os.write(ViewCaptureMessage.View.WIDTH, view.right - view.left)
+        os.write(ViewCaptureMessage.View.HEIGHT, view.bottom - view.top)
+        os.write(ViewCaptureMessage.View.SCROLL_X, view.scrollX)
+        os.write(ViewCaptureMessage.View.SCROLL_Y, view.scrollY)
+
+        os.write(ViewCaptureMessage.View.TRANSLATION_X, view.translateX)
+        os.write(ViewCaptureMessage.View.TRANSLATION_Y, view.translateY)
+        os.write(ViewCaptureMessage.View.SCALE_X, view.scaleX)
+        os.write(ViewCaptureMessage.View.SCALE_Y, view.scaleY)
+        os.write(ViewCaptureMessage.View.ALPHA, view.alpha)
+
+        os.write(ViewCaptureMessage.View.WILL_NOT_DRAW, view.willNotDraw)
+        os.write(ViewCaptureMessage.View.CLIP_CHILDREN, view.clipChildren)
+        os.write(ViewCaptureMessage.View.VISIBILITY, view.visibility)
+
+        os.write(ViewCaptureMessage.View.ELEVATION, view.elevation)
+
+        os.end(token)
+    }
+
+    private fun internClassName(
+        string: String,
+        incrementalState: ViewCaptureDataSource.IncrementalState,
+        newInternedStrings: NewInternedStrings
+    ): Int {
+        return internString(
+            string,
+            incrementalState.mInternMapClassName,
+            newInternedStrings.classNames
+        )
+    }
+
+    private fun internPackageName(
+        string: String,
+        incrementalState: ViewCaptureDataSource.IncrementalState,
+        newInternedStrings: NewInternedStrings
+    ): Int {
+        return internString(
+            string,
+            incrementalState.mInternMapPackageName,
+            newInternedStrings.packageNames
+        )
+    }
+
+    private fun internViewId(
+        string: String,
+        incrementalState: ViewCaptureDataSource.IncrementalState,
+        newInternedStrings: NewInternedStrings
+    ): Int {
+        return internString(string, incrementalState.mInternMapViewId, newInternedStrings.viewIds)
+    }
+
+    private fun internWindowName(
+        string: String,
+        incrementalState: ViewCaptureDataSource.IncrementalState,
+        newInternedStrings: NewInternedStrings
+    ): Int {
+        return internString(
+            string,
+            incrementalState.mInternMapWindowName,
+            newInternedStrings.windowNames
+        )
+    }
+
+    private fun internString(
+        string: String,
+        internMap: MutableMap<String, Int>,
+        newInternedStrings: MutableList<String>
+    ): Int {
+        if (internMap.containsKey(string)) {
+            return internMap[string]!!
+        }
+
+        // +1 to avoid intern ID = 0, because javastream optimizes out zero values
+        // and the perfetto trace processor would not de-intern that string.
+        val internId = internMap.size + 1
+
+        internMap.put(string, internId)
+        newInternedStrings.add(string)
+        return internId
+    }
+
+    private fun serializeIncrementalState(
+        os: ProtoOutputStream,
+        incrementalState: ViewCaptureDataSource.IncrementalState,
+        newInternedStrings: NewInternedStrings
+    ) {
+        var flags = TracePacket.SEQ_NEEDS_INCREMENTAL_STATE
+        if (!incrementalState.mHasNotifiedClearedState) {
+            flags = flags or TracePacket.SEQ_INCREMENTAL_STATE_CLEARED
+            incrementalState.mHasNotifiedClearedState = true
+        }
+        os.write(TracePacket.SEQUENCE_FLAGS, flags)
+
+        val token = os.start(TracePacket.INTERNED_DATA)
+        serializeInternMap(
+            os,
+            InternedData.VIEWCAPTURE_CLASS_NAME,
+            incrementalState.mInternMapClassName,
+            newInternedStrings.classNames
+        )
+        serializeInternMap(
+            os,
+            InternedData.VIEWCAPTURE_PACKAGE_NAME,
+            incrementalState.mInternMapPackageName,
+            newInternedStrings.packageNames
+        )
+        serializeInternMap(
+            os,
+            InternedData.VIEWCAPTURE_VIEW_ID,
+            incrementalState.mInternMapViewId,
+            newInternedStrings.viewIds
+        )
+        serializeInternMap(
+            os,
+            InternedData.VIEWCAPTURE_WINDOW_NAME,
+            incrementalState.mInternMapWindowName,
+            newInternedStrings.windowNames
+        )
+        os.end(token)
+    }
+
+    private fun serializeInternMap(
+        os: ProtoOutputStream,
+        fieldId: Long,
+        map: Map<String, Int>,
+        newInternedStrings: List<String>
+    ) {
+        if (newInternedStrings.isEmpty()) {
+            return
+        }
+
+        var currentInternId = map.size - newInternedStrings.size + 1
+        for (internedString in newInternedStrings) {
+            val token = os.start(fieldId)
+            os.write(InternedString.IID, currentInternId++)
+            os.write(InternedString.STR, internedString.toByteArray())
+            os.end(token)
+        }
+    }
+
+    companion object {
+        // Keep two frames in the base class' ring buffer.
+        // This is the minimum required by the current implementation to work.
+        private val RING_BUFFER_SIZE = 2
+    }
+}
diff --git a/systemUIViewCapture/src/com/android/app/viewcapture/ViewCapture.java b/systemUIViewCapture/src/com/android/app/viewcapture/ViewCapture.java
index bbd797efbf..d74d042029 100644
--- a/systemUIViewCapture/src/com/android/app/viewcapture/ViewCapture.java
+++ b/systemUIViewCapture/src/com/android/app/viewcapture/ViewCapture.java
@@ -19,7 +19,9 @@ package com.android.app.viewcapture;
 import static com.android.app.viewcapture.data.ExportedData.MagicNumber.MAGIC_NUMBER_H;
 import static com.android.app.viewcapture.data.ExportedData.MagicNumber.MAGIC_NUMBER_L;
 
+import android.content.ComponentCallbacks2;
 import android.content.Context;
+import android.content.res.Configuration;
 import android.content.res.Resources;
 import android.media.permission.SafeCloseable;
 import android.os.HandlerThread;
@@ -46,6 +48,7 @@ import com.android.app.viewcapture.data.MotionWindowData;
 import com.android.app.viewcapture.data.ViewNode;
 import com.android.app.viewcapture.data.WindowData;
 
+import java.io.DataOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.ArrayList;
@@ -125,7 +128,7 @@ public abstract class ViewCapture {
      * Attaches the ViewCapture to the provided window and returns a handle to detach the listener
      */
     @NonNull
-    public SafeCloseable startCapture(Window window) {
+    public SafeCloseable startCapture(@NonNull Window window) {
         String title = window.getAttributes().getTitle().toString();
         String name = TextUtils.isEmpty(title) ? window.toString() : title;
         return startCapture(window.getDecorView(), name);
@@ -136,11 +139,16 @@ public abstract class ViewCapture {
      * Verifies that ViewCapture is enabled before actually attaching an onDrawListener.
      */
     @NonNull
-    public SafeCloseable startCapture(View view, String name) {
+    public SafeCloseable startCapture(@NonNull View view, @NonNull String name) {
         WindowListener listener = new WindowListener(view, name);
         if (mIsEnabled) MAIN_EXECUTOR.execute(listener::attachToRoot);
         mListeners.add(listener);
+        view.getContext().registerComponentCallbacks(listener);
+
         return () -> {
+            if (listener.mRoot != null && listener.mRoot.getContext() != null) {
+                listener.mRoot.getContext().unregisterComponentCallbacks(listener);
+            }
             mListeners.remove(listener);
             listener.detachFromRoot();
         };
@@ -173,9 +181,14 @@ public abstract class ViewCapture {
     }
 
     @AnyThread
-    public void dumpTo(OutputStream os, Context context)
+    protected void dumpTo(OutputStream os, Context context)
             throws InterruptedException, ExecutionException, IOException {
-        if (mIsEnabled) getExportedData(context).writeTo(os);
+        if (mIsEnabled) {
+            DataOutputStream dataOutputStream = new DataOutputStream(os);
+            ExportedData ex = getExportedData(context);
+            dataOutputStream.writeInt(ex.getSerializedSize());
+            ex.writeTo(dataOutputStream);
+        }
     }
 
     @VisibleForTesting
@@ -208,7 +221,7 @@ public abstract class ViewCapture {
 
     @AnyThread
     private CompletableFuture<List<WindowData>> getWindowData(Context context,
-            ArrayList<Class> outClassList, Predicate<WindowListener> filter) {
+                                                              ArrayList<Class> outClassList, Predicate<WindowListener> filter) {
         ViewIdProvider idProvider = new ViewIdProvider(context.getResources());
         return CompletableFuture.supplyAsync(() ->
                 mListeners.stream().filter(filter).toList(), MAIN_EXECUTOR).thenApplyAsync(it ->
@@ -216,48 +229,57 @@ public abstract class ViewCapture {
                 mBgExecutor);
     }
 
+    @WorkerThread
+    protected void onCapturedViewPropertiesBg(long elapsedRealtimeNanos, String windowName,
+                                              ViewPropertyRef startFlattenedViewTree) {
+    }
 
     /**
      * Once this window listener is attached to a window's root view, it traverses the entire
      * view tree on the main thread every time onDraw is called. It then saves the state of the view
      * tree traversed in a local list of nodes, so that this list of nodes can be processed on a
      * background thread, and prepared for being dumped into a bugreport.
-     *
+     * <p>
      * Since some of the work needs to be done on the main thread after every draw, this piece of
      * code needs to be hyper optimized. That is why we are recycling ViewRef and ViewPropertyRef
      * objects and storing the list of nodes as a flat LinkedList, rather than as a tree. This data
      * structure allows recycling to happen in O(1) time via pointer assignment. Without this
      * optimization, a lot of time is wasted creating ViewRef objects, or finding ViewRef objects to
      * recycle.
-     *
+     * <p>
      * Another optimization is to only traverse view nodes on the main thread that have potentially
      * changed since the last frame was drawn. This can be determined via a combination of private
      * flags inside the View class.
-     *
+     * <p>
      * Another optimization is to not store or manipulate any string objects on the main thread.
      * While this might seem trivial, using Strings in any form causes the ViewCapture to hog the
      * main thread for up to an additional 6-7ms. It must be avoided at all costs.
-     *
+     * <p>
      * Another optimization is to only store the class names of the Views in the view hierarchy one
      * time. They are then referenced via a classNameIndex value stored in each ViewPropertyRef.
-     *
+     * <p>
      * TODO: b/262585897: If further memory optimization is required, an effective one would be to
      * only store the changes between frames, rather than the entire node tree for each frame.
      * The go/web-hv UX already does this, and has reaped significant memory improves because of it.
-     *
+     * <p>
      * TODO: b/262585897: Another memory optimization could be to store all integer, float, and
      * boolean information via single integer values via the Chinese remainder theorem, or a similar
      * algorithm, which enables multiple numerical values to be stored inside 1 number. Doing this
      * would allow each ViewProperty / ViewRef to slim down its memory footprint significantly.
-     *
+     * <p>
      * One important thing to remember is that bugs related to recycling will usually only appear
      * after at least 2000 frames have been rendered. If that code is changed, the tester can
      * use hard-coded logs to verify that recycling is happening, and test view capturing at least
      * ~8000 frames or so to verify the recycling functionality is working properly.
+     * <p>
+     * Each WindowListener is memory aware and will both stop collecting view capture information,
+     * as well as delete their current stash of information upon a signal from the system that
+     * memory resources are scarce. The user will need to restart the app process before
+     * more ViewCapture information is captured.
      */
-    private class WindowListener implements ViewTreeObserver.OnDrawListener {
+    private class WindowListener implements ViewTreeObserver.OnDrawListener, ComponentCallbacks2 {
 
-        @Nullable // Nullable in tests only
+        @Nullable
         public View mRoot;
         public final String name;
 
@@ -265,8 +287,8 @@ public abstract class ViewCapture {
 
         private int mFrameIndexBg = -1;
         private boolean mIsFirstFrame = true;
-        private final long[] mFrameTimesNanosBg = new long[mMemorySize];
-        private final ViewPropertyRef[] mNodesBg = new ViewPropertyRef[mMemorySize];
+        private long[] mFrameTimesNanosBg = new long[mMemorySize];
+        private ViewPropertyRef[] mNodesBg = new ViewPropertyRef[mMemorySize];
 
         private boolean mIsActive = true;
         private final Consumer<ViewRef> mCaptureCallback = this::captureViewPropertiesBg;
@@ -284,7 +306,7 @@ public abstract class ViewCapture {
          */
         @Override
         public void onDraw() {
-            Trace.beginSection("view_capture");
+            Trace.beginSection("vc#onDraw");
             captureViewTree(mRoot, mViewRef);
             ViewRef captured = mViewRef.next;
             if (captured != null) {
@@ -302,6 +324,8 @@ public abstract class ViewCapture {
          */
         @WorkerThread
         private void captureViewPropertiesBg(ViewRef viewRefStart) {
+            Trace.beginSection("vc#captureViewPropertiesBg");
+
             long elapsedRealtimeNanos = viewRefStart.elapsedRealtimeNanos;
             mFrameIndexBg++;
             if (mFrameIndexBg >= mMemorySize) {
@@ -370,6 +394,10 @@ public abstract class ViewCapture {
                 viewRefEnd = viewRefEnd.next;
             }
             mNodesBg[mFrameIndexBg] = resultStart;
+
+            onCapturedViewPropertiesBg(elapsedRealtimeNanos, name, resultStart);
+
+            Trace.endSection();
         }
 
         private @Nullable ViewPropertyRef findInLastFrame(int hashCode) {
@@ -382,6 +410,7 @@ public abstract class ViewCapture {
         }
 
         void attachToRoot() {
+            if (mRoot == null) return;
             mIsActive = true;
             if (mRoot.isAttachedToWindow()) {
                 safelyEnableOnDrawListener();
@@ -410,8 +439,10 @@ public abstract class ViewCapture {
         }
 
         private void safelyEnableOnDrawListener() {
-            mRoot.getViewTreeObserver().removeOnDrawListener(this);
-            mRoot.getViewTreeObserver().addOnDrawListener(this);
+            if (mRoot != null) {
+                mRoot.getViewTreeObserver().removeOnDrawListener(this);
+                mRoot.getViewTreeObserver().addOnDrawListener(this);
+            }
         }
 
         @WorkerThread
@@ -462,9 +493,32 @@ public abstract class ViewCapture {
                 return ref;
             }
         }
+
+        @Override
+        public void onTrimMemory(int level) {
+            if (level >= ComponentCallbacks2.TRIM_MEMORY_BACKGROUND) {
+                mNodesBg = new ViewPropertyRef[0];
+                mFrameTimesNanosBg = new long[0];
+                if (mRoot != null && mRoot.getContext() != null) {
+                    mRoot.getContext().unregisterComponentCallbacks(this);
+                }
+                detachFromRoot();
+                mRoot = null;
+            }
+        }
+
+        @Override
+        public void onConfigurationChanged(Configuration configuration) {
+            // No Operation
+        }
+
+        @Override
+        public void onLowMemory() {
+            onTrimMemory(ComponentCallbacks2.TRIM_MEMORY_BACKGROUND);
+        }
     }
 
-    private static class ViewPropertyRef {
+    protected static class ViewPropertyRef {
         // We store reference in memory to avoid generating and storing too many strings
         public Class clazz;
         public int hashCode;
@@ -512,7 +566,7 @@ public abstract class ViewCapture {
          * at the end of the iteration.
          */
         public ViewPropertyRef toProto(ViewIdProvider idProvider, ArrayList<Class> classList,
-                ViewNode.Builder viewNode) {
+                                       ViewNode.Builder viewNode) {
             int classnameIndex = classList.indexOf(clazz);
             if (classnameIndex < 0) {
                 classnameIndex = classList.size();
@@ -552,6 +606,7 @@ public abstract class ViewCapture {
     private static class ViewRef implements Runnable {
         public View view;
         public int childCount = 0;
+        @Nullable
         public ViewRef next;
 
         public Consumer<ViewRef> callback = null;
@@ -594,7 +649,7 @@ public abstract class ViewCapture {
         }
     }
 
-    private static final class ViewIdProvider {
+    protected static final class ViewIdProvider {
 
         private final SparseArray<String> mNames = new SparseArray<>();
         private final Resources mRes;
diff --git a/systemUIViewCapture/src/com/android/app/viewcapture/ViewCaptureDataSource.java b/systemUIViewCapture/src/com/android/app/viewcapture/ViewCaptureDataSource.java
new file mode 100644
index 0000000000..e057848005
--- /dev/null
+++ b/systemUIViewCapture/src/com/android/app/viewcapture/ViewCaptureDataSource.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2024 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.app.viewcapture;
+
+import android.tracing.perfetto.CreateIncrementalStateArgs;
+import android.tracing.perfetto.DataSource;
+import android.tracing.perfetto.DataSourceInstance;
+import android.tracing.perfetto.FlushCallbackArguments;
+import android.tracing.perfetto.StartCallbackArguments;
+import android.tracing.perfetto.StopCallbackArguments;
+import android.util.proto.ProtoInputStream;
+
+import java.util.HashMap;
+import java.util.Map;
+
+class ViewCaptureDataSource
+extends DataSource<DataSourceInstance, Void, ViewCaptureDataSource.IncrementalState> {
+    public static String DATA_SOURCE_NAME = "android.viewcapture";
+
+    private final Runnable mOnStartStaticCallback;
+    private final Runnable mOnFlushStaticCallback;
+    private final Runnable mOnStopStaticCallback;
+
+    ViewCaptureDataSource(Runnable onStart, Runnable onFlush, Runnable onStop) {
+        super(DATA_SOURCE_NAME);
+        this.mOnStartStaticCallback = onStart;
+        this.mOnFlushStaticCallback = onFlush;
+        this.mOnStopStaticCallback = onStop;
+    }
+
+    @Override
+    public IncrementalState createIncrementalState(
+        CreateIncrementalStateArgs<DataSourceInstance> args) {
+        return new IncrementalState();
+    }
+
+    public static class IncrementalState {
+        public final Map<String, Integer> mInternMapPackageName = new HashMap<>();
+        public final Map<String, Integer> mInternMapWindowName = new HashMap<>();
+        public final Map<String, Integer> mInternMapViewId = new HashMap<>();
+        public final Map<String, Integer> mInternMapClassName = new HashMap<>();
+        public boolean mHasNotifiedClearedState = false;
+    }
+
+    @Override
+    public DataSourceInstance createInstance(ProtoInputStream configStream, int instanceIndex) {
+        return new DataSourceInstance(this, instanceIndex) {
+        @Override
+        protected void onStart(StartCallbackArguments args) {
+            mOnStartStaticCallback.run();
+        }
+
+        @Override
+        protected void onFlush(FlushCallbackArguments args) {
+            mOnFlushStaticCallback.run();
+        }
+
+        @Override
+        protected void onStop(StopCallbackArguments args) {
+            mOnStopStaticCallback.run();
+        }
+    };
+    }
+}
diff --git a/systemUIViewCapture/src/com/android/app/viewcapture/ViewCaptureFactory.kt b/systemUIViewCapture/src/com/android/app/viewcapture/ViewCaptureFactory.kt
new file mode 100644
index 0000000000..5fb9ceb3b0
--- /dev/null
+++ b/systemUIViewCapture/src/com/android/app/viewcapture/ViewCaptureFactory.kt
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2024 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.app.viewcapture
+
+import android.content.Context
+import android.os.Looper
+import android.os.Process
+import android.tracing.Flags
+import android.util.Log
+
+/**
+ * Factory to create polymorphic instances of ViewCapture according to build configurations and
+ * flags.
+ */
+class ViewCaptureFactory {
+    companion object {
+        private val TAG = ViewCaptureFactory::class.java.simpleName
+        private var instance: ViewCapture? = null
+
+        @JvmStatic
+        fun getInstance(context: Context): ViewCapture {
+            if (Looper.myLooper() != Looper.getMainLooper()) {
+                return ViewCapture.MAIN_EXECUTOR.submit { getInstance(context) }.get()
+            }
+
+            if (instance != null) {
+                return instance!!
+            }
+
+            return when {
+                !android.os.Build.IS_DEBUGGABLE -> {
+                    Log.i(TAG, "instantiating ${NoOpViewCapture::class.java.simpleName}")
+                    NoOpViewCapture()
+                }
+                !Flags.perfettoViewCaptureTracing() -> {
+                    Log.i(TAG, "instantiating ${SettingsAwareViewCapture::class.java.simpleName}")
+                    SettingsAwareViewCapture(
+                            context.applicationContext,
+                            ViewCapture.createAndStartNewLooperExecutor(
+                                    "SAViewCapture",
+                                    Process.THREAD_PRIORITY_FOREGROUND
+                            )
+                    )
+                }
+                else -> {
+                    Log.i(TAG, "instantiating ${PerfettoViewCapture::class.java.simpleName}")
+                    PerfettoViewCapture(
+                            context.applicationContext,
+                            ViewCapture.createAndStartNewLooperExecutor(
+                                    "PerfettoViewCapture",
+                                    Process.THREAD_PRIORITY_FOREGROUND
+                            )
+                    )
+                }
+            }.also { instance = it }
+        }
+    }
+}
diff --git a/systemUnFold/build.gradle b/systemUnFold/build.gradle
index 2a4a5a3aa8..55721a152a 100644
--- a/systemUnFold/build.gradle
+++ b/systemUnFold/build.gradle
@@ -29,5 +29,7 @@ dependencies {
 
     implementation "androidx.concurrent:concurrent-futures:1.2.0"
     implementation "androidx.lifecycle:lifecycle-common:2.8.6"
-    implementation projects.androidxLib
+
+//    compileOnly projects.androidxLib
+    implementation 'androidx.dynamicanimation:dynamicanimation:1.0.0'
 }
diff --git a/tests/shared/com/android/launcher3/testing/shared/HotseatCellCenterRequest.java b/tests/shared/com/android/launcher3/testing/shared/HotseatCellCenterRequest.java
new file mode 100644
index 0000000000..7eb035a81f
--- /dev/null
+++ b/tests/shared/com/android/launcher3/testing/shared/HotseatCellCenterRequest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2022 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.testing.shared;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/**
+ * Request object for querying a hotseat cell region in Rect.
+ */
+public class HotseatCellCenterRequest implements TestInformationRequest {
+    public final int cellInd;
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeInt(cellInd);
+    }
+
+    @Override
+    public String getRequestName() {
+        return TestProtocol.REQUEST_HOTSEAT_CELL_CENTER;
+    }
+
+    public static final Parcelable.Creator<HotseatCellCenterRequest> CREATOR =
+            new Parcelable.Creator<HotseatCellCenterRequest>() {
+
+                @Override
+                public HotseatCellCenterRequest createFromParcel(Parcel source) {
+                    return new HotseatCellCenterRequest(source);
+                }
+
+                @Override
+                public HotseatCellCenterRequest[] newArray(int size) {
+                    return new HotseatCellCenterRequest[size];
+                }
+            };
+
+    private HotseatCellCenterRequest(int cellInd) {
+        this.cellInd = cellInd;
+    }
+
+    private HotseatCellCenterRequest(Parcel in) {
+        this(in.readInt());
+    }
+
+    /**
+     * Create a builder for HotseatCellCenterRequest.
+     *
+     * @return HotseatCellCenterRequest builder.
+     */
+    public static HotseatCellCenterRequest.Builder builder() {
+        return new HotseatCellCenterRequest.Builder();
+    }
+
+    /**
+     * HotseatCellCenterRequest Builder.
+     */
+    public static final class Builder {
+        private int mCellInd;
+
+        private Builder() {
+            mCellInd = 0;
+        }
+
+        /**
+         * Set the index of hotseat cells.
+         */
+        public HotseatCellCenterRequest.Builder setCellInd(int i) {
+            this.mCellInd = i;
+            return this;
+        }
+
+        /**
+         * build the HotseatCellCenterRequest.
+         */
+        public HotseatCellCenterRequest build() {
+            return new HotseatCellCenterRequest(mCellInd);
+        }
+    }
+}
diff --git a/tests/shared/com/android/launcher3/testing/shared/TestInformationRequest.java b/tests/shared/com/android/launcher3/testing/shared/TestInformationRequest.java
new file mode 100644
index 0000000000..3828203280
--- /dev/null
+++ b/tests/shared/com/android/launcher3/testing/shared/TestInformationRequest.java
@@ -0,0 +1,29 @@
+/*
+ * 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.testing.shared;
+
+import android.os.Parcelable;
+
+/**
+ * A Request sent to TestInformationHandler can implement this interface to carry more information.
+ */
+public interface TestInformationRequest extends Parcelable {
+    /**
+     * The name for handler to dispatch request.
+     */
+    String getRequestName();
+}
diff --git a/tests/shared/com/android/launcher3/testing/shared/WorkspaceCellCenterRequest.java b/tests/shared/com/android/launcher3/testing/shared/WorkspaceCellCenterRequest.java
new file mode 100644
index 0000000000..e2cd8ea965
--- /dev/null
+++ b/tests/shared/com/android/launcher3/testing/shared/WorkspaceCellCenterRequest.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2022 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.testing.shared;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/**
+ * Request object for querying a workspace cell region in Rect.
+ */
+public class WorkspaceCellCenterRequest implements TestInformationRequest {
+    public final int cellX;
+    public final int cellY;
+    public final int spanX;
+    public final int spanY;
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeInt(cellX);
+        dest.writeInt(cellY);
+        dest.writeInt(spanX);
+        dest.writeInt(spanY);
+    }
+
+    public static final Parcelable.Creator<WorkspaceCellCenterRequest> CREATOR =
+            new Parcelable.Creator<WorkspaceCellCenterRequest>() {
+
+                @Override
+                public WorkspaceCellCenterRequest createFromParcel(Parcel source) {
+                    return new WorkspaceCellCenterRequest(source);
+                }
+
+                @Override
+                public WorkspaceCellCenterRequest[] newArray(int size) {
+                    return new WorkspaceCellCenterRequest[size];
+                }
+            };
+
+    private WorkspaceCellCenterRequest(int cellX, int cellY, int spanX, int spanY) {
+        this.cellX = cellX;
+        this.cellY = cellY;
+        this.spanX = spanX;
+        this.spanY = spanY;
+    }
+
+    private WorkspaceCellCenterRequest(Parcel in) {
+        this(in.readInt(), in.readInt(), in.readInt(), in.readInt());
+    }
+
+    /**
+     * Create a builder for WorkspaceCellRectRequest.
+     *
+     * @return WorkspaceCellRectRequest builder.
+     */
+    public static WorkspaceCellCenterRequest.Builder builder() {
+        return new WorkspaceCellCenterRequest.Builder();
+    }
+
+    @Override
+    public String getRequestName() {
+        return TestProtocol.REQUEST_WORKSPACE_CELL_CENTER;
+    }
+
+    /**
+     * WorkspaceCellRectRequest Builder.
+     */
+    public static final class Builder {
+        private int mCellX;
+        private int mCellY;
+        private int mSpanX;
+        private int mSpanY;
+
+        private Builder() {
+            this.mCellX = 0;
+            this.mCellY = 0;
+            this.mSpanX = 1;
+            this.mSpanY = 1;
+        }
+
+        /**
+         * Set X coordinate of upper left corner expressed as a cell position
+         */
+        public WorkspaceCellCenterRequest.Builder setCellX(int x) {
+            this.mCellX = x;
+            return this;
+        }
+
+        /**
+         * Set Y coordinate of upper left corner expressed as a cell position
+         */
+        public WorkspaceCellCenterRequest.Builder setCellY(int y) {
+            this.mCellY = y;
+            return this;
+        }
+
+        /**
+         * Set span Width in cells
+         */
+        public WorkspaceCellCenterRequest.Builder setSpanX(int x) {
+            this.mSpanX = x;
+            return this;
+        }
+
+        /**
+         * Set span Height in cells
+         */
+        public WorkspaceCellCenterRequest.Builder setSpanY(int y) {
+            this.mSpanY = y;
+            return this;
+        }
+
+        /**
+         * build the WorkspaceCellRectRequest.
+         */
+        public WorkspaceCellCenterRequest build() {
+            return new WorkspaceCellCenterRequest(mCellX, mCellY, mSpanX, mSpanY);
+        }
+    }
+}
diff --git a/wmshell/build.gradle b/wmshell/build.gradle
index b9258cb57c..55e24a5d98 100644
--- a/wmshell/build.gradle
+++ b/wmshell/build.gradle
@@ -23,8 +23,9 @@ addFrameworkJar('framework-15.jar')
 compileOnlyCommonJars()
 
 dependencies {
-    implementation 'androidx.core:core-animation:1.0.0-alpha02'
     implementation 'androidx.core:core-ktx:1.9.0'
     implementation "com.google.dagger:hilt-android:$daggerVersion"
     ksp "com.google.dagger:hilt-compiler:$daggerVersion"
+    implementation 'androidx.core:core-animation:1.0.0-alpha02'
+    implementation 'androidx.dynamicanimation:dynamicanimation:1.0.0'
 }
diff --git a/wmshell/shared/aidl/com/android/wm/shell/common/bubbles/BubbleBarLocation.aidl b/wmshell/shared/aidl/com/android/wm/shell/common/bubbles/BubbleBarLocation.aidl
new file mode 100644
index 0000000000..3c5beeb488
--- /dev/null
+++ b/wmshell/shared/aidl/com/android/wm/shell/common/bubbles/BubbleBarLocation.aidl
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2024 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.wm.shell.common.bubbles;
+
+parcelable BubbleBarLocation;
\ No newline at end of file
diff --git a/wmshell/shared/aidl/com/android/wm/shell/common/desktopmode/DesktopModeTransitionSource.aidl b/wmshell/shared/aidl/com/android/wm/shell/common/desktopmode/DesktopModeTransitionSource.aidl
new file mode 100644
index 0000000000..c968e809bf
--- /dev/null
+++ b/wmshell/shared/aidl/com/android/wm/shell/common/desktopmode/DesktopModeTransitionSource.aidl
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2024 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.wm.shell.common.desktopmode;
+
+parcelable DesktopModeTransitionSource;
\ No newline at end of file
diff --git a/wmshell/shared/src/com/android/wm/shell/common/bubbles/BaseBubblePinController.kt b/wmshell/shared/src/com/android/wm/shell/common/bubbles/BaseBubblePinController.kt
new file mode 100644
index 0000000000..eec24683db
--- /dev/null
+++ b/wmshell/shared/src/com/android/wm/shell/common/bubbles/BaseBubblePinController.kt
@@ -0,0 +1,210 @@
+/*
+ * Copyright (C) 2024 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.wm.shell.common.bubbles
+
+import android.graphics.Point
+import android.graphics.RectF
+import android.view.View
+import androidx.annotation.VisibleForTesting
+import androidx.core.animation.Animator
+import androidx.core.animation.AnimatorListenerAdapter
+import androidx.core.animation.ObjectAnimator
+import com.android.wm.shell.common.bubbles.BaseBubblePinController.LocationChangeListener
+import com.android.wm.shell.common.bubbles.BubbleBarLocation.LEFT
+import com.android.wm.shell.common.bubbles.BubbleBarLocation.RIGHT
+
+/**
+ * Base class for common logic shared between different bubble views to support pinning bubble bar
+ * to left or right edge of screen.
+ *
+ * Handles drag events and allows a [LocationChangeListener] to be registered that is notified when
+ * location of the bubble bar should change.
+ *
+ * Shows a drop target when releasing a view would update the [BubbleBarLocation].
+ */
+abstract class BaseBubblePinController(private val screenSizeProvider: () -> Point) {
+
+    private var initialLocationOnLeft = false
+    private var onLeft = false
+    private var dismissZone: RectF? = null
+    private var stuckToDismissTarget = false
+    private var screenCenterX = 0
+    private var listener: LocationChangeListener? = null
+    private var dropTargetAnimator: ObjectAnimator? = null
+
+    /**
+     * Signal the controller that dragging interaction has started.
+     *
+     * @param initialLocationOnLeft side of the screen where bubble bar is pinned to
+     */
+    fun onDragStart(initialLocationOnLeft: Boolean) {
+        this.initialLocationOnLeft = initialLocationOnLeft
+        onLeft = initialLocationOnLeft
+        screenCenterX = screenSizeProvider.invoke().x / 2
+        dismissZone = getExclusionRect()
+    }
+
+    /** View has moved to [x] and [y] screen coordinates */
+    fun onDragUpdate(x: Float, y: Float) {
+        if (dismissZone?.contains(x, y) == true) return
+
+        val wasOnLeft = onLeft
+        onLeft = x < screenCenterX
+        if (wasOnLeft != onLeft) {
+            onLocationChange(if (onLeft) LEFT else RIGHT)
+        } else if (stuckToDismissTarget) {
+            // Moved out of the dismiss view back to initial side, if we have a drop target, show it
+            getDropTargetView()?.apply { animateIn() }
+        }
+        // Make sure this gets cleared
+        stuckToDismissTarget = false
+    }
+
+    /** Signal the controller that view has been dragged to dismiss view. */
+    fun onStuckToDismissTarget() {
+        stuckToDismissTarget = true
+        // Notify that location may be reset
+        val shouldResetLocation = onLeft != initialLocationOnLeft
+        if (shouldResetLocation) {
+            onLeft = initialLocationOnLeft
+            listener?.onChange(if (onLeft) LEFT else RIGHT)
+        }
+        getDropTargetView()?.apply {
+            animateOut {
+                if (shouldResetLocation) {
+                    updateLocation(if (onLeft) LEFT else RIGHT)
+                }
+            }
+        }
+    }
+
+    /** Signal the controller that dragging interaction has finished. */
+    fun onDragEnd() {
+        getDropTargetView()?.let { view -> view.animateOut { removeDropTargetView(view) } }
+        dismissZone = null
+        listener?.onRelease(if (onLeft) LEFT else RIGHT)
+    }
+
+    /**
+     * [LocationChangeListener] that is notified when dragging interaction has resulted in bubble
+     * bar to be pinned on the other edge
+     */
+    fun setListener(listener: LocationChangeListener?) {
+        this.listener = listener
+    }
+
+    /** Get width for exclusion rect where dismiss takes over drag */
+    protected abstract fun getExclusionRectWidth(): Float
+    /** Get height for exclusion rect where dismiss takes over drag */
+    protected abstract fun getExclusionRectHeight(): Float
+
+    /** Create the drop target view and attach it to the parent */
+    protected abstract fun createDropTargetView(): View
+
+    /** Get the drop target view if it exists */
+    protected abstract fun getDropTargetView(): View?
+
+    /** Remove the drop target view */
+    protected abstract fun removeDropTargetView(view: View)
+
+    /** Update size and location of the drop target view */
+    protected abstract fun updateLocation(location: BubbleBarLocation)
+
+    private fun onLocationChange(location: BubbleBarLocation) {
+        showDropTarget(location)
+        listener?.onChange(location)
+    }
+
+    private fun getExclusionRect(): RectF {
+        val rect = RectF(0f, 0f, getExclusionRectWidth(), getExclusionRectHeight())
+        // Center it around the bottom center of the screen
+        val screenBottom = screenSizeProvider.invoke().y
+        rect.offsetTo(screenCenterX - rect.width() / 2, screenBottom - rect.height())
+        return rect
+    }
+
+    private fun showDropTarget(location: BubbleBarLocation) {
+        val targetView = getDropTargetView() ?: createDropTargetView().apply { alpha = 0f }
+        if (targetView.alpha > 0) {
+            targetView.animateOut {
+                updateLocation(location)
+                targetView.animateIn()
+            }
+        } else {
+            updateLocation(location)
+            targetView.animateIn()
+        }
+    }
+
+    private fun View.animateIn() {
+        dropTargetAnimator?.cancel()
+        dropTargetAnimator =
+            ObjectAnimator.ofFloat(this, View.ALPHA, 1f)
+                .setDuration(DROP_TARGET_ALPHA_IN_DURATION)
+                .addEndAction { dropTargetAnimator = null }
+        dropTargetAnimator?.start()
+    }
+
+    private fun View.animateOut(endAction: Runnable? = null) {
+        dropTargetAnimator?.cancel()
+        dropTargetAnimator =
+            ObjectAnimator.ofFloat(this, View.ALPHA, 0f)
+                .setDuration(DROP_TARGET_ALPHA_OUT_DURATION)
+                .addEndAction {
+                    endAction?.run()
+                    dropTargetAnimator = null
+                }
+        dropTargetAnimator?.start()
+    }
+
+    private fun <T : Animator> T.addEndAction(runnable: Runnable): T {
+        addListener(
+            object : AnimatorListenerAdapter() {
+                override fun onAnimationEnd(animation: Animator) {
+                    runnable.run()
+                }
+            }
+        )
+        return this
+    }
+
+    /** Receive updates on location changes */
+    interface LocationChangeListener {
+        /**
+         * Bubble bar has been dragged to a new [BubbleBarLocation]. And the drag is still in
+         * progress.
+         *
+         * Triggered when drag gesture passes the middle of the screen and before touch up. Can be
+         * triggered multiple times per gesture.
+         *
+         * @param location new location as a result of the ongoing drag operation
+         */
+        fun onChange(location: BubbleBarLocation) {}
+
+        /**
+         * Bubble bar has been released in the [BubbleBarLocation].
+         *
+         * @param location final location of the bubble bar once drag is released
+         */
+        fun onRelease(location: BubbleBarLocation)
+    }
+
+    companion object {
+        @VisibleForTesting const val DROP_TARGET_ALPHA_IN_DURATION = 150L
+        @VisibleForTesting const val DROP_TARGET_ALPHA_OUT_DURATION = 100L
+    }
+}
diff --git a/wmshell/shared/src/com/android/wm/shell/common/bubbles/BubbleBarLocation.aidl b/wmshell/shared/src/com/android/wm/shell/common/bubbles/BubbleBarLocation.aidl
new file mode 100644
index 0000000000..3c5beeb488
--- /dev/null
+++ b/wmshell/shared/src/com/android/wm/shell/common/bubbles/BubbleBarLocation.aidl
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2024 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.wm.shell.common.bubbles;
+
+parcelable BubbleBarLocation;
\ No newline at end of file
diff --git a/wmshell/shared/src/com/android/wm/shell/common/bubbles/BubbleBarLocation.kt b/wmshell/shared/src/com/android/wm/shell/common/bubbles/BubbleBarLocation.kt
new file mode 100644
index 0000000000..f0bdfdef10
--- /dev/null
+++ b/wmshell/shared/src/com/android/wm/shell/common/bubbles/BubbleBarLocation.kt
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2024 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.wm.shell.common.bubbles
+
+import android.os.Parcel
+import android.os.Parcelable
+
+/**
+ * The location of the bubble bar.
+ */
+enum class BubbleBarLocation : Parcelable {
+    /**
+     * Place bubble bar at the default location for the chosen system language.
+     * If an RTL language is used, it is on the left. Otherwise on the right.
+     */
+    DEFAULT,
+    /** Default bubble bar location is overridden. Place bubble bar on the left. */
+    LEFT,
+    /** Default bubble bar location is overridden. Place bubble bar on the right. */
+    RIGHT;
+
+    /**
+     * Returns whether bubble bar is pinned to the left edge or right edge.
+     */
+    fun isOnLeft(isRtl: Boolean): Boolean {
+        if (this == DEFAULT) {
+            return isRtl
+        }
+        return this == LEFT
+    }
+
+    override fun describeContents(): Int {
+        return 0
+    }
+
+    override fun writeToParcel(dest: Parcel, flags: Int) {
+        dest.writeString(name)
+    }
+
+    companion object {
+        @JvmField
+        val CREATOR = object : Parcelable.Creator<BubbleBarLocation> {
+            override fun createFromParcel(parcel: Parcel): BubbleBarLocation {
+                return parcel.readString()?.let { valueOf(it) } ?: DEFAULT
+            }
+
+            override fun newArray(size: Int) = arrayOfNulls<BubbleBarLocation>(size)
+        }
+    }
+}
diff --git a/wmshell/shared/src/com/android/wm/shell/common/desktopmode/DesktopModeTransitionSource.aidl b/wmshell/shared/src/com/android/wm/shell/common/desktopmode/DesktopModeTransitionSource.aidl
new file mode 100644
index 0000000000..c968e809bf
--- /dev/null
+++ b/wmshell/shared/src/com/android/wm/shell/common/desktopmode/DesktopModeTransitionSource.aidl
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2024 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.wm.shell.common.desktopmode;
+
+parcelable DesktopModeTransitionSource;
\ No newline at end of file
diff --git a/wmshell/shared/src/com/android/wm/shell/common/desktopmode/DesktopModeTransitionSource.kt b/wmshell/shared/src/com/android/wm/shell/common/desktopmode/DesktopModeTransitionSource.kt
new file mode 100644
index 0000000000..dbbf178613
--- /dev/null
+++ b/wmshell/shared/src/com/android/wm/shell/common/desktopmode/DesktopModeTransitionSource.kt
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2024 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.wm.shell.common.desktopmode
+
+import android.os.Parcel
+import android.os.Parcelable
+
+/** Transition source types for Desktop Mode. */
+enum class DesktopModeTransitionSource : Parcelable {
+    /** Transitions that originated as a consequence of task dragging. */
+    TASK_DRAG,
+    /** Transitions that originated from an app from Overview. */
+    APP_FROM_OVERVIEW,
+    /** Transitions that originated from app handle menu button */
+    APP_HANDLE_MENU_BUTTON,
+    /** Transitions that originated as a result of keyboard shortcuts. */
+    KEYBOARD_SHORTCUT,
+    /** Transitions with source unknown. */
+    UNKNOWN;
+
+    override fun describeContents(): Int {
+        return 0
+    }
+
+    override fun writeToParcel(dest: Parcel, flags: Int) {
+        dest.writeString(name)
+    }
+
+    companion object {
+        @JvmField
+        val CREATOR =
+            object : Parcelable.Creator<DesktopModeTransitionSource> {
+                override fun createFromParcel(parcel: Parcel): DesktopModeTransitionSource {
+                    return parcel.readString()?.let { valueOf(it) } ?: UNKNOWN
+                }
+
+                override fun newArray(size: Int) = arrayOfNulls<DesktopModeTransitionSource>(size)
+            }
+    }
+}
diff --git a/wmshell/shared/src/com/android/wm/shell/shared/animation/PhysicsAnimator.kt b/wmshell/shared/src/com/android/wm/shell/shared/animation/PhysicsAnimator.kt
new file mode 100644
index 0000000000..9d3b56d22a
--- /dev/null
+++ b/wmshell/shared/src/com/android/wm/shell/shared/animation/PhysicsAnimator.kt
@@ -0,0 +1,1032 @@
+/*
+ * 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.wm.shell.shared.animation
+
+import android.util.ArrayMap
+import android.util.Log
+import android.view.View
+import androidx.dynamicanimation.animation.DynamicAnimation
+import androidx.dynamicanimation.animation.FlingAnimation
+import androidx.dynamicanimation.animation.FloatPropertyCompat
+import androidx.dynamicanimation.animation.SpringAnimation
+import androidx.dynamicanimation.animation.SpringForce
+
+import com.android.wm.shell.shared.animation.PhysicsAnimator.Companion.getInstance
+import java.lang.ref.WeakReference
+import java.util.WeakHashMap
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * Extension function for all objects which will return a PhysicsAnimator instance for that object.
+ */
+val <T : View> T.physicsAnimator: PhysicsAnimator<T> get() { return getInstance(this) }
+
+private const val TAG = "PhysicsAnimator"
+
+private val UNSET = -Float.MAX_VALUE
+
+/**
+ * [FlingAnimation] multiplies the friction set via [FlingAnimation.setFriction] by 4.2f, which is
+ * where this number comes from. We use it in [PhysicsAnimator.flingThenSpring] to calculate the
+ * minimum velocity for a fling to reach a certain value, given the fling's friction.
+ */
+private const val FLING_FRICTION_SCALAR_MULTIPLIER = 4.2f
+
+typealias EndAction = () -> Unit
+
+/** A map of Property -> AnimationUpdate, which is provided to update listeners on each frame. */
+typealias UpdateMap<T> =
+        ArrayMap<FloatPropertyCompat<in T>, PhysicsAnimator.AnimationUpdate>
+
+/**
+ * Map of the animators associated with a given object. This ensures that only one animator
+ * per object exists.
+ */
+internal val animators = WeakHashMap<Any, PhysicsAnimator<*>>()
+
+/**
+ * Default spring configuration to use for animations where stiffness and/or damping ratio
+ * were not provided, and a default spring was not set via [PhysicsAnimator.setDefaultSpringConfig].
+ */
+private val globalDefaultSpring = PhysicsAnimator.SpringConfig(
+        SpringForce.STIFFNESS_MEDIUM,
+        SpringForce.DAMPING_RATIO_MEDIUM_BOUNCY)
+
+/**
+ * Default fling configuration to use for animations where friction was not provided, and a default
+ * fling config was not set via [PhysicsAnimator.setDefaultFlingConfig].
+ */
+private val globalDefaultFling = PhysicsAnimator.FlingConfig(
+        friction = 1f, min = -Float.MAX_VALUE, max = Float.MAX_VALUE)
+
+/** Whether to log helpful debug information about animations. */
+private var verboseLogging = false
+
+/**
+ * Animator that uses physics-based animations to animate properties on views and objects. Physics
+ * animations use real-world physical concepts, such as momentum and mass, to realistically simulate
+ * motion. PhysicsAnimator is heavily inspired by [android.view.ViewPropertyAnimator], and
+ * also uses the builder pattern to configure and start animations.
+ *
+ * The physics animations are backed by [DynamicAnimation].
+ *
+ * @param T The type of the object being animated.
+ */
+class PhysicsAnimator<T> private constructor (target: T) {
+    /** Weak reference to the animation target. */
+    val weakTarget = WeakReference(target)
+
+    /** Data class for representing animation frame updates. */
+    data class AnimationUpdate(val value: Float, val velocity: Float)
+
+    /** [DynamicAnimation] instances for the given properties. */
+    private val springAnimations = ArrayMap<FloatPropertyCompat<in T>, SpringAnimation>()
+    private val flingAnimations = ArrayMap<FloatPropertyCompat<in T>, FlingAnimation>()
+
+    /**
+     * Spring and fling configurations for the properties to be animated on the target. We'll
+     * configure and start the DynamicAnimations for these properties according to the provided
+     * configurations.
+     */
+    private val springConfigs = ArrayMap<FloatPropertyCompat<in T>, SpringConfig>()
+    private val flingConfigs = ArrayMap<FloatPropertyCompat<in T>, FlingConfig>()
+
+    /**
+     * Animation listeners for the animation. These will be notified when each property animation
+     * updates or ends.
+     */
+    private val updateListeners = ArrayList<UpdateListener<T>>()
+    private val endListeners = ArrayList<EndListener<T>>()
+
+    /** End actions to run when all animations have completed.  */
+    private val endActions = ArrayList<EndAction>()
+
+    /** SpringConfig to use by default for properties whose springs were not provided. */
+    private var defaultSpring: SpringConfig = globalDefaultSpring
+
+    /** FlingConfig to use by default for properties whose fling configs were not provided. */
+    private var defaultFling: FlingConfig = globalDefaultFling
+
+    /**
+     * Internal listeners that respond to DynamicAnimations updating and ending, and dispatch to
+     * the listeners provided via [addUpdateListener] and [addEndListener]. This allows us to add
+     * just one permanent update and end listener to the DynamicAnimations.
+     */
+    internal var internalListeners = ArrayList<InternalListener>()
+
+    /**
+     * Action to run when [start] is called. This can be changed by
+     * [PhysicsAnimatorTestUtils.prepareForTest] to enable animators to run under test and provide
+     * helpful test utilities.
+     */
+    internal var startAction: () -> Unit = ::startInternal
+
+    /**
+     * Action to run when [cancel] is called. This can be changed by
+     * [PhysicsAnimatorTestUtils.prepareForTest] to cancel animations from the main thread, which
+     * is required.
+     */
+    internal var cancelAction: (Set<FloatPropertyCompat<in T>>) -> Unit = ::cancelInternal
+
+    /**
+     * Springs a property to the given value, using the provided configuration settings.
+     *
+     * Springs are used when you know the exact value to which you want to animate. They can be
+     * configured with a start velocity (typically used when the spring is initiated by a touch
+     * event), but this velocity will be realistically attenuated as forces are applied to move the
+     * property towards the end value.
+     *
+     * If you find yourself repeating the same stiffness and damping ratios many times, consider
+     * storing a single [SpringConfig] instance and passing that in instead of individual values.
+     *
+     * @param property The property to spring to the given value. The property must be an instance
+     * of FloatPropertyCompat&lt;? super T&gt;. For example, if this is a
+     * PhysicsAnimator&lt;FrameLayout&gt;, you can use a FloatPropertyCompat&lt;FrameLayout&gt;, as
+     * well as a FloatPropertyCompat&lt;ViewGroup&gt;, and so on.
+     * @param toPosition The value to spring the given property to.
+     * @param startVelocity The initial velocity to use for the animation.
+     * @param stiffness The stiffness to use for the spring. Higher stiffness values result in
+     * faster animations, while lower stiffness means a slower animation. Reasonable values for
+     * low, medium, and high stiffness can be found as constants in [SpringForce].
+     * @param dampingRatio The damping ratio (bounciness) to use for the spring. Higher values
+     * result in a less 'springy' animation, while lower values allow the animation to bounce
+     * back and forth for a longer time after reaching the final position. Reasonable values for
+     * low, medium, and high damping can be found in [SpringForce].
+     */
+    fun spring(
+        property: FloatPropertyCompat<in T>,
+        toPosition: Float,
+        startVelocity: Float = 0f,
+        stiffness: Float = defaultSpring.stiffness,
+        dampingRatio: Float = defaultSpring.dampingRatio
+    ): PhysicsAnimator<T> {
+        if (verboseLogging) {
+            Log.d(TAG, "Springing ${getReadablePropertyName(property)} to $toPosition.")
+        }
+
+        springConfigs[property] =
+                SpringConfig(stiffness, dampingRatio, startVelocity, toPosition)
+        return this
+    }
+
+    /**
+     * Springs a property to a given value using the provided start velocity and configuration
+     * options.
+     *
+     * @see spring
+     */
+    fun spring(
+        property: FloatPropertyCompat<in T>,
+        toPosition: Float,
+        startVelocity: Float,
+        config: SpringConfig = defaultSpring
+    ): PhysicsAnimator<T> {
+        return spring(
+                property, toPosition, startVelocity, config.stiffness, config.dampingRatio)
+    }
+
+    /**
+     * Springs a property to a given value using the provided configuration options, and a start
+     * velocity of 0f.
+     *
+     * @see spring
+     */
+    fun spring(
+        property: FloatPropertyCompat<in T>,
+        toPosition: Float,
+        config: SpringConfig = defaultSpring
+    ): PhysicsAnimator<T> {
+        return spring(property, toPosition, 0f, config)
+    }
+
+    /**
+     * Springs a property to a given value using the provided configuration options, and a start
+     * velocity of 0f.
+     *
+     * @see spring
+     */
+    fun spring(
+        property: FloatPropertyCompat<in T>,
+        toPosition: Float
+    ): PhysicsAnimator<T> {
+        return spring(property, toPosition, 0f)
+    }
+
+    /**
+     * Flings a property using the given start velocity, using a [FlingAnimation] configured using
+     * the provided configuration settings.
+     *
+     * Flings are used when you have a start velocity, and want the property value to realistically
+     * decrease as friction is applied until the velocity reaches zero. Flings do not have a
+     * deterministic end value. If you are attempting to animate to a specific end value, use
+     * [spring].
+     *
+     * If you find yourself repeating the same friction/min/max values, consider storing a single
+     * [FlingConfig] and passing that in instead.
+     *
+     * @param property The property to fling using the given start velocity.
+     * @param startVelocity The start velocity (in pixels per second) with which to start the fling.
+     * @param friction Friction value applied to slow down the animation over time. Higher values
+     * will more quickly slow the animation. Typical friction values range from 1f to 10f.
+     * @param min The minimum value allowed for the animation. If this value is reached, the
+     * animation will end abruptly.
+     * @param max The maximum value allowed for the animation. If this value is reached, the
+     * animation will end abruptly.
+     */
+    fun fling(
+        property: FloatPropertyCompat<in T>,
+        startVelocity: Float,
+        friction: Float = defaultFling.friction,
+        min: Float = defaultFling.min,
+        max: Float = defaultFling.max
+    ): PhysicsAnimator<T> {
+        if (verboseLogging) {
+            Log.d(TAG, "Flinging ${getReadablePropertyName(property)} " +
+                    "with velocity $startVelocity.")
+        }
+
+        flingConfigs[property] = FlingConfig(friction, min, max, startVelocity)
+        return this
+    }
+
+    /**
+     * Flings a property using the given start velocity, using a [FlingAnimation] configured using
+     * the provided configuration settings.
+     *
+     * @see fling
+     */
+    fun fling(
+        property: FloatPropertyCompat<in T>,
+        startVelocity: Float,
+        config: FlingConfig = defaultFling
+    ): PhysicsAnimator<T> {
+        return fling(property, startVelocity, config.friction, config.min, config.max)
+    }
+
+    /**
+     * Flings a property using the given start velocity. If the fling animation reaches the min/max
+     * bounds (from the [flingConfig]) with velocity remaining, it'll overshoot it and spring back.
+     *
+     * If the object is already out of the fling bounds, it will immediately spring back within
+     * bounds.
+     *
+     * This is useful for animating objects that are bounded by constraints such as screen edges,
+     * since otherwise the fling animation would end abruptly upon reaching the min/max bounds.
+     *
+     * @param property The property to animate.
+     * @param startVelocity The velocity, in pixels/second, with which to start the fling. If the
+     * object is already outside the fling bounds, this velocity will be used as the start velocity
+     * of the spring that will spring it back within bounds.
+     * @param flingMustReachMinOrMax If true, the fling animation is guaranteed to reach either its
+     * minimum bound (if [startVelocity] is negative) or maximum bound (if it's positive). The
+     * animator will use startVelocity if it's sufficient, or add more velocity if necessary. This
+     * is useful when fling's deceleration-based physics are preferable to the acceleration-based
+     * forces used by springs - typically, when you're allowing the user to move an object somewhere
+     * on the screen, but it needs to be along an edge.
+     * @param flingConfig The configuration to use for the fling portion of the animation.
+     * @param springConfig The configuration to use for the spring portion of the animation.
+     */
+    @JvmOverloads
+    fun flingThenSpring(
+        property: FloatPropertyCompat<in T>,
+        startVelocity: Float,
+        flingConfig: FlingConfig,
+        springConfig: SpringConfig,
+        flingMustReachMinOrMax: Boolean = false
+    ): PhysicsAnimator<T> {
+        val target = weakTarget.get()
+        if (target == null) {
+            Log.w(TAG, "Trying to animate a GC-ed target.")
+            return this
+        }
+        val flingConfigCopy = flingConfig.copy()
+        val springConfigCopy = springConfig.copy()
+        val toAtLeast = if (startVelocity < 0) flingConfig.min else flingConfig.max
+
+        if (flingMustReachMinOrMax && isValidValue(toAtLeast)) {
+            val currentValue = property.getValue(target)
+            val flingTravelDistance =
+                    startVelocity / (flingConfig.friction * FLING_FRICTION_SCALAR_MULTIPLIER)
+            val projectedFlingEndValue = currentValue + flingTravelDistance
+            val midpoint = (flingConfig.min + flingConfig.max) / 2
+
+            // If fling velocity is too low to push the target past the midpoint between min and
+            // max, then spring back towards the nearest edge, starting with the current velocity.
+            if ((startVelocity < 0 && projectedFlingEndValue > midpoint) ||
+                    (startVelocity > 0 && projectedFlingEndValue < midpoint)) {
+                val toPosition =
+                        if (projectedFlingEndValue < midpoint) flingConfig.min else flingConfig.max
+                if (isValidValue(toPosition)) {
+                    return spring(property, toPosition, startVelocity, springConfig)
+                }
+            }
+
+            // Projected fling end value is past the midpoint, so fling forward.
+            val distanceToDestination = toAtLeast - property.getValue(target)
+
+            // The minimum velocity required for the fling to end up at the given destination,
+            // taking the provided fling friction value.
+            val velocityToReachDestination = distanceToDestination *
+                    (flingConfig.friction * FLING_FRICTION_SCALAR_MULTIPLIER)
+
+            // If there's distance to cover, and the provided velocity is moving in the correct
+            // direction, ensure that the velocity is high enough to reach the destination.
+            // Otherwise, just use startVelocity - this means that the fling is at or out of bounds.
+            // The fling will immediately end and a spring will bring the object back into bounds
+            // with this startVelocity.
+            flingConfigCopy.startVelocity = when {
+                distanceToDestination > 0f && startVelocity >= 0f ->
+                    max(velocityToReachDestination, startVelocity)
+                distanceToDestination < 0f && startVelocity <= 0f ->
+                    min(velocityToReachDestination, startVelocity)
+                else -> startVelocity
+            }
+
+            springConfigCopy.finalPosition = toAtLeast
+        } else {
+            flingConfigCopy.startVelocity = startVelocity
+        }
+
+        flingConfigs[property] = flingConfigCopy
+        springConfigs[property] = springConfigCopy
+        return this
+    }
+
+    private fun isValidValue(value: Float) = value < Float.MAX_VALUE && value > -Float.MAX_VALUE
+
+    /**
+     * Adds a listener that will be called whenever any property on the animated object is updated.
+     * This will be called on every animation frame, with the current value of the animated object
+     * and the new property values.
+     */
+    fun addUpdateListener(listener: UpdateListener<T>): PhysicsAnimator<T> {
+        updateListeners.add(listener)
+        return this
+    }
+
+    /**
+     * Adds a listener that will be called when a property stops animating. This is useful if
+     * you care about a specific property ending, or want to use the end value/end velocity from a
+     * particular property's animation. If you just want to run an action when all property
+     * animations have ended, use [withEndActions].
+     */
+    fun addEndListener(listener: EndListener<T>): PhysicsAnimator<T> {
+        endListeners.add(listener)
+        return this
+    }
+
+    /**
+     * Adds end actions that will be run sequentially when animations for every property involved in
+     * this specific animation have ended (unless they were explicitly canceled). For example, if
+     * you call:
+     *
+     * animator
+     *   .spring(TRANSLATION_X, ...)
+     *   .spring(TRANSLATION_Y, ...)
+     *   .withEndAction(action)
+     *   .start()
+     *
+     * 'action' will be run when both TRANSLATION_X and TRANSLATION_Y end.
+     *
+     * Other properties may still be animating, if those animations were not started in the same
+     * call. For example:
+     *
+     * animator
+     *   .spring(ALPHA, ...)
+     *   .start()
+     *
+     * animator
+     *   .spring(TRANSLATION_X, ...)
+     *   .spring(TRANSLATION_Y, ...)
+     *   .withEndAction(action)
+     *   .start()
+     *
+     * 'action' will still be run as soon as TRANSLATION_X and TRANSLATION_Y end, even if ALPHA is
+     * still animating.
+     *
+     * If you want to run actions as soon as a subset of property animations have ended, you want
+     * access to the animation's end value/velocity, or you want to run these actions even if the
+     * animation is explicitly canceled, use [addEndListener]. End listeners have an allEnded param,
+     * which indicates that all relevant animations have ended.
+     */
+    fun withEndActions(vararg endActions: EndAction?): PhysicsAnimator<T> {
+        this.endActions.addAll(endActions.filterNotNull())
+        return this
+    }
+
+    /**
+     * Helper overload so that callers from Java can use Runnables or method references as end
+     * actions without having to explicitly return Unit.
+     */
+    fun withEndActions(vararg endActions: Runnable?): PhysicsAnimator<T> {
+        this.endActions.addAll(endActions.filterNotNull().map { it::run })
+        return this
+    }
+
+    fun setDefaultSpringConfig(defaultSpring: SpringConfig) {
+        this.defaultSpring = defaultSpring
+    }
+
+    fun setDefaultFlingConfig(defaultFling: FlingConfig) {
+        this.defaultFling = defaultFling
+    }
+
+    /** Starts the animations! */
+    fun start() {
+        startAction()
+    }
+
+    /**
+     * Starts the animations for real! This is typically called immediately by [start] unless this
+     * animator is under test.
+     */
+    internal fun startInternal() {
+        val target = weakTarget.get()
+        if (target == null) {
+            Log.w(TAG, "Trying to animate a GC-ed object.")
+            return
+        }
+
+        // Functions that will actually start the animations. These are run after we build and add
+        // the InternalListener, since some animations might update/end immediately and we don't
+        // want to miss those updates.
+        val animationStartActions = ArrayList<() -> Unit>()
+
+        for (animatedProperty in getAnimatedProperties()) {
+            val flingConfig = flingConfigs[animatedProperty]
+            val springConfig = springConfigs[animatedProperty]
+
+            // The property's current value on the object.
+            val currentValue = animatedProperty.getValue(target)
+
+            // Start by checking for a fling configuration. If one is present, we're either flinging
+            // or flinging-then-springing. Either way, we'll want to start the fling first.
+            if (flingConfig != null) {
+                animationStartActions.add {
+                    // When the animation is starting, adjust the min/max bounds to include the
+                    // current value of the property, if necessary. This is required to allow a
+                    // fling to bring an out-of-bounds object back into bounds. For example, if an
+                    // object was dragged halfway off the left side of the screen, but then flung to
+                    // the right, we don't want the animation to end instantly just because the
+                    // object started out of bounds. If the fling is in the direction that would
+                    // take it farther out of bounds, it will end instantly as expected.
+                    flingConfig.apply {
+                        min = min(currentValue, this.min)
+                        max = max(currentValue, this.max)
+                    }
+
+                    // Flings can't be updated to a new position while maintaining velocity, because
+                    // we're using the explicitly provided start velocity. Cancel any flings (or
+                    // springs) on this property before flinging.
+                    cancel(animatedProperty)
+
+                    // Apply the configuration and start the animation.
+                    getFlingAnimation(animatedProperty, target)
+                        .also { flingConfig.applyToAnimation(it) }.start()
+                }
+            }
+
+            // Check for a spring configuration. If one is present, we're either springing, or
+            // flinging-then-springing.
+            if (springConfig != null) {
+                // If there is no corresponding fling config, we're only springing.
+                if (flingConfig == null) {
+                    // Apply the configuration and start the animation.
+                    val springAnim = getSpringAnimation(animatedProperty, target)
+
+                    // Apply the configuration and start the animation.
+                    springConfig.applyToAnimation(springAnim)
+                    animationStartActions.add(springAnim::start)
+                } else {
+                    // If there's a corresponding fling config, we're flinging-then-springing. Save
+                    // the fling's original bounds so we can spring to them when the fling ends.
+                    val flingMin = flingConfig.min
+                    val flingMax = flingConfig.max
+
+                    // Add an end listener that will start the spring when the fling ends.
+                    endListeners.add(0, object : EndListener<T> {
+                        override fun onAnimationEnd(
+                            target: T,
+                            property: FloatPropertyCompat<in T>,
+                            wasFling: Boolean,
+                            canceled: Boolean,
+                            finalValue: Float,
+                            finalVelocity: Float,
+                            allRelevantPropertyAnimsEnded: Boolean
+                        ) {
+                            // If this isn't the relevant property, it wasn't a fling, or the fling
+                            // was explicitly cancelled, don't spring.
+                            if (property != animatedProperty || !wasFling || canceled) {
+                                return
+                            }
+
+                            val endedWithVelocity = abs(finalVelocity) > 0
+
+                            // If the object was out of bounds when the fling animation started, it
+                            // will immediately end. In that case, we'll spring it back in bounds.
+                            val endedOutOfBounds = finalValue !in flingMin..flingMax
+
+                            // If the fling ended either out of bounds or with remaining velocity,
+                            // it's time to spring.
+                            if (endedWithVelocity || endedOutOfBounds) {
+                                springConfig.startVelocity = finalVelocity
+
+                                // If the spring's final position isn't set, this is a
+                                // flingThenSpring where flingMustReachMinOrMax was false. We'll
+                                // need to set the spring's final position here.
+                                if (springConfig.finalPosition == UNSET) {
+                                    if (endedWithVelocity) {
+                                        // If the fling ended with negative velocity, that means it
+                                        // hit the min bound, so spring to that bound (and vice
+                                        // versa).
+                                        springConfig.finalPosition =
+                                                if (finalVelocity < 0) flingMin else flingMax
+                                    } else if (endedOutOfBounds) {
+                                        // If the fling ended out of bounds, spring it to the
+                                        // nearest bound.
+                                        springConfig.finalPosition =
+                                                if (finalValue < flingMin) flingMin else flingMax
+                                    }
+                                }
+
+                                // Apply the configuration and start the spring animation.
+                                getSpringAnimation(animatedProperty, target)
+                                    .also { springConfig.applyToAnimation(it) }.start()
+                            }
+                        }
+                    })
+                }
+            }
+        }
+
+        // Add an internal listener that will dispatch animation events to the provided listeners.
+        internalListeners.add(InternalListener(
+                target,
+                getAnimatedProperties(),
+                ArrayList(updateListeners),
+                ArrayList(endListeners),
+                ArrayList(endActions)))
+
+        // Actually start the DynamicAnimations. This is delayed until after the InternalListener is
+        // constructed and added so that we don't miss the end listener firing for any animations
+        // that immediately end.
+        animationStartActions.forEach { it.invoke() }
+
+        clearAnimator()
+    }
+
+    /** Clear the animator's builder variables. */
+    private fun clearAnimator() {
+        springConfigs.clear()
+        flingConfigs.clear()
+
+        updateListeners.clear()
+        endListeners.clear()
+        endActions.clear()
+    }
+
+    /** Retrieves a spring animation for the given property, building one if needed. */
+    private fun getSpringAnimation(
+        property: FloatPropertyCompat<in T>,
+        target: T
+    ): SpringAnimation {
+        return springAnimations.getOrPut(
+                property,
+                { configureDynamicAnimation(SpringAnimation(target, property), property)
+                        as SpringAnimation })
+    }
+
+    /** Retrieves a fling animation for the given property, building one if needed. */
+    private fun getFlingAnimation(property: FloatPropertyCompat<in T>, target: T): FlingAnimation {
+        return flingAnimations.getOrPut(
+                property,
+                { configureDynamicAnimation(FlingAnimation(target, property), property)
+                        as FlingAnimation })
+    }
+
+    /**
+     * Adds update and end listeners to the DynamicAnimation which will dispatch to the internal
+     * listeners.
+     */
+    private fun configureDynamicAnimation(
+        anim: DynamicAnimation<*>,
+        property: FloatPropertyCompat<in T>
+    ): DynamicAnimation<*> {
+        anim.addUpdateListener { _, value, velocity ->
+            for (i in 0 until internalListeners.size) {
+                internalListeners[i].onInternalAnimationUpdate(property, value, velocity)
+            }
+        }
+        anim.addEndListener { _, canceled, value, velocity ->
+            internalListeners.removeAll {
+                it.onInternalAnimationEnd(
+                        property, canceled, value, velocity, anim is FlingAnimation)
+            }
+            if (springAnimations[property] == anim) {
+                springAnimations.remove(property)
+            }
+            if (flingAnimations[property] == anim) {
+                flingAnimations.remove(property)
+            }
+        }
+        return anim
+    }
+
+    /**
+     * Internal listener class that receives updates from DynamicAnimation listeners, and dispatches
+     * them to the appropriate update/end listeners. This class is also aware of which properties
+     * were being animated when the end listeners were passed in, so that we can provide the
+     * appropriate value for allEnded to [EndListener.onAnimationEnd].
+     */
+    internal inner class InternalListener constructor(
+        private val target: T,
+        private var properties: Set<FloatPropertyCompat<in T>>,
+        private var updateListeners: List<UpdateListener<T>>,
+        private var endListeners: List<EndListener<T>>,
+        private var endActions: List<EndAction>
+    ) {
+
+        /** The number of properties whose animations haven't ended. */
+        private var numPropertiesAnimating = properties.size
+
+        /**
+         * Update values that haven't yet been dispatched because not all property animations have
+         * updated yet.
+         */
+        private val undispatchedUpdates =
+                ArrayMap<FloatPropertyCompat<in T>, AnimationUpdate>()
+
+        /** Called when a DynamicAnimation updates.  */
+        internal fun onInternalAnimationUpdate(
+            property: FloatPropertyCompat<in T>,
+            value: Float,
+            velocity: Float
+        ) {
+            // If this property animation isn't relevant to this listener, ignore it.
+            if (!properties.contains(property)) {
+                return
+            }
+
+            undispatchedUpdates[property] = AnimationUpdate(value, velocity)
+            maybeDispatchUpdates()
+        }
+
+        /**
+         * Called when a DynamicAnimation ends.
+         *
+         * @return True if this listener should be removed from the list of internal listeners, so
+         * it no longer receives updates from DynamicAnimations.
+         */
+        internal fun onInternalAnimationEnd(
+            property: FloatPropertyCompat<in T>,
+            canceled: Boolean,
+            finalValue: Float,
+            finalVelocity: Float,
+            isFling: Boolean
+        ): Boolean {
+            // If this property animation isn't relevant to this listener, ignore it.
+            if (!properties.contains(property)) {
+                return false
+            }
+
+            // Dispatch updates if we have one for each property.
+            numPropertiesAnimating--
+            maybeDispatchUpdates()
+
+            // If we didn't have an update for each property, dispatch the update for the ending
+            // property. This guarantees that an update isn't sent for this property *after* we call
+            // onAnimationEnd for that property.
+            if (undispatchedUpdates.contains(property)) {
+                updateListeners.forEach { updateListener ->
+                    updateListener.onAnimationUpdateForProperty(
+                            target,
+                            UpdateMap<T>().also { it[property] = undispatchedUpdates[property] })
+                }
+
+                undispatchedUpdates.remove(property)
+            }
+
+            val allEnded = !arePropertiesAnimating(properties)
+            endListeners.forEach {
+                it.onAnimationEnd(
+                        target, property, isFling, canceled, finalValue, finalVelocity,
+                        allEnded)
+
+                // Check that the end listener didn't restart this property's animation.
+                if (isPropertyAnimating(property)) {
+                    return false
+                }
+            }
+
+            // If all of the animations that this listener cares about have ended, run the end
+            // actions unless the animation was canceled.
+            if (allEnded && !canceled) {
+                endActions.forEach { it() }
+            }
+
+            return allEnded
+        }
+
+        /**
+         * Dispatch undispatched values if we've received an update from each of the animating
+         * properties.
+         */
+        private fun maybeDispatchUpdates() {
+            if (undispatchedUpdates.size >= numPropertiesAnimating &&
+                    undispatchedUpdates.size > 0) {
+                updateListeners.forEach {
+                    it.onAnimationUpdateForProperty(target, ArrayMap(undispatchedUpdates))
+                }
+
+                undispatchedUpdates.clear()
+            }
+        }
+    }
+
+    /** Return true if any animations are running on the object.  */
+    fun isRunning(): Boolean {
+        return arePropertiesAnimating(springAnimations.keys.union(flingAnimations.keys))
+    }
+
+    /** Returns whether the given property is animating.  */
+    fun isPropertyAnimating(property: FloatPropertyCompat<in T>): Boolean {
+        return springAnimations[property]?.isRunning ?: false ||
+                flingAnimations[property]?.isRunning ?: false
+    }
+
+    /** Returns whether any of the given properties are animating.  */
+    fun arePropertiesAnimating(properties: Set<FloatPropertyCompat<in T>>): Boolean {
+        return properties.any { isPropertyAnimating(it) }
+    }
+
+    /** Return the set of properties that will begin animating upon calling [start]. */
+    internal fun getAnimatedProperties(): Set<FloatPropertyCompat<in T>> {
+        return springConfigs.keys.union(flingConfigs.keys)
+    }
+
+    /**
+     * Cancels the given properties. This is typically called immediately by [cancel], unless this
+     * animator is under test.
+     */
+    internal fun cancelInternal(properties: Set<FloatPropertyCompat<in T>>) {
+        for (property in properties) {
+            flingAnimations[property]?.cancel()
+            springAnimations[property]?.cancel()
+        }
+    }
+
+    /** Cancels all in progress animations on all properties. */
+    fun cancel() {
+        if (flingAnimations.size > 0) {
+            cancelAction(flingAnimations.keys)
+        }
+        if (springAnimations.size > 0) {
+            cancelAction(springAnimations.keys)
+        }
+    }
+
+    /** Cancels in progress animations on the provided properties only. */
+    fun cancel(vararg properties: FloatPropertyCompat<in T>) {
+        cancelAction(properties.toSet())
+    }
+
+    /**
+     * Container object for spring animation configuration settings. This allows you to store
+     * default stiffness and damping ratio values in a single configuration object, which you can
+     * pass to [spring].
+     */
+    data class SpringConfig internal constructor(
+        var stiffness: Float,
+        internal var dampingRatio: Float,
+        internal var startVelocity: Float = 0f,
+        internal var finalPosition: Float = UNSET
+    ) {
+
+        constructor() :
+                this(globalDefaultSpring.stiffness, globalDefaultSpring.dampingRatio)
+
+        constructor(stiffness: Float, dampingRatio: Float) :
+                this(stiffness = stiffness, dampingRatio = dampingRatio, startVelocity = 0f)
+
+        /** Apply these configuration settings to the given SpringAnimation. */
+        internal fun applyToAnimation(anim: SpringAnimation) {
+            val springForce = anim.spring ?: SpringForce()
+            anim.spring = springForce.apply {
+                stiffness = this@SpringConfig.stiffness
+                dampingRatio = this@SpringConfig.dampingRatio
+                finalPosition = this@SpringConfig.finalPosition
+            }
+
+            if (startVelocity != 0f) anim.setStartVelocity(startVelocity)
+        }
+    }
+
+    /**
+     * Container object for fling animation configuration settings. This allows you to store default
+     * friction values (as well as optional min/max values) in a single configuration object, which
+     * you can pass to [fling] and related methods.
+     */
+    data class FlingConfig internal constructor(
+        internal var friction: Float,
+        var min: Float,
+        var max: Float,
+        internal var startVelocity: Float
+    ) {
+
+        constructor() : this(globalDefaultFling.friction)
+
+        constructor(friction: Float) :
+                this(friction, globalDefaultFling.min, globalDefaultFling.max)
+
+        constructor(friction: Float, min: Float, max: Float) :
+                this(friction, min, max, startVelocity = 0f)
+
+        /** Apply these configuration settings to the given FlingAnimation. */
+        internal fun applyToAnimation(anim: FlingAnimation) {
+            anim.apply {
+                friction = this@FlingConfig.friction
+                setMinValue(min)
+                setMaxValue(max)
+                setStartVelocity(startVelocity)
+            }
+        }
+    }
+
+    /**
+     * Listener for receiving values from in progress animations. Used with
+     * [PhysicsAnimator.addUpdateListener].
+     *
+     * @param <T> The type of the object being animated.
+    </T> */
+    fun interface UpdateListener<T> {
+
+        /**
+         * Called on each animation frame with the target object, and a map of FloatPropertyCompat
+         * -> AnimationUpdate, containing the latest value and velocity for that property. When
+         * multiple properties are animating together, the map will typically contain one entry for
+         * each property. However, you should never assume that this is the case - when a property
+         * animation ends earlier than the others, you'll receive an UpdateMap containing only that
+         * property's final update. Subsequently, you'll only receive updates for the properties
+         * that are still animating.
+         *
+         * Always check that the map contains an update for the property you're interested in before
+         * accessing it.
+         *
+         * @param target The animated object itself.
+         * @param values Map of property to AnimationUpdate, which contains that property
+         * animation's latest value and velocity. You should never assume that a particular property
+         * is present in this map.
+         */
+        fun onAnimationUpdateForProperty(
+            target: T,
+            values: UpdateMap<T>
+        )
+    }
+
+    /**
+     * Listener for receiving callbacks when animations end.
+     *
+     * @param <T> The type of the object being animated.
+    </T> */
+    fun interface EndListener<T> {
+
+        /**
+         * Called with the final animation values as each property animation ends. This can be used
+         * to respond to specific property animations concluding (such as hiding a view when ALPHA
+         * ends, even if the corresponding TRANSLATION animations have not ended).
+         *
+         * If you just want to run an action when all of the property animations have ended, you can
+         * use [PhysicsAnimator.withEndActions].
+         *
+         * @param target The animated object itself.
+         * @param property The property whose animation has just ended.
+         * @param wasFling Whether this property ended after a fling animation (as opposed to a
+         * spring animation). If this property was animated via [flingThenSpring], this will be true
+         * if the fling animation did not reach the min/max bounds, decelerating to a stop
+         * naturally. It will be false if it hit the bounds and was sprung back.
+         * @param canceled Whether the animation was explicitly canceled before it naturally ended.
+         * @param finalValue The final value of the animated property.
+         * @param finalVelocity The final velocity (in pixels per second) of the ended animation.
+         * This is typically zero, unless this was a fling animation which ended abruptly due to
+         * reaching its configured min/max values.
+         * @param allRelevantPropertyAnimsEnded Whether all properties relevant to this end listener
+         * have ended. Relevant properties are those which were animated alongside the
+         * [addEndListener] call where this animator was passed in. For example:
+         *
+         * animator
+         *    .spring(TRANSLATION_X, 100f)
+         *    .spring(TRANSLATION_Y, 200f)
+         *    .withEndListener(firstEndListener)
+         *    .start()
+         *
+         * firstEndListener will be called first for TRANSLATION_X, with allEnded = false,
+         * because TRANSLATION_Y is still running. When TRANSLATION_Y ends, it'll be called with
+         * allEnded = true.
+         *
+         * If a subsequent call to start() is made with other properties, those properties are not
+         * considered relevant and allEnded will still equal true when only TRANSLATION_X and
+         * TRANSLATION_Y end. For example, if immediately after the prior example, while
+         * TRANSLATION_X and TRANSLATION_Y are still animating, we called:
+         *
+         * animator.
+         *    .spring(SCALE_X, 2f, stiffness = 10f) // That will take awhile...
+         *    .withEndListener(secondEndListener)
+         *    .start()
+         *
+         * firstEndListener will still be called with allEnded = true when TRANSLATION_X/Y end, even
+         * though SCALE_X is still animating. Similarly, secondEndListener will be called with
+         * allEnded = true as soon as SCALE_X ends, even if the translation animations are still
+         * running.
+         */
+        fun onAnimationEnd(
+            target: T,
+            property: FloatPropertyCompat<in T>,
+            wasFling: Boolean,
+            canceled: Boolean,
+            finalValue: Float,
+            finalVelocity: Float,
+            allRelevantPropertyAnimsEnded: Boolean
+        )
+    }
+
+    companion object {
+
+        /**
+         * Callback to notify that a new animator was created. Used in [PhysicsAnimatorTestUtils]
+         * to be able to keep track of animators and wait for them to finish.
+         */
+        internal var onAnimatorCreated: (PhysicsAnimator<*>, Any) -> Unit = { _, _ -> }
+
+        @JvmStatic
+        @Suppress("UNCHECKED_CAST")
+        fun <T : Any> getInstance(target: T): PhysicsAnimator<T> {
+            if (!animators.containsKey(target)) {
+                val animator = PhysicsAnimator(target)
+                onAnimatorCreated(animator, target)
+                animators[target] = animator
+            }
+
+            return animators[target] as PhysicsAnimator<T>
+        }
+
+        /**
+         * Set whether all physics animators should log a lot of information about animations.
+         * Useful for debugging!
+         */
+        @JvmStatic
+        fun setVerboseLogging(debug: Boolean) {
+            verboseLogging = debug
+        }
+
+        /**
+         * Estimates the end value of a fling that starts at the given value using the provided
+         * start velocity and fling configuration.
+         *
+         * This is only an estimate. Fling animations use a timing-based physics simulation that is
+         * non-deterministic, so this exact value may not be reached.
+         */
+        @JvmStatic
+        fun estimateFlingEndValue(
+            startValue: Float,
+            startVelocity: Float,
+            flingConfig: FlingConfig
+        ): Float {
+            val distance = startVelocity / (flingConfig.friction * FLING_FRICTION_SCALAR_MULTIPLIER)
+            return Math.min(flingConfig.max, Math.max(flingConfig.min, startValue + distance))
+        }
+
+        @JvmStatic
+        fun getReadablePropertyName(property: FloatPropertyCompat<*>): String {
+            return when (property) {
+                DynamicAnimation.TRANSLATION_X -> "translationX"
+                DynamicAnimation.TRANSLATION_Y -> "translationY"
+                DynamicAnimation.TRANSLATION_Z -> "translationZ"
+                DynamicAnimation.SCALE_X -> "scaleX"
+                DynamicAnimation.SCALE_Y -> "scaleY"
+                DynamicAnimation.ROTATION -> "rotation"
+                DynamicAnimation.ROTATION_X -> "rotationX"
+                DynamicAnimation.ROTATION_Y -> "rotationY"
+                DynamicAnimation.SCROLL_X -> "scrollX"
+                DynamicAnimation.SCROLL_Y -> "scrollY"
+                DynamicAnimation.ALPHA -> "alpha"
+                else -> "Custom FloatPropertyCompat instance"
+            }
+        }
+    }
+}
diff --git a/wmshell/shared/src/com/android/wm/shell/shared/animation/PhysicsAnimatorTestUtils.kt b/wmshell/shared/src/com/android/wm/shell/shared/animation/PhysicsAnimatorTestUtils.kt
new file mode 100644
index 0000000000..235b9bf7b9
--- /dev/null
+++ b/wmshell/shared/src/com/android/wm/shell/shared/animation/PhysicsAnimatorTestUtils.kt
@@ -0,0 +1,480 @@
+/*
+ * 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.wm.shell.shared.animation
+
+import android.os.Handler
+import android.os.Looper
+import android.util.ArrayMap
+import androidx.dynamicanimation.animation.FloatPropertyCompat
+import com.android.wm.shell.shared.animation.PhysicsAnimatorTestUtils.prepareForTest
+import java.util.*
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import kotlin.collections.ArrayList
+import kotlin.collections.HashMap
+import kotlin.collections.HashSet
+import kotlin.collections.Set
+import kotlin.collections.component1
+import kotlin.collections.component2
+import kotlin.collections.drop
+import kotlin.collections.forEach
+import kotlin.collections.getOrPut
+import kotlin.collections.set
+import kotlin.collections.toList
+import kotlin.collections.toTypedArray
+
+typealias UpdateMatcher = (PhysicsAnimator.AnimationUpdate) -> Boolean
+typealias UpdateFramesPerProperty<T> =
+        ArrayMap<FloatPropertyCompat<in T>, ArrayList<PhysicsAnimator.AnimationUpdate>>
+
+/**
+ * Utilities for testing code that uses [PhysicsAnimator].
+ *
+ * Start by calling [prepareForTest] at the beginning of each test - this will modify the behavior
+ * of all PhysicsAnimator instances so that they post animations to the main thread (so they don't
+ * crash). It'll also enable the use of the other static helper methods in this class, which you can
+ * use to do things like block the test until animations complete (so you can test end states), or
+ * verify keyframes.
+ */
+object PhysicsAnimatorTestUtils {
+    var timeoutMs: Long = 2000
+    private var startBlocksUntilAnimationsEnd = false
+    private val animationThreadHandler = Handler(Looper.getMainLooper())
+    private val allAnimatedObjects = HashSet<Any>()
+    private val animatorTestHelpers = HashMap<PhysicsAnimator<*>, AnimatorTestHelper<*>>()
+
+    /**
+     * Modifies the behavior of all [PhysicsAnimator] instances so that they post animations to the
+     * main thread, and report all of their
+     */
+    @JvmStatic
+    fun prepareForTest() {
+        PhysicsAnimator.onAnimatorCreated = { animator, target ->
+            allAnimatedObjects.add(target)
+            animatorTestHelpers[animator] = AnimatorTestHelper(animator)
+        }
+
+        timeoutMs = 2000
+        startBlocksUntilAnimationsEnd = false
+        allAnimatedObjects.clear()
+    }
+
+    @JvmStatic
+    fun tearDown() {
+        val latch = CountDownLatch(1)
+        animationThreadHandler.post {
+            animatorTestHelpers.keys.forEach { it.cancel() }
+            latch.countDown()
+        }
+
+        latch.await()
+
+        animatorTestHelpers.clear()
+        animators.clear()
+        allAnimatedObjects.clear()
+    }
+
+    /**
+     * Sets the maximum time (in milliseconds) to block the test thread while waiting for animations
+     * before throwing an exception.
+     */
+    @JvmStatic
+    fun setBlockTimeout(timeoutMs: Long) {
+        PhysicsAnimatorTestUtils.timeoutMs = timeoutMs
+    }
+
+    /**
+     * Sets whether all animations should block the test thread until they end. This is typically
+     * the desired behavior, since you can invoke code that runs an animation and then assert things
+     * about its end state.
+     */
+    @JvmStatic
+    fun setAllAnimationsBlock(block: Boolean) {
+        startBlocksUntilAnimationsEnd = block
+    }
+
+    /**
+     * Blocks the calling thread until animations of the given property on the target object end.
+     */
+    @JvmStatic
+    @Throws(InterruptedException::class)
+    fun <T : Any> blockUntilAnimationsEnd(
+        animator: PhysicsAnimator<T>,
+        vararg properties: FloatPropertyCompat<in T>
+    ) {
+        val animatingProperties = HashSet<FloatPropertyCompat<in T>>()
+        for (property in properties) {
+            if (animator.isPropertyAnimating(property)) {
+                animatingProperties.add(property)
+            }
+        }
+
+        if (animatingProperties.size > 0) {
+            val latch = CountDownLatch(animatingProperties.size)
+            getAnimationTestHelper(animator).addTestEndListener(
+                    object : PhysicsAnimator.EndListener<T> {
+                override fun onAnimationEnd(
+                    target: T,
+                    property: FloatPropertyCompat<in T>,
+                    wasFling: Boolean,
+                    canceled: Boolean,
+                    finalValue: Float,
+                    finalVelocity: Float,
+                    allRelevantPropertyAnimsEnded: Boolean
+                ) {
+                    if (animatingProperties.contains(property)) {
+                        latch.countDown()
+                    }
+                }
+            })
+
+            latch.await(timeoutMs, TimeUnit.MILLISECONDS)
+        }
+    }
+
+    /**
+     * Blocks the calling thread until all animations of the given property (on all target objects)
+     * have ended. Useful when you don't have access to the objects being animated, but still need
+     * to wait for them to end so that other testable side effects occur (such as update/end
+     * listeners).
+     */
+    @JvmStatic
+    @Throws(InterruptedException::class)
+    @Suppress("UNCHECKED_CAST")
+    fun <T : Any> blockUntilAnimationsEnd(
+        vararg properties: FloatPropertyCompat<in T>
+    ) {
+        for (target in allAnimatedObjects) {
+            try {
+                blockUntilAnimationsEnd(
+                        PhysicsAnimator.getInstance(target) as PhysicsAnimator<T>, *properties)
+            } catch (e: ClassCastException) {
+                // Keep checking the other objects for ones whose types match the provided
+                // properties.
+            }
+        }
+    }
+
+    /**
+     * Blocks the calling thread until the first animation frame in which predicate returns true. If
+     * the given object isn't animating, returns without blocking.
+     */
+    @JvmStatic
+    @Throws(InterruptedException::class)
+    fun <T : Any> blockUntilFirstAnimationFrameWhereTrue(
+        animator: PhysicsAnimator<T>,
+        predicate: (T) -> Boolean
+    ) {
+        if (animator.isRunning()) {
+            val latch = CountDownLatch(1)
+            getAnimationTestHelper(animator).addTestUpdateListener(object : PhysicsAnimator
+            .UpdateListener<T> {
+                override fun onAnimationUpdateForProperty(
+                    target: T,
+                    values: UpdateMap<T>
+                ) {
+                    if (predicate(target)) {
+                        latch.countDown()
+                    }
+                }
+            })
+
+            latch.await(timeoutMs, TimeUnit.MILLISECONDS)
+        }
+    }
+
+    /**
+     * Verifies that the animator reported animation frame values to update listeners that satisfy
+     * the given matchers, in order. Not all frames need to satisfy a matcher - we'll run through
+     * all animation frames, and check them against the current predicate. If it returns false, we
+     * continue through the frames until it returns true, and then move on to the next matcher.
+     * Verification fails if we run out of frames while unsatisfied matchers remain.
+     *
+     * If verification is successful, all frames to this point are considered 'verified' and will be
+     * cleared. Subsequent calls to this method will start verification at the next animation frame.
+     *
+     * Example: Verify that an animation surpassed x = 50f before going negative.
+     * verifyAnimationUpdateFrames(
+     *    animator, TRANSLATION_X,
+     *    { u -> u.value > 50f },
+     *    { u -> u.value < 0f })
+     *
+     * Example: verify that an animation went backwards at some point while still being on-screen.
+     * verifyAnimationUpdateFrames(
+     *    animator, TRANSLATION_X,
+     *    { u -> u.velocity < 0f && u.value >= 0f })
+     *
+     * This method is intended to help you test longer, more complicated animations where it's
+     * critical that certain values were reached. Using this method to test short animations can
+     * fail due to the animation having fewer frames than provided matchers. For example, an
+     * animation from x = 1f to x = 5f might only have two frames, at x = 3f and x = 5f. The
+     * following would then fail despite it seeming logically sound:
+     *
+     * verifyAnimationUpdateFrames(
+     *    animator, TRANSLATION_X,
+     *    { u -> u.value > 1f },
+     *    { u -> u.value > 2f },
+     *    { u -> u.value > 3f })
+     *
+     * Tests might also fail if your matchers are too granular, such as this example test after an
+     * animation from x = 0f to x = 100f. It's unlikely there was a frame specifically between 2f
+     * and 3f.
+     *
+     * verifyAnimationUpdateFrames(
+     *    animator, TRANSLATION_X,
+     *    { u -> u.value > 2f && u.value < 3f },
+     *    { u -> u.value >= 50f })
+     *
+     * Failures will print a helpful log of all animation frames so you can see what caused the test
+     * to fail.
+     */
+    fun <T : Any> verifyAnimationUpdateFrames(
+        animator: PhysicsAnimator<T>,
+        property: FloatPropertyCompat<in T>,
+        firstUpdateMatcher: UpdateMatcher,
+        vararg additionalUpdateMatchers: UpdateMatcher
+    ) {
+        val updateFrames: UpdateFramesPerProperty<T> = getAnimationUpdateFrames(animator)
+
+        if (!updateFrames.containsKey(property)) {
+            error("No frames for given target object and property.")
+        }
+
+        // Copy the frames to avoid a ConcurrentModificationException if the animation update
+        // listeners attempt to add a new frame while we're verifying these.
+        val framesForProperty = ArrayList(updateFrames[property]!!)
+        val matchers = ArrayDeque<UpdateMatcher>(
+                additionalUpdateMatchers.toList())
+        val frameTraceMessage = StringBuilder()
+
+        var curMatcher = firstUpdateMatcher
+
+        // Loop through the updates from the testable animator.
+        for (update in framesForProperty) {
+            // Check whether this frame satisfies the current matcher.
+            if (curMatcher(update)) {
+                // If that was the last unsatisfied matcher, we're good here. 'Verify' all remaining
+                // frames and return without failing.
+                if (matchers.size == 0) {
+                    getAnimationUpdateFrames(animator).remove(property)
+                    return
+                }
+
+                frameTraceMessage.append("$update\t(satisfied matcher)\n")
+                curMatcher = matchers.pop() // Get the next matcher and keep going.
+            } else {
+                frameTraceMessage.append("${update}\n")
+            }
+        }
+
+        val readablePropertyName = PhysicsAnimator.getReadablePropertyName(property)
+        getAnimationUpdateFrames(animator).remove(property)
+
+        throw RuntimeException(
+                "Failed to verify animation frames for property $readablePropertyName: " +
+                        "Provided ${additionalUpdateMatchers.size + 1} matchers, " +
+                        "however ${matchers.size + 1} remained unsatisfied.\n\n" +
+                        "All frames:\n$frameTraceMessage")
+    }
+
+    /**
+     * Overload of [verifyAnimationUpdateFrames] that builds matchers for you, from given float
+     * values. For example, to verify that an animations passed from 0f to 50f to 100f back to 50f:
+     *
+     * verifyAnimationUpdateFrames(animator, TRANSLATION_X, 0f, 50f, 100f, 50f)
+     *
+     * This verifies that update frames were received with values of >= 0f, >= 50f, >= 100f, and
+     * <= 50f.
+     *
+     * The same caveats apply: short animations might not have enough frames to satisfy all of the
+     * matchers, and overly specific calls (such as 0f, 1f, 2f, 3f, etc. for an animation from
+     * x = 0f to x = 100f) might fail as the animation only had frames at 0f, 25f, 50f, 75f, and
+     * 100f. As with [verifyAnimationUpdateFrames], failures will print a helpful log of all frames
+     * so you can see what caused the test to fail.
+     */
+    fun <T : Any> verifyAnimationUpdateFrames(
+        animator: PhysicsAnimator<T>,
+        property: FloatPropertyCompat<in T>,
+        startValue: Float,
+        firstTargetValue: Float,
+        vararg additionalTargetValues: Float
+    ) {
+        val matchers = ArrayList<UpdateMatcher>()
+
+        val values = ArrayList<Float>().also {
+            it.add(firstTargetValue)
+            it.addAll(additionalTargetValues.toList())
+        }
+
+        var prevVal = startValue
+        for (value in values) {
+            if (value > prevVal) {
+                matchers.add { update -> update.value >= value }
+            } else {
+                matchers.add { update -> update.value <= value }
+            }
+
+            prevVal = value
+        }
+
+        verifyAnimationUpdateFrames(
+                animator, property, matchers[0], *matchers.drop(0).toTypedArray())
+    }
+
+    /**
+     * Returns all of the values that have ever been reported to update listeners, per property.
+     */
+    @Suppress("UNCHECKED_CAST")
+    fun <T : Any> getAnimationUpdateFrames(animator: PhysicsAnimator<T>):
+            UpdateFramesPerProperty<T> {
+        return animatorTestHelpers[animator]?.getUpdates() as UpdateFramesPerProperty<T>
+    }
+
+    /**
+     * Clears animation frame updates from the given animator so they aren't used the next time its
+     * passed to [verifyAnimationUpdateFrames].
+     */
+    fun <T : Any> clearAnimationUpdateFrames(animator: PhysicsAnimator<T>) {
+        animatorTestHelpers[animator]?.clearUpdates()
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun <T> getAnimationTestHelper(animator: PhysicsAnimator<T>): AnimatorTestHelper<T> {
+        return animatorTestHelpers[animator] as AnimatorTestHelper<T>
+    }
+
+    /**
+     * Helper class for testing an animator. This replaces the animator's start action with
+     * [startForTest] and adds test listeners to enable other test utility behaviors. We build one
+     * these for each Animator and keep them around so we can access the updates.
+     */
+    class AnimatorTestHelper<T> (private val animator: PhysicsAnimator<T>) {
+
+        /** All updates received for each property animation. */
+        private val allUpdates =
+                ArrayMap<FloatPropertyCompat<in T>, ArrayList<PhysicsAnimator.AnimationUpdate>>()
+
+        private val testEndListeners = ArrayList<PhysicsAnimator.EndListener<T>>()
+        private val testUpdateListeners = ArrayList<PhysicsAnimator.UpdateListener<T>>()
+
+        /** Whether we're currently in the middle of executing startInternal(). */
+        private var currentlyRunningStartInternal = false
+
+        init {
+            animator.startAction = ::startForTest
+            animator.cancelAction = ::cancelForTest
+        }
+
+        internal fun addTestEndListener(listener: PhysicsAnimator.EndListener<T>) {
+            testEndListeners.add(listener)
+        }
+
+        internal fun addTestUpdateListener(listener: PhysicsAnimator.UpdateListener<T>) {
+            testUpdateListeners.add(listener)
+        }
+
+        internal fun getUpdates(): UpdateFramesPerProperty<T> {
+            return allUpdates
+        }
+
+        internal fun clearUpdates() {
+            allUpdates.clear()
+        }
+
+        private fun startForTest() {
+            // The testable animator needs to block the main thread until super.start() has been
+            // called, since callers expect .start() to be synchronous but we're posting it to a
+            // handler here. We may also continue blocking until all animations end, if
+            // startBlocksUntilAnimationsEnd = true.
+            val unblockLatch = CountDownLatch(if (startBlocksUntilAnimationsEnd) 2 else 1)
+
+            animationThreadHandler.post {
+                // Add an update listener that dispatches to any test update listeners added by
+                // tests.
+                animator.addUpdateListener(object : PhysicsAnimator.UpdateListener<T> {
+                    override fun onAnimationUpdateForProperty(
+                        target: T,
+                        values: ArrayMap<FloatPropertyCompat<in T>, PhysicsAnimator.AnimationUpdate>
+                    ) {
+                        values.forEach { (property, value) ->
+                            allUpdates.getOrPut(property, { ArrayList() }).add(value)
+                        }
+
+                        for (listener in testUpdateListeners) {
+                            listener.onAnimationUpdateForProperty(target, values)
+                        }
+                    }
+                })
+
+                // Add an end listener that dispatches to any test end listeners added by tests, and
+                // unblocks the main thread if required.
+                animator.addEndListener(object : PhysicsAnimator.EndListener<T> {
+                    override fun onAnimationEnd(
+                        target: T,
+                        property: FloatPropertyCompat<in T>,
+                        wasFling: Boolean,
+                        canceled: Boolean,
+                        finalValue: Float,
+                        finalVelocity: Float,
+                        allRelevantPropertyAnimsEnded: Boolean
+                    ) {
+                        for (listener in testEndListeners) {
+                            listener.onAnimationEnd(
+                                    target, property, wasFling, canceled, finalValue, finalVelocity,
+                                    allRelevantPropertyAnimsEnded)
+                        }
+
+                        if (allRelevantPropertyAnimsEnded) {
+                            testEndListeners.clear()
+                            testUpdateListeners.clear()
+
+                            if (startBlocksUntilAnimationsEnd) {
+                                unblockLatch.countDown()
+                            }
+                        }
+                    }
+                })
+
+                currentlyRunningStartInternal = true
+                animator.startInternal()
+                currentlyRunningStartInternal = false
+                unblockLatch.countDown()
+            }
+
+            unblockLatch.await(timeoutMs, TimeUnit.MILLISECONDS)
+        }
+
+        private fun cancelForTest(properties: Set<FloatPropertyCompat<in T>>) {
+            // If this was called from startInternal, we are already on the animation thread, and
+            // should just call cancelInternal rather than posting it. If we post it, the
+            // cancellation will occur after the rest of startInternal() and we'll immediately
+            // cancel the animation we worked so hard to start!
+            if (currentlyRunningStartInternal) {
+                animator.cancelInternal(properties)
+                return
+            }
+
+            val unblockLatch = CountDownLatch(1)
+
+            animationThreadHandler.post {
+                animator.cancelInternal(properties)
+                unblockLatch.countDown()
+            }
+
+            unblockLatch.await(timeoutMs, TimeUnit.MILLISECONDS)
+        }
+    }
+}