diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 0601958f2e8bbfa87f66d5a0b5123251df12f921..1273803b516a32756c2b0b84bcb5d8e7968605ee 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -15,7 +15,7 @@ cache:
 build:
   stage: build
   script:
-  - ./gradlew build
+  - ./gradlew assembleApiQ
   artifacts:
     paths:
     - app/build/outputs/apk
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 0b7502afca8ec6499bf01eeb2eb5094205045fd0..becf03ecb015af8d1dc37490aa07bee63b564ddc 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,20 +1,12 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
+    <option name="LINE_SEPARATOR" value="&#10;" />
     <JetCodeStyleSettings>
       <option name="PACKAGES_TO_USE_STAR_IMPORTS">
         <value>
           <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
         </value>
       </option>
-      <option name="PACKAGES_IMPORT_LAYOUT">
-        <value>
-          <package name="" alias="false" withSubpackages="true" />
-          <package name="java" alias="false" withSubpackages="true" />
-          <package name="javax" alias="false" withSubpackages="true" />
-          <package name="kotlin" alias="false" withSubpackages="true" />
-          <package name="" alias="true" withSubpackages="true" />
-        </value>
-      </option>
       <option name="NAME_COUNT_TO_USE_STAR_IMPORT" value="2147483647" />
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
@@ -24,6 +16,30 @@
     <XML>
       <option name="XML_LEGACY_SETTINGS_IMPORTED" value="true" />
     </XML>
+    <ADDITIONAL_INDENT_OPTIONS fileType="java">
+      <option name="TAB_SIZE" value="8" />
+    </ADDITIONAL_INDENT_OPTIONS>
+    <ADDITIONAL_INDENT_OPTIONS fileType="js">
+      <option name="CONTINUATION_INDENT_SIZE" value="4" />
+    </ADDITIONAL_INDENT_OPTIONS>
+    <codeStyleSettings language="JAVA">
+      <option name="KEEP_BLANK_LINES_IN_DECLARATIONS" value="1" />
+      <option name="KEEP_BLANK_LINES_IN_CODE" value="1" />
+      <option name="KEEP_BLANK_LINES_BEFORE_RBRACE" value="0" />
+      <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
+      <option name="CALL_PARAMETERS_WRAP" value="5" />
+      <option name="CALL_PARAMETERS_LPAREN_ON_NEXT_LINE" value="true" />
+      <option name="CALL_PARAMETERS_RPAREN_ON_NEXT_LINE" value="true" />
+      <option name="METHOD_PARAMETERS_WRAP" value="5" />
+      <option name="METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE" value="true" />
+      <option name="METHOD_PARAMETERS_RPAREN_ON_NEXT_LINE" value="true" />
+      <option name="EXTENDS_LIST_WRAP" value="1" />
+      <option name="METHOD_CALL_CHAIN_WRAP" value="1" />
+      <option name="ASSIGNMENT_WRAP" value="1" />
+      <indentOptions>
+        <option name="CONTINUATION_INDENT_SIZE" value="4" />
+      </indentOptions>
+    </codeStyleSettings>
     <codeStyleSettings language="JSON">
       <indentOptions>
         <option name="CONTINUATION_INDENT_SIZE" value="4" />
diff --git a/.idea/dictionaries/amit.xml b/.idea/dictionaries/amit.xml
new file mode 100644
index 0000000000000000000000000000000000000000..35041aa9f4a334e78fb789dff0a1284a1fbdbb47
--- /dev/null
+++ b/.idea/dictionaries/amit.xml
@@ -0,0 +1,3 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="amit" />
+</component>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 58918f50335428f2efb3af4d621f9f405ed659d4..9c4f0a65041296f7a0c4ff6818c91c29e53dea01 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,4 +1,12 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK" />
+  <component name="DesignSurface">
+    <option name="filePathToZoomLevelMap">
+      <map>
+        <entry key="../../../../layout/custom_preview.xml" value="0.1" />
+      </map>
+    </option>
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="11" project-jdk-type="JavaSDK" />
+>>>>>>> Stashed changes
 </project>
\ No newline at end of file
diff --git a/.idea/runConfigurations.xml b/.idea/runConfigurations.xml
index 7f68460d8b38ac04e3a3224d7c79ef719b1991a9..e497da999824b5c5629039f2e74794dd96b6c419 100644
--- a/.idea/runConfigurations.xml
+++ b/.idea/runConfigurations.xml
@@ -3,6 +3,7 @@
   <component name="RunConfigurationProducerService">
     <option name="ignoredProducers">
       <set>
+        <option value="com.android.tools.idea.compose.preview.runconfiguration.ComposePreviewRunConfigurationProducer" />
         <option value="org.jetbrains.plugins.gradle.execution.test.runner.AllInPackageGradleConfigurationProducer" />
         <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestClassGradleConfigurationProducer" />
         <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestMethodGradleConfigurationProducer" />
diff --git a/QuickstepCompat/.gitignore b/QuickstepCompat/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..796b96d1c402326528b4ba3c12ee9d92d0e212e9
--- /dev/null
+++ b/QuickstepCompat/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/QuickstepCompat/build.gradle b/QuickstepCompat/build.gradle
new file mode 100644
index 0000000000000000000000000000000000000000..96599673e10a8c721081276333989c0549dfe0b8
--- /dev/null
+++ b/QuickstepCompat/build.gradle
@@ -0,0 +1,38 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-android-extensions'
+apply from: '../spotless/spotless.gradle'
+android {
+    compileSdkVersion 29
+    buildToolsVersion "29.0.2"
+
+
+    defaultConfig {
+        minSdkVersion 25
+        targetSdkVersion 29
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles 'consumer-rules.pro'
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    addFrameworkJar('framework.jar')
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+    implementation 'androidx.appcompat:appcompat:1.0.2'
+    implementation 'androidx.core:core-ktx:1.1.0'
+    testImplementation 'junit:junit:4.12'
+    androidTestImplementation 'androidx.test:runner:1.2.0'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
+}
diff --git a/QuickstepCompat/consumer-rules.pro b/QuickstepCompat/consumer-rules.pro
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/QuickstepCompat/proguard-rules.pro b/QuickstepCompat/proguard-rules.pro
new file mode 100644
index 0000000000000000000000000000000000000000..f1b424510da51fd82143bc74a0a801ae5a1e2fcd
--- /dev/null
+++ b/QuickstepCompat/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
diff --git a/QuickstepCompat/src/main/AndroidManifest.xml b/QuickstepCompat/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000000000000000000000000000000000..aef876601f424d3ad4b62d9e0af9dc703ba14bcc
--- /dev/null
+++ b/QuickstepCompat/src/main/AndroidManifest.xml
@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="xyz.paphonb.quickstep.compat" />
diff --git a/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/ActivityManagerCompat.java b/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/ActivityManagerCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..2262c260ff31e9353e9f59ff4d295e7eb6193c88
--- /dev/null
+++ b/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/ActivityManagerCompat.java
@@ -0,0 +1,52 @@
+package xyz.paphonb.quickstep.compat;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.TaskSnapshot;
+import android.app.IAssistDataReceiver;
+import android.app.ITaskStackListener;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Rect;
+import android.os.Bundle;
+import android.os.RemoteException;
+
+import java.util.List;
+
+public abstract class ActivityManagerCompat {
+
+    public abstract List<ActivityManager.RunningTaskInfo> getFilteredTasks(
+            int maxNum,  int ignoreActivityType, int ignoreWindowingMode) throws RemoteException;
+
+    public abstract List<ActivityManager.RecentTaskInfo> getRecentTasks(
+            int maxNum, int flags, int userId) throws RemoteException;
+
+    public abstract ActivityManager.TaskSnapshot getTaskSnapshot(
+            int taskId, boolean reducedResolution) throws RemoteException;
+
+    public abstract void startRecentsActivity(Intent intent, IAssistDataReceiver assistDataReceiver,
+                                              RecentsAnimationRunner recentsAnimationRunner) throws RemoteException;
+
+    public abstract void cancelRecentsAnimation(boolean restoreHomeStackPosition) throws RemoteException;
+
+    public abstract int startActivityFromRecents(int taskId, Bundle bOptions) throws RemoteException;
+
+    public abstract boolean setTaskWindowingModeSplitScreenPrimary(
+            int taskId, int createMode, boolean toTop, boolean animate,
+            Rect initialBounds, boolean showRecents) throws RemoteException;
+
+    public abstract boolean removeTask(int taskId) throws RemoteException;
+
+    public abstract void removeAllVisibleRecentTasks() throws RemoteException;
+
+    public abstract void cancelTaskWindowTransition(int taskId) throws RemoteException;
+
+    public abstract int getLockTaskModeState() throws RemoteException;
+
+    public abstract void registerTaskStackListener(ITaskStackListener listener) throws RemoteException;
+
+    public abstract void unregisterTaskStackListener(ITaskStackListener listener) throws RemoteException;
+
+    public abstract boolean supportsMultiWindow(Context context);
+
+    public abstract int getDisplayId(Context context);
+}
diff --git a/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/InputCompat.java b/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/InputCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..3b5417859758ae5ac1c4cb40033c098000f4d9e8
--- /dev/null
+++ b/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/InputCompat.java
@@ -0,0 +1,29 @@
+package xyz.paphonb.quickstep.compat;
+
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.RemoteException;
+import android.view.BatchedInputEventReceiver;;
+import android.view.Choreographer;
+import android.view.IWindowManager;
+import android.view.InputChannel;
+import android.view.InputEvent;
+
+public abstract class InputCompat {
+
+    public abstract BatchedInputEventReceiver createBatchedInputEventReceiver(
+            InputChannel inputChannel, Looper looper, Choreographer choreographer,
+            final InputEventListener listener);
+
+    public abstract void createInputConsumer(
+            IWindowManager windowManager, IBinder token, String name, int displayId,
+            InputChannel inputChannel) throws RemoteException;
+
+    public abstract boolean destroyInputConsumer(
+            IWindowManager windowManager, String name, int displayId) throws RemoteException;
+
+    public interface InputEventListener {
+
+        boolean onInputEvent(InputEvent event);
+    }
+}
diff --git a/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/QuickstepCompatFactory.java b/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/QuickstepCompatFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..387119c5e7e3d534f3bc883a6e134de9e403bcfc
--- /dev/null
+++ b/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/QuickstepCompatFactory.java
@@ -0,0 +1,15 @@
+package xyz.paphonb.quickstep.compat;
+
+import androidx.annotation.NonNull;
+
+public abstract class QuickstepCompatFactory {
+
+    @NonNull
+    public abstract ActivityManagerCompat getActivityManagerCompat();
+
+    @NonNull
+    public abstract RecentsCompat getRecentsModelCompat();
+
+    @NonNull
+    public abstract InputCompat getInputCompat();
+}
diff --git a/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/RecentsAnimationRunner.java b/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/RecentsAnimationRunner.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5eaa3818b8823a5cb348712ea9b372ab1769c48
--- /dev/null
+++ b/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/RecentsAnimationRunner.java
@@ -0,0 +1,14 @@
+package xyz.paphonb.quickstep.compat;
+
+import android.graphics.Rect;
+import android.view.IRecentsAnimationController;
+import android.view.RemoteAnimationTarget;
+
+public interface RecentsAnimationRunner {
+
+    void onAnimationStart(IRecentsAnimationController controller,
+                          RemoteAnimationTarget[] apps, Rect homeContentInsets,
+                          Rect minimizedHomeBounds);
+
+    void onAnimationCanceled(boolean deferredWithScreenshot);
+}
diff --git a/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/RecentsCompat.java b/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/RecentsCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..84a6159f86fa8cf19c19944e238c3cd9a3de9a21
--- /dev/null
+++ b/QuickstepCompat/src/main/java/xyz/paphonb/quickstep/compat/RecentsCompat.java
@@ -0,0 +1,69 @@
+package xyz.paphonb.quickstep.compat;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.TaskSnapshot;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.os.IRemoteCallback;
+import android.os.RemoteException;
+import android.view.IAppTransitionAnimationSpecsFuture;
+import android.view.IRecentsAnimationController;
+import android.view.RemoteAnimationAdapter;
+import android.view.SurfaceControl;
+import android.view.ViewRootImpl;
+import android.view.WindowCallbacks;
+
+public abstract class RecentsCompat {
+
+    public abstract int getTaskId(ActivityManager.RecentTaskInfo info);
+
+    public abstract int getTaskId(ActivityManager.RunningTaskInfo info);
+
+    public abstract int getDisplayId(ActivityManager.RecentTaskInfo info);
+
+    public abstract Bitmap getThumbnail(TaskSnapshot snapshot);
+
+    public abstract void finishRecentsAnimation(
+            IRecentsAnimationController animationController, boolean toHome,
+            boolean sendUserLeaveHint) throws RemoteException;
+
+    public abstract void registerRtFrameCallback(ViewRootImpl viewRoot, FrameDrawingCallback callback);
+
+    public abstract void setSurfaceBufferSize(SurfaceControl.Transaction transaction, SurfaceControl surfaceControl, int w, int h);
+
+    public abstract WindowCallbacks createWindowCallbacks(WindowCallbacksWrapper callbacks);
+
+    public abstract void overridePendingAppTransitionMultiThumbFuture(
+            IAppTransitionAnimationSpecsFuture specsFuture, IRemoteCallback callback,
+            boolean scaleUp, int displayId) throws RemoteException;
+
+    public abstract void overridePendingAppTransitionRemote(
+            RemoteAnimationAdapter remoteAnimationAdapter, int displayId) throws RemoteException;
+
+    public abstract boolean hasNavigationBar(int displayId) throws RemoteException;
+
+    public abstract int getNavBarPosition(int displayId) throws RemoteException;
+
+    public interface FrameDrawingCallback {
+
+        void onFrameDraw(long frame);
+    }
+
+    public interface WindowCallbacksWrapper {
+
+        void onWindowSizeIsChanging(Rect newBounds, boolean fullscreen, Rect systemInsets,
+                                    Rect stableInsets);
+
+        void onWindowDragResizeStart(Rect initialBounds, boolean fullscreen,
+                                     Rect systemInsets, Rect stableInsets, int resizeMode);
+
+        void onWindowDragResizeEnd();
+
+        boolean onContentDrawn(int offsetX, int offsetY, int sizeX, int sizeY);
+
+        void onRequestDraw(boolean reportNextDraw);
+
+        void onPostDraw(Canvas canvas);
+    }
+}
diff --git a/QuickstepCompat/src/main/res/values/strings.xml b/QuickstepCompat/src/main/res/values/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..8f60ea95ea3f03ad59af1a5453292f0cfe0ea709
--- /dev/null
+++ b/QuickstepCompat/src/main/res/values/strings.xml
@@ -0,0 +1,4 @@
+<resources>
+    <string name="app_name">QuickstepCompat</string>
+    <integer name="config_quickstepCompatFactory">800</integer>
+</resources>
diff --git a/QuickstepCompatVQ/.gitignore b/QuickstepCompatVQ/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..796b96d1c402326528b4ba3c12ee9d92d0e212e9
--- /dev/null
+++ b/QuickstepCompatVQ/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/QuickstepCompatVQ/build.gradle b/QuickstepCompatVQ/build.gradle
new file mode 100644
index 0000000000000000000000000000000000000000..33a677ba7930c88f578df67693ae8e8adb52ede5
--- /dev/null
+++ b/QuickstepCompatVQ/build.gradle
@@ -0,0 +1,39 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-android-extensions'
+apply from: '../spotless/spotless.gradle'
+android {
+    compileSdkVersion 29
+    buildToolsVersion "29.0.2"
+
+
+    defaultConfig {
+        minSdkVersion 25
+        targetSdkVersion 29
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles 'consumer-rules.pro'
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    addFrameworkJar('framework.jar')
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+    implementation 'androidx.appcompat:appcompat:1.0.2'
+    implementation 'androidx.core:core-ktx:1.1.0'
+    implementation project(':QuickstepCompat')
+    testImplementation 'junit:junit:4.12'
+    androidTestImplementation 'androidx.test:runner:1.2.0'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
+}
diff --git a/QuickstepCompatVQ/consumer-rules.pro b/QuickstepCompatVQ/consumer-rules.pro
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/QuickstepCompatVQ/proguard-rules.pro b/QuickstepCompatVQ/proguard-rules.pro
new file mode 100644
index 0000000000000000000000000000000000000000..f1b424510da51fd82143bc74a0a801ae5a1e2fcd
--- /dev/null
+++ b/QuickstepCompatVQ/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
diff --git a/QuickstepCompatVQ/src/main/AndroidManifest.xml b/QuickstepCompatVQ/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000000000000000000000000000000000..b736786b91c9475bbd9c4af5b193464dba8caa11
--- /dev/null
+++ b/QuickstepCompatVQ/src/main/AndroidManifest.xml
@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="xyz.paphonb.quickstep.compat.ten" />
diff --git a/QuickstepCompatVQ/src/main/java/xyz/paphonb/quickstep/compat/ten/ActivityManagerCompatVQ.java b/QuickstepCompatVQ/src/main/java/xyz/paphonb/quickstep/compat/ten/ActivityManagerCompatVQ.java
new file mode 100644
index 0000000000000000000000000000000000000000..3457d76ed351876c7baab2480c7a0da61d81402b
--- /dev/null
+++ b/QuickstepCompatVQ/src/main/java/xyz/paphonb/quickstep/compat/ten/ActivityManagerCompatVQ.java
@@ -0,0 +1,119 @@
+package xyz.paphonb.quickstep.compat.ten;
+
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.TaskSnapshot;
+import android.app.ActivityTaskManager;
+import android.app.IAssistDataReceiver;
+import android.app.ITaskStackListener;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Rect;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.view.IRecentsAnimationController;
+import android.view.IRecentsAnimationRunner;
+import android.view.RemoteAnimationTarget;
+
+import java.util.List;
+
+import xyz.paphonb.quickstep.compat.ActivityManagerCompat;
+import xyz.paphonb.quickstep.compat.RecentsAnimationRunner;
+
+public class ActivityManagerCompatVQ extends ActivityManagerCompat {
+
+    @Override
+    public List<ActivityManager.RunningTaskInfo> getFilteredTasks(int maxNum, int ignoreActivityType, int ignoreWindowingMode) throws RemoteException {
+        return ActivityTaskManager.getService().getFilteredTasks(maxNum, ignoreActivityType, ignoreWindowingMode);
+    }
+
+    @Override
+    public List<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum, int flags, int userId) throws RemoteException {
+        return ActivityTaskManager.getService().getRecentTasks(maxNum, flags, userId).getList();
+    }
+
+    @Override
+    public ActivityManager.TaskSnapshot getTaskSnapshot(int taskId, boolean reducedResolution) throws RemoteException {
+        return ActivityTaskManager.getService().getTaskSnapshot(taskId, reducedResolution);
+    }
+
+    @Override
+    public void startRecentsActivity(Intent intent, IAssistDataReceiver assistDataReceiver, final RecentsAnimationRunner recentsAnimationRunner) throws RemoteException {
+        IRecentsAnimationRunner runner = null;
+        if (recentsAnimationRunner != null) {
+            runner = new IRecentsAnimationRunner.Stub() {
+                @Override
+                public void onAnimationStart(IRecentsAnimationController controller,
+                                             RemoteAnimationTarget[] apps, Rect homeContentInsets,
+                                             Rect minimizedHomeBounds) {
+                    recentsAnimationRunner.onAnimationStart(controller, apps, homeContentInsets, minimizedHomeBounds);
+                }
+
+                @Override
+                public void onAnimationCanceled(boolean deferredWithScreenshot) {
+                    recentsAnimationRunner.onAnimationCanceled(deferredWithScreenshot);
+                }
+            };
+        }
+        ActivityTaskManager.getService().startRecentsActivity(intent, assistDataReceiver, runner);
+    }
+
+    @Override
+    public void cancelRecentsAnimation(boolean restoreHomeStackPosition) throws RemoteException {
+        ActivityTaskManager.getService().cancelRecentsAnimation(restoreHomeStackPosition);
+    }
+
+    @Override
+    public int startActivityFromRecents(int taskId, Bundle bOptions) throws RemoteException {
+        return ActivityTaskManager.getService().startActivityFromRecents(taskId, bOptions);
+    }
+
+    @Override
+    public boolean setTaskWindowingModeSplitScreenPrimary(
+            int taskId, int createMode, boolean toTop, boolean animate,
+            Rect initialBounds, boolean showRecents) throws RemoteException {
+        return ActivityTaskManager.getService().setTaskWindowingModeSplitScreenPrimary(taskId,
+                createMode, toTop, animate, initialBounds, showRecents);
+    }
+
+    @Override
+    public boolean removeTask(int taskId) throws RemoteException {
+        return ActivityTaskManager.getService().removeTask(taskId);
+    }
+
+    @Override
+    public void removeAllVisibleRecentTasks() throws RemoteException {
+        ActivityTaskManager.getService().removeAllVisibleRecentTasks();
+    }
+
+    @Override
+    public void cancelTaskWindowTransition(int taskId) throws RemoteException {
+        ActivityTaskManager.getService().cancelTaskWindowTransition(taskId);
+    }
+
+    @Override
+    public int getLockTaskModeState() throws RemoteException {
+        return ActivityTaskManager.getService().getLockTaskModeState();
+    }
+
+    @Override
+    public void registerTaskStackListener(ITaskStackListener listener) throws RemoteException {
+        ActivityTaskManager.getService().registerTaskStackListener(listener);
+    }
+
+    @Override
+    public void unregisterTaskStackListener(ITaskStackListener listener) throws RemoteException {
+        ActivityTaskManager.getService().unregisterTaskStackListener(listener);
+    }
+
+    @Override
+    public boolean supportsMultiWindow(Context context) {
+        return ActivityTaskManager.supportsMultiWindow(context);
+    }
+
+    @Override
+    public int getDisplayId(Context context) {
+        return context.getDisplayId();
+    }
+}
diff --git a/QuickstepCompatVQ/src/main/java/xyz/paphonb/quickstep/compat/ten/InputCompatVQ.java b/QuickstepCompatVQ/src/main/java/xyz/paphonb/quickstep/compat/ten/InputCompatVQ.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4d045c57aa3ba0a5023985c54299ad46743868d
--- /dev/null
+++ b/QuickstepCompatVQ/src/main/java/xyz/paphonb/quickstep/compat/ten/InputCompatVQ.java
@@ -0,0 +1,46 @@
+package xyz.paphonb.quickstep.compat.ten;
+
+import android.os.Build;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.RemoteException;
+import android.view.BatchedInputEventReceiver;;
+import android.view.Choreographer;
+import android.view.IWindowManager;
+import android.view.InputChannel;
+import android.view.InputEvent;
+
+import androidx.annotation.RequiresApi;
+
+import xyz.paphonb.quickstep.compat.InputCompat;
+
+@RequiresApi(Build.VERSION_CODES.Q)
+public class InputCompatVQ extends InputCompat {
+
+    @Override
+    public BatchedInputEventReceiver createBatchedInputEventReceiver(
+            InputChannel inputChannel, Looper looper, Choreographer choreographer,
+            final InputCompat.InputEventListener listener) {
+        return new BatchedInputEventReceiver(inputChannel, looper, choreographer) {
+
+            @Override
+            public void onInputEvent(InputEvent event) {
+                boolean handled = listener.onInputEvent(event);
+                finishInputEvent(event, handled);
+            }
+        };
+    }
+
+    @Override
+    public void createInputConsumer(
+            IWindowManager windowManager, IBinder token, String name, int displayId,
+            InputChannel inputChannel) throws RemoteException {
+        windowManager.createInputConsumer(token, name, displayId, inputChannel);
+    }
+
+    @Override
+    public boolean destroyInputConsumer(
+            IWindowManager windowManager, String name, int displayId) throws RemoteException {
+        return windowManager.destroyInputConsumer(name, displayId);
+    }
+}
diff --git a/QuickstepCompatVQ/src/main/java/xyz/paphonb/quickstep/compat/ten/QuickstepCompatFactoryVQ.java b/QuickstepCompatVQ/src/main/java/xyz/paphonb/quickstep/compat/ten/QuickstepCompatFactoryVQ.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ab51ae252bb058f9669aee73477a12f11566862
--- /dev/null
+++ b/QuickstepCompatVQ/src/main/java/xyz/paphonb/quickstep/compat/ten/QuickstepCompatFactoryVQ.java
@@ -0,0 +1,35 @@
+package xyz.paphonb.quickstep.compat.ten;
+
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import org.jetbrains.annotations.NotNull;
+
+import xyz.paphonb.quickstep.compat.ActivityManagerCompat;
+import xyz.paphonb.quickstep.compat.InputCompat;
+import xyz.paphonb.quickstep.compat.QuickstepCompatFactory;
+import xyz.paphonb.quickstep.compat.RecentsCompat;
+
+@RequiresApi(Build.VERSION_CODES.Q)
+public class QuickstepCompatFactoryVQ extends QuickstepCompatFactory {
+
+    @NotNull
+    @Override
+    public ActivityManagerCompat getActivityManagerCompat() {
+        return new ActivityManagerCompatVQ();
+    }
+
+    @NotNull
+    @Override
+    public RecentsCompat getRecentsModelCompat() {
+        return new RecentsCompatVQ();
+    }
+
+    @NonNull
+    @Override
+    public InputCompat getInputCompat() {
+        return new InputCompatVQ();
+    }
+}
diff --git a/QuickstepCompatVQ/src/main/java/xyz/paphonb/quickstep/compat/ten/RecentsCompatVQ.java b/QuickstepCompatVQ/src/main/java/xyz/paphonb/quickstep/compat/ten/RecentsCompatVQ.java
new file mode 100644
index 0000000000000000000000000000000000000000..e5e8ec112a3dba9398d241fdc0d90bbac9e11928
--- /dev/null
+++ b/QuickstepCompatVQ/src/main/java/xyz/paphonb/quickstep/compat/ten/RecentsCompatVQ.java
@@ -0,0 +1,126 @@
+package xyz.paphonb.quickstep.compat.ten;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.TaskSnapshot;
+import android.graphics.Bitmap;
+import android.graphics.HardwareRenderer;
+import android.graphics.RecordingCanvas;
+import android.graphics.Rect;
+import android.os.Build;
+import android.os.IRemoteCallback;
+import android.os.RemoteException;
+import android.view.IAppTransitionAnimationSpecsFuture;
+import android.view.IRecentsAnimationController;
+import android.view.RemoteAnimationAdapter;
+import android.view.SurfaceControl;
+import android.view.ViewRootImpl;
+import android.view.WindowCallbacks;
+import android.view.WindowManagerGlobal;
+
+import androidx.annotation.RequiresApi;
+
+import xyz.paphonb.quickstep.compat.RecentsCompat;
+
+@RequiresApi(Build.VERSION_CODES.Q)
+public class RecentsCompatVQ extends RecentsCompat {
+
+    @Override
+    public int getTaskId(ActivityManager.RecentTaskInfo info) {
+        return info.taskId;
+    }
+
+    @Override
+    public int getTaskId(ActivityManager.RunningTaskInfo info) {
+        return info.taskId;
+    }
+
+    @Override
+    public int getDisplayId(ActivityManager.RecentTaskInfo info) {
+        return info.displayId;
+    }
+
+    @Override
+    public Bitmap getThumbnail(TaskSnapshot snapshot) {
+        return Bitmap.wrapHardwareBuffer(snapshot.getSnapshot(), snapshot.getColorSpace());
+    }
+
+    @Override
+    public void finishRecentsAnimation(
+            IRecentsAnimationController animationController, boolean toHome,
+            boolean sendUserLeaveHint) throws RemoteException {
+        animationController.finish(toHome, sendUserLeaveHint);
+    }
+
+    @Override
+    public void registerRtFrameCallback(ViewRootImpl viewRoot, final FrameDrawingCallback callback) {
+        viewRoot.registerRtFrameCallback(new HardwareRenderer.FrameDrawingCallback() {
+            @Override
+            public void onFrameDraw(long frame) {
+                callback.onFrameDraw(frame);
+            }
+        });
+    }
+
+    @Override
+    public void setSurfaceBufferSize(SurfaceControl.Transaction transaction, SurfaceControl surfaceControl, int w, int h) {
+        transaction.setBufferSize(surfaceControl, w, h);
+    }
+
+    @Override
+    public WindowCallbacks createWindowCallbacks(final WindowCallbacksWrapper callbacks) {
+        return new WindowCallbacks() {
+            @Override
+            public void onWindowSizeIsChanging(Rect newBounds, boolean fullscreen, Rect systemInsets,
+                                               Rect stableInsets) {
+                callbacks.onWindowSizeIsChanging(newBounds, fullscreen, systemInsets, stableInsets);
+            }
+
+            @Override
+            public void onWindowDragResizeStart(Rect initialBounds, boolean fullscreen,
+                                                Rect systemInsets, Rect stableInsets, int resizeMode) {
+                callbacks.onWindowDragResizeStart(initialBounds, fullscreen, systemInsets, stableInsets, resizeMode);
+            }
+
+            @Override
+            public void onWindowDragResizeEnd() {
+                callbacks.onWindowDragResizeEnd();
+            }
+
+            @Override
+            public boolean onContentDrawn(int offsetX, int offsetY, int sizeX, int sizeY) {
+                return callbacks.onContentDrawn(offsetX, offsetY, sizeX, sizeY);
+            }
+
+            @Override
+            public void onRequestDraw(boolean reportNextDraw) {
+                callbacks.onRequestDraw(reportNextDraw);
+            }
+
+            @Override
+            public void onPostDraw(RecordingCanvas canvas) {
+                callbacks.onPostDraw(canvas);
+            }
+        };
+    }
+
+    public void overridePendingAppTransitionMultiThumbFuture(
+            IAppTransitionAnimationSpecsFuture specsFuture, IRemoteCallback callback,
+            boolean scaleUp, int displayId) throws RemoteException {
+        WindowManagerGlobal.getWindowManagerService()
+                .overridePendingAppTransitionMultiThumbFuture(specsFuture, callback, scaleUp, displayId);
+    }
+
+    public void overridePendingAppTransitionRemote(
+            RemoteAnimationAdapter remoteAnimationAdapter, int displayId) throws RemoteException {
+        WindowManagerGlobal.getWindowManagerService()
+                .overridePendingAppTransitionRemote(remoteAnimationAdapter, displayId);
+    }
+
+    public boolean hasNavigationBar(int displayId) throws RemoteException {
+        return WindowManagerGlobal.getWindowManagerService().hasNavigationBar(displayId);
+    }
+
+    public int getNavBarPosition(int displayId) throws RemoteException {
+        return WindowManagerGlobal.getWindowManagerService().getNavBarPosition(displayId);
+    }
+}
diff --git a/QuickstepCompatVQ/src/main/res/values/strings.xml b/QuickstepCompatVQ/src/main/res/values/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..f5e9aaf1e636a9710d714f842fbe3fefb4c6f29a
--- /dev/null
+++ b/QuickstepCompatVQ/src/main/res/values/strings.xml
@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">QuickstepCompatVQ</string>
+</resources>
diff --git a/SystemUISharedLib/.gitignore b/SystemUISharedLib/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..796b96d1c402326528b4ba3c12ee9d92d0e212e9
--- /dev/null
+++ b/SystemUISharedLib/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/SystemUISharedLib/build.gradle b/SystemUISharedLib/build.gradle
new file mode 100644
index 0000000000000000000000000000000000000000..87dd11f3b61571a5bc2a81485fce7783744d4edb
--- /dev/null
+++ b/SystemUISharedLib/build.gradle
@@ -0,0 +1,45 @@
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 29
+    buildToolsVersion "29.0.2"
+
+
+    defaultConfig {
+        minSdkVersion 25
+        targetSdkVersion 29
+        versionCode 1
+        versionName "1.0"
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles 'consumer-rules.pro'
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    sourceSets {
+        main {
+            aidl.srcDirs = ['src/main/java']
+        }
+    }
+
+    addFrameworkJar('framework.jar')
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    compileOnly fileTree(dir: "../app/libs", include: 'framework.jar')
+    implementation project(':QuickstepCompat')
+    implementation project(':QuickstepCompatVQ')
+
+    implementation "androidx.annotation:annotation:1.2.0"
+
+    testImplementation 'junit:junit:4.12'
+    androidTestImplementation 'androidx.test:runner:1.2.0'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1'
+}
diff --git a/SystemUISharedLib/consumer-rules.pro b/SystemUISharedLib/consumer-rules.pro
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/SystemUISharedLib/proguard-rules.pro b/SystemUISharedLib/proguard-rules.pro
new file mode 100644
index 0000000000000000000000000000000000000000..f1b424510da51fd82143bc74a0a801ae5a1e2fcd
--- /dev/null
+++ b/SystemUISharedLib/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
diff --git a/SystemUISharedLib/src/main/AndroidManifest.xml b/SystemUISharedLib/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000000000000000000000000000000000..795aa3e7e9207178230a54dd0fa7535f0b183723
--- /dev/null
+++ b/SystemUISharedLib/src/main/AndroidManifest.xml
@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.android.systemui.shared"/>
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/QuickstepCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/QuickstepCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..741a400ffdf273a2763b7231084af68452857105
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/QuickstepCompat.java
@@ -0,0 +1,33 @@
+package com.android.systemui.shared;
+
+import xyz.paphonb.quickstep.compat.ActivityManagerCompat;
+import xyz.paphonb.quickstep.compat.InputCompat;
+import xyz.paphonb.quickstep.compat.QuickstepCompatFactory;
+import xyz.paphonb.quickstep.compat.RecentsCompat;
+import xyz.paphonb.quickstep.compat.ten.QuickstepCompatFactoryVQ;
+
+public class QuickstepCompat {
+
+    private static ActivityManagerCompat sActivityManagerCompat;
+    private static RecentsCompat sRecentsModelCompat;
+    private static InputCompat sInputCompat;
+
+    static {
+        QuickstepCompatFactory factory = new QuickstepCompatFactoryVQ();
+        sActivityManagerCompat = factory.getActivityManagerCompat();
+        sRecentsModelCompat = factory.getRecentsModelCompat();
+        sInputCompat = factory.getInputCompat();
+    }
+
+    public static ActivityManagerCompat getActivityManager() {
+        return sActivityManagerCompat;
+    }
+
+    public static RecentsCompat getRecentsCompat() {
+        return sRecentsModelCompat;
+    }
+
+    public static InputCompat getInputCompat() {
+        return sInputCompat;
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/IOverviewProxy.aidl b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/IOverviewProxy.aidl
new file mode 100644
index 0000000000000000000000000000000000000000..577e3bbefdade55de80405feef52a8b2110f8e01
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/IOverviewProxy.aidl
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.shared.recents;
+
+import android.graphics.Region;
+import android.os.Bundle;
+import android.view.MotionEvent;
+import com.android.systemui.shared.recents.ISystemUiProxy;
+
+oneway interface IOverviewProxy {
+
+    void onActiveNavBarRegionChanges(in Region activeRegion) = 11;
+
+    void onInitialize(in Bundle params) = 12;
+
+
+    /**
+     * @deprecated
+     */
+    void onBind(in ISystemUiProxy sysUiProxy) = 0;
+
+    /**
+     * Called once immediately prior to the first onMotionEvent() call, providing a hint to the
+     * target the initial source of the subsequent motion events.
+     *
+     * @param downHitTarget is one of the {@link NavigationBarCompat.HitTarget}s
+     *
+     * @deprecated
+     */
+    void onPreMotionEvent(int downHitTarget) = 1;
+
+    /**
+     * Proxies motion events from the nav bar in SystemUI to the OverviewProxyService. The sender
+     * guarantees the following order of events:
+     *
+     * Normal gesture: DOWN, (MOVE/POINTER_DOWN/POINTER_UP)*, UP
+     * Quick scrub: DOWN, (MOVE/POINTER_DOWN/POINTER_UP)*, SCRUB_START, SCRUB_PROGRESS*, SCRUB_END
+     *
+     * Once quick scrub is sent, then no further motion events will be provided.
+     *
+     * @deprecated
+     */
+    void onMotionEvent(in MotionEvent event) = 2;
+
+    /**
+     * Sent when the user starts to actively scrub the nav bar to switch tasks. Once this event is
+     * sent the caller will stop sending any motion events and will no longer preemptively cancel
+     * any recents animations started as a part of the motion event handling.
+     *
+     * @deprecated
+     */
+    void onQuickScrubStart() = 3;
+
+    /**
+     * Sent when the user stops actively scrubbing the nav bar to switch tasks.
+     *
+     * @deprecated
+     */
+    void onQuickScrubEnd() = 4;
+
+    /**
+     * Sent for each movement over the nav bar while the user is scrubbing it to switch tasks.
+     *
+     * @deprecated
+     */
+    void onQuickScrubProgress(float progress) = 5;
+
+    /**
+     * Sent when overview button is pressed to toggle show/hide of overview.
+     */
+    void onOverviewToggle() = 6;
+
+    /**
+     * Sent when overview is to be shown.
+     */
+    void onOverviewShown(boolean triggeredFromAltTab) = 7;
+
+    /**
+     * Sent when overview is to be hidden.
+     */
+    void onOverviewHidden(boolean triggeredFromAltTab, boolean triggeredFromHomeKey) = 8;
+
+    /**
+     * Sent when a user swipes up over the navigation bar to launch overview. Swipe up is determined
+     * by passing the touch slop in the direction towards launcher from navigation bar. During and
+     * after this event is sent the caller will continue to send motion events. The motion
+     * {@param event} passed after the touch slop was exceeded will also be passed after by
+     * {@link onMotionEvent}. Since motion events will be sent, motion up or cancel can still be
+     * sent to cancel overview regardless the current state of launcher (eg. if overview is already
+     * visible, this event will still be sent if user swipes up). When this signal is sent,
+     * navigation bar will not handle any gestures such as quick scrub and the home button will
+     * cancel (long) press.
+     *
+     * @deprecated
+     */
+    void onQuickStep(in MotionEvent event) = 9;
+
+    /**
+     * Sent when there was an action on one of the onboarding tips view.
+     */
+    void onTip(int actionType, int viewType) = 10;
+
+    /**
+     * Sent when device assistant changes its default assistant whether it is available or not.
+     */
+    void onAssistantAvailable(boolean available) = 13;
+
+    /**
+     * Sent when the assistant changes how visible it is to the user.
+     */
+    void onAssistantVisibilityChanged(float visibility) = 14;
+
+    /**
+     * Sent when back is triggered.
+     */
+    void onBackAction(boolean completed, int downX, int downY, boolean isButton,
+            boolean gestureSwipeLeft) = 15;
+
+    /**
+     * Sent when some system ui state changes.
+     */
+    void onSystemUiStateChanged(int stateFlags) = 16;
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/ISystemUiProxy.aidl b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/ISystemUiProxy.aidl
new file mode 100644
index 0000000000000000000000000000000000000000..f1d2db73c163b14a2d746be20bfdbe5b628d4b4a
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/ISystemUiProxy.aidl
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.shared.recents;
+
+import android.graphics.Rect;
+import android.os.Bundle;
+import android.view.MotionEvent;
+
+/**
+ * Temporary callbacks into SystemUI.
+ */
+interface ISystemUiProxy {
+
+    /**
+     * Proxies SurfaceControl.screenshotToBuffer().
+     * @Removed
+     * GraphicBufferCompat screenshot(in Rect sourceCrop, int width, int height, int minLayer,
+     *             int maxLayer, boolean useIdentityTransform, int rotation) = 0;
+     */
+
+    /**
+     * Begins screen pinning on the provided {@param taskId}.
+     */
+    void startScreenPinning(int taskId) = 1;
+
+    /**
+     * Enables/disables launcher/overview interaction features {@link InteractionType}.
+     * @deprecated
+     */
+    void setInteractionState(int flags) = 4;
+
+    /**
+     * Notifies SystemUI that split screen has been invoked.
+     */
+    void onSplitScreenInvoked() = 5;
+
+    /**
+     * Notifies SystemUI that Overview is shown.
+     */
+    void onOverviewShown(boolean fromHome) = 6;
+
+    /**
+     * Get the secondary split screen app's rectangle when not minimized.
+     */
+    Rect getNonMinimizedSplitScreenSecondaryBounds() = 7;
+
+    /**
+     * Control the {@param alpha} of the back button in the navigation bar and {@param animate} if
+     * needed from current value
+     * @deprecated
+     */
+    void setBackButtonAlpha(float alpha, boolean animate) = 8;
+
+    /**
+     * Control the {@param alpha} of the option nav bar button (back-button in 2 button mode
+     * and home bar in no-button mode) and {@param animate} if needed from current value
+     */
+    void setNavBarButtonAlpha(float alpha, boolean animate) = 19;
+
+    /**
+     * Proxies motion events from the homescreen UI to the status bar. Only called when
+     * swipe down is detected on WORKSPACE. The sender guarantees the following order of events on
+     * the tracking pointer.
+     *
+     * Normal gesture: DOWN, MOVE/POINTER_DOWN/POINTER_UP)*, UP or CANCLE
+     */
+    void onStatusBarMotionEvent(in MotionEvent event) = 9;
+
+    /**
+     * Proxies the assistant gesture's progress started from navigation bar.
+     */
+    void onAssistantProgress(float progress) = 12;
+
+    /**
+    * Proxies the assistant gesture fling velocity (in pixels per millisecond) upon completion.
+    * Velocity is 0 for drag gestures.
+    */
+    void onAssistantGestureCompletion(float velocity) = 18;
+
+    /**
+     * Start the assistant.
+     */
+    void startAssistant(in Bundle bundle) = 13;
+
+    /**
+     * Creates a new gesture monitor
+     */
+    Bundle monitorGestureInput(String name, int displayId) = 14;
+
+    /**
+     * Notifies that the accessibility button in the system's navigation area has been clicked
+     */
+    void notifyAccessibilityButtonClicked(int displayId) = 15;
+
+    /**
+     * Notifies that the accessibility button in the system's navigation area has been long clicked
+     */
+    void notifyAccessibilityButtonLongClicked() = 16;
+
+    /**
+     * Ends the system screen pinning.
+     */
+    void stopScreenPinning() = 17;
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/IconLoader.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/IconLoader.java
new file mode 100644
index 0000000000000000000000000000000000000000..75eee9d3d6c058e81ed21a5b1b2144d2aa8cbd7a
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/IconLoader.java
@@ -0,0 +1,200 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.systemui.shared.recents.model;
+
+import static android.content.pm.PackageManager.MATCH_ANY_USER;
+
+import android.app.ActivityManager;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.UserHandle;
+import android.util.IconDrawableFactory;
+import android.util.Log;
+import android.util.LruCache;
+import com.android.systemui.shared.system.PackageManagerWrapper;
+
+public abstract class IconLoader {
+
+    private static final String TAG = "IconLoader";
+
+    protected final Context mContext;
+    protected final TaskKeyLruCache<Drawable> mIconCache;
+    protected final LruCache<ComponentName, ActivityInfo> mActivityInfoCache;
+
+    public IconLoader(Context context, TaskKeyLruCache<Drawable> iconCache, LruCache<ComponentName,
+            ActivityInfo> activityInfoCache) {
+        mContext = context;
+        mIconCache = iconCache;
+        mActivityInfoCache = activityInfoCache;
+    }
+
+    /**
+     * Returns the activity info for the given task key, retrieving one from the system if the
+     * task key is expired.
+     *
+     * TODO: Move this to an ActivityInfoCache class
+     */
+    public ActivityInfo getAndUpdateActivityInfo(Task.TaskKey taskKey) {
+        ComponentName cn = taskKey.getComponent();
+        if (cn == null) {
+            Log.e(TAG, "Unexpected null component name: " + taskKey);
+            return null;
+        }
+        ActivityInfo activityInfo = mActivityInfoCache.get(cn);
+        if (activityInfo == null) {
+            activityInfo = PackageManagerWrapper.getInstance().getActivityInfo(cn, taskKey.userId);
+            if (activityInfo == null) {
+                Log.e(TAG, "Unexpected null activity info: " + cn + ", " +
+                        activityInfo);
+                return null;
+            }
+            mActivityInfoCache.put(cn, activityInfo);
+        }
+        return activityInfo;
+    }
+
+    public Drawable getIcon(Task t) {
+        Drawable cachedIcon = mIconCache.get(t.key);
+        if (cachedIcon == null) {
+            cachedIcon = createNewIconForTask(t.key, t.taskDescription, true /* returnDefault */);
+            mIconCache.put(t.key, cachedIcon);
+        }
+        return cachedIcon;
+    }
+
+    /**
+     * Returns the cached task icon if the task key is not expired, updating the cache if it is.
+     */
+    public Drawable getAndInvalidateIfModified(Task.TaskKey taskKey,
+            ActivityManager.TaskDescription td, boolean loadIfNotCached) {
+        // Return the cached activity icon if it exists
+        Drawable icon = mIconCache.getAndInvalidateIfModified(taskKey);
+        if (icon != null) {
+            return icon;
+        }
+
+        if (loadIfNotCached) {
+            icon = createNewIconForTask(taskKey, td, false /* returnDefault */);
+            if (icon != null) {
+                mIconCache.put(taskKey, icon);
+                return icon;
+            }
+        }
+
+        // We couldn't load any icon
+        return null;
+    }
+
+    protected Drawable createNewIconForTask(Task.TaskKey taskKey,
+            ActivityManager.TaskDescription desc, boolean returnDefault) {
+        int userId = taskKey.userId;
+        Bitmap tdIcon = desc.getInMemoryIcon();
+        if (tdIcon != null) {
+            return createDrawableFromBitmap(tdIcon, userId, desc);
+        }
+        if (desc.getIconResource() != 0) {
+            try {
+                PackageManager pm = mContext.getPackageManager();
+                ApplicationInfo appInfo = pm.getApplicationInfo(taskKey.getPackageName(),
+                        MATCH_ANY_USER);
+                Resources res = pm.getResourcesForApplication(appInfo);
+                return createBadgedDrawable(res.getDrawable(desc.getIconResource(), null), userId,
+                        desc);
+            } catch (Resources.NotFoundException|PackageManager.NameNotFoundException e) {
+                Log.e(TAG, "Could not find icon drawable from resource", e);
+            }
+        }
+
+        tdIcon = ActivityManager.TaskDescription.loadTaskDescriptionIcon(
+                desc.getIconFilename(), userId);
+        if (tdIcon != null) {
+            return createDrawableFromBitmap(tdIcon, userId, desc);
+        }
+
+        // Load the icon from the activity info and cache it
+        ActivityInfo activityInfo = getAndUpdateActivityInfo(taskKey);
+        if (activityInfo != null) {
+            Drawable icon = getBadgedActivityIcon(activityInfo, userId, desc);
+            if (icon != null) {
+                return icon;
+            }
+        }
+
+        // At this point, even if we can't load the icon, we will set the default icon.
+        return returnDefault ? getDefaultIcon(userId) : null;
+    }
+
+    public abstract Drawable getDefaultIcon(int userId);
+
+    protected Drawable createDrawableFromBitmap(Bitmap icon, int userId,
+            ActivityManager.TaskDescription desc) {
+        return createBadgedDrawable(
+                new BitmapDrawable(mContext.getResources(), icon), userId, desc);
+    }
+
+    protected abstract Drawable createBadgedDrawable(Drawable icon, int userId,
+            ActivityManager.TaskDescription desc);
+
+    /**
+     * @return the activity icon for the ActivityInfo for a user, badging if necessary.
+     */
+    protected abstract Drawable getBadgedActivityIcon(ActivityInfo info, int userId,
+            ActivityManager.TaskDescription desc);
+
+    public static class DefaultIconLoader extends IconLoader {
+
+        private final BitmapDrawable mDefaultIcon;
+        private final IconDrawableFactory mDrawableFactory;
+
+        public DefaultIconLoader(Context context, TaskKeyLruCache<Drawable> iconCache,
+                LruCache<ComponentName, ActivityInfo> activityInfoCache) {
+            super(context, iconCache, activityInfoCache);
+
+            // Create the default assets
+            Bitmap icon = Bitmap.createBitmap(1, 1, Bitmap.Config.ALPHA_8);
+            icon.eraseColor(0);
+            mDefaultIcon = new BitmapDrawable(context.getResources(), icon);
+            mDrawableFactory = IconDrawableFactory.newInstance(context);
+        }
+
+        @Override
+        public Drawable getDefaultIcon(int userId) {
+            return mDefaultIcon;
+        }
+
+        @Override
+        protected Drawable createBadgedDrawable(Drawable icon, int userId,
+                ActivityManager.TaskDescription desc) {
+            if (userId != UserHandle.myUserId()) {
+                icon = mContext.getPackageManager().getUserBadgedIcon(icon, new UserHandle(userId));
+            }
+            return icon;
+        }
+
+        @Override
+        protected Drawable getBadgedActivityIcon(ActivityInfo info, int userId,
+                ActivityManager.TaskDescription desc) {
+            return mDrawableFactory.getBadgedIcon(info, info.applicationInfo, userId);
+        }
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/Task.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/Task.java
new file mode 100644
index 0000000000000000000000000000000000000000..15279634dc4677954a65a8335c52cd3d66225541
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/Task.java
@@ -0,0 +1,415 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.shared.recents.model;
+
+import static android.view.Display.DEFAULT_DISPLAY;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.TaskDescription;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.graphics.Color;
+import android.graphics.drawable.Drawable;
+import android.view.ViewDebug;
+import com.android.systemui.shared.QuickstepCompat;
+import com.android.systemui.shared.recents.utilities.Utilities;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Objects;
+
+/**
+ * A task in the recent tasks list.
+ */
+public class Task {
+
+    public static final String TAG = "Task";
+
+    /* Task callbacks */
+    @Deprecated
+    public interface TaskCallbacks {
+        /* Notifies when a task has been bound */
+        void onTaskDataLoaded(Task task, ThumbnailData thumbnailData);
+        /* Notifies when a task has been unbound */
+        void onTaskDataUnloaded();
+        /* Notifies when a task's windowing mode has changed. */
+        void onTaskWindowingModeChanged();
+    }
+
+    /* The Task Key represents the unique primary key for the task */
+    public static class TaskKey {
+        @ViewDebug.ExportedProperty(category="recents")
+        public final int id;
+        @ViewDebug.ExportedProperty(category="recents")
+        public int windowingMode;
+        @ViewDebug.ExportedProperty(category="recents")
+        public final Intent baseIntent;
+        @ViewDebug.ExportedProperty(category="recents")
+        public final int userId;
+        @ViewDebug.ExportedProperty(category="recents")
+        public long lastActiveTime;
+
+        /**
+         * The id of the task was running from which display.
+         */
+        @ViewDebug.ExportedProperty(category = "recents")
+        public final int displayId;
+
+        // The source component name which started this task
+        public final ComponentName sourceComponent;
+
+        private int mHashCode;
+
+        public TaskKey(ActivityManager.RecentTaskInfo t) {
+            ComponentName sourceComponent = t.origActivity != null
+                    // Activity alias if there is one
+                    ? t.origActivity
+                    // The real activity if there is no alias (or the target if there is one)
+                    : t.realActivity;
+            this.id = QuickstepCompat.getRecentsCompat().getTaskId(t);
+            this.windowingMode = t.configuration.windowConfiguration.getWindowingMode();
+            this.baseIntent = t.baseIntent;
+            this.sourceComponent = sourceComponent;
+            this.userId = t.userId;
+            this.lastActiveTime = t.lastActiveTime;
+            this.displayId = QuickstepCompat.getRecentsCompat().getDisplayId(t);
+            updateHashCode();
+        }
+
+        public TaskKey(ActivityManager.RunningTaskInfo t) {
+            ComponentName sourceComponent = t.origActivity != null
+                    // Activity alias if there is one
+                    ? t.origActivity
+                    // The real activity if there is no alias (or the target if there is one)
+                    : t.realActivity;
+            this.id = t.taskId;
+            this.windowingMode = t.configuration.windowConfiguration.getWindowingMode();
+            this.baseIntent = t.baseIntent;
+            this.sourceComponent = sourceComponent;
+            this.userId = t.userId;
+            this.lastActiveTime = t.lastActiveTime;
+            this.displayId = t.displayId;
+            updateHashCode();
+        }
+
+        public TaskKey(int id, int windowingMode, Intent intent,
+                ComponentName sourceComponent, int userId, long lastActiveTime) {
+            this.id = id;
+            this.windowingMode = windowingMode;
+            this.baseIntent = intent;
+            this.sourceComponent = sourceComponent;
+            this.userId = userId;
+            this.lastActiveTime = lastActiveTime;
+            this.displayId = DEFAULT_DISPLAY;
+            updateHashCode();
+        }
+
+        public TaskKey(int id, int windowingMode, Intent intent,
+                ComponentName sourceComponent, int userId, long lastActiveTime, int displayId) {
+            this.id = id;
+            this.windowingMode = windowingMode;
+            this.baseIntent = intent;
+            this.sourceComponent = sourceComponent;
+            this.userId = userId;
+            this.lastActiveTime = lastActiveTime;
+            this.displayId = displayId;
+            updateHashCode();
+        }
+
+        public void setWindowingMode(int windowingMode) {
+            this.windowingMode = windowingMode;
+            updateHashCode();
+        }
+
+        public ComponentName getComponent() {
+            return this.baseIntent.getComponent();
+        }
+
+        public String getPackageName() {
+            if (this.baseIntent.getComponent() != null) {
+                return this.baseIntent.getComponent().getPackageName();
+            }
+            return this.baseIntent.getPackage();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (!(o instanceof TaskKey)) {
+                return false;
+            }
+            TaskKey otherKey = (TaskKey) o;
+            return id == otherKey.id
+                    && windowingMode == otherKey.windowingMode
+                    && userId == otherKey.userId;
+        }
+
+        @Override
+        public int hashCode() {
+            return mHashCode;
+        }
+
+        @Override
+        public String toString() {
+            return "id=" + id + " windowingMode=" + windowingMode + " user=" + userId
+                    + " lastActiveTime=" + lastActiveTime;
+        }
+
+        private void updateHashCode() {
+            mHashCode = Objects.hash(id, windowingMode, userId);
+        }
+    }
+
+    @ViewDebug.ExportedProperty(deepExport=true, prefix="key_")
+    public TaskKey key;
+
+    /**
+     * The temporary sort index in the stack, used when ordering the stack.
+     */
+    @Deprecated
+    public int temporarySortIndexInStack;
+
+    /**
+     * The icon is the task description icon (if provided), which falls back to the activity icon,
+     * which can then fall back to the application icon.
+     */
+    public Drawable icon;
+    public ThumbnailData thumbnail;
+    @ViewDebug.ExportedProperty(category="recents")
+    @Deprecated
+    public String title;
+    @ViewDebug.ExportedProperty(category="recents")
+    public String titleDescription;
+    @ViewDebug.ExportedProperty(category="recents")
+    public int colorPrimary;
+    @ViewDebug.ExportedProperty(category="recents")
+    public int colorBackground;
+    @ViewDebug.ExportedProperty(category="recents")
+    @Deprecated
+    public boolean useLightOnPrimaryColor;
+
+    /**
+     * The task description for this task, only used to reload task icons.
+     */
+    public TaskDescription taskDescription;
+
+    /**
+     * The state isLaunchTarget will be set for the correct task upon launching Recents.
+     */
+    @ViewDebug.ExportedProperty(category="recents")
+    @Deprecated
+    public boolean isLaunchTarget;
+    @ViewDebug.ExportedProperty(category="recents")
+    @Deprecated
+    public boolean isStackTask;
+    @ViewDebug.ExportedProperty(category="recents")
+    @Deprecated
+    public boolean isSystemApp;
+    @ViewDebug.ExportedProperty(category="recents")
+    public boolean isDockable;
+
+    /**
+     * Resize mode. See {@link ActivityInfo#resizeMode}.
+     */
+    @ViewDebug.ExportedProperty(category="recents")
+    @Deprecated
+    public int resizeMode;
+
+    @ViewDebug.ExportedProperty(category="recents")
+    public ComponentName topActivity;
+
+    @ViewDebug.ExportedProperty(category="recents")
+    public boolean isLocked;
+
+    @Deprecated
+    private ArrayList<TaskCallbacks> mCallbacks = new ArrayList<>();
+
+    public Task() {
+        // Do nothing
+    }
+
+    /**
+     * Creates a task object from the provided task info
+     */
+    public static Task from(TaskKey taskKey, ActivityManager.RecentTaskInfo taskInfo, boolean isLocked) {
+        ActivityManager.TaskDescription td = taskInfo.taskDescription;
+        return new Task(taskKey,
+                td != null ? td.getPrimaryColor() : 0,
+                td != null ? td.getBackgroundColor() : 0,
+                taskInfo.supportsSplitScreenMultiWindow, isLocked, td, taskInfo.topActivity);
+    }
+
+    /**
+     * Creates a task object from the provided task info
+     */
+    public static Task from(TaskKey taskKey, ActivityManager.RunningTaskInfo taskInfo, boolean isLocked) {
+        ActivityManager.TaskDescription td = taskInfo.taskDescription;
+        return new Task(taskKey,
+                td != null ? td.getPrimaryColor() : 0,
+                td != null ? td.getBackgroundColor() : 0,
+                taskInfo.supportsSplitScreenMultiWindow, isLocked, td, taskInfo.topActivity);
+    }
+
+    public Task(TaskKey key) {
+        this.key = key;
+        this.taskDescription = new TaskDescription();
+    }
+
+    public Task(TaskKey key, int colorPrimary, int colorBackground,
+            boolean isDockable, boolean isLocked, TaskDescription taskDescription,
+            ComponentName topActivity) {
+        this.key = key;
+        this.colorPrimary = colorPrimary;
+        this.colorBackground = colorBackground;
+        this.taskDescription = taskDescription;
+        this.isDockable = isDockable;
+        this.isLocked = isLocked;
+        this.topActivity = topActivity;
+    }
+
+    @Deprecated
+    public Task(TaskKey key, Drawable icon, ThumbnailData thumbnail, String title,
+            String titleDescription, int colorPrimary, int colorBackground, boolean isLaunchTarget,
+            boolean isStackTask, boolean isSystemApp, boolean isDockable,
+            TaskDescription taskDescription, int resizeMode, ComponentName topActivity,
+            boolean isLocked) {
+        this.key = key;
+        this.icon = icon;
+        this.thumbnail = thumbnail;
+        this.title = title;
+        this.titleDescription = titleDescription;
+        this.colorPrimary = colorPrimary;
+        this.colorBackground = colorBackground;
+        this.useLightOnPrimaryColor = Utilities.computeContrastBetweenColors(this.colorPrimary,
+                Color.WHITE) > 3f;
+        this.taskDescription = taskDescription;
+        this.isLaunchTarget = isLaunchTarget;
+        this.isStackTask = isStackTask;
+        this.isSystemApp = isSystemApp;
+        this.isDockable = isDockable;
+        this.resizeMode = resizeMode;
+        this.topActivity = topActivity;
+        this.isLocked = isLocked;
+    }
+
+    /**
+     * Copies the metadata from another task, but retains the current callbacks.
+     */
+    @Deprecated
+    public void copyFrom(Task o) {
+        this.key = o.key;
+        this.icon = o.icon;
+        this.thumbnail = o.thumbnail;
+        this.title = o.title;
+        this.titleDescription = o.titleDescription;
+        this.colorPrimary = o.colorPrimary;
+        this.colorBackground = o.colorBackground;
+        this.useLightOnPrimaryColor = o.useLightOnPrimaryColor;
+        this.taskDescription = o.taskDescription;
+        this.isLaunchTarget = o.isLaunchTarget;
+        this.isStackTask = o.isStackTask;
+        this.isSystemApp = o.isSystemApp;
+        this.isDockable = o.isDockable;
+        this.resizeMode = o.resizeMode;
+        this.isLocked = o.isLocked;
+        this.topActivity = o.topActivity;
+    }
+
+    /**
+     * Add a callback.
+     */
+    @Deprecated
+    public void addCallback(TaskCallbacks cb) {
+        if (!mCallbacks.contains(cb)) {
+            mCallbacks.add(cb);
+        }
+    }
+
+    /**
+     * Remove a callback.
+     */
+    @Deprecated
+    public void removeCallback(TaskCallbacks cb) {
+        mCallbacks.remove(cb);
+    }
+
+    /** Updates the task's windowing mode. */
+    @Deprecated
+    public void setWindowingMode(int windowingMode) {
+        key.setWindowingMode(windowingMode);
+        int callbackCount = mCallbacks.size();
+        for (int i = 0; i < callbackCount; i++) {
+            mCallbacks.get(i).onTaskWindowingModeChanged();
+        }
+    }
+
+    /** Notifies the callback listeners that this task has been loaded */
+    @Deprecated
+    public void notifyTaskDataLoaded(ThumbnailData thumbnailData, Drawable applicationIcon) {
+        this.icon = applicationIcon;
+        this.thumbnail = thumbnailData;
+        int callbackCount = mCallbacks.size();
+        for (int i = 0; i < callbackCount; i++) {
+            mCallbacks.get(i).onTaskDataLoaded(this, thumbnailData);
+        }
+    }
+
+    /** Notifies the callback listeners that this task has been unloaded */
+    @Deprecated
+    public void notifyTaskDataUnloaded(Drawable defaultApplicationIcon) {
+        icon = defaultApplicationIcon;
+        thumbnail = null;
+        for (int i = mCallbacks.size() - 1; i >= 0; i--) {
+            mCallbacks.get(i).onTaskDataUnloaded();
+        }
+    }
+
+    /**
+     * Returns the top activity component.
+     */
+    public ComponentName getTopComponent() {
+        return topActivity != null
+                ? topActivity
+                : key.baseIntent.getComponent();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        // Check that the id matches
+        Task t = (Task) o;
+        return key.equals(t.key);
+    }
+
+    @Override
+    public String toString() {
+        return "[" + key.toString() + "] " + title;
+    }
+
+    public void dump(String prefix, PrintWriter writer) {
+        writer.print(prefix); writer.print(key);
+        if (!isDockable) {
+            writer.print(" dockable=N");
+        }
+        if (isLaunchTarget) {
+            writer.print(" launchTarget=Y");
+        }
+        if (isLocked) {
+            writer.print(" locked=Y");
+        }
+        writer.print(" "); writer.print(title);
+        writer.println();
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/TaskKeyCache.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/TaskKeyCache.java
new file mode 100644
index 0000000000000000000000000000000000000000..342cb75b2c14ff1d6471ce1860af2c0fb185347e
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/TaskKeyCache.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.systemui.shared.recents.model;
+
+import android.util.Log;
+import android.util.SparseArray;
+
+import com.android.systemui.shared.recents.model.Task.TaskKey;
+
+/**
+ * Base class for both strong and LRU task key cache.
+ */
+public abstract class TaskKeyCache<V> {
+
+    protected static final String TAG = "TaskKeyCache";
+
+    protected final SparseArray<TaskKey> mKeys = new SparseArray<>();
+
+    /**
+     * Gets a specific entry in the cache with the specified key, regardless of whether the cached
+     * value is valid or not.
+     */
+    public final synchronized V get(TaskKey key) {
+        return getCacheEntry(key.id);
+    }
+
+    /**
+     * Returns the value only if the key is valid (has not been updated since the last time it was
+     * in the cache)
+     */
+    public final synchronized V getAndInvalidateIfModified(TaskKey key) {
+        TaskKey lastKey = mKeys.get(key.id);
+        if (lastKey != null) {
+            if ((lastKey.windowingMode != key.windowingMode) ||
+                    (lastKey.lastActiveTime != key.lastActiveTime)) {
+                // The task has updated (been made active since the last time it was put into the
+                // LRU cache) or the stack id for the task has changed, invalidate that cache item
+                remove(key);
+                return null;
+            }
+        }
+        // Either the task does not exist in the cache, or the last active time is the same as
+        // the key specified, so return what is in the cache
+        return getCacheEntry(key.id);
+    }
+
+    /** Puts an entry in the cache for a specific key. */
+    public final synchronized void put(TaskKey key, V value) {
+        if (key == null || value == null) {
+            Log.e(TAG, "Unexpected null key or value: " + key + ", " + value);
+            return;
+        }
+        mKeys.put(key.id, key);
+        putCacheEntry(key.id, value);
+    }
+
+
+    /** Removes a cache entry for a specific key. */
+    public final synchronized void remove(TaskKey key) {
+        // Remove the key after the cache value because we need it to make the callback
+        removeCacheEntry(key.id);
+        mKeys.remove(key.id);
+    }
+
+    /** Removes all the entries in the cache. */
+    public final synchronized void evictAll() {
+        evictAllCache();
+        mKeys.clear();
+    }
+
+    protected abstract V getCacheEntry(int id);
+    protected abstract void putCacheEntry(int id, V value);
+    protected abstract void removeCacheEntry(int id);
+    protected abstract void evictAllCache();
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/TaskKeyLruCache.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/TaskKeyLruCache.java
new file mode 100644
index 0000000000000000000000000000000000000000..e106c657109dc9681d493c5e2bd15bcd0452b71f
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/TaskKeyLruCache.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.shared.recents.model;
+
+import android.util.LruCache;
+
+import com.android.systemui.shared.recents.model.Task.TaskKey;
+
+import java.io.PrintWriter;
+
+/**
+ * A mapping of {@link TaskKey} to value, with additional LRU functionality where the least
+ * recently referenced key/values will be evicted as more values than the given cache size are
+ * inserted.
+ *
+ * In addition, this also allows the caller to invalidate cached values for keys that have since
+ * changed.
+ */
+public class TaskKeyLruCache<V> extends TaskKeyCache<V> {
+
+    public interface EvictionCallback {
+        void onEntryEvicted(TaskKey key);
+    }
+
+    private final LruCache<Integer, V> mCache;
+    private final EvictionCallback mEvictionCallback;
+
+    public TaskKeyLruCache(int cacheSize) {
+        this(cacheSize, null);
+    }
+
+    public TaskKeyLruCache(int cacheSize, EvictionCallback evictionCallback) {
+        mEvictionCallback = evictionCallback;
+        mCache = new LruCache<Integer, V>(cacheSize) {
+
+            @Override
+            protected void entryRemoved(boolean evicted, Integer taskId, V oldV, V newV) {
+                if (mEvictionCallback != null) {
+                    mEvictionCallback.onEntryEvicted(mKeys.get(taskId));
+                }
+
+                // Only remove from mKeys on cache remove, not a cache update.
+                if (newV == null) {
+                    mKeys.remove(taskId);
+                }
+            }
+        };
+    }
+
+    /** Trims the cache to a specific size */
+    public final void trimToSize(int cacheSize) {
+        mCache.trimToSize(cacheSize);
+    }
+
+    public void dump(String prefix, PrintWriter writer) {
+        String innerPrefix = prefix + "  ";
+
+        writer.print(prefix); writer.print(TAG);
+        writer.print(" numEntries="); writer.print(mKeys.size());
+        writer.println();
+        int keyCount = mKeys.size();
+        for (int i = 0; i < keyCount; i++) {
+            writer.print(innerPrefix); writer.println(mKeys.get(mKeys.keyAt(i)));
+        }
+    }
+
+    @Override
+    protected V getCacheEntry(int id) {
+        return mCache.get(id);
+    }
+
+    @Override
+    protected void putCacheEntry(int id, V value) {
+        mCache.put(id, value);
+    }
+
+    @Override
+    protected void removeCacheEntry(int id) {
+        mCache.remove(id);
+    }
+
+    @Override
+    protected void evictAllCache() {
+        mCache.evictAll();
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/ThumbnailData.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/ThumbnailData.java
new file mode 100644
index 0000000000000000000000000000000000000000..02c779a809e67444399f73b932c73d895e5d02bf
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/model/ThumbnailData.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2016 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.recents.model;
+
+import static android.content.res.Configuration.ORIENTATION_UNDEFINED;
+import static com.android.systemui.shared.system.WindowManagerWrapper.WINDOWING_MODE_UNDEFINED;
+
+import android.app.ActivityManager.TaskSnapshot;
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import com.android.systemui.shared.QuickstepCompat;
+
+/**
+ * Data for a single thumbnail.
+ */
+public class ThumbnailData {
+
+    public final Bitmap thumbnail;
+    public int orientation;
+    public Rect insets;
+    public boolean reducedResolution;
+    public boolean isRealSnapshot;
+    public boolean isTranslucent;
+    public int windowingMode;
+    public int systemUiVisibility;
+    public float scale;
+
+    public ThumbnailData() {
+        thumbnail = null;
+        orientation = ORIENTATION_UNDEFINED;
+        insets = new Rect();
+        reducedResolution = false;
+        scale = 1f;
+        isRealSnapshot = true;
+        isTranslucent = false;
+        windowingMode = WINDOWING_MODE_UNDEFINED;
+        systemUiVisibility = 0;
+    }
+
+    public ThumbnailData(TaskSnapshot snapshot) {
+        thumbnail = QuickstepCompat.getRecentsCompat().getThumbnail(snapshot);
+        insets = new Rect(snapshot.getContentInsets());
+        orientation = snapshot.getOrientation();
+        reducedResolution = snapshot.isReducedResolution();
+        scale = snapshot.getScale();
+        isRealSnapshot = snapshot.isRealSnapshot();
+        isTranslucent = snapshot.isTranslucent();
+        windowingMode = snapshot.getWindowingMode();
+        systemUiVisibility = snapshot.getSystemUiVisibility();
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/utilities/AppTrace.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/utilities/AppTrace.java
new file mode 100644
index 0000000000000000000000000000000000000000..0241c593b85095495210a47bb22ab3c0f3aca353
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/utilities/AppTrace.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.systemui.shared.recents.utilities;
+
+import static android.os.Trace.TRACE_TAG_APP;
+
+/**
+ * Helper class for internal trace functions.
+ */
+public class AppTrace {
+
+    /**
+     * Begins a new async trace section with the given {@param key} and {@param cookie}.
+     */
+    public static void start(String key, int cookie) {
+        android.os.Trace.asyncTraceBegin(TRACE_TAG_APP, key, cookie);
+    }
+
+    /**
+     * Begins a new async trace section with the given {@param key}.
+     */
+    public static void start(String key) {
+        android.os.Trace.asyncTraceBegin(TRACE_TAG_APP, key, 0);
+    }
+
+    /**
+     * Ends an existing async trace section with the given {@param key}.
+     */
+    public static void end(String key) {
+        android.os.Trace.asyncTraceEnd(TRACE_TAG_APP, key, 0);
+    }
+
+    /**
+     * Ends an existing async trace section with the given {@param key} and {@param cookie}.
+     */
+    public static void end(String key, int cookie) {
+        android.os.Trace.asyncTraceEnd(TRACE_TAG_APP, key, cookie);
+    }
+
+    /**
+     * Begins a new trace section with the given {@param key}. Can be nested.
+     */
+    public static void beginSection(String key) {
+        android.os.Trace.beginSection(key);
+    }
+
+    /**
+     * Ends an existing trace section started in the last {@link #beginSection(String)}.
+     */
+    public static void endSection() {
+        android.os.Trace.endSection();
+    }
+
+    /**
+     * Traces a counter value.
+     */
+    public static void count(String name, int count) {
+        android.os.Trace.traceCounter(TRACE_TAG_APP, name, count);
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/utilities/RectFEvaluator.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/utilities/RectFEvaluator.java
new file mode 100644
index 0000000000000000000000000000000000000000..51c1b5aa13d75d2ceb0441cbb3ba3ebfb3700112
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/utilities/RectFEvaluator.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2016 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.recents.utilities;
+
+import android.animation.TypeEvaluator;
+import android.graphics.RectF;
+
+/**
+ * This evaluator can be used to perform type interpolation between <code>RectF</code> values.
+ */
+public class RectFEvaluator implements TypeEvaluator<RectF> {
+
+    private final RectF mRect = new RectF();
+
+    /**
+     * This function returns the result of linearly interpolating the start and
+     * end Rect values, with <code>fraction</code> representing the proportion
+     * between the start and end values. The calculation is a simple parametric
+     * calculation on each of the separate components in the Rect objects
+     * (left, top, right, and bottom).
+     *
+     * <p>The object returned will be the <code>reuseRect</code> passed into the constructor.</p>
+     *
+     * @param fraction   The fraction from the starting to the ending values
+     * @param startValue The start Rect
+     * @param endValue   The end Rect
+     * @return A linear interpolation between the start and end values, given the
+     *         <code>fraction</code> parameter.
+     */
+    @Override
+    public RectF evaluate(float fraction, RectF startValue, RectF endValue) {
+        float left = startValue.left + ((endValue.left - startValue.left) * fraction);
+        float top = startValue.top + ((endValue.top - startValue.top) * fraction);
+        float right = startValue.right + ((endValue.right - startValue.right) * fraction);
+        float bottom = startValue.bottom + ((endValue.bottom - startValue.bottom) * fraction);
+        mRect.set(left, top, right, bottom);
+        return mRect;
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/utilities/Utilities.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/utilities/Utilities.java
new file mode 100644
index 0000000000000000000000000000000000000000..7dffc26139561b195327c9c79ef8d9bccf78b439
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/utilities/Utilities.java
@@ -0,0 +1,61 @@
+/*
+ * 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.recents.utilities;
+
+import android.graphics.Color;
+import android.os.Handler;
+import android.os.Message;
+
+/* Common code */
+public class Utilities {
+
+    /**
+     * Posts a runnable on a handler at the front of the queue ignoring any sync barriers.
+     */
+    public static void postAtFrontOfQueueAsynchronously(Handler h, Runnable r) {
+        Message msg = h.obtainMessage().setCallback(r);
+        h.sendMessageAtFrontOfQueue(msg);
+    }
+
+    /** Calculates the constrast between two colors, using the algorithm provided by the WCAG v2. */
+    public static float computeContrastBetweenColors(int bg, int fg) {
+        float bgR = Color.red(bg) / 255f;
+        float bgG = Color.green(bg) / 255f;
+        float bgB = Color.blue(bg) / 255f;
+        bgR = (bgR < 0.03928f) ? bgR / 12.92f : (float) Math.pow((bgR + 0.055f) / 1.055f, 2.4f);
+        bgG = (bgG < 0.03928f) ? bgG / 12.92f : (float) Math.pow((bgG + 0.055f) / 1.055f, 2.4f);
+        bgB = (bgB < 0.03928f) ? bgB / 12.92f : (float) Math.pow((bgB + 0.055f) / 1.055f, 2.4f);
+        float bgL = 0.2126f * bgR + 0.7152f * bgG + 0.0722f * bgB;
+
+        float fgR = Color.red(fg) / 255f;
+        float fgG = Color.green(fg) / 255f;
+        float fgB = Color.blue(fg) / 255f;
+        fgR = (fgR < 0.03928f) ? fgR / 12.92f : (float) Math.pow((fgR + 0.055f) / 1.055f, 2.4f);
+        fgG = (fgG < 0.03928f) ? fgG / 12.92f : (float) Math.pow((fgG + 0.055f) / 1.055f, 2.4f);
+        fgB = (fgB < 0.03928f) ? fgB / 12.92f : (float) Math.pow((fgB + 0.055f) / 1.055f, 2.4f);
+        float fgL = 0.2126f * fgR + 0.7152f * fgG + 0.0722f * fgB;
+
+        return Math.abs((fgL + 0.05f) / (bgL + 0.05f));
+    }
+
+    /**
+     * @return the clamped {@param value} between the provided {@param min} and {@param max}.
+     */
+    public static float clamp(float value, float min, float max) {
+        return Math.max(min, Math.min(max, value));
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/view/AppTransitionAnimationSpecCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/view/AppTransitionAnimationSpecCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..ebdc884285d28a1611154179bf5cbdab9cd3a9e8
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/view/AppTransitionAnimationSpecCompat.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.systemui.shared.recents.view;
+
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.view.AppTransitionAnimationSpec;
+
+/**
+ * Wraps the internal app transition animation spec.
+ */
+public class AppTransitionAnimationSpecCompat {
+
+    private int mTaskId;
+    private Bitmap mBuffer;
+    private Rect mRect;
+
+    public AppTransitionAnimationSpecCompat(int taskId, Bitmap buffer, Rect rect) {
+        mTaskId = taskId;
+        mBuffer = buffer;
+        mRect = rect;
+    }
+
+    public AppTransitionAnimationSpec toAppTransitionAnimationSpec() {
+        return new AppTransitionAnimationSpec(mTaskId,
+                mBuffer != null ? mBuffer.createGraphicBufferHandle() : null, mRect);
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/view/AppTransitionAnimationSpecsFuture.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/view/AppTransitionAnimationSpecsFuture.java
new file mode 100644
index 0000000000000000000000000000000000000000..c227feec75b6cbe29363f8b10360075ba330ca56
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/view/AppTransitionAnimationSpecsFuture.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.systemui.shared.recents.view;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.os.RemoteException;
+import android.view.AppTransitionAnimationSpec;
+import android.view.IAppTransitionAnimationSpecsFuture;
+
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.FutureTask;
+
+/**
+ * To be implemented by a particular animation to asynchronously provide the animation specs for a
+ * particular transition.
+ */
+public abstract class AppTransitionAnimationSpecsFuture {
+
+    private final Handler mHandler;
+    private FutureTask<List<AppTransitionAnimationSpecCompat>> mComposeTask = new FutureTask<>(
+            new Callable<List<AppTransitionAnimationSpecCompat>>() {
+                @Override
+                public List<AppTransitionAnimationSpecCompat> call() throws Exception {
+                    return composeSpecs();
+                }
+            });
+
+    private final IAppTransitionAnimationSpecsFuture mFuture =
+            new IAppTransitionAnimationSpecsFuture.Stub() {
+        @Override
+        public AppTransitionAnimationSpec[] get() throws RemoteException {
+            try {
+                if (!mComposeTask.isDone()) {
+                    mHandler.post(mComposeTask);
+                }
+                List<AppTransitionAnimationSpecCompat> specs = mComposeTask.get();
+                // Clear reference to the compose task this future holds onto the reference to it's
+                // implementation (which can leak references to the bitmap it creates for the
+                // transition)
+                mComposeTask = null;
+                if (specs == null) {
+                    return null;
+                }
+
+                AppTransitionAnimationSpec[] arr = new AppTransitionAnimationSpec[specs.size()];
+                for (int i = 0; i < specs.size(); i++) {
+                    arr[i] = specs.get(i).toAppTransitionAnimationSpec();
+                }
+                return arr;
+            } catch (Exception e) {
+                return null;
+            }
+        }
+    };
+
+    public AppTransitionAnimationSpecsFuture(Handler handler) {
+        mHandler = handler;
+    }
+
+    /**
+     * Returns the future to handle the call from window manager.
+     */
+    public final IAppTransitionAnimationSpecsFuture getFuture() {
+        return mFuture;
+    }
+
+    /**
+     * Called ahead of the future callback to compose the specs to be returned in the future.
+     */
+    public final void composeSpecsSynchronous() {
+        if (Looper.myLooper() != mHandler.getLooper()) {
+            throw new RuntimeException("composeSpecsSynchronous() called from wrong looper");
+        }
+        mComposeTask.run();
+    }
+
+    public abstract List<AppTransitionAnimationSpecCompat> composeSpecs();
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/view/RecentsTransition.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/view/RecentsTransition.java
new file mode 100644
index 0000000000000000000000000000000000000000..e253360a53641d17e82c8ddb2ae4b133435381d4
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/recents/view/RecentsTransition.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.systemui.shared.recents.view;
+
+import android.app.ActivityOptions;
+import android.app.ActivityOptions.OnAnimationStartedListener;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.GraphicBuffer;
+import android.graphics.Picture;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IRemoteCallback;
+import android.os.RemoteException;
+import android.view.View;
+
+import java.util.function.Consumer;
+
+/**
+ * A helper class to create transitions to/from an App to Recents.
+ */
+public class RecentsTransition {
+
+    /**
+     * Creates a new transition aspect scaled transition activity options.
+     */
+    public static ActivityOptions createAspectScaleAnimation(Context context, Handler handler,
+            boolean scaleUp, AppTransitionAnimationSpecsFuture animationSpecsFuture,
+            final Runnable animationStartCallback) {
+        final OnAnimationStartedListener animStartedListener = new OnAnimationStartedListener() {
+            private boolean mHandled;
+
+            @Override
+            public void onAnimationStarted() {
+                // OnAnimationStartedListener can be called numerous times, so debounce here to
+                // prevent multiple callbacks
+                if (mHandled) {
+                    return;
+                }
+                mHandled = true;
+
+                if (animationStartCallback != null) {
+                    animationStartCallback.run();
+                }
+            }
+        };
+        final ActivityOptions opts = ActivityOptions.makeMultiThumbFutureAspectScaleAnimation(
+                context, handler,
+                animationSpecsFuture != null ? animationSpecsFuture.getFuture() : null,
+                animStartedListener, scaleUp);
+        return opts;
+    }
+
+    /**
+     * Wraps a animation-start callback in a binder that can be called from window manager.
+     */
+    public static IRemoteCallback wrapStartedListener(final Handler handler,
+            final Runnable animationStartCallback) {
+        if (animationStartCallback == null) {
+            return null;
+        }
+        return new IRemoteCallback.Stub() {
+            @Override
+            public void sendResult(Bundle data) throws RemoteException {
+                handler.post(animationStartCallback);
+            }
+        };
+    }
+
+    /**
+     * @return a {@link GraphicBuffer} with the {@param view} drawn into it. Result can be null if
+     *         we were unable to allocate a hardware bitmap.
+     */
+    public static Bitmap drawViewIntoHardwareBitmap(int width, int height, final View view,
+            final float scale, final int eraseColor) {
+        return createHardwareBitmap(width, height, new Consumer<Canvas>() {
+            @Override
+            public void accept(Canvas c) {
+                c.scale(scale, scale);
+                if (eraseColor != 0) {
+                    c.drawColor(eraseColor);
+                }
+                if (view != null) {
+                    view.draw(c);
+                }
+            }
+        });
+    }
+
+    /**
+     * @return a hardware {@link Bitmap} after being drawn with the {@param consumer}. Result can be
+     *         null if we were unable to allocate a hardware bitmap.
+     */
+    public static Bitmap createHardwareBitmap(int width, int height, Consumer<Canvas> consumer) {
+        final Picture picture = new Picture();
+        final Canvas canvas = picture.beginRecording(width, height);
+        consumer.accept(canvas);
+        picture.endRecording();
+        return Bitmap.createBitmap(picture);
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ActivityCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ActivityCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..4db744c59e6000ee544e8b795d08869e93cbc6fc
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ActivityCompat.java
@@ -0,0 +1,67 @@
+/*
+ * 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.Activity;
+import android.view.View;
+import android.view.ViewHierarchyEncoder;
+
+import com.android.systemui.shared.QuickstepCompat;
+
+import java.io.ByteArrayOutputStream;
+
+public class ActivityCompat {
+    private final Activity mWrapped;
+
+    public ActivityCompat(Activity activity) {
+        mWrapped = activity;
+    }
+
+    /**
+     * @see Activity#registerRemoteAnimations
+     */
+    public void registerRemoteAnimations(RemoteAnimationDefinitionCompat definition) {
+        mWrapped.registerRemoteAnimations(definition.getWrapped());
+    }
+
+    /**
+     * @see android.view.ViewDebug#dumpv2(View, ByteArrayOutputStream)
+     */
+    public boolean encodeViewHierarchy(ByteArrayOutputStream out) {
+        View view = null;
+        if (mWrapped.getWindow() != null &&
+                mWrapped.getWindow().peekDecorView() != null &&
+                mWrapped.getWindow().peekDecorView().getViewRootImpl() != null) {
+            view = mWrapped.getWindow().peekDecorView().getViewRootImpl().getView();
+        }
+        if (view == null) {
+            return false;
+        }
+
+        final ViewHierarchyEncoder encoder = new ViewHierarchyEncoder(out);
+        int[] location = view.getLocationOnScreen();
+        encoder.addProperty("window:left", location[0]);
+        encoder.addProperty("window:top", location[1]);
+        view.encode(encoder);
+        encoder.endStream();
+        return true;
+    }
+
+    public int getDisplayId() {
+        return QuickstepCompat.getActivityManager().getDisplayId(mWrapped);
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ActivityManagerWrapper.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ActivityManagerWrapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1ba8f0d365eab99b348215aa51eddb63bc1dcea
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ActivityManagerWrapper.java
@@ -0,0 +1,515 @@
+/*
+ * Copyright (C) 2015 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 static android.app.ActivityManager.LOCK_TASK_MODE_LOCKED;
+import static android.app.ActivityManager.LOCK_TASK_MODE_NONE;
+import static android.app.ActivityManager.LOCK_TASK_MODE_PINNED;
+import static android.app.ActivityManager.RECENT_IGNORE_UNAVAILABLE;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+
+import android.annotation.NonNull;
+import android.app.ActivityManager;
+import android.app.ActivityManager.RecentTaskInfo;
+import android.app.ActivityManager.RunningTaskInfo;
+import android.app.ActivityOptions;
+import android.app.AppGlobals;
+import android.app.IAssistDataReceiver;
+import android.app.WindowConfiguration;
+import android.app.WindowConfiguration.ActivityType;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.UserInfo;
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.os.UserHandle;
+import android.provider.Settings;
+import android.util.Log;
+import android.view.IRecentsAnimationController;
+import android.view.RemoteAnimationTarget;
+import com.android.internal.app.IVoiceInteractionManagerService;
+import com.android.systemui.shared.QuickstepCompat;
+import com.android.systemui.shared.recents.model.Task;
+import com.android.systemui.shared.recents.model.ThumbnailData;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Future;
+import java.util.function.Consumer;
+import xyz.paphonb.quickstep.compat.RecentsAnimationRunner;
+
+public class ActivityManagerWrapper {
+
+    private static final String TAG = "ActivityManagerWrapper";
+
+    private static final ActivityManagerWrapper sInstance = new ActivityManagerWrapper();
+
+    // Should match the values in PhoneWindowManager
+    public static final String CLOSE_SYSTEM_WINDOWS_REASON_RECENTS = "recentapps";
+
+    private final PackageManager mPackageManager;
+    private final BackgroundExecutor mBackgroundExecutor;
+    private final TaskStackChangeListeners mTaskStackChangeListeners;
+
+    private ActivityManagerWrapper() {
+        final Context context = AppGlobals.getInitialApplication();
+        mPackageManager = context.getPackageManager();
+        mBackgroundExecutor = BackgroundExecutor.get();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            mTaskStackChangeListeners = new TaskStackChangeListenersVQ(Looper.getMainLooper());
+        } else {
+            mTaskStackChangeListeners = new TaskStackChangeListenersVP(Looper.getMainLooper());
+        }
+    }
+
+    public static ActivityManagerWrapper getInstance() {
+        return sInstance;
+    }
+
+    /**
+     * @return the current user's id.
+     */
+    public int getCurrentUserId() {
+        UserInfo ui;
+        try {
+            ui = ActivityManager.getService().getCurrentUser();
+            return ui != null ? ui.id : 0;
+        } catch (RemoteException e) {
+            throw e.rethrowFromSystemServer();
+        }
+    }
+
+    /**
+     * @return the top running task (can be {@code null}).
+     */
+    public ActivityManager.RunningTaskInfo getRunningTask() {
+        return getRunningTask(ACTIVITY_TYPE_RECENTS /* ignoreActivityType */);
+    }
+
+    public ActivityManager.RunningTaskInfo getRunningTask(@ActivityType int ignoreActivityType) {
+        // Note: The set of running tasks from the system is ordered by recency
+        try {
+            List<ActivityManager.RunningTaskInfo> tasks =
+                    QuickstepCompat.getActivityManager().getFilteredTasks(1, ignoreActivityType,
+                            WINDOWING_MODE_PINNED /* ignoreWindowingMode */);
+            if (tasks.isEmpty()) {
+                return null;
+            }
+            return tasks.get(0);
+        } catch (RemoteException e) {
+            return null;
+        }
+    }
+
+    /**
+     * @return a list of the recents tasks.
+     */
+    public List<RecentTaskInfo> getRecentTasks(int numTasks, int userId) {
+        try {
+            return QuickstepCompat.getActivityManager().getRecentTasks(numTasks,
+                            RECENT_IGNORE_UNAVAILABLE, userId);
+        } catch (RemoteException e) {
+            Log.e(TAG, "Failed to get recent tasks", e);
+            return new ArrayList<>();
+        }
+    }
+
+    /**
+     * @return the task snapshot for the given {@param taskId}.
+     */
+    public @NonNull ThumbnailData getTaskThumbnail(int taskId, boolean reducedResolution) {
+        ActivityManager.TaskSnapshot snapshot = null;
+        try {
+            snapshot = QuickstepCompat.getActivityManager().getTaskSnapshot(taskId, reducedResolution);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to retrieve task snapshot", e);
+        }
+        if (snapshot != null) {
+            return new ThumbnailData(snapshot);
+        } else {
+            return new ThumbnailData();
+        }
+    }
+
+    /**
+     * @return the activity label, badging if necessary.
+     */
+    public String getBadgedActivityLabel(ActivityInfo info, int userId) {
+        return getBadgedLabel(info.loadLabel(mPackageManager).toString(), userId);
+    }
+
+    /**
+     * @return the application label, badging if necessary.
+     */
+    public String getBadgedApplicationLabel(ApplicationInfo appInfo, int userId) {
+        return getBadgedLabel(appInfo.loadLabel(mPackageManager).toString(), userId);
+    }
+
+    /**
+     * @return the content description for a given task, badging it if necessary.  The content
+     * description joins the app and activity labels.
+     */
+    public String getBadgedContentDescription(ActivityInfo info, int userId,
+            ActivityManager.TaskDescription td) {
+        String activityLabel;
+        if (td != null && td.getLabel() != null) {
+            activityLabel = td.getLabel();
+        } else {
+            activityLabel = info.loadLabel(mPackageManager).toString();
+        }
+        String applicationLabel = info.applicationInfo.loadLabel(mPackageManager).toString();
+        String badgedApplicationLabel = getBadgedLabel(applicationLabel, userId);
+        return applicationLabel.equals(activityLabel)
+                ? badgedApplicationLabel
+                : badgedApplicationLabel + " " + activityLabel;
+    }
+
+    /**
+     * @return the given label for a user, badging if necessary.
+     */
+    private String getBadgedLabel(String label, int userId) {
+        if (userId != UserHandle.myUserId()) {
+            label = mPackageManager.getUserBadgedLabel(label, new UserHandle(userId)).toString();
+        }
+        return label;
+    }
+
+    /**
+     * Starts the recents activity. The caller should manage the thread on which this is called.
+     */
+    public void startRecentsActivity(Intent intent, final AssistDataReceiver assistDataReceiver,
+            final RecentsAnimationListener animationHandler, final Consumer<Boolean> resultCallback,
+            Handler resultCallbackHandler) {
+        try {
+            IAssistDataReceiver receiver = null;
+            if (assistDataReceiver != null) {
+                receiver = new IAssistDataReceiver.Stub() {
+                    public void onHandleAssistData(Bundle resultData) {
+                        assistDataReceiver.onHandleAssistData(resultData);
+                    }
+                    public void onHandleAssistScreenshot(Bitmap screenshot) {
+                        assistDataReceiver.onHandleAssistScreenshot(screenshot);
+                    }
+                };
+            }
+            RecentsAnimationRunner runner = null;
+            if (animationHandler != null) {
+                runner = new RecentsAnimationRunner() {
+                    @Override
+                    public void onAnimationStart(IRecentsAnimationController controller,
+                            RemoteAnimationTarget[] apps, Rect homeContentInsets,
+                            Rect minimizedHomeBounds) {
+                        final RecentsAnimationControllerCompat controllerCompat =
+                                new RecentsAnimationControllerCompat(controller);
+                        final RemoteAnimationTargetCompat[] appsCompat =
+                                RemoteAnimationTargetCompat.wrap(apps);
+                        animationHandler.onAnimationStart(controllerCompat, appsCompat,
+                                homeContentInsets, minimizedHomeBounds);
+                    }
+
+                    @Override
+                    public void onAnimationCanceled(boolean deferredWithScreenshot) {
+                        animationHandler.onAnimationCanceled(deferredWithScreenshot);
+                    }
+                };
+            }
+            QuickstepCompat.getActivityManager().startRecentsActivity(intent, receiver, runner);
+            if (resultCallback != null) {
+                resultCallbackHandler.post(new Runnable() {
+                    @Override
+                    public void run() {
+                        resultCallback.accept(true);
+                    }
+                });
+            }
+        } catch (Exception e) {
+            if (resultCallback != null) {
+                resultCallbackHandler.post(new Runnable() {
+                    @Override
+                    public void run() {
+                        resultCallback.accept(false);
+                    }
+                });
+            }
+        }
+    }
+
+    /**
+     * Cancels the remote recents animation started from {@link #startRecentsActivity}.
+     */
+    public void cancelRecentsAnimation(boolean restoreHomeStackPosition) {
+        try {
+            QuickstepCompat.getActivityManager().cancelRecentsAnimation(restoreHomeStackPosition);
+        } catch (RemoteException e) {
+            Log.e(TAG, "Failed to cancel recents animation", e);
+        }
+    }
+
+    /**
+     * Starts a task from Recents.
+     *
+     * @see {@link #startActivityFromRecentsAsync(TaskKey, ActivityOptions, int, int, Consumer, Handler)}
+     */
+    public void startActivityFromRecentsAsync(Task.TaskKey taskKey, ActivityOptions options,
+            Consumer<Boolean> resultCallback, Handler resultCallbackHandler) {
+        startActivityFromRecentsAsync(taskKey, options, WINDOWING_MODE_UNDEFINED,
+                ACTIVITY_TYPE_UNDEFINED, resultCallback, resultCallbackHandler);
+    }
+
+    /**
+     * Starts a task from Recents.
+     *
+     * @param resultCallback The result success callback
+     * @param resultCallbackHandler The handler to receive the result callback
+     */
+    public void startActivityFromRecentsAsync(final Task.TaskKey taskKey, ActivityOptions options,
+            int windowingMode, int activityType, final Consumer<Boolean> resultCallback,
+            final Handler resultCallbackHandler) {
+        if (taskKey.windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+            // We show non-visible docked tasks in Recents, but we always want to launch
+            // them in the fullscreen stack.
+            if (options == null) {
+                options = ActivityOptions.makeBasic();
+            }
+            options.setLaunchWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY);
+        } else if (windowingMode != WINDOWING_MODE_UNDEFINED
+                || activityType != ACTIVITY_TYPE_UNDEFINED) {
+            if (options == null) {
+                options = ActivityOptions.makeBasic();
+            }
+            options.setLaunchWindowingMode(windowingMode);
+            options.setLaunchActivityType(activityType);
+        }
+        final ActivityOptions finalOptions = options;
+
+
+        boolean result = false;
+        try {
+            result = startActivityFromRecents(taskKey.id, finalOptions);
+        } catch (Exception e) {
+            // Fall through
+        }
+        final boolean finalResult = result;
+        if (resultCallback != null) {
+            resultCallbackHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    resultCallback.accept(finalResult);
+                }
+            });
+        }
+    }
+
+    /**
+     * Starts a task from Recents synchronously.
+     */
+    public boolean startActivityFromRecents(int taskId, ActivityOptions options) {
+        try {
+            Bundle optsBundle = options == null ? null : options.toBundle();
+            QuickstepCompat.getActivityManager().startActivityFromRecents(taskId, optsBundle);
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    /**
+     * Moves an already resumed task to the side of the screen to initiate split screen.
+     */
+    public boolean setTaskWindowingModeSplitScreenPrimary(int taskId, int createMode,
+            Rect initialBounds) {
+        try {
+            return QuickstepCompat.getActivityManager().setTaskWindowingModeSplitScreenPrimary(taskId,
+                    createMode, true /* onTop */, false /* animate */, initialBounds,
+                    true /* showRecents */);
+        } catch (RemoteException e) {
+            return false;
+        }
+    }
+
+    /**
+     * Registers a task stack listener with the system.
+     * This should be called on the main thread.
+     */
+    public void registerTaskStackListener(TaskStackChangeListener listener) {
+        synchronized (mTaskStackChangeListeners) {
+            mTaskStackChangeListeners.addListener(ActivityManager.getService(), listener);
+        }
+    }
+
+    /**
+     * Unregisters a task stack listener with the system.
+     * This should be called on the main thread.
+     */
+    public void unregisterTaskStackListener(TaskStackChangeListener listener) {
+        synchronized (mTaskStackChangeListeners) {
+            mTaskStackChangeListeners.removeListener(listener);
+        }
+    }
+
+    /**
+     * Requests that the system close any open system windows (including other SystemUI).
+     */
+    public Future<?> closeSystemWindows(final String reason) {
+        return mBackgroundExecutor.submit(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    ActivityManager.getService().closeSystemDialogs(reason);
+                } catch (RemoteException e) {
+                    Log.w(TAG, "Failed to close system windows", e);
+                }
+            }
+        });
+    }
+
+    /**
+     * Removes a task by id.
+     */
+    public void removeTask(final int taskId) {
+        mBackgroundExecutor.submit(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    QuickstepCompat.getActivityManager().removeTask(taskId);
+                } catch (RemoteException e) {
+                    Log.w(TAG, "Failed to remove task=" + taskId, e);
+                }
+            }
+        });
+    }
+
+    /**
+     * Removes all the recent tasks.
+     */
+    public void removeAllRecentTasks() {
+        mBackgroundExecutor.submit(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    QuickstepCompat.getActivityManager().removeAllVisibleRecentTasks();
+                } catch (RemoteException e) {
+                    Log.w(TAG, "Failed to remove all tasks", e);
+                }
+            }
+        });
+    }
+
+    /**
+     * Cancels the current window transtion to/from Recents for the given task id.
+     */
+    public void cancelWindowTransition(int taskId) {
+        try {
+            QuickstepCompat.getActivityManager().cancelTaskWindowTransition(taskId);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to cancel window transition for task=" + taskId, e);
+        }
+    }
+
+    /**
+     * @return whether screen pinning is active.
+     */
+    public boolean isScreenPinningActive() {
+        try {
+            return QuickstepCompat.getActivityManager().getLockTaskModeState() == LOCK_TASK_MODE_PINNED;
+        } catch (RemoteException e) {
+            return false;
+        }
+    }
+
+    /**
+     * @return whether screen pinning is enabled.
+     */
+    public boolean isScreenPinningEnabled() {
+        final ContentResolver cr = AppGlobals.getInitialApplication().getContentResolver();
+        return Settings.System.getInt(cr, Settings.System.LOCK_TO_APP_ENABLED, 0) != 0;
+    }
+
+    /**
+     * @return whether there is currently a locked task (ie. in screen pinning).
+     */
+    public boolean isLockToAppActive() {
+        try {
+            return QuickstepCompat.getActivityManager().getLockTaskModeState() != LOCK_TASK_MODE_NONE;
+        } catch (RemoteException e) {
+            return false;
+        }
+    }
+
+    /**
+     * @return whether lock task mode is active in kiosk-mode (not screen pinning).
+     */
+    public boolean isLockTaskKioskModeActive() {
+        try {
+            return QuickstepCompat.getActivityManager().getLockTaskModeState() == LOCK_TASK_MODE_LOCKED;
+        } catch (RemoteException e) {
+            return false;
+        }
+    }
+
+    /**
+     * Shows a voice session identified by {@code token}
+     * @return true if the session was shown, false otherwise
+     */
+    public boolean showVoiceSession(IBinder token, Bundle args, int flags) {
+        IVoiceInteractionManagerService service = IVoiceInteractionManagerService.Stub.asInterface(
+                ServiceManager.getService(Context.VOICE_INTERACTION_MANAGER_SERVICE));
+        if (service == null) {
+            return false;
+        }
+        try {
+            return service.showSessionFromSession(token, args, flags);
+        } catch (RemoteException e) {
+            return false;
+        }
+    }
+
+    /**
+     * Returns true if the system supports freeform multi-window.
+     */
+    public boolean supportsFreeformMultiWindow(Context context) {
+        final boolean freeformDevOption = Settings.Global.getInt(context.getContentResolver(),
+                Settings.Global.DEVELOPMENT_ENABLE_FREEFORM_WINDOWS_SUPPORT, 0) != 0;
+        return QuickstepCompat.getActivityManager().supportsMultiWindow(context)
+                && (context.getPackageManager().hasSystemFeature(
+                PackageManager.FEATURE_FREEFORM_WINDOW_MANAGEMENT)
+                || freeformDevOption);
+    }
+
+    /**
+     * Returns true if the running task represents the home task
+     */
+    public static boolean isHomeTask(RunningTaskInfo info) {
+        return info.configuration.windowConfiguration.getActivityType()
+                == WindowConfiguration.ACTIVITY_TYPE_HOME;
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ActivityOptionsCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ActivityOptionsCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..817fe32f18e57cea97121a2968275d03308c40b0
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ActivityOptionsCompat.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.systemui.shared.system;
+
+import static android.app.ActivityTaskManager.SPLIT_SCREEN_CREATE_MODE_BOTTOM_OR_RIGHT;
+import static android.app.ActivityTaskManager.SPLIT_SCREEN_CREATE_MODE_TOP_OR_LEFT;
+import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+
+import android.app.ActivityOptions;
+import android.content.Context;
+import android.os.Build;
+import android.os.Handler;
+
+/**
+ * Wrapper around internal ActivityOptions creation.
+ */
+public abstract class ActivityOptionsCompat {
+
+    /**
+     * @return ActivityOptions for starting a task in split screen as the primary window.
+     */
+    public static ActivityOptions makeSplitScreenOptions(boolean dockTopLeft) {
+        return makeSplitScreenOptions(dockTopLeft, true);
+    }
+
+    /**
+     * @return ActivityOptions for starting a task in split screen.
+     */
+    public static ActivityOptions makeSplitScreenOptions(boolean dockTopLeft, boolean isPrimary) {
+        final ActivityOptions options = ActivityOptions.makeBasic();
+        options.setLaunchWindowingMode(isPrimary
+                ? WINDOWING_MODE_SPLIT_SCREEN_PRIMARY
+                : WINDOWING_MODE_SPLIT_SCREEN_SECONDARY);
+        options.setSplitScreenCreateMode(dockTopLeft
+                ? SPLIT_SCREEN_CREATE_MODE_TOP_OR_LEFT
+                : SPLIT_SCREEN_CREATE_MODE_BOTTOM_OR_RIGHT);
+        return options;
+    }
+
+    /**
+     * @return ActivityOptions for starting a task in freeform.
+     */
+    public static ActivityOptions makeFreeformOptions() {
+        final ActivityOptions options = ActivityOptions.makeBasic();
+        options.setLaunchWindowingMode(WINDOWING_MODE_FREEFORM);
+        return options;
+    }
+
+    public static ActivityOptions makeRemoteAnimation(
+            RemoteAnimationAdapterCompat remoteAnimationAdapter) {
+        return ActivityOptions.makeRemoteAnimation(remoteAnimationAdapter.getWrapped());
+    }
+
+    public static ActivityOptions makeCustomAnimation(Context context, int enterResId,
+            int exitResId, final Runnable callback, final Handler callbackHandler) {
+        return ActivityOptions.makeCustomAnimation(context, enterResId, exitResId, callbackHandler,
+                new ActivityOptions.OnAnimationStartedListener() {
+                    @Override
+                    public void onAnimationStarted() {
+                        if (callback != null) {
+                            callbackHandler.post(callback);
+                        }
+                    }
+                });
+    }
+
+    /**
+     * Sets the flag to freeze the recents task list reordering as a part of launching the activity.
+     */
+    public static ActivityOptions setFreezeRecentTasksList(ActivityOptions opts) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            opts.setFreezeRecentTasksReordering();
+        }
+        return opts;
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/AssistDataReceiver.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/AssistDataReceiver.java
new file mode 100644
index 0000000000000000000000000000000000000000..7cd6c512b660608325b30f44c163633ab11a2f39
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/AssistDataReceiver.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.systemui.shared.system;
+
+import android.graphics.Bitmap;
+import android.os.Bundle;
+
+/**
+ * Abstract class for assist data receivers.
+ */
+public abstract class AssistDataReceiver {
+    public void onHandleAssistData(Bundle resultData) {}
+    public void onHandleAssistScreenshot(Bitmap screenshot) {}
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/BackgroundExecutor.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/BackgroundExecutor.java
new file mode 100644
index 0000000000000000000000000000000000000000..0bd89a78cfdae233db022b5a65a8595ca40dbf99
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/BackgroundExecutor.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.systemui.shared.system;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+/**
+ * Offloads work from other threads by running it in a background thread.
+ */
+public class BackgroundExecutor {
+
+    private static final BackgroundExecutor sInstance = new BackgroundExecutor();
+
+    private final ExecutorService mExecutorService = Executors.newFixedThreadPool(2);
+
+    /**
+     * @return the static instance of the background executor.
+     */
+    public static BackgroundExecutor get() {
+        return sInstance;
+    }
+
+    /**
+     * Runs the given {@param callable} on one of the background executor threads.
+     */
+    public <T> Future<T> submit(Callable<T> callable) {
+        return mExecutorService.submit(callable);
+    }
+
+    /**
+     * Runs the given {@param runnable} on one of the background executor threads.
+     */
+    public Future<?> submit(Runnable runnable) {
+        return mExecutorService.submit(runnable);
+    }
+
+    /**
+     * Runs the given {@param runnable} on one of the background executor threads. Return
+     * {@param result} when the future is resolved.
+     */
+    public <T> Future<T> submit(Runnable runnable, T result) {
+        return mExecutorService.submit(runnable, result);
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ChoreographerCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ChoreographerCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..76b447e3fa934bc0ea46a03f44c47f85e7496411
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ChoreographerCompat.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.systemui.shared.system;
+
+import static android.view.Choreographer.CALLBACK_INPUT;
+
+import android.view.Choreographer;
+
+/**
+ * Wraps the internal choreographer.
+ */
+public class ChoreographerCompat {
+
+    /**
+     * Posts an input callback to the choreographer.
+     */
+    public static void postInputFrame(Choreographer choreographer, Runnable runnable) {
+        choreographer.postCallback(CALLBACK_INPUT, runnable, null);
+    }
+
+    public static Choreographer getSfInstance() {
+        return Choreographer.getSfInstance();
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ContextCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ContextCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..51fcb0a841caf1eda1720178ed9f29de3e547db2
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ContextCompat.java
@@ -0,0 +1,34 @@
+/*
+ * 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.content.Context;
+
+/**
+ * Wraps a context to expose some methods for launcher to call.
+ */
+public class ContextCompat {
+    private final Context mWrapped;
+
+    public ContextCompat(Context context) {
+        mWrapped = context;
+    }
+
+    public int getUserId() {
+        return mWrapped.getUserId();
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/DevicePolicyManagerWrapper.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/DevicePolicyManagerWrapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..c6722aece9fc5d1b224b79906f16ca0769b0da93
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/DevicePolicyManagerWrapper.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2019 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.AppGlobals;
+import android.app.admin.DevicePolicyManager;
+
+/**
+ * Wrapper for {@link DevicePolicyManager}.
+ */
+public class DevicePolicyManagerWrapper {
+    private static final DevicePolicyManagerWrapper sInstance = new DevicePolicyManagerWrapper();
+
+    private static final DevicePolicyManager sDevicePolicyManager =
+            AppGlobals.getInitialApplication().getSystemService(DevicePolicyManager.class);
+
+    private DevicePolicyManagerWrapper() { }
+
+    public static DevicePolicyManagerWrapper getInstance() {
+        return sInstance;
+    }
+
+    /**
+     * Returns whether the given package is allowed to run in Lock Task mode.
+     */
+    public boolean isLockTaskPermitted(String pkg) {
+        return sDevicePolicyManager.isLockTaskPermitted(pkg);
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/DockedStackListenerCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/DockedStackListenerCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb319e625b4417d5502166be6bc7a3f44acb0669
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/DockedStackListenerCompat.java
@@ -0,0 +1,63 @@
+/*
+ * 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.view.IDockedStackListener;
+
+/**
+ * An interface to track docked stack changes.
+ */
+public class DockedStackListenerCompat {
+
+    IDockedStackListener.Stub mListener = new IDockedStackListener.Stub() {
+        @Override
+        public void onDividerVisibilityChanged(boolean visible) {}
+
+        @Override
+        public void onDockedStackExistsChanged(boolean exists) {
+            DockedStackListenerCompat.this.onDockedStackExistsChanged(exists);
+        }
+
+        @Override
+        public void onDockedStackMinimizedChanged(boolean minimized, long animDuration,
+                boolean isHomeStackResizable) {
+            DockedStackListenerCompat.this.onDockedStackMinimizedChanged(minimized, animDuration,
+                    isHomeStackResizable);
+        }
+
+        @Override
+        public void onAdjustedForImeChanged(boolean adjustedForIme, long animDuration) {}
+
+        @Override
+        public void onDockSideChanged(final int newDockSide) {
+            DockedStackListenerCompat.this.onDockSideChanged(newDockSide);
+        }
+    };
+
+    public void onDockedStackExistsChanged(boolean exists) {
+        // To be overridden
+    }
+
+    public void onDockedStackMinimizedChanged(boolean minimized, long animDuration,
+            boolean isHomeStackResizable) {
+        // To be overridden
+    }
+
+    public void onDockSideChanged(final int newDockSide) {
+        // To be overridden
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/InputChannelCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/InputChannelCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..4714c42a4a8ad49a3cee970a37845afc6dc76e99
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/InputChannelCompat.java
@@ -0,0 +1,128 @@
+/**
+ * Copyright (C) 2019 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.os.Bundle;
+import android.os.Looper;
+import android.view.BatchedInputEventReceiver;
+import android.view.Choreographer;
+import android.view.InputChannel;
+import android.view.InputEvent;
+import android.view.InputEventSender;
+import android.view.MotionEvent;
+
+import com.android.systemui.shared.QuickstepCompat;
+
+import xyz.paphonb.quickstep.compat.InputCompat;
+
+/**
+ * @see android.view.InputChannel
+ */
+public class InputChannelCompat {
+
+    /**
+     * Callback for receiving event callbacks
+     */
+    public interface InputEventListener {
+        /**
+         * @param ev event to be handled
+         */
+        void onInputEvent(InputEvent ev);
+    }
+
+    /**
+     * Creates a dispatcher from the extras received as part on onInitialize
+     */
+    public static InputEventReceiver fromBundle(Bundle params, String key,
+            Looper looper, Choreographer choreographer, InputEventListener listener) {
+
+        InputChannel channel = params.getParcelable(key);
+        return new InputEventReceiver(channel, looper, choreographer, listener);
+    }
+
+    /**
+     * Version of addBatch method which preserves time accuracy in nanoseconds instead of
+     * converting the time to milliseconds.
+     * @param src old MotionEvent where the target should be appended
+     * @param target new MotionEvent which should be added to the src
+     * @return true if the merge was successful
+     *
+     * @see MotionEvent#addBatch(MotionEvent)
+     */
+    public static boolean mergeMotionEvent(MotionEvent src, MotionEvent target) {
+        return target.addBatch(src);
+    }
+
+    /**
+     * @see BatchedInputEventReceiver
+     */
+    public static class InputEventReceiver {
+
+        private final BatchedInputEventReceiver mReceiver;
+        private final InputChannel mInputChannel;
+
+        public InputEventReceiver(InputChannel inputChannel, Looper looper,
+                Choreographer choreographer, final InputEventListener listener) {
+            mInputChannel = inputChannel;
+            mReceiver = QuickstepCompat.getInputCompat().createBatchedInputEventReceiver(
+                    inputChannel, looper, choreographer, new InputCompat.InputEventListener() {
+                        @Override
+                        public boolean onInputEvent(InputEvent event) {
+                            listener.onInputEvent(event);
+                            return true;
+                        }
+                    });
+        }
+
+        /**
+         * @see BatchedInputEventReceiver#dispose()
+         */
+        public void dispose() {
+            mReceiver.dispose();
+            mInputChannel.dispose();
+        }
+    }
+
+    /**
+     * @see InputEventSender
+     */
+    public static class InputEventDispatcher {
+
+        private final InputChannel mInputChannel;
+        private final InputEventSender mSender;
+
+        public InputEventDispatcher(InputChannel inputChannel, Looper looper) {
+            mInputChannel = inputChannel;
+            mSender = new InputEventSender(inputChannel, looper) { };
+        }
+
+        /**
+         * @see InputEventSender#sendInputEvent(int, InputEvent)
+         */
+        public void dispatch(InputEvent ev) {
+            mSender.sendInputEvent(ev.getSequenceNumber(), ev);
+        }
+
+        /**
+         * @see InputEventSender#dispose()
+         */
+        public void dispose() {
+            mSender.dispose();
+            mInputChannel.dispose();
+        }
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/InputConsumerController.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/InputConsumerController.java
new file mode 100644
index 0000000000000000000000000000000000000000..930e61981bff9e97336e1386e0f2a3452c171905
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/InputConsumerController.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.shared.system;
+
+import static android.view.Display.DEFAULT_DISPLAY;
+import static android.view.WindowManager.INPUT_CONSUMER_PIP;
+import static android.view.WindowManager.INPUT_CONSUMER_RECENTS_ANIMATION;
+
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.RemoteException;
+import android.util.Log;
+import android.view.BatchedInputEventReceiver;
+import android.view.Choreographer;
+import android.view.IWindowManager;
+import android.view.InputChannel;
+import android.view.InputEvent;
+import android.view.WindowManagerGlobal;
+import com.android.systemui.shared.QuickstepCompat;
+import java.io.PrintWriter;
+import xyz.paphonb.quickstep.compat.InputCompat;
+
+/**
+ * Manages the input consumer that allows the SystemUI to directly receive input.
+ */
+public class InputConsumerController {
+
+    private static final String TAG = InputConsumerController.class.getSimpleName();
+
+    /**
+     * Listener interface for callers to subscribe to input events.
+     */
+    public interface InputListener {
+        /** Handles any input event. */
+        boolean onInputEvent(InputEvent ev);
+    }
+
+    /**
+     * Listener interface for callers to learn when this class is registered or unregistered with
+     * window manager
+     */
+    public interface RegistrationListener {
+        void onRegistrationChanged(boolean isRegistered);
+    }
+
+    /**
+     * Input handler used for the input consumer. Input events are batched and consumed with the
+     * SurfaceFlinger vsync.
+     */
+    private BatchedInputEventReceiver createInputEventReceiver(InputChannel inputChannel, Looper looper) {
+        return QuickstepCompat.getInputCompat().createBatchedInputEventReceiver(
+                inputChannel, looper, Choreographer.getSfInstance(), new InputCompat.InputEventListener() {
+                    @Override
+                    public boolean onInputEvent(InputEvent event) {
+                        if (mListener != null) {
+                            return mListener.onInputEvent(event);
+                        }
+                        return true;
+                    }
+                });
+    }
+
+    private final IWindowManager mWindowManager;
+    private final IBinder mToken;
+    private final String mName;
+
+    private BatchedInputEventReceiver mInputEventReceiver;
+    private InputListener mListener;
+    private RegistrationListener mRegistrationListener;
+
+    /**
+     * @param name the name corresponding to the input consumer that is defined in the system.
+     */
+    public InputConsumerController(IWindowManager windowManager, String name) {
+        mWindowManager = windowManager;
+        mToken = new Binder();
+        mName = name;
+    }
+
+    /**
+     * @return A controller for the pip input consumer.
+     */
+    public static InputConsumerController getPipInputConsumer() {
+        return new InputConsumerController(WindowManagerGlobal.getWindowManagerService(),
+                INPUT_CONSUMER_PIP);
+    }
+
+    /**
+     * @return A controller for the recents animation input consumer.
+     */
+    public static InputConsumerController getRecentsAnimationInputConsumer() {
+        return new InputConsumerController(WindowManagerGlobal.getWindowManagerService(),
+                INPUT_CONSUMER_RECENTS_ANIMATION);
+    }
+
+    /**
+     * Sets the input listener.
+     */
+    public void setInputListener(InputListener listener) {
+        mListener = listener;
+    }
+
+    /**
+     * Sets the registration listener.
+     */
+    public void setRegistrationListener(RegistrationListener listener) {
+        mRegistrationListener = listener;
+        if (mRegistrationListener != null) {
+            mRegistrationListener.onRegistrationChanged(mInputEventReceiver != null);
+        }
+    }
+
+    /**
+     * Check if the InputConsumer is currently registered with WindowManager
+     *
+     * @return {@code true} if registered, {@code false} if not.
+     */
+    public boolean isRegistered() {
+        return mInputEventReceiver != null;
+    }
+
+    /**
+     * Registers the input consumer.
+     */
+    public void registerInputConsumer() {
+        if (mInputEventReceiver == null) {
+            final InputChannel inputChannel = new InputChannel();
+            try {
+                // TODO(b/113087003): Support Picture-in-picture in multi-display.
+                QuickstepCompat.getInputCompat().destroyInputConsumer(mWindowManager, mName, DEFAULT_DISPLAY);
+                QuickstepCompat.getInputCompat().createInputConsumer(mWindowManager, mToken, mName, DEFAULT_DISPLAY, inputChannel);
+            } catch (RemoteException e) {
+                Log.e(TAG, "Failed to create input consumer", e);
+            }
+            mInputEventReceiver = createInputEventReceiver(inputChannel, Looper.myLooper());
+            if (mRegistrationListener != null) {
+                mRegistrationListener.onRegistrationChanged(true /* isRegistered */);
+            }
+        }
+    }
+
+    /**
+     * Unregisters the input consumer.
+     */
+    public void unregisterInputConsumer() {
+        if (mInputEventReceiver != null) {
+            try {
+                // TODO(b/113087003): Support Picture-in-picture in multi-display.
+                QuickstepCompat.getInputCompat().destroyInputConsumer(mWindowManager, mName, DEFAULT_DISPLAY);
+            } catch (RemoteException e) {
+                Log.e(TAG, "Failed to destroy input consumer", e);
+            }
+            mInputEventReceiver.dispose();
+            mInputEventReceiver = null;
+            if (mRegistrationListener != null) {
+                mRegistrationListener.onRegistrationChanged(false /* isRegistered */);
+            }
+        }
+    }
+
+    public void dump(PrintWriter pw, String prefix) {
+        final String innerPrefix = prefix + "  ";
+        pw.println(prefix + TAG);
+        pw.println(innerPrefix + "registered=" + (mInputEventReceiver != null));
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/InputMonitorCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/InputMonitorCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..319d18774176efcb25f42e8318619558452c07c7
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/InputMonitorCompat.java
@@ -0,0 +1,71 @@
+/**
+ * Copyright (C) 2019 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.os.Build;
+import android.os.Bundle;
+import android.os.Looper;
+import android.view.Choreographer;
+import android.view.InputMonitor;
+
+import com.android.systemui.shared.system.InputChannelCompat.InputEventListener;
+import com.android.systemui.shared.system.InputChannelCompat.InputEventReceiver;
+
+/**
+ * @see android.view.InputMonitor
+ */
+public class InputMonitorCompat {
+
+    private final InputMonitor mInputMonitor;
+
+    private InputMonitorCompat(InputMonitor monitor) {
+        mInputMonitor = monitor;
+    }
+
+    /**
+     * @see InputMonitor#pilferPointers()
+     */
+    public void pilferPointers() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return;
+        mInputMonitor.pilferPointers();
+    }
+
+    /**
+     * @see InputMonitor#dispose()
+     */
+    public void dispose() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return;
+        mInputMonitor.dispose();
+    }
+
+    /**
+     * @see InputMonitor#getInputChannel()
+     */
+    public InputEventReceiver getInputReceiver(Looper looper, Choreographer choreographer,
+            InputEventListener listener) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return null;
+        return new InputEventReceiver(mInputMonitor.getInputChannel(), looper, choreographer,
+                listener);
+    }
+
+    /**
+     * Gets the input monitor stored in a bundle
+     */
+    public static InputMonitorCompat fromBundle(Bundle bundle, String key) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return new InputMonitorCompat(null);
+        return new InputMonitorCompat((InputMonitor) bundle.getParcelable(key));
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/KeyguardManagerCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/KeyguardManagerCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..c42e7e3fd216fe8a119df89fd10516ab6a48c2e9
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/KeyguardManagerCompat.java
@@ -0,0 +1,32 @@
+/*
+ * 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.KeyguardManager;
+import android.content.Context;
+
+public class KeyguardManagerCompat {
+    private final KeyguardManager mKeyguardManager;
+
+    public KeyguardManagerCompat(Context context) {
+        mKeyguardManager = (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
+    }
+
+    public boolean isDeviceLocked(int userId) {
+        return mKeyguardManager.isDeviceLocked(userId);
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/LatencyTrackerCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/LatencyTrackerCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d5933e5f59905c9af3f95752e47f99deef5086c
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/LatencyTrackerCompat.java
@@ -0,0 +1,34 @@
+/*
+ * 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.content.Context;
+
+import com.android.internal.util.LatencyTracker;
+
+/**
+ * @see LatencyTracker
+ */
+public class LatencyTrackerCompat {
+    public static boolean isEnabled(Context context) {
+        return LatencyTracker.isEnabled(context);
+    }
+
+    public static void logToggleRecents(int duration) {
+        LatencyTracker.logAction(LatencyTracker.ACTION_TOGGLE_RECENTS, duration);
+    }
+}
\ No newline at end of file
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/LauncherEventUtil.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/LauncherEventUtil.java
new file mode 100644
index 0000000000000000000000000000000000000000..eed9580e221364f7b05a83bb230e464398b3cf7e
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/LauncherEventUtil.java
@@ -0,0 +1,29 @@
+/*
+ * 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;
+
+public class LauncherEventUtil {
+
+    // Constants for the Action
+    public static final int VISIBLE = 0;
+    public static final int DISMISS = 1;
+
+    // Constants for the Target (View)
+    public static final int RECENTS_SWIPE_UP_ONBOARDING_TIP = 0;
+    public static final int RECENTS_QUICK_SCRUB_ONBOARDING_TIP = 1;
+
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/MetricsLoggerCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/MetricsLoggerCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..952c8aee240839f048def65cfd0239ef9575cebd
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/MetricsLoggerCompat.java
@@ -0,0 +1,50 @@
+/*
+ * 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 com.android.internal.logging.MetricsLogger;
+import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
+
+public class MetricsLoggerCompat {
+
+    private final MetricsLogger mMetricsLogger;
+    public static final int OVERVIEW_ACTIVITY = MetricsEvent.OVERVIEW_ACTIVITY;
+
+    public MetricsLoggerCompat() {
+        mMetricsLogger = new MetricsLogger();
+    }
+
+    public void action(int category) {
+        mMetricsLogger.action(category);
+    }
+
+    public void action(int category, int value) {
+        mMetricsLogger.action(category, value);
+    }
+
+    public void visible(int category) {
+        mMetricsLogger.visible(category);
+    }
+
+    public void hidden(int category) {
+        mMetricsLogger.hidden(category);
+    }
+
+    public void visibility(int category, boolean visible) {
+        mMetricsLogger.visibility(category, visible);
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/PackageManagerWrapper.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/PackageManagerWrapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..443c1e1280fa431cd5a4dfa802ad8f5edd49e6c5
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/PackageManagerWrapper.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2015 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.AppGlobals;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.IPackageManager;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.ResolveInfoFlags;
+import android.content.pm.ResolveInfo;
+import android.os.RemoteException;
+import android.os.UserHandle;
+
+import java.util.List;
+
+public class PackageManagerWrapper {
+
+    private static final PackageManagerWrapper sInstance = new PackageManagerWrapper();
+
+    private static final IPackageManager mIPackageManager = AppGlobals.getPackageManager();
+
+    public static final String ACTION_PREFERRED_ACTIVITY_CHANGED =
+            Intent.ACTION_PREFERRED_ACTIVITY_CHANGED;
+
+    public static PackageManagerWrapper getInstance() {
+        return sInstance;
+    }
+
+    private PackageManagerWrapper() {}
+
+    /**
+     * @return the activity info for a given {@param componentName} and {@param userId}.
+     */
+    public ActivityInfo getActivityInfo(ComponentName componentName, int userId) {
+        try {
+            return mIPackageManager.getActivityInfo(componentName, PackageManager.GET_META_DATA,
+                    userId);
+        } catch (RemoteException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * Report the set of 'Home' activity candidates, plus (if any) which of them
+     * is the current "always use this one" setting.
+     */
+    public ComponentName getHomeActivities(List<ResolveInfo> allHomeCandidates) {
+        try {
+            return mIPackageManager.getHomeActivities(allHomeCandidates);
+        } catch (RemoteException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * Determine the best Activity to perform for a given Intent.
+     */
+    public ResolveInfo resolveActivity(Intent intent, @ResolveInfoFlags int flags) {
+        final String resolvedType =
+                intent.resolveTypeIfNeeded(AppGlobals.getInitialApplication().getContentResolver());
+        try {
+            return mIPackageManager.resolveIntent(
+                    intent, resolvedType, flags, UserHandle.getCallingUserId());
+        } catch (RemoteException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/PinnedStackListenerForwarder.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/PinnedStackListenerForwarder.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ae2df5b97bf51e584ff38faa7f1420a439325c3
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/PinnedStackListenerForwarder.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2019 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.content.pm.ParceledListSlice;
+import android.graphics.Rect;
+import android.os.RemoteException;
+import android.view.IPinnedStackController;
+import android.view.IPinnedStackListener;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * PinnedStackListener that simply forwards all calls to each listener added via
+ * {@link #addListener}. This is necessary since calling
+ * {@link com.android.server.wm.WindowManagerService#registerPinnedStackListener} replaces any
+ * previously set listener.
+ */
+public class PinnedStackListenerForwarder extends IPinnedStackListener.Stub {
+    private List<IPinnedStackListener> mListeners = new ArrayList<>();
+
+    /** Adds a listener to receive updates from the WindowManagerService. */
+    public void addListener(IPinnedStackListener listener) {
+        mListeners.add(listener);
+    }
+
+    /** Removes a listener so it will no longer receive updates from the WindowManagerService. */
+    public void removeListener(IPinnedStackListener listener) {
+        mListeners.remove(listener);
+    }
+
+    @Override
+    public void onListenerRegistered(IPinnedStackController controller) throws RemoteException {
+        for (IPinnedStackListener listener : mListeners) {
+            listener.onListenerRegistered(controller);
+        }
+    }
+
+    @Override
+    public void onMovementBoundsChanged(Rect insetBounds, Rect normalBounds, Rect animatingBounds,
+            boolean fromImeAdjustment, boolean fromShelfAdjustment, int displayRotation)
+            throws RemoteException {
+        for (IPinnedStackListener listener : mListeners) {
+            listener.onMovementBoundsChanged(
+                    insetBounds, normalBounds, animatingBounds,
+                    fromImeAdjustment, fromShelfAdjustment, displayRotation);
+        }
+    }
+
+    @Override
+    public void onImeVisibilityChanged(boolean imeVisible, int imeHeight) throws RemoteException {
+        for (IPinnedStackListener listener : mListeners) {
+            listener.onImeVisibilityChanged(imeVisible, imeHeight);
+        }
+    }
+
+    @Override
+    public void onShelfVisibilityChanged(boolean shelfVisible, int shelfHeight)
+            throws RemoteException {
+        for (IPinnedStackListener listener : mListeners) {
+            listener.onShelfVisibilityChanged(shelfVisible, shelfHeight);
+        }
+    }
+
+    @Override
+    public void onMinimizedStateChanged(boolean isMinimized) throws RemoteException {
+        for (IPinnedStackListener listener : mListeners) {
+            listener.onMinimizedStateChanged(isMinimized);
+        }
+    }
+
+    @Override
+    public void onActionsChanged(ParceledListSlice actions) throws RemoteException {
+        for (IPinnedStackListener listener : mListeners) {
+            listener.onActionsChanged(actions);
+        }
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/QuickStepContract.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/QuickStepContract.java
new file mode 100644
index 0000000000000000000000000000000000000000..072fc69758d8c464fa2964accd9c6fc27638adad
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/QuickStepContract.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (C) 2019 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 static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_2BUTTON;
+import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_3BUTTON;
+import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_GESTURAL;
+
+import android.annotation.IntDef;
+import android.content.Context;
+import android.content.res.Resources;
+import android.os.Build;
+import android.view.ViewConfiguration;
+import android.view.WindowManagerPolicyConstants;
+import com.android.internal.policy.ScreenDecorationsUtils;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.StringJoiner;
+
+/**
+ * Various shared constants between Launcher and SysUI as part of quickstep
+ */
+public class QuickStepContract {
+
+    public static final String KEY_EXTRA_SYSUI_PROXY = "extra_sysui_proxy";
+    public static final String KEY_EXTRA_INPUT_MONITOR = "extra_input_monitor";
+    public static final String KEY_EXTRA_WINDOW_CORNER_RADIUS = "extra_window_corner_radius";
+    public static final String KEY_EXTRA_SUPPORTS_WINDOW_CORNERS = "extra_supports_window_corners";
+
+    public static final String NAV_BAR_MODE_2BUTTON_OVERLAY =
+            WindowManagerPolicyConstants.NAV_BAR_MODE_2BUTTON_OVERLAY;
+    public static final String NAV_BAR_MODE_3BUTTON_OVERLAY =
+            WindowManagerPolicyConstants.NAV_BAR_MODE_3BUTTON_OVERLAY;
+    public static final String NAV_BAR_MODE_GESTURAL_OVERLAY =
+            WindowManagerPolicyConstants.NAV_BAR_MODE_GESTURAL_OVERLAY;
+
+    // Action sent by a system app to switch to gesture nav
+    public static final String ACTION_ENABLE_GESTURE_NAV =
+            "com.android.systemui.ENABLE_GESTURE_NAV";
+    // Action for the intent to receive the result
+    public static final String ACTION_ENABLE_GESTURE_NAV_RESULT =
+            "com.android.systemui.action.ENABLE_GESTURE_NAV_RESULT";
+    // Extra containing the pending intent to receive the result
+    public static final String EXTRA_RESULT_INTENT = "com.android.systemui.EXTRA_RESULT_INTENT";
+
+    // Overview is disabled, either because the device is in lock task mode, or because the device
+    // policy has disabled the feature
+    public static final int SYSUI_STATE_SCREEN_PINNING = 1 << 0;
+    // The navigation bar is hidden due to immersive mode
+    public static final int SYSUI_STATE_NAV_BAR_HIDDEN = 1 << 1;
+    // The notification panel is expanded and interactive (either locked or unlocked), and the
+    // quick settings is not expanded
+    public static final int SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED = 1 << 2;
+    // The keyguard bouncer is showing
+    public static final int SYSUI_STATE_BOUNCER_SHOWING = 1 << 3;
+    // The navigation bar a11y button should be shown
+    public static final int SYSUI_STATE_A11Y_BUTTON_CLICKABLE = 1 << 4;
+    // The navigation bar a11y button shortcut is available
+    public static final int SYSUI_STATE_A11Y_BUTTON_LONG_CLICKABLE = 1 << 5;
+    // The keyguard is showing and not occluded
+    public static final int SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING = 1 << 6;
+    // The recents feature is disabled (either by SUW/SysUI/device policy)
+    public static final int SYSUI_STATE_OVERVIEW_DISABLED = 1 << 7;
+    // The home feature is disabled (either by SUW/SysUI/device policy)
+    public static final int SYSUI_STATE_HOME_DISABLED = 1 << 8;
+    // The keyguard is showing, but occluded
+    public static final int SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED = 1 << 9;
+    // The search feature is disabled (either by SUW/SysUI/device policy)
+    public static final int SYSUI_STATE_SEARCH_DISABLED = 1 << 10;
+    // The notification panel is expanded and interactive (either locked or unlocked), and the
+    // quick settings is not expanded
+    public static final int SYSUI_STATE_QUICK_SETTINGS_EXPANDED = 1 << 11;
+
+    @Retention(RetentionPolicy.SOURCE)
+    @IntDef({SYSUI_STATE_SCREEN_PINNING,
+            SYSUI_STATE_NAV_BAR_HIDDEN,
+            SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED,
+            SYSUI_STATE_QUICK_SETTINGS_EXPANDED,
+            SYSUI_STATE_BOUNCER_SHOWING,
+            SYSUI_STATE_A11Y_BUTTON_CLICKABLE,
+            SYSUI_STATE_A11Y_BUTTON_LONG_CLICKABLE,
+            SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING,
+            SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED,
+            SYSUI_STATE_OVERVIEW_DISABLED,
+            SYSUI_STATE_HOME_DISABLED,
+            SYSUI_STATE_SEARCH_DISABLED
+    })
+    public @interface SystemUiStateFlags {}
+
+    public static String getSystemUiStateString(int flags) {
+        StringJoiner str = new StringJoiner("|");
+        str.add((flags & SYSUI_STATE_SCREEN_PINNING) != 0 ? "screen_pinned" : "");
+        str.add((flags & SYSUI_STATE_OVERVIEW_DISABLED) != 0 ? "overview_disabled" : "");
+        str.add((flags & SYSUI_STATE_HOME_DISABLED) != 0 ? "home_disabled" : "");
+        str.add((flags & SYSUI_STATE_SEARCH_DISABLED) != 0 ? "search_disabled" : "");
+        str.add((flags & SYSUI_STATE_NAV_BAR_HIDDEN) != 0 ? "navbar_hidden" : "");
+        str.add((flags & SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED) != 0 ? "notif_visible" : "");
+        str.add((flags & SYSUI_STATE_QUICK_SETTINGS_EXPANDED) != 0 ? "qs_visible" : "");
+        str.add((flags & SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING) != 0 ? "keygrd_visible" : "");
+        str.add((flags & SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED) != 0
+                ? "keygrd_occluded" : "");
+        str.add((flags & SYSUI_STATE_BOUNCER_SHOWING) != 0 ? "bouncer_visible" : "");
+        str.add((flags & SYSUI_STATE_A11Y_BUTTON_CLICKABLE) != 0 ? "a11y_click" : "");
+        str.add((flags & SYSUI_STATE_A11Y_BUTTON_LONG_CLICKABLE) != 0 ? "a11y_long_click" : "");
+        return str.toString();
+    }
+
+    /**
+     * Ratio of quickstep touch slop (when system takes over the touch) to view touch slop
+     */
+    public static final float QUICKSTEP_TOUCH_SLOP_RATIO = 3;
+
+    /**
+     * Touch slop for quickstep gesture
+     */
+    public static final float getQuickStepTouchSlopPx(Context context) {
+        return QUICKSTEP_TOUCH_SLOP_RATIO * ViewConfiguration.get(context).getScaledTouchSlop();
+    }
+
+    /**
+     * Touch slopes and thresholds for quick step operations. Drag slop is the point where the
+     * home button press/long press over are ignored and will start to drag when exceeded and the
+     * touch slop is when the respected operation will occur when exceeded. Touch slop must be
+     * larger than the drag slop.
+     */
+    public static int getQuickStepDragSlopPx() {
+        return convertDpToPixel(10);
+    }
+
+    public static int getQuickStepTouchSlopPx() {
+        return convertDpToPixel(24);
+    }
+
+    public static int getQuickScrubTouchSlopPx() {
+        return convertDpToPixel(24);
+    }
+
+    private static int convertDpToPixel(float dp) {
+        return (int) (dp * Resources.getSystem().getDisplayMetrics().density);
+    }
+
+    /**
+     * Returns whether the specified sysui state is such that the assistant gesture should be
+     * disabled.
+     */
+    public static boolean isAssistantGestureDisabled(int sysuiStateFlags) {
+        // Disable when in quick settings, screen pinning, immersive, the bouncer is showing, 
+        // or search is disabled
+        int disableFlags = SYSUI_STATE_SCREEN_PINNING
+                | SYSUI_STATE_NAV_BAR_HIDDEN
+                | SYSUI_STATE_BOUNCER_SHOWING
+                | SYSUI_STATE_SEARCH_DISABLED
+                | SYSUI_STATE_QUICK_SETTINGS_EXPANDED;
+        if ((sysuiStateFlags & disableFlags) != 0) {
+            return true;
+        }
+
+        // Disable when notifications are showing (only if unlocked)
+        if ((sysuiStateFlags & SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED) != 0
+                && (sysuiStateFlags & SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING) == 0) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Returns whether the specified sysui state is such that the back gesture should be
+     * disabled.
+     */
+    public static boolean isBackGestureDisabled(int sysuiStateFlags) {
+        // Always allow when the bouncer is showing (even on top of the keyguard)
+        if ((sysuiStateFlags & SYSUI_STATE_BOUNCER_SHOWING) != 0) {
+            return false;
+        }
+        // Disable when in immersive, or the notifications are interactive
+        int disableFlags = SYSUI_STATE_NAV_BAR_HIDDEN
+                | SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED
+                | SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING;
+        return (sysuiStateFlags & disableFlags) != 0;
+    }
+
+    /**
+     * @return whether this nav bar mode is edge to edge
+     */
+    public static boolean isGesturalMode(int mode) {
+        return mode == NAV_BAR_MODE_GESTURAL;
+    }
+
+    /**
+     * @return whether this nav bar mode is swipe up
+     */
+    public static boolean isSwipeUpMode(int mode) {
+        return mode == NAV_BAR_MODE_2BUTTON;
+    }
+
+    /**
+     * @return whether this nav bar mode is 3 button
+     */
+    public static boolean isLegacyMode(int mode) {
+        return mode == NAV_BAR_MODE_3BUTTON;
+    }
+
+    /**
+     * Corner radius that should be used on windows in order to cover the display.
+     * These values are expressed in pixels because they should not respect display or font
+     * scaling, this means that we don't have to reload them on config changes.
+     */
+    public static float getWindowCornerRadius(Resources resources) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            return ScreenDecorationsUtils.getWindowCornerRadius(resources);
+        } else {
+            return 0;
+        }
+    }
+
+    /**
+     * If live rounded corners are supported on windows.
+     */
+    public static boolean supportsRoundedCornersOnWindows(Resources resources) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            return ScreenDecorationsUtils.supportsRoundedCornersOnWindows(resources);
+        } else {
+            return true;
+        }
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RecentsAnimationControllerCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RecentsAnimationControllerCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..d72c0a1f69a73aee87f429d4477c7147a71b8362
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RecentsAnimationControllerCompat.java
@@ -0,0 +1,125 @@
+/*
+ * 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.ActivityManager.TaskSnapshot;
+import android.os.Build;
+import android.os.Build.VERSION;
+import android.os.RemoteException;
+import android.util.Log;
+import android.view.IRecentsAnimationController;
+
+import com.android.systemui.shared.QuickstepCompat;
+import com.android.systemui.shared.recents.model.ThumbnailData;
+
+public class RecentsAnimationControllerCompat {
+
+    private static final String TAG = RecentsAnimationControllerCompat.class.getSimpleName();
+
+    private IRecentsAnimationController mAnimationController;
+
+    public RecentsAnimationControllerCompat() { }
+
+    public RecentsAnimationControllerCompat(IRecentsAnimationController animationController) {
+        mAnimationController = animationController;
+    }
+
+    public ThumbnailData screenshotTask(int taskId) {
+        try {
+            TaskSnapshot snapshot = mAnimationController.screenshotTask(taskId);
+            return snapshot != null ? new ThumbnailData(snapshot) : new ThumbnailData();
+        } catch (RemoteException e) {
+            Log.e(TAG, "Failed to screenshot task", e);
+            return new ThumbnailData();
+        }
+    }
+
+    public void setInputConsumerEnabled(boolean enabled) {
+        try {
+            mAnimationController.setInputConsumerEnabled(enabled);
+        } catch (RemoteException e) {
+            Log.e(TAG, "Failed to set input consumer enabled state", e);
+        }
+    }
+
+    public void setAnimationTargetsBehindSystemBars(boolean behindSystemBars) {
+        try {
+            mAnimationController.setAnimationTargetsBehindSystemBars(behindSystemBars);
+        } catch (RemoteException e) {
+            Log.e(TAG, "Failed to set whether animation targets are behind system bars", e);
+        }
+    }
+
+    public void setSplitScreenMinimized(boolean minimized) {
+        try {
+            mAnimationController.setSplitScreenMinimized(minimized);
+        } catch (RemoteException e) {
+            Log.e(TAG, "Failed to set minimize dock", e);
+        }
+    }
+
+    public void hideCurrentInputMethod() {
+        try {
+            mAnimationController.hideCurrentInputMethod();
+        } catch (RemoteException e) {
+            Log.e(TAG, "Failed to set hide input method", e);
+        }
+    }
+
+    /**
+     * Finish the current recents animation.
+     * @param toHome Going to home or back to the previous app.
+     * @param sendUserLeaveHint determines whether userLeaveHint will be set true to the previous
+     *                          app.
+     */
+    public void finish(boolean toHome, boolean sendUserLeaveHint) {
+        try {
+            QuickstepCompat.getRecentsCompat().finishRecentsAnimation(
+                    mAnimationController, toHome, sendUserLeaveHint);
+        } catch (RemoteException e) {
+            Log.e(TAG, "Failed to finish recents animation", e);
+        }
+    }
+
+    @Deprecated
+    public void setCancelWithDeferredScreenshot(boolean screenshot) {
+        if (VERSION.SDK_INT < Build.VERSION_CODES.Q) return;
+        try {
+            mAnimationController.setCancelWithDeferredScreenshot(screenshot);
+        } catch (RemoteException e) {
+            Log.e(TAG, "Failed to set cancel with deferred screenshot", e);
+        }
+    }
+
+    public void setDeferCancelUntilNextTransition(boolean defer, boolean screenshot) {
+        if (VERSION.SDK_INT < Build.VERSION_CODES.Q) return;
+        try {
+            mAnimationController.setDeferCancelUntilNextTransition(defer, screenshot);
+        } catch (RemoteException e) {
+            Log.e(TAG, "Failed to set deferred cancel with screenshot", e);
+        }
+    }
+
+    public void cleanupScreenshot() {
+        if (VERSION.SDK_INT < Build.VERSION_CODES.Q) return;
+        try {
+            mAnimationController.cleanupScreenshot();
+        } catch (RemoteException e) {
+            Log.e(TAG, "Failed to clean up screenshot of recents animation", e);
+        }
+    }
+}
\ No newline at end of file
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RecentsAnimationListener.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RecentsAnimationListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..5850fda617fc3c4cddedb6d77f29073582f2165e
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RecentsAnimationListener.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+
+package com.android.systemui.shared.system;
+
+import android.graphics.Rect;
+
+public interface RecentsAnimationListener {
+
+    /**
+     * Called when the animation into Recents can start. This call is made on the binder thread.
+     */
+    void onAnimationStart(RecentsAnimationControllerCompat controller,
+            RemoteAnimationTargetCompat[] apps, Rect homeContentInsets, Rect minimizedHomeBounds);
+
+    /**
+     * Called when the animation into Recents was canceled. This call is made on the binder thread.
+     */
+    void onAnimationCanceled(boolean deferredWithScreenshot);
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RemoteAnimationAdapterCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RemoteAnimationAdapterCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..61be076ac48a455e36aaed9190a86c93ea0127e6
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RemoteAnimationAdapterCompat.java
@@ -0,0 +1,71 @@
+/*
+ * 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.os.RemoteException;
+import android.util.Log;
+import android.view.IRemoteAnimationFinishedCallback;
+import android.view.IRemoteAnimationRunner;
+import android.view.RemoteAnimationAdapter;
+import android.view.RemoteAnimationTarget;
+
+/**
+ * @see RemoteAnimationAdapter
+ */
+public class RemoteAnimationAdapterCompat {
+
+    private final RemoteAnimationAdapter mWrapped;
+
+    public RemoteAnimationAdapterCompat(RemoteAnimationRunnerCompat runner, long duration,
+            long statusBarTransitionDelay) {
+        mWrapped = new RemoteAnimationAdapter(wrapRemoteAnimationRunner(runner), duration,
+                statusBarTransitionDelay);
+    }
+
+    RemoteAnimationAdapter getWrapped() {
+        return mWrapped;
+    }
+
+    private static IRemoteAnimationRunner.Stub wrapRemoteAnimationRunner(
+            final RemoteAnimationRunnerCompat remoteAnimationAdapter) {
+        return new IRemoteAnimationRunner.Stub() {
+            @Override
+            public void onAnimationStart(RemoteAnimationTarget[] apps,
+                    final IRemoteAnimationFinishedCallback finishedCallback) {
+                final RemoteAnimationTargetCompat[] appsCompat =
+                        RemoteAnimationTargetCompat.wrap(apps);
+                final Runnable animationFinishedCallback = new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            finishedCallback.onAnimationFinished();
+                        } catch (RemoteException e) {
+                            Log.e("ActivityOptionsCompat", "Failed to call app controlled animation"
+                                    + " finished callback", e);
+                        }
+                    }
+                };
+                remoteAnimationAdapter.onAnimationStart(appsCompat, animationFinishedCallback);
+            }
+
+            @Override
+            public void onAnimationCancelled() {
+                remoteAnimationAdapter.onAnimationCancelled();
+            }
+        };
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RemoteAnimationDefinitionCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RemoteAnimationDefinitionCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..098698aa1c5c6521d2c5eb5ded26b67730f310be
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RemoteAnimationDefinitionCompat.java
@@ -0,0 +1,40 @@
+/*
+ * 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.view.RemoteAnimationDefinition;
+
+/**
+ * @see RemoteAnimationDefinition
+ */
+public class RemoteAnimationDefinitionCompat {
+
+    private final RemoteAnimationDefinition mWrapped = new RemoteAnimationDefinition();
+
+    public void addRemoteAnimation(int transition, RemoteAnimationAdapterCompat adapter) {
+        mWrapped.addRemoteAnimation(transition, adapter.getWrapped());
+    }
+
+    public void addRemoteAnimation(int transition, int activityTypeFilter,
+            RemoteAnimationAdapterCompat adapter) {
+        mWrapped.addRemoteAnimation(transition, activityTypeFilter, adapter.getWrapped());
+    }
+
+    RemoteAnimationDefinition getWrapped() {
+        return mWrapped;
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RemoteAnimationRunnerCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RemoteAnimationRunnerCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a85df9671972774331ec73267fa5138e94d5917
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RemoteAnimationRunnerCompat.java
@@ -0,0 +1,22 @@
+/*
+ * 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;
+
+public interface RemoteAnimationRunnerCompat {
+    void onAnimationStart(RemoteAnimationTargetCompat[] apps, Runnable finishedCallback);
+    void onAnimationCancelled();
+}
\ No newline at end of file
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RemoteAnimationTargetCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RemoteAnimationTargetCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..0420a05d80fd26a5db082a7f4024c400ed623fca
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RemoteAnimationTargetCompat.java
@@ -0,0 +1,92 @@
+/*
+ * 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.WindowConfiguration;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.os.Build;
+import android.view.RemoteAnimationTarget;
+import android.view.SurfaceControl;
+
+/**
+ * @see RemoteAnimationTarget
+ */
+public class RemoteAnimationTargetCompat {
+
+    public static final int MODE_OPENING = RemoteAnimationTarget.MODE_OPENING;
+    public static final int MODE_CLOSING = RemoteAnimationTarget.MODE_CLOSING;
+    public final int mode;
+
+    public static final int ACTIVITY_TYPE_UNDEFINED = WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
+    public static final int ACTIVITY_TYPE_STANDARD = WindowConfiguration.ACTIVITY_TYPE_STANDARD;
+    public static final int ACTIVITY_TYPE_HOME = WindowConfiguration.ACTIVITY_TYPE_HOME;
+    public static final int ACTIVITY_TYPE_RECENTS = WindowConfiguration.ACTIVITY_TYPE_RECENTS;
+    public static final int ACTIVITY_TYPE_ASSISTANT = WindowConfiguration.ACTIVITY_TYPE_ASSISTANT;
+    public final int activityType;
+
+    public final int taskId;
+    public final SurfaceControlCompat leash;
+    public final boolean isTranslucent;
+    public final Rect clipRect;
+    public final int prefixOrderIndex;
+    public final Point position;
+    public final Rect sourceContainerBounds;
+    public final boolean isNotInRecents;
+    public final Rect contentInsets;
+
+    private final SurfaceControl mStartLeash;
+
+    public RemoteAnimationTargetCompat(RemoteAnimationTarget app) {
+        taskId = app.taskId;
+        mode = app.mode;
+        leash = new SurfaceControlCompat(app.leash);
+        isTranslucent = app.isTranslucent;
+        clipRect = app.clipRect;
+        position = app.position;
+        sourceContainerBounds = app.sourceContainerBounds;
+        prefixOrderIndex = app.prefixOrderIndex;
+        isNotInRecents = app.isNotInRecents;
+        contentInsets = app.contentInsets;
+        activityType = app.windowConfiguration.getActivityType();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            mStartLeash = app.startLeash;
+        } else {
+            mStartLeash = null;
+        }
+    }
+
+    public static RemoteAnimationTargetCompat[] wrap(RemoteAnimationTarget[] apps) {
+        final RemoteAnimationTargetCompat[] appsCompat =
+                new RemoteAnimationTargetCompat[apps.length];
+        for (int i = 0; i < apps.length; i++) {
+            appsCompat[i] = new RemoteAnimationTargetCompat(apps[i]);
+        }
+        return appsCompat;
+    }
+
+    /**
+     * @see SurfaceControl#release()
+     */
+    public void release() {
+        leash.mSurfaceControl.release();
+        if (mStartLeash != null) {
+            mStartLeash.release();
+        }
+    }
+}
\ No newline at end of file
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RotationWatcher.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RotationWatcher.java
new file mode 100644
index 0000000000000000000000000000000000000000..166dc596ae3f222323aefcf04713b9888596de4b
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/RotationWatcher.java
@@ -0,0 +1,71 @@
+/*
+ * 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.content.Context;
+import android.os.RemoteException;
+import android.util.Log;
+import android.view.IRotationWatcher;
+import android.view.WindowManagerGlobal;
+
+import com.android.systemui.shared.QuickstepCompat;
+
+public abstract class RotationWatcher {
+
+    private static final String TAG = "RotationWatcher";
+
+    private final Context mContext;
+
+    private final IRotationWatcher mWatcher = new IRotationWatcher.Stub() {
+
+        @Override
+        public void onRotationChanged(int rotation) {
+            RotationWatcher.this.onRotationChanged(rotation);
+
+        }
+    };
+
+    private boolean mIsWatching = false;
+
+    public RotationWatcher(Context context) {
+        mContext = context;
+    }
+
+    protected abstract void onRotationChanged(int rotation);
+
+    public void enable() {
+        if (!mIsWatching) {
+            try {
+                WindowManagerGlobal.getWindowManagerService().watchRotation(mWatcher,
+                        QuickstepCompat.getActivityManager().getDisplayId(mContext));
+                mIsWatching = true;
+            } catch (RemoteException e) {
+                Log.w(TAG, "Failed to set rotation watcher", e);
+            }
+        }
+    }
+
+    public void disable() {
+        if (mIsWatching) {
+            try {
+                WindowManagerGlobal.getWindowManagerService().removeRotationWatcher(mWatcher);
+                mIsWatching = false;
+            }  catch (RemoteException e) {
+                Log.w(TAG, "Failed to remove rotation watcher", e);
+            }
+        }
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/StatsLogCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/StatsLogCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..2238eac03032efb1ea8e1afb33740595f007f88b
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/StatsLogCompat.java
@@ -0,0 +1,55 @@
+/*
+ * 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.os.Build;
+import android.os.Build.VERSION;
+import android.util.StatsLog;
+
+/**
+ * Wrapper class to make StatsLog hidden API accessible.
+ */
+public class StatsLogCompat {
+
+    /**
+     * StatsLog.write(StatsLog.LAUNCHER_EVENT, int action, int src_state, int dst_state,
+     *                byte[] extension, boolean is_swipe_up_enabled);
+     */
+    public static void write(int action, int srcState, int dstState, byte [] extension,
+            boolean swipeUpEnabled) {
+        if (Build.VERSION.SDK_INT != Build.VERSION_CODES.Q) return;
+        StatsLog.write(19, action, srcState, dstState, extension,
+                swipeUpEnabled);
+    }
+
+    /**
+     *  StatsLog.write(StatsLog.STYLE_EVENT, action, colorPackageHash,
+     *           fontPackageHash, shapePackageHash, clockPackageHash,
+     *           launcherGrid, wallpaperCategoryHash, wallpaperIdHash,
+     *           colorPreference, locationPreference);
+     */
+    public static void write(int action, int colorPackageHash,
+            int fontPackageHash, int shapePackageHash, int clockPackageHash,
+            int launcherGrid, int wallpaperCategoryHash, int wallpaperIdHash,
+            int colorPreference, int locationPreference) {
+        if (Build.VERSION.SDK_INT != Build.VERSION_CODES.Q) return;
+        StatsLog.write(179, action, colorPackageHash,
+                fontPackageHash, shapePackageHash, clockPackageHash,
+                launcherGrid, wallpaperCategoryHash, wallpaperIdHash,
+                colorPreference, locationPreference);
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/SurfaceControlCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/SurfaceControlCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd12141c326885d6e3e785dbf358bd548226b915
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/SurfaceControlCompat.java
@@ -0,0 +1,27 @@
+/*
+ * 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.view.SurfaceControl;
+
+public class SurfaceControlCompat {
+    SurfaceControl mSurfaceControl;
+
+    public SurfaceControlCompat(SurfaceControl surfaceControl) {
+        mSurfaceControl = surfaceControl;
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/SyncRtSurfaceTransactionApplierCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/SyncRtSurfaceTransactionApplierCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..4b5764a827e980833816f486a0f6b0c0c41bcc7e
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/SyncRtSurfaceTransactionApplierCompat.java
@@ -0,0 +1,212 @@
+/*
+ * 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.graphics.Matrix;
+import android.graphics.Rect;
+import android.os.Handler;
+import android.os.Handler.Callback;
+import android.os.Message;
+import android.os.Trace;
+import android.view.Surface;
+import android.view.View;
+import android.view.ViewRootImpl;
+
+import com.android.systemui.shared.QuickstepCompat;
+
+import java.util.function.Consumer;
+
+import xyz.paphonb.quickstep.compat.RecentsCompat;
+
+/**
+ * Helper class to apply surface transactions in sync with RenderThread.
+ *
+ * NOTE: This is a modification of {@link android.view.SyncRtSurfaceTransactionApplier}, we can't 
+ *       currently reference that class from the shared lib as it is hidden.
+ */
+public class SyncRtSurfaceTransactionApplierCompat {
+
+    private static final int MSG_UPDATE_SEQUENCE_NUMBER = 0;
+
+    private final Surface mTargetSurface;
+    private final ViewRootImpl mTargetViewRootImpl;
+    private final Handler mApplyHandler;
+
+    private int mSequenceNumber = 0;
+    private int mPendingSequenceNumber = 0;
+    private Runnable mAfterApplyCallback;
+
+    /**
+     * @param targetView The view in the surface that acts as synchronization anchor.
+     */
+    public SyncRtSurfaceTransactionApplierCompat(View targetView) {
+        mTargetViewRootImpl = targetView != null ? targetView.getViewRootImpl() : null;
+        mTargetSurface = mTargetViewRootImpl != null ? mTargetViewRootImpl.mSurface : null;
+
+        mApplyHandler = new Handler(new Callback() {
+            @Override
+            public boolean handleMessage(Message msg) {
+                if (msg.what == MSG_UPDATE_SEQUENCE_NUMBER) {
+                    onApplyMessage(msg.arg1);
+                    return true;
+                }
+                return false;
+            }
+        });
+    }
+
+    private void onApplyMessage(int seqNo) {
+        mSequenceNumber = seqNo;
+        if (mSequenceNumber == mPendingSequenceNumber && mAfterApplyCallback != null) {
+            Runnable r = mAfterApplyCallback;
+            mAfterApplyCallback = null;
+            r.run();
+        }
+    }
+
+    /**
+     * Schedules applying surface parameters on the next frame.
+     *
+     * @param params The surface parameters to apply. DO NOT MODIFY the list after passing into
+     *               this method to avoid synchronization issues.
+     */
+    public void scheduleApply(final SyncRtSurfaceTransactionApplierCompat.SurfaceParams... params) {
+        if (mTargetViewRootImpl == null || mTargetViewRootImpl.getView() == null) {
+            return;
+        }
+
+        mPendingSequenceNumber++;
+        final int toApplySeqNo = mPendingSequenceNumber;
+        QuickstepCompat.getRecentsCompat().registerRtFrameCallback(mTargetViewRootImpl, new RecentsCompat.FrameDrawingCallback() {
+            @Override
+            public void onFrameDraw(long frame) {
+                if (mTargetSurface == null || !mTargetSurface.isValid()) {
+                    Message.obtain(mApplyHandler, MSG_UPDATE_SEQUENCE_NUMBER, toApplySeqNo, 0)
+                            .sendToTarget();
+                    return;
+                }
+                Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Sync transaction frameNumber=" + frame);
+                TransactionCompat t = new TransactionCompat();
+                for (int i = params.length - 1; i >= 0; i--) {
+                    SyncRtSurfaceTransactionApplierCompat.SurfaceParams surfaceParams =
+                            params[i];
+                    SurfaceControlCompat surface = surfaceParams.surface;
+                    t.deferTransactionUntil(surface, mTargetSurface, frame);
+                    applyParams(t, surfaceParams);
+                }
+                t.setEarlyWakeup();
+                t.apply();
+                Trace.traceEnd(Trace.TRACE_TAG_VIEW);
+                Message.obtain(mApplyHandler, MSG_UPDATE_SEQUENCE_NUMBER, toApplySeqNo, 0)
+                        .sendToTarget();
+            }
+        });
+
+        // Make sure a frame gets scheduled.
+        mTargetViewRootImpl.getView().invalidate();
+    }
+
+    /**
+     * Calls the runnable when any pending apply calls have completed
+     */
+    public void addAfterApplyCallback(final Runnable afterApplyCallback) {
+        if (mSequenceNumber == mPendingSequenceNumber) {
+            afterApplyCallback.run();
+        } else {
+            if (mAfterApplyCallback == null) {
+                mAfterApplyCallback = afterApplyCallback;
+            } else {
+                final Runnable oldCallback = mAfterApplyCallback;
+                mAfterApplyCallback = new Runnable() {
+                    @Override
+                    public void run() {
+                        afterApplyCallback.run();
+                        oldCallback.run();
+                    }
+                };
+            }
+        }
+    }
+
+    public static void applyParams(TransactionCompat t,
+            SyncRtSurfaceTransactionApplierCompat.SurfaceParams params) {
+        t.setMatrix(params.surface, params.matrix);
+        t.setWindowCrop(params.surface, params.windowCrop);
+        t.setAlpha(params.surface, params.alpha);
+        t.setLayer(params.surface, params.layer);
+        t.setCornerRadius(params.surface, params.cornerRadius);
+        t.show(params.surface);
+    }
+
+    /**
+     * Creates an instance of SyncRtSurfaceTransactionApplier, deferring until the target view is
+     * attached if necessary.
+     */
+    public static void create(final View targetView,
+            final Consumer<SyncRtSurfaceTransactionApplierCompat> callback) {
+        if (targetView == null) {
+            // No target view, no applier
+            callback.accept(null);
+        } else if (targetView.getViewRootImpl() != null) {
+            // Already attached, we're good to go
+            callback.accept(new SyncRtSurfaceTransactionApplierCompat(targetView));
+        } else {
+            // Haven't been attached before we can get the view root
+            targetView.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() {
+                @Override
+                public void onViewAttachedToWindow(View v) {
+                    targetView.removeOnAttachStateChangeListener(this);
+                    callback.accept(new SyncRtSurfaceTransactionApplierCompat(targetView));
+                }
+
+                @Override
+                public void onViewDetachedFromWindow(View v) {
+                    // Do nothing
+                }
+            });
+        }
+    }
+
+    public static class SurfaceParams {
+
+        /**
+         * Constructs surface parameters to be applied when the current view state gets pushed to
+         * RenderThread.
+         *
+         * @param surface The surface to modify.
+         * @param alpha Alpha to apply.
+         * @param matrix Matrix to apply.
+         * @param windowCrop Crop to apply.
+         */
+        public SurfaceParams(SurfaceControlCompat surface, float alpha, Matrix matrix,
+                Rect windowCrop, int layer, float cornerRadius) {
+            this.surface = surface;
+            this.alpha = alpha;
+            this.matrix = new Matrix(matrix);
+            this.windowCrop = new Rect(windowCrop);
+            this.layer = layer;
+            this.cornerRadius = cornerRadius;
+        }
+
+        public final SurfaceControlCompat surface;
+        public final float alpha;
+        final float cornerRadius;
+        public final Matrix matrix;
+        public final Rect windowCrop;
+        public final int layer;
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/SystemGestureExclusionListenerCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/SystemGestureExclusionListenerCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a316de4c42f1698adbde224b279495e0ab82115
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/SystemGestureExclusionListenerCompat.java
@@ -0,0 +1,112 @@
+/**
+ * Copyright (C) 2019 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.graphics.Region;
+import android.os.RemoteException;
+import android.util.Log;
+import android.view.ISystemGestureExclusionListener;
+import android.view.WindowManagerGlobal;
+import androidx.annotation.Keep;
+
+/**
+ * Utility class to listen for exclusion rect changes.
+ */
+public abstract class SystemGestureExclusionListenerCompat {
+
+    private static final String TAG = "SGEListenerCompat";
+
+    private final int mDisplayId;
+
+    private ISystemGestureExclusionListener mGestureExclusionListener =
+            new ISystemGestureExclusionListener.Stub() {
+                @Override
+                public void onSystemGestureExclusionChanged(int displayId,
+                        Region systemGestureExclusion, Region unrestrictedOrNull) {
+                    if (displayId == mDisplayId) {
+                        Region unrestricted = (unrestrictedOrNull == null)
+                                ? systemGestureExclusion : unrestrictedOrNull;
+                        onExclusionChanged(systemGestureExclusion, unrestricted);
+                    }
+                }
+
+                @Keep
+                public void onSystemGestureExclusionChanged(int displayId,
+                        Region systemGestureExclusion) {
+                    onSystemGestureExclusionChanged(displayId, systemGestureExclusion, null);
+                }
+            };
+    private boolean mRegistered;
+
+    public SystemGestureExclusionListenerCompat(int displayId) {
+        mDisplayId = displayId;
+    }
+
+    /**
+     * Called when the exclusion region has changed.
+     *
+     * TODO: remove, once all subclasses have migrated to
+     *       {@link #onExclusionChanged(Region, Region)}.
+     */
+    public abstract void onExclusionChanged(Region systemGestureExclusion);
+
+    /**
+     * Called when the exclusion region has changed.
+     *
+     * @param systemGestureExclusion the system gesture exclusion to be applied
+     * @param systemGestureExclusionUnrestricted what would be the system gesture exclusion, if
+     *           there were no restrictions being applied. For logging purposes only.
+     *
+     */
+    public void onExclusionChanged(Region systemGestureExclusion,
+            Region systemGestureExclusionUnrestricted) {
+        // TODO: make abstract, once all subclasses have migrated away from
+        //       onExclusionChanged(Region)
+        onExclusionChanged(systemGestureExclusion);
+    }
+
+    /**
+     * Registers the listener for getting exclusion rect changes.
+     */
+    public void register() {
+        if (!mRegistered) {
+            try {
+                WindowManagerGlobal.getWindowManagerService()
+                        .registerSystemGestureExclusionListener(
+                                mGestureExclusionListener, mDisplayId);
+                mRegistered = true;
+            } catch (RemoteException e) {
+                Log.e(TAG, "Failed to register window manager callbacks", e);
+            }
+        }
+    }
+
+    /**
+     * Unregisters the receiver if previously registered
+     */
+    public void unregister() {
+        if (mRegistered) {
+            try {
+                WindowManagerGlobal.getWindowManagerService()
+                        .unregisterSystemGestureExclusionListener(
+                                mGestureExclusionListener, mDisplayId);
+                mRegistered = false;
+            } catch (RemoteException e) {
+                Log.e(TAG, "Failed to unregister window manager callbacks", e);
+            }
+        }
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskDescriptionCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskDescriptionCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..eaf8d9b57398ac6fa3ae00040398d4457001a1b7
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskDescriptionCompat.java
@@ -0,0 +1,40 @@
+/*
+ * 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.ActivityManager;
+
+public class TaskDescriptionCompat {
+
+    private ActivityManager.TaskDescription mTaskDescription;
+
+    public TaskDescriptionCompat(ActivityManager.TaskDescription td) {
+        mTaskDescription = td;
+    }
+
+    public int getPrimaryColor() {
+        return mTaskDescription != null
+                ? mTaskDescription.getPrimaryColor()
+                : 0;
+    }
+
+    public int getBackgroundColor() {
+        return mTaskDescription != null
+                ? mTaskDescription.getBackgroundColor()
+                : 0;
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskInfoCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskInfoCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..023d8e6ec73943da610ea815605fd069eef2705a
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskInfoCompat.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.ActivityManager;
+import android.app.ActivityManager.RunningTaskInfo;
+import android.app.TaskInfo;
+import android.content.ComponentName;
+
+public class TaskInfoCompat {
+
+    public static int getUserId(TaskInfo info) {
+        return info.userId;
+    }
+
+    public static int getActivityType(TaskInfo info) {
+        return info.configuration.windowConfiguration.getActivityType();
+    }
+
+    public static int getActivityType(RunningTaskInfo info) {
+        return info.configuration.windowConfiguration.getActivityType();
+    }
+
+    public static int getWindowingMode(TaskInfo info) {
+        return info.configuration.windowConfiguration.getWindowingMode();
+    }
+
+    public static boolean supportsSplitScreenMultiWindow(TaskInfo info) {
+        return info.supportsSplitScreenMultiWindow;
+    }
+
+    public static ComponentName getTopActivity(TaskInfo info) {
+        return info.topActivity;
+    }
+
+    public static ActivityManager.TaskDescription getTaskDescription(TaskInfo info) {
+        return info.taskDescription;
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskStackChangeListener.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskStackChangeListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..1dc4cbf3f02a7522674f0254916cf1cac3099cd5
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskStackChangeListener.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.shared.system;
+
+import android.app.ActivityManager.RunningTaskInfo;
+import android.content.ComponentName;
+import android.os.IBinder;
+import android.os.UserHandle;
+import android.util.Log;
+
+import com.android.systemui.shared.QuickstepCompat;
+import com.android.systemui.shared.recents.model.ThumbnailData;
+
+/**
+ * An interface to track task stack changes. Classes should implement this instead of
+ * {@link android.app.ITaskStackListener} to reduce IPC calls from system services.
+ */
+public abstract class TaskStackChangeListener {
+
+    // Binder thread callbacks
+    public void onTaskStackChangedBackground() { }
+
+    // Main thread callbacks
+    public void onTaskStackChanged() { }
+    public void onTaskSnapshotChanged(int taskId, ThumbnailData snapshot) { }
+    public void onActivityPinned(String packageName, int userId, int taskId, int stackId) { }
+    public void onActivityUnpinned() { }
+    public void onPinnedActivityRestartAttempt(boolean clearedTask) { }
+    public void onPinnedStackAnimationStarted() { }
+    public void onPinnedStackAnimationEnded() { }
+    public void onActivityForcedResizable(String packageName, int taskId, int reason) { }
+    public void onActivityDismissingDockedStack() { }
+    public void onActivityLaunchOnSecondaryDisplayFailed() { }
+
+    public void onActivityLaunchOnSecondaryDisplayFailed(RunningTaskInfo taskInfo) {
+        onActivityLaunchOnSecondaryDisplayFailed();
+    }
+
+    /**
+     * @see #onActivityLaunchOnSecondaryDisplayRerouted(RunningTaskInfo taskInfo)
+     */
+    public void onActivityLaunchOnSecondaryDisplayRerouted() { }
+
+    /**
+     * Called when an activity was requested to be launched on a secondary display but was rerouted
+     * to default display.
+     *
+     * @param taskInfo info about the Activity's task
+     */
+    public void onActivityLaunchOnSecondaryDisplayRerouted(RunningTaskInfo taskInfo) {
+        onActivityLaunchOnSecondaryDisplayRerouted();
+    }
+
+    /**
+     * Called when contents are drawn for the first time on a display which can only contain one
+     * task.
+     *
+     * @param displayId the id of the display on which contents are drawn.
+     */
+    public void onSingleTaskDisplayDrawn(int displayId) { }
+
+    public void onTaskProfileLocked(int taskId, int userId) { }
+    public void onTaskCreated(int taskId, ComponentName componentName) { }
+    public void onTaskRemoved(int taskId) { }
+    public void onTaskMovedToFront(int taskId) { }
+
+    public void onTaskMovedToFront(RunningTaskInfo taskInfo) {
+        onTaskMovedToFront(QuickstepCompat.getRecentsCompat().getTaskId(taskInfo));
+    }
+
+    public void onActivityRequestedOrientationChanged(int taskId, int requestedOrientation) { }
+    public void onSizeCompatModeActivityChanged(int displayId, IBinder activityToken) { }
+
+    public void onBackPressedOnTaskRoot(RunningTaskInfo taskInfo) { }
+
+    /**
+     * Called when a task is reparented to a stack on a different display.
+     *
+     * @param taskId id of the task which was moved to a different display.
+     * @param newDisplayId id of the new display.
+     */
+    public void onTaskDisplayChanged(int taskId, int newDisplayId) { }
+
+    /**
+     * Checks that the current user matches the process. Since
+     * {@link android.app.ITaskStackListener} is not multi-user aware, handlers of
+     * {@link TaskStackChangeListener} should make this call to verify that we don't act on events
+     * originating from another user's interactions.
+     */
+    protected final boolean checkCurrentUserId(int currentUserId, boolean debug) {
+        int processUserId = UserHandle.myUserId();
+        if (processUserId != currentUserId) {
+            if (debug) {
+                Log.d("TaskStackChangeListener", "UID mismatch. Process is uid=" + processUserId
+                        + " and the current user is uid=" + currentUserId);
+            }
+            return false;
+        }
+        return true;
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskStackChangeListeners.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskStackChangeListeners.java
new file mode 100644
index 0000000000000000000000000000000000000000..619bc95f84488173befad7780e6f53dd02168e07
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskStackChangeListeners.java
@@ -0,0 +1,374 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.shared.system;
+
+import android.app.ActivityManager.RunningTaskInfo;
+import android.app.ActivityManager.TaskSnapshot;
+import android.app.ActivityTaskManager;
+import android.app.IActivityManager;
+import android.app.TaskStackListener;
+import android.content.ComponentName;
+import android.os.Build;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.Message;
+import android.os.RemoteException;
+import android.os.Trace;
+import android.util.Log;
+
+import com.android.systemui.shared.QuickstepCompat;
+import com.android.systemui.shared.recents.model.ThumbnailData;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Tracks all the task stack listeners
+ */
+public abstract class TaskStackChangeListeners extends TaskStackListener {
+
+    private static final String TAG = TaskStackChangeListeners.class.getSimpleName();
+
+    /**
+     * List of {@link TaskStackChangeListener} registered from {@link #addListener}.
+     */
+    private final List<TaskStackChangeListener> mTaskStackListeners = new ArrayList<>();
+    private final List<TaskStackChangeListener> mTmpListeners = new ArrayList<>();
+
+    protected final Handler mHandler;
+    private boolean mRegistered;
+
+    public TaskStackChangeListeners(Looper looper) {
+        mHandler = new H(looper);
+    }
+
+    public void addListener(IActivityManager am, TaskStackChangeListener listener) {
+        mTaskStackListeners.add(listener);
+        if (!mRegistered) {
+            // Register mTaskStackListener to IActivityManager only once if needed.
+            try {
+                QuickstepCompat.getActivityManager().registerTaskStackListener(this);
+                mRegistered = true;
+            } catch (Exception e) {
+                Log.w(TAG, "Failed to call registerTaskStackListener", e);
+            }
+        }
+    }
+
+    public void removeListener(TaskStackChangeListener listener) {
+        mTaskStackListeners.remove(listener);
+        if (mTaskStackListeners.isEmpty() && mRegistered) {
+            // Unregister mTaskStackListener once we have no more listeners
+            try {
+                QuickstepCompat.getActivityManager().unregisterTaskStackListener(this);
+                mRegistered = false;
+            } catch (Exception e) {
+                Log.w(TAG, "Failed to call unregisterTaskStackListener", e);
+            }
+        }
+    }
+
+    @Override
+    public void onTaskStackChanged() throws RemoteException {
+        // Call the task changed callback for the non-ui thread listeners first
+        synchronized (mTaskStackListeners) {
+            mTmpListeners.clear();
+            mTmpListeners.addAll(mTaskStackListeners);
+        }
+        for (int i = mTmpListeners.size() - 1; i >= 0; i--) {
+            mTmpListeners.get(i).onTaskStackChangedBackground();
+        }
+
+        mHandler.removeMessages(H.ON_TASK_STACK_CHANGED);
+        mHandler.sendEmptyMessage(H.ON_TASK_STACK_CHANGED);
+    }
+
+    @Override
+    public void onActivityPinned(String packageName, int userId, int taskId, int stackId)
+            throws RemoteException {
+        mHandler.removeMessages(H.ON_ACTIVITY_PINNED);
+        mHandler.obtainMessage(H.ON_ACTIVITY_PINNED,
+                new PinnedActivityInfo(packageName, userId, taskId, stackId)).sendToTarget();
+    }
+
+    @Override
+    public void onActivityUnpinned() throws RemoteException {
+        mHandler.removeMessages(H.ON_ACTIVITY_UNPINNED);
+        mHandler.sendEmptyMessage(H.ON_ACTIVITY_UNPINNED);
+    }
+
+    @Override
+    public void onPinnedActivityRestartAttempt(boolean clearedTask)
+            throws RemoteException {
+        mHandler.removeMessages(H.ON_PINNED_ACTIVITY_RESTART_ATTEMPT);
+        mHandler.obtainMessage(H.ON_PINNED_ACTIVITY_RESTART_ATTEMPT, clearedTask ? 1 : 0, 0)
+                .sendToTarget();
+    }
+
+    @Override
+    public void onPinnedStackAnimationStarted() throws RemoteException {
+        mHandler.removeMessages(H.ON_PINNED_STACK_ANIMATION_STARTED);
+        mHandler.sendEmptyMessage(H.ON_PINNED_STACK_ANIMATION_STARTED);
+    }
+
+    @Override
+    public void onPinnedStackAnimationEnded() throws RemoteException {
+        mHandler.removeMessages(H.ON_PINNED_STACK_ANIMATION_ENDED);
+        mHandler.sendEmptyMessage(H.ON_PINNED_STACK_ANIMATION_ENDED);
+    }
+
+    @Override
+    public void onActivityForcedResizable(String packageName, int taskId, int reason)
+            throws RemoteException {
+        mHandler.obtainMessage(H.ON_ACTIVITY_FORCED_RESIZABLE, taskId, reason, packageName)
+                .sendToTarget();
+    }
+
+    @Override
+    public void onActivityDismissingDockedStack() throws RemoteException {
+        mHandler.sendEmptyMessage(H.ON_ACTIVITY_DISMISSING_DOCKED_STACK);
+    }
+
+    @Override
+    public void onTaskProfileLocked(int taskId, int userId) throws RemoteException {
+        mHandler.obtainMessage(H.ON_TASK_PROFILE_LOCKED, taskId, userId).sendToTarget();
+    }
+
+    @Override
+    public void onTaskSnapshotChanged(int taskId, TaskSnapshot snapshot) throws RemoteException {
+        mHandler.obtainMessage(H.ON_TASK_SNAPSHOT_CHANGED, taskId, 0, snapshot).sendToTarget();
+    }
+
+    @Override
+    public void onTaskCreated(int taskId, ComponentName componentName) throws RemoteException {
+        mHandler.obtainMessage(H.ON_TASK_CREATED, taskId, 0, componentName).sendToTarget();
+    }
+
+    @Override
+    public void onTaskRemoved(int taskId) throws RemoteException {
+        mHandler.obtainMessage(H.ON_TASK_REMOVED, taskId, 0).sendToTarget();
+    }
+
+    @Override
+    public void onActivityRequestedOrientationChanged(int taskId, int requestedOrientation)
+            throws RemoteException {
+        mHandler.obtainMessage(H.ON_ACTIVITY_REQUESTED_ORIENTATION_CHANGE, taskId,
+                requestedOrientation).sendToTarget();
+    }
+
+    protected final class H extends Handler {
+        private static final int ON_TASK_STACK_CHANGED = 1;
+        private static final int ON_TASK_SNAPSHOT_CHANGED = 2;
+        private static final int ON_ACTIVITY_PINNED = 3;
+        private static final int ON_PINNED_ACTIVITY_RESTART_ATTEMPT = 4;
+        private static final int ON_PINNED_STACK_ANIMATION_ENDED = 5;
+        private static final int ON_ACTIVITY_FORCED_RESIZABLE = 6;
+        private static final int ON_ACTIVITY_DISMISSING_DOCKED_STACK = 7;
+        private static final int ON_TASK_PROFILE_LOCKED = 8;
+        private static final int ON_PINNED_STACK_ANIMATION_STARTED = 9;
+        private static final int ON_ACTIVITY_UNPINNED = 10;
+        protected static final int ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_FAILED = 11;
+        private static final int ON_TASK_CREATED = 12;
+        private static final int ON_TASK_REMOVED = 13;
+        protected static final int ON_TASK_MOVED_TO_FRONT = 14;
+        private static final int ON_ACTIVITY_REQUESTED_ORIENTATION_CHANGE = 15;
+        protected static final int ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_REROUTED = 16;
+        protected static final int ON_SIZE_COMPAT_MODE_ACTIVITY_CHANGED = 17;
+        protected static final int ON_BACK_PRESSED_ON_TASK_ROOT = 18;
+        private static final int ON_SINGLE_TASK_DISPLAY_DRAWN = 19;
+        protected static final int ON_TASK_DISPLAY_CHANGED = 20;
+
+
+        public H(Looper looper) {
+            super(looper);
+        }
+
+        @Override
+        public void handleMessage(Message msg) {
+            synchronized (mTaskStackListeners) {
+                switch (msg.what) {
+                    case ON_TASK_STACK_CHANGED: {
+                        Trace.beginSection("onTaskStackChanged");
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onTaskStackChanged();
+                        }
+                        Trace.endSection();
+                        break;
+                    }
+                    case ON_TASK_SNAPSHOT_CHANGED: {
+                        Trace.beginSection("onTaskSnapshotChanged");
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onTaskSnapshotChanged(msg.arg1,
+                                    new ThumbnailData((TaskSnapshot) msg.obj));
+                        }
+                        Trace.endSection();
+                        break;
+                    }
+                    case ON_ACTIVITY_PINNED: {
+                        final PinnedActivityInfo info = (PinnedActivityInfo) msg.obj;
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onActivityPinned(
+                                    info.mPackageName, info.mUserId, info.mTaskId, info.mStackId);
+                        }
+                        break;
+                    }
+                    case ON_ACTIVITY_UNPINNED: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onActivityUnpinned();
+                        }
+                        break;
+                    }
+                    case ON_PINNED_ACTIVITY_RESTART_ATTEMPT: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onPinnedActivityRestartAttempt(
+                                    msg.arg1 != 0);
+                        }
+                        break;
+                    }
+                    case ON_PINNED_STACK_ANIMATION_STARTED: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onPinnedStackAnimationStarted();
+                        }
+                        break;
+                    }
+                    case ON_PINNED_STACK_ANIMATION_ENDED: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onPinnedStackAnimationEnded();
+                        }
+                        break;
+                    }
+                    case ON_ACTIVITY_FORCED_RESIZABLE: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onActivityForcedResizable(
+                                    (String) msg.obj, msg.arg1, msg.arg2);
+                        }
+                        break;
+                    }
+                    case ON_ACTIVITY_DISMISSING_DOCKED_STACK: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onActivityDismissingDockedStack();
+                        }
+                        break;
+                    }
+                    case ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_FAILED: {
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                            final RunningTaskInfo info = (RunningTaskInfo) msg.obj;
+                            for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                                mTaskStackListeners.get(i)
+                                        .onActivityLaunchOnSecondaryDisplayFailed(info);
+                            }
+                        } else {
+                            for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                                mTaskStackListeners.get(i)
+                                        .onActivityLaunchOnSecondaryDisplayFailed();
+                            }
+                        }
+                        break;
+                    }
+                    case ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_REROUTED: {
+                        final RunningTaskInfo info = (RunningTaskInfo) msg.obj;
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i)
+                                    .onActivityLaunchOnSecondaryDisplayRerouted(info);
+                        }
+                        break;
+                    }
+                    case ON_TASK_PROFILE_LOCKED: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onTaskProfileLocked(msg.arg1, msg.arg2);
+                        }
+                        break;
+                    }
+                    case ON_TASK_CREATED: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onTaskCreated(msg.arg1,
+                                    (ComponentName) msg.obj);
+                        }
+                        break;
+                    }
+                    case ON_TASK_REMOVED: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onTaskRemoved(msg.arg1);
+                        }
+                        break;
+                    }
+                    case ON_TASK_MOVED_TO_FRONT: {
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                            final RunningTaskInfo info = (RunningTaskInfo) msg.obj;
+                            for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                                mTaskStackListeners.get(i).onTaskMovedToFront(info);
+                            }
+                        } else {
+                            for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                                mTaskStackListeners.get(i).onTaskMovedToFront(msg.arg1);
+                            }
+                        }
+                        break;
+                    }
+                    case ON_ACTIVITY_REQUESTED_ORIENTATION_CHANGE: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i)
+                                    .onActivityRequestedOrientationChanged(msg.arg1, msg.arg2);
+                        }
+                        break;
+                    }
+                    case ON_SIZE_COMPAT_MODE_ACTIVITY_CHANGED: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onSizeCompatModeActivityChanged(
+                                    msg.arg1, (IBinder) msg.obj);
+                        }
+                        break;
+                    }
+                    case ON_BACK_PRESSED_ON_TASK_ROOT: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onBackPressedOnTaskRoot(
+                                    (RunningTaskInfo) msg.obj);
+                        }
+                        break;
+                    }
+                    case ON_SINGLE_TASK_DISPLAY_DRAWN: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onSingleTaskDisplayDrawn(msg.arg1);
+                        }
+                        break;
+                    }
+                    case ON_TASK_DISPLAY_CHANGED: {
+                        for (int i = mTaskStackListeners.size() - 1; i >= 0; i--) {
+                            mTaskStackListeners.get(i).onTaskDisplayChanged(msg.arg1, msg.arg2);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    private static class PinnedActivityInfo {
+        final String mPackageName;
+        final int mUserId;
+        final int mTaskId;
+        final int mStackId;
+
+        PinnedActivityInfo(String packageName, int userId, int taskId, int stackId) {
+            mPackageName = packageName;
+            mUserId = userId;
+            mTaskId = taskId;
+            mStackId = stackId;
+        }
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskStackChangeListenersVP.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskStackChangeListenersVP.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b2fe39beb7dfb0730fc91897577aef74682025b
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskStackChangeListenersVP.java
@@ -0,0 +1,22 @@
+package com.android.systemui.shared.system;
+
+import android.app.ActivityManager;
+import android.os.Looper;
+import android.os.RemoteException;
+
+public class TaskStackChangeListenersVP extends TaskStackChangeListeners {
+
+    public TaskStackChangeListenersVP(Looper looper) {
+        super(looper);
+    }
+
+    @Override
+    public void onActivityLaunchOnSecondaryDisplayFailed() throws RemoteException {
+        mHandler.sendEmptyMessage(H.ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_FAILED);
+    }
+
+    @Override
+    public void onTaskMovedToFront(int taskId) throws RemoteException {
+        mHandler.obtainMessage(H.ON_TASK_MOVED_TO_FRONT, taskId, 0).sendToTarget();
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskStackChangeListenersVQ.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskStackChangeListenersVQ.java
new file mode 100644
index 0000000000000000000000000000000000000000..50c538e1b86e52c09523c72696767e76cfea9949
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TaskStackChangeListenersVQ.java
@@ -0,0 +1,50 @@
+package com.android.systemui.shared.system;
+
+import android.app.ActivityManager;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.RemoteException;
+
+public class TaskStackChangeListenersVQ extends TaskStackChangeListeners {
+
+    public TaskStackChangeListenersVQ(Looper looper) {
+        super(looper);
+    }
+
+    @Override
+    public void onActivityLaunchOnSecondaryDisplayFailed(ActivityManager.RunningTaskInfo taskInfo,
+                                                         int requestedDisplayId) throws RemoteException {
+        mHandler.obtainMessage(H.ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_FAILED, requestedDisplayId,
+                0 /* unused */,
+                taskInfo).sendToTarget();
+    }
+
+    @Override
+    public void onActivityLaunchOnSecondaryDisplayRerouted(ActivityManager.RunningTaskInfo taskInfo,
+                                                           int requestedDisplayId) throws RemoteException {
+        mHandler.obtainMessage(H.ON_ACTIVITY_LAUNCH_ON_SECONDARY_DISPLAY_REROUTED,
+                requestedDisplayId, 0 /* unused */, taskInfo).sendToTarget();
+    }
+
+    @Override
+    public void onTaskMovedToFront(ActivityManager.RunningTaskInfo taskInfo)
+            throws RemoteException {
+        mHandler.obtainMessage(H.ON_TASK_MOVED_TO_FRONT, taskInfo).sendToTarget();
+    }
+
+    @Override
+    public void onBackPressedOnTaskRoot(ActivityManager.RunningTaskInfo taskInfo) throws RemoteException {
+        mHandler.obtainMessage(H.ON_BACK_PRESSED_ON_TASK_ROOT, taskInfo).sendToTarget();
+    }
+
+    @Override
+    public void onSizeCompatModeActivityChanged(int displayId, IBinder activityToken) {
+        mHandler.obtainMessage(H.ON_SIZE_COMPAT_MODE_ACTIVITY_CHANGED, displayId, 0 /* unused */,
+                activityToken).sendToTarget();
+    }
+
+    @Override
+    public void onTaskDisplayChanged(int taskId, int newDisplayId) throws RemoteException {
+        mHandler.obtainMessage(H.ON_TASK_DISPLAY_CHANGED, taskId, newDisplayId).sendToTarget();
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ThreadedRendererCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ThreadedRendererCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..bf88a291843d9605675ae7d17ca39c7d4e11dbe0
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/ThreadedRendererCompat.java
@@ -0,0 +1,33 @@
+/*
+ * 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.view.ThreadedRenderer;
+
+/**
+ * @see ThreadedRenderer
+ */
+public class ThreadedRendererCompat {
+
+    public static int EGL_CONTEXT_PRIORITY_HIGH_IMG = 0x3101;
+    public static int EGL_CONTEXT_PRIORITY_MEDIUM_IMG = 0x3102;
+    public static int EGL_CONTEXT_PRIORITY_LOW_IMG = 0x3103;
+
+    public static void setContextPriority(int priority) {
+        ThreadedRenderer.setContextPriority(priority);
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TonalCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TonalCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a0f89b7dc7db27cd57259c48137349a2209c208
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/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/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TransactionCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TransactionCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..756506d1affe5b565be37f52599434413ef9a0d2
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/TransactionCompat.java
@@ -0,0 +1,116 @@
+/*
+ * 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.graphics.Matrix;
+import android.graphics.Rect;
+import android.os.Build;
+import android.os.IBinder;
+import android.view.Surface;
+import android.view.SurfaceControl.Transaction;
+import com.android.systemui.shared.QuickstepCompat;
+
+public class TransactionCompat {
+
+    final Transaction mTransaction;
+
+    final float[] mTmpValues = new float[9];
+
+    public TransactionCompat() {
+        mTransaction = new Transaction();
+    }
+
+    public void apply() {
+        mTransaction.apply();
+    }
+
+    public TransactionCompat show(SurfaceControlCompat surfaceControl) {
+        mTransaction.show(surfaceControl.mSurfaceControl);
+        return this;
+    }
+
+    public TransactionCompat hide(SurfaceControlCompat surfaceControl) {
+        mTransaction.hide(surfaceControl.mSurfaceControl);
+        return this;
+    }
+
+    public TransactionCompat setPosition(SurfaceControlCompat surfaceControl, float x, float y) {
+        mTransaction.setPosition(surfaceControl.mSurfaceControl, x, y);
+        return this;
+    }
+
+    public TransactionCompat setSize(SurfaceControlCompat surfaceControl, int w, int h) {
+        QuickstepCompat.getRecentsCompat().setSurfaceBufferSize(mTransaction, surfaceControl.mSurfaceControl, w, h);
+        return this;
+    }
+
+    public TransactionCompat setLayer(SurfaceControlCompat surfaceControl, int z) {
+        mTransaction.setLayer(surfaceControl.mSurfaceControl, z);
+        return this;
+    }
+
+    public TransactionCompat setAlpha(SurfaceControlCompat surfaceControl, float alpha) {
+        mTransaction.setAlpha(surfaceControl.mSurfaceControl, alpha);
+        return this;
+    }
+
+    public TransactionCompat setMatrix(SurfaceControlCompat surfaceControl, float dsdx, float dtdx,
+            float dtdy, float dsdy) {
+        mTransaction.setMatrix(surfaceControl.mSurfaceControl, dsdx, dtdx, dtdy, dsdy);
+        return this;
+    }
+
+    public TransactionCompat setMatrix(SurfaceControlCompat surfaceControl, Matrix matrix) {
+        mTransaction.setMatrix(surfaceControl.mSurfaceControl, matrix, mTmpValues);
+        return this;
+    }
+
+    public TransactionCompat setWindowCrop(SurfaceControlCompat surfaceControl, Rect crop) {
+        mTransaction.setWindowCrop(surfaceControl.mSurfaceControl, crop);
+        return this;
+    }
+
+    public TransactionCompat setCornerRadius(SurfaceControlCompat surfaceControl, float radius) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            mTransaction.setCornerRadius(surfaceControl.mSurfaceControl, radius);
+        }
+        return this;
+    }
+
+    public TransactionCompat deferTransactionUntil(SurfaceControlCompat surfaceControl,
+            IBinder handle, long frameNumber) {
+        mTransaction.deferTransactionUntil(surfaceControl.mSurfaceControl, handle, frameNumber);
+        return this;
+    }
+
+    public TransactionCompat deferTransactionUntil(SurfaceControlCompat surfaceControl,
+            Surface barrier, long frameNumber) {
+        mTransaction.deferTransactionUntilSurface(surfaceControl.mSurfaceControl, barrier,
+                frameNumber);
+        return this;
+    }
+
+    public TransactionCompat setEarlyWakeup() {
+        mTransaction.setEarlyWakeup();
+        return this;
+    }
+
+    public TransactionCompat setColor(SurfaceControlCompat surfaceControl, float[] color) {
+        mTransaction.setColor(surfaceControl.mSurfaceControl, color);
+        return this;
+    }
+}
\ No newline at end of file
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/WindowCallbacksCompat.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/WindowCallbacksCompat.java
new file mode 100644
index 0000000000000000000000000000000000000000..73387906bba706dce7f5d41caebe072e4950e880
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/WindowCallbacksCompat.java
@@ -0,0 +1,113 @@
+/*
+ * 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.graphics.Canvas;
+import android.graphics.Rect;
+import android.view.View;
+import android.view.ViewRootImpl;
+import android.view.WindowCallbacks;
+
+import com.android.systemui.shared.QuickstepCompat;
+
+import xyz.paphonb.quickstep.compat.RecentsCompat.WindowCallbacksWrapper;
+
+public class WindowCallbacksCompat {
+
+    private final WindowCallbacksWrapper mWindowCallbacksWrapper = new WindowCallbacksWrapper() {
+        @Override
+        public void onWindowSizeIsChanging(Rect newBounds, boolean fullscreen, Rect systemInsets,
+                Rect stableInsets) {
+            WindowCallbacksCompat.this.onWindowSizeIsChanging(newBounds, fullscreen, systemInsets,
+                    stableInsets);
+        }
+
+        @Override
+        public void onWindowDragResizeStart(Rect initialBounds, boolean fullscreen,
+                Rect systemInsets, Rect stableInsets, int resizeMode) {
+            WindowCallbacksCompat.this.onWindowDragResizeStart(initialBounds, fullscreen,
+                    systemInsets, stableInsets, resizeMode);
+        }
+
+        @Override
+        public void onWindowDragResizeEnd() {
+            WindowCallbacksCompat.this.onWindowDragResizeEnd();
+        }
+
+        @Override
+        public boolean onContentDrawn(int offsetX, int offsetY, int sizeX, int sizeY) {
+            return WindowCallbacksCompat.this.onContentDrawn(offsetX, offsetY, sizeX, sizeY);
+        }
+
+        @Override
+        public void onRequestDraw(boolean reportNextDraw) {
+            WindowCallbacksCompat.this.onRequestDraw(reportNextDraw);
+        }
+
+        @Override
+        public void onPostDraw(Canvas canvas) {
+            WindowCallbacksCompat.this.onPostDraw(canvas);
+        }
+    };
+    private final WindowCallbacks mWindowCallbacks = QuickstepCompat.getRecentsCompat().createWindowCallbacks(mWindowCallbacksWrapper);
+
+    private final View mView;
+
+    public WindowCallbacksCompat(View view) {
+        mView = view;
+    }
+
+    public void onWindowSizeIsChanging(Rect newBounds, boolean fullscreen, Rect systemInsets,
+            Rect stableInsets) { }
+
+    public void onWindowDragResizeStart(Rect initialBounds, boolean fullscreen, Rect systemInsets,
+            Rect stableInsets, int resizeMode) { }
+
+    public void onWindowDragResizeEnd() { }
+
+    public boolean onContentDrawn(int offsetX, int offsetY, int sizeX, int sizeY) {
+        return false;
+    }
+
+    public void onRequestDraw(boolean reportNextDraw) {
+        if (reportNextDraw) {
+            reportDrawFinish();
+        }
+    }
+
+    public void onPostDraw(Canvas canvas) { }
+
+    public void reportDrawFinish() {
+        mView.getViewRootImpl().reportDrawFinish();
+    }
+
+    public boolean attach() {
+        ViewRootImpl root = mView.getViewRootImpl();
+        if (root != null) {
+            root.addWindowCallbacks(mWindowCallbacks);
+            root.requestInvalidateRootRenderNode();
+            return true;
+        }
+        return false;
+    }
+
+    public void detach() {
+        ViewRootImpl root = mView.getViewRootImpl();
+        if (root != null) {
+            root.removeWindowCallbacks(mWindowCallbacks);
+        }
+    }
+}
diff --git a/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/WindowManagerWrapper.java b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/WindowManagerWrapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3859b5756fc817686bd93bbd77c8e92d8b6e48c
--- /dev/null
+++ b/SystemUISharedLib/src/main/java/com/android/systemui/shared/system/WindowManagerWrapper.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.shared.system;
+
+import static android.view.Display.DEFAULT_DISPLAY;
+import static android.view.WindowManagerPolicyConstants.NAV_BAR_BOTTOM;
+import static android.view.WindowManagerPolicyConstants.NAV_BAR_INVALID;
+import static android.view.WindowManagerPolicyConstants.NAV_BAR_LEFT;
+import static android.view.WindowManagerPolicyConstants.NAV_BAR_RIGHT;
+
+import android.app.WindowConfiguration;
+import android.graphics.Rect;
+import android.os.Handler;
+import android.os.RemoteException;
+import android.util.Log;
+import android.view.IPinnedStackListener;
+import android.view.WindowManager;
+import android.view.WindowManagerGlobal;
+import com.android.systemui.shared.QuickstepCompat;
+import com.android.systemui.shared.recents.view.AppTransitionAnimationSpecsFuture;
+import com.android.systemui.shared.recents.view.RecentsTransition;
+
+public class WindowManagerWrapper {
+
+    private static final String TAG = "WindowManagerWrapper";
+
+    public static final int TRANSIT_UNSET = WindowManager.TRANSIT_UNSET;
+    public static final int TRANSIT_NONE = WindowManager.TRANSIT_NONE;
+    public static final int TRANSIT_ACTIVITY_OPEN = WindowManager.TRANSIT_ACTIVITY_OPEN;
+    public static final int TRANSIT_ACTIVITY_CLOSE = WindowManager.TRANSIT_ACTIVITY_CLOSE;
+    public static final int TRANSIT_TASK_OPEN = WindowManager.TRANSIT_TASK_OPEN;
+    public static final int TRANSIT_TASK_CLOSE = WindowManager.TRANSIT_TASK_CLOSE;
+    public static final int TRANSIT_TASK_TO_FRONT = WindowManager.TRANSIT_TASK_TO_FRONT;
+    public static final int TRANSIT_TASK_TO_BACK = WindowManager.TRANSIT_TASK_TO_BACK;
+    public static final int TRANSIT_WALLPAPER_CLOSE = WindowManager.TRANSIT_WALLPAPER_CLOSE;
+    public static final int TRANSIT_WALLPAPER_OPEN = WindowManager.TRANSIT_WALLPAPER_OPEN;
+    public static final int TRANSIT_WALLPAPER_INTRA_OPEN =
+            WindowManager.TRANSIT_WALLPAPER_INTRA_OPEN;
+    public static final int TRANSIT_WALLPAPER_INTRA_CLOSE =
+            WindowManager.TRANSIT_WALLPAPER_INTRA_CLOSE;
+    public static final int TRANSIT_TASK_OPEN_BEHIND = WindowManager.TRANSIT_TASK_OPEN_BEHIND;
+    public static final int TRANSIT_TASK_IN_PLACE = WindowManager.TRANSIT_TASK_IN_PLACE;
+    public static final int TRANSIT_ACTIVITY_RELAUNCH = WindowManager.TRANSIT_ACTIVITY_RELAUNCH;
+    public static final int TRANSIT_DOCK_TASK_FROM_RECENTS =
+            WindowManager.TRANSIT_DOCK_TASK_FROM_RECENTS;
+    public static final int TRANSIT_KEYGUARD_GOING_AWAY = WindowManager.TRANSIT_KEYGUARD_GOING_AWAY;
+    public static final int TRANSIT_KEYGUARD_GOING_AWAY_ON_WALLPAPER =
+            WindowManager.TRANSIT_KEYGUARD_GOING_AWAY_ON_WALLPAPER;
+    public static final int TRANSIT_KEYGUARD_OCCLUDE = WindowManager.TRANSIT_KEYGUARD_OCCLUDE;
+    public static final int TRANSIT_KEYGUARD_UNOCCLUDE = WindowManager.TRANSIT_KEYGUARD_UNOCCLUDE;
+
+    public static final int NAV_BAR_POS_INVALID = NAV_BAR_INVALID;
+    public static final int NAV_BAR_POS_LEFT = NAV_BAR_LEFT;
+    public static final int NAV_BAR_POS_RIGHT = NAV_BAR_RIGHT;
+    public static final int NAV_BAR_POS_BOTTOM = NAV_BAR_BOTTOM;
+
+    public static final int ACTIVITY_TYPE_STANDARD = WindowConfiguration.ACTIVITY_TYPE_STANDARD;
+
+    public static final int WINDOWING_MODE_UNDEFINED = WindowConfiguration.WINDOWING_MODE_UNDEFINED;
+    public static final int WINDOWING_MODE_FULLSCREEN =
+            WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
+    public static final int WINDOWING_MODE_PINNED = WindowConfiguration.WINDOWING_MODE_PINNED;
+    public static final int WINDOWING_MODE_SPLIT_SCREEN_PRIMARY =
+            WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+    public static final int WINDOWING_MODE_SPLIT_SCREEN_SECONDARY =
+            WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
+    public static final int WINDOWING_MODE_FREEFORM = WindowConfiguration.WINDOWING_MODE_FREEFORM;
+
+    private static final WindowManagerWrapper sInstance = new WindowManagerWrapper();
+
+    /**
+     * Forwarder to which we can add multiple pinned stack listeners. Each listener will receive
+     * updates from the window manager service.
+     */
+    private PinnedStackListenerForwarder mPinnedStackListenerForwarder =
+            new PinnedStackListenerForwarder();
+
+    public static WindowManagerWrapper getInstance() {
+        return sInstance;
+    }
+
+    /**
+     * @return the stable insets for the primary display.
+     */
+    public void getStableInsets(Rect outStableInsets) {
+        try {
+            WindowManagerGlobal.getWindowManagerService().getStableInsets(DEFAULT_DISPLAY,
+                    outStableInsets);
+        } catch (RemoteException e) {
+            Log.e(TAG, "Failed to get stable insets", e);
+        }
+    }
+
+    /**
+     * Overrides a pending app transition.
+     */
+    public void overridePendingAppTransitionMultiThumbFuture(
+            AppTransitionAnimationSpecsFuture animationSpecFuture, Runnable animStartedCallback,
+            Handler animStartedCallbackHandler, boolean scaleUp, int displayId) {
+        try {
+            QuickstepCompat.getRecentsCompat()
+                    .overridePendingAppTransitionMultiThumbFuture(animationSpecFuture.getFuture(),
+                            RecentsTransition.wrapStartedListener(animStartedCallbackHandler,
+                                    animStartedCallback), scaleUp, displayId);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to override pending app transition (multi-thumbnail future): ", e);
+        }
+    }
+
+    public void overridePendingAppTransitionRemote(
+            RemoteAnimationAdapterCompat remoteAnimationAdapter, int displayId) {
+        try {
+            QuickstepCompat.getRecentsCompat().overridePendingAppTransitionRemote(
+                    remoteAnimationAdapter.getWrapped(), displayId);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to override pending app transition (remote): ", e);
+        }
+    }
+
+    /**
+     * Enable or disable haptic feedback on the navigation bar buttons.
+     */
+    public void setNavBarVirtualKeyHapticFeedbackEnabled(boolean enabled) {
+        try {
+            WindowManagerGlobal.getWindowManagerService()
+                    .setNavBarVirtualKeyHapticFeedbackEnabled(enabled);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to enable or disable navigation bar button haptics: ", e);
+        }
+    }
+
+    public void setShelfHeight(boolean visible, int shelfHeight) {
+        try {
+            WindowManagerGlobal.getWindowManagerService().setShelfHeight(visible, shelfHeight);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to set shelf height");
+        }
+    }
+
+    public void setRecentsVisibility(boolean visible) {
+        try {
+            WindowManagerGlobal.getWindowManagerService().setRecentsVisibility(visible);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to set recents visibility");
+        }
+    }
+
+    public void setPipVisibility(final boolean visible) {
+        try {
+            WindowManagerGlobal.getWindowManagerService().setPipVisibility(visible);
+        } catch (RemoteException e) {
+            Log.e(TAG, "Unable to reach window manager", e);
+        }
+    }
+
+    /**
+     * @param displayId the id of display to check if there is a software navigation bar.
+     *
+     * @return whether there is a soft nav bar on specific display.
+     */
+    public boolean hasSoftNavigationBar(int displayId) {
+        try {
+            return QuickstepCompat.getRecentsCompat().hasNavigationBar(displayId);
+        } catch (RemoteException e) {
+            return false;
+        }
+    }
+
+    /**
+     * @return The side of the screen where navigation bar is positioned.
+     * @see #NAV_BAR_POS_RIGHT
+     * @see #NAV_BAR_POS_LEFT
+     * @see #NAV_BAR_POS_BOTTOM
+     * @see #NAV_BAR_POS_INVALID
+     */
+    public int getNavBarPosition(int displayId) {
+        try {
+            return QuickstepCompat.getRecentsCompat().getNavBarPosition(displayId);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to get nav bar position");
+        }
+        return NAV_BAR_POS_INVALID;
+    }
+
+    /**
+     * Registers a docked stack listener with the system.
+     */
+    public void registerDockedStackListener(DockedStackListenerCompat listener) {
+        try {
+            WindowManagerGlobal.getWindowManagerService().registerDockedStackListener(
+                    listener.mListener);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Failed to register docked stack listener");
+        }
+    }
+
+    /**
+     * Adds a pinned stack listener, which will receive updates from the window manager service
+     * along with any other pinned stack listeners that were added via this method.
+     */
+    public void addPinnedStackListener(IPinnedStackListener listener) throws RemoteException {
+        mPinnedStackListenerForwarder.addListener(listener);
+        WindowManagerGlobal.getWindowManagerService().registerPinnedStackListener(
+                DEFAULT_DISPLAY, mPinnedStackListenerForwarder);
+    }
+
+    /**
+     * Removes a pinned stack listener.
+     */
+    public void removePinnedStackListener(IPinnedStackListener listener) {
+        mPinnedStackListenerForwarder.removeListener(listener);
+    }
+}
diff --git a/SystemUISharedLib/src/main/res/values/strings.xml b/SystemUISharedLib/src/main/res/values/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2ba12375a34dfcbf67c137cee675fddb9ac29bca
--- /dev/null
+++ b/SystemUISharedLib/src/main/res/values/strings.xml
@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">SystemUISharedLib</string>
+</resources>
diff --git a/app/build.gradle b/app/build.gradle
index fb5da052f89f9f4c4c5475d168e78096f7450936..a89582cd4d32916bc2f6136709811daa5438653d 100755
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -5,6 +5,7 @@ apply plugin: 'com.android.application'
 apply plugin: 'kotlin-android'
 apply plugin: 'kotlin-kapt'
 apply plugin: 'kotlin-android-extensions'
+apply from: '../spotless/spotless.gradle'
 
 // Manifest version information!
 def versionMajor = 1
@@ -30,7 +31,6 @@ android {
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
         debug {
-            applicationIdSuffix '.debug'
             signingConfig signingConfigs.debug
         }
 
@@ -46,9 +46,9 @@ android {
 
     signingConfigs {
         debug {
-            storeFile file(getRootDir().path + "/keystore/debug.keystore")
+            storeFile file(getRootDir().path + "/keystore/platform.keystore")
             storePassword 'android'
-            keyAlias 'androiddebugkey'
+            keyAlias 'platform'
             keyPassword 'android'
         }
     }
@@ -90,24 +90,37 @@ android {
     }
 
     sourceSets {
+        main {
+            java.srcDirs += ['src/quickstep/src', 'src/quickstep/recents_ui_overrides/src']
+            res.srcDirs += ['src/quickstep/res', 'src/quickstep/recents_ui_overrides/res']
+        }
         apiQ {
-            java.srcDirs = ['src/apiOreo/java/foundation/e']
+            java.srcDirs = ['src/apiOreo/java/']
             res.srcDirs = ['src/apiOreo/res']
+            manifest.srcFile "src/apiOreo/AndroidManifest.xml"
         }
     }
+    addFrameworkJar('framework.jar')
 }
 
 dependencies {
     implementation 'me.relex:circleindicator:2.1.4'
-
+    implementation "androidx.preference:preference-ktx:1.1.1"
+    implementation 'androidx.appcompat:appcompat:1.2.0'
+    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
+    implementation "androidx.dynamicanimation:dynamicanimation:1.0.0"
+    compileOnly files('libs/framework.jar')
+    implementation project(':SystemUISharedLib')
     apiNougatImplementation 'org.cyanogenmod:platform.sdk:6.0'
     apiOreoImplementation files('libs/lineage-sdk-oreo.jar')
     apiQImplementation files('libs/lineage-sdk-q.jar')
-
     debugImplementation 'com.amitshekhar.android:debug-db:1.0.4'
 
     implementation 'org.greenrobot:eventbus:3.1.1'
 
+    // Recents dependency
+
+
     // Support Libs
     implementation Libs.AndroidX.appcompat
     implementation Libs.AndroidX.recyclerview
@@ -151,5 +164,3 @@ dependencies {
     androidTestImplementation Libs.AndroidX.Test.rules
     implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.0.0'
 }
-
-apply plugin: 'com.getkeepsafe.dexcount'
diff --git a/app/libs/framework.jar b/app/libs/framework.jar
new file mode 100644
index 0000000000000000000000000000000000000000..592572c90dfa1660afe7996790c6d4deefcd1fb4
Binary files /dev/null and b/app/libs/framework.jar differ
diff --git a/app/libs/plugin_core.jar b/app/libs/plugin_core.jar
new file mode 100644
index 0000000000000000000000000000000000000000..dd27f86fa3f803e79353f2e549caa72d9bdbad6b
Binary files /dev/null and b/app/libs/plugin_core.jar differ
diff --git a/app/libs/sysui_shared.jar b/app/libs/sysui_shared.jar
new file mode 100644
index 0000000000000000000000000000000000000000..53a6ceb4d06e87b31c69070e18eb74622257cc26
Binary files /dev/null and b/app/libs/sysui_shared.jar differ
diff --git a/app/src/androidTest/java/foundation/e/blisslauncher/ExampleInstrumentedTest.java b/app/src/androidTest/java/foundation/e/blisslauncher/ExampleInstrumentedTest.java
index f0223b542855e3e0a8796aa661923aa7d72ac19b..fd263cef330d90e2afe34ea46ffce3dca7e23cf7 100755
--- a/app/src/androidTest/java/foundation/e/blisslauncher/ExampleInstrumentedTest.java
+++ b/app/src/androidTest/java/foundation/e/blisslauncher/ExampleInstrumentedTest.java
@@ -17,12 +17,11 @@ package foundation.e.blisslauncher;
 
 import static org.junit.Assert.*;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
 import android.content.Context;
 import android.support.test.InstrumentationRegistry;
 import android.support.test.runner.AndroidJUnit4;
+import org.junit.Test;
+import org.junit.runner.RunWith;
 
 /**
  * Instrumentation test, which will execute on an Android device.
diff --git a/app/src/apiNougat/java/foundation/e/blisslauncher/core/Preferences.java b/app/src/apiNougat/java/foundation/e/blisslauncher/core/Preferences.java
index 11d140491ffc2da9d648c7a61384390b1ddda18d..70b9f50916fc9090741da74ae97ee70fd4365c02 100644
--- a/app/src/apiNougat/java/foundation/e/blisslauncher/core/Preferences.java
+++ b/app/src/apiNougat/java/foundation/e/blisslauncher/core/Preferences.java
@@ -1,19 +1,17 @@
 package foundation.e.blisslauncher.core;
 
+
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.graphics.Color;
-
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import java.util.ArrayList;
-import java.util.Locale;
-
 import cyanogenmod.weather.WeatherInfo;
 import cyanogenmod.weather.WeatherLocation;
 import foundation.e.blisslauncher.core.utils.Constants;
+import java.util.ArrayList;
+import java.util.Locale;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
 
 public class Preferences {
 
diff --git a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/CustomLocationPreference.java b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/CustomLocationPreference.java
index a84a6455655587849a82b4827783c0feb16cabcb..59ada5db444ca21212a9815cb03caf6dc5e70ad4 100644
--- a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/CustomLocationPreference.java
+++ b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/CustomLocationPreference.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.app.AlertDialog;
 import android.app.ProgressDialog;
 import android.content.Context;
@@ -12,14 +13,12 @@ import android.util.AttributeSet;
 import android.view.View;
 import android.widget.Button;
 import android.widget.Toast;
-
-import java.util.HashSet;
-import java.util.List;
-
 import cyanogenmod.weather.CMWeatherManager;
 import cyanogenmod.weather.WeatherLocation;
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.Preferences;
+import java.util.HashSet;
+import java.util.List;
 
 public class CustomLocationPreference extends EditTextPreference
         implements CMWeatherManager.LookupCityRequestListener {
diff --git a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/DeviceStatusService.java b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/DeviceStatusService.java
index 43635b91989ef95793f646a5511038f385ebfddc..77d2c331ca1322c02b9a19541e5de48e2c24b493 100644
--- a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/DeviceStatusService.java
+++ b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/DeviceStatusService.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.app.Service;
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -8,7 +9,6 @@ import android.content.IntentFilter;
 import android.net.ConnectivityManager;
 import android.os.IBinder;
 import android.util.Log;
-
 import foundation.e.blisslauncher.core.utils.Constants;
 
 public class DeviceStatusService extends Service {
diff --git a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/ForecastBuilder.java b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/ForecastBuilder.java
index e38de4c14117a3024765300141af6e88af0de292..8ed26ce8ebecee53247186eb43513e20cbafcbcd 100644
--- a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/ForecastBuilder.java
+++ b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/ForecastBuilder.java
@@ -14,18 +14,16 @@ import android.view.View;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
 import android.widget.TextView;
-
+import cyanogenmod.weather.WeatherInfo;
+import cyanogenmod.weather.util.WeatherUtils;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Preferences;
 import java.util.Calendar;
 import java.util.GregorianCalendar;
 import java.util.List;
 import java.util.Locale;
 import java.util.TimeZone;
 
-import cyanogenmod.weather.WeatherInfo;
-import cyanogenmod.weather.util.WeatherUtils;
-import foundation.e.blisslauncher.R;
-import foundation.e.blisslauncher.core.Preferences;
-
 public class ForecastBuilder {
 
     private static final String TAG = "ForecastBuilder";
diff --git a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/IconSelectionPreference.java b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/IconSelectionPreference.java
index 57b4e882da15b8cacc64c9557aa4bab3d5362f13..03f2f8abdf45c984154dc6c9ecaa7bf23b05cae0 100644
--- a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/IconSelectionPreference.java
+++ b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/IconSelectionPreference.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.annotation.SuppressLint;
 import android.app.AlertDialog;
 import android.content.BroadcastReceiver;
@@ -25,15 +26,12 @@ import android.widget.ArrayAdapter;
 import android.widget.GridView;
 import android.widget.ImageView;
 import android.widget.TextView;
-
 import androidx.annotation.NonNull;
-
+import foundation.e.blisslauncher.R;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Locale;
 
-import foundation.e.blisslauncher.R;
-
 public class IconSelectionPreference extends DialogPreference implements
         AdapterView.OnItemClickListener {
     private static final String INTENT_CATEGORY_ICONPACK = "com.dvtonder.chronus.ICON_PACK";
diff --git a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/PermissionRequestActivity.java b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/PermissionRequestActivity.java
index 9b4637a9a7e222dd4de16d7b3c9ec75e8da4fced..e95368ed16ed03c00110f13e6dff24b4a9f71f64 100644
--- a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/PermissionRequestActivity.java
+++ b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/PermissionRequestActivity.java
@@ -1,12 +1,12 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.Manifest;
 import android.app.Activity;
 import android.content.pm.PackageManager;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.ResultReceiver;
-
 import androidx.annotation.NonNull;
 
 public class PermissionRequestActivity extends Activity {
diff --git a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherIconUtils.java b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherIconUtils.java
index 7804e09ee81d9eec6aea37e02abdb7e18ed11ee5..006f80efead55c425d6b32b1b9dae156f3fbe8e7 100644
--- a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherIconUtils.java
+++ b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherIconUtils.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.content.res.Resources;
@@ -13,7 +14,6 @@ import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.util.DisplayMetrics;
 import android.util.Log;
-
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.utils.Constants;
 
diff --git a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherPreferences.java b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherPreferences.java
index 460e32a5838e70b32775a10996dfca3d5d9b9c87..24ae038de44e7355e71825920ac7ed6ac5887b50 100644
--- a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherPreferences.java
+++ b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherPreferences.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.Manifest;
 import android.app.AlertDialog;
 import android.app.Dialog;
@@ -19,9 +20,7 @@ import android.provider.Settings;
 import android.text.TextUtils;
 import android.util.Log;
 import android.widget.Toast;
-
 import androidx.annotation.NonNull;
-
 import cyanogenmod.weather.CMWeatherManager;
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.Preferences;
diff --git a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherSourceListenerService.java b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherSourceListenerService.java
index 11a142df0f6cdcba2fd4e71caaed41b298694056..c88db0aa0caa92dfaa3fa6a2ee2f680f513f9e63 100644
--- a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherSourceListenerService.java
+++ b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherSourceListenerService.java
@@ -1,11 +1,11 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.app.Service;
 import android.content.Context;
 import android.content.Intent;
 import android.os.IBinder;
 import android.util.Log;
-
 import cyanogenmod.weather.CMWeatherManager;
 import foundation.e.blisslauncher.core.Preferences;
 import foundation.e.blisslauncher.core.utils.Constants;
diff --git a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherUpdateService.java b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherUpdateService.java
index 92445be07d5ecb1f9e667fbbf64bdcb73e349352..23ce05b34d80f40ea8470d8c4c4385802634221b 100644
--- a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherUpdateService.java
+++ b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherUpdateService.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.annotation.SuppressLint;
 import android.app.AlarmManager;
 import android.app.PendingIntent;
@@ -25,12 +26,7 @@ import android.os.SystemClock;
 import android.text.TextUtils;
 import android.util.Log;
 import android.widget.Toast;
-
 import androidx.localbroadcastmanager.content.LocalBroadcastManager;
-
-import java.lang.ref.WeakReference;
-import java.util.Date;
-
 import cyanogenmod.weather.CMWeatherManager;
 import cyanogenmod.weather.WeatherInfo;
 import cyanogenmod.weather.WeatherLocation;
@@ -38,6 +34,8 @@ import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.Preferences;
 import foundation.e.blisslauncher.core.utils.Constants;
 import foundation.e.blisslauncher.core.utils.PackageManagerUtils;
+import java.lang.ref.WeakReference;
+import java.util.Date;
 
 public class WeatherUpdateService extends Service {
     private static final String TAG = "WeatherUpdateService";
diff --git a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherUtils.java b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherUtils.java
index e61eaafef0f82e4f5ac31ac379f5e7b5e45aad9a..3679590bbc6c750873d4996e4a84a51a5250a50c 100644
--- a/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherUtils.java
+++ b/app/src/apiNougat/java/foundation/e/blisslauncher/features/weather/WeatherUtils.java
@@ -1,13 +1,12 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.content.Context;
 import android.content.res.Resources;
-
-import java.text.DecimalFormat;
-
 import cyanogenmod.app.CMContextConstants;
 import cyanogenmod.providers.WeatherContract;
 import foundation.e.blisslauncher.R;
+import java.text.DecimalFormat;
 
 public final class WeatherUtils {
 
diff --git a/app/src/apiOreo/java/foundation/e/blisslauncher/core/Preferences.java b/app/src/apiOreo/java/foundation/e/blisslauncher/core/Preferences.java
index b437ef44201aef62338c7c612f15e55cd8bea98a..03dc2372c69d0e0f5c506b868184d7634ecd86ad 100644
--- a/app/src/apiOreo/java/foundation/e/blisslauncher/core/Preferences.java
+++ b/app/src/apiOreo/java/foundation/e/blisslauncher/core/Preferences.java
@@ -1,19 +1,17 @@
 package foundation.e.blisslauncher.core;
 
+
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.graphics.Color;
-
-import org.json.JSONArray;
-import org.json.JSONException;
-import org.json.JSONObject;
-
+import foundation.e.blisslauncher.core.utils.Constants;
 import java.util.ArrayList;
 import java.util.Locale;
-
-import foundation.e.blisslauncher.core.utils.Constants;
 import lineageos.weather.WeatherInfo;
 import lineageos.weather.WeatherLocation;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
 
 public class Preferences {
 
diff --git a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/CustomLocationPreference.java b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/CustomLocationPreference.java
index 34513b07cf4dc052ec3f1df06b4bb60d28f23bd4..86a5dcc4f0f83f019cc9647246d19b54a0895d03 100644
--- a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/CustomLocationPreference.java
+++ b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/CustomLocationPreference.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.app.AlertDialog;
 import android.app.ProgressDialog;
 import android.content.Context;
@@ -13,12 +14,10 @@ import android.util.Log;
 import android.view.View;
 import android.widget.Button;
 import android.widget.Toast;
-
-import java.util.HashSet;
-import java.util.List;
-
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.Preferences;
+import java.util.HashSet;
+import java.util.List;
 import lineageos.weather.LineageWeatherManager;
 import lineageos.weather.WeatherLocation;
 
diff --git a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/DeviceStatusService.java b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/DeviceStatusService.java
index 43635b91989ef95793f646a5511038f385ebfddc..77d2c331ca1322c02b9a19541e5de48e2c24b493 100644
--- a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/DeviceStatusService.java
+++ b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/DeviceStatusService.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.app.Service;
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -8,7 +9,6 @@ import android.content.IntentFilter;
 import android.net.ConnectivityManager;
 import android.os.IBinder;
 import android.util.Log;
-
 import foundation.e.blisslauncher.core.utils.Constants;
 
 public class DeviceStatusService extends Service {
diff --git a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/ForecastBuilder.java b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/ForecastBuilder.java
index 01adeb765a03281245cfb340aa86e7e09bde7267..2ad8c2259138bbf4a3f4b1fd08d85755a6ae5c6c 100644
--- a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/ForecastBuilder.java
+++ b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/ForecastBuilder.java
@@ -14,15 +14,13 @@ import android.view.View;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
 import android.widget.TextView;
-
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Preferences;
 import java.util.Calendar;
 import java.util.GregorianCalendar;
 import java.util.List;
 import java.util.Locale;
 import java.util.TimeZone;
-
-import foundation.e.blisslauncher.R;
-import foundation.e.blisslauncher.core.Preferences;
 import lineageos.weather.WeatherInfo;
 import lineageos.weather.util.WeatherUtils;
 
diff --git a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/IconSelectionPreference.java b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/IconSelectionPreference.java
index 57b4e882da15b8cacc64c9557aa4bab3d5362f13..03f2f8abdf45c984154dc6c9ecaa7bf23b05cae0 100644
--- a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/IconSelectionPreference.java
+++ b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/IconSelectionPreference.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.annotation.SuppressLint;
 import android.app.AlertDialog;
 import android.content.BroadcastReceiver;
@@ -25,15 +26,12 @@ import android.widget.ArrayAdapter;
 import android.widget.GridView;
 import android.widget.ImageView;
 import android.widget.TextView;
-
 import androidx.annotation.NonNull;
-
+import foundation.e.blisslauncher.R;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Locale;
 
-import foundation.e.blisslauncher.R;
-
 public class IconSelectionPreference extends DialogPreference implements
         AdapterView.OnItemClickListener {
     private static final String INTENT_CATEGORY_ICONPACK = "com.dvtonder.chronus.ICON_PACK";
diff --git a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/PermissionRequestActivity.java b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/PermissionRequestActivity.java
index 9b4637a9a7e222dd4de16d7b3c9ec75e8da4fced..e95368ed16ed03c00110f13e6dff24b4a9f71f64 100644
--- a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/PermissionRequestActivity.java
+++ b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/PermissionRequestActivity.java
@@ -1,12 +1,12 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.Manifest;
 import android.app.Activity;
 import android.content.pm.PackageManager;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.ResultReceiver;
-
 import androidx.annotation.NonNull;
 
 public class PermissionRequestActivity extends Activity {
diff --git a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherIconUtils.java b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherIconUtils.java
index 7804e09ee81d9eec6aea37e02abdb7e18ed11ee5..006f80efead55c425d6b32b1b9dae156f3fbe8e7 100644
--- a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherIconUtils.java
+++ b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherIconUtils.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.content.res.Resources;
@@ -13,7 +14,6 @@ import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.util.DisplayMetrics;
 import android.util.Log;
-
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.utils.Constants;
 
diff --git a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherPreferences.java b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherPreferences.java
index 4b11985e79acf330a98b260b375c441fb4cd23f2..c9ec5262ea4b7f38f0c97361d662668b459ca689 100644
--- a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherPreferences.java
+++ b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherPreferences.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.Manifest;
 import android.app.AlertDialog;
 import android.app.Dialog;
@@ -19,9 +20,7 @@ import android.provider.Settings;
 import android.text.TextUtils;
 import android.util.Log;
 import android.widget.Toast;
-
 import androidx.annotation.NonNull;
-
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.Preferences;
 import foundation.e.blisslauncher.core.utils.Constants;
diff --git a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherSourceListenerService.java b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherSourceListenerService.java
index 6cb26d48701e29fa6d1131e0b1cead95aa8110c4..fd22470c21bfea39ebb23c6a6afcf5eedf7aaf1b 100644
--- a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherSourceListenerService.java
+++ b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherSourceListenerService.java
@@ -1,11 +1,11 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.app.Service;
 import android.content.Context;
 import android.content.Intent;
 import android.os.IBinder;
 import android.util.Log;
-
 import foundation.e.blisslauncher.core.Preferences;
 import foundation.e.blisslauncher.core.utils.Constants;
 import lineageos.weather.LineageWeatherManager;
diff --git a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherUpdateService.java b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherUpdateService.java
index 02af6ea1a7ac6759cffbaa1d20f5e052d0007941..87bf3894ab6efe1f4c7cf34c9d085772a440c527 100644
--- a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherUpdateService.java
+++ b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherUpdateService.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.annotation.SuppressLint;
 import android.app.AlarmManager;
 import android.app.PendingIntent;
@@ -25,16 +26,13 @@ import android.os.SystemClock;
 import android.text.TextUtils;
 import android.util.Log;
 import android.widget.Toast;
-
 import androidx.localbroadcastmanager.content.LocalBroadcastManager;
-
-import java.lang.ref.WeakReference;
-import java.util.Date;
-
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.Preferences;
 import foundation.e.blisslauncher.core.utils.Constants;
 import foundation.e.blisslauncher.core.utils.PackageManagerUtils;
+import java.lang.ref.WeakReference;
+import java.util.Date;
 import lineageos.weather.LineageWeatherManager;
 import lineageos.weather.WeatherInfo;
 import lineageos.weather.WeatherLocation;
diff --git a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherUtils.java b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherUtils.java
index a56717f8556344ee4057cc9b40f472f027b9785c..f460f47d9cb983eff975d642458d1f53f58bacb0 100644
--- a/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherUtils.java
+++ b/app/src/apiOreo/java/foundation/e/blisslauncher/features/weather/WeatherUtils.java
@@ -1,11 +1,10 @@
 package foundation.e.blisslauncher.features.weather;
 
+
 import android.content.Context;
 import android.content.res.Resources;
-
-import java.text.DecimalFormat;
-
 import foundation.e.blisslauncher.R;
+import java.text.DecimalFormat;
 import lineageos.app.LineageContextConstants;
 import lineageos.providers.WeatherContract;
 import lineageos.providers.WeatherContract.WeatherColumns.WeatherCode;
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index fc2935bc72800ae5395b98879a16ba39d90a33ba..3449b4d57d646aea58e638285901e528cafc837e 100755
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -9,15 +9,12 @@
         android:label="@string/permlab_install_shortcut"
         android:permissionGroup="android.permission-group.SYSTEM_TOOLS"
         android:protectionLevel="dangerous" />
-
     <permission
         android:name="com.android.launcher.permission.UNINSTALL_SHORTCUT"
         android:description="@string/permdesc_uninstall_shortcut"
         android:label="@string/permlab_uninstall_shortcut"
         android:permissionGroup="android.permission-group.SYSTEM_TOOLS"
-        android:protectionLevel="dangerous" />
-
-    <!-- General permissions BEGIN-->
+        android:protectionLevel="dangerous" /> <!-- General permissions BEGIN -->
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />
     <uses-permission android:name="android.permission.INTERNET" />
@@ -35,15 +32,13 @@
         tools:ignore="ProtectedPermissions" />
     <uses-permission
         android:name="android.permission.WRITE_SECURE_SETTINGS"
-        tools:ignore="ProtectedPermissions" />
-    <!-- General permissions END-->
-
+        tools:ignore="ProtectedPermissions" /> <!-- General permissions END -->
     <!-- LineageOS specific permissions BEGIN -->
     <uses-permission android:name="lineageos.permission.ACCESS_WEATHER_MANAGER" />
-    <uses-permission android:name="lineageos.permission.READ_WEATHER" />
-    <!-- LineageOS specific permissions END -->
+    <uses-permission android:name="lineageos.permission.READ_WEATHER" /> <!-- LineageOS specific permissions END -->
+    <uses-permission android:name="foundation.e.pwaplayer.provider.READ_WRITE" />
 
-    <uses-permission android:name="foundation.e.pwaplayer.provider.READ_WRITE"/>
+    <uses-permission android:name="android.permission.CONTROL_REMOTE_APP_TRANSITION_ANIMATIONS" />
 
     <application
         android:name=".BlissLauncher"
@@ -53,7 +48,27 @@
         android:supportsRtl="true"
         android:theme="@style/AppTheme"
         tools:ignore="AllowBackup,GoogleAppIndexingWarning">
-
+        <activity android:name=".features.test.TestActivity"
+            android:theme="@style/HomeScreenTheme"
+            android:launchMode="singleTask"
+            android:clearTaskOnLaunch="true"
+            android:stateNotNeeded="true"
+            android:windowSoftInputMode="adjustPan"
+            android:screenOrientation="portrait"
+            android:configChanges="keyboard|keyboardHidden|mcc|mnc|navigation|orientation|screenSize|screenLayout|smallestScreenSize"
+            android:resizeableActivity="true"
+            android:resumeWhilePausing="true"
+            android:taskAffinity=""
+            android:exported="true"
+            android:enabled="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.HOME" />
+                <category android:name="android.intent.category.LAUNCHER" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.MONKEY" />
+            </intent-filter>
+        </activity>
         <!--
         Main launcher activity. When extending only change the name, and keep all the
         attributes and intent filters the same
@@ -70,13 +85,10 @@
             android:windowSoftInputMode="adjustPan">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
-
-                <category android:name="android.intent.category.HOME" />
                 <category android:name="android.intent.category.DEFAULT" />
                 <category android:name="android.intent.category.MONKEY" />
             </intent-filter>
         </activity>
-
         <activity
             android:name=".features.shortcuts.AddItemActivity"
             android:autoRemoveFromRecents="true"
@@ -87,25 +99,21 @@
                 <action android:name="android.content.pm.action.CONFIRM_PIN_SHORTCUT" />
             </intent-filter>
         </activity>
-
         <activity
             android:name=".features.weather.WeatherPreferences"
             android:theme="@style/AppTheme" />
-
         <activity
             android:name=".features.weather.PermissionRequestActivity"
             android:excludeFromRecents="true"
             android:exported="true"
             android:noHistory="true"
             android:theme="@android:style/Theme.Translucent.NoTitleBar" />
-
         <activity
             android:name=".features.widgets.WidgetsActivity"
             android:autoRemoveFromRecents="true"
             android:excludeFromRecents="true"
             android:label="@string/widgets"
             android:theme="@style/AppTheme" />
-
         <activity
             android:name=".features.widgets.WidgetPicker"
             android:autoRemoveFromRecents="true"
@@ -124,13 +132,9 @@
                 <action android:name="android.service.notification.NotificationListenerService" />
             </intent-filter>
         </service>
-
         <service android:name=".features.weather.WeatherUpdateService" />
         <service android:name=".features.weather.DeviceStatusService" />
-        <service android:name=".features.weather.WeatherSourceListenerService" />
-
-
-        <!-- Intent received used to install shortcuts from other applications -->
+        <service android:name=".features.weather.WeatherSourceListenerService" /> <!-- Intent received used to install shortcuts from other applications -->
         <receiver
             android:name=".features.shortcuts.InstallShortcutReceiver"
             android:enabled="true"
@@ -138,9 +142,7 @@
             <intent-filter>
                 <action android:name="com.android.launcher.action.INSTALL_SHORTCUT" />
             </intent-filter>
-        </receiver>
-
-        <!-- Intent received used to uninstall shortcuts from other applications -->
+        </receiver> <!-- Intent received used to uninstall shortcuts from other applications -->
         <receiver
             android:name=".features.shortcuts.UninstallShortcutReceiver"
             android:enabled="true"
@@ -148,10 +150,9 @@
             <intent-filter>
                 <action android:name="com.android.launcher.action.UNINSTALL_SHORTCUT" />
             </intent-filter>
-        </receiver>
-
-        <!-- Intent received when a session is committed -->
-        <!--<receiver android:name="com.android.launcher3.SessionCommitReceiver">
+        </receiver> <!-- Intent received when a session is committed -->
+        <!--
+<receiver android:name="com.android.launcher3.SessionCommitReceiver">
             <intent-filter>
                 <action android:name="android.content.pm.action.SESSION_COMMITTED" />
             </intent-filter>
@@ -162,12 +163,49 @@
             <intent-filter>
                 <action android:name="android.appwidget.action.APPWIDGET_HOST_RESTORED" />
             </intent-filter>
-        </receiver>-->
-
+        </receiver>
+        -->
         <receiver android:name="core.broadcast.PackageAddedRemovedHandler" />
 
         <meta-data
             android:name="android.nfc.disable_beam_default"
             android:value="true" />
+
+        <service
+            android:name=".quickstep.TouchInteractionService"
+            android:permission="android.permission.STATUS_BAR_SERVICE"
+            android:directBootAware="true">
+            <intent-filter>
+                <action android:name="android.intent.action.QUICKSTEP_SERVICE" />
+            </intent-filter>
+        </service>
+
+        <!-- STOPSHIP: Change exported to false once all the integration is complete.
+        It is set to true so that the activity can be started from command line -->
+        <activity android:name=".quickstep.RecentsActivity"
+            android:exported="true"
+            android:excludeFromRecents="true"
+            android:launchMode="singleTask"
+            android:clearTaskOnLaunch="true"
+            android:stateNotNeeded="true"
+            android:theme="@style/HomeScreenTheme"
+            android:screenOrientation="unspecified"
+            android:configChanges="keyboard|keyboardHidden|mcc|mnc|navigation|orientation|screenSize|screenLayout|smallestScreenSize"
+            android:resizeableActivity="true"
+            android:resumeWhilePausing="true"
+            android:taskAffinity="" />
+
+        <activity
+            android:name=".proxy.ProxyActivityStarter"
+            android:theme="@android:style/Theme.Translucent.NoTitleBar.Fullscreen"
+            android:launchMode="singleTask"
+            android:clearTaskOnLaunch="true"
+            android:exported="false" />
+
+        <activity android:name=".quickstep.LockScreenRecentsActivity"
+            android:theme="@android:style/Theme.NoDisplay"
+            android:showOnLockScreen="true"
+            android:directBootAware="true" />
     </application>
-</manifest>
+
+</manifest>
\ No newline at end of file
diff --git a/app/src/main/java/foundation/e/blisslauncher/BlissLauncher.java b/app/src/main/java/foundation/e/blisslauncher/BlissLauncher.java
index 8141d07c65bc92786f55a3d45dc8694b36aae347..4968641ee3e2c1c762c1dcf95e99c967b7f3d2da 100755
--- a/app/src/main/java/foundation/e/blisslauncher/BlissLauncher.java
+++ b/app/src/main/java/foundation/e/blisslauncher/BlissLauncher.java
@@ -1,18 +1,20 @@
 package foundation.e.blisslauncher;
 
+
 import android.app.Application;
 import android.appwidget.AppWidgetManager;
 import android.content.Context;
-
 import foundation.e.blisslauncher.core.DeviceProfile;
 import foundation.e.blisslauncher.core.IconsHandler;
 import foundation.e.blisslauncher.core.blur.BlurWallpaperProvider;
 import foundation.e.blisslauncher.core.customviews.WidgetHost;
 import foundation.e.blisslauncher.features.launcher.AppProvider;
+import foundation.e.blisslauncher.features.test.InvariantDeviceProfile;
 
 public class BlissLauncher extends Application {
     private IconsHandler iconsPackHandler;
     private DeviceProfile deviceProfile;
+    private InvariantDeviceProfile invDeviceProfile;
 
     private AppProvider mAppProvider;
 
@@ -42,6 +44,13 @@ public class BlissLauncher extends Application {
         return deviceProfile;
     }
 
+    public InvariantDeviceProfile getInvariantDeviceProfile() {
+        if (invDeviceProfile == null) {
+            invDeviceProfile = new InvariantDeviceProfile(this);
+        }
+        return invDeviceProfile;
+    }
+
     public void resetDeviceProfile() {
         deviceProfile = new DeviceProfile(this);
     }
diff --git a/app/src/main/java/foundation/e/blisslauncher/FixedScaleDrawable.java b/app/src/main/java/foundation/e/blisslauncher/FixedScaleDrawable.java
index 1f40317c456baa88ec881e07e1fba851c9df438c..457ca0ee359a37fa8a3f842240603433bd20600f 100644
--- a/app/src/main/java/foundation/e/blisslauncher/FixedScaleDrawable.java
+++ b/app/src/main/java/foundation/e/blisslauncher/FixedScaleDrawable.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher;
 
+
 import android.annotation.TargetApi;
 import android.content.res.Resources;
 import android.graphics.Canvas;
@@ -7,7 +8,6 @@ import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.DrawableWrapper;
 import android.os.Build;
 import android.util.AttributeSet;
-
 import org.xmlpull.v1.XmlPullParser;
 
 /**
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/AdaptiveIconGenerator.java b/app/src/main/java/foundation/e/blisslauncher/core/AdaptiveIconGenerator.java
index 1eccc03f74f0660eff67dd7f420264b80e7738a4..a37a98679c17c47122326f5cc3db134727b8c512 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/AdaptiveIconGenerator.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/AdaptiveIconGenerator.java
@@ -1,5 +1,9 @@
 package foundation.e.blisslauncher.core;
 
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.lang.Math.round;
+
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Color;
@@ -8,17 +12,11 @@ import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
 import android.util.Log;
 import android.util.SparseIntArray;
-
 import androidx.annotation.NonNull;
 import androidx.core.graphics.ColorUtils;
-
 import foundation.e.blisslauncher.FixedScaleDrawable;
 import foundation.e.blisslauncher.core.customviews.AdaptiveIconDrawableCompat;
 
-import static java.lang.Math.max;
-import static java.lang.Math.min;
-import static java.lang.Math.round;
-
 public class AdaptiveIconGenerator {
 
     // Average number of derived colors (based on averages with ~100 icons and performance testing)
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/AdaptiveIconProvider.java b/app/src/main/java/foundation/e/blisslauncher/core/AdaptiveIconProvider.java
index 7986be8021095f016e2baa5a0c11f918600ed24c..043c197369268c275ef516ea55b1b70204bedae3 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/AdaptiveIconProvider.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/AdaptiveIconProvider.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core;
 
+
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.content.res.AssetManager;
@@ -7,13 +8,10 @@ import android.content.res.Resources;
 import android.content.res.XmlResourceParser;
 import android.graphics.drawable.Drawable;
 import android.util.Log;
-
 import androidx.core.content.res.ResourcesCompat;
-
-import org.xmlpull.v1.XmlPullParser;
-
 import foundation.e.blisslauncher.core.customviews.AdaptiveIconDrawableCompat;
 import foundation.e.blisslauncher.core.utils.ResourceUtils;
+import org.xmlpull.v1.XmlPullParser;
 
 /**
  * Created by falcon on 19/4/18.
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/Alarm.java b/app/src/main/java/foundation/e/blisslauncher/core/Alarm.java
index 4aa4694c96f88165ef0e722ccb6380c52b7d503d..ef7fdb1fab55bcffe9be9bcac4a3c6ef79d2552c 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/Alarm.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/Alarm.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core;
 
+
 import android.os.Handler;
 import android.os.SystemClock;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/ColorExtractor.java b/app/src/main/java/foundation/e/blisslauncher/core/ColorExtractor.java
index f3b4b69798226f07974eb3f528109deed06dc5b0..8f43a4de1a6b74a9d3d97916b6c4addcf902264f 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/ColorExtractor.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/ColorExtractor.java
@@ -17,15 +17,14 @@ package foundation.e.blisslauncher.core;
  * limitations under the License.
  */
 
+
 import android.graphics.Bitmap;
 import android.graphics.Color;
 import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
 import android.util.SparseArray;
-
 import java.util.HashSet;
 import java.util.Set;
-
 import kotlin.collections.ArraysKt;
 
 /**
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/ConfigMonitor.java b/app/src/main/java/foundation/e/blisslauncher/core/ConfigMonitor.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa305e5afdb294b0aff1a5a58e824d1f1c618255
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/ConfigMonitor.java
@@ -0,0 +1,57 @@
+package foundation.e.blisslauncher.core;
+
+/**
+ * Copyright (C) 2015 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.
+ */
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.res.Configuration;
+import android.util.Log;
+
+/**
+ * {@link BroadcastReceiver} which watches configuration changes and
+ * restarts the process in case changes which affect the device profile occur.
+ */
+public class ConfigMonitor extends BroadcastReceiver {
+
+    private final Context mContext;
+    private final float mFontScale;
+    private final int mDensity;
+
+    public ConfigMonitor(Context context) {
+        mContext = context;
+
+        Configuration config = context.getResources().getConfiguration();
+        mFontScale = config.fontScale;
+        mDensity = config.densityDpi;
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        Configuration config = context.getResources().getConfiguration();
+        if (mFontScale != config.fontScale || mDensity != config.densityDpi) {
+            Log.d("ConfigMonitor", "Configuration changed, restarting launcher");
+            mContext.unregisterReceiver(this);
+            android.os.Process.killProcess(android.os.Process.myPid());
+        }
+    }
+
+    public void register() {
+        mContext.registerReceiver(this, new IntentFilter(Intent.ACTION_CONFIGURATION_CHANGED));
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/DeviceProfile.java b/app/src/main/java/foundation/e/blisslauncher/core/DeviceProfile.java
index efa4d261fc80d3515e353ef039cc9fc10f06c363..e8b1a1a8579d7e89907f6a8786d0a6886ad47c47 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/DeviceProfile.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/DeviceProfile.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core;
 
+
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.res.Configuration;
@@ -409,4 +410,18 @@ public class DeviceProfile {
 
         return density;
     }
+
+    /**
+     * Callback when a component changes the DeviceProfile associated with it, as a result of
+     * configuration change
+     */
+    public interface OnDeviceProfileChangeListener {
+
+        /**
+         * Called when the device profile is reassigned. Note that for layout and measurements, it
+         * is sufficient to listen for inset changes. Use this callback when you need to perform
+         * a one time operation.
+         */
+        void onDeviceProfileChanged(DeviceProfile dp);
+    }
 }
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/Flags.kt b/app/src/main/java/foundation/e/blisslauncher/core/Flags.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9fa9217a5531307a77a1784f1ac4c3c7e74d0586
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/Flags.kt
@@ -0,0 +1,7 @@
+package foundation.e.blisslauncher.core
+
+// used to control the behavior of launcher
+object Flags {
+    const val QUICKSTEP_SPRINGS = true
+    const val ENABLE_QUICKSTEP_LIVE_TILE = true
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/IconsHandler.java b/app/src/main/java/foundation/e/blisslauncher/core/IconsHandler.java
index 83bd9fa9d90ac9929db0a507790f82d1bc062d0e..f79bac7cecf3fe72b871116a19c0c224a7a45a99 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/IconsHandler.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/IconsHandler.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core;
 
+
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
@@ -16,24 +17,20 @@ import android.graphics.drawable.AdaptiveIconDrawable;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.util.Log;
-
-import org.w3c.dom.Document;
-import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
-
+import foundation.e.blisslauncher.BlissLauncher;
+import foundation.e.blisslauncher.core.customviews.AdaptiveIconDrawableCompat;
+import foundation.e.blisslauncher.core.utils.GraphicsUtil;
+import foundation.e.blisslauncher.core.utils.UserHandle;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.util.HashMap;
 import java.util.Map;
-
 import javax.xml.parsers.DocumentBuilderFactory;
-
-import foundation.e.blisslauncher.BlissLauncher;
-import foundation.e.blisslauncher.core.customviews.AdaptiveIconDrawableCompat;
-import foundation.e.blisslauncher.core.utils.GraphicsUtil;
-import foundation.e.blisslauncher.core.utils.UserHandle;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
 
 /**
  * Inspired from http://stackoverflow.com/questions/31490630/how-to-load-icon-from-icon-pack
@@ -231,7 +228,7 @@ public class IconsHandler {
         }
     }
 
-    private Drawable getBadgedIcon(Drawable icon, android.os.UserHandle userHandle) {
+    public Drawable getBadgedIcon(Drawable icon, android.os.UserHandle userHandle) {
         return ctx.getApplicationContext().getPackageManager().getUserBadgedIcon(icon, userHandle);
     }
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/KotlinUtils.kt b/app/src/main/java/foundation/e/blisslauncher/core/KotlinUtils.kt
index ea369873f2c276e49bf4b29523b9c3c868e6157b..99c90901948762e09df0cf7330be05227a67213c 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/KotlinUtils.kt
+++ b/app/src/main/java/foundation/e/blisslauncher/core/KotlinUtils.kt
@@ -21,4 +21,4 @@ inline fun <T> Iterable<T>.safeForEach(action: (T) -> Unit) {
     val tmp = ArrayList<T>()
     tmp.addAll(this)
     for (element in tmp) action(element)
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/SettingsObserver.java b/app/src/main/java/foundation/e/blisslauncher/core/SettingsObserver.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab944d1e2bb142315a64e45ce9193e1f1d9e5927
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/SettingsObserver.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package foundation.e.blisslauncher.core;
+
+import android.content.ContentResolver;
+import android.database.ContentObserver;
+import android.os.Handler;
+import android.provider.Settings;
+
+public interface SettingsObserver {
+
+    /**
+     * Registers the content observer to call {@link #onSettingChanged(boolean)} when any of the
+     * passed settings change. The value passed to onSettingChanged() is based on the key setting.
+     */
+    void register(String keySetting, String ... dependentSettings);
+    void unregister();
+    void onSettingChanged(boolean keySettingEnabled);
+
+
+    abstract class Secure extends ContentObserver implements SettingsObserver {
+        private ContentResolver mResolver;
+        private String mKeySetting;
+
+        public Secure(ContentResolver resolver) {
+            super(new Handler());
+            mResolver = resolver;
+        }
+
+        @Override
+        public void register(String keySetting, String ... dependentSettings) {
+            mKeySetting = keySetting;
+            mResolver.registerContentObserver(
+                    Settings.Secure.getUriFor(mKeySetting), false, this);
+            for (String setting : dependentSettings) {
+                mResolver.registerContentObserver(
+                        Settings.Secure.getUriFor(setting), false, this);
+            }
+            onChange(true);
+        }
+
+        @Override
+        public void unregister() {
+            mResolver.unregisterContentObserver(this);
+        }
+
+        @Override
+        public void onChange(boolean selfChange) {
+            super.onChange(selfChange);
+            onSettingChanged(Settings.Secure.getInt(mResolver, mKeySetting, 1) == 1);
+        }
+    }
+
+    abstract class System extends ContentObserver implements SettingsObserver {
+        private ContentResolver mResolver;
+        private String mKeySetting;
+
+        public System(ContentResolver resolver) {
+            super(new Handler());
+            mResolver = resolver;
+        }
+
+        @Override
+        public void register(String keySetting, String ... dependentSettings) {
+            mKeySetting = keySetting;
+            mResolver.registerContentObserver(
+                    Settings.System.getUriFor(mKeySetting), false, this);
+            for (String setting : dependentSettings) {
+                mResolver.registerContentObserver(
+                        Settings.System.getUriFor(setting), false, this);
+            }
+            onChange(true);
+        }
+
+        @Override
+        public void unregister() {
+            mResolver.unregisterContentObserver(this);
+        }
+
+        @Override
+        public void onChange(boolean selfChange) {
+            super.onChange(selfChange);
+            onSettingChanged(Settings.System.getInt(mResolver, mKeySetting, 1) == 1);
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompat.java b/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompat.java
index a6866fdbb31f08c33e42245f9c63ea8abff0574a..d90745e93dd41aa0569448a61d6c14c215cac5db 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompat.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompat.java
@@ -1,8 +1,8 @@
 package foundation.e.blisslauncher.core;
 
+
 import android.content.Context;
 import android.os.UserHandle;
-
 import java.util.List;
 
 public abstract class UserManagerCompat {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVL.java b/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVL.java
index ce8c8d08dbf144ec8f78922fd5994f5aeb850031..256db8041c02d5ce402343f547de249a8e46a462 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVL.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVL.java
@@ -1,19 +1,18 @@
 package foundation.e.blisslauncher.core;
 
+
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.content.pm.PackageManager;
 import android.os.UserHandle;
 import android.os.UserManager;
 import android.util.ArrayMap;
-
+import foundation.e.blisslauncher.core.utils.Constants;
+import foundation.e.blisslauncher.core.utils.LongArrayMap;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import foundation.e.blisslauncher.core.utils.Constants;
-import foundation.e.blisslauncher.core.utils.LongArrayMap;
-
 public class UserManagerCompatVL extends UserManagerCompat {
 
     protected final UserManager mUserManager;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVM.java b/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVM.java
index 053cfd4827bd3e4adda7b66ba6b40cfec5975ae4..e40b29d1af39d08b48e49f7ebf6012718f3f9f23 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVM.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVM.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core;
 
+
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.os.Build;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVN.java b/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVN.java
index 84c4f01add8a9de771ce9dc662fb552a771b41cd..f268a2c6f259f3ee859530aebc219b3631df7d64 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVN.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVN.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core;
 
+
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.os.Build;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVNMr1.java b/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVNMr1.java
index 41e6e24c556b5262f87a4070a0ae3a0eeed0eab2..61b58317131ffb6c5438c73394b3bef1caf7b1ac 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVNMr1.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/UserManagerCompatVNMr1.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core;
 
+
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.os.Build;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/Utilities.java b/app/src/main/java/foundation/e/blisslauncher/core/Utilities.java
index 502746241a80d7d684a690bf79d32309d893223f..571f6ca3042ef5d4df60e6bb90067a8a9026fd3d 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/Utilities.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/Utilities.java
@@ -1,21 +1,40 @@
 package foundation.e.blisslauncher.core;
 
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
 import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
+import android.graphics.Matrix;
 import android.graphics.Paint;
+import android.graphics.Rect;
+import android.graphics.RectF;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.os.Build;
+import android.os.Handler;
+import android.os.Message;
+import android.os.PowerManager;
 import android.text.TextUtils;
 import android.util.DisplayMetrics;
 import android.util.Log;
 import android.util.TypedValue;
+import android.view.MotionEvent;
 import android.view.View;
+import android.view.ViewConfiguration;
 import android.view.ViewGroup;
+import android.view.animation.Interpolator;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
@@ -27,29 +46,39 @@ import java.util.concurrent.TimeUnit;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-
 public class Utilities {
 
     private static final String TAG = "Utilities";
 
     private static final Pattern sTrimPattern =
-            Pattern.compile("^[\\s|\\p{javaSpaceChar}]*(.*)[\\s|\\p{javaSpaceChar}]*$");
+        Pattern.compile("^[\\s|\\p{javaSpaceChar}]*(.*)[\\s|\\p{javaSpaceChar}]*$");
+
+    private static final int[] sLoc0 = new int[2];
+    private static final int[] sLoc1 = new int[2];
+    private static final float[] sPoint = new float[2];
+    private static final Matrix sMatrix = new Matrix();
+    private static final Matrix sInverseMatrix = new Matrix();
 
     /**
      * Use hard coded values to compile with android source.
      */
+    public static final boolean ATLEAST_Q = Build.VERSION.SDK_INT >= 29;
+    public static final boolean ATLEAST_P =
+        Build.VERSION.SDK_INT >= 28;
+
     public static final boolean ATLEAST_OREO =
-            Build.VERSION.SDK_INT >= 26;
+        Build.VERSION.SDK_INT >= 26;
 
     public static final boolean ATLEAST_NOUGAT_MR1 =
-            Build.VERSION.SDK_INT >= 25;
+        Build.VERSION.SDK_INT >= 25;
 
     public static final boolean ATLEAST_NOUGAT =
-            Build.VERSION.SDK_INT >= 24;
+        Build.VERSION.SDK_INT >= 24;
 
     public static final boolean ATLEAST_MARSHMALLOW =
-            Build.VERSION.SDK_INT >= 23;
+        Build.VERSION.SDK_INT >= 23;
 
+    public static final int SINGLE_FRAME_MS = 16;
 
     // These values are same as that in {@link AsyncTask}.
     private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
@@ -60,8 +89,20 @@ public class Utilities {
      * An {@link Executor} to be used with async task with no limit on the queue size.
      */
     public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(
-            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
-            TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
+        CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
+        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()
+    );
+
+    /**
+     * Set on a motion event dispatched from the nav bar. See {@link MotionEvent#setEdgeFlags(int)}.
+     */
+    public static final int EDGE_NAV_BAR = 1 << 8;
+
+    /**
+     * Set on a motion event do disallow any gestures and only handle touch.
+     * See {@link MotionEvent#setEdgeFlags(int)}.
+     */
+    public static final int FLAG_NO_GESTURES = 1 << 9;
 
     /**
      * Compresses the bitmap to a byte array for serialization.
@@ -82,13 +123,15 @@ public class Utilities {
         }
     }
 
-    public static float dpiFromPx(int size, DisplayMetrics metrics){
+    public static float dpiFromPx(int size, DisplayMetrics metrics) {
         float densityRatio = (float) metrics.densityDpi / DisplayMetrics.DENSITY_DEFAULT;
         return (size / densityRatio);
     }
+
     public static int pxFromDp(float size, DisplayMetrics metrics) {
         return Math.round(TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
-                size, metrics));
+            size, metrics
+        ));
     }
 
     public static float pxFromDp(int dp, Context context) {
@@ -98,7 +141,8 @@ public class Utilities {
 
     public static int pxFromSp(float size, DisplayMetrics metrics) {
         return Math.round(TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP,
-                size, metrics));
+            size, metrics
+        ));
     }
 
     /**
@@ -112,7 +156,7 @@ public class Utilities {
     }
 
     public static String convertMonthToString() {
-        Calendar cal=Calendar.getInstance();
+        Calendar cal = Calendar.getInstance();
         SimpleDateFormat month_date = new SimpleDateFormat("MMM");
         return month_date.format(cal.getTime());
     }
@@ -164,7 +208,11 @@ public class Utilities {
         return drawableToBitmap(drawable, forceCreate, 0);
     }
 
-    public static Bitmap drawableToBitmap(Drawable drawable, boolean forceCreate, int fallbackSize) {
+    public static Bitmap drawableToBitmap(
+        Drawable drawable,
+        boolean forceCreate,
+        int fallbackSize
+    ) {
         if (!forceCreate && drawable instanceof BitmapDrawable) {
             return ((BitmapDrawable) drawable).getBitmap();
         }
@@ -214,4 +262,331 @@ public class Utilities {
     public static int boundToRange(int value, int lowerBound, int upperBound) {
         return Math.max(lowerBound, Math.min(value, upperBound));
     }
+
+    /**
+     * @see #boundToRange(int, int, int).
+     */
+    public static float boundToRange(float value, float lowerBound, float upperBound) {
+        return Math.max(lowerBound, Math.min(value, upperBound));
+    }
+
+    /**
+     * @see #boundToRange(int, int, int).
+     */
+    public static long boundToRange(long value, long lowerBound, long upperBound) {
+        return Math.max(lowerBound, Math.min(value, upperBound));
+    }
+
+    public static boolean isSystemApp(Context context, Intent intent) {
+        PackageManager pm = context.getPackageManager();
+        ComponentName cn = intent.getComponent();
+        String packageName = null;
+        if (cn == null) {
+            ResolveInfo info = pm.resolveActivity(intent, PackageManager.MATCH_DEFAULT_ONLY);
+            if ((info != null) && (info.activityInfo != null)) {
+                packageName = info.activityInfo.packageName;
+            }
+        } else {
+            packageName = cn.getPackageName();
+        }
+        if (packageName != null) {
+            try {
+                PackageInfo info = pm.getPackageInfo(packageName, 0);
+                return (info != null) && (info.applicationInfo != null) &&
+                    ((info.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0);
+            } catch (PackageManager.NameNotFoundException e) {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Given a coordinate relative to the descendant, find the coordinate in a parent view's
+     * coordinates.
+     *
+     * @param descendant        The descendant to which the passed coordinate is relative.
+     * @param ancestor          The root view to make the coordinates relative to.
+     * @param coord             The coordinate that we want mapped.
+     * @param includeRootScroll Whether or not to account for the scroll of the descendant:
+     *                          sometimes this is relevant as in a child's coordinates within the descendant.
+     * @return The factor by which this descendant is scaled relative to this DragLayer. Caution
+     * this scale factor is assumed to be equal in X and Y, and so if at any point this
+     * assumption fails, we will need to return a pair of scale factors.
+     */
+    public static float getDescendantCoordRelativeToAncestor(
+        View descendant, View ancestor, int[] coord, boolean includeRootScroll
+    ) {
+        sPoint[0] = coord[0];
+        sPoint[1] = coord[1];
+
+        float scale = 1.0f;
+        View v = descendant;
+        while (v != ancestor && v != null) {
+            // For TextViews, scroll has a meaning which relates to the text position
+            // which is very strange... ignore the scroll.
+            if (v != descendant || includeRootScroll) {
+                sPoint[0] -= v.getScrollX();
+                sPoint[1] -= v.getScrollY();
+            }
+
+            v.getMatrix().mapPoints(sPoint);
+            sPoint[0] += v.getLeft();
+            sPoint[1] += v.getTop();
+            scale *= v.getScaleX();
+
+            v = (View) v.getParent();
+        }
+
+        coord[0] = Math.round(sPoint[0]);
+        coord[1] = Math.round(sPoint[1]);
+        return scale;
+    }
+
+    /**
+     * Given a coordinate relative to the descendant, find the coordinate in a parent view's
+     * coordinates.
+     *
+     * @param descendant        The descendant to which the passed coordinate is relative.
+     * @param ancestor          The root view to make the coordinates relative to.
+     * @param coord             The coordinate that we want mapped.
+     * @param includeRootScroll Whether or not to account for the scroll of the descendant:
+     *                          sometimes this is relevant as in a child's coordinates within the descendant.
+     * @return The factor by which this descendant is scaled relative to this DragLayer. Caution
+     * this scale factor is assumed to be equal in X and Y, and so if at any point this
+     * assumption fails, we will need to return a pair of scale factors.
+     */
+    public static float getDescendantCoordRelativeToAncestor(
+        View descendant, View ancestor, float[] coord, boolean includeRootScroll
+    ) {
+        return getDescendantCoordRelativeToAncestor(descendant, ancestor, coord, includeRootScroll,
+            false, null
+        );
+    }
+
+    /**
+     * Given a coordinate relative to the descendant, find the coordinate in a parent view's
+     * coordinates.
+     *
+     * @param descendant        The descendant to which the passed coordinate is relative.
+     * @param ancestor          The root view to make the coordinates relative to.
+     * @param coord             The coordinate that we want mapped.
+     * @param includeRootScroll Whether or not to account for the scroll of the descendant:
+     *                          sometimes this is relevant as in a child's coordinates within the descendant.
+     * @param ignoreTransform   If true, view transform is ignored
+     * @param outRotation       If not null, and {@param ignoreTransform} is true, this is set to the
+     *                          overall rotation of the view in degrees.
+     * @return The factor by which this descendant is scaled relative to this DragLayer. Caution
+     * this scale factor is assumed to be equal in X and Y, and so if at any point this
+     * assumption fails, we will need to return a pair of scale factors.
+     */
+    public static float getDescendantCoordRelativeToAncestor(
+        View descendant, View ancestor,
+        float[] coord, boolean includeRootScroll, boolean ignoreTransform,
+        float[] outRotation
+    ) {
+        float scale = 1.0f;
+        View v = descendant;
+        while (v != ancestor && v != null) {
+            // For TextViews, scroll has a meaning which relates to the text position
+            // which is very strange... ignore the scroll.
+            if (v != descendant || includeRootScroll) {
+                offsetPoints(coord, -v.getScrollX(), -v.getScrollY());
+            }
+
+            v.getMatrix().mapPoints(coord);
+
+            offsetPoints(coord, v.getLeft(), v.getTop());
+            scale *= v.getScaleX();
+
+            v = (View) v.getParent();
+        }
+        return scale;
+    }
+
+    public static void offsetPoints(float[] points, float offsetX, float offsetY) {
+        for (int i = 0; i < points.length; i += 2) {
+            points[i] += offsetX;
+            points[i + 1] += offsetY;
+        }
+    }
+
+    /**
+     * Inverse of {@link #getDescendantCoordRelativeToAncestor(View, View, int[], boolean)}.
+     */
+    public static void mapCoordInSelfToDescendant(View descendant, View root, int[] coord) {
+        sMatrix.reset();
+        View v = descendant;
+        while (v != root) {
+            sMatrix.postTranslate(-v.getScrollX(), -v.getScrollY());
+            sMatrix.postConcat(v.getMatrix());
+            sMatrix.postTranslate(v.getLeft(), v.getTop());
+            v = (View) v.getParent();
+        }
+        sMatrix.postTranslate(-v.getScrollX(), -v.getScrollY());
+        sMatrix.invert(sInverseMatrix);
+
+        sPoint[0] = coord[0];
+        sPoint[1] = coord[1];
+        sInverseMatrix.mapPoints(sPoint);
+        coord[0] = Math.round(sPoint[0]);
+        coord[1] = Math.round(sPoint[1]);
+    }
+
+    /**
+     * Inverse of {@link #getDescendantCoordRelativeToAncestor(View, View, float[], boolean)}.
+     */
+    public static void mapCoordInSelfToDescendant(View descendant, View root, float[] coord) {
+        sMatrix.reset();
+        View v = descendant;
+        while(v != root) {
+            sMatrix.postTranslate(-v.getScrollX(), -v.getScrollY());
+            sMatrix.postConcat(v.getMatrix());
+            sMatrix.postTranslate(v.getLeft(), v.getTop());
+            v = (View) v.getParent();
+        }
+        sMatrix.postTranslate(-v.getScrollX(), -v.getScrollY());
+        sMatrix.invert(sInverseMatrix);
+        sInverseMatrix.mapPoints(coord);
+    }
+
+    /**
+     * Utility method to determine whether the given point, in local coordinates,
+     * is inside the view, where the area of the view is expanded by the slop factor.
+     * This method is called while processing touch-move events to determine if the event
+     * is still within the view.
+     */
+    public static boolean pointInView(View v, float localX, float localY, float slop) {
+        return localX >= -slop && localY >= -slop && localX < (v.getWidth() + slop) &&
+            localY < (v.getHeight() + slop);
+    }
+
+    public static void scaleRectAboutCenter(Rect r, float scale) {
+        if (scale != 1.0f) {
+            int cx = r.centerX();
+            int cy = r.centerY();
+            r.offset(-cx, -cy);
+            scaleRect(r, scale);
+            r.offset(cx, cy);
+        }
+    }
+
+    public static void scaleRect(Rect r, float scale) {
+        if (scale != 1.0f) {
+            r.left = (int) (r.left * scale + 0.5f);
+            r.top = (int) (r.top * scale + 0.5f);
+            r.right = (int) (r.right * scale + 0.5f);
+            r.bottom = (int) (r.bottom * scale + 0.5f);
+        }
+    }
+
+    public static boolean isRtl(Resources res) {
+        return res.getConfiguration().getLayoutDirection() == View.LAYOUT_DIRECTION_RTL;
+    }
+
+    public static boolean isPowerSaverPreventingAnimation(Context context) {
+        if (ATLEAST_P) {
+            // Battery saver mode no longer prevents animations.
+            return false;
+        }
+        PowerManager powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+        return powerManager.isPowerSaveMode();
+    }
+
+    public static <T> T getOverrideObject(Class<T> clazz, Context context, int resId) {
+        String className = context.getString(resId);
+        if (!TextUtils.isEmpty(className)) {
+            try {
+                Class<?> cls = Class.forName(className);
+                return (T) cls.getDeclaredConstructor(Context.class).newInstance(context);
+            } catch (ClassNotFoundException | InstantiationException | IllegalAccessException
+                | ClassCastException | NoSuchMethodException | InvocationTargetException e) {
+                Log.e(TAG, "Bad overriden class", e);
+            }
+        }
+
+        try {
+            return clazz.newInstance();
+        } catch (InstantiationException | IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static void scaleRectFAboutCenter(RectF r, float scale) {
+        if (scale != 1.0f) {
+            float cx = r.centerX();
+            float cy = r.centerY();
+            r.offset(-cx, -cy);
+            r.left = r.left * scale;
+            r.top = r.top * scale;
+            r.right = r.right * scale;
+            r.bottom = r.bottom * scale;
+            r.offset(cx, cy);
+        }
+    }
+
+    /**
+     * Utility method to post a runnable on the handler, skipping the synchronization barriers.
+     */
+    public static void postAsyncCallback(Handler handler, Runnable callback) {
+        Message msg = Message.obtain(handler, callback);
+        msg.setAsynchronous(true);
+        handler.sendMessage(msg);
+    }
+
+    public static SharedPreferences getPrefs(Context context) {
+        return context.getSharedPreferences(
+            "foundation.e.blisslauncher.prefs", Context.MODE_PRIVATE);
+    }
+
+    public static float mapRange(float value, float min, float max) {
+        return min + (value * (max - min));
+    }
+
+    public static float squaredHypot(float x, float y) {
+        return x * x + y * y;
+    }
+
+    public static float squaredTouchSlop(Context context) {
+        float slop = ViewConfiguration.get(context).getScaledTouchSlop();
+        return slop * slop;
+    }
+
+    public static boolean shouldDisableGestures(MotionEvent ev) {
+        return (ev.getEdgeFlags() & FLAG_NO_GESTURES) == FLAG_NO_GESTURES;
+    }
+
+    public static float getProgress(float current, float min, float max) {
+        return Math.abs(current - min) / Math.abs(max - min);
+    }
+
+    public static void unregisterReceiverSafely(Context context, BroadcastReceiver receiver) {
+        try {
+            context.unregisterReceiver(receiver);
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * Maps t from one range to another range.
+     *
+     * @param t       The value to map.
+     * @param fromMin The lower bound of the range that t is being mapped from.
+     * @param fromMax The upper bound of the range that t is being mapped from.
+     * @param toMin   The lower bound of the range that t is being mapped to.
+     * @param toMax   The upper bound of the range that t is being mapped to.
+     * @return The mapped value of t.
+     */
+    public static float mapToRange(
+        float t, float fromMin, float fromMax, float toMin, float toMax,
+        Interpolator interpolator
+    ) {
+        if (fromMin == fromMax || toMin == toMax) {
+            Log.e(TAG, "mapToRange: range has 0 length");
+            return toMin;
+        }
+        float progress = getProgress(t, fromMin, fromMax);
+        return mapRange(interpolator.getInterpolation(progress), toMin, toMax);
+    }
 }
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/blur/BlurWallpaperFilter.kt b/app/src/main/java/foundation/e/blisslauncher/core/blur/BlurWallpaperFilter.kt
index 30fb67121069fb22dd4e7f7140c4235d9350472b..81feada09a6ba790926ef186875eb72223fc27b8 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/blur/BlurWallpaperFilter.kt
+++ b/app/src/main/java/foundation/e/blisslauncher/core/blur/BlurWallpaperFilter.kt
@@ -30,4 +30,4 @@ class BlurWallpaperFilter(private val context: Context) : WallpaperFilter {
                 })
         }
     }
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/blur/ShaderBlurDrawable.kt b/app/src/main/java/foundation/e/blisslauncher/core/blur/ShaderBlurDrawable.kt
index b025aebde727ed2221130183c157d8f97d3aa094..000b9c933535c6bb3ed53803e51c7848531801e6 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/blur/ShaderBlurDrawable.kt
+++ b/app/src/main/java/foundation/e/blisslauncher/core/blur/ShaderBlurDrawable.kt
@@ -63,9 +63,9 @@ class ShaderBlurDrawable internal constructor(private val blurWallpaperProvider:
                 blurBitmap
             }
 
-        //setupBlurPath()
+        // setupBlurPath()
 
-        //canvas.translate(0f, -1500f)
+        // canvas.translate(0f, -1500f)
         if (noRadius) {
             canvas.drawRect(
                 0f, 0f,
@@ -75,7 +75,7 @@ class ShaderBlurDrawable internal constructor(private val blurWallpaperProvider:
         } else {
             canvas.drawPath(DeviceProfile.path, blurPaint)
         }
-        //canvas.translate(0f, 1500f)
+        // canvas.translate(0f, 1500f)
     }
 
     override fun setAlpha(alpha: Int) {
@@ -126,4 +126,4 @@ class ShaderBlurDrawable internal constructor(private val blurWallpaperProvider:
     fun startListening() = blurWallpaperProvider.addListener(this)
 
     fun stopListening() = blurWallpaperProvider.removeListener(this)
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/blur/WallpaperFilter.kt b/app/src/main/java/foundation/e/blisslauncher/core/blur/WallpaperFilter.kt
index c85321ed76fbc85c543ef392945c6c34e189a6a6..b7a9b84589c76a809cd3bbcd2b899e3b610157a6 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/blur/WallpaperFilter.kt
+++ b/app/src/main/java/foundation/e/blisslauncher/core/blur/WallpaperFilter.kt
@@ -54,4 +54,4 @@ interface WallpaperFilter {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/broadcast/ManagedProfileBroadcastReceiver.java b/app/src/main/java/foundation/e/blisslauncher/core/broadcast/ManagedProfileBroadcastReceiver.java
index 94f511a2712da1b2021e0733748137f26e14ed0b..f58aca70914071a1201a4f71d7c3910d378a7779 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/broadcast/ManagedProfileBroadcastReceiver.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/broadcast/ManagedProfileBroadcastReceiver.java
@@ -1,12 +1,12 @@
 package foundation.e.blisslauncher.core.broadcast;
 
+
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.os.UserHandle;
 import android.util.Log;
-
 import foundation.e.blisslauncher.core.events.EventRelay;
 import foundation.e.blisslauncher.core.events.ForceReloadEvent;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/broadcast/PackageAddedRemovedHandler.java b/app/src/main/java/foundation/e/blisslauncher/core/broadcast/PackageAddedRemovedHandler.java
index 6e5280833b9a16cfdb2ff4cc55a98d4ed16dda92..cdf90d0060cd01249ef93550a6d4e3ba8787a88d 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/broadcast/PackageAddedRemovedHandler.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/broadcast/PackageAddedRemovedHandler.java
@@ -1,11 +1,11 @@
 package foundation.e.blisslauncher.core.broadcast;
 
+
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Process;
 import android.util.Log;
-
 import foundation.e.blisslauncher.BlissLauncher;
 import foundation.e.blisslauncher.core.events.AppAddEvent;
 import foundation.e.blisslauncher.core.events.AppChangeEvent;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/broadcast/TimeChangeBroadcastReceiver.java b/app/src/main/java/foundation/e/blisslauncher/core/broadcast/TimeChangeBroadcastReceiver.java
index e1cde5cc7368d1d31c318f9fc63ac0d7ceb526b5..f783b09ebdfc54ff06bd9ca42b1661be1ae515e0 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/broadcast/TimeChangeBroadcastReceiver.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/broadcast/TimeChangeBroadcastReceiver.java
@@ -1,10 +1,10 @@
 package foundation.e.blisslauncher.core.broadcast;
 
+
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
-
 import foundation.e.blisslauncher.core.events.EventRelay;
 import foundation.e.blisslauncher.core.events.TimeChangedEvent;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/broadcast/WallpaperChangeReceiver.java b/app/src/main/java/foundation/e/blisslauncher/core/broadcast/WallpaperChangeReceiver.java
index 45bebbc83ff6f888b58430c40ac9b81387160260..2f38553d84006fc2b8f793787d20bc443f210f88 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/broadcast/WallpaperChangeReceiver.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/broadcast/WallpaperChangeReceiver.java
@@ -1,5 +1,7 @@
 package foundation.e.blisslauncher.core.broadcast;
 
+import static android.content.Context.WALLPAPER_SERVICE;
+
 import android.app.WallpaperManager;
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -7,11 +9,8 @@ import android.content.Intent;
 import android.content.IntentFilter;
 import android.os.IBinder;
 import android.view.View;
-
 import foundation.e.blisslauncher.core.blur.BlurWallpaperProvider;
 
-import static android.content.Context.WALLPAPER_SERVICE;
-
 public class WallpaperChangeReceiver extends BroadcastReceiver {
     private final Context mContext;
     private IBinder mWindowToken;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/AbstractFloatingView.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/AbstractFloatingView.java
new file mode 100644
index 0000000000000000000000000000000000000000..612a6f2340f098f14eef4163e02b895d0a8a18be
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/AbstractFloatingView.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2016 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 foundation.e.blisslauncher.core.customviews;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.util.AttributeSet;
+import android.util.Pair;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.LinearLayout;
+
+import androidx.annotation.IntDef;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.features.test.BaseDragLayer;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.features.test.TouchController;
+
+/**
+ * Base class for a View which shows a floating UI on top of the launcher UI.
+ */
+public abstract class AbstractFloatingView extends LinearLayout implements TouchController {
+
+    @IntDef(flag = true, value = {
+        TYPE_TASK_MENU,
+        TYPE_OPTIONS_POPUP,
+        TYPE_LISTENER
+    })
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface FloatingViewType {
+    }
+
+    public static final int TYPE_LISTENER = 1 << 1;
+
+    // Popups related to quickstep UI
+    public static final int TYPE_TASK_MENU = 1 << 2;
+    public static final int TYPE_OPTIONS_POPUP = 1 << 3;
+
+    public static final int TYPE_ALL = TYPE_TASK_MENU | TYPE_OPTIONS_POPUP | TYPE_LISTENER;
+
+    public static final int TYPE_ACCESSIBLE = TYPE_ALL & ~TYPE_LISTENER;
+
+    public static final int TYPE_STATUS_BAR_SWIPE_DOWN_DISALLOW = TYPE_TASK_MENU;
+
+    protected boolean mIsOpen;
+
+    public AbstractFloatingView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public AbstractFloatingView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    /**
+     * We need to handle touch events to prevent them from falling through to the workspace below.
+     */
+    @SuppressLint("ClickableViewAccessibility")
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        return true;
+    }
+
+    public final void close(boolean animate) {
+        animate &= !Utilities.isPowerSaverPreventingAnimation(getContext());
+        handleClose(animate);
+        mIsOpen = false;
+    }
+
+    protected abstract void handleClose(boolean animate);
+
+    public final boolean isOpen() {
+        return mIsOpen;
+    }
+
+    protected void onWidgetsBound() {
+    }
+
+    protected abstract boolean isOfType(@FloatingViewType int type);
+
+    /**
+     * @return Whether the back is consumed. If false, Launcher will handle the back as well.
+     */
+    public boolean onBackPressed() {
+        close(true);
+        return true;
+    }
+
+    @Override
+    public boolean onControllerTouchEvent(MotionEvent ev) {
+        return false;
+    }
+
+    protected Pair<View, String> getAccessibilityTarget() {
+        return null;
+    }
+
+    protected static <T extends AbstractFloatingView> T getOpenView(
+        BaseDraggingActivity activity, @FloatingViewType int type
+    ) {
+        BaseDragLayer dragLayer = activity.getDragLayer();
+        // Iterate in reverse order. AbstractFloatingView is added later to the dragLayer,
+        // and will be one of the last views.
+        for (int i = dragLayer.getChildCount() - 1; i >= 0; i--) {
+            View child = dragLayer.getChildAt(i);
+            if (child instanceof AbstractFloatingView) {
+                AbstractFloatingView view = (AbstractFloatingView) child;
+                if (view.isOfType(type) && view.isOpen()) {
+                    return (T) view;
+                }
+            }
+        }
+        return null;
+    }
+
+    public static void closeOpenContainer(
+        BaseDraggingActivity activity,
+        @FloatingViewType int type
+    ) {
+        AbstractFloatingView view = getOpenView(activity, type);
+        if (view != null) {
+            view.close(true);
+        }
+    }
+
+    public static void closeOpenViews(
+        BaseDraggingActivity activity, boolean animate,
+        @FloatingViewType int type
+    ) {
+        BaseDragLayer dragLayer = activity.getDragLayer();
+        // Iterate in reverse order. AbstractFloatingView is added later to the dragLayer,
+        // and will be one of the last views.
+        for (int i = dragLayer.getChildCount() - 1; i >= 0; i--) {
+            View child = dragLayer.getChildAt(i);
+            if (child instanceof AbstractFloatingView) {
+                AbstractFloatingView abs = (AbstractFloatingView) child;
+                if (abs.isOfType(type)) {
+                    abs.close(animate);
+                }
+            }
+        }
+    }
+
+    public static void closeAllOpenViews(BaseDraggingActivity activity, boolean animate) {
+        closeOpenViews(activity, animate, TYPE_ALL);
+        activity.finishAutoCancelActionMode();
+    }
+
+    public static void closeAllOpenViews(BaseDraggingActivity activity) {
+        closeAllOpenViews(activity, true);
+    }
+
+    public static void closeAllOpenViewsExcept(
+        BaseDraggingActivity activity, boolean animate,
+        @FloatingViewType int type
+    ) {
+        closeOpenViews(activity, animate, TYPE_ALL & ~type);
+        activity.finishAutoCancelActionMode();
+    }
+
+    public static void closeAllOpenViewsExcept(
+        BaseDraggingActivity activity,
+        @FloatingViewType int type
+    ) {
+        closeAllOpenViewsExcept(activity, true, type);
+    }
+
+    public static AbstractFloatingView getTopOpenView(BaseDraggingActivity activity) {
+        return getTopOpenViewWithType(activity, TYPE_ALL);
+    }
+
+    public static AbstractFloatingView getTopOpenViewWithType(
+        BaseDraggingActivity activity,
+        @FloatingViewType int type
+    ) {
+        return getOpenView(activity, type);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/AdaptiveIconDrawableCompat.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/AdaptiveIconDrawableCompat.java
index ee839e7f46c1538c859731be6866ecc3f6a440d0..28cc6e5376332fd1f93294fe79fb20aff6cddccc 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/AdaptiveIconDrawableCompat.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/AdaptiveIconDrawableCompat.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.annotation.SuppressLint;
 import android.content.res.ColorStateList;
 import android.content.res.Resources;
@@ -24,19 +25,15 @@ import android.graphics.drawable.Drawable;
 import android.util.AttributeSet;
 import android.util.DisplayMetrics;
 import android.util.TypedValue;
-
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-
-import org.xmlpull.v1.XmlPullParser;
-import org.xmlpull.v1.XmlPullParserException;
-
+import foundation.e.blisslauncher.core.utils.AdaptiveIconUtils;
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-
-import foundation.e.blisslauncher.core.utils.AdaptiveIconUtils;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
 
 /**
  * <p>This class can also be created via XML inflation using <code>&lt;adaptive-icon></code> tag
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/AppWidgetResizeFrame.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/AppWidgetResizeFrame.java
index 7f34e229e027986cc72538a284feb4d23e0a63b2..c172b052842b0522f97c9a9b4a1037a210fa3134 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/AppWidgetResizeFrame.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/AppWidgetResizeFrame.java
@@ -1,14 +1,13 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.appwidget.AppWidgetHostView;
 import android.appwidget.AppWidgetProviderInfo;
 import android.content.Context;
 import android.graphics.Rect;
 import android.widget.FrameLayout;
 import android.widget.ImageView;
-
 import androidx.annotation.NonNull;
-
 import foundation.e.blisslauncher.R;
 
 public class AppWidgetResizeFrame extends FrameLayout {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlissDragShadowBuilder.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlissDragShadowBuilder.java
index da870aeae2cfe3b26521cc4f5bfa2dff5cf69f9d..7d2c74de0004455b2ae9f07300f2270c47c519f0 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlissDragShadowBuilder.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlissDragShadowBuilder.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.graphics.Canvas;
 import android.graphics.Point;
 import android.util.Log;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlissFrameLayout.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlissFrameLayout.java
index 75793eb0325c8a5fa0af4a830718abb4b9277ef2..01f6051ac6f8612f1d23ca0eb09150b9a8b7136f 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlissFrameLayout.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlissFrameLayout.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.animation.ObjectAnimator;
 import android.content.Context;
 import android.graphics.Canvas;
@@ -203,8 +204,8 @@ public class BlissFrameLayout extends FrameLayout {
         final SquareImageView squareImageView = findViewById(
                 R.id.icon_image_view);
         LinearLayout.LayoutParams layoutParams = (LinearLayout.LayoutParams) icon.getLayoutParams();
-        layoutParams.leftMargin = mDeviceProfile.iconDrawablePaddingPx / 2;
-        layoutParams.rightMargin = mDeviceProfile.iconDrawablePaddingPx / 2;
+//        layoutParams.leftMargin = mDeviceProfile.iconDrawablePaddingPx / 2;
+//        layoutParams.rightMargin = mDeviceProfile.iconDrawablePaddingPx / 2;
         label.setPadding((int) Utilities.pxFromDp(4, mContext),
                 (int) Utilities.pxFromDp(0, mContext),
                 (int) Utilities.pxFromDp(4, mContext),
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlissInput.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlissInput.java
index 659c9e593ae74ac2ce3009e8f663b29ad3fbe36c..56743959a6f66946b12183647146d467e8369036 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlissInput.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlissInput.java
@@ -1,9 +1,9 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.content.Context;
 import android.util.AttributeSet;
 import android.view.DragEvent;
-
 import androidx.appcompat.widget.AppCompatEditText;
 
 public class BlissInput extends AppCompatEditText {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlurBackgroundView.kt b/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlurBackgroundView.kt
index 1022a8982eb1da45b3697b15643105f96c149b45..a63abaa8449a62875c7a89c6a02fd4254e8b279b 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlurBackgroundView.kt
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/BlurBackgroundView.kt
@@ -77,4 +77,4 @@ class BlurBackgroundView(context: Context, attrs: AttributeSet?) : View(context,
     }
 
     override fun setInsets(insets: WindowInsets) {}
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/CustomAnalogClock.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/CustomAnalogClock.java
index 1cb819d9d5fb5b9f84fedbcc84bcfe5e27dfea4f..c8c79a365cd89235d83f823680bd7d35fc50b1d3 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/CustomAnalogClock.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/CustomAnalogClock.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.content.Context;
 import android.content.res.Resources;
 import android.graphics.Canvas;
@@ -7,13 +8,10 @@ import android.graphics.drawable.Drawable;
 import android.os.Handler;
 import android.util.AttributeSet;
 import android.view.View;
-
 import androidx.core.content.ContextCompat;
-
-import java.util.Calendar;
-
 import foundation.e.blisslauncher.BlissLauncher;
 import foundation.e.blisslauncher.R;
+import java.util.Calendar;
 
 /**
  * Created by falcon on 8/3/18.
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/DialOverlay.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/DialOverlay.java
index d3522dda25724be1f66f1595a6410eb26a4ac6ee..ab2d9c73c498fe42cb16f47201348c38a7f8a6af 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/DialOverlay.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/DialOverlay.java
@@ -1,8 +1,8 @@
 package foundation.e.blisslauncher.core.customviews;
 
 
-import android.graphics.Canvas;
 
+import android.graphics.Canvas;
 import java.util.Calendar;
 
 /**
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/DockGridLayout.kt b/app/src/main/java/foundation/e/blisslauncher/core/customviews/DockGridLayout.kt
index 1baf2cc79638fb97b64b6f8c3b156b7feb065044..ead3a75707fbe5f0d563224cad5f3929728872ce 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/DockGridLayout.kt
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/DockGridLayout.kt
@@ -12,10 +12,10 @@ import foundation.e.blisslauncher.core.blur.ShaderBlurDrawable
 import foundation.e.blisslauncher.core.runOnMainThread
 
 class DockGridLayout @JvmOverloads constructor(
-    private val mContext: Context,
+    context: Context,
     attrs: AttributeSet? = null,
     defStyleAttr: Int = 0
-) : GridLayout(mContext, attrs, defStyleAttr), Insettable,
+) : GridLayout(context, attrs, defStyleAttr), Insettable,
     BlurWallpaperProvider.Listener {
     private val blurWallpaperProvider: BlurWallpaperProvider
     private var fullBlurDrawable: ShaderBlurDrawable? = null
@@ -44,13 +44,13 @@ class DockGridLayout @JvmOverloads constructor(
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
-        BlurWallpaperProvider.getInstance(mContext).addListener(this)
+        BlurWallpaperProvider.getInstance(context).addListener(this)
         fullBlurDrawable!!.startListening()
     }
 
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
-        BlurWallpaperProvider.getInstance(mContext).removeListener(this)
+        BlurWallpaperProvider.getInstance(context).removeListener(this)
         fullBlurDrawable!!.stopListening()
     }
 
@@ -75,7 +75,7 @@ class DockGridLayout @JvmOverloads constructor(
 
     override fun setInsets(insets: WindowInsets?) {
         if (insets == null) return
-        val deviceProfile = BlissLauncher.getApplication(mContext).deviceProfile
+        val deviceProfile = BlissLauncher.getApplication(context).deviceProfile
         val lp =
             layoutParams as InsettableRelativeLayout.LayoutParams
         lp.height = deviceProfile.hotseatCellHeightPx + insets.systemWindowInsetBottom
@@ -104,7 +104,7 @@ class DockGridLayout @JvmOverloads constructor(
 
     init {
         setWillNotDraw(false)
-        blurWallpaperProvider = BlurWallpaperProvider.getInstance(mContext)
+        blurWallpaperProvider = BlurWallpaperProvider.getInstance(context)
         createBlurDrawable()
     }
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/HandsOverlay.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/HandsOverlay.java
index 66a1872c033e9df07105acbba8817e52b16fa1b1..ab096c3b00a14ffcb21f65e450e13855f6f38ebf 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/HandsOverlay.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/HandsOverlay.java
@@ -1,10 +1,10 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.content.Context;
 import android.content.res.Resources;
 import android.graphics.Canvas;
 import android.graphics.drawable.Drawable;
-
 import java.util.Calendar;
 
 /**
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/HorizontalPager.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/HorizontalPager.java
index aa8cdf20685d7740151faf1739de51d931b09722..0a1dfe5b2a746cb778c24bc0e91d79a9c2eac8cf 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/HorizontalPager.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/HorizontalPager.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.content.res.TypedArray;
@@ -17,18 +18,15 @@ import android.view.ViewGroup;
 import android.view.ViewParent;
 import android.view.WindowInsets;
 import android.widget.Scroller;
-
 import androidx.core.view.GestureDetectorCompat;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.Set;
-
 import foundation.e.blisslauncher.BlissLauncher;
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.features.launcher.DetectSwipeGestureListener;
 import foundation.e.blisslauncher.features.launcher.LauncherActivity;
 import foundation.e.blisslauncher.features.launcher.OnSwipeDownListener;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Set;
 
 public class HorizontalPager extends ViewGroup implements Insettable {
     private static final String TAG = "HorizontalPager";
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/Insettable.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/Insettable.java
index 91d686b7790e94b225a93e681041a9443139a4e5..54315f79816b4648224f0ff69961edeedae55424 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/Insettable.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/Insettable.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.view.View;
 import android.view.WindowInsets;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/InsettableFrameLayout.kt b/app/src/main/java/foundation/e/blisslauncher/core/customviews/InsettableFrameLayout.kt
index 373db03b4c857e2faec8ce72f484b2ae0fb1f715..8c8b4e68097e46b53d0888d134ac734ef65bb5c3 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/InsettableFrameLayout.kt
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/InsettableFrameLayout.kt
@@ -1,21 +1,104 @@
 package foundation.e.blisslauncher.core.customviews
 
 import android.content.Context
+import android.graphics.Rect
 import android.util.AttributeSet
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
 import android.view.WindowInsets
 import android.widget.FrameLayout
-import foundation.e.blisslauncher.BlissLauncher
+import foundation.e.blisslauncher.R
 
-class InsettableFrameLayout(private val mContext: Context, attrs: AttributeSet?) : FrameLayout(
+open class InsettableFrameLayout(mContext: Context, attrs: AttributeSet?) : FrameLayout(
     mContext, attrs
 ), Insettable {
 
+    var windowInsets: WindowInsets? = null
+
+    val insets: Rect
+        get() {
+            var tempInsets = Rect()
+            if (this.windowInsets != null) {
+                tempInsets.left = this.windowInsets!!.systemWindowInsetLeft
+                tempInsets.top = this.windowInsets!!.systemWindowInsetTop
+                tempInsets.right = this.windowInsets!!.systemWindowInsetRight
+                tempInsets.bottom = this.windowInsets!!.systemWindowInsetBottom
+            }
+            return tempInsets
+        }
+
+    private fun setFrameLayoutChildInsets(child: View, newInsets: WindowInsets?, oldInsets: Rect) {
+        if (newInsets == null) return
+        val lp: FrameLayout.LayoutParams =
+            child.layoutParams as FrameLayout.LayoutParams
+        if (child is Insettable) {
+            Log.i("Insettable", "setIsnets for child")
+            (child as Insettable).setInsets(newInsets)
+        } /*else {
+            lp.topMargin += newInsets.systemWindowInsetTop - oldInsets.top
+            lp.leftMargin += newInsets.systemWindowInsetLeft - oldInsets.left
+            lp.rightMargin += newInsets.systemWindowInsetRight - oldInsets.right
+            lp.bottomMargin += newInsets.systemWindowInsetBottom - oldInsets.bottom
+        }*/
+        child.layoutParams = lp
+    }
+
+    override fun onApplyWindowInsets(insets: WindowInsets?): WindowInsets? {
+        // BlissLauncher.getApplication(mContext).resetDeviceProfile()
+        setInsets(insets)
+        Log.d("InsettableFrameLayout", "On applyWindowInsets insets with: insets = $tag")
+        return insets
+    }
+
     override fun setInsets(insets: WindowInsets?) {
+        Log.d("InsettableFrameLayout", "Setting insets with: insets = $tag")
         if (insets == null) return
-        val deviceProfile = BlissLauncher.getApplication(mContext).deviceProfile
-        setPadding(
-            paddingLeft, paddingTop,
-            paddingRight, paddingBottom + insets.systemWindowInsetBottom
-        )
+        for (i in 0 until childCount) {
+            val child = getChildAt(i)
+            var oldInsets = Rect()
+            if (this.windowInsets != null) {
+                oldInsets.left = this.windowInsets!!.systemWindowInsetLeft
+                oldInsets.top = this.windowInsets!!.systemWindowInsetTop
+                oldInsets.right = this.windowInsets!!.systemWindowInsetRight
+                oldInsets.bottom = this.windowInsets!!.systemWindowInsetBottom
+            }
+            setFrameLayoutChildInsets(child, insets, oldInsets)
+        }
+        this.windowInsets = insets
+    }
+
+    override fun onViewAdded(child: View) {
+        super.onViewAdded(child)
+        setFrameLayoutChildInsets(child, windowInsets, Rect())
+    }
+
+    companion object {
+        fun dispatchInsets(parent: ViewGroup, insets: WindowInsets) {
+            val n = parent.childCount
+            for (i in 0 until n) {
+                val child = parent.getChildAt(i)
+                if (child is Insettable) {
+                    (child as Insettable).setInsets(insets)
+                }
+            }
+        }
+    }
+    open class LayoutParams : FrameLayout.LayoutParams {
+        var ignoreInsets = false
+
+        constructor(c: Context, attrs: AttributeSet?) : super(c, attrs) {
+            val a = c.obtainStyledAttributes(
+                attrs,
+                R.styleable.InsettableFrameLayout_Layout
+            )
+            ignoreInsets = a.getBoolean(
+                R.styleable.InsettableFrameLayout_Layout_layout_ignoreInsets, false
+            )
+            a.recycle()
+        }
+
+        constructor(width: Int, height: Int) : super(width, height) {}
+        constructor(lp: ViewGroup.LayoutParams?) : super(lp!!) {}
     }
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/InsettableRelativeLayout.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/InsettableRelativeLayout.java
index f1122c2ea74c11361f73ffd7569df614e6f4b6db..b8e61530ff49c33f88aa1e8129bf51355c50894c 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/InsettableRelativeLayout.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/InsettableRelativeLayout.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.content.Context;
 import android.content.res.TypedArray;
 import android.util.AttributeSet;
@@ -7,7 +8,6 @@ import android.view.View;
 import android.view.ViewGroup;
 import android.view.WindowInsets;
 import android.widget.RelativeLayout;
-
 import foundation.e.blisslauncher.BlissLauncher;
 import foundation.e.blisslauncher.R;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/InsettableScrollLayout.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/InsettableScrollLayout.java
index 126f21834cc0e55fc31ce435b60b6e1a28955520..3ba485fb2849eef5bb208eaab6b6c7c926c33ae5 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/InsettableScrollLayout.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/InsettableScrollLayout.java
@@ -1,9 +1,9 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.content.Context;
 import android.util.AttributeSet;
 import android.widget.ScrollView;
-
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/LauncherPagedView.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/LauncherPagedView.java
new file mode 100644
index 0000000000000000000000000000000000000000..7dc33ac2b8dead5dfa15a1b3fb83aee923c974be
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/LauncherPagedView.java
@@ -0,0 +1,2410 @@
+package foundation.e.blisslauncher.core.customviews;
+
+import static foundation.e.blisslauncher.core.utils.Constants.ITEM_TYPE_APPLICATION;
+import static foundation.e.blisslauncher.features.test.LauncherState.NORMAL;
+import static foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils.SPRING_LOADED_TRANSITION_MS;
+import static foundation.e.blisslauncher.features.test.dragndrop.DragLayer.ALPHA_INDEX_OVERLAY;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.LayoutTransition;
+import android.animation.ObjectAnimator;
+import android.animation.PropertyValuesHolder;
+import android.animation.ValueAnimator;
+import android.annotation.SuppressLint;
+import android.app.WallpaperManager;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Paint;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.os.UserHandle;
+import android.text.TextUtils;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+import android.view.WindowInsets;
+import android.widget.GridLayout;
+import android.widget.Toast;
+import foundation.e.blisslauncher.BuildConfig;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.customviews.pageindicators.PageIndicatorDots;
+import foundation.e.blisslauncher.core.database.model.ApplicationItem;
+import foundation.e.blisslauncher.core.database.model.FolderItem;
+import foundation.e.blisslauncher.core.database.model.LauncherItem;
+import foundation.e.blisslauncher.core.database.model.ShortcutItem;
+import foundation.e.blisslauncher.core.touch.ItemClickHandler;
+import foundation.e.blisslauncher.core.touch.ItemLongClickListener;
+import foundation.e.blisslauncher.core.utils.Constants;
+import foundation.e.blisslauncher.core.utils.GraphicsUtil;
+import foundation.e.blisslauncher.core.utils.LongArrayMap;
+import foundation.e.blisslauncher.features.launcher.Hotseat;
+import foundation.e.blisslauncher.features.test.Alarm;
+import foundation.e.blisslauncher.features.test.CellLayout;
+import foundation.e.blisslauncher.features.test.IconTextView;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.LauncherStateManager;
+import foundation.e.blisslauncher.features.test.OnAlarmListener;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.features.test.WorkspaceStateTransitionAnimation;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+import foundation.e.blisslauncher.features.test.anim.Interpolators;
+import foundation.e.blisslauncher.features.test.dragndrop.DragController;
+import foundation.e.blisslauncher.features.test.dragndrop.DragOptions;
+import foundation.e.blisslauncher.features.test.dragndrop.DragSource;
+import foundation.e.blisslauncher.features.test.dragndrop.DragView;
+import foundation.e.blisslauncher.features.test.dragndrop.DropTarget;
+import foundation.e.blisslauncher.features.test.dragndrop.SpringLoadedDragController;
+import foundation.e.blisslauncher.features.test.graphics.DragPreviewProvider;
+import java.util.ArrayList;
+import java.util.List;
+import org.jetbrains.annotations.NotNull;
+
+public class LauncherPagedView extends PagedView<PageIndicatorDots> implements View.OnTouchListener,
+    Insettable, DropTarget, DragSource, DragController.DragListener,
+    LauncherStateManager.StateHandler {
+
+    private static final String TAG = "LauncherPagedView";
+    private static final int DEFAULT_PAGE = 0;
+    private static final int SNAP_OFF_EMPTY_SCREEN_DURATION = 400;
+    private static final int FADE_EMPTY_SCREEN_DURATION = 150;
+
+    /**
+     * The value that {@link #mTransitionProgress} must be greater than for
+     * {@link #isFinishedSwitchingState()} ()} to return true.
+     */
+    private static final float FINISHED_SWITCHING_STATE_TRANSITION_PROGRESS = 0.5f;
+
+    private static final boolean MAP_NO_RECURSE = false;
+    private static final boolean MAP_RECURSE = true;
+
+    // The screen id used for the empty screen always present to the right.
+    public static final long EXTRA_EMPTY_SCREEN_ID = -201;
+    // The is the first screen. It is always present, even if its empty.
+    public static final long FIRST_SCREEN_ID = 0;
+    private static final int ADJACENT_SCREEN_DROP_DURATION = 300;
+
+    private final TestActivity mLauncher;
+
+    private LayoutTransition mLayoutTransition;
+    final WallpaperManager mWallpaperManager;
+
+    public final LongArrayMap<CellLayout> mWorkspaceScreens = new LongArrayMap<>();
+    final ArrayList<Long> mScreenOrder = new ArrayList<>();
+
+    // Variables relating to touch disambiguation (scrolling workspace vs. scrolling a widget)
+    private float mXDown;
+    private float mYDown;
+    final static float START_DAMPING_TOUCH_SLOP_ANGLE = (float) Math.PI / 6;
+    final static float MAX_SWIPE_ANGLE = (float) Math.PI / 3;
+    final static float TOUCH_SLOP_DAMPING_FACTOR = 4;
+
+    private final static Paint sPaint = new Paint();
+
+    Runnable mRemoveEmptyScreenRunnable;
+    boolean mDeferRemoveExtraEmptyScreen = false;
+    private boolean mStripScreensOnPageStopMoving = false;
+    private SpringLoadedDragController mSpringLoadedDragController;
+    private DragController mDragController;
+    private boolean mChildrenLayersEnabled = true;
+    private CellLayout.CellInfo mDragInfo;
+    private CellLayout mDragSourceInternal;
+    private DragPreviewProvider mOutlineProvider;
+    private final int[] mTempXY = new int[2];
+    float[] mDragViewVisualCenter = new float[2];
+    private final float[] mTempTouchCoordinates = new float[2];
+    private CellLayout mDropToLayout;
+    private CellLayout mDragTargetLayout;
+    private CellLayout mDragOverlappingLayout;
+    /**
+     * Target drop area calculated during last acceptDrop call.
+     */
+    int[] mTargetCell = new int[2];
+    private int mDragOverX = -1;
+    private int mDragOverY = -1;
+
+    private static final int FOLDER_CREATION_TIMEOUT = 0;
+    public static final int REORDER_TIMEOUT = 650;
+    private final Alarm mFolderCreationAlarm = new Alarm();
+    private final Alarm mReorderAlarm = new Alarm();
+    //private FolderIcon mDragOverFolderIcon = null;
+    private boolean mCreateUserFolderOnDrop = false;
+    private boolean mAddToExistingFolderOnDrop = false;
+    private float mMaxDistanceForFolderCreation;
+
+    // Related to dragging, folder creation and reordering
+    private static final int DRAG_MODE_NONE = 0;
+    private static final int DRAG_MODE_CREATE_FOLDER = 1;
+    private static final int DRAG_MODE_ADD_TO_FOLDER = 2;
+    private static final int DRAG_MODE_REORDER = 3;
+    private int mDragMode = DRAG_MODE_NONE;
+    int mLastReorderX = -1;
+    int mLastReorderY = -1;
+    private IconTextView parentFolderCell;
+    private float mTransitionProgress;
+    private boolean mIsSwitchingState;
+    private boolean mForceDrawAdjacentPages;
+    private WorkspaceStateTransitionAnimation mStateTransitionAnimation;
+
+    // State related to Launcher Overlay
+    TestActivity.LauncherOverlay mLauncherOverlay;
+    boolean mScrollInteractionBegan;
+    boolean mStartedSendingScrollEvents;
+    float mLastOverlayScroll = 0;
+    boolean mOverlayShown = false;
+    private Runnable mOnOverlayHiddenCallback;
+    // Total over scrollX in the overlay direction.
+    private float mOverlayTranslation;
+
+    public LauncherPagedView(Context context, AttributeSet attributeSet) {
+        this(context, attributeSet, 0);
+    }
+
+    public LauncherPagedView(Context context, AttributeSet attributeSet, int defStyle) {
+        super(context, attributeSet, defStyle);
+
+        mLauncher = TestActivity.Companion.getLauncher(context);
+        mStateTransitionAnimation = new WorkspaceStateTransitionAnimation(mLauncher, this);
+        mWallpaperManager = WallpaperManager.getInstance(context);
+        setHapticFeedbackEnabled(false);
+        initWorkspace();
+
+        setMotionEventSplittingEnabled(true);
+        setOnTouchListener((v, event) -> false);
+    }
+
+    private void initWorkspace() {
+        mCurrentPage = DEFAULT_PAGE;
+        setClipToPadding(false);
+        setupLayoutTransition();
+        //setWallpaperDimension();
+    }
+
+    private void setupLayoutTransition() {
+        // We want to show layout transitions when pages are deleted, to close the gap.
+        mLayoutTransition = new LayoutTransition();
+        mLayoutTransition.enableTransitionType(LayoutTransition.DISAPPEARING);
+        mLayoutTransition.enableTransitionType(LayoutTransition.CHANGE_DISAPPEARING);
+        mLayoutTransition.disableTransitionType(LayoutTransition.APPEARING);
+        mLayoutTransition.disableTransitionType(LayoutTransition.CHANGE_APPEARING);
+        setLayoutTransition(mLayoutTransition);
+    }
+
+    void enableLayoutTransitions() {
+        setLayoutTransition(mLayoutTransition);
+    }
+
+    void disableLayoutTransitions() {
+        setLayoutTransition(null);
+    }
+
+    @Override
+    public void onViewAdded(View child) {
+        if (!(child instanceof GridLayout)) {
+            throw new IllegalArgumentException("A Workspace can only have GridLayout children.");
+        }
+        GridLayout grid = (GridLayout) child;
+        //grid.setOnInterceptOnTouchListener(this);
+        super.onViewAdded(child);
+    }
+
+    public boolean isTouchActive() {
+        return mTouchState != TOUCH_STATE_REST;
+    }
+
+    @Override
+    public void setInsets(WindowInsets insets) {
+        mInsets.set(
+            insets.getSystemWindowInsetLeft(),
+            insets.getSystemWindowInsetTop(),
+            insets.getSystemWindowInsetRight(),
+            insets.getSystemWindowInsetBottom()
+        );
+
+        VariantDeviceProfile grid = mLauncher.getDeviceProfile();
+        mMaxDistanceForFolderCreation = (0.55f * grid.getIconSizePx());
+        Rect padding = grid.getWorkspacePadding();
+        setPadding(padding.left, padding.top, padding.right, padding.bottom);
+        int paddingLeftRight = grid.getCellLayoutPaddingLeftRightPx();
+        int paddingBottom = grid.getCellLayoutBottomPaddingPx();
+        for (int i = mWorkspaceScreens.size() - 1; i >= 0; i--) {
+            mWorkspaceScreens.valueAt(i)
+                .setPadding(paddingLeftRight, 0, paddingLeftRight, paddingBottom);
+        }
+    }
+
+    public void deferRemoveExtraEmptyScreen() {
+        mDeferRemoveExtraEmptyScreen = true;
+    }
+
+    public void bindAndInitFirstScreen(View view) {
+        // Do nothing here.
+    }
+
+    public void removeAllWorkspaceScreens() {
+        // Disable all layout transitions before removing all pages to ensure that we don't get the
+        // transition animations competing with us changing the scroll when we add pages
+        disableLayoutTransitions();
+
+        // Remove the pages and clear the screen models
+        //removeFolderListeners();
+        removeAllViews();
+        mScreenOrder.clear();
+        mWorkspaceScreens.clear();
+
+        // Ensure that the first page is always present
+        //bindAndInitFirstScreen(qsb);
+
+        // Re-enable the layout transitions
+        enableLayoutTransitions();
+    }
+
+    public void insertNewWorkspaceScreenBeforeEmptyScreen(long screenId) {
+        // Find the index to insert this view into.  If the empty screen exists, then
+        // insert it before that.
+        int insertIndex = mScreenOrder.indexOf(EXTRA_EMPTY_SCREEN_ID);
+        if (insertIndex < 0) {
+            insertIndex = mScreenOrder.size();
+        }
+        insertNewWorkspaceScreen(screenId, insertIndex);
+    }
+
+    public void bindItems(@NotNull List<? extends LauncherItem> launcherItems) {
+        removeAllWorkspaceScreens();
+        GridLayout workspaceScreen = insertNewWorkspaceScreen(0);
+        for (LauncherItem launcherItem : launcherItems) {
+            IconTextView appView = (IconTextView) LayoutInflater.from(getContext())
+                .inflate(R.layout.app_icon, null, false);
+            appView.applyFromShortcutItem(launcherItem);
+            appView.setOnClickListener(ItemClickHandler.INSTANCE);
+            appView.setOnLongClickListener(ItemLongClickListener.INSTANCE_WORKSPACE);
+            if (launcherItem.container == Constants.CONTAINER_DESKTOP) {
+                if (workspaceScreen.getChildCount() >= mLauncher.getDeviceProfile().getInv()
+                    .getNumRows() * mLauncher.getDeviceProfile().getInv().getNumColumns()
+                    || launcherItem.screenId > mScreenOrder.size() - 1) {
+                    workspaceScreen = insertNewWorkspaceScreen(mScreenOrder.size());
+                }
+                launcherItem.screenId = mScreenOrder.size() - 1;
+                launcherItem.cell = workspaceScreen.getChildCount();
+                Log.d(
+                    TAG,
+                    "launcherItemCell " + launcherItem.cell % mLauncher.getDeviceProfile().getInv()
+                        .getNumColumns() + " " + launcherItem.cell % mLauncher.getDeviceProfile()
+                        .getInv().getNumRows() + " " + launcherItem.cell
+                );
+                GridLayout.Spec rowSpec = GridLayout.spec(GridLayout.UNDEFINED);
+                GridLayout.Spec colSpec = GridLayout.spec(GridLayout.UNDEFINED);
+                GridLayout.LayoutParams iconLayoutParams =
+                    new GridLayout.LayoutParams(rowSpec, colSpec);
+                iconLayoutParams.height = mLauncher.getDeviceProfile().getCellHeightPx();
+                iconLayoutParams.width = mLauncher.getDeviceProfile().getCellWidthPx();
+                iconLayoutParams.setGravity(Gravity.CENTER);
+                appView.setLayoutParams(iconLayoutParams);
+                appView.setTextVisibility(true);
+                //appView.setWithText(true);
+                Log.i(TAG, "bindItems: " + appView);
+                workspaceScreen.addView(appView);
+            } else if (launcherItem.container == Constants.CONTAINER_HOTSEAT) {
+                //appView.findViewById(R.id.app_label).setVisibility(GONE);
+                GridLayout.Spec rowSpec = GridLayout.spec(GridLayout.UNDEFINED);
+                GridLayout.Spec colSpec = GridLayout.spec(GridLayout.UNDEFINED);
+                GridLayout.LayoutParams iconLayoutParams =
+                    new GridLayout.LayoutParams(rowSpec, colSpec);
+                iconLayoutParams.setGravity(Gravity.CENTER);
+                iconLayoutParams.height = mLauncher.getDeviceProfile().getHotseatCellHeightPx();
+                iconLayoutParams.width = mLauncher.getDeviceProfile().getCellWidthPx();
+                appView.setLayoutParams(iconLayoutParams);
+                //appView.setWithText(false);
+                mLauncher.getHotseat().getLayout().addView(appView);
+            }
+        }
+    }
+
+    public GridLayout insertNewWorkspaceScreen(long screenId) {
+        return insertNewWorkspaceScreen(screenId, getChildCount());
+    }
+
+    public GridLayout insertNewWorkspaceScreen(long screenId, int insertIndex) {
+        if (mWorkspaceScreens.containsKey(screenId)) {
+            throw new RuntimeException("Screen id " + screenId + " already exists!");
+        }
+
+        // Inflate the cell layout, but do not add it automatically so that we can get the newly
+        // created CellLayout.
+        CellLayout newScreen = (CellLayout) LayoutInflater.from(getContext()).inflate(
+            R.layout.workspace_screen, this, false /* attachToRoot */);
+        int paddingLeftRight = mLauncher.getDeviceProfile().getCellLayoutPaddingLeftRightPx();
+        int paddingBottom = mLauncher.getDeviceProfile().getCellLayoutBottomPaddingPx();
+        newScreen.setPadding(paddingLeftRight, 0, paddingLeftRight, paddingBottom);
+        newScreen.setRowCount(mLauncher.getDeviceProfile().getInv().getNumRows());
+        newScreen.setColumnCount(mLauncher.getDeviceProfile().getInv().getNumColumns());
+
+        mWorkspaceScreens.put(screenId, newScreen);
+        mScreenOrder.add(insertIndex, screenId);
+        addView(newScreen, insertIndex);
+        /*mStateTransitionAnimation.applyChildState(
+            mLauncher.getStateManager().getState(), newScreen, insertIndex);*/
+
+        return newScreen;
+    }
+
+    public void addExtraEmptyScreenOnDrag() {
+        boolean lastChildOnScreen = false;
+        boolean childOnFinalScreen = false;
+
+        // Cancel any pending removal of empty screen
+        mRemoveEmptyScreenRunnable = null;
+
+        if (mDragSourceInternal != null) {
+            if (mDragSourceInternal.getChildCount() == 1) {
+                lastChildOnScreen = true;
+            }
+            CellLayout cl = (CellLayout) mDragSourceInternal;
+            if (indexOfChild(cl) == getChildCount() - 1) {
+                childOnFinalScreen = true;
+            }
+        }
+
+        // If this is the last item on the final screen
+        if (lastChildOnScreen && childOnFinalScreen) {
+            return;
+        }
+        if (!mWorkspaceScreens.containsKey(EXTRA_EMPTY_SCREEN_ID)) {
+            insertNewWorkspaceScreen(EXTRA_EMPTY_SCREEN_ID);
+        }
+    }
+
+    public boolean addExtraEmptyScreen() {
+        if (!mWorkspaceScreens.containsKey(EXTRA_EMPTY_SCREEN_ID)) {
+            insertNewWorkspaceScreen(EXTRA_EMPTY_SCREEN_ID);
+            return true;
+        }
+        return false;
+    }
+
+    private void convertFinalScreenToEmptyScreenIfNecessary() {
+        if (mLauncher.isWorkspaceLoading()) {
+            // Invalid and dangerous operation if workspace is loading
+            return;
+        }
+
+        if (hasExtraEmptyScreen() || mScreenOrder.size() == 0) return;
+        long finalScreenId = mScreenOrder.get(mScreenOrder.size() - 1);
+
+        CellLayout finalScreen = mWorkspaceScreens.get(finalScreenId);
+
+        // If the final screen is empty, convert it to the extra empty screen
+        if (finalScreen.getChildCount() == 0) {
+            mWorkspaceScreens.remove(finalScreenId);
+            mScreenOrder.remove(finalScreenId);
+
+            // if this is the last screen, convert it to the empty screen
+            mWorkspaceScreens.put(EXTRA_EMPTY_SCREEN_ID, finalScreen);
+            mScreenOrder.add(EXTRA_EMPTY_SCREEN_ID);
+
+            // Update the model if we have changed any screens
+            //TODO: LauncherModel.updateWorkspaceScreenOrder(mLauncher, mScreenOrder);
+        }
+    }
+
+    public void removeExtraEmptyScreen(final boolean animate, boolean stripEmptyScreens) {
+        removeExtraEmptyScreenDelayed(animate, null, 0, stripEmptyScreens);
+    }
+
+    public void removeExtraEmptyScreenDelayed(
+        final boolean animate, final Runnable onComplete,
+        final int delay, final boolean stripEmptyScreens
+    ) {
+        if (mLauncher.isWorkspaceLoading()) {
+            // Don't strip empty screens if the workspace is still loading
+            return;
+        }
+
+        if (delay > 0) {
+            postDelayed(() -> removeExtraEmptyScreenDelayed(
+                animate,
+                onComplete,
+                0,
+                stripEmptyScreens
+            ), delay);
+            return;
+        }
+
+        convertFinalScreenToEmptyScreenIfNecessary();
+        if (hasExtraEmptyScreen()) {
+            int emptyIndex = mScreenOrder.indexOf(EXTRA_EMPTY_SCREEN_ID);
+            if (getNextPage() == emptyIndex) {
+                snapToPage(getNextPage() - 1, SNAP_OFF_EMPTY_SCREEN_DURATION);
+                fadeAndRemoveEmptyScreen(SNAP_OFF_EMPTY_SCREEN_DURATION, FADE_EMPTY_SCREEN_DURATION,
+                    onComplete, stripEmptyScreens
+                );
+            } else {
+                snapToPage(getNextPage(), 0);
+                fadeAndRemoveEmptyScreen(0, FADE_EMPTY_SCREEN_DURATION,
+                    onComplete, stripEmptyScreens
+                );
+            }
+            return;
+        } else if (stripEmptyScreens) {
+            // If we're not going to strip the empty screens after removing
+            // the extra empty screen, do it right away.
+            stripEmptyScreens();
+        }
+
+        if (onComplete != null) {
+            onComplete.run();
+        }
+    }
+
+    private void fadeAndRemoveEmptyScreen(
+        int delay, int duration, final Runnable onComplete,
+        final boolean stripEmptyScreens
+    ) {
+        // XXX: Do we need to update LM workspace screens below?
+        PropertyValuesHolder alpha = PropertyValuesHolder.ofFloat("alpha", 0f);
+        PropertyValuesHolder bgAlpha = PropertyValuesHolder.ofFloat("backgroundAlpha", 0f);
+
+        final GridLayout cl = mWorkspaceScreens.get(EXTRA_EMPTY_SCREEN_ID);
+
+        mRemoveEmptyScreenRunnable = () -> {
+            if (hasExtraEmptyScreen()) {
+                mWorkspaceScreens.remove(EXTRA_EMPTY_SCREEN_ID);
+                mScreenOrder.remove(EXTRA_EMPTY_SCREEN_ID);
+                removeView(cl);
+                if (stripEmptyScreens) {
+                    stripEmptyScreens();
+                }
+                // Update the page indicator to reflect the removed page.
+                showPageIndicatorAtCurrentScroll();
+            }
+        };
+
+        ObjectAnimator oa = ObjectAnimator.ofPropertyValuesHolder(cl, alpha, bgAlpha);
+        oa.setDuration(duration);
+        oa.setStartDelay(delay);
+        oa.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                if (mRemoveEmptyScreenRunnable != null) {
+                    mRemoveEmptyScreenRunnable.run();
+                }
+                if (onComplete != null) {
+                    onComplete.run();
+                }
+            }
+        });
+        oa.start();
+    }
+
+    public boolean hasExtraEmptyScreen() {
+        return mWorkspaceScreens.containsKey(EXTRA_EMPTY_SCREEN_ID) && getChildCount() > 1;
+    }
+
+    public long commitExtraEmptyScreen() {
+        if (mLauncher.isWorkspaceLoading()) {
+            // Invalid and dangerous operation if workspace is loading
+            return -1;
+        }
+
+        CellLayout cl = mWorkspaceScreens.get(EXTRA_EMPTY_SCREEN_ID);
+        mWorkspaceScreens.remove(EXTRA_EMPTY_SCREEN_ID);
+        mScreenOrder.remove(EXTRA_EMPTY_SCREEN_ID);
+
+        long newId = mScreenOrder.size();
+        mWorkspaceScreens.put(newId, cl);
+        mScreenOrder.add(newId);
+
+        // Update the model for the new screen
+        //TODO: LauncherModel.updateWorkspaceScreenOrder(mLauncher, mScreenOrder);
+
+        return newId;
+    }
+
+    public CellLayout getScreenWithId(long screenId) {
+        return mWorkspaceScreens.get(screenId);
+    }
+
+    public long getIdForScreen(CellLayout layout) {
+        int index = mWorkspaceScreens.indexOfValue(layout);
+        if (index != -1) {
+            return mWorkspaceScreens.keyAt(index);
+        }
+        return -1;
+    }
+
+    /**
+     * Converts an AppItem into a View object that can be rendered inside
+     * the pages and the mDock.
+     * <p>
+     * The View object also has all the required listeners attached to it.
+     */
+    @SuppressLint({"InflateParams", "ClickableViewAccessibility"})
+    private BlissFrameLayout prepareLauncherItem(final LauncherItem launcherItem) {
+        final BlissFrameLayout iconView = (BlissFrameLayout) mLauncher.getLayoutInflater().inflate(
+            R.layout.app_view,
+            null
+        );
+
+        iconView.setLauncherItem(launcherItem);
+        final SquareFrameLayout icon = iconView.findViewById(R.id.app_icon);
+        if (launcherItem.itemType == Constants.ITEM_TYPE_FOLDER) {
+            iconView.applyBadge(
+                false,
+                launcherItem.container != Constants.CONTAINER_HOTSEAT
+            );
+        } else if (launcherItem.itemType == ITEM_TYPE_APPLICATION) {
+            ApplicationItem applicationItem = (ApplicationItem) launcherItem;
+            iconView.applyBadge(
+                false,
+                launcherItem.container != Constants.CONTAINER_HOTSEAT
+            );
+        }
+
+        /*icon.setOnLongClickListener(view -> {
+            handleWobbling(true);
+            longPressed = true;
+            return true;
+        });
+
+        icon.setOnTouchListener(new View.OnTouchListener() {
+            long iconPressedAt = 0;
+
+            @Override
+            public boolean onTouch(View view, MotionEvent event) {
+                if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
+                    if (!mLongClickStartsDrag) {
+                        iconPressedAt = System.currentTimeMillis();
+                    }
+                } else if (event.getActionMasked() == MotionEvent.ACTION_MOVE) {
+                    if (longPressed || (!mLongClickStartsDrag
+                        && (System.currentTimeMillis() - iconPressedAt) > 150)) {
+                        longPressed = false;
+                        movingApp = iconView;
+                        dragShadowBuilder = new BlissDragShadowBuilder(
+                            icon, (event.getX() < 0 ? 0 : event.getX()),
+                            (event.getY() < 0 ? 0 : event.getY())
+                        );
+                        icon.startDrag(null, dragShadowBuilder, iconView, 0);
+                        if (iconView.getParent().getParent() instanceof HorizontalPager) {
+                            parentPage = getCurrentAppsPageNumber();
+                        } else {
+                            parentPage = -99;
+                        }
+                        iconView.clearAnimation();
+                        movingApp.setVisibility(View.INVISIBLE);
+                        dragDropEnabled = true;
+                    }
+                } else if (event.getAction() == MotionEvent.ACTION_UP) {
+                    new Handler(Looper.getMainLooper()).post(() -> {
+                        if (movingApp != null && movingApp.getVisibility() != VISIBLE) {
+                            movingApp.setVisibility(VISIBLE);
+                            movingApp.invalidate();
+                        }
+                    });
+                    return false;
+                }
+                return false;
+            }
+        });
+
+        icon.setOnClickListener(view -> {
+            if (isWobbling) {
+                handleWobbling(false);
+                return;
+            }
+
+            if (launcherItem.itemType != Constants.ITEM_TYPE_FOLDER) {
+                startActivitySafely(getApplicationContext(), launcherItem, view);
+            } else {
+                folderFromDock = !(iconView.getParent().getParent() instanceof HorizontalPager);
+                displayFolder((FolderItem) launcherItem, iconView);
+            }
+        });*/
+
+        return iconView;
+    }
+
+    public int getPageIndexForScreenId(long screenId) {
+        return indexOfChild(mWorkspaceScreens.get(screenId));
+    }
+
+    public long getScreenIdForPageIndex(int index) {
+        if (0 <= index && index < mScreenOrder.size()) {
+            return mScreenOrder.get(index);
+        }
+        return -1;
+    }
+
+    public ArrayList<Long> getScreenOrder() {
+        return mScreenOrder;
+    }
+
+    public void stripEmptyScreens() {
+        if (mLauncher.isWorkspaceLoading()) {
+            // Don't strip empty screens if the workspace is still loading.
+            // This is dangerous and can result in data loss.
+            return;
+        }
+
+        if (isPageInTransition()) {
+            mStripScreensOnPageStopMoving = true;
+            return;
+        }
+
+        int currentPage = getNextPage();
+        ArrayList<Long> removeScreens = new ArrayList<>();
+        int total = mWorkspaceScreens.size();
+        for (int i = 0; i < total; i++) {
+            long id = mWorkspaceScreens.keyAt(i);
+            GridLayout cl = mWorkspaceScreens.valueAt(i);
+            removeScreens.add(id);
+        }
+
+        // We enforce at least one page to add new items to. In the case that we remove the last
+        // such screen, we convert the last screen to the empty screen
+        int minScreens = 1;
+
+        int pageShift = 0;
+        for (Long id : removeScreens) {
+            CellLayout cl = mWorkspaceScreens.get(id);
+            mWorkspaceScreens.remove(id);
+            mScreenOrder.remove(id);
+
+            if (getChildCount() > minScreens) {
+                if (indexOfChild(cl) < currentPage) {
+                    pageShift++;
+                }
+
+                removeView(cl);
+            } else {
+                // if this is the last screen, convert it to the empty screen
+                mRemoveEmptyScreenRunnable = null;
+                mWorkspaceScreens.put(EXTRA_EMPTY_SCREEN_ID, cl);
+                mScreenOrder.add(EXTRA_EMPTY_SCREEN_ID);
+            }
+        }
+
+        if (!removeScreens.isEmpty()) {
+            // Update the model if we have changed any screens
+            //TODO: LauncherModel.updateWorkspaceScreenOrder(mLauncher, mScreenOrder);
+        }
+
+        if (pageShift >= 0) {
+            setCurrentPage(currentPage - pageShift);
+        }
+    }
+
+    /**
+     * Adds the specified child in the specified screen. The position and dimension of
+     * the child are defined by x, y, spanX and spanY.
+     *
+     * @param child    The child to add in one of the workspace's screens.
+     * @param screenId The screen in which to add the child.
+     * @param x        The X position of the child in the screen's grid.
+     * @param y        The Y position of the child in the screen's grid.
+     */
+    private void addInScreen(View child, long container, long screenId, int x, int y) {
+        Log.d(
+            TAG,
+            "addInScreen() called with: child = [" + child + "], container = [" + container + "], screenId = [" + screenId + "], x = [" + x + "], y = [" + y + "]"
+        );
+        addInScreen(
+            child,
+            container,
+            screenId,
+            y * mLauncher.getDeviceProfile().getInv().getNumColumns() + x
+        );
+    }
+
+    /**
+     * Adds the specified child in the specified screen. The position and dimension of
+     * the child are defined by x, y, spanX and spanY.
+     *
+     * @param child    The child to add in one of the workspace's screens.
+     * @param screenId The screen in which to add the child.
+     * @param index    The index of the child in grid.
+     */
+    private void addInScreen(View child, long container, long screenId, int index) {
+        if (container == Constants.CONTAINER_DESKTOP) {
+            if (getScreenWithId(screenId) == null) {
+                Log.e(TAG, "Skipping child, screenId " + screenId + " not found");
+                // DEBUGGING - Print out the stack trace to see where we are adding from
+                new Throwable().printStackTrace();
+                return;
+            }
+        }
+        if (screenId == EXTRA_EMPTY_SCREEN_ID) {
+            // This should never happen
+            throw new RuntimeException("Screen id should not be EXTRA_EMPTY_SCREEN_ID");
+        }
+
+        final CellLayout layout;
+        if (container == Constants.CONTAINER_HOTSEAT) {
+            layout = mLauncher.getHotseat().getLayout();
+
+            // Hide folder title in the hotseat
+            //TODO: Enable when supporting folders
+            /*if (child instanceof FolderIcon) {
+                ((FolderIcon) child).setTextVisible(false);
+            }*/
+        } else {
+            // Show folder title if not in the hotseat
+            //TODO: Enable when supporting folders
+            /*if (child instanceof FolderIcon) {
+                ((FolderIcon) child).setTextVisible(true);
+            }*/
+            layout = getScreenWithId(screenId);
+        }
+
+        ViewGroup.LayoutParams genericLp = child.getLayoutParams();
+        GridLayout.Spec rowSpec = GridLayout.spec(GridLayout.UNDEFINED);
+        GridLayout.Spec colSpec = GridLayout.spec(GridLayout.UNDEFINED);
+        CellLayout.LayoutParams lp;
+        if (!(genericLp instanceof CellLayout.LayoutParams)) {
+            lp = new GridLayout.LayoutParams(rowSpec, colSpec);
+        } else {
+            lp = (CellLayout.LayoutParams) genericLp;
+            lp.rowSpec = GridLayout.spec(GridLayout.UNDEFINED);
+            lp.columnSpec = GridLayout.spec(GridLayout.UNDEFINED);
+        }
+        lp.setGravity(Gravity.CENTER);
+
+        // Get the canonical child id to uniquely represent this view in this screen
+        LauncherItem info = (LauncherItem) child.getTag();
+        int childId = mLauncher.getViewIdForItem(info);
+
+        //boolean markCellsAsOccupied = !(child instanceof Folder);
+        boolean markCellsAsOccupied = true;
+        if (!layout.addViewToCellLayout(
+            child,
+            index,
+            childId,
+            lp,
+            markCellsAsOccupied
+        )) {
+            // TODO: This branch occurs when the workspace is adding views
+            // outside of the defined grid
+            // maybe we should be deleting these items from the LauncherModel?
+        }
+
+        child.setHapticFeedbackEnabled(false);
+        child.setOnLongClickListener(ItemLongClickListener.INSTANCE_WORKSPACE);
+        if (child instanceof DropTarget) {
+            mDragController.addDropTarget((DropTarget) child);
+        }
+    }
+
+    public void addInScreenFromBind(View child, LauncherItem info) {
+        mWorkspaceScreens.get(info.screenId).addView(child);
+    }
+
+    /**
+     * Called directly from a CellLayout (not by the framework), after we've been added as a
+     * listener via setOnInterceptTouchEventListener(). This allows us to tell the CellLayout
+     * that it should intercept touch events, which is not something that is normally supported.
+     */
+    @SuppressLint("ClickableViewAccessibility")
+    @Override
+    public boolean onTouch(View v, MotionEvent event) {
+        return shouldConsumeTouch(v);
+    }
+
+    private boolean shouldConsumeTouch(View v) {
+        return !workspaceIconsCanBeDragged()
+            || (!workspaceInModalState() && indexOfChild(v) != mCurrentPage);
+    }
+
+    public boolean isSwitchingState() {
+        return mIsSwitchingState;
+    }
+
+    private boolean workspaceInModalState() {
+        return !mLauncher.isInState(NORMAL);
+    }
+
+    /**
+     * Returns whether a drag should be allowed to be started from the current workspace state.
+     */
+    public boolean workspaceIconsCanBeDragged() {
+        return mLauncher.getStateManager().getState().workspaceIconsCanBeDragged;
+    }
+
+    /**
+     * This differs from isSwitchingState in that we take into account how far the transition
+     * has completed.
+     */
+    public boolean isFinishedSwitchingState() {
+        return !mIsSwitchingState
+            || (mTransitionProgress > FINISHED_SWITCHING_STATE_TRANSITION_PROGRESS);
+    }
+
+    @Override
+    public boolean dispatchUnhandledMove(View focused, int direction) {
+        return super.dispatchUnhandledMove(focused, direction);
+    }
+
+    @Override
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        if (ev.getActionMasked() == MotionEvent.ACTION_DOWN) {
+            mXDown = ev.getX();
+            mYDown = ev.getY();
+        }
+        return super.onInterceptTouchEvent(ev);
+    }
+
+    @Override
+    protected void determineScrollingStart(MotionEvent ev) {
+        float deltaX = ev.getX() - mXDown;
+        float absDeltaX = Math.abs(deltaX);
+        float absDeltaY = Math.abs(ev.getY() - mYDown);
+
+        if (Float.compare(absDeltaX, 0f) == 0) return;
+
+        float slope = absDeltaY / absDeltaX;
+        float theta = (float) Math.atan(slope);
+
+        if (absDeltaX > mTouchSlop || absDeltaY > mTouchSlop) {
+            cancelCurrentPageLongPress();
+        }
+
+        if (theta > MAX_SWIPE_ANGLE) {
+            // Above MAX_SWIPE_ANGLE, we don't want to ever start scrolling the workspace
+            return;
+        } else if (theta > START_DAMPING_TOUCH_SLOP_ANGLE) {
+            // Above START_DAMPING_TOUCH_SLOP_ANGLE and below MAX_SWIPE_ANGLE, we want to
+            // increase the touch slop to make it harder to begin scrolling the workspace. This
+            // results in vertically scrolling widgets to more easily. The higher the angle, the
+            // more we increase touch slop.
+            theta -= START_DAMPING_TOUCH_SLOP_ANGLE;
+            float extraRatio = (float)
+                Math.sqrt((theta / (MAX_SWIPE_ANGLE - START_DAMPING_TOUCH_SLOP_ANGLE)));
+            super.determineScrollingStart(ev, 1 + TOUCH_SLOP_DAMPING_FACTOR * extraRatio);
+        } else {
+            // Below START_DAMPING_TOUCH_SLOP_ANGLE, we don't do anything special
+            super.determineScrollingStart(ev);
+        }
+    }
+
+    protected void onPageBeginTransition() {
+        super.onPageBeginTransition();
+        updateChildrenLayersEnabled();
+    }
+
+    protected void onPageEndTransition() {
+        super.onPageEndTransition();
+        updateChildrenLayersEnabled();
+
+        if (mDragController.isDragging()) {
+            /*if (workspaceInModalState()) {
+                // If we are in springloaded mode, then force an event to check if the current touch
+                // is under a new page (to scroll to)
+                mDragController.forceTouchMove();
+            }*/
+        }
+
+        if (mStripScreensOnPageStopMoving) {
+            stripEmptyScreens();
+            mStripScreensOnPageStopMoving = false;
+        }
+    }
+
+    public void moveToDefaultScreen() {
+        int page = DEFAULT_PAGE;
+        if (getNextPage() != page) {
+            snapToPage(page);
+        }
+        View child = getChildAt(page);
+        if (child != null) {
+            child.requestFocus();
+        }
+    }
+
+    @Override
+    public int getExpectedHeight() {
+        return getMeasuredHeight() <= 0 || !mIsLayoutValid
+            ? mLauncher.getDeviceProfile().getHeightPx() : getMeasuredHeight();
+    }
+
+    @Override
+    public int getExpectedWidth() {
+        return getMeasuredWidth() <= 0 || !mIsLayoutValid
+            ? mLauncher.getDeviceProfile().getWidthPx() : getMeasuredWidth();
+    }
+
+    private void updateChildrenLayersEnabled() {
+        boolean enableChildrenLayers = mIsSwitchingState || isPageInTransition();
+
+        if (enableChildrenLayers != mChildrenLayersEnabled) {
+            mChildrenLayersEnabled = enableChildrenLayers;
+            if (mChildrenLayersEnabled) {
+                enableHwLayersOnVisiblePages();
+            } else {
+                for (int i = 0; i < getPageCount(); i++) {
+                    final GridLayout grid = (GridLayout) getChildAt(i);
+                    grid.setLayerType(LAYER_TYPE_NONE, sPaint);
+                }
+            }
+        }
+    }
+
+    private void enableHwLayersOnVisiblePages() {
+        if (mChildrenLayersEnabled) {
+            final int screenCount = getChildCount();
+
+            final int[] visibleScreens = getVisibleChildrenRange();
+            int leftScreen = visibleScreens[0];
+            int rightScreen = visibleScreens[1];
+
+            if (mForceDrawAdjacentPages) {
+                // In overview mode, make sure that the two side pages are visible.
+                leftScreen = Utilities.boundToRange(getCurrentPage() - 1, 0, rightScreen);
+                rightScreen = Utilities.boundToRange(getCurrentPage() + 1,
+                    leftScreen, getPageCount() - 1
+                );
+            }
+
+            if (leftScreen == rightScreen) {
+                // make sure we're caching at least two pages always
+                if (rightScreen < screenCount - 1) {
+                    rightScreen++;
+                } else if (leftScreen > 0) {
+                    leftScreen--;
+                }
+            }
+
+            for (int i = 0; i < screenCount; i++) {
+                final GridLayout layout = (GridLayout) getPageAt(i);
+                // enable layers between left and right screen inclusive.
+                boolean enableLayer = leftScreen <= i && i <= rightScreen;
+                layout.setLayerType(enableLayer ? LAYER_TYPE_HARDWARE : LAYER_TYPE_NONE, sPaint);
+            }
+        }
+    }
+
+    public void setup(@NotNull DragController dragController) {
+        mSpringLoadedDragController = new SpringLoadedDragController(mLauncher);
+        mDragController = dragController;
+
+        // hardware layers on children are enabled on startup, but should be disabled until
+        // needed
+        updateChildrenLayersEnabled();
+    }
+
+    protected void onScrollInteractionBegin() {
+        super.onScrollInteractionBegin();
+        mScrollInteractionBegan = true;
+    }
+
+    protected void onScrollInteractionEnd() {
+        super.onScrollInteractionEnd();
+        mScrollInteractionBegan = false;
+        if (mStartedSendingScrollEvents) {
+            mStartedSendingScrollEvents = false;
+            mLauncherOverlay.onScrollInteractionEnd();
+        }
+    }
+
+    public void setLauncherOverlay(TestActivity.LauncherOverlay overlay) {
+        mLauncherOverlay = overlay;
+        // A new overlay has been set. Reset event tracking
+        mStartedSendingScrollEvents = false;
+        onOverlayScrollChanged(0);
+    }
+
+    private boolean isScrollingOverlay() {
+        return mLauncherOverlay != null &&
+            ((mIsRtl && getUnboundedScrollX() > mMaxScroll)
+                || (!mIsRtl && getUnboundedScrollX() <mMinScroll));
+    }
+
+    @Override
+    protected void snapToDestination() {
+        // If we're overscrolling the overlay, we make sure to immediately reset the PagedView
+        // to it's baseline position instead of letting the overscroll settle. The overlay handles
+        // it's own settling, and every gesture to the overlay should be self-contained and start
+        // from 0, so we zero it out here.
+        if (isScrollingOverlay()) {
+            // We reset mWasInOverscroll so that PagedView doesn't zero out the overscroll
+            // interaction when we call snapToPageImmediately.
+            mWasInOverscroll = false;
+            snapToPageImmediately(0);
+        } else {
+            super.snapToDestination();
+        }
+    }
+
+    @Override
+    public boolean scrollLeft() {
+        boolean result = false;
+        if (!workspaceInModalState() && !mIsSwitchingState) {
+            result = super.scrollLeft();
+        }
+        // TODO: Fix this asap
+        /*Folder openFolder = Folder.getOpen(mLauncher);
+        if (openFolder != null) {
+            openFolder.completeDragExit();
+        }*/
+        return result;
+    }
+
+    @Override
+    public boolean scrollRight() {
+        boolean result = false;
+        if (!workspaceInModalState() && !mIsSwitchingState) {
+            result = super.scrollRight();
+        }
+        // TODO: Fix this asap
+        /*Folder openFolder = Folder.getOpen(mLauncher);
+        if (openFolder != null) {
+            openFolder.completeDragExit();
+        }*/
+        return result;
+    }
+
+    @Override
+    protected void onScrollChanged(int l, int t, int oldl, int oldt) {
+        super.onScrollChanged(l, t, oldl, oldt);
+
+        // Update the page indicator progress.
+        boolean isTransitioning =
+            mIsSwitchingState || (getLayoutTransition() != null && getLayoutTransition()
+                .isRunning());
+        if (!isTransitioning) {
+            showPageIndicatorAtCurrentScroll();
+        }
+
+        //updatePageAlphaValues();
+        enableHwLayersOnVisiblePages();
+    }
+
+    public void showPageIndicatorAtCurrentScroll() {
+        if (mPageIndicator != null) {
+            mPageIndicator.setScroll(getScrollX(), computeMaxScrollX());
+        }
+    }
+
+    @Override
+    protected void overScroll(int amount) {
+        boolean shouldScrollOverlay = mLauncherOverlay != null && !mScroller.isSpringing() &&
+            ((amount <= 0 && !mIsRtl) || (amount >= 0 && mIsRtl));
+
+        boolean shouldZeroOverlay = mLauncherOverlay != null && mLastOverlayScroll != 0 &&
+            ((amount >= 0 && !mIsRtl) || (amount <= 0 && mIsRtl));
+
+        if (shouldScrollOverlay) {
+            if (!mStartedSendingScrollEvents && mScrollInteractionBegan) {
+                mStartedSendingScrollEvents = true;
+                mLauncherOverlay.onScrollInteractionBegin();
+            }
+
+            mLastOverlayScroll = Math.abs(((float) amount) / getMeasuredWidth());
+            mLauncherOverlay.onScrollChange(mLastOverlayScroll, mIsRtl);
+        } else {
+            dampedOverScroll(amount);
+        }
+
+        if (shouldZeroOverlay) {
+            mLauncherOverlay.onScrollChange(0, mIsRtl);
+        }
+    }
+
+    @Override
+    protected boolean shouldFlingForVelocity(int velocityX) {
+        // When the overlay is moving, the fling or settle transition is controlled by the overlay.
+        return Float.compare(Math.abs(mOverlayTranslation), 0) == 0 &&
+            super.shouldFlingForVelocity(velocityX);
+    }
+
+    @Override
+    public void onDragStart(
+        DragObject dragObject, DragOptions options
+    ) {
+        if (mDragInfo != null && mDragInfo.getCell() != null) {
+            CellLayout layout = (CellLayout) mDragInfo.getCell().getParent();
+            layout.markCellsAsUnoccupiedForView(mDragInfo.getCell());
+        }
+
+        if (mOutlineProvider != null) {
+            if (dragObject.dragView != null) {
+                Bitmap preview = dragObject.dragView.getPreviewBitmap();
+
+                // The outline is used to visualize where the item will land if dropped
+                mOutlineProvider.generateDragOutline(preview);
+            }
+        }
+
+        updateChildrenLayersEnabled();
+
+        // Do not add a new page if it is a accessible drag which was not started by the workspace.
+        // We do not support accessibility drag from other sources and instead provide a direct
+        // action for move/add to homescreen.
+        // When a accessible drag is started by the folder, we only allow rearranging withing the
+        // folder.
+        // boolean addNewPage = !(options.isAccessibleDrag && dragObject.dragSource != this);
+        boolean addNewPage = true;
+
+        if (addNewPage) {
+            mDeferRemoveExtraEmptyScreen = false;
+            addExtraEmptyScreenOnDrag();
+        }
+    }
+
+    @Override
+    public void onDragEnd() {
+        if (!mDeferRemoveExtraEmptyScreen) {
+            //removeExtraEmptyScreen(true, mDragSourceInternal != null);
+        }
+
+        updateChildrenLayersEnabled();
+        mDragInfo = null;
+        mOutlineProvider = null;
+        mDragSourceInternal = null;
+    }
+
+    /**
+     * Called at the end of a drag which originated on the workspace.
+     */
+    public void onDropCompleted(
+        View target, DragObject d, boolean success
+    ) {
+        if (success) {
+            if (target != this && mDragInfo != null) {
+                removeWorkspaceItem(mDragInfo.getCell());
+            }
+        } else if (mDragInfo != null) {
+            final CellLayout cellLayout = mLauncher.getCellLayout(
+                mDragInfo.getContainer(), mDragInfo.getScreenId());
+            if (cellLayout != null) {
+                cellLayout.onDropChild(mDragInfo.getCell());
+            } else {
+                // TODO: Don't throw this exception in release build.
+                throw new RuntimeException("Invalid state: cellLayout == null in "
+                    + "Workspace#onDropCompleted. Please file a bug. ");
+            }
+        }
+        mDragInfo = null;
+    }
+
+    /**
+     * For opposite operation. See {@link #addInScreen}.
+     */
+    public void removeWorkspaceItem(View v) {
+        CellLayout parentCell = getParentCellLayoutForView(v);
+        if (parentCell != null) {
+            parentCell.removeView(v);
+        } else {
+            // When an app is uninstalled using the drop target, we wait until resume to remove
+            // the icon. We also remove all the corresponding items from the workspace at
+            // {@link Launcher#bindComponentsRemoved}. That call can come before or after
+            // {@link Launcher#mOnResumeCallbacks} depending on how busy the worker thread is.
+            Log.e(TAG, "mDragInfo.cell has null parent");
+        }
+        if (v instanceof DropTarget) {
+            mDragController.removeDropTarget((DropTarget) v);
+        }
+    }
+
+    /**
+     * Returns a specific CellLayout
+     */
+    CellLayout getParentCellLayoutForView(View v) {
+        ArrayList<CellLayout> layouts = getWorkspaceAndHotseatCellLayouts();
+        for (CellLayout layout : layouts) {
+            if (layout.indexOfChild(v) > -1) {
+                return layout;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Returns a list of all the CellLayouts in the workspace.
+     */
+    ArrayList<CellLayout> getWorkspaceAndHotseatCellLayouts() {
+        ArrayList<CellLayout> layouts = new ArrayList<>();
+        int screenCount = getChildCount();
+        for (int screen = 0; screen < screenCount; screen++) {
+            layouts.add(((CellLayout) getChildAt(screen)));
+        }
+        if (mLauncher.getHotseat() != null) {
+            layouts.add(mLauncher.getHotseat().getLayout());
+        }
+        return layouts;
+    }
+
+    @Override
+    public boolean isDropEnabled() {
+        Log.d(TAG, "isDropEnabled() called");
+        return true;
+    }
+
+    /**
+     * @return false if the callback is still pending
+     */
+    private boolean tryRunOverlayCallback() {
+        if (mOnOverlayHiddenCallback == null) {
+            // Return true as no callback is pending. This is used by OnWindowFocusChangeListener
+            // to remove itself if multiple focus handles were added.
+            return true;
+        }
+        if (mOverlayShown || !hasWindowFocus()) {
+            return false;
+        }
+
+        mOnOverlayHiddenCallback.run();
+        mOnOverlayHiddenCallback = null;
+        return true;
+    }
+
+    /**
+     * Runs the given callback when the minus one overlay is hidden. Specifically, it is run
+     * when launcher's window has focus and the overlay is no longer being shown. If a callback
+     * is already present, the new callback will chain off it so both are run.
+     *
+     * @return Whether the callback was deferred.
+     */
+    public boolean runOnOverlayHidden(Runnable callback) {
+        if (mOnOverlayHiddenCallback == null) {
+            mOnOverlayHiddenCallback = callback;
+        } else {
+            // Chain the new callback onto the previous callback(s).
+            Runnable oldCallback = mOnOverlayHiddenCallback;
+            mOnOverlayHiddenCallback = () -> {
+                oldCallback.run();
+                callback.run();
+            };
+        }
+        if (!tryRunOverlayCallback()) {
+            ViewTreeObserver observer = getViewTreeObserver();
+            if (observer != null && observer.isAlive()) {
+                observer.addOnWindowFocusChangeListener(
+                    new ViewTreeObserver.OnWindowFocusChangeListener() {
+                        @Override
+                        public void onWindowFocusChanged(boolean hasFocus) {
+                            if (tryRunOverlayCallback() && observer.isAlive()) {
+                                observer.removeOnWindowFocusChangeListener(this);
+                            }
+                        }
+                    });
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void onDrop(DragObject d, DragOptions options) {
+        mDragViewVisualCenter = d.getVisualCenter(mDragViewVisualCenter);
+        CellLayout dropTargetLayout = mDropToLayout;
+
+        // We want the point to be mapped to the dragTarget.
+        if (dropTargetLayout != null) {
+            if (mLauncher.isHotseatLayout(dropTargetLayout)) {
+                mapPointFromSelfToHotseatLayout(mLauncher.getHotseat(), mDragViewVisualCenter);
+            } else {
+                mapPointFromSelfToChild(dropTargetLayout, mDragViewVisualCenter);
+            }
+        }
+
+        boolean droppedOnOriginalCell = false;
+
+        int snapScreen = -1;
+        boolean resizeOnDrop = false;
+        if (d.dragSource != this || mDragInfo == null) {
+            final int[] touchXY = new int[]{(int) mDragViewVisualCenter[0],
+                (int) mDragViewVisualCenter[1]};
+            //onDropExternal(touchXY, dropTargetLayout, d);
+        } else {
+            final View cell = mDragInfo.getCell();
+            boolean droppedOnOriginalCellDuringTransition = false;
+            Runnable onCompleteRunnable = null;
+
+            if (dropTargetLayout != null && !d.cancelled) {
+                // Move internally
+                boolean hasMovedLayouts = (getParentCellLayoutForView(cell) != dropTargetLayout);
+                boolean hasMovedIntoHotseat = mLauncher.isHotseatLayout(dropTargetLayout);
+                long container = hasMovedIntoHotseat ?
+                    Constants.CONTAINER_HOTSEAT :
+                    Constants.CONTAINER_DESKTOP;
+                long screenId = (mTargetCell[0] < 0) ?
+                    mDragInfo.getScreenId() : getIdForScreen(dropTargetLayout);
+                int spanX = 1;
+                int spanY = 1;
+                // First we find the cell nearest to point at which the item is
+                // dropped, without any consideration to whether there is an item there.
+
+                mTargetCell = findNearestArea((int) mDragViewVisualCenter[0], (int)
+                    mDragViewVisualCenter[1], dropTargetLayout, mTargetCell);
+                float distance = dropTargetLayout.getDistanceFromCell(mDragViewVisualCenter[0],
+                    mDragViewVisualCenter[1], mTargetCell
+                );
+
+                // If the item being dropped is a shortcut and the nearest drop
+                // cell also contains a shortcut, then create a folder with the two shortcuts.
+                if (createUserFolderIfNecessary(cell, container,
+                    dropTargetLayout, mTargetCell, distance, false, d.dragView
+                ) ||
+                    addToExistingFolderIfNecessary(cell, dropTargetLayout, mTargetCell,
+                        distance, d, false
+                    )) {
+                    return;
+                }
+
+                // Aside from the special case where we're dropping a shortcut onto a shortcut,
+                // we need to find the nearest cell location that is vacant
+                LauncherItem item = d.dragInfo;
+                int cellX = item.cell % mLauncher.getDeviceProfile().getInv().getNumColumns();
+                int cellY = item.cell % mLauncher.getDeviceProfile().getInv().getNumRows();
+
+                droppedOnOriginalCell = item.screenId == screenId && item.container == container
+                    && cellX == mTargetCell[0] && cellY == mTargetCell[1];
+                //droppedOnOriginalCellDuringTransition = droppedOnOriginalCell && mIsSwitchingState;
+
+                // When quickly moving an item, a user may accidentally rearrange their
+                // workspace. So instead we move the icon back safely to its original position.
+
+                //TODO: may consider later
+               /* boolean returnToOriginalCellToPreventShuffling = !isFinishedSwitchingState()
+                    && !droppedOnOriginalCell && !dropTargetLayout
+                    .isRegionVacant(mTargetCell[0], mTargetCell[1], spanX, spanY);
+
+                if (returnToOriginalCellToPreventShuffling) {
+                    mTargetCell[0] = mTargetCell[1] = -1;
+                } else {
+                    mTargetCell = dropTargetLayout.performReorder((int) mDragViewVisualCenter[0],
+                        (int) mDragViewVisualCenter[1], 1, 1, spanX, spanY, cell,
+                        mTargetCell, resultSpan, CellLayout.MODE_ON_DROP
+                    );
+                }*/
+                int[] resultSpan = new int[2];
+                mTargetCell = dropTargetLayout.performReorder((int) mDragViewVisualCenter[0],
+                    (int) mDragViewVisualCenter[1], 1, 1, spanX, spanY, cell,
+                    mTargetCell, resultSpan, CellLayout.MODE_ON_DROP
+                );
+
+                boolean foundCell = mTargetCell[0] >= 0 && mTargetCell[1] >= 0;
+
+                Log.d(TAG, "Found cell " + foundCell + " " + mTargetCell[0] + " " + mTargetCell[0]);
+
+                if (foundCell) {
+                    if (getScreenIdForPageIndex(mCurrentPage) != screenId && !hasMovedIntoHotseat) {
+                        snapScreen = getPageIndexForScreenId(screenId);
+                        snapToPage(snapScreen);
+                    }
+
+                    final LauncherItem info = (LauncherItem) cell.getTag();
+                    if (hasMovedLayouts) {
+                        // Reparent the view
+                        CellLayout parentCell = getParentCellLayoutForView(cell);
+                        if (parentCell != null) {
+                            parentCell.removeView(cell);
+                        } else if (BuildConfig.DEBUG) {
+                            throw new NullPointerException("mDragInfo.cell has null parent");
+                        }
+
+                        addInScreen(cell, container, screenId, mTargetCell[0], mTargetCell[1]);
+                    }
+
+                    // update the item's position after drop
+                    /*CellLayout.LayoutParams lp = (CellLayout.LayoutParams) cell.getLayoutParams();
+                    lp.cellX = lp.tmpCellX = mTargetCell[0];
+                    lp.cellY = lp.tmpCellY = mTargetCell[1];
+                    lp.cellHSpan = item.spanX;
+                    lp.cellVSpan = item.spanY;
+                    lp.isLockedToGrid = true;*/
+
+                    //TODO: Update the launcher database here.
+                } else {
+                    onNoCellFound(dropTargetLayout);
+
+                    // If we can't find a drop location, we return the item to its original position
+                    addInScreen(
+                        cell,
+                        mDragInfo.getContainer(),
+                        mDragInfo.getScreenId(),
+                        mDragInfo.getRank()
+                    );
+                }
+            }
+
+            final CellLayout parent = (CellLayout) cell.getParent();
+            if (d.dragView.hasDrawn()) {
+                if (droppedOnOriginalCellDuringTransition) {
+                    // Animate the item to its original position, while simultaneously exiting
+                    // spring-loaded mode so the page meets the icon where it was picked up.
+                    mLauncher.getDragController().animateDragViewToOriginalPosition(
+                        onCompleteRunnable, cell, SPRING_LOADED_TRANSITION_MS);
+                    //mLauncher.getStateManager().goToState(NORMAL);
+                    parent.onDropChild(cell);
+                    return;
+                }
+                final LauncherItem info = (LauncherItem) cell.getTag();
+                int duration = snapScreen < 0 ? -1 : ADJACENT_SCREEN_DROP_DURATION;
+
+                mLauncher.getDragLayer().animateViewIntoPosition(d.dragView, cell, duration,
+                    this
+                );
+            } else {
+                d.deferDragViewCleanupPostAnimation = false;
+                cell.setVisibility(VISIBLE);
+            }
+            parent.onDropChild(cell);
+
+            /*mLauncher.getStateManager().goToState(
+                NORMAL, SPRING_LOADED_EXIT_DELAY, onCompleteRunnable);*/
+        }
+    }
+
+    boolean createUserFolderIfNecessary(
+        View newView, long container, CellLayout target,
+        int[] targetCell, float distance, boolean external, DragView dragView
+    ) {
+        if (distance > mMaxDistanceForFolderCreation) return false;
+        View v = target.getChildAt(targetCell[0], targetCell[1]);
+
+        boolean hasntMoved = false;
+        if (mDragInfo != null) {
+            CellLayout cellParent = getParentCellLayoutForView(mDragInfo.getCell());
+            hasntMoved = (mDragInfo.getRank() % cellParent.getMCountX() == targetCell[0] &&
+                mDragInfo.getRank() / cellParent
+                    .getMCountX() == targetCell[1]) && (cellParent == target);
+        }
+
+        if (v == null || hasntMoved || !mCreateUserFolderOnDrop) return false;
+        mCreateUserFolderOnDrop = false;
+        final long screenId = getIdForScreen(target);
+
+        boolean aboveShortcut =
+            (v.getTag() instanceof ApplicationItem) || (v.getTag() instanceof ShortcutItem);
+        boolean willBecomeShortcut =
+            (v.getTag() instanceof ApplicationItem) || (v.getTag() instanceof ShortcutItem);
+
+        if (aboveShortcut && willBecomeShortcut) {
+            LauncherItem sourceItem = (LauncherItem) newView.getTag();
+            LauncherItem destItem = (LauncherItem) v.getTag();
+
+            Rect folderLocation = new Rect();
+            target.removeView(v);
+            FolderItem fi = new FolderItem();
+            fi.title = getResources().getString(R.string.untitled);
+            fi.id = String.valueOf(System.currentTimeMillis());
+            fi.items = new ArrayList<>();
+            sourceItem.container = Long.parseLong(fi.id);
+            destItem.container = Long.parseLong(fi.id);
+            sourceItem.screenId = -1;
+            destItem.screenId = -1;
+            sourceItem.cell = fi.items.size();
+            fi.items.add(sourceItem);
+            destItem.cell = fi.items.size();
+            fi.items.add(destItem);
+            Drawable folderIcon = new GraphicsUtil(getContext()).generateFolderIcon(getContext(),
+                sourceItem.icon, destItem.icon
+            );
+            fi.icon = folderIcon;
+            fi.container = container;
+            fi.screenId = screenId;
+            fi.cell = targetCell[1] * mLauncher.getDeviceProfile().getInv()
+                .getNumColumns() + targetCell[0];
+            IconTextView folderView = (IconTextView) LayoutInflater.from(getContext())
+                .inflate(R.layout.app_icon, null, false);
+            folderView.applyFromShortcutItem(fi);
+            folderView.setOnClickListener(ItemClickHandler.INSTANCE);
+            folderView.setOnLongClickListener(ItemLongClickListener.INSTANCE_WORKSPACE);
+            addInScreen(folderView, fi);
+            // if the drag started here, we need to remove it from the workspace
+            if (!external) {
+                getParentCellLayoutForView(mDragInfo.getCell()).removeView(mDragInfo.getCell());
+            }
+            //Add animation here.
+            dragView.remove();
+            dragView = null;
+            invalidate();
+            return true;
+        }
+        return false;
+    }
+
+    private void addInScreen(IconTextView child, LauncherItem item) {
+        addInScreen(child, item.container, item.screenId, item.cell);
+    }
+
+    boolean addToExistingFolderIfNecessary(
+        View newView, CellLayout target, int[] targetCell,
+        float distance, DragObject d, boolean external
+    ) {
+        if (distance > mMaxDistanceForFolderCreation) return false;
+
+        View dropOverView = target.getChildAt(targetCell[0], targetCell[1]);
+        if (!mAddToExistingFolderOnDrop) return false;
+        mAddToExistingFolderOnDrop = false;
+
+        if ((dropOverView instanceof IconTextView) && (dropOverView
+            .getTag() instanceof FolderItem)) {
+            FolderItem fi = (FolderItem) dropOverView.getTag();
+            LauncherItem sourceItem = (LauncherItem) newView.getTag();
+            sourceItem.container = Long.parseLong(fi.id);
+            sourceItem.screenId = -1;
+            sourceItem.cell = fi.items.size();
+            fi.items.add(sourceItem);
+            fi.icon = new GraphicsUtil(getContext()).generateFolderIcon(getContext(), fi);
+            ((IconTextView) dropOverView).applyFromShortcutItem(fi);
+            // if the drag started here, we need to remove it from the workspace
+            if (!external) {
+                getParentCellLayoutForView(mDragInfo.getCell()).removeView(mDragInfo.getCell());
+            }
+            //Add animation here.
+            d.dragView.remove();
+            d.dragView = null;
+            invalidate();
+            return true;
+        }
+        return false;
+    }
+
+    public void onNoCellFound(View dropTargetLayout) {
+        Log.d(TAG, "onNoCellFound() called with: dropTargetLayout = [" + dropTargetLayout + "]");
+        if (mLauncher.isHotseatLayout(dropTargetLayout)) {
+            showOutOfSpaceMessage(true);
+        } else {
+            showOutOfSpaceMessage(false);
+        }
+    }
+
+    private void showOutOfSpaceMessage(boolean isHotseatLayout) {
+        int strId = (isHotseatLayout ? R.string.hotseat_out_of_space : R.string.out_of_space);
+        Toast.makeText(mLauncher, mLauncher.getString(strId), Toast.LENGTH_SHORT).show();
+    }
+
+    @Override
+    public void onDragEnter(DragObject dragObject) {
+        Log.d(TAG, "onDragEnter() called with: dragObject = [" + dragObject + "]");
+        mCreateUserFolderOnDrop = false;
+        mAddToExistingFolderOnDrop = false;
+
+        mDropToLayout = null;
+        mDragViewVisualCenter = dragObject.getVisualCenter(mDragViewVisualCenter);
+        setDropLayoutForDragObject(dragObject, mDragViewVisualCenter[0], mDragViewVisualCenter[1]);
+    }
+
+    /**
+     * Updates {@link #mDragTargetLayout} and {@link #mDragOverlappingLayout}
+     * based on the DragObject's position.
+     * <p>
+     * The layout will be:
+     * - The Hotseat if the drag object is over it
+     * - A side page if we are in spring-loaded mode and the drag object is over it
+     * - The current page otherwise
+     *
+     * @return whether the layout is different from the current {@link #mDragTargetLayout}.
+     */
+    private boolean setDropLayoutForDragObject(DragObject d, float centerX, float centerY) {
+        CellLayout layout = null;
+        // Test to see if we are over the hotseat first
+        if (mLauncher.getHotseat() != null) {
+            if (isPointInSelfOverHotseat(d.x, d.y)) {
+                layout = mLauncher.getHotseat().getLayout();
+            }
+        }
+
+        int nextPage = getNextPage();
+        if (layout == null && !isPageInTransition()) {
+            // Check if the item is dragged over left page
+            mTempTouchCoordinates[0] = Math.min(centerX, d.x);
+            mTempTouchCoordinates[1] = d.y;
+            layout = verifyInsidePage(nextPage + (mIsRtl ? 1 : -1), mTempTouchCoordinates);
+        }
+
+        if (layout == null && !isPageInTransition()) {
+            // Check if the item is dragged over right page
+            mTempTouchCoordinates[0] = Math.max(centerX, d.x);
+            mTempTouchCoordinates[1] = d.y;
+            layout = verifyInsidePage(nextPage + (mIsRtl ? -1 : 1), mTempTouchCoordinates);
+        }
+
+        // Always pick the current page.
+        if (layout == null && nextPage >= 0 && nextPage < getPageCount()) {
+            layout = (CellLayout) getChildAt(nextPage);
+        }
+        if (layout != mDragTargetLayout) {
+            setCurrentDropLayout(layout);
+            setCurrentDragOverlappingLayout(layout);
+            return true;
+        }
+        return false;
+    }
+
+    void setCurrentDropLayout(CellLayout layout) {
+        if (mDragTargetLayout != null) {
+            mDragTargetLayout.revertTempState();
+            mDragTargetLayout.onDragExit();
+        }
+        mDragTargetLayout = layout;
+        if (mDragTargetLayout != null) {
+            mDragTargetLayout.onDragEnter();
+        }
+        cleanupReorder(true);
+        cleanupFolderCreation();
+        setCurrentDropOverCell(-1, -1);
+    }
+
+    void setCurrentDragOverlappingLayout(CellLayout layout) {
+        if (mDragOverlappingLayout != null) {
+            mDragOverlappingLayout.setIsDragOverlapping(false);
+        }
+        mDragOverlappingLayout = layout;
+        if (mDragOverlappingLayout != null) {
+            mDragOverlappingLayout.setIsDragOverlapping(true);
+        }
+        // Invalidating the scrim will also force this CellLayout
+        // to be invalidated so that it is highlighted if necessary.
+        //mLauncher.getDragLayer().getScrim().invalidate();
+    }
+
+    public CellLayout getCurrentDragOverlappingLayout() {
+        return mDragOverlappingLayout;
+    }
+
+    void setCurrentDropOverCell(int x, int y) {
+        if (x != mDragOverX || y != mDragOverY) {
+            mDragOverX = x;
+            mDragOverY = y;
+            setDragMode(DRAG_MODE_NONE);
+        }
+    }
+
+    void setDragMode(int dragMode) {
+        if (dragMode != mDragMode) {
+            if (dragMode == DRAG_MODE_NONE) {
+                cleanupAddToFolder();
+                // We don't want to cancel the re-order alarm every time the target cell changes
+                // as this feels to slow / unresponsive.
+                cleanupReorder(false);
+                cleanupFolderCreation();
+            } else if (dragMode == DRAG_MODE_ADD_TO_FOLDER) {
+                cleanupReorder(true);
+                cleanupFolderCreation();
+            } else if (dragMode == DRAG_MODE_CREATE_FOLDER) {
+                cleanupAddToFolder();
+                cleanupReorder(true);
+            } else if (dragMode == DRAG_MODE_REORDER) {
+                cleanupAddToFolder();
+                cleanupFolderCreation();
+            }
+            mDragMode = dragMode;
+        }
+    }
+
+    private void cleanupFolderCreation() {
+        if (parentFolderCell != null) {
+            parentFolderCell.setScaleX(1f);
+            parentFolderCell.setScaleY(1f);
+        }
+
+        mFolderCreationAlarm.setOnAlarmListener(null);
+        mFolderCreationAlarm.cancelAlarm();
+    }
+
+    // Enable when supporting folder
+    private void cleanupAddToFolder() {
+        /*if (mDragOverFolderIcon != null) {
+            mDragOverFolderIcon.onDragExit();
+            mDragOverFolderIcon = null;
+        }*/
+    }
+
+    private void cleanupReorder(boolean cancelAlarm) {
+        // Any pending reorders are canceled
+        if (cancelAlarm) {
+            mReorderAlarm.cancelAlarm();
+        }
+        mLastReorderX = -1;
+        mLastReorderY = -1;
+    }
+
+    /**
+     * Returns the child CellLayout if the point is inside the page coordinates, null otherwise.
+     */
+    private CellLayout verifyInsidePage(int pageNo, float[] touchXy) {
+        if (pageNo >= 0 && pageNo < getPageCount()) {
+            CellLayout cl = (CellLayout) getChildAt(pageNo);
+            mapPointFromSelfToChild(cl, touchXy);
+            if (touchXy[0] >= 0 && touchXy[0] <= cl.getWidth() &&
+                touchXy[1] >= 0 && touchXy[1] <= cl.getHeight()) {
+                // This point is inside the cell layout
+                return cl;
+            }
+        }
+        return null;
+    }
+
+    /*
+     *
+     * Convert the 2D coordinate xy from the parent View's coordinate space to this CellLayout's
+     * coordinate space. The argument xy is modified with the return result.
+     */
+    void mapPointFromSelfToChild(View v, float[] xy) {
+        xy[0] = xy[0] - v.getLeft();
+        xy[1] = xy[1] - v.getTop();
+    }
+
+    boolean isPointInSelfOverHotseat(int x, int y) {
+        mTempXY[0] = x;
+        mTempXY[1] = y;
+        mLauncher.getDragLayer().getDescendantCoordRelativeToSelf(this, mTempXY, true);
+        View hotseat = mLauncher.getHotseat();
+        return mTempXY[0] >= hotseat.getLeft() &&
+            mTempXY[0] <= hotseat.getRight() &&
+            mTempXY[1] >= hotseat.getTop() &&
+            mTempXY[1] <= hotseat.getBottom();
+    }
+
+    void mapPointFromSelfToHotseatLayout(Hotseat hotseat, float[] xy) {
+        mTempXY[0] = (int) xy[0];
+        mTempXY[1] = (int) xy[1];
+        mLauncher.getDragLayer().getDescendantCoordRelativeToSelf(this, mTempXY, true);
+        mLauncher.getDragLayer().mapCoordInSelfToDescendant(hotseat.getLayout(), mTempXY);
+
+        xy[0] = mTempXY[0];
+        xy[1] = mTempXY[1];
+    }
+
+    @Override
+    public void onDragOver(DragObject d) {
+        Log.d(TAG, "onDragOver() called with: dragObject = [" + d + "]");
+
+        LauncherItem item = d.dragInfo;
+        if (item == null) {
+            throw new NullPointerException("DragObject has null info");
+        }
+        // Ensure that we have proper spans for the item that we are dropping
+        if (item.cell < 0) throw new RuntimeException("Improper spans found");
+        mDragViewVisualCenter = d.getVisualCenter(mDragViewVisualCenter);
+
+        final View child = (mDragInfo == null) ? null : mDragInfo.getCell();
+        if (setDropLayoutForDragObject(d, mDragViewVisualCenter[0], mDragViewVisualCenter[1])) {
+            if (mLauncher.isHotseatLayout(mDragTargetLayout)) {
+                mSpringLoadedDragController.cancel();
+            } else {
+                mSpringLoadedDragController.setAlarm(mDragTargetLayout);
+            }
+        }
+
+        // Handle the drag over
+        if (mDragTargetLayout != null) {
+            // We want the point to be mapped to the dragTarget.
+            if (mLauncher.isHotseatLayout(mDragTargetLayout)) {
+                mapPointFromSelfToHotseatLayout(mLauncher.getHotseat(), mDragViewVisualCenter);
+            } else {
+                Log.d(
+                    TAG,
+                    "Before mapping: " + mDragViewVisualCenter[0] + " " + mDragViewVisualCenter[1]
+                );
+                mapPointFromSelfToChild(mDragTargetLayout, mDragViewVisualCenter);
+                Log.d(
+                    TAG,
+                    "After mapping: " + mDragViewVisualCenter[0] + " " + mDragViewVisualCenter[1]
+                );
+            }
+
+            mTargetCell = findNearestArea((int) mDragViewVisualCenter[0],
+                (int) mDragViewVisualCenter[1],
+                mDragTargetLayout, mTargetCell
+            );
+            int reorderX = mTargetCell[0];
+            int reorderY = mTargetCell[1];
+
+            setCurrentDropOverCell(mTargetCell[0], mTargetCell[1]);
+
+            float targetCellDistance = mDragTargetLayout.getDistanceFromCell(
+                mDragViewVisualCenter[0], mDragViewVisualCenter[1], mTargetCell);
+
+            //TODO: Enable when supporting foler
+            manageFolderFeedback(mDragTargetLayout, mTargetCell, targetCellDistance, d);
+
+            boolean nearestDropOccupied = mDragTargetLayout.isNearestDropLocationOccupied((int)
+                mDragViewVisualCenter[0], (int) mDragViewVisualCenter[1], child, mTargetCell);
+
+            Log.d(
+                TAG,
+                "Reorder [" + mLastReorderX + ", " + mLastReorderY + "] [" + reorderX + ", " + reorderY + "] "
+            );
+            Log.d(
+                TAG,
+                "Reorder " + mDragMode + " " + mReorderAlarm
+                    .alarmPending() + " " + nearestDropOccupied
+            );
+
+            if (!nearestDropOccupied) {
+                mDragTargetLayout.visualizeDropLocation(child, mOutlineProvider,
+                    mTargetCell[0], mTargetCell[1], false, d
+                );
+            } else if ((mDragMode == DRAG_MODE_NONE || mDragMode == DRAG_MODE_REORDER)
+                && (mLastReorderX != reorderX || mLastReorderY != reorderY)) {
+                Log.d(
+                    TAG,
+                    "Reorder  Setting reorder now"
+                );
+                int[] resultSpan = new int[2];
+                /*mDragTargetLayout.performReorder((int) mDragViewVisualCenter[0],
+                    (int) mDragViewVisualCenter[1], 1, 1, 1, 1,
+                    child, mTargetCell, resultSpan, CellLayout.MODE_SHOW_REORDER_HINT);*/
+
+                // Otherwise, if we aren't adding to or creating a folder and there's no pending
+                // reorder, then we schedule a reorder
+                ReorderAlarmListener listener =
+                    new ReorderAlarmListener(mDragViewVisualCenter, d, child);
+                mReorderAlarm.setOnAlarmListener(listener);
+                mReorderAlarm.setAlarm(REORDER_TIMEOUT);
+            }
+
+            if (mDragMode == DRAG_MODE_CREATE_FOLDER || mDragMode == DRAG_MODE_ADD_TO_FOLDER ||
+                !nearestDropOccupied) {
+                if (mDragTargetLayout != null) {
+                    mDragTargetLayout.revertTempState();
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onDragExit(DragObject dragObject) {
+        // Here we store the final page that will be dropped to, if the workspace in fact
+        // receives the drop
+        mDropToLayout = mDragTargetLayout;
+        if (mDragMode == DRAG_MODE_CREATE_FOLDER) {
+            mCreateUserFolderOnDrop = true;
+        } else if (mDragMode == DRAG_MODE_ADD_TO_FOLDER) {
+            mAddToExistingFolderOnDrop = true;
+        }
+
+        // Reset the previous drag target
+        setCurrentDropLayout(null);
+        setCurrentDragOverlappingLayout(null);
+
+        mSpringLoadedDragController.cancel();
+    }
+
+    @Override
+    public boolean acceptDrop(DragObject dragObject) {
+        CellLayout dropTargetLayout = mDropToLayout;
+        long screenId = getIdForScreen(dropTargetLayout);
+        if (screenId == EXTRA_EMPTY_SCREEN_ID) {
+            commitExtraEmptyScreen();
+        }
+        return true;
+    }
+
+    @Override
+    public void prepareAccessibilityDrop() {
+        Log.d(TAG, "prepareAccessibilityDrop() called");
+    }
+
+    @Override
+    public void getHitRectRelativeToDragLayer(Rect outRect) {
+        // We want the workspace to have the whole area of the display (it will find the correct
+        // cell layout to drop to in the existing drag/drop logic.
+        mLauncher.getDragLayer().getDescendantRectRelativeToSelf(this, outRect);
+    }
+
+    public void startDrag(CellLayout.CellInfo cellInfo, DragOptions dragOptions) {
+        View child = cellInfo.getCell();
+        mDragInfo = cellInfo;
+        child.setVisibility(GONE);
+        beginDragShared(child, this, dragOptions);
+    }
+
+    public void beginDragShared(View child, DragSource source, DragOptions options) {
+        Object dragObject = child.getTag();
+        if (!(dragObject instanceof LauncherItem)) {
+            String msg = "Drag started with a view that has no tag set. This "
+                + "will cause a crash down the line. "
+                + "View: " + child + "  tag: " + child.getTag();
+            throw new IllegalStateException(msg);
+        }
+
+        beginDragShared(
+            child,
+            source,
+            (LauncherItem) dragObject,
+            new DragPreviewProvider(child),
+            options
+        );
+    }
+
+    private DragView beginDragShared(
+        View child,
+        DragSource source,
+        LauncherItem dragObject,
+        DragPreviewProvider previewProvider,
+        DragOptions dragOptions
+    ) {
+        float iconScale = 1f;
+        if (child instanceof IconTextView) {
+            Drawable icon = ((IconTextView) child).getIcon();
+        }
+
+        child.clearFocus();
+        child.setPressed(false);
+        mOutlineProvider = previewProvider;
+
+        // The drag bitmap follows the touch point around on the screen
+        final Bitmap b = previewProvider.createDragBitmap();
+        int halfPadding = previewProvider.previewPadding / 2;
+
+        float scale = previewProvider.getScaleAndPosition(b, mTempXY);
+        int dragLayerX = mTempXY[0];
+        int dragLayerY = mTempXY[1];
+
+        Log.i(TAG, "beginDragShared: " + dragLayerY);
+
+        VariantDeviceProfile grid = mLauncher.getDeviceProfile();
+        Point dragVisualizeOffset = null;
+        Rect dragRect = null;
+        if (child instanceof IconTextView) {
+            dragRect =
+                ((IconTextView) child).getIconBounds();
+            dragLayerY += dragRect.top;
+            Log.i(TAG, "beginDragShared: " + dragLayerY + " " + dragRect);
+
+            // Note: The dragRect is used to calculate drag layer offsets, but the
+            // dragVisualizeOffset in addition to the dragRect (the size) to position the outline.
+            dragVisualizeOffset = new Point(-halfPadding, halfPadding);
+        }
+
+        // Clear the pressed state if necessary
+        if (child instanceof IconTextView) {
+            IconTextView icon = (IconTextView) child;
+            icon.clearPressedBackground();
+        }
+
+        if (child.getParent() instanceof CellLayout) {
+            mDragSourceInternal = (CellLayout) child.getParent();
+        }
+
+        DragView dv = mDragController.startDrag(b, dragLayerX, dragLayerY, source,
+            dragObject, dragVisualizeOffset, dragRect, scale * iconScale, scale, dragOptions
+        );
+        dv.setIntrinsicIconScaleFactor(dragOptions.intrinsicIconScaleFactor);
+        return dv;
+    }
+
+    /**
+     * Calculate the nearest cell where the given object would be dropped.
+     * <p>
+     * pixelX and pixelY should be in the coordinate system of layout
+     */
+    int[] findNearestArea(int pixelX, int pixelY, CellLayout layout, int[] recycle) {
+        return layout.findNearestArea(
+            pixelX, pixelY, recycle);
+    }
+
+    boolean willCreateUserFolder(
+        LauncherItem info, CellLayout target, int[] targetCell,
+        float distance, boolean considerTimeout
+    ) {
+        if (distance > mMaxDistanceForFolderCreation) return false;
+        View dropOverView = target.getChildAt(targetCell[0], targetCell[1]);
+        return willCreateUserFolder(info, dropOverView, considerTimeout);
+    }
+
+    boolean willCreateUserFolder(LauncherItem info, View dropOverView, boolean considerTimeout) {
+
+        boolean hasntMoved = false;
+        if (mDragInfo != null) {
+            hasntMoved = dropOverView == mDragInfo.getCell();
+        }
+
+        if (dropOverView == null || hasntMoved || (considerTimeout && !mCreateUserFolderOnDrop)) {
+            return false;
+        }
+
+        boolean aboveShortcut = (dropOverView.getTag() instanceof ShortcutItem || dropOverView
+            .getTag() instanceof ApplicationItem);
+        boolean willBecomeShortcut =
+            (info.itemType == ITEM_TYPE_APPLICATION ||
+                info.itemType == Constants.ITEM_TYPE_SHORTCUT);
+
+        return (aboveShortcut && willBecomeShortcut);
+    }
+
+    boolean willAddToExistingUserFolder(
+        LauncherItem dragInfo, CellLayout target, int[] targetCell,
+        float distance
+    ) {
+        if (distance > mMaxDistanceForFolderCreation) return false;
+        View dropOverView = target.getChildAt(targetCell[0], targetCell[1]);
+        return willAddToExistingUserFolder(dragInfo, dropOverView);
+    }
+
+    boolean willAddToExistingUserFolder(LauncherItem dragInfo, View dropOverView) {
+        if (dropOverView.getTag() instanceof FolderItem) {
+            return true;
+        }
+        return false;
+    }
+
+    private void manageFolderFeedback(
+        CellLayout targetLayout,
+        int[] targetCell, float distance, DragObject dragObject
+    ) {
+        Log.d(
+            TAG,
+            "manageFolderFeedback() called with: targetLayout = [" + targetLayout + "], targetCell = [" + targetCell + "], distance = [" + distance + "], dragObject = [" + dragObject + "]"
+        );
+        if (distance > mMaxDistanceForFolderCreation) return;
+
+        final View dragOverView = mDragTargetLayout.getChildAt(mTargetCell[0], mTargetCell[1]);
+        LauncherItem info = dragObject.dragInfo;
+        boolean userFolderPending = willCreateUserFolder(info, dragOverView, false);
+        Log.i(TAG, "manageFolderFeedback: userFolderPending: " + userFolderPending);
+        if (mDragMode == DRAG_MODE_NONE && userFolderPending &&
+            !mFolderCreationAlarm.alarmPending()) {
+
+            FolderCreationAlarmListener listener = new
+                FolderCreationAlarmListener(targetLayout, targetCell[0], targetCell[1], true);
+
+            if (!dragObject.accessibleDrag) {
+                mFolderCreationAlarm.setOnAlarmListener(listener);
+                mFolderCreationAlarm.setAlarm(FOLDER_CREATION_TIMEOUT);
+            } else {
+                listener.onAlarm(mFolderCreationAlarm);
+            }
+
+            //TODO: Enable when supporting accessibility
+            /*if (dragObject.stateAnnouncer != null) {
+                dragObject.stateAnnouncer.announce(WorkspaceAccessibilityHelper
+                    .getDescriptionForDropOver(dragOverView, getContext()));
+            }*/
+            return;
+        }
+
+        boolean willAddToFolder = willAddToExistingUserFolder(info, dragOverView);
+        if (willAddToFolder && mDragMode == DRAG_MODE_NONE && !mFolderCreationAlarm
+            .alarmPending()) {
+            FolderCreationAlarmListener listener = new
+                FolderCreationAlarmListener(targetLayout, targetCell[0], targetCell[1], false);
+
+            if (!dragObject.accessibleDrag) {
+                mFolderCreationAlarm.setOnAlarmListener(listener);
+                mFolderCreationAlarm.setAlarm(FOLDER_CREATION_TIMEOUT);
+            } else {
+                listener.onAlarm(mFolderCreationAlarm);
+            }
+            setDragMode(DRAG_MODE_ADD_TO_FOLDER);
+            return;
+        }
+
+        if (mDragMode == DRAG_MODE_ADD_TO_FOLDER && !willAddToFolder) {
+            setDragMode(DRAG_MODE_NONE);
+        }
+        if (mDragMode == DRAG_MODE_CREATE_FOLDER && !userFolderPending) {
+            setDragMode(DRAG_MODE_NONE);
+        }
+    }
+
+    private void onStartStateTransition(LauncherState state) {
+        mIsSwitchingState = true;
+        mTransitionProgress = 0;
+
+        updateChildrenLayersEnabled();
+    }
+
+    private void onEndStateTransition() {
+        mIsSwitchingState = false;
+        mForceDrawAdjacentPages = false;
+        mTransitionProgress = 1;
+
+        updateChildrenLayersEnabled();
+    }
+
+    /**
+     * Sets the current workspace {@link LauncherState} and updates the UI without any animations
+     */
+    @Override
+    public void setState(LauncherState toState) {
+        onStartStateTransition(toState);
+        mStateTransitionAnimation.setState(toState);
+        onEndStateTransition();
+    }
+
+    /**
+     * Sets the current workspace {@link LauncherState}, then animates the UI
+     */
+    @Override
+    public void setStateWithAnimation(
+        LauncherState toState,
+        AnimatorSetBuilder builder, LauncherStateManager.AnimationConfig config
+    ) {
+        StateTransitionListener listener = new StateTransitionListener(toState);
+        mStateTransitionAnimation.setStateWithAnimation(toState, builder, config);
+
+        // Invalidate the pages now, so that we have the visible pages before the
+        // animation is started
+        if (toState.hasMultipleVisiblePages) {
+            mForceDrawAdjacentPages = true;
+        }
+        invalidate(); // This will call dispatchDraw(), which calls getVisiblePages().
+
+        ValueAnimator stepAnimator = ValueAnimator.ofFloat(0, 1);
+        stepAnimator.addUpdateListener(listener);
+        stepAnimator.setDuration(config.duration);
+        stepAnimator.addListener(listener);
+        builder.play(stepAnimator);
+    }
+
+    /**
+     * Similar to {@link #getFirstMatch} but optimized to finding a suitable view for the app close
+     * animation.
+     *
+     * @param packageName The package name of the app to match.
+     * @param user        The user of the app to match.
+     */
+    public View getFirstMatchForAppClose(String packageName, UserHandle user) {
+        final int curPage = getCurrentPage();
+        final CellLayout currentPage = (CellLayout) getPageAt(curPage);
+        final LauncherPagedView.ItemOperator packageAndUser =
+            (LauncherItem info, View view) -> info != null
+                && info.getTargetComponent() != null
+                && TextUtils.equals(info.getTargetComponent().getPackageName(), packageName)
+                && info.user.equals(user);
+        final LauncherPagedView.ItemOperator packageAndUserAndApp =
+            (LauncherItem info, View view) ->
+                packageAndUser.evaluate(info, view) && info.itemType == ITEM_TYPE_APPLICATION;
+
+        return getFirstMatch(
+            new CellLayout[]{mLauncher.getHotseat(), currentPage},
+            packageAndUserAndApp
+        );
+    }
+
+    /**
+     * @param cellLayouts List of CellLayouts to scan, in order of preference.
+     * @param operators   List of operators, in order starting from best matching operator.
+     * @return
+     */
+    private View getFirstMatch(CellLayout[] cellLayouts, final ItemOperator... operators) {
+        // This array is filled with the first match for each operator.
+        final View[] matches = new View[operators.length];
+        // For efficiency, the outer loop should be CellLayout.
+        for (CellLayout cellLayout : cellLayouts) {
+            mapOverCellLayout(MAP_NO_RECURSE, cellLayout, (info, v) -> {
+                for (int i = 0; i < operators.length; ++i) {
+                    if (matches[i] == null && operators[i].evaluate(info, v)) {
+                        matches[i] = v;
+                        if (i == 0) {
+                            // We can return since this is the best match possible.
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            });
+            if (matches[0] != null) {
+                break;
+            }
+        }
+        for (View match : matches) {
+            if (match != null) {
+                return match;
+            }
+        }
+        return null;
+    }
+
+    private boolean mapOverCellLayout(boolean recurse, CellLayout layout, ItemOperator op) {
+        // TODO(b/128460496) Potential race condition where layout is not yet loaded
+        if (layout == null) {
+            return false;
+        }
+        // map over all the shortcuts on the workspace
+        final int itemCount = layout.getChildCount();
+        for (int itemIdx = 0; itemIdx < itemCount; itemIdx++) {
+            View item = layout.getChildAt(itemIdx);
+            LauncherItem info = (LauncherItem) item.getTag();
+            if (recurse && info instanceof FolderItem) {
+                FolderItem folder = (FolderItem) info;
+                List<LauncherItem> folderChildren = folder.items;
+                // map over all the children in the folder
+                final int childCount = folder.items.size();
+                for (int childIdx = 0; childIdx < childCount; childIdx++) {
+                    LauncherItem childItem = folderChildren.get(childIdx);
+                    if (op.evaluate(info, item)) {
+                        return true;
+                    }
+                }
+            } else {
+                if (op.evaluate(info, item)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * The overlay scroll is being controlled locally, just update our overlay effect
+     */
+    public void onOverlayScrollChanged(float scroll) {
+        if (Float.compare(scroll, 1f) == 0) {
+            mOverlayShown = true;
+            // Not announcing the overlay page for accessibility since it announces itself.
+        } else if (Float.compare(scroll, 0f) == 0) {
+            if (Float.compare(mOverlayTranslation, 0f) != 0) {
+                // When arriving to 0 overscroll from non-zero overscroll, announce page for
+                // accessibility since default announcements were disabled while in overscroll
+                // state.
+                // Not doing this if mOverlayShown because in that case the accessibility service
+                // will announce the launcher window description upon regaining focus after
+                // switching from the overlay screen.
+                announcePageForAccessibility();
+            }
+            mOverlayShown = false;
+            tryRunOverlayCallback();
+        }
+
+        float offset = 0f;
+
+        scroll = Math.max(scroll - offset, 0);
+        scroll = Math.min(1, scroll / (1 - offset));
+
+        float alpha = 1 - Interpolators.DEACCEL_3.getInterpolation(scroll);
+        float transX = mLauncher.getDragLayer().getMeasuredWidth() * scroll;
+
+        if (mIsRtl) {
+            transX = -transX;
+        }
+        mOverlayTranslation = transX;
+        Log.d(TAG, "onOverlayScrollChanged() called with: scroll = [" + scroll + "]");
+
+        // TODO(adamcohen): figure out a final effect here. We may need to recommend
+        // different effects based on device performance. On at least one relatively high-end
+        // device I've tried, translating the launcher causes things to get quite laggy.
+        mLauncher.getDragLayer().setTranslationX(transX);
+        mLauncher.getDragLayer().getAlphaProperty(ALPHA_INDEX_OVERLAY).setValue(alpha);
+    }
+
+    protected void announcePageForAccessibility() {
+        // TODO: Enable it when supporting accessibility.
+        /*if (isAccessibilityEnabled(getContext())) {
+            // Notify the user when the page changes
+            announceForAccessibility(getCurrentPageDescription());
+        }*/
+    }
+
+    public Hotseat getHotseat() {
+        return mLauncher.getHotseat();
+    }
+
+    public interface ItemOperator {
+        /**
+         * Process the next itemInfo, possibly with side-effect on the next item.
+         *
+         * @param info info for the shortcut
+         * @param view view for the shortcut
+         * @return true if done, false to continue the map
+         */
+        boolean evaluate(LauncherItem info, View view);
+    }
+
+    class FolderCreationAlarmListener implements OnAlarmListener {
+        final CellLayout layout;
+        final IconTextView cell;
+        final int cellX;
+        final int cellY;
+        final boolean createFolder;
+
+        public FolderCreationAlarmListener(
+            CellLayout layout,
+            int cellX,
+            int cellY,
+            boolean createFolder
+        ) {
+            this.layout = layout;
+            this.cellX = cellX;
+            this.cellY = cellY;
+            this.cell = (IconTextView) layout.getChildAt(cellX, cellY);
+            this.createFolder = createFolder;
+        }
+
+        public void onAlarm(Alarm alarm) {
+            Log.d(TAG, "onAlarm() called with: alarm = [" + alarm + "]");
+            parentFolderCell = cell;
+            parentFolderCell.setScaleX(1.2f);
+            parentFolderCell.setScaleY(1.2f);
+            if (createFolder) {
+                setDragMode(DRAG_MODE_CREATE_FOLDER);
+            } else {
+                setDragMode(DRAG_MODE_ADD_TO_FOLDER);
+            }
+        }
+    }
+
+    class ReorderAlarmListener implements OnAlarmListener {
+        final float[] dragViewCenter;
+        final DragObject dragObject;
+        final View child;
+
+        public ReorderAlarmListener(float[] dragViewCenter, DragObject dragObject, View child) {
+            this.dragViewCenter = dragViewCenter;
+            this.child = child;
+            this.dragObject = dragObject;
+        }
+
+        public void onAlarm(Alarm alarm) {
+            int[] resultSpan = new int[2];
+            mTargetCell = findNearestArea((int) mDragViewVisualCenter[0],
+                (int) mDragViewVisualCenter[1], mDragTargetLayout,
+                mTargetCell
+            );
+            mLastReorderX = mTargetCell[0];
+            mLastReorderY = mTargetCell[1];
+
+            mTargetCell = mDragTargetLayout.performReorder((int) mDragViewVisualCenter[0],
+                (int) mDragViewVisualCenter[1], 1, 1, 1, 1,
+                child, mTargetCell, resultSpan, CellLayout.MODE_DRAG_OVER
+            );
+
+            if (mTargetCell[0] < 0 || mTargetCell[1] < 0) {
+                mDragTargetLayout.revertTempState();
+            } else {
+                setDragMode(DRAG_MODE_REORDER);
+            }
+            mDragTargetLayout.visualizeDropLocation(child, mOutlineProvider,
+                mTargetCell[0], mTargetCell[1], false, dragObject
+            );
+        }
+    }
+
+    private class StateTransitionListener extends AnimatorListenerAdapter
+        implements ValueAnimator.AnimatorUpdateListener {
+
+        private final LauncherState mToState;
+
+        StateTransitionListener(LauncherState toState) {
+            mToState = toState;
+        }
+
+        @Override
+        public void onAnimationUpdate(ValueAnimator anim) {
+            mTransitionProgress = anim.getAnimatedFraction();
+        }
+
+        @Override
+        public void onAnimationStart(Animator animation) {
+            onStartStateTransition(mToState);
+        }
+
+        @Override
+        public void onAnimationEnd(Animator animation) {
+            onEndStateTransition();
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/PageIndicatorLinearLayout.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/PageIndicatorLinearLayout.java
index 25514bcb9348c7a33aee3f7fb4067c075472b0f1..fa6644124294c0157f38d82eef2dd755879ca886 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/PageIndicatorLinearLayout.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/PageIndicatorLinearLayout.java
@@ -1,11 +1,10 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.content.Context;
 import android.util.AttributeSet;
 import android.widget.LinearLayout;
-
 import androidx.annotation.Nullable;
-
 import foundation.e.blisslauncher.BlissLauncher;
 import foundation.e.blisslauncher.core.DeviceProfile;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/PagedView.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/PagedView.java
index 9ec64ffa76b0fbe2c0f0b8ebd6374facad71ed68..9eff5025a95cd7fdac06592164dfd081643445e5 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/PagedView.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/PagedView.java
@@ -16,13 +16,14 @@ package foundation.e.blisslauncher.core.customviews;
  * limitations under the License.
  */
 
+
+import static foundation.e.blisslauncher.core.touch.OverScroll.OVERSCROLL_DAMP_FACTOR;
+
 import android.animation.LayoutTransition;
-import android.animation.TimeInterpolator;
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.content.res.TypedArray;
 import android.graphics.Rect;
-import android.os.Bundle;
 import android.util.AttributeSet;
 import android.util.Log;
 import android.view.InputDevice;
@@ -34,18 +35,13 @@ import android.view.ViewConfiguration;
 import android.view.ViewDebug;
 import android.view.ViewGroup;
 import android.view.ViewParent;
-import android.view.accessibility.AccessibilityEvent;
-import android.view.accessibility.AccessibilityNodeInfo;
 import android.view.animation.Interpolator;
-import android.widget.ScrollView;
-import android.widget.Scroller;
-
-import java.util.ArrayList;
-
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.Utilities;
 import foundation.e.blisslauncher.core.customviews.pageindicators.PageIndicator;
 import foundation.e.blisslauncher.core.touch.OverScroll;
+import foundation.e.blisslauncher.core.utils.OverScroller;
+import java.util.ArrayList;
 
 /**
  * An abstraction of the original Workspace which supports browsing through a
@@ -56,15 +52,15 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
     private static final boolean DEBUG = false;
 
     protected static final int INVALID_PAGE = -1;
-    protected static final ComputePageScrollsLogic SIMPLE_SCROLL_LOGIC = (v) -> v.getVisibility() != GONE;
+    protected static final ComputePageScrollsLogic SIMPLE_SCROLL_LOGIC =
+            (v) -> v.getVisibility() != GONE;
 
     public static final int PAGE_SNAP_ANIMATION_DURATION = 750;
-    public static final int SLOW_PAGE_SNAP_ANIMATION_DURATION = 950;
 
     // OverScroll constants
     private final static int OVERSCROLL_PAGE_SNAP_ANIMATION_DURATION = 270;
+    private static final float RETURN_TO_ORIGINAL_PAGE_THRESHOLD = 0.5f;
 
-    private static final float RETURN_TO_ORIGINAL_PAGE_THRESHOLD = 0.33f;
     // The page is moved more than halfway, automatically move to the next page on touch up.
     private static final float SIGNIFICANT_MOVE_THRESHOLD = 0.4f;
 
@@ -76,8 +72,6 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
     private static final int MIN_SNAP_VELOCITY = 1500;
     private static final int MIN_FLING_VELOCITY = 250;
 
-    public static final int INVALID_RESTORE_PAGE = -1001;
-
     private boolean mFreeScroll = false;
     private boolean mSettleOnPageInFreeScroll = false;
 
@@ -92,8 +86,9 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
 
     @ViewDebug.ExportedProperty(category = "launcher")
     protected int mNextPage = INVALID_PAGE;
-    protected int mMaxScrollX;
-    public Scroller mScroller;
+    protected int mMaxScroll;
+    protected int mMinScroll;
+    public OverScroller mScroller;
     private Interpolator mDefaultInterpolator;
     private VelocityTracker mVelocityTracker;
     protected int mPageSpacing = 0;
@@ -113,6 +108,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
 
     protected int mTouchState = TOUCH_STATE_REST;
 
+    // The amount of movement to begin scrolling
     protected int mTouchSlop;
     private int mMaximumVelocity;
     protected boolean mAllowOverScroll = true;
@@ -123,6 +119,8 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
 
     protected boolean mIsPageInTransition = false;
 
+    protected float mSpringOverScrollX;
+
     protected boolean mWasInOverscroll = false;
 
     // mOverScrollX is equal to getScrollX() when we're within the normal scroll range. Otherwise
@@ -158,6 +156,9 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
     public PagedView(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
 
+        Log.d(TAG, "PagedView() called with: context = [" + context + "], attrs = [" + attrs +
+                "], defStyle = [" + defStyle + "]");
+
         TypedArray a = context.obtainStyledAttributes(attrs,
                 R.styleable.PagedView, defStyle, 0);
         mPageIndicatorViewId = a.getResourceId(R.styleable.PagedView_pageIndicator, -1);
@@ -165,14 +166,8 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
 
         setHapticFeedbackEnabled(false);
         mIsRtl = false;
-        init();
-    }
+        mScroller = new OverScroller(getContext());
 
-    /**
-     * Initializes various states for this workspace.
-     */
-    protected void init() {
-        mScroller = new Scroller(getContext());
         mCurrentPage = 0;
 
         final ViewConfiguration configuration = ViewConfiguration.get(getContext());
@@ -229,6 +224,12 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
         return index;
     }
 
+    protected void scrollAndForceFinish(int scrollX) {
+        scrollTo(scrollX, 0);
+        mScroller.startScroll(mScroller.getCurrPos(), scrollX - mScroller.getCurrPos());
+        forceFinishScroller(true);
+    }
+
     /**
      * Updates the scroll of the current page immediately to its final scroll position.  We use this
      * in CustomizePagedView to allow tabs to share the same PagedView while resetting the scroll of
@@ -240,9 +241,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
         if (0 <= mCurrentPage && mCurrentPage < getPageCount()) {
             newX = getScrollForPage(mCurrentPage);
         }
-        scrollTo(newX, 0);
-        mScroller.setFinalX(newX);
-        forceFinishScroller(true);
+        scrollAndForceFinish(newX);
     }
 
     public void abortScrollerAnimation(boolean resetNextPage) {
@@ -302,6 +301,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
             mPageIndicator.setActiveMarker(getNextPage());
         }
     }
+
     protected void pageBeginTransition() {
         if (!mIsPageInTransition) {
             mIsPageInTransition = true;
@@ -346,39 +346,45 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
 
     @Override
     public void scrollTo(int x, int y) {
+        Log.d(TAG, "scrollTo() called with: x = [" + x + "], y = [" + y + "]");
         // In free scroll mode, we clamp the scrollX
         if (mFreeScroll) {
             // If the scroller is trying to move to a location beyond the maximum allowed
             // in the free scroll mode, we make sure to end the scroll operation.
-            if (!mScroller.isFinished() && (x > mMaxScrollX || x < 0)) {
+            if (!mScroller.isFinished() && (x > mMaxScroll || x < 0)) {
                 forceFinishScroller(false);
             }
 
-            x = Utilities.boundToRange(x, 0, mMaxScrollX);
+            x = Utilities.boundToRange(x, 0, mMaxScroll);
         }
 
         mUnboundedScrollX = x;
 
-        boolean isXBeforeFirstPage = mIsRtl ? (x > mMaxScrollX) : (x < 0);
-        boolean isXAfterLastPage = mIsRtl ? (x < 0) : (x > mMaxScrollX);
+        boolean isXBeforeFirstPage = mIsRtl ? (x > mMaxScroll) : (x < 0);
+        boolean isXAfterLastPage = mIsRtl ? (x < 0) : (x > mMaxScroll);
+
+        if (!isXBeforeFirstPage && !isXAfterLastPage) {
+            mSpringOverScrollX = 0;
+        }
+
         if (isXBeforeFirstPage) {
-            super.scrollTo(mIsRtl ? mMaxScrollX : 0, y);
+            super.scrollTo(mIsRtl ? mMaxScroll : 0, y);
             if (mAllowOverScroll) {
                 mWasInOverscroll = true;
                 if (mIsRtl) {
-                    overScroll(x - mMaxScrollX);
+                    overScroll(x - mMaxScroll);
                 } else {
-                    overScroll(x);
+                    overScroll(x - mMinScroll);
                 }
             }
         } else if (isXAfterLastPage) {
-            super.scrollTo(mIsRtl ? 0 : mMaxScrollX, y);
+            super.scrollTo(mIsRtl ? 0 : mMaxScroll, y);
             if (mAllowOverScroll) {
                 mWasInOverscroll = true;
                 if (mIsRtl) {
-                    overScroll(x);
+                    overScroll(x - mMinScroll);
                 } else {
-                    overScroll(x - mMaxScrollX);
+                    overScroll(x - mMaxScroll);
                 }
             }
         } else {
@@ -386,37 +392,27 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
                 overScroll(0);
                 mWasInOverscroll = false;
             }
-            mOverScrollX = x;
             super.scrollTo(x, y);
         }
     }
 
-    private void sendScrollAccessibilityEvent() {
-    }
-
     // we moved this functionality to a helper function so SmoothPagedView can reuse it
     protected boolean computeScrollHelper() {
         return computeScrollHelper(true);
     }
 
-    protected void announcePageForAccessibility() {
-    }
-
     protected boolean computeScrollHelper(boolean shouldInvalidate) {
         if (mScroller.computeScrollOffset()) {
             // Don't bother scrolling if the page does not need to be moved
-            if (getUnboundedScrollX() != mScroller.getCurrX()
-                    || getScrollY() != mScroller.getCurrY()
-                    || mOverScrollX != mScroller.getCurrX()) {
-                scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
+            if (getUnboundedScrollX() != mScroller.getCurrPos()
+                    || mOverScrollX != mScroller.getCurrPos()) {
+                scrollTo(mScroller.getCurrPos(), 0);
             }
             if (shouldInvalidate) {
                 invalidate();
             }
             return true;
         } else if (mNextPage != INVALID_PAGE && shouldInvalidate) {
-            sendScrollAccessibilityEvent();
-
             int prevPage = mCurrentPage;
             mCurrentPage = validateNewPage(mNextPage);
             mNextPage = INVALID_PAGE;
@@ -427,10 +423,6 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
             if (mTouchState == TOUCH_STATE_REST) {
                 pageEndTransition();
             }
-
-            if (canAnnouncePageDescription()) {
-                announcePageForAccessibility();
-            }
         }
         return false;
     }
@@ -445,7 +437,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
     }
 
     public int getNormalChildHeight() {
-        return  getExpectedHeight() - getPaddingTop() - getPaddingBottom()
+        return getExpectedHeight() - getPaddingTop() - getPaddingBottom()
                 - mInsets.top - mInsets.bottom;
     }
 
@@ -453,8 +445,9 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
         return getMeasuredWidth();
     }
 
+    // Used for recents view.
     public int getNormalChildWidth() {
-        return  getExpectedWidth() - getPaddingLeft() - getPaddingRight()
+        return getExpectedWidth() - getPaddingLeft() - getPaddingRight()
                 - mInsets.left - mInsets.right;
     }
 
@@ -513,6 +506,10 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
     @SuppressLint("DrawAllocation")
     @Override
     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        Log.d(
+            TAG,
+            "onLayout() called with: changed = [" + changed + "], left = [" + left + "], top = [" + top + "], right = [" + right + "], bottom = [" + bottom + "]"
+        );
         mIsLayoutValid = true;
         final int childCount = getChildCount();
         boolean pageScrollChanged = false;
@@ -539,7 +536,8 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
 
                 @Override
                 public void startTransition(LayoutTransition transition, ViewGroup container,
-                                            View view, int transitionType) { }
+                                            View view, int transitionType) {
+                }
 
                 @Override
                 public void endTransition(LayoutTransition transition, ViewGroup container,
@@ -568,7 +566,6 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
     /**
      * Initializes {@code outPageScrolls} with scroll positions for view at that index. The length
      * of {@code outPageScrolls} should be same as the the childCount
-     *
      */
     protected boolean getPageScrolls(int[] outPageScrolls, boolean layoutChildren,
                                      ComputePageScrollsLogic scrollLogic) {
@@ -585,7 +582,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
         final int scrollOffsetRight = getWidth() - getPaddingRight() - mInsets.right;
         boolean pageScrollChanged = false;
 
-        for (int i = startIndex, childLeft = scrollOffsetLeft; i != endIndex; i += delta) {
+        for (int i = startIndex, childLeft = scrollOffsetLeft + offsetForPageScrolls(); i != endIndex; i += delta) {
             final View child = getPageAt(i);
             if (scrollLogic.shouldIncludeView(child)) {
                 final int childWidth = child.getMeasuredWidth();
@@ -601,7 +598,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
                 // based on the orientation.
                 final int pageScroll = mIsRtl
                         ? (childLeft - scrollOffsetLeft)
-                        : Math.max(0, childRight  - scrollOffsetRight);
+                        : Math.max(0, childRight - scrollOffsetRight);
                 if (outPageScrolls[i] != pageScroll) {
                     pageScrollChanged = true;
                     outPageScrolls[i] = pageScroll;
@@ -618,7 +615,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
     }
 
     private void updateMaxScrollX() {
-        mMaxScrollX = computeMaxScrollX();
+        mMaxScroll = computeMaxScrollX();
     }
 
     protected int computeMaxScrollX() {
@@ -645,6 +642,16 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
         invalidate();
     }
 
+    protected void updateMinAndMaxScrollX() {
+        mMinScroll = computeMinScrollX();
+        mMaxScroll = computeMaxScrollX();
+    }
+
+    protected int computeMinScrollX() {
+        return 0;
+    }
+
+
     @Override
     public void onViewAdded(View child) {
         super.onViewAdded(child);
@@ -663,6 +670,10 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
         return getPageAt(index).getLeft();
     }
 
+    protected int offsetForPageScrolls() {
+        return 0;
+    }
+
     @Override
     public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) {
         int page = indexToPage(indexOfChild(child));
@@ -735,7 +746,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
             if (mCurrentPage > 0) {
                 getPageAt(mCurrentPage - 1).addFocusables(views, direction, focusableMode);
             }
-        } else if (direction == View.FOCUS_RIGHT){
+        } else if (direction == View.FOCUS_RIGHT) {
             if (mCurrentPage < getPageCount() - 1) {
                 getPageAt(mCurrentPage + 1).addFocusables(views, direction, focusableMode);
             }
@@ -745,7 +756,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
     /**
      * If one of our descendant views decides that it could be focused now, only
      * pass that along if it's on the current page.
-     *
+     * <p>
      * This happens when live folders requery, and if they're off page, they
      * end up calling requestFocus, which pulls it on page.
      */
@@ -763,7 +774,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
             }
             ViewParent parent = v.getParent();
             if (parent instanceof View) {
-                v = (View)v.getParent();
+                v = (View) v.getParent();
             } else {
                 return;
             }
@@ -779,14 +790,16 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
             // We need to make sure to cancel our long press if
             // a scrollable widget takes over touch events
             final View currentPage = getPageAt(mCurrentPage);
-            if(currentPage != null) {
+            if (currentPage != null) {
                 currentPage.cancelLongPress();
             }
         }
         super.requestDisallowInterceptTouchEvent(disallowIntercept);
     }
 
-    /** Returns whether x and y originated within the buffered viewport */
+    /**
+     * Returns whether x and y originated within the buffered viewport
+     */
     private boolean isTouchPointInViewportWithBuffer(int x, int y) {
         sTmpRect.set(-getMeasuredWidth() / 2, 0, 3 * getMeasuredWidth() / 2, getMeasuredHeight());
         return sTmpRect.contains(x, y);
@@ -848,8 +861,9 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
                  * otherwise don't.  mScroller.isFinished should be false when
                  * being flinged.
                  */
-                final int xDist = Math.abs(mScroller.getFinalX() - mScroller.getCurrX());
-                final boolean finishedScrolling = (mScroller.isFinished() || xDist < mTouchSlop / 3);
+                final int xDist = Math.abs(mScroller.getFinalPos() - mScroller.getCurrPos());
+                final boolean finishedScrolling =
+                        (mScroller.isFinished() || xDist < mTouchSlop / 3);
 
                 if (finishedScrolling) {
                     mTouchState = TOUCH_STATE_REST;
@@ -957,7 +971,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
 
         float scrollProgress = delta / (totalDistance * 1.0f);
         scrollProgress = Math.min(scrollProgress, MAX_SCROLL_PROGRESS);
-        scrollProgress = Math.max(scrollProgress, - MAX_SCROLL_PROGRESS);
+        scrollProgress = Math.max(scrollProgress, -MAX_SCROLL_PROGRESS);
         return scrollProgress;
     }
 
@@ -989,25 +1003,38 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
         int overScrollAmount = OverScroll.dampedScroll(amount, getMeasuredWidth());
         if (amount < 0) {
             mOverScrollX = overScrollAmount;
-            super.scrollTo(mOverScrollX, getScrollY());
         } else {
-            mOverScrollX = mMaxScrollX + overScrollAmount;
-            super.scrollTo(mOverScrollX, getScrollY());
+            mOverScrollX = mMaxScroll + overScrollAmount;
         }
+        super.scrollTo(mOverScrollX, getScrollY());
         invalidate();
     }
 
-    protected void overScroll(float amount) {
-        dampedOverScroll(amount);
-    }
+    protected void overScroll(int amount) {
+        mSpringOverScrollX = amount;
+        if (mScroller.isSpringing()) {
+            invalidate();
+            return;
+        }
+
+        if (amount == 0) return;
 
+        if (mFreeScroll && !mScroller.isFinished()) {
+            if (amount < 0) {
+                super.scrollTo(mMinScroll + amount, getScrollY());
+            } else {
+                super.scrollTo(mMaxScroll + amount, getScrollY());
+            }
+        } else {
+            dampedOverScroll(amount);
+        }    }
 
     protected void enableFreeScroll(boolean settleOnPageInFreeScroll) {
         setEnableFreeScroll(true);
         mSettleOnPageInFreeScroll = settleOnPageInFreeScroll;
     }
 
-    private void setEnableFreeScroll(boolean freeScroll) {
+    protected void setEnableFreeScroll(boolean freeScroll) {
         boolean wasFreeScroll = mFreeScroll;
         mFreeScroll = freeScroll;
 
@@ -1017,13 +1044,17 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
             snapToPage(getNextPage());
         }
 
-        setEnableOverscroll(!freeScroll);
+        setEnableOverScroll(!freeScroll);
     }
 
-    protected void setEnableOverscroll(boolean enable) {
+    protected void setEnableOverScroll(boolean enable) {
         mAllowOverScroll = enable;
     }
 
+    protected void restoreScrollOnLayout() {
+        setCurrentPage(getNextPage());
+    }
+
     @Override
     public boolean onTouchEvent(MotionEvent ev) {
         super.onTouchEvent(ev);
@@ -1070,8 +1101,10 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
 
                     mTotalMotionX += Math.abs(deltaX);
 
-                    // Only scroll and update mLastMotionX if we have moved some discrete amount.  We
-                    // keep the remainder because we are actually testing if we've moved from the last
+                    // Only scroll and update mLastMotionX if we have moved some discrete amount.
+                    // We
+                    // keep the remainder because we are actually testing if we've moved from the
+                    // last
                     // scrolled position (which is discrete).
                     if (Math.abs(deltaX) >= 1.0f) {
                         scrollBy((int) deltaX, 0);
@@ -1080,7 +1113,8 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
                     } else {
                         awakenScrollBars();
                     }
-                } else {
+                }
+                else {
                     determineScrollingStart(ev);
                 }
                 break;
@@ -1099,11 +1133,15 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
                             SIGNIFICANT_MOVE_THRESHOLD;
 
                     mTotalMotionX += Math.abs(mLastMotionX + mLastMotionXRemainder - x);
-                    boolean isFling = mTotalMotionX > mTouchSlop && shouldFlingForVelocity(velocityX);
+                    boolean isFling =
+                            mTotalMotionX > mTouchSlop && shouldFlingForVelocity(velocityX);
+                    boolean isDeltaXLeft = mIsRtl ? deltaX > 0 : deltaX < 0;
+                    boolean isVelocityXLeft = mIsRtl ? velocityX > 0 : velocityX < 0;
 
                     if (!mFreeScroll) {
                         // In the case that the page is moved far to one direction and then is flung
-                        // in the opposite direction, we use a threshold to determine whether we should
+                        // in the opposite direction, we use a threshold to determine whether we
+                        // should
                         // just return to the starting page, or if we should skip one further.
                         boolean returnToOriginalPage = false;
                         if (Math.abs(deltaX) > pageWidth * RETURN_TO_ORIGINAL_PAGE_THRESHOLD &&
@@ -1112,11 +1150,11 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
                         }
 
                         int finalPage;
-                        // We give flings precedence over large moves, which is why we short-circuit our
+                        // We give flings precedence over large moves, which is why we
+                        // short-circuit our
                         // test for a large move if a fling has been registered. That is, a large
-                        // move to the left and fling to the right will register as a fling to the right.
-                        boolean isDeltaXLeft = mIsRtl ? deltaX > 0 : deltaX < 0;
-                        boolean isVelocityXLeft = mIsRtl ? velocityX > 0 : velocityX < 0;
+                        // move to the left and fling to the right will register as a fling to
+                        // the right.
                         if (((isSignificantMove && !isDeltaXLeft && !isFling) ||
                                 (isFling && !isVelocityXLeft)) && mCurrentPage > 0) {
                             finalPage = returnToOriginalPage ? mCurrentPage : mCurrentPage - 1;
@@ -1134,40 +1172,49 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
                             abortScrollerAnimation(true);
                         }
 
-                        float scaleX = getScaleX();
-                        int vX = (int) (-velocityX * scaleX);
-                        int initialScrollX = (int) (getScrollX() * scaleX);
-
-                        mScroller.fling(initialScrollX,
-                                getScrollY(), vX, 0, Integer.MIN_VALUE, Integer.MAX_VALUE, 0, 0);
-                        int unscaledScrollX = (int) (mScroller.getFinalX() / scaleX);
-                        mNextPage = getPageNearestToCenterOfScreen(unscaledScrollX);
-                        int firstPageScroll = getScrollForPage(!mIsRtl ? 0 : getPageCount() - 1);
-                        int lastPageScroll = getScrollForPage(!mIsRtl ? getPageCount() - 1 : 0);
-                        if (mSettleOnPageInFreeScroll && unscaledScrollX > 0
-                                && unscaledScrollX < mMaxScrollX) {
-                            // If scrolling ends in the half of the added space that is closer to the
-                            // end, settle to the end. Otherwise snap to the nearest page.
-                            // If flinging past one of the ends, don't change the velocity as it will
-                            // get stopped at the end anyway.
-                            final int finalX = unscaledScrollX < firstPageScroll / 2 ?
-                                    0 :
-                                    unscaledScrollX > (lastPageScroll + mMaxScrollX) / 2 ?
-                                            mMaxScrollX :
-                                            getScrollForPage(mNextPage);
-
-                            mScroller.setFinalX((int) (finalX * getScaleX()));
-                            // Ensure the scroll/snap doesn't happen too fast;
-                            int extraScrollDuration = OVERSCROLL_PAGE_SNAP_ANIMATION_DURATION
+                        int initialScrollX = getScrollX();
+
+                        if (((initialScrollX >= mMaxScroll) && (isVelocityXLeft || !isFling)) ||
+                            ((initialScrollX <= mMinScroll) && (!isVelocityXLeft || !isFling))) {
+                            mScroller.springBack(getScrollX(), mMinScroll, mMaxScroll);
+                            mNextPage = getPageNearestToCenterOfScreen();
+                        } else {
+                            mScroller.setInterpolator(mDefaultInterpolator);
+                            mScroller.fling(initialScrollX,
+                                -velocityX, mMinScroll, mMaxScroll, Math.round(getWidth() * 0.5f * OVERSCROLL_DAMP_FACTOR));
+                            int finalX = mScroller.getFinalPos();
+                            mNextPage = getPageNearestToCenterOfScreen(finalX);
+                            int firstPageScroll = getScrollForPage(!mIsRtl ? 0 : getPageCount() - 1);
+                            int lastPageScroll = getScrollForPage(!mIsRtl ? getPageCount() - 1 : 0);
+                            if (finalX > 0
+                                && finalX < mMaxScroll) {
+                                // If scrolling ends in the half of the added space that is closer to
+                                // the
+                                // end, settle to the end. Otherwise snap to the nearest page.
+                                // If flinging past one of the ends, don't change the velocity as it
+                                // will
+                                // get stopped at the end anyway.
+                                int pageSnappedX = finalX < (firstPageScroll + mMinScroll) / 2
+                                    ? mMinScroll
+                                    : finalX > (lastPageScroll + mMaxScroll) / 2
+                                    ? mMaxScroll
+                                    : getScrollForPage(mNextPage);
+
+                                mScroller.setFinalPos(pageSnappedX);
+                                // Ensure the scroll/snap doesn't happen too fast;
+                                int extraScrollDuration = OVERSCROLL_PAGE_SNAP_ANIMATION_DURATION
                                     - mScroller.getDuration();
-                            if (extraScrollDuration > 0) {
-                                mScroller.extendDuration(extraScrollDuration);
+                                if (extraScrollDuration > 0) {
+                                    mScroller.extendDuration(extraScrollDuration);
+                                }
                             }
+
                         }
                         invalidate();
                     }
                     onScrollInteractionEnd();
-                } else if (mTouchState == TOUCH_STATE_PREV_PAGE) {
+                }
+                else if (mTouchState == TOUCH_STATE_PREV_PAGE) {
                     // at this point we have not moved beyond the touch slop
                     // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so
                     // we can just page
@@ -1177,7 +1224,8 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
                     } else {
                         snapToDestination();
                     }
-                } else if (mTouchState == TOUCH_STATE_NEXT_PAGE) {
+                }
+                else if (mTouchState == TOUCH_STATE_NEXT_PAGE) {
                     // at this point we have not moved beyond the touch slop
                     // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so
                     // we can just page
@@ -1231,22 +1279,22 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
 
     @Override
     public boolean onGenericMotionEvent(MotionEvent event) {
-        if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {
+        if (event.isFromSource(InputDevice.SOURCE_CLASS_POINTER)) {
             switch (event.getAction()) {
                 case MotionEvent.ACTION_SCROLL: {
                     // Handle mouse (or ext. device) by shifting the page depending on the scroll
-                    final float vscroll;
-                    final float hscroll;
+                    final float vScroll;
+                    final float hScroll;
                     if ((event.getMetaState() & KeyEvent.META_SHIFT_ON) != 0) {
-                        vscroll = 0;
-                        hscroll = event.getAxisValue(MotionEvent.AXIS_VSCROLL);
+                        vScroll = 0;
+                        hScroll = event.getAxisValue(MotionEvent.AXIS_VSCROLL);
                     } else {
-                        vscroll = -event.getAxisValue(MotionEvent.AXIS_VSCROLL);
-                        hscroll = event.getAxisValue(MotionEvent.AXIS_HSCROLL);
+                        vScroll = -event.getAxisValue(MotionEvent.AXIS_VSCROLL);
+                        hScroll = event.getAxisValue(MotionEvent.AXIS_HSCROLL);
                     }
-                    if (hscroll != 0 || vscroll != 0) {
-                        boolean isForwardScroll = mIsRtl ? (hscroll < 0 || vscroll < 0)
-                                : (hscroll > 0 || vscroll > 0);
+                    if (hScroll != 0 || vScroll != 0) {
+                        boolean isForwardScroll = mIsRtl ? (hScroll < 0 || vScroll < 0)
+                                : (hScroll > 0 || vScroll > 0);
                         if (isForwardScroll) {
                             scrollRight();
                         } else {
@@ -1330,7 +1378,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
     }
 
     protected boolean isInOverScroll() {
-        return (mOverScrollX > mMaxScrollX || mOverScrollX < 0);
+        return (mOverScrollX > mMaxScroll || mOverScrollX < 0);
     }
 
     protected int getPageSnapDuration() {
@@ -1388,32 +1436,30 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
     }
 
     public boolean snapToPageImmediately(int whichPage) {
-        return snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION, true, null);
+        return snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION, true);
     }
 
     public boolean snapToPage(int whichPage, int duration) {
-        return snapToPage(whichPage, duration, false, null);
-    }
-
-    public boolean snapToPage(int whichPage, int duration, TimeInterpolator interpolator) {
-        return snapToPage(whichPage, duration, false, interpolator);
+        return snapToPage(whichPage, duration, false);
     }
 
-    protected boolean snapToPage(int whichPage, int duration, boolean immediate,
-                                 TimeInterpolator interpolator) {
+    public boolean snapToPage(int whichPage, int duration, boolean immediate) {
         whichPage = validateNewPage(whichPage);
 
         int newX = getScrollForPage(whichPage);
         final int delta = newX - getUnboundedScrollX();
-        return snapToPage(whichPage, delta, duration, immediate, interpolator);
+        return snapToPage(whichPage, delta, duration, immediate);
     }
 
     protected boolean snapToPage(int whichPage, int delta, int duration) {
-        return snapToPage(whichPage, delta, duration, false, null);
+        return snapToPage(whichPage, delta, duration, false);
     }
 
-    protected boolean snapToPage(int whichPage, int delta, int duration, boolean immediate,
-                                 TimeInterpolator interpolator) {
+    protected boolean snapToPage(int whichPage, int delta, int duration, boolean immediate) {
+        Log.d(TAG,
+                "snapToPage() called with: whichPage = [" + whichPage + "], delta = [" + delta +
+                        "], duration = [" + duration + "], immediate = [" + immediate + "], " +
+                        "unboundedScrollX = [" + getUnboundedScrollX() + "]");
         if (mFirstLayout) {
             setCurrentPage(whichPage);
             return false;
@@ -1438,7 +1484,7 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
             abortScrollerAnimation(false);
         }
 
-        mScroller.startScroll(getUnboundedScrollX(), 0, delta, 0, duration);
+        mScroller.startScroll(getUnboundedScrollX(), delta, duration);
 
         updatePageIndicator();
 
@@ -1468,91 +1514,25 @@ public abstract class PagedView<T extends View & PageIndicator> extends ViewGrou
         return false;
     }
 
-    @Override
-    public CharSequence getAccessibilityClassName() {
-        // Some accessibility services have special logic for ScrollView. Since we provide same
-        // accessibility info as ScrollView, inform the service to handle use the same way.
-        return ScrollView.class.getName();
-    }
-
-    protected boolean isPageOrderFlipped() {
-        return false;
-    }
-
-    /* Accessibility */
-    @SuppressWarnings("deprecation")
-    @Override
-    public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
-        super.onInitializeAccessibilityNodeInfo(info);
-        final boolean pagesFlipped = isPageOrderFlipped();
-        info.setScrollable(getPageCount() > 1);
-        if (getCurrentPage() < getPageCount() - 1) {
-            info.addAction(pagesFlipped ? AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD
-                    : AccessibilityNodeInfo.ACTION_SCROLL_FORWARD);
-        }
-        if (getCurrentPage() > 0) {
-            info.addAction(pagesFlipped ? AccessibilityNodeInfo.ACTION_SCROLL_FORWARD
-                    : AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD);
-        }
-
-        // Accessibility-wise, PagedView doesn't support long click, so disabling it.
-        // Besides disabling the accessibility long-click, this also prevents this view from getting
-        // accessibility focus.
-        info.setLongClickable(false);
-        info.removeAction(AccessibilityNodeInfo.AccessibilityAction.ACTION_LONG_CLICK);
-    }
-
-    @Override
-    public void sendAccessibilityEvent(int eventType) {
-        // Don't let the view send real scroll events.
-        if (eventType != AccessibilityEvent.TYPE_VIEW_SCROLLED) {
-            super.sendAccessibilityEvent(eventType);
-        }
+    protected float getDownMotionX() {
+        return mDownMotionX;
     }
 
-    @Override
-    public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
-        super.onInitializeAccessibilityEvent(event);
-        event.setScrollable(getPageCount() > 1);
+    protected float getDownMotionY() {
+        return mDownMotionY;
     }
 
-    @Override
-    public boolean performAccessibilityAction(int action, Bundle arguments) {
-        if (super.performAccessibilityAction(action, arguments)) {
-            return true;
-        }
-        final boolean pagesFlipped = isPageOrderFlipped();
-        switch (action) {
-            case AccessibilityNodeInfo.ACTION_SCROLL_FORWARD: {
-                if (pagesFlipped ? scrollLeft() : scrollRight()) {
-                    return true;
-                }
-            } break;
-            case AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD: {
-                if (pagesFlipped ? scrollRight() : scrollLeft()) {
-                    return true;
-                }
-            }
-            break;
-        }
+    protected boolean isPageOrderFlipped() {
         return false;
     }
 
-    protected boolean canAnnouncePageDescription() {
-        return true;
-    }
-
-    protected String getCurrentPageDescription() {
+    public String getCurrentPageDescription() {
         return getContext().getString(R.string.default_scroll_format,
-                getNextPage() + 1, getChildCount());
+            getNextPage() + 1, getChildCount());
     }
 
-    protected float getDownMotionX() {
-        return mDownMotionX;
-    }
-
-    protected float getDownMotionY() {
-        return mDownMotionY;
+    public int getPageSpacing() {
+        return mPageSpacing;
     }
 
     protected interface ComputePageScrollsLogic {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/PathParser.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/PathParser.java
index 7a00f3e63fa7bb904c8642935936bf85a757562c..8ffc92dc0600b008cab7cf13ea9cbbd874c3efb4 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/PathParser.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/PathParser.java
@@ -1,8 +1,8 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.graphics.Path;
 import android.util.Log;
-
 import java.util.ArrayList;
 import java.util.Arrays;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/RoundedWidgetView.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/RoundedWidgetView.java
index 101be1547f41d321ba33ab3e55ef9a9392586976..c2657d51779fd7454c8dc2b560ad5707afa0f5d1 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/RoundedWidgetView.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/RoundedWidgetView.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.appwidget.AppWidgetHostView;
 import android.content.Context;
 import android.graphics.Canvas;
@@ -11,9 +12,7 @@ import android.view.View;
 import android.view.ViewGroup;
 import android.widget.FrameLayout;
 import android.widget.ImageView;
-
 import androidx.annotation.Nullable;
-
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.features.widgets.CheckLongPressHelper;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/SquareFrameLayout.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/SquareFrameLayout.java
index 67e4b0c262805ecafdc0f3be37bf21f38049cfe3..a6be4b4bd66f6f13ce9f26b1a6e1f8274a1ae8a4 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/SquareFrameLayout.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/SquareFrameLayout.java
@@ -1,9 +1,9 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.content.Context;
 import android.util.AttributeSet;
 import android.widget.FrameLayout;
-
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/SquareImageView.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/SquareImageView.java
index ce90e78fbcb879ab16e06dd74f0b2267e818a0d1..9037dec5afc271bfc1cf025ffceea9a38146b3f5 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/SquareImageView.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/SquareImageView.java
@@ -1,30 +1,39 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.content.Context;
 import android.util.AttributeSet;
 
 import androidx.appcompat.widget.AppCompatImageView;
 
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+
 /**
  * Created by falcon on 16/2/18.
  */
 
 public class SquareImageView extends AppCompatImageView {
 
+    private VariantDeviceProfile deviceProfile;
+
     public SquareImageView(Context context) {
         this(context, null);
     }
 
     public SquareImageView(Context context, AttributeSet attributeSet) {
         super(context, attributeSet);
+        TestActivity launcher = TestActivity.Companion.getLauncher(context);
+        deviceProfile = launcher.getDeviceProfile();
     }
 
     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+
         int width = getMeasuredWidth();
         int height = getMeasuredHeight();
-        int size = width < height ? width : height;
-        setMeasuredDimension(size, size);
+        int size = Math.min(width, height);
+        setMeasuredDimension(deviceProfile.getIconSizePx(), deviceProfile.getIconSizePx());
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/SquareLinearLayout.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/SquareLinearLayout.java
index 5b4f13f4da381b2af6d32f6591c29463f8c39092..9d3dcec9f3403e8dc4668452f553fd52be21edca 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/SquareLinearLayout.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/SquareLinearLayout.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.content.Context;
 import android.util.AttributeSet;
 import android.widget.LinearLayout;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/WidgetHost.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/WidgetHost.java
index 10ec70ead799db853e86a8458bec7460ecb5bd9d..8208b5236e6fabf1300acc52313a4f437940c7a7 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/WidgetHost.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/WidgetHost.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.customviews;
 
+
 import android.appwidget.AppWidgetHost;
 import android.appwidget.AppWidgetHostView;
 import android.appwidget.AppWidgetProviderInfo;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/Workspace.java b/app/src/main/java/foundation/e/blisslauncher/core/customviews/Workspace.java
deleted file mode 100644
index 934693cd08c245b8ec0c1e3810c751c1bc8a53a9..0000000000000000000000000000000000000000
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/Workspace.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package foundation.e.blisslauncher.core.customviews;
-
-import android.animation.LayoutTransition;
-import android.content.Context;
-import android.util.AttributeSet;
-import android.view.MotionEvent;
-import android.view.View;
-
-import foundation.e.blisslauncher.core.customviews.pageindicators.PageIndicatorDots;
-import foundation.e.blisslauncher.features.launcher.LauncherActivity;
-
-public class Workspace extends PagedView<PageIndicatorDots> implements View.OnTouchListener{
-
-    private static final String TAG = "Workspace";
-    private static final int DEFAULT_PAGE = 0;
-    private final LauncherActivity mLauncher;
-    private LayoutTransition mLayoutTransition;
-
-    public Workspace(Context context, AttributeSet attributeSet) {
-        this(context, attributeSet, 0);
-    }
-
-    public Workspace(Context context, AttributeSet attributeSet, int defStyle) {
-        super(context, attributeSet, defStyle);
-
-        mLauncher = LauncherActivity.getLauncher(context);
-        setHapticFeedbackEnabled(false);
-        initWorkspace();
-
-        setOnTouchListener(new OnTouchListener() {
-            @Override
-            public boolean onTouch(View v, MotionEvent event) {
-                return false;
-            }
-        });
-    }
-
-    private void initWorkspace() {
-        mCurrentPage = DEFAULT_PAGE;
-        setClipToPadding(false);
-        setupLayoutTransition();
-
-        //setWallpaperDimension();
-    }
-
-    private void setupLayoutTransition() {
-        // We want to show layout transitions when pages are deleted, to close the gap.
-        mLayoutTransition = new LayoutTransition();
-        mLayoutTransition.enableTransitionType(LayoutTransition.DISAPPEARING);
-        mLayoutTransition.enableTransitionType(LayoutTransition.CHANGE_DISAPPEARING);
-        mLayoutTransition.disableTransitionType(LayoutTransition.APPEARING);
-        mLayoutTransition.disableTransitionType(LayoutTransition.CHANGE_APPEARING);
-        setLayoutTransition(mLayoutTransition);
-    }
-
-    void enableLayoutTransitions() {
-        setLayoutTransition(mLayoutTransition);
-    }
-    void disableLayoutTransitions() {
-        setLayoutTransition(null);
-    }
-
-    @Override
-    public boolean onTouch(View v, MotionEvent event) {
-        return false;
-    }
-}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/pageindicators/PageIndicator.kt b/app/src/main/java/foundation/e/blisslauncher/core/customviews/pageindicators/PageIndicator.kt
index d75d0800112b731871d64206554ccbcac8f585d6..171ea79aee1d32f85b66945c53a22cd9777fa206 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/pageindicators/PageIndicator.kt
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/pageindicators/PageIndicator.kt
@@ -7,4 +7,4 @@ interface PageIndicator {
     fun setScroll(currentScroll: Int, totalScroll: Int)
     fun setActiveMarker(activePage: Int)
     fun setMarkersCount(numMarkers: Int)
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/customviews/pageindicators/PageIndicatorDots.kt b/app/src/main/java/foundation/e/blisslauncher/core/customviews/pageindicators/PageIndicatorDots.kt
index eb032fcb0039ae4f011cedeba8d4f0be7326bb6c..d3d96802855e70a944db2c1aa39dcdecdd2964e0 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/customviews/pageindicators/PageIndicatorDots.kt
+++ b/app/src/main/java/foundation/e/blisslauncher/core/customviews/pageindicators/PageIndicatorDots.kt
@@ -12,19 +12,25 @@ import android.graphics.Paint
 import android.graphics.RectF
 import android.util.AttributeSet
 import android.util.Property
+import android.view.Gravity
 import android.view.View
 import android.view.ViewOutlineProvider
+import android.view.WindowInsets
 import android.view.animation.Interpolator
 import android.view.animation.OvershootInterpolator
 import foundation.e.blisslauncher.R
+import foundation.e.blisslauncher.core.customviews.Insettable
+import foundation.e.blisslauncher.features.test.BaseDragLayer
+import foundation.e.blisslauncher.features.test.TestActivity
 import kotlin.math.abs
 
 /**
  * [PageIndicator] which shows dots per page. The active page is shown with the current
  * accent color.
  */
-class PageIndicatorDots(context: Context?, attrs: AttributeSet?, defStyleAttr: Int) :
-    View(context, attrs, defStyleAttr), PageIndicator {
+class PageIndicatorDots(context: Context, attrs: AttributeSet?, defStyleAttr: Int) :
+    View(context, attrs, defStyleAttr), PageIndicator, Insettable {
+    private var mLauncher: TestActivity
     private val mCirclePaint: Paint = Paint(Paint.ANTI_ALIAS_FLAG)
     private val mDotRadius: Float
     private val mActiveColor: Int
@@ -32,6 +38,7 @@ class PageIndicatorDots(context: Context?, attrs: AttributeSet?, defStyleAttr: I
     private val mIsRtl: Boolean = false
     private var mNumPages = 0
     private var mActivePage = 0
+
     /**
      * The current position of the active dot including the animation progress.
      * For ex:
@@ -46,8 +53,8 @@ class PageIndicatorDots(context: Context?, attrs: AttributeSet?, defStyleAttr: I
     private var mAnimator: ObjectAnimator? = null
     private var mEntryAnimationRadiusFactors: FloatArray? = null
 
-    constructor(context: Context?) : this(context, null)
-    constructor(context: Context?, attrs: AttributeSet?) : this(context, attrs, 0)
+    constructor(context: Context) : this(context, null)
+    constructor(context: Context, attrs: AttributeSet?) : this(context, attrs, 0)
 
     override fun setScroll(currentScroll: Int, totalScroll: Int) {
         var currentScroll = currentScroll
@@ -151,6 +158,7 @@ class PageIndicatorDots(context: Context?, attrs: AttributeSet?, defStyleAttr: I
         if (mActivePage != activePage) {
             mActivePage = activePage
         }
+        invalidate()
     }
 
     override fun setMarkersCount(numMarkers: Int) {
@@ -254,6 +262,7 @@ class PageIndicatorDots(context: Context?, attrs: AttributeSet?, defStyleAttr: I
      */
     private inner class AnimationCycleListener : AnimatorListenerAdapter() {
         private var mCancelled = false
+
         override fun onAnimationCancel(animation: Animator?) {
             mCancelled = true
         }
@@ -270,12 +279,16 @@ class PageIndicatorDots(context: Context?, attrs: AttributeSet?, defStyleAttr: I
         private const val SHIFT_PER_ANIMATION = 0.5f
         private const val SHIFT_THRESHOLD = 0.1f
         private const val ANIMATION_DURATION: Long = 150
+
         private const val ENTER_ANIMATION_START_DELAY = 300
         private const val ENTER_ANIMATION_STAGGERED_DELAY = 150
         private const val ENTER_ANIMATION_DURATION = 400
+
         // This value approximately overshoots to 1.5 times the original size.
         private const val ENTER_ANIMATION_OVERSHOOT_TENSION = 4.9f
+
         private val sTempRect: RectF? = RectF()
+
         private val CURRENT_POSITION: Property<PageIndicatorDots, Float> =
             object : Property<PageIndicatorDots, Float>(
                 Float::class.java, "current_position"
@@ -293,11 +306,21 @@ class PageIndicatorDots(context: Context?, attrs: AttributeSet?, defStyleAttr: I
     }
 
     init {
+        mLauncher = TestActivity.getLauncher(context)
         mCirclePaint.style = Paint.Style.FILL
         mDotRadius = resources.getDimension(R.dimen.dotSize) / 2
         outlineProvider = MyOutlineProver()
         mActiveColor = resources.getColor(R.color.dot_on_color)
-        mInActiveColor = resources.getColor(R.color.dot_on_color)
-        //mIsRtl = Utilities.isRtl(getResources())
+        mInActiveColor = resources.getColor(R.color.dot_off_color)
+        // mIsRtl = Utilities.isRtl(getResources())
+    }
+
+    override fun setInsets(insets: WindowInsets) {
+        val deviceProfile = mLauncher.deviceProfile
+        val lp = layoutParams as BaseDragLayer.LayoutParams
+        lp.leftMargin = 0.also { lp.rightMargin = it }
+        lp.gravity = Gravity.CENTER_HORIZONTAL or Gravity.BOTTOM
+        lp.bottomMargin = deviceProfile.hotseatBarSizePx + resources.getDimensionPixelSize(R.dimen.dotPadding) * 2 + insets.systemWindowInsetBottom
+        layoutParams = lp
     }
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/database/DatabaseManager.java b/app/src/main/java/foundation/e/blisslauncher/core/database/DatabaseManager.java
index 9819fbc7959655341ac801911c6833df4f66adb2..dafb44c947b1b2fc71f55a168b56c02cf6cdc6d3 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/database/DatabaseManager.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/database/DatabaseManager.java
@@ -1,11 +1,8 @@
 package foundation.e.blisslauncher.core.database;
 
+
 import android.content.Context;
 import android.widget.GridLayout;
-
-import java.util.ArrayList;
-import java.util.List;
-
 import foundation.e.blisslauncher.core.customviews.BlissFrameLayout;
 import foundation.e.blisslauncher.core.database.model.FolderItem;
 import foundation.e.blisslauncher.core.database.model.LauncherItem;
@@ -13,6 +10,8 @@ import foundation.e.blisslauncher.core.database.model.WidgetItem;
 import foundation.e.blisslauncher.core.executors.AppExecutors;
 import foundation.e.blisslauncher.core.utils.Constants;
 import io.reactivex.Single;
+import java.util.ArrayList;
+import java.util.List;
 
 public class DatabaseManager {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/database/LauncherDB.java b/app/src/main/java/foundation/e/blisslauncher/core/database/LauncherDB.java
index 477e022ca28d44ef933fba4bac41e7178b1c86d6..eab48cc7238732a96ce7c34583d57542766d6227 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/database/LauncherDB.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/database/LauncherDB.java
@@ -1,8 +1,8 @@
 package foundation.e.blisslauncher.core.database;
 
 
-import android.content.Context;
 
+import android.content.Context;
 import androidx.annotation.NonNull;
 import androidx.room.Database;
 import androidx.room.Room;
@@ -10,7 +10,6 @@ import androidx.room.RoomDatabase;
 import androidx.room.TypeConverters;
 import androidx.room.migration.Migration;
 import androidx.sqlite.db.SupportSQLiteDatabase;
-
 import foundation.e.blisslauncher.core.database.converters.CharSequenceConverter;
 import foundation.e.blisslauncher.core.database.daos.LauncherDao;
 import foundation.e.blisslauncher.core.database.daos.WidgetDao;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/database/converters/CharSequenceConverter.java b/app/src/main/java/foundation/e/blisslauncher/core/database/converters/CharSequenceConverter.java
index 6ab349367f9d41a3d46108b7cef41061fa360b94..e2e2de853f03c1ac1f189279433cf2ba73112510 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/database/converters/CharSequenceConverter.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/database/converters/CharSequenceConverter.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.database.converters;
 
+
 import androidx.room.TypeConverter;
 
 public class CharSequenceConverter {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/database/daos/LauncherDao.java b/app/src/main/java/foundation/e/blisslauncher/core/database/daos/LauncherDao.java
index 68a3ea571465429f411588a0e2a9308ad73f93e7..01562fd565b1d0da7618d185e138e9e347960fc9 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/database/daos/LauncherDao.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/database/daos/LauncherDao.java
@@ -1,15 +1,14 @@
 package foundation.e.blisslauncher.core.database.daos;
 
 
+
 import androidx.room.Dao;
 import androidx.room.Insert;
 import androidx.room.OnConflictStrategy;
 import androidx.room.Query;
-
-import java.util.List;
-
 import foundation.e.blisslauncher.core.database.model.LauncherItem;
 import foundation.e.blisslauncher.core.utils.Constants;
+import java.util.List;
 
 @Dao
 public interface LauncherDao {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/database/daos/WidgetDao.java b/app/src/main/java/foundation/e/blisslauncher/core/database/daos/WidgetDao.java
index e23172c2e47e09d0544da1d0c76999f3a7d68dbe..0c40ccb3cad948cbb9e3c61d1eb6ee9559f9f38b 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/database/daos/WidgetDao.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/database/daos/WidgetDao.java
@@ -1,13 +1,12 @@
 package foundation.e.blisslauncher.core.database.daos;
 
+
 import androidx.room.Dao;
 import androidx.room.Insert;
 import androidx.room.OnConflictStrategy;
 import androidx.room.Query;
-
-import java.util.List;
-
 import foundation.e.blisslauncher.core.database.model.WidgetItem;
+import java.util.List;
 
 @Dao
 public interface WidgetDao {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/database/model/ApplicationItem.java b/app/src/main/java/foundation/e/blisslauncher/core/database/model/ApplicationItem.java
index d2730485b9bad1d80792db946a4a251b745704f6..daac0facb95cd5b93c4bf3d24f61b7575b3ef56c 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/database/model/ApplicationItem.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/database/model/ApplicationItem.java
@@ -1,10 +1,10 @@
 package foundation.e.blisslauncher.core.database.model;
 
+
 import android.content.ComponentName;
 import android.content.Intent;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.LauncherActivityInfo;
-
 import foundation.e.blisslauncher.core.utils.Constants;
 import foundation.e.blisslauncher.core.utils.UserHandle;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/database/model/CalendarIcon.java b/app/src/main/java/foundation/e/blisslauncher/core/database/model/CalendarIcon.java
index e0ac91cbb49a21f49986fcb3761183e1fe8e05f0..9402d8e054be49d5df9ff89b7af88d5a0a8f9873 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/database/model/CalendarIcon.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/database/model/CalendarIcon.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.database.model;
 
+
 import android.widget.TextView;
 
 /**
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/database/model/FolderItem.java b/app/src/main/java/foundation/e/blisslauncher/core/database/model/FolderItem.java
index 8f1ac50867568081b51cf6622f6bc72615edba7c..c96d7304c5bf57408088ee14171a9ea41a8ac0f4 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/database/model/FolderItem.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/database/model/FolderItem.java
@@ -1,8 +1,8 @@
 package foundation.e.blisslauncher.core.database.model;
 
-import java.util.List;
 
 import foundation.e.blisslauncher.core.utils.Constants;
+import java.util.List;
 
 public class FolderItem extends LauncherItem {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/database/model/LauncherItem.java b/app/src/main/java/foundation/e/blisslauncher/core/database/model/LauncherItem.java
index 15860ca805d8ae3a9bb98f2d47fa9cda0652cf68..4de62c0ea6504fd97a6a24920aeec13d51ab8cc0 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/database/model/LauncherItem.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/database/model/LauncherItem.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.database.model;
 
+
 import android.content.ComponentName;
 import android.content.Intent;
 import android.graphics.drawable.Drawable;
@@ -138,6 +139,15 @@ public class LauncherItem {
         }
     }
 
+    public void copyFrom(LauncherItem item) {
+        this.id = item.id;
+        this.itemType = item.itemType;
+        this.screenId = item.screenId;
+        this.container = item.container;
+        this.user = item.user;
+        this.cell = item.cell;
+    }
+
     @Override
     public String toString() {
         return "[id: " + id + "item_type: " + itemType + ", container: " + container + ", screen: " + screenId
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/database/model/ShortcutItem.java b/app/src/main/java/foundation/e/blisslauncher/core/database/model/ShortcutItem.java
index 5db545ec30dfab652b83464e66888c88bb7ee623..511a84759562e50f605afb21bf19107f74e6204a 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/database/model/ShortcutItem.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/database/model/ShortcutItem.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.database.model;
 
+
 import foundation.e.blisslauncher.core.utils.Constants;
 
 public class ShortcutItem extends LauncherItem {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/database/model/WidgetItem.java b/app/src/main/java/foundation/e/blisslauncher/core/database/model/WidgetItem.java
index 28de71e054c76f08a3147360554bad7f50e00bfb..fbe0c94ac999811273e35a823e86b437484f0b24 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/database/model/WidgetItem.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/database/model/WidgetItem.java
@@ -1,6 +1,7 @@
 package foundation.e.blisslauncher.core.database.model;
 
 
+
 import androidx.room.Entity;
 import androidx.room.PrimaryKey;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/events/AppAddEvent.java b/app/src/main/java/foundation/e/blisslauncher/core/events/AppAddEvent.java
index 229b56345cb405cce9229db11343a43f2dc7d55a..f68e71fefa30abcf146c7dd6be591fb70f72964e 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/events/AppAddEvent.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/events/AppAddEvent.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.events;
 
+
 import foundation.e.blisslauncher.core.utils.UserHandle;
 
 public class AppAddEvent extends Event{
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/events/AppChangeEvent.java b/app/src/main/java/foundation/e/blisslauncher/core/events/AppChangeEvent.java
index 55916dece29f7ee11b3d58dc206060af9585c1cf..55b98f0a41feef004e0ac4f558e543e77ad16051 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/events/AppChangeEvent.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/events/AppChangeEvent.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.events;
 
+
 import foundation.e.blisslauncher.core.utils.UserHandle;
 
 public class AppChangeEvent extends Event{
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/events/AppRemoveEvent.java b/app/src/main/java/foundation/e/blisslauncher/core/events/AppRemoveEvent.java
index 1b6987696a02dcdd16ad7b395d2899e302f3ce03..c8cbca6c999b41f17740ea81a4df1868c3de92f3 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/events/AppRemoveEvent.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/events/AppRemoveEvent.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.events;
 
+
 import foundation.e.blisslauncher.core.utils.UserHandle;
 
 public class AppRemoveEvent extends Event {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/events/EventRelay.java b/app/src/main/java/foundation/e/blisslauncher/core/events/EventRelay.java
index 4587951ab8091d903939a14e523233f752e91a51..d908cd2147bdd036fa2bdda747658e46dc488976 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/events/EventRelay.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/events/EventRelay.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.events;
 
+
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/events/ShortcutAddEvent.java b/app/src/main/java/foundation/e/blisslauncher/core/events/ShortcutAddEvent.java
index 6de089ffe7bd37e4591c40e7f3c4be738794f414..6ac772c4cbaba43ba16b36a9228436458fa2e9b0 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/events/ShortcutAddEvent.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/events/ShortcutAddEvent.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.events;
 
+
 import foundation.e.blisslauncher.core.database.model.ShortcutItem;
 
 public class ShortcutAddEvent extends Event {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/executors/AppExecutors.java b/app/src/main/java/foundation/e/blisslauncher/core/executors/AppExecutors.java
index be58e20827435c8ad5ecf9bd701f3e6531ba4b86..225fef92f7f4236a7fb8ebddca9bd7f42972d34d 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/executors/AppExecutors.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/executors/AppExecutors.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.executors;
 
+
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/executors/LooperExecutor.java b/app/src/main/java/foundation/e/blisslauncher/core/executors/LooperExecutor.java
new file mode 100644
index 0000000000000000000000000000000000000000..cfa66be69048db61592025c36ca05d0b1223fa91
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/executors/LooperExecutor.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+package foundation.e.blisslauncher.core.executors;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import java.util.List;
+import java.util.concurrent.AbstractExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Extension of {@link AbstractExecutorService} which executed on a provided looper.
+ */
+public class LooperExecutor extends AbstractExecutorService {
+
+    private final Handler mHandler;
+
+    public LooperExecutor(Looper looper) {
+        mHandler = new Handler(looper);
+    }
+
+    public Handler getHandler() {
+        return mHandler;
+    }
+
+    @Override
+    public void execute(Runnable runnable) {
+        if (mHandler.getLooper() == Looper.myLooper()) {
+            runnable.run();
+        } else {
+            mHandler.post(runnable);
+        }
+    }
+
+    /**
+     * Not supported and throws an exception when used.
+     */
+    @Override
+    @Deprecated
+    public void shutdown() {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Not supported and throws an exception when used.
+     */
+    @Override
+    @Deprecated
+    public List<Runnable> shutdownNow() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean isShutdown() {
+        return false;
+    }
+
+    @Override
+    public boolean isTerminated() {
+        return false;
+    }
+
+    /**
+     * Not supported and throws an exception when used.
+     */
+    @Override
+    @Deprecated
+    public boolean awaitTermination(long l, TimeUnit timeUnit) throws InterruptedException {
+        throw new UnsupportedOperationException();
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/executors/MainThreadExecutor.java b/app/src/main/java/foundation/e/blisslauncher/core/executors/MainThreadExecutor.java
index 1088b1c02d725227458563cee90d926b7f171cdd..3e9e7a83944f912b69d29c59886b7a779269fe45 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/executors/MainThreadExecutor.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/executors/MainThreadExecutor.java
@@ -1,53 +1,17 @@
 package foundation.e.blisslauncher.core.executors;
 
+
 import android.os.Handler;
 import android.os.Looper;
-
 import androidx.annotation.NonNull;
-
 import java.util.List;
 import java.util.concurrent.AbstractExecutorService;
 import java.util.concurrent.TimeUnit;
 
-public class MainThreadExecutor extends AbstractExecutorService {
-
-    private final Handler mHandler;
+public class MainThreadExecutor extends LooperExecutor {
 
     public MainThreadExecutor() {
-        mHandler = new Handler(Looper.getMainLooper());
-    }
-    @Override
-    public void shutdown() {
-        throw new UnsupportedOperationException();
-    }
-
-    @NonNull
-    @Override
-    public List<Runnable> shutdownNow() {
-        throw new UnsupportedOperationException();
+        super(Looper.getMainLooper());
     }
 
-    @Override
-    public boolean isShutdown() {
-        return false;
-    }
-
-    @Override
-    public boolean isTerminated() {
-        return false;
-    }
-
-    @Override
-    public boolean awaitTermination(long timeout, @NonNull TimeUnit unit) throws InterruptedException {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public void execute(@NonNull Runnable runnable) {
-        if (mHandler.getLooper() == Looper.myLooper()) {
-            runnable.run();
-        } else {
-            mHandler.post(runnable);
-        }
-    }
 }
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/migrate/CurrentMigration.java b/app/src/main/java/foundation/e/blisslauncher/core/migrate/CurrentMigration.java
index 64ab058779afe5abe6da9bb695c07c22532789d6..2a177fd9f6ff42a522653e521ab625812318d8c5 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/migrate/CurrentMigration.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/migrate/CurrentMigration.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.migrate;
 
+
 import java.util.List;
 
 public class CurrentMigration {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/migrate/MigrateComponentInfo.java b/app/src/main/java/foundation/e/blisslauncher/core/migrate/MigrateComponentInfo.java
index 749b68b9e120a88def8249f1fadb79a33055e44a..bd29bcb192ff10715ebfeef94c14169f2e1026a7 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/migrate/MigrateComponentInfo.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/migrate/MigrateComponentInfo.java
@@ -4,4 +4,3 @@ class MigrateComponentInfo {
     String old_component_name;
     String new_component_name;
 }
-
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/migrate/Migration.java b/app/src/main/java/foundation/e/blisslauncher/core/migrate/Migration.java
index 151ffb71cf3f72bfd4a25e298ae7317e05e5e40a..79f8c507f067d1ad7419cd46feae6f5553d5b9f7 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/migrate/Migration.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/migrate/Migration.java
@@ -1,19 +1,17 @@
 package foundation.e.blisslauncher.core.migrate;
 
+
 import android.content.Context;
 import android.util.Log;
-
 import com.google.gson.Gson;
-
+import foundation.e.blisslauncher.core.Preferences;
+import foundation.e.blisslauncher.core.database.DatabaseManager;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
-import foundation.e.blisslauncher.core.Preferences;
-import foundation.e.blisslauncher.core.database.DatabaseManager;
-
 public class Migration {
 
     public static volatile Migration instance;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/migrate/MigrationInfo.java b/app/src/main/java/foundation/e/blisslauncher/core/migrate/MigrationInfo.java
index eec2b8eb6930f4a3770704cc09aee5893fc03725..0552c46cf32ebdc1af6e78f1577375d8bf332d6f 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/migrate/MigrationInfo.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/migrate/MigrationInfo.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.migrate;
 
+
 import java.util.List;
 
 public class MigrationInfo implements Comparable<MigrationInfo> {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/network/RetrofitService.java b/app/src/main/java/foundation/e/blisslauncher/core/network/RetrofitService.java
index 7072f65f2ec5d9a925f29040b602d117d70423ea..1c4bea6d55d81c28a51e3f30c47c703989215e0f 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/network/RetrofitService.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/network/RetrofitService.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.network;
 
+
 import okhttp3.OkHttpClient;
 import okhttp3.logging.HttpLoggingInterceptor;
 import retrofit2.Retrofit;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/network/duckduckgo/DuckDuckGoSuggestionService.java b/app/src/main/java/foundation/e/blisslauncher/core/network/duckduckgo/DuckDuckGoSuggestionService.java
index 49e2929e198d60af5c61647f1dda29f7860e1bfc..f95ed15e2825ce1e3d5387cd543d32110f00e086 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/network/duckduckgo/DuckDuckGoSuggestionService.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/network/duckduckgo/DuckDuckGoSuggestionService.java
@@ -1,8 +1,8 @@
 package foundation.e.blisslauncher.core.network.duckduckgo;
 
-import java.util.List;
 
 import io.reactivex.Observable;
+import java.util.List;
 import retrofit2.http.GET;
 import retrofit2.http.Query;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantData.java b/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantData.java
index 949511a3f1660c02d27dc9dc999c020e203ef97e..065d0dc16072b6b330fe8aef298a4ac2c03306d9 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantData.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantData.java
@@ -1,8 +1,8 @@
 package foundation.e.blisslauncher.core.network.qwant;
 
+
 import com.google.gson.annotations.Expose;
 import com.google.gson.annotations.SerializedName;
-
 import java.util.List;
 
 public class QwantData {
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantItem.java b/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantItem.java
index f576ae7915d5aa81c698a4265159e643a911c0dd..a33a29fdf0839e77a9ece1aa881adc9ba343f6cf 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantItem.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantItem.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.network.qwant;
 
+
 import com.google.gson.annotations.Expose;
 import com.google.gson.annotations.SerializedName;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantResult.java b/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantResult.java
index 80c3a599b3759162ef400d10c0b862c302067f9b..8385430ce819180282e9641f086360c76c311a74 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantResult.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantResult.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.network.qwant;
 
+
 import com.google.gson.annotations.Expose;
 import com.google.gson.annotations.SerializedName;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantSuggestionService.java b/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantSuggestionService.java
index bb1a90ef7b6d57c51719082c9dd197c377dd1caf..b63a41b494b74ee58424de9e8606d2269b38e9a7 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantSuggestionService.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/network/qwant/QwantSuggestionService.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.network.qwant;
 
+
 import io.reactivex.Observable;
 import retrofit2.http.GET;
 import retrofit2.http.Query;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/touch/AbstractStateChangeTouchController.java b/app/src/main/java/foundation/e/blisslauncher/core/touch/AbstractStateChangeTouchController.java
new file mode 100644
index 0000000000000000000000000000000000000000..f701aed8f605701b777702b16cccd5d111dca40e
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/touch/AbstractStateChangeTouchController.java
@@ -0,0 +1,459 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.core.touch;
+
+import static foundation.e.blisslauncher.core.Utilities.SINGLE_FRAME_MS;
+import static foundation.e.blisslauncher.features.test.LauncherState.NORMAL;
+import static foundation.e.blisslauncher.features.test.LauncherState.OVERVIEW;
+import static foundation.e.blisslauncher.features.test.LauncherStateManager.ANIM_ALL;
+import static foundation.e.blisslauncher.features.test.LauncherStateManager.ATOMIC_OVERVIEW_SCALE_COMPONENT;
+import static foundation.e.blisslauncher.features.test.LauncherStateManager.NON_ATOMIC_COMPONENT;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.scrollInterpolatorForVelocity;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ValueAnimator;
+import android.view.HapticFeedbackConstants;
+import android.view.MotionEvent;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.utils.FlingBlockCheck;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.LauncherStateManager;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.TouchController;
+import foundation.e.blisslauncher.features.test.anim.AnimationSuccessListener;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+import foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils;
+import foundation.e.blisslauncher.features.test.anim.PendingAnimation;
+
+/**
+ * TouchController for handling state changes
+ */
+public abstract class AbstractStateChangeTouchController
+        implements TouchController, SwipeDetector.Listener {
+
+    private static final String TAG = "ASCTouchController";
+
+    // Progress after which the transition is assumed to be a success in case user does not fling
+    public static final float SUCCESS_TRANSITION_PROGRESS = 0.5f;
+
+    /**
+     * Play an atomic recents animation when the progress from NORMAL to OVERVIEW reaches this.
+     */
+    public static final float ATOMIC_OVERVIEW_ANIM_THRESHOLD = 0.5f;
+    protected final long ATOMIC_DURATION = getAtomicDuration();
+
+    protected final TestActivity mLauncher;
+    protected final SwipeDetector mDetector;
+
+    private boolean mNoIntercept;
+    protected int mStartContainerType;
+
+    protected LauncherState mStartState;
+    protected LauncherState mFromState;
+    protected LauncherState mToState;
+    protected AnimatorPlaybackController mCurrentAnimation;
+    protected PendingAnimation mPendingAnimation;
+
+    private float mStartProgress;
+    // Ratio of transition process [0, 1] to drag displacement (px)
+    private float mProgressMultiplier;
+    private float mDisplacementShift;
+    private boolean mCanBlockFling;
+    private FlingBlockCheck mFlingBlockCheck = new FlingBlockCheck();
+
+    public AnimatorSet mAtomicAnim;
+    private boolean mPassedOverviewAtomicThreshold;
+    // mAtomicAnim plays the atomic components of the state animations when we pass the threshold.
+    // However, if we reinit to transition to a new state (e.g. OVERVIEW -> ALL_APPS) before the
+    // atomic animation finishes, we only control the non-atomic components so that we don't
+    // interfere with the atomic animation. When the atomic animation ends, we start controlling
+    // the atomic components as well, using this controller.
+    private AnimatorPlaybackController mAtomicComponentsController;
+    private float mAtomicComponentsStartProgress;
+
+    public AbstractStateChangeTouchController(TestActivity l, SwipeDetector.Direction dir) {
+        mLauncher = l;
+        mDetector = new SwipeDetector(l, this, dir);
+    }
+
+    protected long getAtomicDuration() {
+        return 200;
+    }
+
+    protected abstract boolean canInterceptTouch(MotionEvent ev);
+
+    @Override
+    public final boolean onControllerInterceptTouchEvent(MotionEvent ev) {
+        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
+            mNoIntercept = !canInterceptTouch(ev);
+            if (mNoIntercept) {
+                return false;
+            }
+
+            // Now figure out which direction scroll events the controller will start
+            // calling the callbacks.
+            final int directionsToDetectScroll;
+            boolean ignoreSlopWhenSettling = false;
+
+            if (mCurrentAnimation != null) {
+                directionsToDetectScroll = SwipeDetector.DIRECTION_BOTH;
+                ignoreSlopWhenSettling = true;
+            } else {
+                directionsToDetectScroll = getSwipeDirection();
+                if (directionsToDetectScroll == 0) {
+                    mNoIntercept = true;
+                    return false;
+                }
+            }
+            mDetector.setDetectableScrollConditions(
+                    directionsToDetectScroll, ignoreSlopWhenSettling);
+        }
+
+        if (mNoIntercept) {
+            return false;
+        }
+
+        onControllerTouchEvent(ev);
+        return mDetector.isDraggingOrSettling();
+    }
+
+    private int getSwipeDirection() {
+        LauncherState fromState = mLauncher.getStateManager().getState();
+        int swipeDirection = 0;
+        if (getTargetState(fromState, true /* isDragTowardPositive */) != fromState) {
+            swipeDirection |= SwipeDetector.DIRECTION_POSITIVE;
+        }
+        if (getTargetState(fromState, false /* isDragTowardPositive */) != fromState) {
+            swipeDirection |= SwipeDetector.DIRECTION_NEGATIVE;
+        }
+        return swipeDirection;
+    }
+
+    @Override
+    public final boolean onControllerTouchEvent(MotionEvent ev) {
+        return mDetector.onTouchEvent(ev);
+    }
+
+    /**
+     * Returns the state to go to from fromState given the drag direction. If there is no state in
+     * that direction, returns fromState.
+     */
+    protected abstract LauncherState getTargetState(LauncherState fromState,
+            boolean isDragTowardPositive);
+
+    protected abstract float initCurrentAnimation(@LauncherStateManager.AnimationComponents int animComponents);
+
+    private boolean reinitCurrentAnimation(boolean reachedToState, boolean isDragTowardPositive) {
+        LauncherState newFromState = mFromState == null ? mLauncher.getStateManager().getState()
+                : reachedToState ? mToState : mFromState;
+        LauncherState newToState = getTargetState(newFromState, isDragTowardPositive);
+
+        if (newFromState == mFromState && newToState == mToState || (newFromState == newToState)) {
+            return false;
+        }
+
+        mFromState = newFromState;
+        mToState = newToState;
+
+        mStartProgress = 0;
+        mPassedOverviewAtomicThreshold = false;
+        if (mCurrentAnimation != null) {
+            mCurrentAnimation.setOnCancelRunnable(null);
+        }
+        int animComponents = goingBetweenNormalAndOverview(mFromState, mToState)
+                ? NON_ATOMIC_COMPONENT : ANIM_ALL;
+        if (mAtomicAnim != null) {
+            // Control the non-atomic components until the atomic animation finishes, then control
+            // the atomic components as well.
+            animComponents = NON_ATOMIC_COMPONENT;
+            mAtomicAnim.addListener(new AnimationSuccessListener() {
+                @Override
+                public void onAnimationSuccess(Animator animation) {
+                    cancelAtomicComponentsController();
+                    if (mCurrentAnimation != null) {
+                        mAtomicComponentsStartProgress = mCurrentAnimation.getProgressFraction();
+                        long duration = 200l;
+                        mAtomicComponentsController = AnimatorPlaybackController.wrap(
+                                createAtomicAnimForState(mFromState, mToState, duration), duration);
+                        mAtomicComponentsController.dispatchOnStart();
+                    }
+                }
+            });
+        }
+        if (goingBetweenNormalAndOverview(mFromState, mToState)) {
+            cancelAtomicComponentsController();
+        }
+        mProgressMultiplier = initCurrentAnimation(animComponents);
+        mCurrentAnimation.dispatchOnStart();
+        return true;
+    }
+
+    private boolean goingBetweenNormalAndOverview(LauncherState fromState, LauncherState toState) {
+        return (fromState == NORMAL || fromState == OVERVIEW)
+                && (toState == NORMAL || toState == OVERVIEW)
+                && mPendingAnimation == null;
+    }
+
+    @Override
+    public void onDragStart(boolean start) {
+        mStartState = mLauncher.getStateManager().getState();
+        if (mCurrentAnimation == null) {
+            mFromState = mStartState;
+            mToState = null;
+            mAtomicComponentsController = null;
+            reinitCurrentAnimation(false, mDetector.wasInitialTouchPositive());
+            mDisplacementShift = 0;
+        } else {
+            mCurrentAnimation.pause();
+            mStartProgress = mCurrentAnimation.getProgressFraction();
+        }
+        mCanBlockFling = mFromState == NORMAL;
+        mFlingBlockCheck.unblockFling();
+    }
+
+    @Override
+    public boolean onDrag(float displacement) {
+        float deltaProgress = mProgressMultiplier * (displacement - mDisplacementShift);
+        float progress = deltaProgress + mStartProgress;
+        updateProgress(progress);
+        boolean isDragTowardPositive = (displacement - mDisplacementShift) < 0;
+        if (progress <= 0) {
+            if (reinitCurrentAnimation(false, isDragTowardPositive)) {
+                mDisplacementShift = displacement;
+                if (mCanBlockFling) {
+                    mFlingBlockCheck.blockFling();
+                }
+            }
+        } else if (progress >= 1) {
+            if (reinitCurrentAnimation(true, isDragTowardPositive)) {
+                mDisplacementShift = displacement;
+                if (mCanBlockFling) {
+                    mFlingBlockCheck.blockFling();
+                }
+            }
+        } else {
+            mFlingBlockCheck.onEvent();
+        }
+
+        return true;
+    }
+
+    protected void updateProgress(float fraction) {
+        mCurrentAnimation.setPlayFraction(fraction);
+        if (mAtomicComponentsController != null) {
+            mAtomicComponentsController.setPlayFraction(fraction - mAtomicComponentsStartProgress);
+        }
+        maybeUpdateAtomicAnim(mFromState, mToState, fraction);
+    }
+
+    /**
+     * When going between normal and overview states, see if we passed the overview threshold and
+     * play the appropriate atomic animation if so.
+     */
+    private void maybeUpdateAtomicAnim(LauncherState fromState, LauncherState toState,
+            float progress) {
+        if (!goingBetweenNormalAndOverview(fromState, toState)) {
+            return;
+        }
+        float threshold = toState == OVERVIEW ? ATOMIC_OVERVIEW_ANIM_THRESHOLD
+                : 1f - ATOMIC_OVERVIEW_ANIM_THRESHOLD;
+        boolean passedThreshold = progress >= threshold;
+        if (passedThreshold != mPassedOverviewAtomicThreshold) {
+            LauncherState atomicFromState = passedThreshold ? fromState: toState;
+            LauncherState atomicToState = passedThreshold ? toState : fromState;
+            mPassedOverviewAtomicThreshold = passedThreshold;
+            if (mAtomicAnim != null) {
+                mAtomicAnim.cancel();
+            }
+            mAtomicAnim = createAtomicAnimForState(atomicFromState, atomicToState, ATOMIC_DURATION);
+            mAtomicAnim.addListener(new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    mAtomicAnim = null;
+                }
+            });
+            mAtomicAnim.start();
+            mLauncher.getDragLayer().performHapticFeedback(HapticFeedbackConstants.CONTEXT_CLICK);
+        }
+    }
+
+    private AnimatorSet createAtomicAnimForState(LauncherState fromState, LauncherState targetState,
+            long duration) {
+        AnimatorSetBuilder builder = getAnimatorSetBuilderForStates(fromState, targetState);
+        return mLauncher.getStateManager().createAtomicAnimation(fromState, targetState, builder,
+            ATOMIC_OVERVIEW_SCALE_COMPONENT, duration);
+    }
+
+    protected AnimatorSetBuilder getAnimatorSetBuilderForStates(LauncherState fromState,
+        LauncherState toState) {
+        return new AnimatorSetBuilder();
+    }
+
+    @Override
+    public void onDragEnd(float velocity, boolean fling) {
+        boolean blockedFling = fling && mFlingBlockCheck.isBlocked();
+        if (blockedFling) {
+            fling = false;
+        }
+
+        final LauncherState targetState;
+        final float progress = mCurrentAnimation.getProgressFraction();
+        if (fling) {
+            targetState =
+                    Float.compare(Math.signum(velocity), Math.signum(mProgressMultiplier)) == 0
+                            ? mToState : mFromState;
+            // snap to top or bottom using the release velocity
+        } else {
+            float successProgress = SUCCESS_TRANSITION_PROGRESS;
+            targetState = (progress > successProgress) ? mToState : mFromState;
+        }
+
+        final float endProgress;
+        final float startProgress;
+        final long duration;
+        // Increase the duration if we prevented the fling, as we are going against a high velocity.
+        final int durationMultiplier = blockedFling && targetState == mFromState
+                ? LauncherAnimUtils.blockedFlingDurationFactor(velocity) : 1;
+
+        if (targetState == mToState) {
+            endProgress = 1;
+            if (progress >= 1) {
+                duration = 0;
+                startProgress = 1;
+            } else {
+                startProgress = Utilities.boundToRange(
+                        progress + velocity * SINGLE_FRAME_MS * mProgressMultiplier, 0f, 1f);
+                duration = SwipeDetector.calculateDuration(velocity,
+                        endProgress - Math.max(progress, 0)) * durationMultiplier;
+            }
+        } else {
+            // Let the state manager know that the animation didn't go to the target state,
+            // but don't cancel ourselves (we already clean up when the animation completes).
+            Runnable onCancel = mCurrentAnimation.getOnCancelRunnable();
+            mCurrentAnimation.setOnCancelRunnable(null);
+            mCurrentAnimation.dispatchOnCancel();
+            mCurrentAnimation.setOnCancelRunnable(onCancel);
+
+            endProgress = 0;
+            if (progress <= 0) {
+                duration = 0;
+                startProgress = 0;
+            } else {
+                startProgress = Utilities.boundToRange(
+                        progress + velocity * SINGLE_FRAME_MS * mProgressMultiplier, 0f, 1f);
+                duration = SwipeDetector.calculateDuration(velocity,
+                        Math.min(progress, 1) - endProgress) * durationMultiplier;
+            }
+        }
+
+        mCurrentAnimation.setEndAction(() -> onSwipeInteractionCompleted(targetState));
+        ValueAnimator anim = mCurrentAnimation.getAnimationPlayer();
+        anim.setFloatValues(startProgress, endProgress);
+        maybeUpdateAtomicAnim(mFromState, targetState, targetState == mToState ? 1f : 0f);
+        updateSwipeCompleteAnimation(anim, Math.max(duration, getRemainingAtomicDuration()),
+                targetState, velocity, fling);
+        mCurrentAnimation.dispatchOnStart();
+        anim.start();
+        if (mAtomicAnim == null) {
+            startAtomicComponentsAnim(endProgress, anim.getDuration());
+        } else {
+            mAtomicAnim.addListener(new AnimationSuccessListener() {
+                @Override
+                public void onAnimationSuccess(Animator animator) {
+                    startAtomicComponentsAnim(endProgress, anim.getDuration());
+                }
+            });
+        }
+    }
+
+    /**
+     * Animates the atomic components from the current progress to the final progress.
+     *
+     * Note that this only applies when we are controlling the atomic components separately from
+     * the non-atomic components, which only happens if we reinit before the atomic animation
+     * finishes.
+     */
+    private void startAtomicComponentsAnim(float toProgress, long duration) {
+        if (mAtomicComponentsController != null) {
+            ValueAnimator atomicAnim = mAtomicComponentsController.getAnimationPlayer();
+            atomicAnim.setFloatValues(mAtomicComponentsController.getProgressFraction(), toProgress);
+            atomicAnim.setDuration(duration);
+            atomicAnim.start();
+            atomicAnim.addListener(new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    mAtomicComponentsController = null;
+                }
+            });
+        }
+    }
+
+    private long getRemainingAtomicDuration() {
+        if (mAtomicAnim == null) {
+            return 0;
+        }
+        if (Utilities.ATLEAST_OREO) {
+            return mAtomicAnim.getTotalDuration() - mAtomicAnim.getCurrentPlayTime();
+        } else {
+            long remainingDuration = 0;
+            for (Animator anim : mAtomicAnim.getChildAnimations()) {
+                remainingDuration = Math.max(remainingDuration, anim.getDuration());
+            }
+            return remainingDuration;
+        }
+    }
+
+    protected void updateSwipeCompleteAnimation(ValueAnimator animator, long expectedDuration,
+            LauncherState targetState, float velocity, boolean isFling) {
+        animator.setDuration(expectedDuration)
+                .setInterpolator(scrollInterpolatorForVelocity(velocity));
+    }
+
+    protected void onSwipeInteractionCompleted(LauncherState targetState) {
+        clearState();
+        boolean shouldGoToTargetState = true;
+        if (mPendingAnimation != null) {
+            boolean reachedTarget = mToState == targetState;
+            mPendingAnimation.finish(reachedTarget);
+            mPendingAnimation = null;
+            shouldGoToTargetState = !reachedTarget;
+        }
+        if (shouldGoToTargetState) {
+            mLauncher.getStateManager().goToState(targetState, false /* animated */);
+        }
+    }
+
+    protected void clearState() {
+        mCurrentAnimation = null;
+        cancelAtomicComponentsController();
+        mDetector.finishedScrolling();
+        mDetector.setDetectableScrollConditions(0, false);
+    }
+
+    private void cancelAtomicComponentsController() {
+        if (mAtomicComponentsController != null) {
+            mAtomicComponentsController.getAnimationPlayer().cancel();
+            mAtomicComponentsController = null;
+        }
+    }
+
+    protected float getShiftRange() {
+        return 0;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/touch/ItemClickHandler.java b/app/src/main/java/foundation/e/blisslauncher/core/touch/ItemClickHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8634624803cfa202f083629d74d2d52ef3f157f
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/touch/ItemClickHandler.java
@@ -0,0 +1,167 @@
+/*
+ * 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 foundation.e.blisslauncher.core.touch;
+
+import android.content.Intent;
+import android.util.Log;
+import android.view.View;
+import android.view.View.OnClickListener;
+
+import foundation.e.blisslauncher.core.database.model.ApplicationItem;
+import foundation.e.blisslauncher.core.database.model.FolderItem;
+import foundation.e.blisslauncher.core.database.model.LauncherItem;
+import foundation.e.blisslauncher.core.database.model.ShortcutItem;
+import foundation.e.blisslauncher.features.test.IconTextView;
+import foundation.e.blisslauncher.features.test.TestActivity;
+
+/**
+ * Class for handling clicks on workspace and all-apps items
+ */
+public class ItemClickHandler {
+
+    /**
+     * Instance used for click handling on items
+     */
+    public static final OnClickListener INSTANCE = ItemClickHandler::onClick;
+
+    private static void onClick(View v) {
+        // Make sure that rogue clicks don't get through while allapps is launching, or after the
+        // view has detached (it's possible for this to happen if the view is removed mid touch).
+        if (v.getWindowToken() == null) {
+            return;
+        }
+
+        TestActivity launcher = TestActivity.Companion.getLauncher(v.getContext());
+        //TODO:
+        /*if (!launcher.getWorkspace().isFinishedSwitchingState()) {
+            return;
+        }*/
+
+        Object tag = v.getTag();
+        if (tag instanceof ShortcutItem) {
+            onClickAppShortcut(v, (ShortcutItem) tag, launcher);
+        } else if (tag instanceof FolderItem) {
+            onClickFolderIcon(v);
+        } else if (tag instanceof ApplicationItem) {
+            startAppShortcutOrInfoActivity(v, (ApplicationItem) tag, launcher);
+        }
+    }
+
+    /**
+     * Event handler for a folder icon click.
+     *
+     * @param v The view that was clicked. Must be an instance of {@link IconTextView}.
+     */
+    private static void onClickFolderIcon(View v) {
+        Log.d("ItemClick", "onClickFolderIcon() called with: v = [" + v + "]");
+        /*Folder folder = ((FolderIcon) v).getFolder();
+        if (!folder.isOpen() && !folder.isDestroyed()) {
+            // Open the requested folder
+            folder.animateOpen();
+        }*/
+    }
+
+    /**
+     * Event handler for the app widget view which has not fully restored.
+     */
+    /*private static void onClickPendingWidget(PendingAppWidgetHostView v, Launcher launcher) {
+        if (launcher.getPackageManager().isSafeMode()) {
+            Toast.makeText(launcher, R.string.safemode_widget_error, Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        final LauncherAppWidgetInfo info = (LauncherAppWidgetInfo) v.getTag();
+        if (v.isReadyForClickSetup()) {
+            LauncherAppWidgetProviderInfo appWidgetInfo = AppWidgetManagerCompat
+                    .getInstance(launcher).findProvider(info.providerName, info.user);
+            if (appWidgetInfo == null) {
+                return;
+            }
+            WidgetAddFlowHandler addFlowHandler = new WidgetAddFlowHandler(appWidgetInfo);
+
+            if (info.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_NOT_VALID)) {
+                if (!info.hasRestoreFlag(LauncherAppWidgetInfo.FLAG_ID_ALLOCATED)) {
+                    // This should not happen, as we make sure that an Id is allocated during bind.
+                    return;
+                }
+                addFlowHandler.startBindFlow(launcher, info.appWidgetId, info,
+                        REQUEST_BIND_PENDING_APPWIDGET);
+            } else {
+                addFlowHandler.startConfigActivity(launcher, info, REQUEST_RECONFIGURE_APPWIDGET);
+            }
+        } else {
+            final String packageName = info.providerName.getPackageName();
+            onClickPendingAppItem(v, launcher, packageName, info.installProgress >= 0);
+        }
+    }*/
+
+    /**
+     * Event handler for an app shortcut click.
+     *
+     * @param v The view that was clicked. Must be a tagged with a {@link ShortcutItem}.
+     */
+    private static void onClickAppShortcut(View v, LauncherItem shortcut, TestActivity launcher) {
+        /*if (shortcut.isDisabled()) {
+            final int disabledFlags = shortcut.runtimeStatusFlags & ShortcutInfo.FLAG_DISABLED_MASK;
+            if ((disabledFlags &
+                    ~FLAG_DISABLED_SUSPENDED &
+                    ~FLAG_DISABLED_QUIET_USER) == 0) {
+                // If the app is only disabled because of the above flags, launch activity anyway.
+                // Framework will tell the user why the app is suspended.
+            } else {
+                if (!TextUtils.isEmpty(shortcut.disabledMessage)) {
+                    // Use a message specific to this shortcut, if it has one.
+                    Toast.makeText(launcher, shortcut.disabledMessage, Toast.LENGTH_SHORT).show();
+                    return;
+                }
+                // Otherwise just use a generic error message.
+                int error = R.string.activity_not_available;
+                if ((shortcut.runtimeStatusFlags & FLAG_DISABLED_SAFEMODE) != 0) {
+                    error = R.string.safemode_shortcut_error;
+                } else if ((shortcut.runtimeStatusFlags & FLAG_DISABLED_BY_PUBLISHER) != 0 ||
+                        (shortcut.runtimeStatusFlags & FLAG_DISABLED_LOCKED_USER) != 0) {
+                    error = R.string.shortcut_not_available;
+                }
+                Toast.makeText(launcher, error, Toast.LENGTH_SHORT).show();
+                return;
+            }
+        }*/
+
+        // Start activities
+        startAppShortcutOrInfoActivity(v, shortcut, launcher);
+    }
+
+    private static void startAppShortcutOrInfoActivity(View v, LauncherItem item, TestActivity launcher) {
+        Intent intent;
+        intent = item.getIntent();
+        if (intent == null) {
+            throw new IllegalArgumentException("Input must have a valid intent");
+        }
+        if (item instanceof ShortcutItem) {
+            ShortcutItem si = (ShortcutItem) item;
+            /*if (si.hasStatusFlag(ShortcutInfo.FLAG_SUPPORTS_WEB_UI)
+                    && intent.getAction() == Intent.ACTION_VIEW) {
+                // make a copy of the intent that has the package set to null
+                // we do this because the platform sometimes disables instant
+                // apps temporarily (triggered by the user) and fallbacks to the
+                // web ui. This only works though if the package isn't set
+                intent = new Intent(intent);
+                intent.setPackage(null);
+            }*/
+        }
+        launcher.startActivitySafely(v, intent, item);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/touch/ItemLongClickListener.java b/app/src/main/java/foundation/e/blisslauncher/core/touch/ItemLongClickListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..f0bffa8bf29ec350b7a056fef4935f44c3d493e1
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/touch/ItemLongClickListener.java
@@ -0,0 +1,86 @@
+/*
+ * 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 foundation.e.blisslauncher.core.touch;
+
+import android.util.Log;
+import android.view.View;
+import android.view.View.OnLongClickListener;
+
+import foundation.e.blisslauncher.core.database.model.LauncherItem;
+import foundation.e.blisslauncher.features.test.CellLayout;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.dragndrop.DragOptions;
+
+/**
+ * Class to handle long-clicks on workspace items and start drag as a result.
+ */
+public class ItemLongClickListener {
+
+    public static OnLongClickListener INSTANCE_WORKSPACE =
+        ItemLongClickListener::onWorkspaceItemLongClick;
+
+    private static final String TAG = "ItemLongClickListener";
+
+    private static boolean onWorkspaceItemLongClick(View v) {
+        int[] temp = new int[2];
+        v.getLocationOnScreen(temp);
+        Log.i(TAG,
+            "onWorkspaceItemLongClick: [" + v.getLeft() + ", " + v.getTop() + "] ["+temp[0]+", "+temp[1]+"]"
+        );
+        TestActivity launcher = TestActivity.Companion.getLauncher(v.getContext());
+        if (!canStartDrag(launcher)) return false;
+        //if (!launcher.isInState(NORMAL) && !launcher.isInState(OVERVIEW)) return false;
+        if (!(v.getTag() instanceof LauncherItem)) return false;
+
+        //launcher.setWaitingForResult(null);
+        beginDrag(v, launcher, (LauncherItem) v.getTag(), new DragOptions());
+        return true;
+    }
+
+    public static void beginDrag(
+        View v, TestActivity launcher, LauncherItem info,
+        DragOptions dragOptions
+    ) {
+        //TODO: Enable when supporting folders
+       /* if (info.container >= 0) {
+            Folder folder = Folder.getOpen(launcher);
+            if (folder != null) {
+                if (!folder.getItemsInReadingOrder().contains(v)) {
+                    folder.close(true);
+                } else {
+                    folder.startDrag(v, dragOptions);
+                    return;
+                }
+            }
+        }*/
+
+        CellLayout.CellInfo longClickCellInfo = new CellLayout.CellInfo(v, info);
+        launcher.getLauncherPagedView().startDrag(longClickCellInfo, dragOptions);
+    }
+
+    public static boolean canStartDrag(TestActivity launcher) {
+        if (launcher == null) {
+            return false;
+        }
+        // We prevent dragging when we are loading the workspace as it is possible to pick up a view
+        // that is subsequently removed from the workspace in startBinding().
+        if (launcher.isWorkspaceLocked()) return false;
+        // Return early if an item is already being dragged (e.g. when long-pressing two shortcuts)
+        if (launcher.getDragController().isDragging()) return false;
+
+        return true;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/touch/OverScroll.java b/app/src/main/java/foundation/e/blisslauncher/core/touch/OverScroll.java
index 1a89c0bef8a4d9cd4b03c84b403917e0df2fe0b8..9461f076a8e726915f4ebfd65db79a9f753acf84 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/touch/OverScroll.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/touch/OverScroll.java
@@ -5,7 +5,7 @@ package foundation.e.blisslauncher.core.touch;
  */
 public class OverScroll {
 
-    private static final float OVERSCROLL_DAMP_FACTOR = 0.07f;
+    public static final float OVERSCROLL_DAMP_FACTOR = 0.07f;
 
     /**
      * This curve determines how the effect of scrolling over the limits of the page diminishes
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/touch/SwipeDetector.java b/app/src/main/java/foundation/e/blisslauncher/core/touch/SwipeDetector.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d777adef7a6c6e2a9ad8b6e8a8408a25c49127d
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/touch/SwipeDetector.java
@@ -0,0 +1,404 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.core.touch;
+
+import static android.view.MotionEvent.INVALID_POINTER_ID;
+
+import android.content.Context;
+import android.graphics.PointF;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.ViewConfiguration;
+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
+import foundation.e.blisslauncher.core.Utilities;
+
+/**
+ * One dimensional scroll/drag/swipe gesture detector.
+ *
+ * Definition of swipe is different from android system in that this detector handles
+ * 'swipe to dismiss', 'swiping up/down a container' but also keeps scrolling state before
+ * swipe action happens
+ */
+public class SwipeDetector {
+
+    private static final boolean DBG = false;
+    private static final String TAG = "SwipeDetector";
+
+    private int mScrollConditions;
+    public static final int DIRECTION_POSITIVE = 1 << 0;
+    public static final int DIRECTION_NEGATIVE = 1 << 1;
+    public static final int DIRECTION_BOTH = DIRECTION_NEGATIVE | DIRECTION_POSITIVE;
+
+    private static final float ANIMATION_DURATION = 1200;
+
+    protected int mActivePointerId = INVALID_POINTER_ID;
+
+    /**
+     * The minimum release velocity in pixels per millisecond that triggers fling..
+     */
+    public static final float RELEASE_VELOCITY_PX_MS = 1.0f;
+
+    /* Scroll state, this is set to true during dragging and animation. */
+    private ScrollState mState = ScrollState.IDLE;
+
+    enum ScrollState {
+        IDLE,
+        DRAGGING,      // onDragStart, onDrag
+        SETTLING       // onDragEnd
+    }
+
+    public static abstract class Direction {
+
+        abstract float getDisplacement(MotionEvent ev, int pointerIndex, PointF refPoint,
+                boolean isRtl);
+
+        /**
+         * Distance in pixels a touch can wander before we think the user is scrolling.
+         */
+        abstract float getActiveTouchSlop(MotionEvent ev, int pointerIndex, PointF downPos);
+
+        abstract float getVelocity(VelocityTracker tracker, boolean isRtl);
+
+        abstract boolean isPositive(float displacement);
+
+        abstract boolean isNegative(float displacement);
+    }
+
+    public static final Direction VERTICAL = new Direction() {
+
+        @Override
+        float getDisplacement(MotionEvent ev, int pointerIndex, PointF refPoint, boolean isRtl) {
+            return ev.getY(pointerIndex) - refPoint.y;
+        }
+
+        @Override
+        float getActiveTouchSlop(MotionEvent ev, int pointerIndex, PointF downPos) {
+            return Math.abs(ev.getX(pointerIndex) - downPos.x);
+        }
+
+        @Override
+        float getVelocity(VelocityTracker tracker, boolean isRtl) {
+            return tracker.getYVelocity();
+        }
+
+        @Override
+        boolean isPositive(float displacement) {
+            // Up
+            return displacement < 0;
+        }
+
+        @Override
+        boolean isNegative(float displacement) {
+            // Down
+            return displacement > 0;
+        }
+    };
+
+    public static final Direction HORIZONTAL = new Direction() {
+
+        @Override
+        float getDisplacement(MotionEvent ev, int pointerIndex, PointF refPoint, boolean isRtl) {
+            float displacement = ev.getX(pointerIndex) - refPoint.x;
+            if (isRtl) {
+                displacement = -displacement;
+            }
+            return displacement;
+        }
+
+        @Override
+        float getActiveTouchSlop(MotionEvent ev, int pointerIndex, PointF downPos) {
+            return Math.abs(ev.getY(pointerIndex) - downPos.y);
+        }
+
+        @Override
+        float getVelocity(VelocityTracker tracker, boolean isRtl) {
+            float velocity = tracker.getXVelocity();
+            if (isRtl) {
+                velocity = -velocity;
+            }
+            return velocity;
+        }
+
+        @Override
+        boolean isPositive(float displacement) {
+            // Right
+            return displacement > 0;
+        }
+
+        @Override
+        boolean isNegative(float displacement) {
+            // Left
+            return displacement < 0;
+        }
+    };
+
+    //------------------- ScrollState transition diagram -----------------------------------
+    //
+    // IDLE ->      (mDisplacement > mTouchSlop) -> DRAGGING
+    // DRAGGING -> (MotionEvent#ACTION_UP, MotionEvent#ACTION_CANCEL) -> SETTLING
+    // SETTLING -> (MotionEvent#ACTION_DOWN) -> DRAGGING
+    // SETTLING -> (View settled) -> IDLE
+
+    private void setState(ScrollState newState) {
+        if (DBG) {
+            Log.d(TAG, "setState:" + mState + "->" + newState);
+        }
+        // onDragStart and onDragEnd is reported ONLY on state transition
+        if (newState == ScrollState.DRAGGING) {
+            initializeDragging();
+            if (mState == ScrollState.IDLE) {
+                reportDragStart(false /* recatch */);
+            } else if (mState == ScrollState.SETTLING) {
+                reportDragStart(true /* recatch */);
+            }
+        }
+        if (newState == ScrollState.SETTLING) {
+            reportDragEnd();
+        }
+
+        mState = newState;
+    }
+
+    public boolean isDraggingOrSettling() {
+        return mState == ScrollState.DRAGGING || mState == ScrollState.SETTLING;
+    }
+
+    public int getDownX() {
+        return (int) mDownPos.x;
+    }
+
+    public int getDownY() {
+        return (int) mDownPos.y;
+    }
+    /**
+     * There's no touch and there's no animation.
+     */
+    public boolean isIdleState() {
+        return mState == ScrollState.IDLE;
+    }
+
+    public boolean isSettlingState() {
+        return mState == ScrollState.SETTLING;
+    }
+
+    public boolean isDraggingState() {
+        return mState == ScrollState.DRAGGING;
+    }
+
+    private final PointF mDownPos = new PointF();
+    private final PointF mLastPos = new PointF();
+    private final Direction mDir;
+    private final boolean mIsRtl;
+
+    private final float mTouchSlop;
+    private final float mMaxVelocity;
+
+    /* Client of this gesture detector can register a callback. */
+    private final Listener mListener;
+
+    private VelocityTracker mVelocityTracker;
+
+    private float mLastDisplacement;
+    private float mDisplacement;
+
+    private float mSubtractDisplacement;
+    private boolean mIgnoreSlopWhenSettling;
+
+    public interface Listener {
+        void onDragStart(boolean start);
+
+        boolean onDrag(float displacement);
+
+        default boolean onDrag(float displacement, MotionEvent event) {
+            return onDrag(displacement);
+        }
+
+        void onDragEnd(float velocity, boolean fling);
+    }
+
+    public SwipeDetector(@NonNull Context context, @NonNull Listener l, @NonNull Direction dir) {
+        this(ViewConfiguration.get(context), l, dir, Utilities.isRtl(context.getResources()));
+    }
+
+    @VisibleForTesting
+    protected SwipeDetector(@NonNull ViewConfiguration config, @NonNull Listener l,
+            @NonNull Direction dir, boolean isRtl) {
+        mListener = l;
+        mDir = dir;
+        mIsRtl = isRtl;
+        mTouchSlop = config.getScaledTouchSlop();
+        mMaxVelocity = config.getScaledMaximumFlingVelocity();
+    }
+
+    public void setDetectableScrollConditions(int scrollDirectionFlags, boolean ignoreSlop) {
+        mScrollConditions = scrollDirectionFlags;
+        mIgnoreSlopWhenSettling = ignoreSlop;
+    }
+
+    public int getScrollDirections() {
+        return mScrollConditions;
+    }
+
+    private boolean shouldScrollStart(MotionEvent ev, int pointerIndex) {
+        // reject cases where the angle or slop condition is not met.
+        if (Math.max(mDir.getActiveTouchSlop(ev, pointerIndex, mDownPos), mTouchSlop)
+                > Math.abs(mDisplacement)) {
+            return false;
+        }
+
+        // Check if the client is interested in scroll in current direction.
+        if (((mScrollConditions & DIRECTION_NEGATIVE) > 0 && mDir.isNegative(mDisplacement)) ||
+                ((mScrollConditions & DIRECTION_POSITIVE) > 0 && mDir.isPositive(mDisplacement))) {
+            return true;
+        }
+        return false;
+    }
+
+    public boolean onTouchEvent(MotionEvent ev) {
+        int actionMasked = ev.getActionMasked();
+        if (actionMasked == MotionEvent.ACTION_DOWN && mVelocityTracker != null) {
+            mVelocityTracker.clear();
+        }
+        if (mVelocityTracker == null) {
+            mVelocityTracker = VelocityTracker.obtain();
+        }
+        mVelocityTracker.addMovement(ev);
+
+        switch (actionMasked) {
+            case MotionEvent.ACTION_DOWN:
+                mActivePointerId = ev.getPointerId(0);
+                mDownPos.set(ev.getX(), ev.getY());
+                mLastPos.set(mDownPos);
+                mLastDisplacement = 0;
+                mDisplacement = 0;
+
+                if (mState == ScrollState.SETTLING && mIgnoreSlopWhenSettling) {
+                    setState(ScrollState.DRAGGING);
+                }
+                break;
+            //case MotionEvent.ACTION_POINTER_DOWN:
+            case MotionEvent.ACTION_POINTER_UP:
+                int ptrIdx = ev.getActionIndex();
+                int ptrId = ev.getPointerId(ptrIdx);
+                if (ptrId == mActivePointerId) {
+                    final int newPointerIdx = ptrIdx == 0 ? 1 : 0;
+                    mDownPos.set(
+                            ev.getX(newPointerIdx) - (mLastPos.x - mDownPos.x),
+                            ev.getY(newPointerIdx) - (mLastPos.y - mDownPos.y));
+                    mLastPos.set(ev.getX(newPointerIdx), ev.getY(newPointerIdx));
+                    mActivePointerId = ev.getPointerId(newPointerIdx);
+                }
+                break;
+            case MotionEvent.ACTION_MOVE:
+                int pointerIndex = ev.findPointerIndex(mActivePointerId);
+                if (pointerIndex == INVALID_POINTER_ID) {
+                    break;
+                }
+                mDisplacement = mDir.getDisplacement(ev, pointerIndex, mDownPos, mIsRtl);
+
+                // handle state and listener calls.
+                if (mState != ScrollState.DRAGGING && shouldScrollStart(ev, pointerIndex)) {
+                    setState(ScrollState.DRAGGING);
+                }
+                if (mState == ScrollState.DRAGGING) {
+                    reportDragging(ev);
+                }
+                mLastPos.set(ev.getX(pointerIndex), ev.getY(pointerIndex));
+                break;
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP:
+                // These are synthetic events and there is no need to update internal values.
+                if (mState == ScrollState.DRAGGING) {
+                    setState(ScrollState.SETTLING);
+                }
+                mVelocityTracker.recycle();
+                mVelocityTracker = null;
+                break;
+            default:
+                break;
+        }
+        return true;
+    }
+
+    public void finishedScrolling() {
+        setState(ScrollState.IDLE);
+    }
+
+    private boolean reportDragStart(boolean recatch) {
+        mListener.onDragStart(!recatch);
+        if (DBG) {
+            Log.d(TAG, "onDragStart recatch:" + recatch);
+        }
+        return true;
+    }
+
+    private void initializeDragging() {
+        if (mState == ScrollState.SETTLING && mIgnoreSlopWhenSettling) {
+            mSubtractDisplacement = 0;
+        }
+        if (mDisplacement > 0) {
+            mSubtractDisplacement = mTouchSlop;
+        } else {
+            mSubtractDisplacement = -mTouchSlop;
+        }
+    }
+
+    /**
+     * Returns if the start drag was towards the positive direction or negative.
+     *
+     * @see #setDetectableScrollConditions(int, boolean)
+     * @see #DIRECTION_BOTH
+     */
+    public boolean wasInitialTouchPositive() {
+        return mDir.isPositive(mSubtractDisplacement);
+    }
+
+    private boolean reportDragging(MotionEvent event) {
+        if (mDisplacement != mLastDisplacement) {
+            if (DBG) {
+                Log.d(TAG, String.format("onDrag disp=%.1f", mDisplacement));
+            }
+
+            mLastDisplacement = mDisplacement;
+            return mListener.onDrag(mDisplacement - mSubtractDisplacement, event);
+        }
+        return true;
+    }
+
+    private void reportDragEnd() {
+        mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+        float velocity = mDir.getVelocity(mVelocityTracker, mIsRtl) / 1000;
+        if (DBG) {
+            Log.d(TAG, String.format("onScrollEnd disp=%.1f, velocity=%.1f",
+                    mDisplacement, velocity));
+        }
+
+        mListener.onDragEnd(velocity, Math.abs(velocity) > RELEASE_VELOCITY_PX_MS);
+    }
+
+    public static long calculateDuration(float velocity, float progressNeeded) {
+        // TODO: make these values constants after tuning.
+        float velocityDivisor = Math.max(2f, Math.abs(0.5f * velocity));
+        float travelDistance = Math.max(0.2f, progressNeeded);
+        long duration = (long) Math.max(100, ANIMATION_DURATION / velocityDivisor * travelDistance);
+        if (DBG) {
+            Log.d(TAG, String.format("calculateDuration=%d, v=%f, d=%f", duration, velocity, progressNeeded));
+        }
+        return duration;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/touch/TouchEventTranslator.java b/app/src/main/java/foundation/e/blisslauncher/core/touch/TouchEventTranslator.java
new file mode 100644
index 0000000000000000000000000000000000000000..527b8f57ede50d736dbc9d6f9dfdfe75febc568c
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/touch/TouchEventTranslator.java
@@ -0,0 +1,283 @@
+/*
+ * 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 foundation.e.blisslauncher.core.touch;
+
+import android.graphics.PointF;
+import android.util.Log;
+import android.util.Pair;
+import android.util.SparseArray;
+import android.view.MotionEvent;
+import android.view.MotionEvent.PointerCoords;
+import android.view.MotionEvent.PointerProperties;
+
+import java.util.function.Consumer;
+
+/**
+ * To minimize the size of the MotionEvent, historic events are not copied and passed via the
+ * listener.
+ */
+public class TouchEventTranslator {
+
+    private static final String TAG = "TouchEventTranslator";
+    private static final boolean DEBUG = false;
+
+    private class DownState {
+        long timeStamp;
+        float downX;
+        float downY;
+        public DownState(long timeStamp, float downX, float downY) {
+            this.timeStamp = timeStamp;
+            this.downX = downX;
+            this.downY = downY;
+        }
+    };
+    private final DownState ZERO = new DownState(0, 0f, 0f);
+
+    private final Consumer<MotionEvent> mListener;
+
+    private final SparseArray<DownState> mDownEvents;
+    private final SparseArray<PointF> mFingers;
+
+    private final SparseArray<Pair<PointerProperties[], PointerCoords[]>> mCache;
+
+    public TouchEventTranslator(Consumer<MotionEvent> listener) {
+        mDownEvents = new SparseArray<>();
+        mFingers = new SparseArray<>();
+        mCache = new SparseArray<>();
+
+        mListener = listener;
+    }
+
+    public void reset() {
+        mDownEvents.clear();
+        mFingers.clear();
+    }
+
+    public float getDownX() {
+        return mDownEvents.get(0).downX;
+    }
+
+    public float getDownY() {
+        return mDownEvents.get(0).downY;
+    }
+
+    public void setDownParameters(int idx, MotionEvent e) {
+        DownState ev = new DownState(e.getEventTime(), e.getX(idx), e.getY(idx));
+        mDownEvents.append(idx, ev);
+    }
+
+    public void dispatchDownEvents(MotionEvent ev) {
+        for(int i = 0; i < ev.getPointerCount() && i < mDownEvents.size(); i++) {
+            int pid = ev.getPointerId(i);
+            put(pid, i, ev.getX(i), 0, mDownEvents.get(i).timeStamp, ev);
+        }
+    }
+
+    public void processMotionEvent(MotionEvent ev) {
+        if (DEBUG) {
+            printSamples(TAG + " processMotionEvent", ev);
+        }
+        int index = ev.getActionIndex();
+        float x = ev.getX(index);
+        float y = ev.getY(index) - mDownEvents.get(index, ZERO).downY;
+        switch (ev.getActionMasked()) {
+            case MotionEvent.ACTION_POINTER_DOWN:
+                int pid = ev.getPointerId(index);
+                if(mFingers.get(pid, null) != null) {
+                    for(int i=0; i < ev.getPointerCount(); i++) {
+                        pid = ev.getPointerId(i);
+                        position(pid, x, y);
+                    }
+                    generateEvent(ev.getAction(), ev);
+                } else {
+                    put(pid, index, x, y, ev);
+                }
+                break;
+            case MotionEvent.ACTION_MOVE:
+                for(int i=0; i < ev.getPointerCount(); i++) {
+                    pid = ev.getPointerId(i);
+                    position(pid, x, y);
+                }
+                generateEvent(ev.getAction(), ev);
+                break;
+            case MotionEvent.ACTION_POINTER_UP:
+            case MotionEvent.ACTION_UP:
+                pid = ev.getPointerId(index);
+                lift(pid, index, x, y, ev);
+                break;
+            case MotionEvent.ACTION_CANCEL:
+                cancel(ev);
+                break;
+            default:
+                Log.v(TAG, "Didn't process ");
+                printSamples(TAG, ev);
+
+        }
+    }
+
+    private TouchEventTranslator put(int id, int index, float x, float y, MotionEvent ev) {
+        return put(id, index, x, y, ev.getEventTime(), ev);
+    }
+
+    private TouchEventTranslator put(int id, int index, float x, float y, long ms, MotionEvent ev) {
+        checkFingerExistence(id, false);
+        boolean isInitialDown = (mFingers.size() == 0);
+
+        mFingers.put(id, new PointF(x, y));
+        int n = mFingers.size();
+
+        if (mCache.get(n) == null) {
+            PointerProperties[] properties = new PointerProperties[n];
+            PointerCoords[] coords = new PointerCoords[n];
+            for (int i = 0; i < n; i++) {
+                properties[i] = new PointerProperties();
+                coords[i] = new PointerCoords();
+            }
+            mCache.put(n, new Pair(properties, coords));
+        }
+
+        int action;
+        if (isInitialDown) {
+            action = MotionEvent.ACTION_DOWN;
+        } else {
+            action = MotionEvent.ACTION_POINTER_DOWN;
+            // Set the id of the changed pointer.
+            action |= index << MotionEvent.ACTION_POINTER_INDEX_SHIFT;
+        }
+        generateEvent(action, ms, ev);
+        return this;
+    }
+
+    public TouchEventTranslator position(int id, float x, float y) {
+        checkFingerExistence(id, true);
+        mFingers.get(id).set(x, y);
+        return this;
+    }
+
+    private TouchEventTranslator lift(int id, int index, MotionEvent ev) {
+        checkFingerExistence(id, true);
+        boolean isFinalUp = (mFingers.size() == 1);
+        int action;
+        if (isFinalUp) {
+            action = MotionEvent.ACTION_UP;
+        } else {
+            action = MotionEvent.ACTION_POINTER_UP;
+            // Set the id of the changed pointer.
+            action |= index << MotionEvent.ACTION_POINTER_INDEX_SHIFT;
+        }
+        generateEvent(action, ev);
+        mFingers.remove(id);
+        return this;
+    }
+
+    private TouchEventTranslator lift(int id, int index, float x, float y, MotionEvent ev) {
+        checkFingerExistence(id, true);
+        mFingers.get(id).set(x, y);
+        return lift(id, index, ev);
+    }
+
+    public TouchEventTranslator cancel(MotionEvent ev) {
+        generateEvent(MotionEvent.ACTION_CANCEL, ev);
+        mFingers.clear();
+        return this;
+    }
+
+    private void checkFingerExistence(int id, boolean shouldExist) {
+        if (shouldExist != (mFingers.get(id, null) != null)) {
+            throw new IllegalArgumentException(
+                    shouldExist ? "Finger does not exist" : "Finger already exists");
+        }
+    }
+
+
+    /**
+     * Used to debug MotionEvents being sent/received.
+     */
+    public void printSamples(String msg, MotionEvent ev) {
+        System.out.printf("%s %s", msg, MotionEvent.actionToString(ev.getActionMasked()));
+        final int pointerCount = ev.getPointerCount();
+        System.out.printf("#%d/%d", ev.getActionIndex(), pointerCount);
+        System.out.printf(" t=%d:", ev.getEventTime());
+        for (int p = 0; p < pointerCount; p++) {
+            System.out.printf("  id=%d: (%f,%f)",
+                    ev.getPointerId(p), ev.getX(p), ev.getY(p));
+        }
+        System.out.println();
+    }
+
+    private void generateEvent(int action, MotionEvent ev) {
+        generateEvent(action, ev.getEventTime(), ev);
+    }
+
+    private void generateEvent(int action, long ms, MotionEvent ev) {
+        Pair<PointerProperties[], PointerCoords[]> state = getFingerState();
+        MotionEvent event = MotionEvent.obtain(
+                mDownEvents.get(0).timeStamp,
+                ms,
+                action,
+                state.first.length,
+                state.first,
+                state.second,
+                ev.getMetaState(),
+                ev.getButtonState() /* buttonState */,
+                ev.getXPrecision() /* xPrecision */,
+                ev.getYPrecision() /* yPrecision */,
+                ev.getDeviceId(),
+                ev.getEdgeFlags(),
+                ev.getSource(),
+                ev.getFlags() /* flags */);
+        if (DEBUG) {
+            printSamples(TAG + " generateEvent", event);
+        }
+        if (event.getPointerId(event.getActionIndex()) < 0) {
+            printSamples(TAG + "generateEvent", event);
+            throw new IllegalStateException(event.getActionIndex() + " not found in MotionEvent");
+        }
+        mListener.accept(event);
+        event.recycle();
+    }
+
+    /**
+     * Returns the description of the fingers' state expected by MotionEvent.
+     */
+    private Pair<PointerProperties[], PointerCoords[]> getFingerState() {
+        int nFingers = mFingers.size();
+
+        Pair<PointerProperties[], PointerCoords[]> result = mCache.get(nFingers);
+        PointerProperties[] properties = result.first;
+        PointerCoords[] coordinates = result.second;
+
+        int index = 0;
+        for (int i = 0; i < mFingers.size(); i++) {
+            int id = mFingers.keyAt(i);
+            PointF location = mFingers.get(id);
+
+            PointerProperties property = properties[i];
+            property.id = id;
+            property.toolType = MotionEvent.TOOL_TYPE_FINGER;
+            properties[index] = property;
+
+            PointerCoords coordinate = coordinates[i];
+            coordinate.x = location.x;
+            coordinate.y = location.y;
+            coordinate.pressure = 1.0f;
+            coordinates[index] = coordinate;
+
+            index++;
+        }
+        return mCache.get(nFingers);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/AppUtils.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/AppUtils.java
index a8b2808c9dd8cd14088ecfef2b2a9541f00c3a6b..b0aebbef93fe1da0864d40b0f6dbdf324dc15377 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/AppUtils.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/AppUtils.java
@@ -15,6 +15,7 @@
  */
 package foundation.e.blisslauncher.core.utils;
 
+
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.content.Intent;
@@ -26,17 +27,14 @@ import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.os.UserManager;
 import android.util.Log;
-
 import androidx.annotation.Nullable;
-
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
 import foundation.e.blisslauncher.BlissLauncher;
 import foundation.e.blisslauncher.core.IconsHandler;
 import foundation.e.blisslauncher.core.database.model.ApplicationItem;
 import foundation.e.blisslauncher.features.launcher.AppProvider;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 
 public class AppUtils {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/BitmapUtils.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/BitmapUtils.java
index 7d8550bd1eea7b64eb64a852d81b20116fb0f6e3..f2fe715bf330f1aaca24c4565461f2bebde2ddd9 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/BitmapUtils.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/BitmapUtils.java
@@ -15,6 +15,7 @@
  */
 package foundation.e.blisslauncher.core.utils;
 
+
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Paint;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/ComponentKey.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/ComponentKey.java
index e769ad1a2f8b12bd8945b2fa15871fa9e56ac13e..b96fbaaab7886d6df06340fb80e0b8316f0370df 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/ComponentKey.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/ComponentKey.java
@@ -16,14 +16,13 @@ package foundation.e.blisslauncher.core.utils;
  * limitations under the License.
  */
 
+
 import android.content.ComponentName;
 import android.content.Context;
 import android.os.Process;
 import android.os.UserHandle;
-
-import java.util.Arrays;
-
 import foundation.e.blisslauncher.core.UserManagerCompat;
+import java.util.Arrays;
 
 public class ComponentKey {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/Constants.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/Constants.java
index 8b69e9a66b462e8f3d7829894600cc01f7beaf0c..777e9023704ff88a3e23c2ad35998c15e26adde5 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/Constants.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/Constants.java
@@ -57,7 +57,7 @@ public class Constants {
     /**
      * Represents types of container.
      */
-    public static final int CONTAINER_DESKTOP = -100;
-    public static final int CONTAINER_HOTSEAT = -101;
+    public static final long CONTAINER_DESKTOP = -100;
+    public static final long CONTAINER_HOTSEAT = -101;
 
 }
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/FlingBlockCheck.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/FlingBlockCheck.java
new file mode 100644
index 0000000000000000000000000000000000000000..da3d0f766f83c586222e03fd8b5ba4818c601781
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/FlingBlockCheck.java
@@ -0,0 +1,52 @@
+/*
+ * 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 foundation.e.blisslauncher.core.utils;
+
+import android.os.SystemClock;
+
+/**
+ * Determines whether a fling should be blocked. Currently we block flings when crossing thresholds
+ * to new states, and unblock after a short duration.
+ */
+public class FlingBlockCheck {
+    // Allow flinging to a new state after waiting this many milliseconds.
+    private static final long UNBLOCK_FLING_PAUSE_DURATION = 200;
+
+    private boolean mBlockFling;
+    private long mBlockFlingTime;
+
+    public void blockFling() {
+        mBlockFling = true;
+        mBlockFlingTime = SystemClock.uptimeMillis();
+    }
+
+    public void unblockFling() {
+        mBlockFling = false;
+        mBlockFlingTime = 0;
+    }
+
+    public void onEvent() {
+        // We prevent flinging after passing a state, but allow it if the user pauses briefly.
+        if (SystemClock.uptimeMillis() - mBlockFlingTime >= UNBLOCK_FLING_PAUSE_DURATION) {
+            mBlockFling = false;
+        }
+    }
+
+    public boolean isBlocked() {
+        return mBlockFling;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/GraphicsUtil.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/GraphicsUtil.java
index 05296a8c5733cee582595e9044baee320c8b9b8d..b16111f1fa2ae3cb99feae91c298e2231a22bd09 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/GraphicsUtil.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/GraphicsUtil.java
@@ -15,6 +15,7 @@
  */
 package foundation.e.blisslauncher.core.utils;
 
+
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.Bitmap;
@@ -24,13 +25,11 @@ import android.graphics.Paint;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.util.Log;
-
-import java.util.HashMap;
-import java.util.Map;
-
 import foundation.e.blisslauncher.BlissLauncher;
 import foundation.e.blisslauncher.core.DeviceProfile;
 import foundation.e.blisslauncher.core.database.model.FolderItem;
+import java.util.HashMap;
+import java.util.Map;
 
 public class GraphicsUtil {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/IOUtils.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/IOUtils.java
index 62f6a60133b4f54cb47d082c9748903f2f635a41..0c2a05bf3710fae1af753f638c8c39bcb06b5535 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/IOUtils.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/IOUtils.java
@@ -15,6 +15,7 @@
  */
 package foundation.e.blisslauncher.core.utils;
 
+
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/ListUtil.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/ListUtil.java
index 9c9bf65311ea2cefea92caf2af17e3ca534a3c00..b59291357e6f14b24cd57fbe8976b59bbe6bc4c9 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/ListUtil.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/ListUtil.java
@@ -15,8 +15,8 @@
  */
 package foundation.e.blisslauncher.core.utils;
 
-import android.app.usage.UsageStats;
 
+import android.app.usage.UsageStats;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/LongArrayMap.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/LongArrayMap.java
index 415f07892f73b09ef4ebbb755e6fb1087cb6c259..7d7fcaa2a4fd3e2e990bf8f0b1b1d3b1c5c50936 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/LongArrayMap.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/LongArrayMap.java
@@ -15,10 +15,9 @@
  */
 package foundation.e.blisslauncher.core.utils;
 
-import android.util.LongSparseArray;
 
+import android.util.LongSparseArray;
 import androidx.annotation.NonNull;
-
 import java.util.Iterator;
 
 /**
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/MultiHashMap.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/MultiHashMap.java
index 7e036299b1ee5f2b8038c2af3aee41dfbc597fff..c9af2d83fea44c1f878f2c2304f89fa3006f1f7f 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/MultiHashMap.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/MultiHashMap.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.core.utils;
 
+
 import java.util.ArrayList;
 import java.util.HashMap;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/MultiValueAlpha.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/MultiValueAlpha.java
new file mode 100644
index 0000000000000000000000000000000000000000..f53ce6f98cf036a0949f2d93ebb4716d1b6c396d
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/MultiValueAlpha.java
@@ -0,0 +1,101 @@
+/*
+ * 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 foundation.e.blisslauncher.core.utils;
+
+import android.util.Property;
+import android.view.View;
+
+/**
+ * Utility class to handle separating a single value as a factor of multiple values
+ */
+public class MultiValueAlpha {
+
+    public static final Property<AlphaProperty, Float> VALUE =
+            new Property<AlphaProperty, Float>(Float.TYPE, "value") {
+
+                @Override
+                public Float get(AlphaProperty alphaProperty) {
+                    return alphaProperty.mValue;
+                }
+
+                @Override
+                public void set(AlphaProperty object, Float value) {
+                    object.setValue(value);
+                }
+            };
+
+    private final View mView;
+    private final AlphaProperty[] mMyProperties;
+
+    private int mValidMask;
+
+    public MultiValueAlpha(View view, int size) {
+        mView = view;
+        mMyProperties = new AlphaProperty[size];
+
+        mValidMask = 0;
+        for (int i = 0; i < size; i++) {
+            int myMask = 1 << i;
+            mValidMask |= myMask;
+            mMyProperties[i] = new AlphaProperty(myMask);
+        }
+    }
+
+    public AlphaProperty getProperty(int index) {
+        return mMyProperties[index];
+    }
+
+    public class AlphaProperty {
+
+        private final int mMyMask;
+
+        private float mValue = 1;
+        // Factor of all other alpha channels, only valid if mMyMask is present in mValidMask.
+        private float mOthers = 1;
+
+        AlphaProperty(int myMask) {
+            mMyMask = myMask;
+        }
+
+        public void setValue(float value) {
+            if (mValue == value) {
+                return;
+            }
+
+            if ((mValidMask & mMyMask) == 0) {
+                // Our cache value is not correct, recompute it.
+                mOthers = 1;
+                for (AlphaProperty prop : mMyProperties) {
+                    if (prop != this) {
+                        mOthers *= prop.mValue;
+                    }
+                }
+            }
+
+            // Since we have changed our value, all other caches except our own need to be
+            // recomputed. Change mValidMask to indicate the new valid caches (only our own).
+            mValidMask = mMyMask;
+            mValue = value;
+
+            mView.setAlpha(mOthers * mValue);
+        }
+
+        public float getValue() {
+            return mValue;
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/OverScroller.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/OverScroller.java
new file mode 100644
index 0000000000000000000000000000000000000000..43a6ea62572ce9487cb7016a0dfc27745ddfada4
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/OverScroller.java
@@ -0,0 +1,854 @@
+/*
+ * Copyright (C) 2010 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 foundation.e.blisslauncher.core.utils;
+
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.SCROLL;
+
+import android.animation.TimeInterpolator;
+import android.content.Context;
+import android.hardware.SensorManager;
+import android.util.Log;
+import android.view.ViewConfiguration;
+import android.view.animation.AnimationUtils;
+import android.view.animation.Interpolator;
+import androidx.dynamicanimation.animation.FloatPropertyCompat;
+import androidx.dynamicanimation.animation.SpringAnimation;
+import androidx.dynamicanimation.animation.SpringForce;
+
+/**
+ * Based on {@link android.widget.OverScroller} supporting only 1-d scrolling and with more
+ * customization options.
+ */
+public class OverScroller {
+    private int mMode;
+
+    private final SplineOverScroller mScroller;
+
+    private TimeInterpolator mInterpolator;
+
+    private final boolean mFlywheel;
+
+    private static final int DEFAULT_DURATION = 250;
+    private static final int SCROLL_MODE = 0;
+    private static final int FLING_MODE = 1;
+
+    /**
+     * Creates an OverScroller with a viscous fluid scroll interpolator and flywheel.
+     * @param context
+     */
+    public OverScroller(Context context) {
+        this(context, null);
+    }
+
+    /**
+     * Creates an OverScroller with flywheel enabled.
+     * @param context The context of this application.
+     * @param interpolator The scroll interpolator. If null, a default (viscous) interpolator will
+     * be used.
+     */
+    public OverScroller(Context context, Interpolator interpolator) {
+        this(context, interpolator, true);
+    }
+
+    /**
+     * Creates an OverScroller.
+     * @param context The context of this application.
+     * @param interpolator The scroll interpolator. If null, a default (viscous) interpolator will
+     * be used.
+     * @param flywheel If true, successive fling motions will keep on increasing scroll speed.
+     */
+    public OverScroller(Context context, Interpolator interpolator, boolean flywheel) {
+        if (interpolator == null) {
+            mInterpolator = SCROLL;
+        } else {
+            mInterpolator = interpolator;
+        }
+        mFlywheel = flywheel;
+        mScroller = new SplineOverScroller(context);
+    }
+
+    public void setInterpolator(TimeInterpolator interpolator) {
+        if (interpolator == null) {
+            mInterpolator = SCROLL;
+        } else {
+            mInterpolator = interpolator;
+        }
+    }
+
+    /**
+     * The amount of friction applied to flings. The default value
+     * is {@link ViewConfiguration#getScrollFriction}.
+     *
+     * @param friction A scalar dimension-less value representing the coefficient of
+     *         friction.
+     */
+    public final void setFriction(float friction) {
+        mScroller.setFriction(friction);
+    }
+
+    /**
+     *
+     * Returns whether the scroller has finished scrolling.
+     *
+     * @return True if the scroller has finished scrolling, false otherwise.
+     */
+    public final boolean isFinished() {
+        return mScroller.mFinished;
+    }
+
+    /**
+     * Force the finished field to a particular value. Contrary to
+     * {@link #abortAnimation()}, forcing the animation to finished
+     * does NOT cause the scroller to move to the final x and y
+     * position.
+     *
+     * @param finished The new finished value.
+     */
+    public final void forceFinished(boolean finished) {
+        mScroller.mFinished = finished;
+    }
+
+    /**
+     * Returns the current offset in the scroll.
+     *
+     * @return The new offset as an absolute distance from the origin.
+     */
+    public final int getCurrPos() {
+        return mScroller.mCurrentPosition;
+    }
+
+    /**
+     * Returns the absolute value of the current velocity.
+     *
+     * @return The original velocity less the deceleration, norm of the X and Y velocity vector.
+     */
+    public float getCurrVelocity() {
+        return mScroller.mCurrVelocity;
+    }
+
+    /**
+     * Returns the start offset in the scroll.
+     *
+     * @return The start offset as an absolute distance from the origin.
+     */
+    public final int getStartPos() {
+        return mScroller.mStart;
+    }
+
+    /**
+     * Returns where the scroll will end. Valid only for "fling" scrolls.
+     *
+     * @return The final offset as an absolute distance from the origin.
+     */
+    public final int getFinalPos() {
+        return mScroller.mFinal;
+    }
+
+    /**
+     * Returns how long the scroll event will take, in milliseconds.
+     *
+     * @return The duration of the scroll in milliseconds.
+     */
+    public final int getDuration() {
+        return mScroller.mDuration;
+    }
+
+    /**
+     * Extend the scroll animation. This allows a running animation to scroll
+     * further and longer, when used with {@link #setFinalPos(int)}.
+     *
+     * @param extend Additional time to scroll in milliseconds.
+     * @see #setFinalPos(int)
+     */
+    public void extendDuration(int extend) {
+        mScroller.extendDuration(extend);
+    }
+
+    /**
+     * Sets the final position for this scroller.
+     *
+     * @param newPos The new offset as an absolute distance from the origin.
+     * @see #extendDuration(int)
+     */
+    public void setFinalPos(int newPos) {
+        mScroller.setFinalPosition(newPos);
+    }
+
+    /**
+     * Call this when you want to know the new location. If it returns true, the
+     * animation is not yet finished.
+     */
+    public boolean computeScrollOffset() {
+        if (isFinished()) {
+            return false;
+        }
+
+        switch (mMode) {
+            case SCROLL_MODE:
+                if (isSpringing()) {
+                    return true;
+                }
+                long time = AnimationUtils.currentAnimationTimeMillis();
+                // Any scroller can be used for time, since they were started
+                // together in scroll mode. We use X here.
+                final long elapsedTime = time - mScroller.mStartTime;
+
+                final int duration = mScroller.mDuration;
+                if (elapsedTime < duration) {
+                    final float q = mInterpolator.getInterpolation(elapsedTime / (float) duration);
+                    mScroller.updateScroll(q);
+                } else {
+                    abortAnimation();
+                }
+                break;
+
+            case FLING_MODE:
+                if (!mScroller.mFinished) {
+                    if (!mScroller.update()) {
+                        if (!mScroller.continueWhenFinished()) {
+                            mScroller.finish();
+                        }
+                    }
+                }
+
+                break;
+        }
+
+        return true;
+    }
+
+    /**
+     * Start scrolling by providing a starting point and the distance to travel.
+     * The scroll will use the default value of 250 milliseconds for the
+     * duration.
+     *
+     * @param start Starting horizontal scroll offset in pixels. Positive
+     *        numbers will scroll the content to the left.
+     * @param delta Distance to travel. Positive numbers will scroll the
+     *        content to the left.
+     */
+    public void startScroll(int start, int delta) {
+        startScroll(start, delta, DEFAULT_DURATION);
+    }
+
+    /**
+     * Start scrolling by providing a starting point and the distance to travel.
+     *
+     * @param start Starting scroll offset in pixels. Positive
+     *        numbers will scroll the content to the left.
+     * @param delta Distance to travel. Positive numbers will scroll the
+     *        content to the left.
+     * @param duration Duration of the scroll in milliseconds.
+     */
+    public void startScroll(int start, int delta, int duration) {
+        mMode = SCROLL_MODE;
+        mScroller.startScroll(start, delta, duration);
+    }
+
+    /**
+     * Start scrolling using a spring by providing a starting point and the distance to travel.
+     *
+     * @param start Starting scroll offset in pixels. Positive
+     *        numbers will scroll the content to the left.
+     * @param delta Distance to travel. Positive numbers will scroll the
+     *        content to the left.
+     * @param duration Duration of the scroll in milliseconds.
+     * @param velocity The starting velocity for the spring in px per ms.
+     */
+    public void startScrollSpring(int start, int delta, int duration, float velocity) {
+        mMode = SCROLL_MODE;
+        mScroller.mState = mScroller.SPRING;
+        mScroller.startScroll(start, delta, duration, velocity);
+    }
+
+    /**
+     * Call this when you want to 'spring back' into a valid coordinate range.
+     *
+     * @param start Starting X coordinate
+     * @param min Minimum valid X value
+     * @param max Maximum valid X value
+     * @return true if a springback was initiated, false if startX and startY were
+     *          already within the valid range.
+     */
+    public boolean springBack(int start, int min, int max) {
+        mMode = FLING_MODE;
+        return mScroller.springback(start, min, max);
+    }
+
+    public void fling(int start, int velocity, int min, int max) {
+        fling(start, velocity, min, max, 0);
+    }
+
+    /**
+     * Start scrolling based on a fling gesture. The distance traveled will
+     * depend on the initial velocity of the fling.
+     *  @param start Starting point of the scroll (X)
+     * @param velocity Initial velocity of the fling (X) measured in pixels per
+     *            second.
+     * @param min Minimum X value. The scroller will not scroll past this point
+ *            unless overX > 0. If overfling is allowed, it will use minX as
+ *            a springback boundary.
+     * @param max Maximum X value. The scroller will not scroll past this point
+*            unless overX > 0. If overfling is allowed, it will use maxX as
+*            a springback boundary.
+     * @param over Overfling range. If > 0, horizontal overfling in either
+*            direction will be possible.
+     */
+    public void fling(int start, int velocity, int min, int max, int over) {
+        // Continue a scroll or fling in progress
+        if (mFlywheel && !isFinished()) {
+            float oldVelocityX = mScroller.mCurrVelocity;
+            if (Math.signum(velocity) == Math.signum(oldVelocityX)) {
+                velocity += oldVelocityX;
+            }
+        }
+
+        mMode = FLING_MODE;
+        mScroller.fling(start, velocity, min, max, over);
+    }
+
+    /**
+     * Notify the scroller that we've reached a horizontal boundary.
+     * Normally the information to handle this will already be known
+     * when the animation is started, such as in a call to one of the
+     * fling functions. However there are cases where this cannot be known
+     * in advance. This function will transition the current motion and
+     * animate from startX to finalX as appropriate.
+     *  @param start Starting/current X position
+     * @param finalPos Desired final X position
+     * @param over Magnitude of overscroll allowed. This should be the maximum
+     */
+    public void notifyEdgeReached(int start, int finalPos, int over) {
+        mScroller.notifyEdgeReached(start, finalPos, over);
+    }
+
+    /**
+     * Returns whether the current Scroller is currently returning to a valid position.
+     * Valid bounds were provided by the
+     * {@link #fling(int, int, int, int, int)} method.
+     *
+     * One should check this value before calling
+     * {@link #startScroll(int, int)} as the interpolation currently in progress
+     * to restore a valid position will then be stopped. The caller has to take into account
+     * the fact that the started scroll will start from an overscrolled position.
+     *
+     * @return true when the current position is overscrolled and in the process of
+     *         interpolating back to a valid value.
+     */
+    public boolean isOverScrolled() {
+        return (!mScroller.mFinished && mScroller.mState != SplineOverScroller.SPLINE);
+    }
+
+    /**
+     * Stops the animation. Contrary to {@link #forceFinished(boolean)},
+     * aborting the animating causes the scroller to move to the final x and y
+     * positions.
+     *
+     * @see #forceFinished(boolean)
+     */
+    public void abortAnimation() {
+        mScroller.finish();
+    }
+
+    /**
+     * Returns the time elapsed since the beginning of the scrolling.
+     *
+     * @return The elapsed time in milliseconds.
+     *
+     * @hide
+     */
+    public int timePassed() {
+        final long time = AnimationUtils.currentAnimationTimeMillis();
+        return (int) (time - mScroller.mStartTime);
+    }
+
+    public boolean isSpringing() {
+        return mScroller.mState == SplineOverScroller.SPRING && !isFinished();
+    }
+
+    static class SplineOverScroller {
+        // Initial position
+        private int mStart;
+
+        // Current position
+        private int mCurrentPosition;
+
+        // Final position
+        private int mFinal;
+
+        // Initial velocity
+        private int mVelocity;
+
+        // Current velocity
+        private float mCurrVelocity;
+
+        // Constant current deceleration
+        private float mDeceleration;
+
+        // Animation starting time, in system milliseconds
+        private long mStartTime;
+
+        // Animation duration, in milliseconds
+        private int mDuration;
+
+        // Duration to complete spline component of animation
+        private int mSplineDuration;
+
+        // Distance to travel along spline animation
+        private int mSplineDistance;
+
+        // Whether the animation is currently in progress
+        private boolean mFinished;
+
+        // The allowed overshot distance before boundary is reached.
+        private int mOver;
+
+        // Fling friction
+        private float mFlingFriction = ViewConfiguration.getScrollFriction();
+
+        // Current state of the animation.
+        private int mState = SPLINE;
+
+        private SpringAnimation mSpring;
+
+        // Constant gravity value, used in the deceleration phase.
+        private static final float GRAVITY = 2000.0f;
+
+        // A context-specific coefficient adjusted to physical values.
+        private float mPhysicalCoeff;
+
+        private static float DECELERATION_RATE = (float) (Math.log(0.78) / Math.log(0.9));
+        private static final float INFLEXION = 0.35f; // Tension lines cross at (INFLEXION, 1)
+        private static final float START_TENSION = 0.5f;
+        private static final float END_TENSION = 1.0f;
+        private static final float P1 = START_TENSION * INFLEXION;
+        private static final float P2 = 1.0f - END_TENSION * (1.0f - INFLEXION);
+
+        private static final int NB_SAMPLES = 100;
+        private static final float[] SPLINE_POSITION = new float[NB_SAMPLES + 1];
+        private static final float[] SPLINE_TIME = new float[NB_SAMPLES + 1];
+
+        private static final int SPLINE = 0;
+        private static final int CUBIC = 1;
+        private static final int BALLISTIC = 2;
+        private static final int SPRING = 3;
+
+        private static final FloatPropertyCompat<SplineOverScroller> SPRING_PROPERTY =
+                new FloatPropertyCompat<SplineOverScroller>("splineOverScrollerSpring") {
+                    @Override
+                    public float getValue(SplineOverScroller scroller) {
+                        return scroller.mCurrentPosition;
+                    }
+
+                    @Override
+                    public void setValue(SplineOverScroller scroller, float value) {
+                        scroller.mCurrentPosition = (int) value;
+                    }
+                };
+
+        static {
+            float x_min = 0.0f;
+            float y_min = 0.0f;
+            for (int i = 0; i < NB_SAMPLES; i++) {
+                final float alpha = (float) i / NB_SAMPLES;
+
+                float x_max = 1.0f;
+                float x, tx, coef;
+                while (true) {
+                    x = x_min + (x_max - x_min) / 2.0f;
+                    coef = 3.0f * x * (1.0f - x);
+                    tx = coef * ((1.0f - x) * P1 + x * P2) + x * x * x;
+                    if (Math.abs(tx - alpha) < 1E-5) break;
+                    if (tx > alpha) x_max = x;
+                    else x_min = x;
+                }
+                SPLINE_POSITION[i] = coef * ((1.0f - x) * START_TENSION + x) + x * x * x;
+
+                float y_max = 1.0f;
+                float y, dy;
+                while (true) {
+                    y = y_min + (y_max - y_min) / 2.0f;
+                    coef = 3.0f * y * (1.0f - y);
+                    dy = coef * ((1.0f - y) * START_TENSION + y) + y * y * y;
+                    if (Math.abs(dy - alpha) < 1E-5) break;
+                    if (dy > alpha) y_max = y;
+                    else y_min = y;
+                }
+                SPLINE_TIME[i] = coef * ((1.0f - y) * P1 + y * P2) + y * y * y;
+            }
+            SPLINE_POSITION[NB_SAMPLES] = SPLINE_TIME[NB_SAMPLES] = 1.0f;
+        }
+
+        void setFriction(float friction) {
+            mFlingFriction = friction;
+        }
+
+        SplineOverScroller(Context context) {
+            mFinished = true;
+            final float ppi = context.getResources().getDisplayMetrics().density * 160.0f;
+            mPhysicalCoeff = SensorManager.GRAVITY_EARTH // g (m/s^2)
+                    * 39.37f // inch/meter
+                    * ppi
+                    * 0.84f; // look and feel tuning
+        }
+
+        void updateScroll(float q) {
+            if (mState == SPRING) {
+                return;
+            }
+            mCurrentPosition = mStart + Math.round(q * (mFinal - mStart));
+        }
+
+        /*
+         * Get a signed deceleration that will reduce the velocity.
+         */
+        static private float getDeceleration(int velocity) {
+            return velocity > 0 ? -GRAVITY : GRAVITY;
+        }
+
+        /*
+         * Modifies mDuration to the duration it takes to get from start to newFinal using the
+         * spline interpolation. The previous duration was needed to get to oldFinal.
+         */
+        private void adjustDuration(int start, int oldFinal, int newFinal) {
+            final int oldDistance = oldFinal - start;
+            final int newDistance = newFinal - start;
+            final float x = Math.abs((float) newDistance / oldDistance);
+            final int index = (int) (NB_SAMPLES * x);
+            if (index < NB_SAMPLES) {
+                final float x_inf = (float) index / NB_SAMPLES;
+                final float x_sup = (float) (index + 1) / NB_SAMPLES;
+                final float t_inf = SPLINE_TIME[index];
+                final float t_sup = SPLINE_TIME[index + 1];
+                final float timeCoef = t_inf + (x - x_inf) / (x_sup - x_inf) * (t_sup - t_inf);
+                mDuration *= timeCoef;
+            }
+        }
+
+        void startScroll(int start, int distance, int duration) {
+            startScroll(start, distance, duration, 0);
+        }
+
+        void startScroll(int start, int distance, int duration, float velocity) {
+            mFinished = false;
+
+            mCurrentPosition = mStart = start;
+            mFinal = start + distance;
+
+            mStartTime = AnimationUtils.currentAnimationTimeMillis();
+            mDuration = duration;
+
+            if (mState == SPRING) {
+                if (mSpring != null) {
+                    mSpring.cancel();
+                }
+                mSpring = new SpringAnimation(this, SPRING_PROPERTY);
+
+                mSpring.setSpring(new SpringForce(mFinal)
+                        .setStiffness(SpringForce.STIFFNESS_LOW)
+                        .setDampingRatio(SpringForce.DAMPING_RATIO_LOW_BOUNCY));
+                mSpring.setStartVelocity(velocity);
+                mSpring.animateToFinalPosition(mFinal);
+                mSpring.addEndListener((animation, canceled, value, velocity1) -> {
+                    finish();
+                    mState = SPLINE;
+                    mSpring = null;
+                });
+            }
+            // Unused
+            mDeceleration = 0.0f;
+            mVelocity = 0;
+        }
+
+        void finish() {
+            if (mSpring != null && mSpring.isRunning()) mSpring.cancel();
+
+            mCurrentPosition = mFinal;
+            // Not reset since WebView relies on this value for fast fling.
+            // TODO: restore when WebView uses the fast fling implemented in this class.
+            // mCurrVelocity = 0.0f;
+            mFinished = true;
+        }
+
+        void setFinalPosition(int position) {
+            mFinal = position;
+            if (mState == SPRING && mSpring != null) {
+                mSpring.animateToFinalPosition(mFinal);
+            }
+            mSplineDistance = mFinal - mStart;
+            mFinished = false;
+        }
+
+        void extendDuration(int extend) {
+            final long time = AnimationUtils.currentAnimationTimeMillis();
+            final int elapsedTime = (int) (time - mStartTime);
+            mDuration  = mSplineDuration = elapsedTime + extend;
+            mFinished = false;
+        }
+
+        boolean springback(int start, int min, int max) {
+            mFinished = true;
+
+            mCurrentPosition = mStart = mFinal = start;
+            mVelocity = 0;
+
+            mStartTime = AnimationUtils.currentAnimationTimeMillis();
+            mDuration = 0;
+
+            if (start < min) {
+                startSpringback(start, min, 0);
+            } else if (start > max) {
+                startSpringback(start, max, 0);
+            }
+
+            return !mFinished;
+        }
+
+        private void startSpringback(int start, int end, int velocity) {
+            // mStartTime has been set
+            mFinished = false;
+            mState = CUBIC;
+            mCurrentPosition = mStart = start;
+            mFinal = end;
+            final int delta = start - end;
+            mDeceleration = getDeceleration(delta);
+            // TODO take velocity into account
+            mVelocity = -delta; // only sign is used
+            mOver = Math.abs(delta);
+            mDuration = (int) (1000.0 * Math.sqrt(-2.0 * delta / mDeceleration));
+        }
+
+        void fling(int start, int velocity, int min, int max, int over) {
+            mOver = over;
+            mFinished = false;
+            mCurrVelocity = mVelocity = velocity;
+            mDuration = mSplineDuration = 0;
+            mStartTime = AnimationUtils.currentAnimationTimeMillis();
+            mCurrentPosition = mStart = start;
+
+            if (start > max || start < min) {
+                startAfterEdge(start, min, max, velocity);
+                return;
+            }
+
+            mState = SPLINE;
+            double totalDistance = 0.0;
+
+            if (velocity != 0) {
+                mDuration = mSplineDuration = getSplineFlingDuration(velocity);
+                totalDistance = getSplineFlingDistance(velocity);
+            }
+
+            mSplineDistance = (int) (totalDistance * Math.signum(velocity));
+            mFinal = start + mSplineDistance;
+
+            // Clamp to a valid final position
+            if (mFinal < min) {
+                adjustDuration(mStart, mFinal, min);
+                mFinal = min;
+            }
+
+            if (mFinal > max) {
+                adjustDuration(mStart, mFinal, max);
+                mFinal = max;
+            }
+        }
+
+        private double getSplineDeceleration(int velocity) {
+            return Math.log(INFLEXION * Math.abs(velocity) / (mFlingFriction * mPhysicalCoeff));
+        }
+
+        private double getSplineFlingDistance(int velocity) {
+            final double l = getSplineDeceleration(velocity);
+            final double decelMinusOne = DECELERATION_RATE - 1.0;
+            return mFlingFriction * mPhysicalCoeff * Math.exp(DECELERATION_RATE / decelMinusOne * l);
+        }
+
+        /* Returns the duration, expressed in milliseconds */
+        private int getSplineFlingDuration(int velocity) {
+            final double l = getSplineDeceleration(velocity);
+            final double decelMinusOne = DECELERATION_RATE - 1.0;
+            return (int) (1000.0 * Math.exp(l / decelMinusOne));
+        }
+
+        private void fitOnBounceCurve(int start, int end, int velocity) {
+            // Simulate a bounce that started from edge
+            final float durationToApex = - velocity / mDeceleration;
+            // The float cast below is necessary to avoid integer overflow.
+            final float velocitySquared = (float) velocity * velocity;
+            final float distanceToApex = velocitySquared / 2.0f / Math.abs(mDeceleration);
+            final float distanceToEdge = Math.abs(end - start);
+            final float totalDuration = (float) Math.sqrt(
+                    2.0 * (distanceToApex + distanceToEdge) / Math.abs(mDeceleration));
+            mStartTime -= (int) (1000.0f * (totalDuration - durationToApex));
+            mCurrentPosition = mStart = end;
+            mVelocity = (int) (- mDeceleration * totalDuration);
+        }
+
+        private void startBounceAfterEdge(int start, int end, int velocity) {
+            mDeceleration = getDeceleration(velocity == 0 ? start - end : velocity);
+            fitOnBounceCurve(start, end, velocity);
+            onEdgeReached();
+        }
+
+        private void startAfterEdge(int start, int min, int max, int velocity) {
+            if (start > min && start < max) {
+                Log.e("OverScroller", "startAfterEdge called from a valid position");
+                mFinished = true;
+                return;
+            }
+            final boolean positive = start > max;
+            final int edge = positive ? max : min;
+            final int overDistance = start - edge;
+            boolean keepIncreasing = overDistance * velocity >= 0;
+            if (keepIncreasing) {
+                // Will result in a bounce or a to_boundary depending on velocity.
+                startBounceAfterEdge(start, edge, velocity);
+            } else {
+                final double totalDistance = getSplineFlingDistance(velocity);
+                if (totalDistance > Math.abs(overDistance)) {
+                    fling(start, velocity, positive ? min : start, positive ? start : max, mOver);
+                } else {
+                    startSpringback(start, edge, velocity);
+                }
+            }
+        }
+
+        void notifyEdgeReached(int start, int end, int over) {
+            // mState is used to detect successive notifications
+            if (mState == SPLINE) {
+                mOver = over;
+                mStartTime = AnimationUtils.currentAnimationTimeMillis();
+                // We were in fling/scroll mode before: current velocity is such that distance to
+                // edge is increasing. This ensures that startAfterEdge will not start a new fling.
+                startAfterEdge(start, end, end, (int) mCurrVelocity);
+            }
+        }
+
+        private void onEdgeReached() {
+            // mStart, mVelocity and mStartTime were adjusted to their values when edge was reached.
+            // The float cast below is necessary to avoid integer overflow.
+            final float velocitySquared = (float) mVelocity * mVelocity;
+            float distance = velocitySquared / (2.0f * Math.abs(mDeceleration));
+            final float sign = Math.signum(mVelocity);
+
+            if (distance > mOver) {
+                // Default deceleration is not sufficient to slow us down before boundary
+                mDeceleration = - sign * velocitySquared / (2.0f * mOver);
+                distance = mOver;
+            }
+
+            mOver = (int) distance;
+            mState = BALLISTIC;
+            mFinal = mStart + (int) (mVelocity > 0 ? distance : -distance);
+            mDuration = - (int) (1000.0f * mVelocity / mDeceleration);
+        }
+
+        boolean continueWhenFinished() {
+            switch (mState) {
+                case SPLINE:
+                    // Duration from start to null velocity
+                    if (mDuration < mSplineDuration) {
+                        // If the animation was clamped, we reached the edge
+                        mCurrentPosition = mStart = mFinal;
+                        // TODO Better compute speed when edge was reached
+                        mVelocity = (int) mCurrVelocity;
+                        mDeceleration = getDeceleration(mVelocity);
+                        mStartTime += mDuration;
+                        onEdgeReached();
+                    } else {
+                        // Normal stop, no need to continue
+                        return false;
+                    }
+                    break;
+                case BALLISTIC:
+                    mStartTime += mDuration;
+                    startSpringback(mFinal, mStart, 0);
+                    break;
+                case CUBIC:
+                    return false;
+            }
+
+            update();
+            return true;
+        }
+
+        /*
+         * Update the current position and velocity for current time. Returns
+         * true if update has been done and false if animation duration has been
+         * reached.
+         */
+        boolean update() {
+            if (mState == SPRING) {
+                return mFinished;
+            }
+
+            final long time = AnimationUtils.currentAnimationTimeMillis();
+            final long currentTime = time - mStartTime;
+
+            if (currentTime == 0) {
+                // Skip work but report that we're still going if we have a nonzero duration.
+                return mDuration > 0;
+            }
+            if (currentTime > mDuration) {
+                return false;
+            }
+
+            double distance = 0.0;
+            switch (mState) {
+                case SPLINE: {
+                    final float t = (float) currentTime / mSplineDuration;
+                    final int index = (int) (NB_SAMPLES * t);
+                    float distanceCoef = 1.f;
+                    float velocityCoef = 0.f;
+                    if (index < NB_SAMPLES) {
+                        final float t_inf = (float) index / NB_SAMPLES;
+                        final float t_sup = (float) (index + 1) / NB_SAMPLES;
+                        final float d_inf = SPLINE_POSITION[index];
+                        final float d_sup = SPLINE_POSITION[index + 1];
+                        velocityCoef = (d_sup - d_inf) / (t_sup - t_inf);
+                        distanceCoef = d_inf + (t - t_inf) * velocityCoef;
+                    }
+
+                    distance = distanceCoef * mSplineDistance;
+                    mCurrVelocity = velocityCoef * mSplineDistance / mSplineDuration * 1000.0f;
+                    break;
+                }
+
+                case BALLISTIC: {
+                    final float t = currentTime / 1000.0f;
+                    mCurrVelocity = mVelocity + mDeceleration * t;
+                    distance = mVelocity * t + mDeceleration * t * t / 2.0f;
+                    break;
+                }
+
+                case CUBIC: {
+                    final float t = (float) (currentTime) / mDuration;
+                    final float t2 = t * t;
+                    final float sign = Math.signum(mVelocity);
+                    distance = sign * mOver * (3.0f * t2 - 2.0f * t * t2);
+                    mCurrVelocity = sign * mOver * 6.0f * (- t + t2);
+                    break;
+                }
+            }
+
+            mCurrentPosition = mStart + (int) Math.round(distance);
+
+            return true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/PackageManagerHelper.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/PackageManagerHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..88e2cdbb7679534e10afae9253306119bbbc64a1
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/PackageManagerHelper.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2016 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 foundation.e.blisslauncher.core.utils;
+
+import android.app.AppOpsManager;
+import android.content.ActivityNotFoundException;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.LauncherActivityInfo;
+import android.content.pm.LauncherApps;
+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.Build;
+import android.os.Bundle;
+import android.os.PatternMatcher;
+import android.os.UserHandle;
+import android.text.TextUtils;
+import android.util.Log;
+import android.widget.Toast;
+
+import java.net.URISyntaxException;
+import java.util.List;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.database.model.ApplicationItem;
+import foundation.e.blisslauncher.core.database.model.LauncherItem;
+import foundation.e.blisslauncher.core.database.model.ShortcutItem;
+
+/**
+ * Utility methods using package manager
+ */
+public class PackageManagerHelper {
+
+    private static final String TAG = "PackageManagerHelper";
+
+    private final Context mContext;
+    private final PackageManager mPm;
+    private final LauncherApps mLauncherApps;
+
+    public PackageManagerHelper(Context context) {
+        mContext = context;
+        mPm = context.getPackageManager();
+        mLauncherApps = (LauncherApps) context.getSystemService(Context.LAUNCHER_APPS_SERVICE);
+    }
+
+    /**
+     * Returns true if the app can possibly be on the SDCard. This is just a workaround and doesn't
+     * guarantee that the app is on SD card.
+     */
+    public boolean isAppOnSdcard(String packageName, UserHandle user) {
+        ApplicationInfo info = null;
+        try {
+            info = mLauncherApps.getApplicationInfo(
+                packageName, PackageManager.MATCH_UNINSTALLED_PACKAGES, user);
+            return info != null && info.enabled && ((info.flags & ApplicationInfo.FLAG_INSTALLED) != 0)
+                && (info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
+        } catch (NameNotFoundException e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * Returns whether the target app is suspended for a given user as per
+     * {@link android.app.admin.DevicePolicyManager#isPackageSuspended}.
+     */
+    public boolean isAppSuspended(String packageName, UserHandle user) {
+        ApplicationInfo info = null;
+        try {
+            info = mLauncherApps.getApplicationInfo(packageName, 0, user);
+        } catch (NameNotFoundException e) {
+            e.printStackTrace();
+        }
+        return info != null && info.enabled && ((info.flags & ApplicationInfo.FLAG_INSTALLED) != 0) &&
+            isAppSuspended(info);
+    }
+
+    public boolean isSafeMode() {
+        return mContext.getPackageManager().isSafeMode();
+    }
+
+    public Intent getAppLaunchIntent(String pkg, UserHandle user) {
+        List<LauncherActivityInfo> activities = mLauncherApps.getActivityList(pkg, user);
+        return activities.isEmpty() ? null :
+            ApplicationItem.makeLaunchIntent(activities.get(0));
+    }
+
+    /**
+     * Returns whether an application is suspended as per
+     * {@link android.app.admin.DevicePolicyManager#isPackageSuspended}.
+     */
+    public static boolean isAppSuspended(ApplicationInfo info) {
+        // The value of FLAG_SUSPENDED was reused by a hidden constant
+        // ApplicationInfo.FLAG_PRIVILEGED prior to N, so only check for suspended flag on N
+        // or later.
+        if (Utilities.ATLEAST_NOUGAT) {
+            return (info.flags & ApplicationInfo.FLAG_SUSPENDED) != 0;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Returns true if {@param srcPackage} has the permission required to start the activity from
+     * {@param intent}. If {@param srcPackage} is null, then the activity should not need
+     * any permissions
+     */
+    public boolean hasPermissionForActivity(Intent intent, String srcPackage) {
+        ResolveInfo target = mPm.resolveActivity(intent, 0);
+        if (target == null) {
+            // Not a valid target
+            return false;
+        }
+        if (TextUtils.isEmpty(target.activityInfo.permission)) {
+            // No permission is needed
+            return true;
+        }
+        if (TextUtils.isEmpty(srcPackage)) {
+            // The activity requires some permission but there is no source.
+            return false;
+        }
+
+        // Source does not have sufficient permissions.
+        if (mPm.checkPermission(target.activityInfo.permission, srcPackage) !=
+            PackageManager.PERMISSION_GRANTED) {
+            return false;
+        }
+
+        if (!Utilities.ATLEAST_MARSHMALLOW) {
+            // These checks are sufficient for below M devices.
+            return true;
+        }
+
+        // On M and above also check AppOpsManager for compatibility mode permissions.
+        if (TextUtils.isEmpty(AppOpsManager.permissionToOp(target.activityInfo.permission))) {
+            // There is no app-op for this permission, which could have been disabled.
+            return true;
+        }
+
+        // There is no direct way to check if the app-op is allowed for a particular app. Since
+        // app-op is only enabled for apps running in compatibility mode, simply block such apps.
+
+        try {
+            return mPm.getApplicationInfo(srcPackage, 0).targetSdkVersion >= Build.VERSION_CODES.M;
+        } catch (NameNotFoundException e) {
+        }
+
+        return false;
+    }
+
+    /**
+     * Starts the details activity for {@code info}
+     */
+    public void startDetailsActivityForInfo(LauncherItem info, Rect sourceBounds, Bundle opts) {
+        ComponentName componentName = null;
+        if (info instanceof ApplicationItem) {
+            componentName = ((ApplicationItem) info).componentName;
+        } else if (info instanceof ShortcutItem) {
+            componentName = info.getTargetComponent();
+        }
+        if (componentName != null) {
+            try {
+                mLauncherApps.startAppDetailsActivity(
+                    componentName, info.user.getRealHandle(), sourceBounds, opts);
+            } catch (SecurityException | ActivityNotFoundException e) {
+                Toast.makeText(mContext, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
+                Log.e(TAG, "Unable to launch settings", e);
+            }
+        }
+    }
+
+    /**
+     * Creates an intent filter to listen for actions with a specific package in the data field.
+     */
+    public static IntentFilter getPackageFilter(String pkg, String... actions) {
+        IntentFilter packageFilter = new IntentFilter();
+        for (String action : actions) {
+            packageFilter.addAction(action);
+        }
+        packageFilter.addDataScheme("package");
+        packageFilter.addDataSchemeSpecificPart(pkg, PatternMatcher.PATTERN_LITERAL);
+        return packageFilter;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/PackageManagerUtils.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/PackageManagerUtils.java
index 2ee5484bde32b533e8f90eb962763d6621bdc911..54ddbe2eeb96cdc98fd9cd9c87c24bced149e4de 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/PackageManagerUtils.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/PackageManagerUtils.java
@@ -15,6 +15,7 @@
  */
 package foundation.e.blisslauncher.core.utils;
 
+
 import android.content.Context;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/Preconditions.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/Preconditions.java
index d412d2d3a870b6c978b231078e58202b4baa6f8b..7fc42867abd11facbdae8ec697bbe1809a07e620 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/Preconditions.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/Preconditions.java
@@ -15,6 +15,7 @@
  */
 package foundation.e.blisslauncher.core.utils;
 
+
 import android.os.Looper;
 
 /**
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/ResourceUtils.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/ResourceUtils.java
index 3ccdbad4ac6d2664ed2c19f29d89bc06e8c93251..abf54a123de65f69d9fc44fd5b7594af30a74157 100755
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/ResourceUtils.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/ResourceUtils.java
@@ -15,18 +15,22 @@
  */
 package foundation.e.blisslauncher.core.utils;
 
+
 import android.annotation.SuppressLint;
 import android.content.res.AssetManager;
 import android.content.res.Configuration;
 import android.content.res.Resources;
 import android.util.DisplayMetrics;
-
-import java.lang.reflect.InvocationTargetException;
+import android.util.TypedValue;
 
 import foundation.e.blisslauncher.core.Utilities;
+import java.lang.reflect.InvocationTargetException;
 
 public class ResourceUtils {
 
+    public static final String NAVBAR_LANDSCAPE_LEFT_RIGHT_SIZE = "navigation_bar_width";
+    public static final String NAVBAR_BOTTOM_GESTURE_SIZE = "navigation_bar_gesture_height";
+
     /**
      * Sets a fake configuration to the passed Resources to allow access to resources
      * accessible to a sdk level. Used to backport adaptive icon support to different
@@ -89,4 +93,23 @@ public class ResourceUtils {
         }
     }
 
+    public static int getNavbarSize(String resName, Resources res) {
+        return getDimenByName(resName, res, 48);
+    }
+
+    private static int getDimenByName(String resName, Resources res, int defaultValue) {
+        final int frameSize;
+        final int frameSizeResID = res.getIdentifier(resName, "dimen", "android");
+        if (frameSizeResID != 0) {
+            frameSize = res.getDimensionPixelSize(frameSizeResID);
+        } else {
+            frameSize = pxFromDp(defaultValue, res.getDisplayMetrics());
+        }
+        return frameSize;
+    }
+
+    public static int pxFromDp(float size, DisplayMetrics metrics) {
+        return Math.round(TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, size, metrics));
+    }
+
 }
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/SingletonHolder.kt b/app/src/main/java/foundation/e/blisslauncher/core/utils/SingletonHolder.kt
index 7e58554df7dc5e03e016c7f1dd0b0ba383a50607..c59c7d43a38ffe3ef00b094034b325707d067e0f 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/SingletonHolder.kt
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/SingletonHolder.kt
@@ -50,4 +50,4 @@ fun <T, A> ensureOnMainThread(creator: (A) -> T): (A) -> T {
 }
 fun <T> useApplicationContext(creator: (Context) -> T): (Context) -> T {
     return { it -> creator(it.applicationContext) }
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/UserHandle.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/UserHandle.java
index 9c7a668112a72d7a4712401469b3866f673ba9b7..838a4ba31c7cf08ea09d1e874fa6d1961967cf71 100644
--- a/app/src/main/java/foundation/e/blisslauncher/core/utils/UserHandle.java
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/UserHandle.java
@@ -15,6 +15,7 @@
  */
 package foundation.e.blisslauncher.core.utils;
 
+
 import android.annotation.TargetApi;
 import android.os.Build;
 import android.os.Process;
diff --git a/app/src/main/java/foundation/e/blisslauncher/core/utils/ViewCache.java b/app/src/main/java/foundation/e/blisslauncher/core/utils/ViewCache.java
new file mode 100644
index 0000000000000000000000000000000000000000..40710bc0c4a10c381d8f2a8f9d2d8e8dc11d4b67
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/core/utils/ViewCache.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.core.utils;
+
+import android.content.Context;
+import android.util.SparseArray;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+/**
+ * Utility class to cache views at an activity level
+ */
+public class ViewCache {
+
+    protected final SparseArray<CacheEntry> mCache = new SparseArray();
+
+    public void setCacheSize(int layoutId, int size) {
+        mCache.put(layoutId, new CacheEntry(size));
+    }
+
+    public <T extends View> T getView(int layoutId, Context context, ViewGroup parent) {
+        CacheEntry entry = mCache.get(layoutId);
+        if (entry == null) {
+            entry = new CacheEntry(1);
+            mCache.put(layoutId, entry);
+        }
+
+        if (entry.mCurrentSize > 0) {
+            entry.mCurrentSize --;
+            T result = (T) entry.mViews[entry.mCurrentSize];
+            entry.mViews[entry.mCurrentSize] = null;
+            return result;
+        }
+
+        return (T) LayoutInflater.from(context).inflate(layoutId, parent, false);
+    }
+
+    public void recycleView(int layoutId, View view) {
+        CacheEntry entry = mCache.get(layoutId);
+        if (entry != null && entry.mCurrentSize < entry.mMaxSize) {
+            entry.mViews[entry.mCurrentSize] = view;
+            entry.mCurrentSize++;
+        }
+    }
+
+    private static class CacheEntry {
+
+        final int mMaxSize;
+        final View[] mViews;
+
+        int mCurrentSize;
+
+        public CacheEntry(int maxSize) {
+            mMaxSize = maxSize;
+            mViews = new View[maxSize];
+            mCurrentSize = 0;
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/launcher/AppProvider.java b/app/src/main/java/foundation/e/blisslauncher/features/launcher/AppProvider.java
index 882063d558cd7f80938995b1f475a58dfcb0d85f..86394dd14c40a5078c4f6c7b0a202bf3ea2357c5 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/launcher/AppProvider.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/launcher/AppProvider.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.launcher;
 
+
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.ApplicationInfo;
@@ -17,15 +18,6 @@ import android.os.UserManager;
 import android.provider.MediaStore;
 import android.util.Log;
 import android.util.LongSparseArray;
-
-import java.text.Collator;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-
 import foundation.e.blisslauncher.BlissLauncher;
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.Utilities;
@@ -46,6 +38,13 @@ import foundation.e.blisslauncher.features.launcher.tasks.LoadDatabaseTask;
 import foundation.e.blisslauncher.features.launcher.tasks.LoadShortcutTask;
 import foundation.e.blisslauncher.features.shortcuts.DeepShortcutManager;
 import foundation.e.blisslauncher.features.shortcuts.ShortcutInfoCompat;
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
 
 
 // TODO: Find better solution instead of excessively using volatile and synchronized.
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/launcher/AppsRepository.java b/app/src/main/java/foundation/e/blisslauncher/features/launcher/AppsRepository.java
index c4262dff5a7b42c17f968ff7657a6fd8514e75c0..cf4e5cbc7471522da15f3fe92c9a7784c7f209ff 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/launcher/AppsRepository.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/launcher/AppsRepository.java
@@ -1,10 +1,9 @@
 package foundation.e.blisslauncher.features.launcher;
 
-import com.jakewharton.rxrelay2.BehaviorRelay;
-
-import java.util.List;
 
+import com.jakewharton.rxrelay2.BehaviorRelay;
 import foundation.e.blisslauncher.core.database.model.LauncherItem;
+import java.util.List;
 
 public class AppsRepository {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/launcher/DetectSwipeGestureListener.java b/app/src/main/java/foundation/e/blisslauncher/features/launcher/DetectSwipeGestureListener.java
index afef40622ebc1f4f086048c4fe4d5259a644e6ae..0c6b6bf93d686af7099d9a451d1ffa9e52446df2 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/launcher/DetectSwipeGestureListener.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/launcher/DetectSwipeGestureListener.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.launcher;
 
+
 import android.view.GestureDetector;
 import android.view.MotionEvent;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/launcher/EventsObserverImpl.java b/app/src/main/java/foundation/e/blisslauncher/features/launcher/EventsObserverImpl.java
index d1253e3a7da1d33d488d9af6dc5c8bb3a88939dc..06ceb2be277d448ac9feac715c44754976d47e32 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/launcher/EventsObserverImpl.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/launcher/EventsObserverImpl.java
@@ -1,9 +1,7 @@
 package foundation.e.blisslauncher.features.launcher;
 
-import android.util.Log;
-
-import java.util.Calendar;
 
+import android.util.Log;
 import foundation.e.blisslauncher.core.events.AppAddEvent;
 import foundation.e.blisslauncher.core.events.AppChangeEvent;
 import foundation.e.blisslauncher.core.events.AppRemoveEvent;
@@ -12,6 +10,7 @@ import foundation.e.blisslauncher.core.events.EventRelay;
 import foundation.e.blisslauncher.core.events.ForceReloadEvent;
 import foundation.e.blisslauncher.core.events.ShortcutAddEvent;
 import foundation.e.blisslauncher.core.events.TimeChangedEvent;
+import java.util.Calendar;
 
 public class EventsObserverImpl implements EventRelay.EventsObserver<Event> {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/launcher/Hotseat.java b/app/src/main/java/foundation/e/blisslauncher/features/launcher/Hotseat.java
new file mode 100644
index 0000000000000000000000000000000000000000..522faae890c561b32d9dbbc692ce26c88184890c
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/launcher/Hotseat.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2011 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 foundation.e.blisslauncher.features.launcher;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.MotionEvent;
+import android.view.ViewDebug;
+import android.view.ViewGroup;
+import android.view.WindowInsets;
+import android.widget.FrameLayout;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.customviews.Insettable;
+import foundation.e.blisslauncher.core.customviews.InsettableFrameLayout;
+import foundation.e.blisslauncher.features.test.CellLayout;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+
+public class Hotseat extends CellLayout implements Insettable {
+
+    private final TestActivity mLauncher;
+    private CellLayout mContent;
+
+    private static final String TAG = "Hotseat";
+
+    @ViewDebug.ExportedProperty(category = "launcher")
+    private boolean mHasVerticalHotseat;
+
+    public Hotseat(Context context) {
+        this(context, null);
+    }
+
+    public Hotseat(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public Hotseat(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        mLauncher = TestActivity.Companion.getLauncher(context);
+        setBackgroundColor(0x33000000);
+    }
+
+    // TODO: Remove this later.
+    public CellLayout getLayout() {
+        return this;
+    }
+
+    public void resetLayout(boolean hasVerticalHotseat) {
+        removeAllViewsInLayout();
+        mHasVerticalHotseat = hasVerticalHotseat;
+        VariantDeviceProfile idp = mLauncher.getDeviceProfile();
+        setGridSize(idp.getInv().getNumHotseatIcons(), 1);
+    }
+
+    @Override
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        // We don't want any clicks to go through to the hotseat unless the workspace is in
+        // the normal state or an accessible drag is in progress.
+        return false;
+    }
+
+    @Override
+    public void setInsets(WindowInsets insets) {
+        FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) getLayoutParams();
+        VariantDeviceProfile grid = mLauncher.getDeviceProfile();
+        lp.gravity = Gravity.BOTTOM;
+        lp.width = ViewGroup.LayoutParams.MATCH_PARENT;
+        Log.d(TAG, "Bottom inset: "+insets.getSystemWindowInsetBottom());
+        lp.height = grid.getHotseatBarSizePx() + insets.getSystemWindowInsetBottom();
+        Rect padding = grid.getHotseatLayoutPadding();
+        getLayout().setPadding(padding.left, padding.top, padding.right, padding.bottom);
+        setLayoutParams(lp);
+        InsettableFrameLayout.Companion.dispatchInsets(this, insets);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        // Don't let if follow through to workspace
+        return true;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/launcher/LauncherActivity.java b/app/src/main/java/foundation/e/blisslauncher/features/launcher/LauncherActivity.java
index 19027459ed06a3e4ceca0093a0af8bce3d881bb8..6f2e7ed1dbadcf1e911b877a690fa947539692a8 100755
--- a/app/src/main/java/foundation/e/blisslauncher/features/launcher/LauncherActivity.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/launcher/LauncherActivity.java
@@ -1,5 +1,10 @@
 package foundation.e.blisslauncher.features.launcher;
 
+import static android.content.pm.ActivityInfo.CONFIG_ORIENTATION;
+import static android.content.pm.ActivityInfo.CONFIG_SCREEN_SIZE;
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+
 import android.Manifest;
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
@@ -60,7 +65,6 @@ import android.widget.RelativeLayout;
 import android.widget.SeekBar;
 import android.widget.TextView;
 import android.widget.Toast;
-
 import androidx.annotation.NonNull;
 import androidx.appcompat.app.AppCompatActivity;
 import androidx.core.app.ActivityCompat;
@@ -71,20 +75,6 @@ import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
 import androidx.viewpager.widget.PagerAdapter;
 import androidx.viewpager.widget.ViewPager;
-
-import com.jakewharton.rxbinding3.widget.RxTextView;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Calendar;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Set;
-import java.util.concurrent.TimeUnit;
-
 import foundation.e.blisslauncher.BlissLauncher;
 import foundation.e.blisslauncher.BuildConfig;
 import foundation.e.blisslauncher.R;
@@ -142,7 +132,6 @@ import foundation.e.blisslauncher.features.weather.WeatherSourceListenerService;
 import foundation.e.blisslauncher.features.weather.WeatherUpdateService;
 import foundation.e.blisslauncher.features.weather.WeatherUtils;
 import foundation.e.blisslauncher.features.widgets.WidgetManager;
-import foundation.e.blisslauncher.features.widgets.WidgetViewBuilder;
 import foundation.e.blisslauncher.features.widgets.WidgetsActivity;
 import io.reactivex.Observable;
 import io.reactivex.ObservableSource;
@@ -150,16 +139,20 @@ import io.reactivex.android.schedulers.AndroidSchedulers;
 import io.reactivex.disposables.CompositeDisposable;
 import io.reactivex.observers.DisposableObserver;
 import io.reactivex.schedulers.Schedulers;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
 import me.relex.circleindicator.CircleIndicator;
 
-import static android.content.pm.ActivityInfo.CONFIG_ORIENTATION;
-import static android.content.pm.ActivityInfo.CONFIG_SCREEN_SIZE;
-import static android.view.View.GONE;
-import static android.view.View.VISIBLE;
-
 public class LauncherActivity extends AppCompatActivity implements
-        AutoCompleteAdapter.OnSuggestionClickListener,
-        OnSwipeDownListener {
+    AutoCompleteAdapter.OnSuggestionClickListener,
+    OnSwipeDownListener {
 
     public static final int REORDER_TIMEOUT = 350;
     private final static int EMPTY_LOCATION_DRAG = -999;
@@ -207,7 +200,6 @@ public class LauncherActivity extends AppCompatActivity implements
     private boolean allAppsDisplayed;
     private boolean forceRefreshSuggestedApps = false;
 
-
     private List<UsageStats> mUsageStats;
     private FrameLayout swipeSearchContainer;
     private InsettableRelativeLayout workspace;
@@ -269,7 +261,7 @@ public class LauncherActivity extends AppCompatActivity implements
         mAppWidgetHost = BlissLauncher.getApplication(this).getAppWidgetHost();
 
         mLauncherView = LayoutInflater.from(this).inflate(
-                foundation.e.blisslauncher.R.layout.activity_main, null);
+            foundation.e.blisslauncher.R.layout.activity_main, null);
 
         //BlissLauncher.getApplication(LauncherActivity.this).getAppProvider().reload();
 
@@ -288,7 +280,7 @@ public class LauncherActivity extends AppCompatActivity implements
             if (permissionString == null || !permissionString.contains(getPackageName())) {
                 if (BuildConfig.DEBUG) {
                     startActivity(
-                            new Intent("android.settings.ACTION_NOTIFICATION_LISTENER_SETTINGS"));
+                        new Intent("android.settings.ACTION_NOTIFICATION_LISTENER_SETTINGS"));
                 } else if (!Preferences.shouldAskForNotificationAccess(this)) {
                     ComponentName cn = new ComponentName(this, NotificationService.class);
                     if (permissionString == null) {
@@ -305,8 +297,14 @@ public class LauncherActivity extends AppCompatActivity implements
             }
         }
 
-        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
-            requestPermissions(new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, STORAGE_PERMISSION_REQUEST_CODE);
+        if (ActivityCompat.checkSelfPermission(
+            this,
+            Manifest.permission.READ_EXTERNAL_STORAGE
+        ) != PackageManager.PERMISSION_GRANTED) {
+            requestPermissions(
+                new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
+                STORAGE_PERMISSION_REQUEST_CODE
+            );
         }
 
         // Start NotificationService to add count badge to Icons
@@ -337,7 +335,7 @@ public class LauncherActivity extends AppCompatActivity implements
         mDock = mLauncherView.findViewById(R.id.dock);
         mIndicator = mLauncherView.findViewById(R.id.page_indicator);
         mFolderWindowContainer = mLauncherView.findViewById(
-                R.id.folder_window_container);
+            R.id.folder_window_container);
         mFolderAppsViewPager = mLauncherView.findViewById(R.id.folder_apps);
         mFolderTitleInput = mLauncherView.findViewById(R.id.folder_title);
         mProgressBar = mLauncherView.findViewById(R.id.progressbar);
@@ -349,9 +347,9 @@ public class LauncherActivity extends AppCompatActivity implements
         wobbleAnimation = AnimationUtils.loadAnimation(this, R.anim.wobble);
         wobbleReverseAnimation = AnimationUtils.loadAnimation(this, R.anim.wobble_reverse);
         getWindow().getDecorView().setSystemUiVisibility(
-                View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
-                        View.SYSTEM_UI_FLAG_LAYOUT_STABLE
-                        | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
+            View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
+                View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
         workspace.setOnClickListener(v -> {
             if (swipeSearchContainer.getVisibility() == VISIBLE) {
                 hideSwipeSearchContainer();
@@ -361,32 +359,33 @@ public class LauncherActivity extends AppCompatActivity implements
 
     private void createOrUpdateIconGrid() {
         getCompositeDisposable().add(
-                BlissLauncher.getApplication(this)
-                        .getAppProvider()
-                        .getAppsRepository()
-                        .getAppsRelay()
-                        .distinctUntilChanged()
-                        .observeOn(AndroidSchedulers.mainThread())
-                        .subscribeWith(new DisposableObserver<List<LauncherItem>>() {
-                            @Override
-                            public void onNext(List<LauncherItem> launcherItems) {
-                                if (launcherItems == null || launcherItems.size() <= 0) {
-                                    BlissLauncher.getApplication(LauncherActivity.this).getAppProvider().reload(true);
-                                } else if (!allAppsDisplayed) {
-                                    showApps(launcherItems);
-                                }
-                            }
+            BlissLauncher.getApplication(this)
+                .getAppProvider()
+                .getAppsRepository()
+                .getAppsRelay()
+                .distinctUntilChanged()
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribeWith(new DisposableObserver<List<LauncherItem>>() {
+                    @Override
+                    public void onNext(List<LauncherItem> launcherItems) {
+                        if (launcherItems == null || launcherItems.size() <= 0) {
+                            BlissLauncher.getApplication(LauncherActivity.this).getAppProvider()
+                                .reload(true);
+                        } else if (!allAppsDisplayed) {
+                            showApps(launcherItems);
+                        }
+                    }
 
-                            @Override
-                            public void onError(Throwable e) {
-                                e.printStackTrace();
-                            }
+                    @Override
+                    public void onError(Throwable e) {
+                        e.printStackTrace();
+                    }
 
-                            @Override
-                            public void onComplete() {
+                    @Override
+                    public void onComplete() {
 
-                            }
-                        })
+                    }
+                })
         );
     }
 
@@ -405,17 +404,18 @@ public class LauncherActivity extends AppCompatActivity implements
     public void updateAllCalendarIcons(Calendar calendar) {
         for (BlissFrameLayout blissIcon : mCalendarIcons) {
             CalendarIcon calendarIcon = new CalendarIcon(
-                    blissIcon.findViewById(R.id.calendar_month_textview),
-                    blissIcon.findViewById(R.id.calendar_date_textview));
+                blissIcon.findViewById(R.id.calendar_month_textview),
+                blissIcon.findViewById(R.id.calendar_date_textview)
+            );
             updateCalendarIcon(calendarIcon, calendar);
         }
     }
 
     private void updateCalendarIcon(CalendarIcon calendarIcon, Calendar calendar) {
         calendarIcon.monthTextView.setText(
-                Utilities.convertMonthToString());
+            Utilities.convertMonthToString());
         calendarIcon.dayTextView.setText(
-                String.valueOf(calendar.get(Calendar.DAY_OF_MONTH)));
+            String.valueOf(calendar.get(Calendar.DAY_OF_MONTH)));
     }
 
     @Override
@@ -441,7 +441,7 @@ public class LauncherActivity extends AppCompatActivity implements
                 for (int i = 0; i < widgetContainer.getChildCount(); i++) {
                     if (widgetContainer.getChildAt(i) instanceof RoundedWidgetView) {
                         RoundedWidgetView appWidgetHostView =
-                                (RoundedWidgetView) widgetContainer.getChildAt(i);
+                            (RoundedWidgetView) widgetContainer.getChildAt(i);
                         if (appWidgetHostView.getAppWidgetId() == id) {
                             widgetContainer.removeViewAt(i);
                             DatabaseManager.getManager(this).removeWidget(id);
@@ -453,16 +453,17 @@ public class LauncherActivity extends AppCompatActivity implements
             }
 
             RoundedWidgetView widgetView = widgetManager.dequeAddWidgetView();
-            while (widgetView != null) {
+            /*while (widgetView != null) {
                 widgetView = WidgetViewBuilder.create(this, widgetView);
                 addWidgetToContainer(widgetView);
                 widgetView = widgetManager.dequeAddWidgetView();
-            }
+            }*/
         }
     }
 
     private void addWidgetToContainer(
-            RoundedWidgetView widgetView) {
+        RoundedWidgetView widgetView
+    ) {
         widgetView.setPadding(0, 0, 0, 0);
         widgetContainer.addView(widgetView);
     }
@@ -560,7 +561,7 @@ public class LauncherActivity extends AppCompatActivity implements
 
             int current = 0;
             while ((current < pages.size() && pages.get(current).getChildCount()
-                    == mDeviceProfile.maxAppsPerPage)) {
+                == mDeviceProfile.maxAppsPerPage)) {
                 current++;
             }
 
@@ -569,8 +570,8 @@ public class LauncherActivity extends AppCompatActivity implements
                 ImageView dot = new ImageView(LauncherActivity.this);
                 dot.setImageDrawable(getDrawable(R.drawable.dot_off));
                 LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
-                        getResources().getDimensionPixelSize(R.dimen.dotSize),
-                        getResources().getDimensionPixelSize(R.dimen.dotSize)
+                    getResources().getDimensionPixelSize(R.dimen.dotSize),
+                    getResources().getDimensionPixelSize(R.dimen.dotSize)
                 );
                 dot.setLayoutParams(params);
                 mIndicator.addView(dot);
@@ -590,14 +591,14 @@ public class LauncherActivity extends AppCompatActivity implements
                 GridLayout gridLayout = (GridLayout) mFolderAppsViewPager.getChildAt(i);
                 for (int j = 0; j < gridLayout.getChildCount(); j++) {
                     BlissFrameLayout viewGroup =
-                            (BlissFrameLayout) gridLayout.getChildAt(j);
+                        (BlissFrameLayout) gridLayout.getChildAt(j);
                     final LauncherItem existingItem = getAppDetails(viewGroup);
                     if (existingItem.itemType == Constants.ITEM_TYPE_SHORTCUT) {
                         ShortcutItem existingShortcutItem = (ShortcutItem) existingItem;
                         if (existingShortcutItem.id.equalsIgnoreCase(shortcutItem.id)) {
                             BlissFrameLayout blissFrameLayout = prepareLauncherItem(shortcutItem);
                             GridLayout.LayoutParams iconLayoutParams =
-                                    new GridLayout.LayoutParams();
+                                new GridLayout.LayoutParams();
                             iconLayoutParams.height = mDeviceProfile.cellHeightPx;
                             iconLayoutParams.width = mDeviceProfile.cellWidthPx;
                             gridLayout.removeViewAt(j);
@@ -611,7 +612,7 @@ public class LauncherActivity extends AppCompatActivity implements
 
         for (int i = 0; i < mDock.getChildCount(); i++) {
             BlissFrameLayout viewGroup =
-                    (BlissFrameLayout) mDock.getChildAt(i);
+                (BlissFrameLayout) mDock.getChildAt(i);
             LauncherItem launcherItem = getAppDetails(viewGroup);
             if (launcherItem.itemType == Constants.ITEM_TYPE_FOLDER) {
                 FolderItem folderItem = (FolderItem) launcherItem;
@@ -619,18 +620,19 @@ public class LauncherActivity extends AppCompatActivity implements
                     if (folderItem.items.get(k).itemType == Constants.ITEM_TYPE_SHORTCUT) {
                         ShortcutItem existingShortcutItem = (ShortcutItem) folderItem.items.get(k);
                         if (existingShortcutItem.id.equalsIgnoreCase(
-                                shortcutItem.id)) {
+                            shortcutItem.id)) {
                             folderItem.items.set(k, shortcutItem);
-                            folderItem.icon = new GraphicsUtil(this).generateFolderIcon(this,
-                                    folderItem);
+                            folderItem.icon = new GraphicsUtil(this).generateFolderIcon(
+                                this,
+                                folderItem
+                            );
                             BlissFrameLayout blissFrameLayout = prepareLauncherItem(
-                                    launcherItem);
+                                launcherItem);
                             mDock.removeViewAt(i);
                             addAppToDock(blissFrameLayout, i);
                             return;
                         }
                     }
-
                 }
             } else {
                 if (launcherItem.itemType == Constants.ITEM_TYPE_SHORTCUT) {
@@ -649,21 +651,23 @@ public class LauncherActivity extends AppCompatActivity implements
             GridLayout gridLayout = pages.get(i);
             for (int j = 0; j < gridLayout.getChildCount(); j++) {
                 BlissFrameLayout viewGroup =
-                        (BlissFrameLayout) gridLayout.getChildAt(j);
+                    (BlissFrameLayout) gridLayout.getChildAt(j);
                 LauncherItem launcherItem = getAppDetails(viewGroup);
                 if (launcherItem.itemType == Constants.ITEM_TYPE_FOLDER) {
                     FolderItem folderItem = (FolderItem) launcherItem;
                     for (int k = 0; k < folderItem.items.size(); k++) {
                         if (folderItem.items.get(k).itemType == Constants.ITEM_TYPE_SHORTCUT) {
                             ShortcutItem existingShortcutItem =
-                                    (ShortcutItem) folderItem.items.get(k);
+                                (ShortcutItem) folderItem.items.get(k);
                             if (existingShortcutItem.id.equalsIgnoreCase(
-                                    shortcutItem.id)) {
+                                shortcutItem.id)) {
                                 folderItem.items.set(k, shortcutItem);
-                                folderItem.icon = new GraphicsUtil(this).generateFolderIcon(this,
-                                        folderItem);
+                                folderItem.icon = new GraphicsUtil(this).generateFolderIcon(
+                                    this,
+                                    folderItem
+                                );
                                 BlissFrameLayout blissFrameLayout = prepareLauncherItem(
-                                        launcherItem);
+                                    launcherItem);
                                 gridLayout.removeViewAt(j);
                                 addAppToGrid(gridLayout, blissFrameLayout, j);
                                 moveTo = i + 1;
@@ -698,7 +702,8 @@ public class LauncherActivity extends AppCompatActivity implements
                     LauncherItem launcherItem = getAppDetails(grid.getChildAt(j));
                     if (launcherItem.itemType == Constants.ITEM_TYPE_APPLICATION) {
                         ApplicationItem app = (ApplicationItem) launcherItem;
-                        if (app.packageName.equals(packageName) && app.user.isSameUser(userHandle)) {
+                        if (app.packageName.equals(packageName) && app.user
+                            .isSameUser(userHandle)) {
                             activeFolder.items.remove(app);
                         }
                     } else if (launcherItem.itemType == Constants.ITEM_TYPE_SHORTCUT) {
@@ -719,7 +724,9 @@ public class LauncherActivity extends AppCompatActivity implements
                 for (LauncherItem item : folderItem.items) {
                     if (item.itemType == Constants.ITEM_TYPE_APPLICATION) {
                         ApplicationItem applicationItem = (ApplicationItem) item;
-                        if (applicationItem.packageName.equalsIgnoreCase(packageName) && applicationItem.user.isSameUser(userHandle)) {
+                        if (applicationItem.packageName
+                            .equalsIgnoreCase(packageName) && applicationItem.user
+                            .isSameUser(userHandle)) {
                             folderItem.items.remove(applicationItem);
                         }
                     } else if (item.itemType == Constants.ITEM_TYPE_SHORTCUT) {
@@ -732,7 +739,8 @@ public class LauncherActivity extends AppCompatActivity implements
                 updateFolderInGrid(mDock, folderItem, j);
             } else if (appItem.itemType == Constants.ITEM_TYPE_APPLICATION) {
                 ApplicationItem applicationItem = (ApplicationItem) appItem;
-                if (applicationItem.packageName.equalsIgnoreCase(packageName) && applicationItem.user.isSameUser(userHandle)) {
+                if (applicationItem.packageName
+                    .equalsIgnoreCase(packageName) && applicationItem.user.isSameUser(userHandle)) {
                     mDock.removeViewAt(j);
                 }
             } else if (appItem.itemType == Constants.ITEM_TYPE_SHORTCUT) {
@@ -752,7 +760,9 @@ public class LauncherActivity extends AppCompatActivity implements
                     for (LauncherItem item : folderItem.items) {
                         if (item.itemType == Constants.ITEM_TYPE_APPLICATION) {
                             ApplicationItem applicationItem = (ApplicationItem) item;
-                            if (applicationItem.packageName.equalsIgnoreCase(packageName) && applicationItem.user.isSameUser(userHandle)) {
+                            if (applicationItem.packageName
+                                .equalsIgnoreCase(packageName) && applicationItem.user
+                                .isSameUser(userHandle)) {
                                 folderItem.items.remove(applicationItem);
                             }
                         } else if (item.itemType == Constants.ITEM_TYPE_SHORTCUT) {
@@ -775,7 +785,9 @@ public class LauncherActivity extends AppCompatActivity implements
                     }
                 } else if (launcherItem.itemType == Constants.ITEM_TYPE_APPLICATION) {
                     ApplicationItem applicationItem = (ApplicationItem) launcherItem;
-                    if (applicationItem.packageName.equalsIgnoreCase(packageName) && applicationItem.user.isSameUser(userHandle)) {
+                    if (applicationItem.packageName
+                        .equalsIgnoreCase(packageName) && applicationItem.user
+                        .isSameUser(userHandle)) {
                         grid.removeViewAt(j);
                         if (grid.getChildCount() == 0) {
                             pages.remove(i);
@@ -810,7 +822,7 @@ public class LauncherActivity extends AppCompatActivity implements
         mFolderAppsViewPager.getAdapter().notifyDataSetChanged();
         if (activeFolder.items.size() == 0) {
             ((ViewGroup) activeFolderView.getParent()).removeView
-                    (activeFolderView);
+                (activeFolderView);
             hideFolderWindowContainer();
         } else {
             if (activeFolder.items.size() == 1) {
@@ -823,31 +835,39 @@ public class LauncherActivity extends AppCompatActivity implements
                     addAppToDock(view, mDock.indexOfChild(activeFolderView));
                 } else {
                     GridLayout gridLayout = pages.get
-                            (getCurrentAppsPageNumber());
+                        (getCurrentAppsPageNumber());
                     addAppToGrid(gridLayout, view,
-                            gridLayout.indexOfChild(activeFolderView));
+                        gridLayout.indexOfChild(activeFolderView)
+                    );
                 }
 
                 ((ViewGroup) activeFolderView.getParent()).removeView(
-                        activeFolderView);
+                    activeFolderView);
                 hideFolderWindowContainer();
             } else {
                 updateIcon(activeFolderView, activeFolder,
-                        new GraphicsUtil(this).generateFolderIcon(this,
-                                activeFolder),
-                        folderFromDock);
+                    new GraphicsUtil(this).generateFolderIcon(
+                        this,
+                        activeFolder
+                    ),
+                    folderFromDock
+                );
                 hideFolderWindowContainer();
             }
         }
     }
 
-    private void updateFolderInGrid(GridLayout grid, FolderItem folderItem,
-                                    int folderIndex) {
+    private void updateFolderInGrid(
+        GridLayout grid, FolderItem folderItem,
+        int folderIndex
+    ) {
         if (folderItem.items.size() == 0) {
             grid.removeViewAt(folderIndex);
         } else {
-            folderItem.icon = new GraphicsUtil(this).generateFolderIcon(this,
-                    folderItem);
+            folderItem.icon = new GraphicsUtil(this).generateFolderIcon(
+                this,
+                folderItem
+            );
             BlissFrameLayout blissFrameLayout = prepareLauncherItem(folderItem);
             grid.removeViewAt(folderIndex);
             if (grid instanceof DockGridLayout) {
@@ -871,15 +891,17 @@ public class LauncherActivity extends AppCompatActivity implements
                 GridLayout gridLayout = (GridLayout) mFolderAppsViewPager.getChildAt(i);
                 for (int j = 0; j < gridLayout.getChildCount(); j++) {
                     BlissFrameLayout viewGroup =
-                            (BlissFrameLayout) gridLayout.getChildAt(j);
+                        (BlissFrameLayout) gridLayout.getChildAt(j);
                     final LauncherItem existingItem =
-                            getAppDetails(viewGroup);
+                        getAppDetails(viewGroup);
                     if (existingItem.itemType == Constants.ITEM_TYPE_APPLICATION) {
                         ApplicationItem existingAppItem = (ApplicationItem) existingItem;
-                        if (existingAppItem.packageName.equalsIgnoreCase(packageName) && existingAppItem.user.isSameUser(userHandle)) {
+                        if (existingAppItem.packageName
+                            .equalsIgnoreCase(packageName) && existingAppItem.user
+                            .isSameUser(userHandle)) {
                             BlissFrameLayout blissFrameLayout = prepareLauncherItem(updatedAppItem);
                             GridLayout.LayoutParams iconLayoutParams =
-                                    new GridLayout.LayoutParams();
+                                new GridLayout.LayoutParams();
                             iconLayoutParams.height = mDeviceProfile.cellHeightPx;
                             iconLayoutParams.width = mDeviceProfile.cellWidthPx;
                             gridLayout.removeViewAt(j);
@@ -887,14 +909,13 @@ public class LauncherActivity extends AppCompatActivity implements
                             return;
                         }
                     }
-
                 }
             }
         }
 
         for (int i = 0; i < mDock.getChildCount(); i++) {
             BlissFrameLayout viewGroup =
-                    (BlissFrameLayout) mDock.getChildAt(i);
+                (BlissFrameLayout) mDock.getChildAt(i);
             LauncherItem existingAppItem = getAppDetails(viewGroup);
             if (existingAppItem.itemType == Constants.ITEM_TYPE_FOLDER) {
                 FolderItem folderItem = (FolderItem) existingAppItem;
@@ -902,24 +923,25 @@ public class LauncherActivity extends AppCompatActivity implements
                     if (folderItem.items.get(k).itemType == Constants.ITEM_TYPE_APPLICATION) {
                         ApplicationItem applicationItem = (ApplicationItem) folderItem.items.get(k);
                         if (applicationItem.packageName.equalsIgnoreCase(
-                                packageName) && applicationItem.user.isSameUser(userHandle)) {
+                            packageName) && applicationItem.user.isSameUser(userHandle)) {
                             folderItem.items.set(k, updatedAppItem);
-                            folderItem.icon = new GraphicsUtil(this).generateFolderIcon(this,
-                                    folderItem);
+                            folderItem.icon = new GraphicsUtil(this).generateFolderIcon(
+                                this,
+                                folderItem
+                            );
                             BlissFrameLayout blissFrameLayout = prepareLauncherItem(
-                                    existingAppItem);
+                                existingAppItem);
                             mDock.removeViewAt(i);
                             addAppToDock(blissFrameLayout, i);
                             return;
                         }
                     }
-
                 }
             } else {
                 if (existingAppItem.itemType == Constants.ITEM_TYPE_APPLICATION) {
                     ApplicationItem applicationItem = (ApplicationItem) existingAppItem;
                     if (applicationItem.packageName.equalsIgnoreCase(packageName)
-                            && applicationItem.user.isSameUser(userHandle)) {
+                        && applicationItem.user.isSameUser(userHandle)) {
                         BlissFrameLayout blissFrameLayout = prepareLauncherItem(updatedAppItem);
                         mDock.removeViewAt(i);
                         addAppToDock(blissFrameLayout, i);
@@ -933,21 +955,23 @@ public class LauncherActivity extends AppCompatActivity implements
             GridLayout gridLayout = pages.get(i);
             for (int j = 0; j < gridLayout.getChildCount(); j++) {
                 BlissFrameLayout viewGroup =
-                        (BlissFrameLayout) gridLayout.getChildAt(j);
+                    (BlissFrameLayout) gridLayout.getChildAt(j);
                 LauncherItem existingAppItem = getAppDetails(viewGroup);
                 if (existingAppItem.itemType == Constants.ITEM_TYPE_FOLDER) {
                     FolderItem folderItem = (FolderItem) existingAppItem;
                     for (int k = 0; k < folderItem.items.size(); k++) {
                         if (folderItem.items.get(k).itemType == Constants.ITEM_TYPE_APPLICATION) {
                             ApplicationItem applicationItem =
-                                    (ApplicationItem) folderItem.items.get(k);
+                                (ApplicationItem) folderItem.items.get(k);
                             if (applicationItem.packageName.equalsIgnoreCase(
-                                    packageName) && applicationItem.user.isSameUser(userHandle)) {
+                                packageName) && applicationItem.user.isSameUser(userHandle)) {
                                 folderItem.items.set(k, updatedAppItem);
-                                folderItem.icon = new GraphicsUtil(this).generateFolderIcon(this,
-                                        folderItem);
+                                folderItem.icon = new GraphicsUtil(this).generateFolderIcon(
+                                    this,
+                                    folderItem
+                                );
                                 BlissFrameLayout blissFrameLayout = prepareLauncherItem(
-                                        existingAppItem);
+                                    existingAppItem);
                                 gridLayout.removeViewAt(j);
                                 addAppToGrid(gridLayout, blissFrameLayout, j);
                                 moveTo = i + 1;
@@ -959,7 +983,7 @@ public class LauncherActivity extends AppCompatActivity implements
                     if (existingAppItem.itemType == Constants.ITEM_TYPE_APPLICATION) {
                         ApplicationItem applicationItem = (ApplicationItem) existingAppItem;
                         if (applicationItem.packageName.equalsIgnoreCase(packageName)
-                                && applicationItem.user.isSameUser(userHandle)) {
+                            && applicationItem.user.isSameUser(userHandle)) {
                             BlissFrameLayout blissFrameLayout = prepareLauncherItem(updatedAppItem);
                             gridLayout.removeViewAt(j);
                             addAppToGrid(gridLayout, blissFrameLayout, j);
@@ -997,26 +1021,27 @@ public class LauncherActivity extends AppCompatActivity implements
 
     private void createOrUpdateBadgeCount() {
         getCompositeDisposable().add(
-                NotificationRepository.getNotificationRepository().getNotifications().subscribeWith(
-                        new DisposableObserver<Set<String>>() {
-                            @Override
-                            public void onNext(Set<String> packages) {
-                                mAppsWithNotifications = packages;
-                                updateBadges(mAppsWithNotifications);
-                            }
+            NotificationRepository.getNotificationRepository().getNotifications().subscribeWith(
+                new DisposableObserver<Set<String>>() {
+                    @Override
+                    public void onNext(Set<String> packages) {
+                        mAppsWithNotifications = packages;
+                        updateBadges(mAppsWithNotifications);
+                    }
 
-                            @Override
-                            public void onError(Throwable e) {
-                                Toast.makeText(LauncherActivity.this, "Recreating Launcher",
-                                        Toast.LENGTH_SHORT).show();
-                                e.printStackTrace();
-                                recreate();
-                            }
+                    @Override
+                    public void onError(Throwable e) {
+                        Toast.makeText(LauncherActivity.this, "Recreating Launcher",
+                            Toast.LENGTH_SHORT
+                        ).show();
+                        e.printStackTrace();
+                        recreate();
+                    }
 
-                            @Override
-                            public void onComplete() {
-                            }
-                        }));
+                    @Override
+                    public void onComplete() {
+                    }
+                }));
     }
 
     private void updateBadges(Set<String> appsWithNotifications) {
@@ -1025,7 +1050,7 @@ public class LauncherActivity extends AppCompatActivity implements
                 GridLayout gridLayout = (GridLayout) mFolderAppsViewPager.getChildAt(i);
                 for (int j = 0; j < gridLayout.getChildCount(); j++) {
                     BlissFrameLayout viewGroup =
-                            (BlissFrameLayout) gridLayout.getChildAt(j);
+                        (BlissFrameLayout) gridLayout.getChildAt(j);
                     final LauncherItem appItem = getAppDetails(viewGroup);
                     if (appItem.itemType != Constants.ITEM_TYPE_SHORTCUT) {
                         updateBadgeToApp(viewGroup, appItem, appsWithNotifications, true);
@@ -1037,7 +1062,7 @@ public class LauncherActivity extends AppCompatActivity implements
             GridLayout gridLayout = pages.get(i);
             for (int j = 0; j < gridLayout.getChildCount(); j++) {
                 BlissFrameLayout viewGroup =
-                        (BlissFrameLayout) gridLayout.getChildAt(j);
+                    (BlissFrameLayout) gridLayout.getChildAt(j);
                 final LauncherItem appItem = getAppDetails(viewGroup);
                 if (appItem.itemType != Constants.ITEM_TYPE_SHORTCUT) {
                     updateBadgeToApp(viewGroup, appItem, appsWithNotifications, true);
@@ -1047,7 +1072,7 @@ public class LauncherActivity extends AppCompatActivity implements
 
         for (int i = 0; i < mDock.getChildCount(); i++) {
             BlissFrameLayout viewGroup =
-                    (BlissFrameLayout) mDock.getChildAt(i);
+                (BlissFrameLayout) mDock.getChildAt(i);
             final LauncherItem appItem = getAppDetails(viewGroup);
             if (appItem.itemType != Constants.ITEM_TYPE_SHORTCUT) {
                 updateBadgeToApp(viewGroup, appItem, appsWithNotifications, false);
@@ -1055,12 +1080,16 @@ public class LauncherActivity extends AppCompatActivity implements
         }
     }
 
-    private void updateBadgeToApp(BlissFrameLayout viewGroup, LauncherItem appItem,
-                                  Set<String> appsWithNotifications, boolean withText) {
+    private void updateBadgeToApp(
+        BlissFrameLayout viewGroup, LauncherItem appItem,
+        Set<String> appsWithNotifications, boolean withText
+    ) {
         if (appItem != null) {
             if (appItem.itemType == Constants.ITEM_TYPE_FOLDER) {
-                viewGroup.applyBadge(checkHasApp((FolderItem) appItem, appsWithNotifications),
-                        withText);
+                viewGroup.applyBadge(
+                    checkHasApp((FolderItem) appItem, appsWithNotifications),
+                    withText
+                );
             } else {
                 ApplicationItem applicationItem = (ApplicationItem) appItem;
                 String pkgName = applicationItem.packageName;
@@ -1107,14 +1136,14 @@ public class LauncherActivity extends AppCompatActivity implements
 
     public void hideKeyboard(View view) {
         InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(
-                Activity.INPUT_METHOD_SERVICE);
+            Activity.INPUT_METHOD_SERVICE);
         assert inputMethodManager != null;
         inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
     }
 
     public void showKeyboard(View view) {
         InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(
-                Activity.INPUT_METHOD_SERVICE);
+            Activity.INPUT_METHOD_SERVICE);
         assert inputMethodManager != null;
         inputMethodManager.showSoftInput(view, 0);
     }
@@ -1140,7 +1169,7 @@ public class LauncherActivity extends AppCompatActivity implements
             public void onScroll(int scrollX) {
                 if (scrollX >= 0 && scrollX < mDeviceProfile.availableWidthPx) {
                     float fraction = (float) (mDeviceProfile.availableWidthPx - scrollX)
-                            / mDeviceProfile.availableWidthPx;
+                        / mDeviceProfile.availableWidthPx;
                     int radius = (int) (fraction * 18);
                     blurLayer.setAlpha(fraction);
                 }
@@ -1153,7 +1182,8 @@ public class LauncherActivity extends AppCompatActivity implements
             public void onViewScrollFinished(int page) {
                 isViewScrolling = false;
 
-                blurLayer.setAlpha((page == 0 || mFolderWindowContainer.getVisibility() == VISIBLE) ? 1f : 0f);
+                blurLayer.setAlpha((page == 0 || mFolderWindowContainer
+                    .getVisibility() == VISIBLE) ? 1f : 0f);
 
                 if (currentPageNumber != page) {
                     currentPageNumber = page;
@@ -1161,15 +1191,17 @@ public class LauncherActivity extends AppCompatActivity implements
                     // reappear when user swipes to the first apps page
                     if (currentPageNumber == 0) {
                         mDock.animate().translationYBy(
-                                Utilities.pxFromDp(105, LauncherActivity.this)).setDuration(
-                                100).withEndAction(() -> mDock.setVisibility(GONE));
+                            Utilities.pxFromDp(105, LauncherActivity.this)).setDuration(
+                            100).withEndAction(() -> mDock.setVisibility(GONE));
 
                         mIndicator.animate().alpha(0).setDuration(100).withEndAction(
-                                () -> mIndicator.setVisibility(GONE));
+                            () -> mIndicator.setVisibility(GONE));
                         refreshSuggestedApps(widgetsPage, forceRefreshSuggestedApps);
                         if (Preferences.weatherRefreshIntervalInMs(LauncherActivity.this) == 0) {
-                            Intent intent = new Intent(LauncherActivity.this,
-                                    WeatherUpdateService.class);
+                            Intent intent = new Intent(
+                                LauncherActivity.this,
+                                WeatherUpdateService.class
+                            );
                             intent.setAction(WeatherUpdateService.ACTION_FORCE_UPDATE);
                             startService(intent);
                         }
@@ -1198,7 +1230,7 @@ public class LauncherActivity extends AppCompatActivity implements
 
             // Check if usage stats have been changed or not to avoid unnecessary flickering
             if (forceRefresh || mUsageStats == null || mUsageStats.size() != usageStats.size()
-                    || !ListUtil.areEqualLists(mUsageStats, usageStats)) {
+                || !ListUtil.areEqualLists(mUsageStats, usageStats)) {
                 mUsageStats = usageStats;
                 if (suggestedAppsGridLayout.getChildCount() > 0) {
                     suggestedAppsGridLayout.removeAllViews();
@@ -1206,7 +1238,8 @@ public class LauncherActivity extends AppCompatActivity implements
                 int i = 0;
                 while (suggestedAppsGridLayout.getChildCount() < 4 && i < mUsageStats.size()) {
                     ApplicationItem appItem = AppUtils.createAppItem(this,
-                            mUsageStats.get(i).getPackageName(), new UserHandle());
+                        mUsageStats.get(i).getPackageName(), new UserHandle()
+                    );
                     if (appItem != null) {
                         BlissFrameLayout view = prepareSuggestedApp(appItem);
                         addAppToGrid(suggestedAppsGridLayout, view);
@@ -1224,7 +1257,8 @@ public class LauncherActivity extends AppCompatActivity implements
      * Populates the pages and the mDock for the first time.
      */
     private void createUI(
-            List<LauncherItem> launcherItems) {
+        List<LauncherItem> launcherItems
+    ) {
         mHorizontalPager.setUiCreated(false);
         mDock.setEnabled(false);
 
@@ -1252,7 +1286,7 @@ public class LauncherActivity extends AppCompatActivity implements
                 }
             } else if (launcherItem.container == Constants.CONTAINER_DESKTOP) {
                 if (workspaceScreen.getChildCount() >= mDeviceProfile.maxAppsPerPage
-                        || launcherItem.screenId > pages.size() - 1) {
+                    || launcherItem.screenId > pages.size() - 1) {
                     workspaceScreen = preparePage();
                     pages.add(workspaceScreen);
                 }
@@ -1279,14 +1313,16 @@ public class LauncherActivity extends AppCompatActivity implements
         grid.setRowCount(mDeviceProfile.numRows);
         grid.setLayoutTransition(getDefaultLayoutTransition());
         grid.setPadding(mDeviceProfile.iconDrawablePaddingPx / 2,
-                (int) (Utilities.pxFromDp(8, this)),
-                mDeviceProfile.iconDrawablePaddingPx / 2, 0);
+            (int) (Utilities.pxFromDp(8, this)),
+            mDeviceProfile.iconDrawablePaddingPx / 2, 0
+        );
         return grid;
     }
 
     private void createWidgetsPage() {
         widgetsPage = (InsettableFrameLayout) getLayoutInflater().inflate(R.layout.widgets_page,
-                mHorizontalPager, false);
+            mHorizontalPager, false
+        );
         widgetContainer = widgetsPage.findViewById(R.id.widget_container);
         /*widgetsPage.setPadding(0,
                 (int) (Utilities.pxFromDp(8, this)),
@@ -1296,7 +1332,7 @@ public class LauncherActivity extends AppCompatActivity implements
         InsettableScrollLayout scrollView = widgetsPage.findViewById(R.id.widgets_scroll_container);
         scrollView.setOnTouchListener((v, event) -> {
             if (widgetsPage.findViewById(R.id.widget_resizer_container).getVisibility()
-                    == VISIBLE) {
+                == VISIBLE) {
                 hideWidgetResizeContainer();
             }
             return false;
@@ -1309,13 +1345,13 @@ public class LauncherActivity extends AppCompatActivity implements
         // Prepare app suggestions view
         // [[BEGIN]]
         widgetsPage.findViewById(R.id.openUsageAccessSettings).setOnClickListener(
-                view -> startActivity(new Intent(Settings.ACTION_USAGE_ACCESS_SETTINGS)));
+            view -> startActivity(new Intent(Settings.ACTION_USAGE_ACCESS_SETTINGS)));
 
         // divided by 2 because of left and right padding.
         int padding =
-                (int) (mDeviceProfile.availableWidthPx / 2 - Utilities.pxFromDp(8, this)
-                        - 2
-                        * mDeviceProfile.cellWidthPx);
+            (int) (mDeviceProfile.availableWidthPx / 2 - Utilities.pxFromDp(8, this)
+                - 2
+                * mDeviceProfile.cellWidthPx);
         widgetsPage.findViewById(R.id.suggestedAppGrid).setPadding(padding, 0, padding, 0);
         // [[END]]
 
@@ -1351,27 +1387,29 @@ public class LauncherActivity extends AppCompatActivity implements
         AutoCompleteAdapter suggestionAdapter = new AutoCompleteAdapter(this);
         suggestionRecyclerView.setHasFixedSize(true);
         suggestionRecyclerView.setLayoutManager(
-                new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false));
+            new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false));
         suggestionRecyclerView.setAdapter(suggestionAdapter);
-        DividerItemDecoration dividerItemDecoration = new DividerItemDecoration(this,
-                DividerItemDecoration.VERTICAL);
+        DividerItemDecoration dividerItemDecoration = new DividerItemDecoration(
+            this,
+            DividerItemDecoration.VERTICAL
+        );
         suggestionRecyclerView.addItemDecoration(dividerItemDecoration);
-        getCompositeDisposable().add(RxTextView.textChanges(mSearchInput)
-                .debounce(300, TimeUnit.MILLISECONDS)
-                .map(CharSequence::toString)
-                .distinctUntilChanged()
-                .switchMap(charSequence -> {
-                    if (charSequence != null && charSequence.length() > 0) {
-                        return searchForQuery(charSequence);
-                    } else {
-                        return Observable.just(
-                                new SuggestionsResult(charSequence));
-                    }
-                })
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-                .subscribeWith(
-                        new SearchInputDisposableObserver(this, suggestionAdapter, widgetsPage)));
+        /*getCompositeDisposable().add(RxTextView.textChanges(mSearchInput)
+            .debounce(300, TimeUnit.MILLISECONDS)
+            .map(CharSequence::toString)
+            .distinctUntilChanged()
+            .switchMap(charSequence -> {
+                if (charSequence != null && charSequence.length() > 0) {
+                    return searchForQuery(charSequence);
+                } else {
+                    return Observable.just(
+                        new SuggestionsResult(charSequence));
+                }
+            })
+            .subscribeOn(Schedulers.io())
+            .observeOn(AndroidSchedulers.mainThread())
+            .subscribeWith(
+                new SearchInputDisposableObserver(this, suggestionAdapter, widgetsPage)));*/
 
         mSearchInput.setOnFocusChangeListener((v, hasFocus) -> {
             if (!hasFocus) {
@@ -1393,18 +1431,18 @@ public class LauncherActivity extends AppCompatActivity implements
 
         // Prepare edit widgets button
         findViewById(R.id.edit_widgets_button).setOnClickListener(
-                view -> startActivity(new Intent(this, WidgetsActivity.class)));
+            view -> startActivity(new Intent(this, WidgetsActivity.class)));
 
         // Prepare weather widget view
         // [[BEGIN]]
         findViewById(R.id.weather_setting_imageview).setOnClickListener(
-                v -> startActivity(new Intent(this, WeatherPreferences.class)));
+            v -> startActivity(new Intent(this, WeatherPreferences.class)));
 
         mWeatherSetupTextView = findViewById(R.id.weather_setup_textview);
         mWeatherPanel = findViewById(R.id.weather_panel);
         mWeatherPanel.setOnClickListener(v -> {
             Intent launchIntent = getPackageManager().getLaunchIntentForPackage(
-                    "foundation.e.weather");
+                "foundation.e.weather");
             if (launchIntent != null) {
                 launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                 startActivity(launchIntent);
@@ -1413,33 +1451,35 @@ public class LauncherActivity extends AppCompatActivity implements
         updateWeatherPanel();
 
         if (WeatherUtils.isWeatherServiceAvailable(
-                this)) {
+            this)) {
             startService(new Intent(this, WeatherSourceListenerService.class));
             startService(new Intent(this, DeviceStatusService.class));
         }
 
         LocalBroadcastManager.getInstance(this).registerReceiver(mWeatherReceiver, new IntentFilter(
-                WeatherUpdateService.ACTION_UPDATE_FINISHED));
+            WeatherUpdateService.ACTION_UPDATE_FINISHED));
 
         if (!Preferences.useCustomWeatherLocation(this)) {
             if (!WeatherPreferences.hasLocationPermission(this)) {
                 String[] permissions = new String[]{Manifest.permission.ACCESS_FINE_LOCATION};
-                requestPermissions(permissions,
-                        WeatherPreferences.LOCATION_PERMISSION_REQUEST_CODE);
+                requestPermissions(
+                    permissions,
+                    WeatherPreferences.LOCATION_PERMISSION_REQUEST_CODE
+                );
             } else {
                 LocationManager lm = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
                 if (!lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
-                        && Preferences.getEnableLocation(this)) {
+                    && Preferences.getEnableLocation(this)) {
                     showLocationEnableDialog();
                     Preferences.setEnableLocation(this);
                 } else {
                     startService(new Intent(this, WeatherUpdateService.class)
-                            .setAction(WeatherUpdateService.ACTION_FORCE_UPDATE));
+                        .setAction(WeatherUpdateService.ACTION_FORCE_UPDATE));
                 }
             }
         } else {
             startService(new Intent(this, WeatherUpdateService.class)
-                    .setAction(WeatherUpdateService.ACTION_FORCE_UPDATE));
+                .setAction(WeatherUpdateService.ACTION_FORCE_UPDATE));
         }
         // [[END]]
 
@@ -1449,33 +1489,36 @@ public class LauncherActivity extends AppCompatActivity implements
             AppWidgetProviderInfo appWidgetInfo = mAppWidgetManager.getAppWidgetInfo(id);
             if (appWidgetInfo != null) {
                 RoundedWidgetView hostView = (RoundedWidgetView) mAppWidgetHost.createView(
-                        getApplicationContext(), id,
-                        appWidgetInfo);
+                    getApplicationContext(), id,
+                    appWidgetInfo
+                );
                 hostView.setAppWidget(id, appWidgetInfo);
                 getCompositeDisposable().add(DatabaseManager.getManager(this).getHeightOfWidget(id)
-                        .subscribeOn(Schedulers.from(AppExecutors.getInstance().diskIO()))
-                        .observeOn(AndroidSchedulers.mainThread())
-                        .subscribe(height -> {
-                            RoundedWidgetView widgetView = WidgetViewBuilder.create(this, hostView);
-                            if (height != 0) {
-                                int minHeight = hostView.getAppWidgetInfo().minResizeHeight;
-                                int maxHeight = mDeviceProfile.availableHeightPx * 3 / 4;
-                                int normalisedDifference = (maxHeight - minHeight) / 100;
-                                int newHeight = minHeight + (normalisedDifference * height);
-                                widgetView.getLayoutParams().height = newHeight;
-                            }
-                            addWidgetToContainer(widgetView);
-                        }, Throwable::printStackTrace));
+                    .subscribeOn(Schedulers.from(AppExecutors.getInstance().diskIO()))
+                    .observeOn(AndroidSchedulers.mainThread())
+                    .subscribe(height -> {
+                        RoundedWidgetView widgetView = null;
+                        if (height != 0) {
+                            int minHeight = hostView.getAppWidgetInfo().minResizeHeight;
+                            int maxHeight = mDeviceProfile.availableHeightPx * 3 / 4;
+                            int normalisedDifference = (maxHeight - minHeight) / 100;
+                            int newHeight = minHeight + (normalisedDifference * height);
+                            widgetView.getLayoutParams().height = newHeight;
+                        }
+                        addWidgetToContainer(widgetView);
+                    }, Throwable::printStackTrace));
             }
         }
     }
 
     @Override
-    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
-                                           @NonNull int[] grantResults) {
+    public void onRequestPermissionsResult(
+        int requestCode, @NonNull String[] permissions,
+        @NonNull int[] grantResults
+    ) {
         if (requestCode == WeatherPreferences.LOCATION_PERMISSION_REQUEST_CODE) {
             if (grantResults.length > 0
-                    && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+                && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                 // We only get here if user tried to enable the preference,
                 // hence safe to turn it on after permission is granted
                 LocationManager lm = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
@@ -1484,12 +1527,12 @@ public class LauncherActivity extends AppCompatActivity implements
                     Preferences.setEnableLocation(this);
                 } else {
                     startService(new Intent(this, WeatherUpdateService.class)
-                            .setAction(WeatherUpdateService.ACTION_FORCE_UPDATE));
+                        .setAction(WeatherUpdateService.ACTION_FORCE_UPDATE));
                 }
             }
         } else if (requestCode == STORAGE_PERMISSION_REQUEST_CODE) {
             if (grantResults.length > 0
-                    && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+                && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                 BlurWallpaperProvider.Companion.getInstance(getApplicationContext()).updateAsync();
             }
         }
@@ -1500,14 +1543,15 @@ public class LauncherActivity extends AppCompatActivity implements
             mWeatherSetupTextView.setVisibility(VISIBLE);
             mWeatherPanel.setVisibility(GONE);
             mWeatherSetupTextView.setOnClickListener(
-                    v -> startActivity(
-                            new Intent(LauncherActivity.this, WeatherPreferences.class)));
+                v -> startActivity(
+                    new Intent(LauncherActivity.this, WeatherPreferences.class)));
             return;
         }
         mWeatherSetupTextView.setVisibility(GONE);
         mWeatherPanel.setVisibility(VISIBLE);
         ForecastBuilder.buildLargePanel(this, mWeatherPanel,
-                Preferences.getCachedWeatherInfo(this));
+            Preferences.getCachedWeatherInfo(this)
+        );
     }
 
     private void showLocationEnableDialog() {
@@ -1516,13 +1560,15 @@ public class LauncherActivity extends AppCompatActivity implements
         builder.setTitle(R.string.weather_retrieve_location_dialog_title);
         builder.setMessage(R.string.weather_retrieve_location_dialog_message);
         builder.setCancelable(false);
-        builder.setPositiveButton(R.string.weather_retrieve_location_dialog_enable_button,
-                (dialog1, whichButton) -> {
-                    Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
-                    intent.setFlags(
-                            Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
-                    startActivityForResult(intent, REQUEST_LOCATION_SOURCE_SETTING);
-                });
+        builder.setPositiveButton(
+            R.string.weather_retrieve_location_dialog_enable_button,
+            (dialog1, whichButton) -> {
+                Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
+                intent.setFlags(
+                    Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+                startActivityForResult(intent, REQUEST_LOCATION_SOURCE_SETTING);
+            }
+        );
         builder.setNegativeButton(R.string.cancel, null);
         enableLocationDialog = builder.create();
         enableLocationDialog.show();
@@ -1534,10 +1580,11 @@ public class LauncherActivity extends AppCompatActivity implements
             LocationManager lm = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
             if (!lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER)) {
                 Toast.makeText(this, "Set custom location in weather settings.",
-                        Toast.LENGTH_SHORT).show();
+                    Toast.LENGTH_SHORT
+                ).show();
             } else {
                 startService(new Intent(this, WeatherUpdateService.class)
-                        .setAction(WeatherUpdateService.ACTION_FORCE_UPDATE));
+                    .setAction(WeatherUpdateService.ACTION_FORCE_UPDATE));
             }
         } else {
             super.onActivityResult(requestCode, resultCode, data);
@@ -1545,19 +1592,21 @@ public class LauncherActivity extends AppCompatActivity implements
     }
 
     private ObservableSource<SuggestionsResult> searchForQuery(
-            CharSequence charSequence) {
+        CharSequence charSequence
+    ) {
         Observable<SuggestionsResult> launcherItems = searchForLauncherItems(
-                charSequence.toString()).subscribeOn(Schedulers.io());
+            charSequence.toString()).subscribeOn(Schedulers.io());
         Observable<SuggestionsResult> networkItems = searchForNetworkItems(
-                charSequence).subscribeOn(Schedulers.io());
+            charSequence).subscribeOn(Schedulers.io());
         return launcherItems.mergeWith(networkItems);
     }
 
     private Observable<SuggestionsResult> searchForLauncherItems(
-            CharSequence charSequence) {
+        CharSequence charSequence
+    ) {
         String query = charSequence.toString().toLowerCase();
         SuggestionsResult suggestionsResult = new SuggestionsResult(
-                query);
+            query);
         List<LauncherItem> launcherItems = new ArrayList<>();
         pages.parallelStream().forEach(gridLayout -> {
             for (int i = 0; i < gridLayout.getChildCount(); i++) {
@@ -1592,7 +1641,7 @@ public class LauncherActivity extends AppCompatActivity implements
         }
 
         launcherItems.sort(Comparator.comparing(launcherItem ->
-                launcherItem.title.toString().toLowerCase().indexOf(query)
+            launcherItem.title.toString().toLowerCase().indexOf(query)
         ));
 
         if (launcherItems.size() > 4) {
@@ -1601,16 +1650,16 @@ public class LauncherActivity extends AppCompatActivity implements
             suggestionsResult.setLauncherItems(launcherItems);
         }
         return Observable.just(suggestionsResult)
-                .onErrorReturn(throwable -> {
-                    suggestionsResult.setLauncherItems(new ArrayList<>());
-                    return suggestionsResult;
-                });
+            .onErrorReturn(throwable -> {
+                suggestionsResult.setLauncherItems(new ArrayList<>());
+                return suggestionsResult;
+            });
     }
 
     private Observable<SuggestionsResult> searchForNetworkItems(CharSequence charSequence) {
         String query = charSequence.toString().toLowerCase(Locale.getDefault()).trim();
         SuggestionProvider suggestionProvider = new SearchSuggestionUtil().getSuggestionProvider(
-                this);
+            this);
         return suggestionProvider.query(query).toObservable();
     }
 
@@ -1623,8 +1672,10 @@ public class LauncherActivity extends AppCompatActivity implements
     }
 
     private void runSearch(String query) {
-        Intent intent = new Intent(Intent.ACTION_VIEW,
-                new SearchSuggestionUtil().getUriForQuery(this, query));
+        Intent intent = new Intent(
+            Intent.ACTION_VIEW,
+            new SearchSuggestionUtil().getUriForQuery(this, query)
+        );
         startActivity(intent);
     }
 
@@ -1646,7 +1697,7 @@ public class LauncherActivity extends AppCompatActivity implements
         view.setLayoutParams(iconLayoutParams);
         view.setWithText(true);
         if (index == EMPTY_LOCATION_DRAG || index == LauncherItem.INVALID_CELL
-                || index > page.getChildCount()) {
+            || index > page.getChildCount()) {
             page.addView(view);
         } else {
             page.addView(view, index);
@@ -1669,7 +1720,7 @@ public class LauncherActivity extends AppCompatActivity implements
         view.setLayoutParams(iconLayoutParams);
         view.setWithText(false);
         if (index == LauncherItem.INVALID_CELL || index == EMPTY_LOCATION_DRAG
-                || index > mDock.getChildCount()) {
+            || index > mDock.getChildCount()) {
             mDock.addView(view);
         } else {
             mDock.addView(view, index);
@@ -1685,20 +1736,25 @@ public class LauncherActivity extends AppCompatActivity implements
     @SuppressLint({"InflateParams", "ClickableViewAccessibility"})
     private BlissFrameLayout prepareLauncherItem(final LauncherItem launcherItem) {
         final BlissFrameLayout iconView = (BlissFrameLayout) getLayoutInflater().inflate(
-                R.layout.app_view,
-                null);
+            R.layout.app_view,
+            null
+        );
         iconView.setLauncherItem(launcherItem);
         final SquareFrameLayout icon = iconView.findViewById(R.id.app_icon);
         if (launcherItem.itemType == Constants.ITEM_TYPE_FOLDER) {
-            iconView.applyBadge(checkHasApp((FolderItem) launcherItem, mAppsWithNotifications),
-                    launcherItem.container != Constants.CONTAINER_HOTSEAT);
+            iconView.applyBadge(
+                checkHasApp((FolderItem) launcherItem, mAppsWithNotifications),
+                launcherItem.container != Constants.CONTAINER_HOTSEAT
+            );
         } else if (launcherItem.itemType == Constants.ITEM_TYPE_APPLICATION) {
             ApplicationItem applicationItem = (ApplicationItem) launcherItem;
             if (applicationItem.appType == ApplicationItem.TYPE_CALENDAR) {
                 mCalendarIcons.add(iconView);
             }
-            iconView.applyBadge(mAppsWithNotifications.contains(applicationItem.packageName),
-                    launcherItem.container != Constants.CONTAINER_HOTSEAT);
+            iconView.applyBadge(
+                mAppsWithNotifications.contains(applicationItem.packageName),
+                launcherItem.container != Constants.CONTAINER_HOTSEAT
+            );
         }
 
         icon.setOnLongClickListener(view -> {
@@ -1718,12 +1774,13 @@ public class LauncherActivity extends AppCompatActivity implements
                     }
                 } else if (event.getActionMasked() == MotionEvent.ACTION_MOVE) {
                     if (longPressed || (!mLongClickStartsDrag
-                            && (System.currentTimeMillis() - iconPressedAt) > 150)) {
+                        && (System.currentTimeMillis() - iconPressedAt) > 150)) {
                         longPressed = false;
                         movingApp = iconView;
                         dragShadowBuilder = new BlissDragShadowBuilder(
-                                icon, (event.getX() < 0 ? 0 : event.getX()),
-                                (event.getY() < 0 ? 0 : event.getY()));
+                            icon, (event.getX() < 0 ? 0 : event.getX()),
+                            (event.getY() < 0 ? 0 : event.getY())
+                        );
                         icon.startDrag(null, dragShadowBuilder, iconView, 0);
                         if (iconView.getParent().getParent() instanceof HorizontalPager) {
                             parentPage = getCurrentAppsPageNumber();
@@ -1766,14 +1823,15 @@ public class LauncherActivity extends AppCompatActivity implements
 
     public BlissFrameLayout prepareSuggestedApp(final LauncherItem launcherItem) {
         final BlissFrameLayout v = (BlissFrameLayout) getLayoutInflater().inflate(
-                R.layout.app_view,
-                null);
+            R.layout.app_view,
+            null
+        );
         v.setLauncherItem(launcherItem);
         final SquareFrameLayout icon = v.findViewById(R.id.app_icon);
 
         if (launcherItem.itemType == Constants.ITEM_TYPE_APPLICATION) {
             v.applyBadge(mAppsWithNotifications.contains(
-                    ((ApplicationItem) launcherItem).packageName), true);
+                ((ApplicationItem) launcherItem).packageName), true);
         }
         icon.setOnClickListener(view -> startActivitySafely(this, launcherItem, view));
         return v;
@@ -1793,17 +1851,22 @@ public class LauncherActivity extends AppCompatActivity implements
         } else {
             ApplicationItem applicationItem = (ApplicationItem) launcherItem;
             if (applicationItem.isDisabled) {
-                Toast.makeText(this, "Package not available or disabled", Toast.LENGTH_SHORT).show();
+                Toast.makeText(this, "Package not available or disabled", Toast.LENGTH_SHORT)
+                    .show();
             } else {
                 if (user == null || user.equals(Process.myUserHandle())) {
                     context.startActivity(intent);
                 } else {
                     ((LauncherApps) getSystemService(LAUNCHER_APPS_SERVICE))
-                            .startMainActivity(intent.getComponent(), user, intent.getSourceBounds(), null);
+                        .startMainActivity(
+                            intent.getComponent(),
+                            user,
+                            intent.getSourceBounds(),
+                            null
+                        );
                 }
             }
         }
-
     }
 
     private void startShortcutIntentSafely(Context context, Intent intent, LauncherItem appItem) {
@@ -1814,19 +1877,19 @@ public class LauncherActivity extends AppCompatActivity implements
                 // containing file Uri's would cause a crash as penaltyDeathOnFileUriExposure
                 // is enabled by default on NYC.
                 StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder().detectAll()
-                        .penaltyLog().build());
+                    .penaltyLog().build());
 
                 if (appItem.itemType == Constants.ITEM_TYPE_SHORTCUT) {
                     if (Utilities.ATLEAST_OREO) {
                         String id = appItem.id;
                         String packageName = intent.getPackage();
                         DeepShortcutManager.getInstance(context).startShortcut(
-                                packageName, id, intent.getSourceBounds(), null,
-                                Process.myUserHandle());
+                            packageName, id, intent.getSourceBounds(), null,
+                            Process.myUserHandle()
+                        );
                     } else {
                         context.startActivity(intent);
                     }
-
                 } else {
                     // Could be launching some bookkeeping activity
                     context.startActivity(intent);
@@ -1839,11 +1902,13 @@ public class LauncherActivity extends AppCompatActivity implements
             // corresponding permission. Show the appropriate permission prompt if that
             // is the case.
             if (intent.getComponent() == null
-                    && Intent.ACTION_CALL.equals(intent.getAction())
-                    && context.checkSelfPermission(Manifest.permission.CALL_PHONE) !=
-                    PackageManager.PERMISSION_GRANTED) {
-                requestPermissions(new String[]{Manifest.permission.CALL_PHONE},
-                        REQUEST_PERMISSION_CALL_PHONE);
+                && Intent.ACTION_CALL.equals(intent.getAction())
+                && context.checkSelfPermission(Manifest.permission.CALL_PHONE) !=
+                PackageManager.PERMISSION_GRANTED) {
+                requestPermissions(
+                    new String[]{Manifest.permission.CALL_PHONE},
+                    REQUEST_PERMISSION_CALL_PHONE
+                );
             } else {
                 // No idea why this was thrown.
                 throw e;
@@ -1890,20 +1955,24 @@ public class LauncherActivity extends AppCompatActivity implements
         }
     }
 
-    private void makeAppWobble(BlissFrameLayout blissFrameLayout, boolean shouldPlayAnimation,
-                               int i) {
+    private void makeAppWobble(
+        BlissFrameLayout blissFrameLayout, boolean shouldPlayAnimation,
+        int i
+    ) {
         UserManager userManager = (UserManager) getSystemService(Context.USER_SERVICE);
         Bundle restrictions = userManager.getUserRestrictions();
-        boolean uninstallDisabled = restrictions.getBoolean(UserManager.DISALLOW_APPS_CONTROL,
-                false)
-                || restrictions.getBoolean(UserManager.DISALLOW_UNINSTALL_APPS, false);
+        boolean uninstallDisabled = restrictions.getBoolean(
+            UserManager.DISALLOW_APPS_CONTROL,
+            false
+        )
+            || restrictions.getBoolean(UserManager.DISALLOW_UNINSTALL_APPS, false);
         if (shouldPlayAnimation) {
             if (blissFrameLayout.getAnimation() == null) {
                 ImageView imageView = blissFrameLayout.findViewById(R.id.uninstall_app);
                 if (imageView == null) {
                     if (!uninstallDisabled) {
                         new Handler(Looper.getMainLooper()).post(
-                                () -> addUninstallIcon(blissFrameLayout));
+                            () -> addUninstallIcon(blissFrameLayout));
                     }
                 }
 
@@ -1916,7 +1985,7 @@ public class LauncherActivity extends AppCompatActivity implements
         } else {
             blissFrameLayout.clearAnimation();
             new Handler(Looper.getMainLooper()).post(
-                    () -> removeUninstallIcon(blissFrameLayout));
+                () -> removeUninstallIcon(blissFrameLayout));
         }
     }
 
@@ -1948,14 +2017,14 @@ public class LauncherActivity extends AppCompatActivity implements
         SquareFrameLayout appIcon = blissFrameLayout.findViewById(R.id.app_icon);
         int size = mDeviceProfile.uninstallIconSizePx;
         int topPadding = (appIcon.getTop() - mDeviceProfile.uninstallIconSizePx / 2
-                + mDeviceProfile.uninstallIconPadding > 0) ?
-                appIcon.getTop() - mDeviceProfile.uninstallIconSizePx / 2
-                        + mDeviceProfile.uninstallIconPadding : 0;
+            + mDeviceProfile.uninstallIconPadding > 0) ?
+            appIcon.getTop() - mDeviceProfile.uninstallIconSizePx / 2
+                + mDeviceProfile.uninstallIconPadding : 0;
         int bottomPadding = topPadding;
         int rightPadding = (appIcon.getLeft() - mDeviceProfile.uninstallIconSizePx / 2
-                + mDeviceProfile.uninstallIconPadding > 0) ?
-                appIcon.getLeft() - mDeviceProfile.uninstallIconSizePx / 2
-                        + mDeviceProfile.uninstallIconPadding : 0;
+            + mDeviceProfile.uninstallIconPadding > 0) ?
+            appIcon.getLeft() - mDeviceProfile.uninstallIconSizePx / 2
+                + mDeviceProfile.uninstallIconPadding : 0;
         int leftPadding = rightPadding;
 
         ImageView imageView = new ImageView(this);
@@ -1973,49 +2042,59 @@ public class LauncherActivity extends AppCompatActivity implements
                     Toast.makeText(this, "Can not uninstall this app", Toast.LENGTH_SHORT).show();
                 } else {
                     Uri packageUri = Uri.fromParts("package", componentName.getPackageName(),
-                            componentName.getClassName());
+                        componentName.getClassName()
+                    );
                     Intent i = new Intent(Intent.ACTION_UNINSTALL_PACKAGE, packageUri)
-                            .putExtra(Intent.EXTRA_USER, launcherItem.user.getRealHandle());
+                        .putExtra(Intent.EXTRA_USER, launcherItem.user.getRealHandle());
                     startActivity(i);
                 }
             } else if (launcherItem.itemType == Constants.ITEM_TYPE_SHORTCUT) {
-                AlertDialog dialog = new AlertDialog.Builder(new ContextThemeWrapper(this, R.style.AlertDialogCustom))
-                        .setTitle(launcherItem.title)
-                        .setMessage(R.string.uninstall_shortcut_dialog)
-                        .setPositiveButton(R.string.ok, (dialog1, which) -> {
-                            ShortcutItem shortcut = (ShortcutItem) launcherItem;
-                            if (shortcut.packageName != null) {
-                                DeepShortcutManager.getInstance(this).unpinShortcut(ShortcutKey.fromItem(shortcut));
-                                if (DeepShortcutManager.getInstance(this).wasLastCallSuccess()) {
-                                    deleteShortcutFromProvider(shortcut.id);
-                                    removeShortcutView(shortcut, blissFrameLayout);
-                                }
-                            } else {
-                                // Null package name generally comes for nougat shortcuts so don't unpin here, just directly delete it.
+                AlertDialog dialog = new AlertDialog.Builder(new ContextThemeWrapper(
+                    this,
+                    R.style.AlertDialogCustom
+                ))
+                    .setTitle(launcherItem.title)
+                    .setMessage(R.string.uninstall_shortcut_dialog)
+                    .setPositiveButton(R.string.ok, (dialog1, which) -> {
+                        ShortcutItem shortcut = (ShortcutItem) launcherItem;
+                        if (shortcut.packageName != null) {
+                            DeepShortcutManager.getInstance(this)
+                                .unpinShortcut(ShortcutKey.fromItem(shortcut));
+                            if (DeepShortcutManager.getInstance(this).wasLastCallSuccess()) {
                                 deleteShortcutFromProvider(shortcut.id);
                                 removeShortcutView(shortcut, blissFrameLayout);
                             }
-
-                        })
-                        .setNegativeButton(R.string.cancel, null)
-                        .setIcon(launcherItem.icon)
-                        .create();
+                        } else {
+                            // Null package name generally comes for nougat shortcuts so don't unpin here, just directly delete it.
+                            deleteShortcutFromProvider(shortcut.id);
+                            removeShortcutView(shortcut, blissFrameLayout);
+                        }
+                    })
+                    .setNegativeButton(R.string.cancel, null)
+                    .setIcon(launcherItem.icon)
+                    .create();
                 dialog.setOnShowListener(arg0 -> {
-                    dialog.getButton(AlertDialog.BUTTON_POSITIVE).setTextColor(getResources().getColor(R.color.color_blue));
-                    dialog.getButton(AlertDialog.BUTTON_NEGATIVE).setTextColor(getResources().getColor(R.color.color_blue));
+                    dialog.getButton(AlertDialog.BUTTON_POSITIVE)
+                        .setTextColor(getResources().getColor(R.color.color_blue));
+                    dialog.getButton(AlertDialog.BUTTON_NEGATIVE)
+                        .setTextColor(getResources().getColor(R.color.color_blue));
                 });
                 dialog.show();
             }
         });
         FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(
-                size + 2 * rightPadding, size + 2 * topPadding);
+            size + 2 * rightPadding, size + 2 * topPadding);
         layoutParams.gravity = Gravity.END | Gravity.TOP;
         blissFrameLayout.addView(imageView, layoutParams);
     }
 
     private void deleteShortcutFromProvider(String id) {
         ContentResolver resolver = getContentResolver();
-        int count = resolver.delete(Uri.parse("content://foundation.e.pwaplayer.provider/pwa"), null, new String[]{id});
+        int count = resolver.delete(
+            Uri.parse("content://foundation.e.pwaplayer.provider/pwa"),
+            null,
+            new String[]{id}
+        );
         Log.d("LauncherActivity", "Items deleted from pwa provider: " + count);
     }
 
@@ -2028,7 +2107,7 @@ public class LauncherActivity extends AppCompatActivity implements
             ((ViewGroup) blissFrameLayout.getParent()).removeView(blissFrameLayout);
             if (activeFolder.items.size() == 0) {
                 ((ViewGroup) activeFolderView.getParent()).removeView
-                        (activeFolderView);
+                    (activeFolderView);
                 hideFolderWindowContainer();
             } else if (activeFolder.items.size() == 1) {
                 LauncherItem item = activeFolder.items.get(0);
@@ -2040,18 +2119,20 @@ public class LauncherActivity extends AppCompatActivity implements
                     addAppToDock(view, mDock.indexOfChild(activeFolderView));
                 } else {
                     GridLayout gridLayout = pages.get
-                            (getCurrentAppsPageNumber());
+                        (getCurrentAppsPageNumber());
                     addAppToGrid(gridLayout, view,
-                            gridLayout.indexOfChild(activeFolderView));
+                        gridLayout.indexOfChild(activeFolderView)
+                    );
                 }
                 activeFolderView.clearAnimation();
                 ((ViewGroup) activeFolderView.getParent()).removeView(
-                        activeFolderView);
+                    activeFolderView);
                 hideFolderWindowContainer();
             } else {
                 updateIcon(activeFolderView, activeFolder,
-                        new GraphicsUtil(this).generateFolderIcon(this, activeFolder),
-                        folderFromDock);
+                    new GraphicsUtil(this).generateFolderIcon(this, activeFolder),
+                    folderFromDock
+                );
                 hideFolderWindowContainer();
             }
         } else {
@@ -2083,7 +2164,7 @@ public class LauncherActivity extends AppCompatActivity implements
                     // Don't offer rearrange functionality when app is being dragged
                     // out of folder window
                     if (getAppDetails(movingApp).container != Constants.CONTAINER_DESKTOP
-                            && getAppDetails(movingApp).container != Constants.CONTAINER_HOTSEAT) {
+                        && getAppDetails(movingApp).container != Constants.CONTAINER_HOTSEAT) {
                         return true;
                     }
 
@@ -2110,12 +2191,14 @@ public class LauncherActivity extends AppCompatActivity implements
                         discardCollidingApp();
                     } else {
                         BlissFrameLayout latestCollidingApp =
-                                (BlissFrameLayout) mDock.getChildAt(index);
+                            (BlissFrameLayout) mDock.getChildAt(index);
                         if (collidingApp != latestCollidingApp) {
                             if (collidingApp != null) {
-                                makeAppCold(collidingApp,
-                                        !(collidingApp.getParent().getParent() instanceof
-                                                HorizontalPager));
+                                makeAppCold(
+                                    collidingApp,
+                                    !(collidingApp.getParent().getParent() instanceof
+                                        HorizontalPager)
+                                );
                             }
                             collidingApp = latestCollidingApp;
                             folderInterest = false;
@@ -2135,15 +2218,17 @@ public class LauncherActivity extends AppCompatActivity implements
                                 makeAppHot(collidingApp);
                             } else {
                                 View app = collidingApp;
-                                makeAppCold(app,
-                                        !(app.getParent().getParent() instanceof HorizontalPager));
+                                makeAppCold(
+                                    app,
+                                    !(app.getParent().getParent() instanceof HorizontalPager)
+                                );
                             }
                         }
                     }
 
                     if (!folderInterest && !mDockReorderAlarm.alarmPending()) {
                         DockReorderAlarmListener dockReorderAlarmListener =
-                                new DockReorderAlarmListener(index);
+                            new DockReorderAlarmListener(index);
                         mDockReorderAlarm.setOnAlarmListener(dockReorderAlarmListener);
                         mDockReorderAlarm.setAlarm(REORDER_TIMEOUT);
                     }
@@ -2157,9 +2242,11 @@ public class LauncherActivity extends AppCompatActivity implements
                         if (!folderInterest) {
                             if (movingApp.getParent() == null) {
                                 if (mDock.getChildCount() >= mDeviceProfile.numColumns) {
-                                    Toast.makeText(LauncherActivity.this,
-                                            "Dock is already full",
-                                            Toast.LENGTH_SHORT).show();
+                                    Toast.makeText(
+                                        LauncherActivity.this,
+                                        "Dock is already full",
+                                        Toast.LENGTH_SHORT
+                                    ).show();
                                 } else {
                                     addAppToDock(movingApp, EMPTY_LOCATION_DRAG);
                                 }
@@ -2186,14 +2273,15 @@ public class LauncherActivity extends AppCompatActivity implements
                         int bottom = top + mFolderAppsViewPager.getHeight();
 
                         if (!(left < right && top < bottom && cX >= left
-                                && cX < right && cY >= top && cY < bottom)) {
+                            && cX < right && cY >= top && cY < bottom)) {
                             removeAppFromFolder();
                         } else {
                             movingApp.setVisibility(View.VISIBLE);
                             int currentItem = mFolderAppsViewPager.getCurrentItem();
                             makeAppWobble(movingApp, true,
-                                    ((GridLayout) mFolderAppsViewPager.getChildAt(
-                                            currentItem)).indexOfChild(movingApp));
+                                ((GridLayout) mFolderAppsViewPager.getChildAt(
+                                    currentItem)).indexOfChild(movingApp)
+                            );
                         }
                     }
                     return true;
@@ -2218,12 +2306,12 @@ public class LauncherActivity extends AppCompatActivity implements
                 } else if (dragEvent.getAction() == DragEvent.ACTION_DRAG_LOCATION) {
                     cX = dragEvent.getX() - dragShadowBuilder.xOffset;
                     cY = mHorizontalPager.getY() + dragEvent.getY()
-                            - dragShadowBuilder.yOffset;
+                        - dragShadowBuilder.yOffset;
 
                     // Don't offer rearrange functionality when app is being dragged
                     // out of folder window
                     if (getAppDetails(movingApp).container != Constants.CONTAINER_DESKTOP
-                            && getAppDetails(movingApp).container != Constants.CONTAINER_HOTSEAT) {
+                        && getAppDetails(movingApp).container != Constants.CONTAINER_HOTSEAT) {
                         return true;
                     }
 
@@ -2238,16 +2326,16 @@ public class LauncherActivity extends AppCompatActivity implements
                         if (getCurrentAppsPageNumber() + 1 < pages.size()) {
                             mHorizontalPager.scrollRight(300);
                         } else if (getCurrentAppsPageNumber() + 1 == pages.size()
-                                && getGridFromPage(page).getChildCount() > 1) {
+                            && getGridFromPage(page).getChildCount() > 1) {
                             GridLayout layout = preparePage();
                             pages.add(layout);
                             ImageView dot = new ImageView(LauncherActivity.this);
                             dot.setImageDrawable(getDrawable(R.drawable.dot_off));
                             LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
-                                    getResources().getDimensionPixelSize(
-                                            R.dimen.dotSize),
-                                    getResources().getDimensionPixelSize(
-                                            R.dimen.dotSize)
+                                getResources().getDimensionPixelSize(
+                                    R.dimen.dotSize),
+                                getResources().getDimensionPixelSize(
+                                    R.dimen.dotSize)
                             );
                             dot.setLayoutParams(params);
                             mIndicator.addView(dot);
@@ -2260,8 +2348,8 @@ public class LauncherActivity extends AppCompatActivity implements
                         if (getCurrentAppsPageNumber() - 1 >= 0) {
                             mHorizontalPager.scrollLeft(300);
                         } else if (getCurrentAppsPageNumber() + 1 == pages.size() - 2
-                                && getGridFromPage(pages.get(pages.size() - 1)).getChildCount()
-                                <= 0) {
+                            && getGridFromPage(pages.get(pages.size() - 1)).getChildCount()
+                            <= 0) {
                             mIndicator.removeViewAt(pages.size());
                             mHorizontalPager.removeViewAt(pages.size());
                             pages.remove(pages.size() - 1);
@@ -2282,9 +2370,11 @@ public class LauncherActivity extends AppCompatActivity implements
                             View latestCollidingApp = getGridFromPage(page).getChildAt(index);
                             if (collidingApp != latestCollidingApp) {
                                 if (collidingApp != null) {
-                                    makeAppCold(collidingApp,
-                                            !(collidingApp.getParent().getParent() instanceof
-                                                    HorizontalPager));
+                                    makeAppCold(
+                                        collidingApp,
+                                        !(collidingApp.getParent().getParent() instanceof
+                                            HorizontalPager)
+                                    );
                                 }
                                 collidingApp = (BlissFrameLayout) latestCollidingApp;
                                 folderInterest = false;
@@ -2294,8 +2384,9 @@ public class LauncherActivity extends AppCompatActivity implements
                                 folderInterest = false;
                             } else {
                                 latestFolderInterest = checkIfFolderInterest(
-                                        getGridFromPage(pages.get(getCurrentAppsPageNumber())),
-                                        index, cX, cY);
+                                    getGridFromPage(pages.get(getCurrentAppsPageNumber())),
+                                    index, cX, cY
+                                );
 
                                 if (latestFolderInterest != folderInterest) {
                                     folderInterest = latestFolderInterest;
@@ -2305,16 +2396,18 @@ public class LauncherActivity extends AppCompatActivity implements
                                     cleanupDockReorder(true);
                                     makeAppHot(collidingApp);
                                 } else {
-                                    makeAppCold(collidingApp,
-                                            !(collidingApp.getParent().getParent() instanceof
-                                                    HorizontalPager));
+                                    makeAppCold(
+                                        collidingApp,
+                                        !(collidingApp.getParent().getParent() instanceof
+                                            HorizontalPager)
+                                    );
                                 }
                             }
                         }
 
                         if (!folderInterest && !mReorderAlarm.alarmPending()) {
                             ReorderAlarmListener reorderAlarmListener = new ReorderAlarmListener(
-                                    page, (ViewGroup) movingApp.getParent(), index);
+                                page, (ViewGroup) movingApp.getParent(), index);
                             mReorderAlarm.setOnAlarmListener(reorderAlarmListener);
                             mReorderAlarm.setAlarm(REORDER_TIMEOUT);
                         }
@@ -2329,7 +2422,7 @@ public class LauncherActivity extends AppCompatActivity implements
                         if (!folderInterest) {
                             if (movingApp.getParent() == null) {
                                 if (gridLayout.getChildCount()
-                                        < mDeviceProfile.maxAppsPerPage) {
+                                    < mDeviceProfile.maxAppsPerPage) {
                                     addAppToGrid(gridLayout, movingApp);
                                 }
                             }
@@ -2347,7 +2440,7 @@ public class LauncherActivity extends AppCompatActivity implements
                     } else {
                         cX = dragEvent.getX() - dragShadowBuilder.xOffset;
                         cY = mHorizontalPager.getY() + dragEvent.getY()
-                                - dragShadowBuilder.yOffset;
+                            - dragShadowBuilder.yOffset;
 
                         // Drop functionality when the folder window is visible
                         int[] topLeftCorner = new int[2];
@@ -2358,16 +2451,17 @@ public class LauncherActivity extends AppCompatActivity implements
                         int bottom = top + mFolderAppsViewPager.getHeight();
 
                         if (!(left < right && top < bottom && cX >= left
-                                && cX < right && cY >= top && cY < bottom)) {
+                            && cX < right && cY >= top && cY < bottom)) {
                             removeAppFromFolder();
                         } else {
                             movingApp.setVisibility(View.VISIBLE);
                             int currentItem = mFolderAppsViewPager.getCurrentItem();
                             GridLayout gridLayout = (GridLayout) mFolderAppsViewPager.getChildAt(
-                                    currentItem);
+                                currentItem);
                             if (gridLayout != null) {
                                 makeAppWobble(movingApp, true,
-                                        gridLayout.indexOfChild(movingApp));
+                                    gridLayout.indexOfChild(movingApp)
+                                );
                             }
                         }
                     }
@@ -2383,12 +2477,14 @@ public class LauncherActivity extends AppCompatActivity implements
                         if (mFolderWindowContainer.getVisibility() == View.VISIBLE) {
                             int currentItem = mFolderAppsViewPager.getCurrentItem();
                             makeAppWobble(movingApp, true,
-                                    ((GridLayout) mFolderAppsViewPager.getChildAt(
-                                            currentItem)).indexOfChild(movingApp));
+                                ((GridLayout) mFolderAppsViewPager.getChildAt(
+                                    currentItem)).indexOfChild(movingApp)
+                            );
                         } else if (movingApp.getParent().getParent() instanceof HorizontalPager) {
                             GridLayout gridLayout = pages.get(getCurrentAppsPageNumber());
                             makeAppWobble(movingApp, true,
-                                    gridLayout.indexOfChild(movingApp));
+                                gridLayout.indexOfChild(movingApp)
+                            );
                         } else {
                             makeAppWobble(movingApp, true, mDock.indexOfChild(movingApp));
                         }
@@ -2453,20 +2549,21 @@ public class LauncherActivity extends AppCompatActivity implements
      */
     private void removeAppFromFolder() {
         if (pages.get(getCurrentAppsPageNumber()).getChildCount()
-                >= mDeviceProfile.maxAppsPerPage) {
+            >= mDeviceProfile.maxAppsPerPage) {
             Toast.makeText(this, "No more room in page", Toast.LENGTH_SHORT).show();
             movingApp.setVisibility(View.VISIBLE);
             int currentItem = mFolderAppsViewPager.getCurrentItem();
             makeAppWobble(movingApp, true,
-                    ((GridLayout) mFolderAppsViewPager.getChildAt(
-                            currentItem)).indexOfChild(movingApp));
+                ((GridLayout) mFolderAppsViewPager.getChildAt(
+                    currentItem)).indexOfChild(movingApp)
+            );
         } else {
             LauncherItem app = getAppDetails(movingApp);
             activeFolder.items.remove(app);
             mFolderAppsViewPager.getAdapter().notifyDataSetChanged();
             assert app != null;
             app.container =
-                    folderFromDock ? Constants.CONTAINER_HOTSEAT : Constants.CONTAINER_DESKTOP;
+                folderFromDock ? Constants.CONTAINER_HOTSEAT : Constants.CONTAINER_DESKTOP;
             app.screenId = folderFromDock ? -1 : currentPageNumber;
 
             if (activeFolder.items.size() == 0) {
@@ -2493,8 +2590,8 @@ public class LauncherActivity extends AppCompatActivity implements
                     activeFolder.items.remove(item);
                     mFolderAppsViewPager.getAdapter().notifyDataSetChanged();
                     item.container =
-                            folderFromDock ? Constants.CONTAINER_HOTSEAT
-                                    : Constants.CONTAINER_DESKTOP;
+                        folderFromDock ? Constants.CONTAINER_HOTSEAT
+                            : Constants.CONTAINER_DESKTOP;
                     item.screenId = folderFromDock ? -1 : currentPageNumber;
                     BlissFrameLayout view = prepareLauncherItem(item);
                     if (folderFromDock) {
@@ -2516,10 +2613,13 @@ public class LauncherActivity extends AppCompatActivity implements
                     DatabaseManager.getManager(this).removeLauncherItem(activeFolder.id);
                 } else {
                     updateIcon(activeFolderView, activeFolder,
-                            new GraphicsUtil(this).generateFolderIcon(this, activeFolder),
-                            folderFromDock);
-                    activeFolderView.applyBadge(checkHasApp(activeFolder, mAppsWithNotifications),
-                            !folderFromDock);
+                        new GraphicsUtil(this).generateFolderIcon(this, activeFolder),
+                        folderFromDock
+                    );
+                    activeFolderView.applyBadge(
+                        checkHasApp(activeFolder, mAppsWithNotifications),
+                        !folderFromDock
+                    );
                 }
                 if (movingApp.getParent() != null) {
                     ((ViewGroup) movingApp.getParent()).removeView(movingApp);
@@ -2532,7 +2632,6 @@ public class LauncherActivity extends AppCompatActivity implements
             hideFolderWindowContainer();
             movingApp.setVisibility(View.VISIBLE);
         }
-
     }
 
     /**
@@ -2540,8 +2639,10 @@ public class LauncherActivity extends AppCompatActivity implements
      */
     private void discardCollidingApp() {
         if (collidingApp != null) {
-            makeAppCold(collidingApp,
-                    !(collidingApp.getParent().getParent() instanceof HorizontalPager));
+            makeAppCold(
+                collidingApp,
+                !(collidingApp.getParent().getParent() instanceof HorizontalPager)
+            );
             collidingApp = null;
             folderInterest = false;
         }
@@ -2560,7 +2661,7 @@ public class LauncherActivity extends AppCompatActivity implements
             index = mDock.indexOfChild(collidingApp);
         } else {
             index = getGridFromPage(pages.get(getCurrentAppsPageNumber())).indexOfChild(
-                    collidingApp);
+                collidingApp);
         }
 
         LauncherItem app1 = getAppDetails(collidingApp);
@@ -2573,11 +2674,13 @@ public class LauncherActivity extends AppCompatActivity implements
             app2.cell = folderItem.items.size();
             folderItem.items.add(app2);
             updateIcon(collidingApp, app1,
-                    new GraphicsUtil(this).generateFolderIcon(this, folderItem),
-                    folderFromDock);
+                new GraphicsUtil(this).generateFolderIcon(this, folderItem),
+                folderFromDock
+            );
             collidingApp.applyBadge(checkHasApp(folderItem, mAppsWithNotifications), !fromDock);
             makeAppWobble(collidingApp, true,
-                    index);
+                index
+            );
         } else {
             FolderItem folder = new FolderItem();
             folder.title = getString(R.string.untitled);
@@ -2592,7 +2695,8 @@ public class LauncherActivity extends AppCompatActivity implements
             app2.cell = folder.items.size();
             folder.items.add(app2);
             Drawable folderIcon = new GraphicsUtil(this).generateFolderIcon(this,
-                    app1.icon, app2.icon);
+                app1.icon, app2.icon
+            );
             folder.icon = folderIcon;
             BlissFrameLayout folderView = prepareLauncherItem(folder);
             makeAppWobble(collidingApp, false, index);
@@ -2615,8 +2719,10 @@ public class LauncherActivity extends AppCompatActivity implements
         //DatabaseManager.getManager(LauncherActivity.this).saveLayouts(pages, mDock);
     }
 
-    private void updateIcon(BlissFrameLayout appView, LauncherItem app, Drawable drawable,
-                            boolean folderFromDock) {
+    private void updateIcon(
+        BlissFrameLayout appView, LauncherItem app, Drawable drawable,
+        boolean folderFromDock
+    ) {
         app.icon = drawable;
         List<Object> tags = (List<Object>) appView.getTag();
         SquareImageView iv = (SquareImageView) tags.get(0);
@@ -2696,15 +2802,16 @@ public class LauncherActivity extends AppCompatActivity implements
         float minDistance = Float.MAX_VALUE;
         int index = EMPTY_LOCATION_DRAG;
 
-
         for (int i = 0; i < page.getChildCount(); i++) {
             View v = page.getChildAt(i).findViewById(R.id.app_icon);
             Rect r = new Rect();
             v.getGlobalVisibleRect(r);
-            Rect r2 = new Rect((int) (x - mDeviceProfile.iconSizePx / 2),
-                    (int) (y - mDeviceProfile.iconSizePx / 2),
-                    (int) (x + mDeviceProfile.iconSizePx / 2),
-                    (int) (y + mDeviceProfile.iconSizePx / 2));
+            Rect r2 = new Rect(
+                (int) (x - mDeviceProfile.iconSizePx / 2),
+                (int) (y - mDeviceProfile.iconSizePx / 2),
+                (int) (x + mDeviceProfile.iconSizePx / 2),
+                (int) (y + mDeviceProfile.iconSizePx / 2)
+            );
             if (Rect.intersects(r, r2)) {
                 float vx = r.left + (float) (r.right - r.left) / 2;
                 float vy = r.top + (float) (r.bottom - r.top) / 2;
@@ -2729,14 +2836,18 @@ public class LauncherActivity extends AppCompatActivity implements
         transition.setStartDelay(LayoutTransition.CHANGE_DISAPPEARING, 0);
         transition.addTransitionListener(new LayoutTransition.TransitionListener() {
             @Override
-            public void startTransition(LayoutTransition layoutTransition,
-                                        ViewGroup viewGroup, View view, int i) {
+            public void startTransition(
+                LayoutTransition layoutTransition,
+                ViewGroup viewGroup, View view, int i
+            ) {
                 dragDropEnabled = false;
             }
 
             @Override
-            public void endTransition(LayoutTransition layoutTransition,
-                                      ViewGroup viewGroup, View view, int i) {
+            public void endTransition(
+                LayoutTransition layoutTransition,
+                ViewGroup viewGroup, View view, int i
+            ) {
                 dragDropEnabled = true;
             }
         });
@@ -2752,7 +2863,7 @@ public class LauncherActivity extends AppCompatActivity implements
         }
 
         LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
-                mDeviceProfile.pageIndicatorSizePx, mDeviceProfile.pageIndicatorSizePx);
+            mDeviceProfile.pageIndicatorSizePx, mDeviceProfile.pageIndicatorSizePx);
 
         for (int i = 0; i < pages.size() + 1; i++) {
             ImageView dot = new ImageView(this);
@@ -2766,11 +2877,11 @@ public class LauncherActivity extends AppCompatActivity implements
     private void updateIndicator() {
         if (mIndicator.getChildAt(activeDot) != null) {
             ((ImageView) mIndicator.getChildAt(activeDot)).setImageResource(
-                    R.drawable.dot_off);
+                R.drawable.dot_off);
         }
         if (mIndicator.getChildAt(currentPageNumber) != null) {
             ((ImageView) mIndicator.getChildAt(currentPageNumber)).setImageResource(
-                    R.drawable.dot_on);
+                R.drawable.dot_on);
             activeDot = currentPageNumber;
         }
     }
@@ -2804,13 +2915,13 @@ public class LauncherActivity extends AppCompatActivity implements
         // properties (X, Y).
         v.getGlobalVisibleRect(startBounds);
         findViewById(R.id.workspace)
-                .getGlobalVisibleRect(finalBounds, globalOffset);
+            .getGlobalVisibleRect(finalBounds, globalOffset);
         startBounds.offset(-globalOffset.x, -globalOffset.y);
         finalBounds.offset(-globalOffset.x, -globalOffset.y);
 
         float startScale;
         if ((float) finalBounds.width() / finalBounds.height()
-                > (float) startBounds.width() / startBounds.height()) {
+            > (float) startBounds.width() / startBounds.height()) {
             // Extend start bounds horizontally
             startScale = (float) startBounds.height() / finalBounds.height();
             float startWidth = startScale * finalBounds.width();
@@ -2833,17 +2944,21 @@ public class LauncherActivity extends AppCompatActivity implements
         valueAnimator.addUpdateListener(animation ->
                 BlurWallpaperProvider.getInstance(this).blur((Integer) animation.getAnimatedValue()));*/
         set.play(ObjectAnimator.ofFloat(mFolderWindowContainer, View.X,
-                startBounds.left, finalBounds.left))
-                .with(ObjectAnimator.ofFloat(mFolderWindowContainer, View.Y,
-                        startBounds.top, finalBounds.top))
-                .with(ObjectAnimator.ofFloat(mFolderWindowContainer, View.SCALE_X,
-                        startScale, 1f))
-                .with(ObjectAnimator.ofFloat(mFolderWindowContainer,
-                        View.SCALE_Y, startScale, 1f))
-                .with(ObjectAnimator.ofFloat(blurLayer, View.ALPHA, 1f))
-                .with(ObjectAnimator.ofFloat(mHorizontalPager, View.ALPHA, 0f))
-                .with(ObjectAnimator.ofFloat(mIndicator, View.ALPHA, 0f))
-                .with(ObjectAnimator.ofFloat(mDock, View.ALPHA, 0f));
+            startBounds.left, finalBounds.left
+        ))
+            .with(ObjectAnimator.ofFloat(mFolderWindowContainer, View.Y,
+                startBounds.top, finalBounds.top
+            ))
+            .with(ObjectAnimator.ofFloat(mFolderWindowContainer, View.SCALE_X,
+                startScale, 1f
+            ))
+            .with(ObjectAnimator.ofFloat(mFolderWindowContainer,
+                View.SCALE_Y, startScale, 1f
+            ))
+            .with(ObjectAnimator.ofFloat(blurLayer, View.ALPHA, 1f))
+            .with(ObjectAnimator.ofFloat(mHorizontalPager, View.ALPHA, 0f))
+            .with(ObjectAnimator.ofFloat(mIndicator, View.ALPHA, 0f))
+            .with(ObjectAnimator.ofFloat(mDock, View.ALPHA, 0f));
         set.setDuration(300);
         set.setInterpolator(new LinearInterpolator());
         set.addListener(new AnimatorListenerAdapter() {
@@ -2888,12 +3003,11 @@ public class LauncherActivity extends AppCompatActivity implements
 
         mFolderAppsViewPager.setAdapter(new FolderAppsPagerAdapter(this, app.items));
         mFolderAppsViewPager.getLayoutParams().width =
-                mDeviceProfile.cellWidthPx * 3 + mDeviceProfile.iconDrawablePaddingPx;
+            mDeviceProfile.cellWidthPx * 3 + mDeviceProfile.iconDrawablePaddingPx;
         mFolderAppsViewPager.getLayoutParams().height =
-                mDeviceProfile.cellHeightPx * 3 + mDeviceProfile.iconDrawablePaddingPx;
+            mDeviceProfile.cellHeightPx * 3 + mDeviceProfile.iconDrawablePaddingPx;
         ((CircleIndicator) mLauncherView.findViewById(R.id.indicator)).setViewPager(
-                mFolderAppsViewPager);
-
+            mFolderAppsViewPager);
     }
 
     private Bitmap getLauncherView() {
@@ -2923,20 +3037,23 @@ public class LauncherActivity extends AppCompatActivity implements
         valueAnimator.addUpdateListener(animation ->
                 BlurWallpaperProvider.getInstance(this).blurWithLauncherView(mergedView, (Integer) animation.getAnimatedValue()));*/
         set.play(ObjectAnimator
-                .ofFloat(mFolderWindowContainer, View.X, startBounds.left))
-                .with(ObjectAnimator
-                        .ofFloat(mFolderWindowContainer,
-                                View.Y, startBounds.top))
-                .with(ObjectAnimator
-                        .ofFloat(mFolderWindowContainer,
-                                View.SCALE_X, startScaleFinal))
-                .with(ObjectAnimator
-                        .ofFloat(mFolderWindowContainer,
-                                View.SCALE_Y, startScaleFinal))
-                .with(ObjectAnimator.ofFloat(blurLayer, View.ALPHA, 0f))
-                .with(ObjectAnimator.ofFloat(mHorizontalPager, View.ALPHA, 1f))
-                .with(ObjectAnimator.ofFloat(mIndicator, View.ALPHA, 1f))
-                .with(ObjectAnimator.ofFloat(mDock, View.ALPHA, 1f));
+            .ofFloat(mFolderWindowContainer, View.X, startBounds.left))
+            .with(ObjectAnimator
+                .ofFloat(mFolderWindowContainer,
+                    View.Y, startBounds.top
+                ))
+            .with(ObjectAnimator
+                .ofFloat(mFolderWindowContainer,
+                    View.SCALE_X, startScaleFinal
+                ))
+            .with(ObjectAnimator
+                .ofFloat(mFolderWindowContainer,
+                    View.SCALE_Y, startScaleFinal
+                ))
+            .with(ObjectAnimator.ofFloat(blurLayer, View.ALPHA, 0f))
+            .with(ObjectAnimator.ofFloat(mHorizontalPager, View.ALPHA, 1f))
+            .with(ObjectAnimator.ofFloat(mIndicator, View.ALPHA, 1f))
+            .with(ObjectAnimator.ofFloat(mDock, View.ALPHA, 1f));
         //.with(valueAnimator);
         set.setDuration(300);
         set.setInterpolator(new LinearInterpolator());
@@ -2977,13 +3094,14 @@ public class LauncherActivity extends AppCompatActivity implements
     protected void onNewIntent(Intent intent) {
         super.onNewIntent(intent);
         final boolean alreadyOnHome = hasWindowFocus() &&
-                ((intent.getFlags() & Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
-                        != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
+            ((intent.getFlags() & Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
+                != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);
 
         boolean shouldMoveToDefaultScreen =
-                alreadyOnHome && swipeSearchContainer.getVisibility() != VISIBLE && !isWobbling
-                        && mFolderWindowContainer.getVisibility() != View.VISIBLE
-                        && (activeRoundedWidgetView == null || !activeRoundedWidgetView.isWidgetActivated());
+            alreadyOnHome && swipeSearchContainer.getVisibility() != VISIBLE && !isWobbling
+                && mFolderWindowContainer.getVisibility() != View.VISIBLE
+                && (activeRoundedWidgetView == null || !activeRoundedWidgetView
+                .isWidgetActivated());
 
         if (alreadyOnHome) {
             returnToHomeScreen();
@@ -3027,10 +3145,10 @@ public class LauncherActivity extends AppCompatActivity implements
         int animationDuration = (int) (blurLayer.getAlpha() * 300);
         AnimatorSet set = new AnimatorSet();
         set.play(ObjectAnimator.ofFloat(swipeSearchContainer, View.TRANSLATION_Y, 0))
-                .with(ObjectAnimator.ofFloat(blurLayer, View.ALPHA, 1f))
-                .with(ObjectAnimator.ofFloat(mHorizontalPager, View.ALPHA, 0f))
-                .with(ObjectAnimator.ofFloat(mIndicator, View.ALPHA, 0f))
-                .with(ObjectAnimator.ofFloat(mDock, View.ALPHA, 0f));
+            .with(ObjectAnimator.ofFloat(blurLayer, View.ALPHA, 1f))
+            .with(ObjectAnimator.ofFloat(mHorizontalPager, View.ALPHA, 0f))
+            .with(ObjectAnimator.ofFloat(mIndicator, View.ALPHA, 0f))
+            .with(ObjectAnimator.ofFloat(mDock, View.ALPHA, 0f));
         set.setDuration(animationDuration);
         set.setInterpolator(new LinearInterpolator());
         set.addListener(new AnimatorListenerAdapter() {
@@ -3056,32 +3174,34 @@ public class LauncherActivity extends AppCompatActivity implements
                                 mIndicator.setVisibility(GONE);
 
                                 BlissInput searchEditText = swipeSearchContainer.findViewById(
-                                        R.id.search_input);
+                                    R.id.search_input);
                                 ImageView clearSuggestions = swipeSearchContainer.findViewById(
-                                        R.id.clearSuggestionImageView);
-                                searchDisposableObserver = RxTextView.textChanges(searchEditText)
-                                        .debounce(300, TimeUnit.MILLISECONDS)
-                                        .map(CharSequence::toString)
-                                        .distinctUntilChanged()
-                                        .switchMap(charSequence -> {
-                                            if (charSequence != null && charSequence.length() > 0) {
-                                                LauncherActivity.this.runOnUiThread(
-                                                        () -> clearSuggestions.setVisibility(VISIBLE));
-                                                return LauncherActivity.this.searchForQuery(charSequence);
-                                            } else {
-                                                LauncherActivity.this.runOnUiThread(
-                                                        () -> clearSuggestions.setVisibility(GONE));
-                                                return Observable.just(
-                                                        new SuggestionsResult(charSequence));
-                                            }
-                                        })
-                                        .subscribeOn(Schedulers.io())
-                                        .observeOn(AndroidSchedulers.mainThread())
-                                        .subscribeWith(
-                                                new SearchInputDisposableObserver(LauncherActivity.this,
-                                                        ((RecyclerView) swipeSearchContainer.findViewById(
-                                                                R.id.suggestionRecyclerView)).getAdapter(),
-                                                        swipeSearchContainer));
+                                    R.id.clearSuggestionImageView);
+                                /*searchDisposableObserver = RxTextView.textChanges(searchEditText)
+                                    .debounce(300, TimeUnit.MILLISECONDS)
+                                    .map(CharSequence::toString)
+                                    .distinctUntilChanged()
+                                    .switchMap(charSequence -> {
+                                        if (charSequence != null && charSequence.length() > 0) {
+                                            LauncherActivity.this.runOnUiThread(
+                                                () -> clearSuggestions.setVisibility(VISIBLE));
+                                            return LauncherActivity.this.searchForQuery(charSequence);
+                                        } else {
+                                            LauncherActivity.this.runOnUiThread(
+                                                () -> clearSuggestions.setVisibility(GONE));
+                                            return Observable.just(
+                                                new SuggestionsResult(charSequence));
+                                        }
+                                    })
+                                    .subscribeOn(Schedulers.io())
+                                    .observeOn(AndroidSchedulers.mainThread())
+                                    .subscribeWith(
+                                        new SearchInputDisposableObserver(
+                                            LauncherActivity.this,
+                                            ((RecyclerView) swipeSearchContainer.findViewById(
+                                                R.id.suggestionRecyclerView)).getAdapter(),
+                                            swipeSearchContainer
+                                        ));*/
                                 searchEditText.requestFocus();
                                 refreshSuggestedApps(swipeSearchContainer, true);
                             }
@@ -3094,20 +3214,22 @@ public class LauncherActivity extends AppCompatActivity implements
     private void setUpSwipeSearchContainer() {
         BlissInput searchEditText = swipeSearchContainer.findViewById(R.id.search_input);
         ImageView clearSuggestions = swipeSearchContainer.findViewById(
-                R.id.clearSuggestionImageView);
+            R.id.clearSuggestionImageView);
         clearSuggestions.setOnClickListener(v -> {
             searchEditText.setText("");
             searchEditText.clearFocus();
         });
 
         RecyclerView suggestionRecyclerView = swipeSearchContainer.findViewById(
-                R.id.suggestionRecyclerView);
+            R.id.suggestionRecyclerView);
         AutoCompleteAdapter networkSuggestionAdapter = new AutoCompleteAdapter(this);
         suggestionRecyclerView.setAdapter(networkSuggestionAdapter);
         suggestionRecyclerView.setLayoutManager(
-                new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false));
-        DividerItemDecoration dividerItemDecoration = new DividerItemDecoration(this,
-                DividerItemDecoration.VERTICAL);
+            new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false));
+        DividerItemDecoration dividerItemDecoration = new DividerItemDecoration(
+            this,
+            DividerItemDecoration.VERTICAL
+        );
         if (suggestionRecyclerView.getItemDecorationCount() == 0) {
             suggestionRecyclerView.addItemDecoration(dividerItemDecoration);
         }
@@ -3139,11 +3261,12 @@ public class LauncherActivity extends AppCompatActivity implements
         }
         AnimatorSet set = new AnimatorSet();
         set.play(ObjectAnimator.ofFloat(swipeSearchContainer, View.TRANSLATION_Y,
-                -swipeSearchContainer.getHeight()))
-                .with(ObjectAnimator.ofFloat(mHorizontalPager, View.ALPHA, 1f))
-                .with(ObjectAnimator.ofFloat(mIndicator, View.ALPHA, 1f))
-                .with(ObjectAnimator.ofFloat(mDock, View.ALPHA, 1f))
-                .with(ObjectAnimator.ofFloat(blurLayer, View.ALPHA, 0f));
+            -swipeSearchContainer.getHeight()
+        ))
+            .with(ObjectAnimator.ofFloat(mHorizontalPager, View.ALPHA, 1f))
+            .with(ObjectAnimator.ofFloat(mIndicator, View.ALPHA, 1f))
+            .with(ObjectAnimator.ofFloat(mDock, View.ALPHA, 1f))
+            .with(ObjectAnimator.ofFloat(blurLayer, View.ALPHA, 0f));
         set.setDuration(300);
         set.setInterpolator(new LinearInterpolator());
         set.addListener(new AnimatorListenerAdapter() {
@@ -3174,13 +3297,13 @@ public class LauncherActivity extends AppCompatActivity implements
                                 swipeSearchContainer.setVisibility(GONE);
                                 blurLayer.setAlpha(0f);
                                 if (searchDisposableObserver != null
-                                        && !searchDisposableObserver.isDisposed()) {
+                                    && !searchDisposableObserver.isDisposed()) {
                                     searchDisposableObserver.dispose();
                                 }
                                 ((BlissInput) swipeSearchContainer.findViewById(R.id.search_input)).setText(
-                                        "");
+                                    "");
                                 swipeSearchContainer.findViewById(
-                                        R.id.search_input).clearFocus();
+                                    R.id.search_input).clearFocus();
                             }
                         }
         );
@@ -3191,7 +3314,7 @@ public class LauncherActivity extends AppCompatActivity implements
     @Override
     public void onSwipeStart() {
         swipeSearchContainer.setTranslationY(
-                BlissLauncher.getApplication(this).getDeviceProfile().availableHeightPx);
+            BlissLauncher.getApplication(this).getDeviceProfile().availableHeightPx);
         swipeSearchContainer.setVisibility(GONE);
         showSwipeSearch = false;
     }
@@ -3230,7 +3353,7 @@ public class LauncherActivity extends AppCompatActivity implements
 
     public void showWidgetResizeContainer(RoundedWidgetView roundedWidgetView) {
         RelativeLayout widgetResizeContainer = widgetsPage.findViewById(
-                R.id.widget_resizer_container);
+            R.id.widget_resizer_container);
         if (widgetResizeContainer.getVisibility() != VISIBLE) {
             activeRoundedWidgetView = roundedWidgetView;
 
@@ -3246,8 +3369,9 @@ public class LauncherActivity extends AppCompatActivity implements
 
             AnimatorSet set = new AnimatorSet();
             set.play(ObjectAnimator.ofFloat(widgetResizeContainer, View.Y,
-                    mDeviceProfile.availableHeightPx,
-                    mDeviceProfile.availableHeightPx - Utilities.pxFromDp(48, this)));
+                mDeviceProfile.availableHeightPx,
+                mDeviceProfile.availableHeightPx - Utilities.pxFromDp(48, this)
+            ));
             set.setDuration(200);
             set.setInterpolator(new LinearInterpolator());
             set.addListener(new AnimatorListenerAdapter() {
@@ -3277,7 +3401,6 @@ public class LauncherActivity extends AppCompatActivity implements
             set.start();
             currentAnimator = set;
         }
-
     }
 
     private void prepareWidgetResizeSeekBar(SeekBar seekBar) {
@@ -3294,15 +3417,19 @@ public class LauncherActivity extends AppCompatActivity implements
             public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                 int newHeight = minHeight + (normalisedDifference * progress);
                 LinearLayout.LayoutParams layoutParams =
-                        (LinearLayout.LayoutParams) activeRoundedWidgetView.getLayoutParams();
+                    (LinearLayout.LayoutParams) activeRoundedWidgetView.getLayoutParams();
                 layoutParams.height = newHeight;
                 activeRoundedWidgetView.setLayoutParams(layoutParams);
 
                 Bundle newOps = new Bundle();
-                newOps.putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH,
-                        mDeviceProfile.getMaxWidgetWidth());
-                newOps.putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH,
-                        mDeviceProfile.getMaxWidgetWidth());
+                newOps.putInt(
+                    AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH,
+                    mDeviceProfile.getMaxWidgetWidth()
+                );
+                newOps.putInt(
+                    AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH,
+                    mDeviceProfile.getMaxWidgetWidth()
+                );
                 newOps.putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT, newHeight);
                 newOps.putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT, newHeight);
                 activeRoundedWidgetView.updateAppWidgetOptions(newOps);
@@ -3317,22 +3444,22 @@ public class LauncherActivity extends AppCompatActivity implements
             @Override
             public void onStopTrackingTouch(SeekBar seekBar) {
                 DatabaseManager.getManager(LauncherActivity.this).saveWidget(
-                        activeRoundedWidgetView.getAppWidgetId(), seekBar.getProgress());
+                    activeRoundedWidgetView.getAppWidgetId(), seekBar.getProgress());
             }
         });
-
     }
 
     public void hideWidgetResizeContainer() {
         RelativeLayout widgetResizeContainer = widgetsPage.findViewById(
-                R.id.widget_resizer_container);
+            R.id.widget_resizer_container);
         if (widgetResizeContainer.getVisibility() == VISIBLE) {
             if (currentAnimator != null) {
                 currentAnimator.cancel();
             }
             AnimatorSet set = new AnimatorSet();
             set.play(ObjectAnimator.ofFloat(widgetResizeContainer, View.Y,
-                    mDeviceProfile.availableHeightPx));
+                mDeviceProfile.availableHeightPx
+            ));
             set.setDuration(200);
             set.setInterpolator(new LinearInterpolator());
             set.addListener(new AnimatorListenerAdapter() {
@@ -3340,7 +3467,7 @@ public class LauncherActivity extends AppCompatActivity implements
                                 public void onAnimationStart(Animator animation) {
                                     super.onAnimationStart(animation);
                                     ((SeekBar) widgetsPage.findViewById(
-                                            R.id.widget_resizer_seekbar)).setOnSeekBarChangeListener(null);
+                                        R.id.widget_resizer_seekbar)).setOnSeekBarChangeListener(null);
                                 }
 
                                 @Override
@@ -3366,7 +3493,16 @@ public class LauncherActivity extends AppCompatActivity implements
 
     public void forceReload() {
         allAppsDisplayed = false;
-        BlissLauncher.getApplication(this).getAppProvider().getAppsRepository().updateAppsRelay(Collections.emptyList());
+        BlissLauncher.getApplication(this).getAppProvider().getAppsRepository()
+            .updateAppsRelay(Collections.emptyList());
+    }
+
+    public boolean isWorkspaceLoading() {
+        return false;
+    }
+
+    public DeviceProfile getDeviceProfile() {
+        return mDeviceProfile;
     }
 
     /**
@@ -3386,13 +3522,15 @@ public class LauncherActivity extends AppCompatActivity implements
         @Override
         public Object instantiateItem(@NonNull ViewGroup container, int position) {
             GridLayout viewGroup = (GridLayout) LayoutInflater.from(mContext).inflate(
-                    R.layout.apps_page, container, false);
+                R.layout.apps_page, container, false);
             viewGroup.setRowCount(3);
             viewGroup.setColumnCount(3);
-            viewGroup.setPadding(mDeviceProfile.iconDrawablePaddingPx / 2,
-                    mDeviceProfile.iconDrawablePaddingPx / 2,
-                    mDeviceProfile.iconDrawablePaddingPx / 2,
-                    mDeviceProfile.iconDrawablePaddingPx / 2);
+            viewGroup.setPadding(
+                mDeviceProfile.iconDrawablePaddingPx / 2,
+                mDeviceProfile.iconDrawablePaddingPx / 2,
+                mDeviceProfile.iconDrawablePaddingPx / 2,
+                mDeviceProfile.iconDrawablePaddingPx / 2
+            );
             int i = 0;
             while (9 * position + i < mFolderAppItems.size() && i < 9) {
                 LauncherItem appItem = mFolderAppItems.get(9 * position + i);
@@ -3420,8 +3558,10 @@ public class LauncherActivity extends AppCompatActivity implements
         }
 
         @Override
-        public void destroyItem(@NonNull ViewGroup container, int position,
-                                @NonNull Object object) {
+        public void destroyItem(
+            @NonNull ViewGroup container, int position,
+            @NonNull Object object
+        ) {
             container.removeView((View) object);
         }
     }
@@ -3441,7 +3581,7 @@ public class LauncherActivity extends AppCompatActivity implements
         public void onAlarm(Alarm alarm) {
             GridLayout gridLayout = pages.get(getCurrentAppsPageNumber());
             if (movingApp.getParent() != null && (parentPage == getCurrentAppsPageNumber()
-                    || gridLayout.getChildCount() < mDeviceProfile.maxAppsPerPage)) {
+                || gridLayout.getChildCount() < mDeviceProfile.maxAppsPerPage)) {
                 ((ViewGroup) movingApp.getParent()).removeView(movingApp);
                 if (gridLayout.getChildCount() < mDeviceProfile.maxAppsPerPage) {
                     addAppToGrid(gridLayout, movingApp, mIndex);
@@ -3460,14 +3600,13 @@ public class LauncherActivity extends AppCompatActivity implements
 
         public void onAlarm(Alarm alarm) {
             if (mDock.getChildCount() < mDeviceProfile.numColumns
-                    || parentPage == -99) {
+                || parentPage == -99) {
                 if (movingApp.getParent() != null) {
                     ((ViewGroup) movingApp.getParent()).removeView(movingApp);
                 }
                 parentPage = -99;
                 addAppToDock(movingApp, mIndex);
             }
-
         }
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/launcher/SearchInputDisposableObserver.java b/app/src/main/java/foundation/e/blisslauncher/features/launcher/SearchInputDisposableObserver.java
index 0da9bf53dd1d3d27a9a3e95ae5cb1edb01af2c42..fd0ad5010ffc7d662d82db89e32e58848b155a19 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/launcher/SearchInputDisposableObserver.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/launcher/SearchInputDisposableObserver.java
@@ -1,26 +1,25 @@
 package foundation.e.blisslauncher.features.launcher;
 
+
 import android.view.View;
 import android.view.ViewGroup;
-
 import androidx.recyclerview.widget.RecyclerView;
-
-import java.util.ArrayList;
-
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.customviews.BlissFrameLayout;
 import foundation.e.blisslauncher.core.database.model.LauncherItem;
 import foundation.e.blisslauncher.features.suggestions.AutoCompleteAdapter;
 import foundation.e.blisslauncher.features.suggestions.SuggestionsResult;
+import foundation.e.blisslauncher.features.test.TestActivity;
 import io.reactivex.observers.DisposableObserver;
+import java.util.ArrayList;
 
 public class SearchInputDisposableObserver extends DisposableObserver<SuggestionsResult> {
 
     private AutoCompleteAdapter networkSuggestionAdapter;
-    private LauncherActivity launcherActivity;
+    private TestActivity launcherActivity;
     private ViewGroup appSuggestionsViewGroup;
 
-    public SearchInputDisposableObserver(LauncherActivity activity, RecyclerView.Adapter autoCompleteAdapter, ViewGroup viewGroup) {
+    public SearchInputDisposableObserver(TestActivity activity, RecyclerView.Adapter autoCompleteAdapter, ViewGroup viewGroup) {
         this.networkSuggestionAdapter = (AutoCompleteAdapter) autoCompleteAdapter;
         this.launcherActivity = activity;
         this.appSuggestionsViewGroup = viewGroup;
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/launcher/tasks/LoadAppsTask.java b/app/src/main/java/foundation/e/blisslauncher/features/launcher/tasks/LoadAppsTask.java
index 3d1458036f9661ecc65a360ece478e24dc55fb7b..de6192f24246ba414b057811a470d20ae57e12ce 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/launcher/tasks/LoadAppsTask.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/launcher/tasks/LoadAppsTask.java
@@ -1,12 +1,11 @@
 package foundation.e.blisslauncher.features.launcher.tasks;
 
-import android.os.AsyncTask;
-
-import java.util.Map;
 
+import android.os.AsyncTask;
 import foundation.e.blisslauncher.core.database.model.ApplicationItem;
 import foundation.e.blisslauncher.core.utils.AppUtils;
 import foundation.e.blisslauncher.features.launcher.AppProvider;
+import java.util.Map;
 
 public class LoadAppsTask extends AsyncTask<Void, Void, Map<String, ApplicationItem>> {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/launcher/tasks/LoadDatabaseTask.java b/app/src/main/java/foundation/e/blisslauncher/features/launcher/tasks/LoadDatabaseTask.java
index ada820a7a21762090e4c4b2e6f87325a25d21e86..34cceb0bdb2ab57f913b37e5d8b9dbf33250026c 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/launcher/tasks/LoadDatabaseTask.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/launcher/tasks/LoadDatabaseTask.java
@@ -1,13 +1,12 @@
 package foundation.e.blisslauncher.features.launcher.tasks;
 
-import android.os.AsyncTask;
-
-import java.util.List;
 
+import android.os.AsyncTask;
 import foundation.e.blisslauncher.core.database.LauncherDB;
 import foundation.e.blisslauncher.core.database.model.LauncherItem;
 import foundation.e.blisslauncher.core.migrate.Migration;
 import foundation.e.blisslauncher.features.launcher.AppProvider;
+import java.util.List;
 
 public class LoadDatabaseTask extends AsyncTask<Void, Void, List<LauncherItem>> {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/launcher/tasks/LoadShortcutTask.java b/app/src/main/java/foundation/e/blisslauncher/features/launcher/tasks/LoadShortcutTask.java
index 13693c9246ba45bea4f3bf853c1068a2e345ccee..8a3f7118e99e982949b2e3ddbe0bcf9ee7b726d8 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/launcher/tasks/LoadShortcutTask.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/launcher/tasks/LoadShortcutTask.java
@@ -1,16 +1,15 @@
 package foundation.e.blisslauncher.features.launcher.tasks;
 
+
 import android.os.AsyncTask;
 import android.os.Process;
 import android.util.Log;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
 import foundation.e.blisslauncher.features.launcher.AppProvider;
 import foundation.e.blisslauncher.features.shortcuts.DeepShortcutManager;
 import foundation.e.blisslauncher.features.shortcuts.ShortcutInfoCompat;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 public class LoadShortcutTask extends AsyncTask<Void, Void, Map<String, ShortcutInfoCompat>> {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/notification/DotRenderer.java b/app/src/main/java/foundation/e/blisslauncher/features/notification/DotRenderer.java
index f4e68593dcbf92e110c345a878cbedc52dd18753..ba0222f77cfeb103d92b8095039fefac971e9ab7 100755
--- a/app/src/main/java/foundation/e/blisslauncher/features/notification/DotRenderer.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/notification/DotRenderer.java
@@ -1,12 +1,12 @@
 package foundation.e.blisslauncher.features.notification;
 
+
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Rect;
-
 import foundation.e.blisslauncher.R;
 
 /**
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/notification/NotificationRepository.java b/app/src/main/java/foundation/e/blisslauncher/features/notification/NotificationRepository.java
index d8d84755df7b4a840178cf763530434c6dd87bde..9ba544f30cbe053e66e552036863c9c9da664211 100755
--- a/app/src/main/java/foundation/e/blisslauncher/features/notification/NotificationRepository.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/notification/NotificationRepository.java
@@ -1,11 +1,10 @@
 package foundation.e.blisslauncher.features.notification;
 
+
 import android.app.Notification;
 import android.service.notification.StatusBarNotification;
 import android.util.Log;
-
 import com.jakewharton.rxrelay2.BehaviorRelay;
-
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/notification/NotificationService.java b/app/src/main/java/foundation/e/blisslauncher/features/notification/NotificationService.java
index 046fdc21720e3df92d6b5d82d8726519e147b198..8790b0432ba9ffbfad3f4bdc05fcfa1c79bd8a30 100755
--- a/app/src/main/java/foundation/e/blisslauncher/features/notification/NotificationService.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/notification/NotificationService.java
@@ -1,9 +1,9 @@
 package foundation.e.blisslauncher.features.notification;
 
+
 import android.content.Intent;
 import android.service.notification.NotificationListenerService;
 import android.service.notification.StatusBarNotification;
-
 import foundation.e.blisslauncher.core.utils.ListUtil;
 
 /**
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/AddItemActivity.java b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/AddItemActivity.java
index b9cfb5cd798d0b2bdb7ff9aceefd08aacde84098..e6bee3cfc8cd4cdd2b72bbc6277c404aad2ae803 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/AddItemActivity.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/AddItemActivity.java
@@ -1,11 +1,11 @@
 package foundation.e.blisslauncher.features.shortcuts;
 
+
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.content.pm.LauncherApps;
 import android.os.Build;
 import android.os.Bundle;
-
 import androidx.appcompat.app.AppCompatActivity;
 
 @TargetApi(Build.VERSION_CODES.O)
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/DeepShortcutManager.java b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/DeepShortcutManager.java
index 96d7c81dfc317553a237aaaca6e8173e5dce38d1..d2f9339ebc7ece0225683031c0620bcfe907da96 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/DeepShortcutManager.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/DeepShortcutManager.java
@@ -16,6 +16,7 @@
 
 package foundation.e.blisslauncher.features.shortcuts;
 
+
 import android.annotation.TargetApi;
 import android.content.ComponentName;
 import android.content.Context;
@@ -27,13 +28,11 @@ import android.graphics.drawable.Drawable;
 import android.os.Bundle;
 import android.os.UserHandle;
 import android.util.Log;
-
+import foundation.e.blisslauncher.core.Utilities;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import foundation.e.blisslauncher.core.Utilities;
-
 /**
  * Performs operations related to deep shortcuts, such as querying for them, pinning them, etc.
  */
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/InstallShortcutReceiver.java b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/InstallShortcutReceiver.java
index e7cf14e88b95f85a8203c0260af94c7c0e952189..b230ed268236437a6f8bb6d0ee35a245fb02a237 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/InstallShortcutReceiver.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/InstallShortcutReceiver.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.shortcuts;
 
+
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
@@ -9,10 +10,6 @@ import android.graphics.drawable.Drawable;
 import android.os.Parcelable;
 import android.os.UserManager;
 import android.util.Log;
-
-
-import java.io.ByteArrayOutputStream;
-
 import foundation.e.blisslauncher.BlissLauncher;
 import foundation.e.blisslauncher.core.IconsHandler;
 import foundation.e.blisslauncher.core.Utilities;
@@ -21,6 +18,7 @@ import foundation.e.blisslauncher.core.events.EventRelay;
 import foundation.e.blisslauncher.core.events.ShortcutAddEvent;
 import foundation.e.blisslauncher.core.utils.Constants;
 import foundation.e.blisslauncher.core.utils.UserHandle;
+import java.io.ByteArrayOutputStream;
 
 public class InstallShortcutReceiver extends BroadcastReceiver {
     private static final String TAG = "InstallShortcutReceiver";
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/ShortcutCache.java b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/ShortcutCache.java
index ffaac6da5a060d59af124188b82e9cb0f187ab9a..d999adf6fddc9c0bac14020646e90b23991e40fb 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/ShortcutCache.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/ShortcutCache.java
@@ -16,11 +16,11 @@
 
 package foundation.e.blisslauncher.features.shortcuts;
 
+
 import android.annotation.TargetApi;
 import android.os.Build;
 import android.util.ArrayMap;
 import android.util.LruCache;
-
 import java.util.List;
 
 /**
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/ShortcutInfoCompat.java b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/ShortcutInfoCompat.java
index d627e71160a57c98557fa4e12723ad2b0d130816..87c9cf851100ec35f71ef279547a3dd558041e22 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/ShortcutInfoCompat.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/ShortcutInfoCompat.java
@@ -16,6 +16,7 @@
 
 package foundation.e.blisslauncher.features.shortcuts;
 
+
 import android.annotation.TargetApi;
 import android.content.ComponentName;
 import android.content.Intent;
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/ShortcutKey.java b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/ShortcutKey.java
index 9df2171f1594f6484708c29ca2cac1893bfbe35d..a0aa0685d9d0a058c7a4eed0989394e4f77a948f 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/ShortcutKey.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/ShortcutKey.java
@@ -1,9 +1,9 @@
 package foundation.e.blisslauncher.features.shortcuts;
 
+
 import android.content.ComponentName;
 import android.content.Intent;
 import android.os.UserHandle;
-
 import foundation.e.blisslauncher.core.database.model.ShortcutItem;
 import foundation.e.blisslauncher.core.utils.ComponentKey;
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/UninstallShortcutReceiver.java b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/UninstallShortcutReceiver.java
index aa9ccf2826cd3090cb68f0402042ea43b105cb0b..112566174366381007de78b4172ccb9ea36efb96 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/UninstallShortcutReceiver.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/shortcuts/UninstallShortcutReceiver.java
@@ -1,9 +1,9 @@
 package foundation.e.blisslauncher.features.shortcuts;
 
+
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
-
 import foundation.e.blisslauncher.core.database.DatabaseManager;
 
 public class UninstallShortcutReceiver extends BroadcastReceiver {
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/suggestions/AutoCompleteAdapter.java b/app/src/main/java/foundation/e/blisslauncher/features/suggestions/AutoCompleteAdapter.java
index 69d80421091f4052d532d2d576a4cade5e5f3050..65943ddcfd3d4902e21a9ee772ee222499b7496a 100755
--- a/app/src/main/java/foundation/e/blisslauncher/features/suggestions/AutoCompleteAdapter.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/suggestions/AutoCompleteAdapter.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.suggestions;
 
+
 import android.content.Context;
 import android.graphics.Color;
 import android.graphics.Typeface;
@@ -12,17 +13,16 @@ import android.view.View;
 import android.view.ViewGroup;
 import android.view.animation.AlphaAnimation;
 import android.widget.TextView;
-
 import androidx.annotation.NonNull;
 import androidx.recyclerview.widget.RecyclerView;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.features.launcher.LauncherActivity;
+import foundation.e.blisslauncher.features.test.TestActivity;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 
-import foundation.e.blisslauncher.R;
-import foundation.e.blisslauncher.features.launcher.LauncherActivity;
-
 public class AutoCompleteAdapter extends
         RecyclerView.Adapter<AutoCompleteAdapter.AutoCompleteViewHolder> {
     private List<String> mItems = new ArrayList<>();
@@ -32,7 +32,7 @@ public class AutoCompleteAdapter extends
 
     public AutoCompleteAdapter(Context context) {
         super();
-        mOnSuggestionClickListener = (LauncherActivity) context;
+        mOnSuggestionClickListener = (TestActivity) context;
         mInflater = LayoutInflater.from(context);
     }
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/suggestions/DuckDuckGoProvider.java b/app/src/main/java/foundation/e/blisslauncher/features/suggestions/DuckDuckGoProvider.java
index 695b9b6f2dba826f2514cdc04362880e92b8de0a..5a610afaf71309b116038eea0153d6ae6a237a84 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/suggestions/DuckDuckGoProvider.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/suggestions/DuckDuckGoProvider.java
@@ -1,13 +1,13 @@
 package foundation.e.blisslauncher.features.suggestions;
 
-import java.io.IOException;
-import java.util.ArrayList;
 
 import foundation.e.blisslauncher.core.network.RetrofitService;
 import foundation.e.blisslauncher.core.network.duckduckgo.DuckDuckGoResult;
 import foundation.e.blisslauncher.core.network.duckduckgo.DuckDuckGoSuggestionService;
 import io.reactivex.Observable;
 import io.reactivex.Single;
+import java.io.IOException;
+import java.util.ArrayList;
 
 public class DuckDuckGoProvider implements SuggestionProvider {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/suggestions/QwantProvider.java b/app/src/main/java/foundation/e/blisslauncher/features/suggestions/QwantProvider.java
index 0c6eb4b7cfa662134172118d37031661b629f20d..a23cbe7b1a864cdc77fa5b5fe89e428b257791f9 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/suggestions/QwantProvider.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/suggestions/QwantProvider.java
@@ -1,6 +1,5 @@
 package foundation.e.blisslauncher.features.suggestions;
 
-import java.io.IOException;
 
 import foundation.e.blisslauncher.core.network.RetrofitService;
 import foundation.e.blisslauncher.core.network.qwant.QwantItem;
@@ -8,6 +7,7 @@ import foundation.e.blisslauncher.core.network.qwant.QwantResult;
 import foundation.e.blisslauncher.core.network.qwant.QwantSuggestionService;
 import io.reactivex.Observable;
 import io.reactivex.Single;
+import java.io.IOException;
 
 public class QwantProvider implements SuggestionProvider {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/suggestions/SearchSuggestionUtil.java b/app/src/main/java/foundation/e/blisslauncher/features/suggestions/SearchSuggestionUtil.java
index 68a7eb9f35f9ff4a54ee4cb05a319d7783191f7d..75de15243cd33aa311d54d178981309830bf96b3 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/suggestions/SearchSuggestionUtil.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/suggestions/SearchSuggestionUtil.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.suggestions;
 
+
 import android.content.ContentResolver;
 import android.content.Context;
 import android.database.Cursor;
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/suggestions/SuggestionProvider.java b/app/src/main/java/foundation/e/blisslauncher/features/suggestions/SuggestionProvider.java
index 9a308caf5e18bedaa34f2f7bad60722ded9b6c5c..dae69a45925140b2567b0de0164230fb615560a6 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/suggestions/SuggestionProvider.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/suggestions/SuggestionProvider.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.suggestions;
 
+
 import io.reactivex.Single;
 
 public interface SuggestionProvider {
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/suggestions/SuggestionsResult.java b/app/src/main/java/foundation/e/blisslauncher/features/suggestions/SuggestionsResult.java
index 218b817baf12a7aa6094548ade0efeec689271eb..05bea6fa67de29eb5a1d975bf2eb11afbc4c9f90 100755
--- a/app/src/main/java/foundation/e/blisslauncher/features/suggestions/SuggestionsResult.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/suggestions/SuggestionsResult.java
@@ -1,8 +1,8 @@
 package foundation.e.blisslauncher.features.suggestions;
 
-import java.util.List;
 
 import foundation.e.blisslauncher.core.database.model.LauncherItem;
+import java.util.List;
 
 public class SuggestionsResult {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/Alarm.java b/app/src/main/java/foundation/e/blisslauncher/features/test/Alarm.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f857b7262a945f50441924231f8b0a014f5f428
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/Alarm.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2010 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 foundation.e.blisslauncher.features.test;
+
+import android.os.Handler;
+import android.os.SystemClock;
+
+public class Alarm implements Runnable {
+    // if we reach this time and the alarm hasn't been cancelled, call the listener
+    private long mAlarmTriggerTime;
+
+    // if we've scheduled a call to run() (ie called mHandler.postDelayed), this variable is true.
+    // We use this to avoid having multiple pending callbacks
+    private boolean mWaitingForCallback;
+
+    private Handler mHandler;
+    private OnAlarmListener mAlarmListener;
+    private boolean mAlarmPending = false;
+
+    public Alarm() {
+        mHandler = new Handler();
+    }
+
+    public void setOnAlarmListener(OnAlarmListener alarmListener) {
+        mAlarmListener = alarmListener;
+    }
+
+    // Sets the alarm to go off in a certain number of milliseconds. If the alarm is already set,
+    // it's overwritten and only the new alarm setting is used
+    public void setAlarm(long millisecondsInFuture) {
+        long currentTime = SystemClock.uptimeMillis();
+        mAlarmPending = true;
+        long oldTriggerTime = mAlarmTriggerTime;
+        mAlarmTriggerTime = currentTime + millisecondsInFuture;
+
+        // If the previous alarm was set for a longer duration, cancel it.
+        if (mWaitingForCallback && oldTriggerTime > mAlarmTriggerTime) {
+            mHandler.removeCallbacks(this);
+            mWaitingForCallback = false;
+        }
+        if (!mWaitingForCallback) {
+            mHandler.postDelayed(this, mAlarmTriggerTime - currentTime);
+            mWaitingForCallback = true;
+        }
+    }
+
+    public void cancelAlarm() {
+        mAlarmPending = false;
+    }
+
+    // this is called when our timer runs out
+    public void run() {
+        mWaitingForCallback = false;
+        if (mAlarmPending) {
+            long currentTime = SystemClock.uptimeMillis();
+            if (mAlarmTriggerTime > currentTime) {
+                // We still need to wait some time to trigger spring loaded mode--
+                // post a new callback
+                mHandler.postDelayed(this, Math.max(0, mAlarmTriggerTime - currentTime));
+                mWaitingForCallback = true;
+            } else {
+                mAlarmPending = false;
+                if (mAlarmListener != null) {
+                    mAlarmListener.onAlarm(this);
+                }
+            }
+        }
+    }
+
+    public boolean alarmPending() {
+        return mAlarmPending;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/BaseActivity.java b/app/src/main/java/foundation/e/blisslauncher/features/test/BaseActivity.java
new file mode 100644
index 0000000000000000000000000000000000000000..a84799e2e6904848ee498885df92eb192e5fce73
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/BaseActivity.java
@@ -0,0 +1,203 @@
+/* Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package foundation.e.blisslauncher.features.test;
+
+import static java.lang.annotation.RetentionPolicy.SOURCE;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.content.Intent;
+import android.view.View.AccessibilityDelegate;
+import androidx.annotation.IntDef;
+import foundation.e.blisslauncher.core.utils.ViewCache;
+import java.lang.annotation.Retention;
+import java.util.ArrayList;
+
+public abstract class BaseActivity extends Activity {
+
+    public static final int INVISIBLE_BY_STATE_HANDLER = 1 << 0;
+    public static final int INVISIBLE_BY_APP_TRANSITIONS = 1 << 1;
+    public static final int INVISIBLE_BY_PENDING_FLAGS = 1 << 2;
+
+    // This is not treated as invisibility flag, but adds as a hint for an incomplete transition.
+    // When the wallpaper animation runs, it replaces this flag with a proper invisibility
+    // flag, INVISIBLE_BY_PENDING_FLAGS only for the duration of that animation.
+    public static final int PENDING_INVISIBLE_BY_WALLPAPER_ANIMATION = 1 << 3;
+
+    private static final int INVISIBLE_FLAGS =
+        INVISIBLE_BY_STATE_HANDLER | INVISIBLE_BY_APP_TRANSITIONS | INVISIBLE_BY_PENDING_FLAGS;
+    public static final int STATE_HANDLER_INVISIBILITY_FLAGS =
+        INVISIBLE_BY_STATE_HANDLER | PENDING_INVISIBLE_BY_WALLPAPER_ANIMATION;
+    public static final int INVISIBLE_ALL =
+        INVISIBLE_FLAGS | PENDING_INVISIBLE_BY_WALLPAPER_ANIMATION;
+
+    @Retention(SOURCE)
+    @IntDef(
+        flag = true,
+        value = {INVISIBLE_BY_STATE_HANDLER, INVISIBLE_BY_APP_TRANSITIONS, INVISIBLE_BY_PENDING_FLAGS, PENDING_INVISIBLE_BY_WALLPAPER_ANIMATION})
+    public @interface InvisibilityFlags {
+    }
+
+    private final ArrayList<VariantDeviceProfile.OnDeviceProfileChangeListener> mDPChangeListeners =
+        new ArrayList<>();
+    private final ArrayList<MultiWindowModeChangedListener> mMultiWindowModeChangedListeners =
+        new ArrayList<>();
+
+    protected VariantDeviceProfile mDeviceProfile;
+    protected SystemUiController mSystemUiController;
+
+    private static final int ACTIVITY_STATE_STARTED = 1 << 0;
+    private static final int ACTIVITY_STATE_RESUMED = 1 << 1;
+
+    private static final int ACTIVITY_STATE_USER_ACTIVE = 1 << 2;
+
+    @Retention(SOURCE)
+    @IntDef(
+        flag = true,
+        value = {ACTIVITY_STATE_STARTED, ACTIVITY_STATE_RESUMED, ACTIVITY_STATE_USER_ACTIVE})
+    public @interface ActivityFlags {
+    }
+
+    @ActivityFlags
+    private int mActivityFlags;
+
+    // When the recents animation is running, the visibility of the Launcher is managed by the
+    // animation
+    @InvisibilityFlags
+    private int mForceInvisible;
+
+    private final ViewCache mViewCache = new ViewCache();
+
+    public ViewCache getViewCache() {
+        return mViewCache;
+    }
+
+    public VariantDeviceProfile getDeviceProfile() {
+        return mDeviceProfile;
+    }
+
+    public AccessibilityDelegate getAccessibilityDelegate() {
+        return null;
+    }
+
+    public static BaseActivity fromContext(Context context) {
+        if (context instanceof BaseActivity) {
+            return (BaseActivity) context;
+        }
+        return ((BaseActivity) ((ContextWrapper) context).getBaseContext());
+    }
+
+    public SystemUiController getSystemUiController() {
+        if (mSystemUiController == null) {
+            mSystemUiController = new SystemUiController(getWindow());
+        }
+        return mSystemUiController;
+    }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+    }
+
+    @Override
+    protected void onStart() {
+        mActivityFlags |= ACTIVITY_STATE_STARTED;
+        super.onStart();
+    }
+
+    @Override
+    protected void onResume() {
+        mActivityFlags |= ACTIVITY_STATE_RESUMED | ACTIVITY_STATE_USER_ACTIVE;
+        super.onResume();
+    }
+
+    @Override
+    protected void onUserLeaveHint() {
+        mActivityFlags &= ~ACTIVITY_STATE_USER_ACTIVE;
+        super.onUserLeaveHint();
+    }
+
+    @Override
+    protected void onStop() {
+        mActivityFlags &= ~ACTIVITY_STATE_STARTED & ~ACTIVITY_STATE_USER_ACTIVE;
+        mForceInvisible = 0;
+        super.onStop();
+    }
+
+    @Override
+    protected void onPause() {
+        mActivityFlags &= ~ACTIVITY_STATE_RESUMED;
+        super.onPause();
+
+        // Reset the overridden sysui flags used for the task-swipe launch animation, we do this
+        // here instead of at the end of the animation because the start of the new activity does
+        // not happen immediately, which would cause us to reset to launcher's sysui flags and then
+        // back to the new app (causing a flash)
+        getSystemUiController().updateUiState(SystemUiController.UI_STATE_NORMAL, 0);
+    }
+
+    public boolean isStarted() {
+        return (mActivityFlags & ACTIVITY_STATE_STARTED) != 0;
+    }
+
+    public boolean hasBeenResumed() {
+        return (mActivityFlags & ACTIVITY_STATE_RESUMED) != 0;
+    }
+
+    public boolean isUserActive() {
+        return (mActivityFlags & ACTIVITY_STATE_USER_ACTIVE) != 0;
+    }
+
+    public void addOnDeviceProfileChangeListener(VariantDeviceProfile.OnDeviceProfileChangeListener listener) {
+        mDPChangeListeners.add(listener);
+    }
+
+    public void removeOnDeviceProfileChangeListener(VariantDeviceProfile.OnDeviceProfileChangeListener listener) {
+        mDPChangeListeners.remove(listener);
+    }
+
+    protected void dispatchDeviceProfileChanged() {
+        for (int i = mDPChangeListeners.size() - 1; i >= 0; i--) {
+            mDPChangeListeners.get(i).onDeviceProfileChanged(mDeviceProfile);
+        }
+    }
+
+    public void addMultiWindowModeChangedListener(MultiWindowModeChangedListener listener) {
+        mMultiWindowModeChangedListeners.add(listener);
+    }
+
+    public void removeMultiWindowModeChangedListener(MultiWindowModeChangedListener listener) {
+        mMultiWindowModeChangedListeners.remove(listener);
+    }
+
+    public void addForceInvisibleFlag(@InvisibilityFlags int flag) {
+        mForceInvisible |= flag;
+    }
+
+    public void clearForceInvisibleFlag(@InvisibilityFlags int flag) {
+        mForceInvisible &= ~flag;
+    }
+
+    public boolean isForceInvisible() {
+        return mForceInvisible != 0;
+    }
+
+    public interface MultiWindowModeChangedListener {
+        void onMultiWindowModeChanged(boolean isInMultiWindowMode);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/BaseDragLayer.java b/app/src/main/java/foundation/e/blisslauncher/features/test/BaseDragLayer.java
new file mode 100644
index 0000000000000000000000000000000000000000..143ee08f0fffa42bd26ea7fd0f42474d9364c1c8
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/BaseDragLayer.java
@@ -0,0 +1,450 @@
+package foundation.e.blisslauncher.features.test;
+
+import static android.view.MotionEvent.ACTION_CANCEL;
+import static android.view.MotionEvent.ACTION_DOWN;
+import static android.view.MotionEvent.ACTION_UP;
+import static foundation.e.blisslauncher.core.Utilities.SINGLE_FRAME_MS;
+import static foundation.e.blisslauncher.core.Utilities.shouldDisableGestures;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewDebug;
+import android.view.ViewGroup;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.customviews.AbstractFloatingView;
+import foundation.e.blisslauncher.core.customviews.InsettableFrameLayout;
+import foundation.e.blisslauncher.core.utils.MultiValueAlpha;
+import java.util.ArrayList;
+
+/**
+ * A viewgroup with utility methods for drag-n-drop and touch interception
+ */
+public abstract class BaseDragLayer<T extends BaseDraggingActivity> extends InsettableFrameLayout {
+
+    protected final int[] mTmpXY = new int[2];
+    protected final Rect mHitRect = new Rect();
+
+    protected final T mActivity;
+
+    private final MultiValueAlpha mMultiValueAlpha;
+
+    protected TouchController[] mControllers;
+    protected TouchController mActiveController;
+    // Touch controller which is being used for the proxy events
+    protected TouchController mProxyTouchController;
+    private TouchCompleteListener mTouchCompleteListener;
+
+    // Touch is being dispatched through the normal view dispatch system
+    private static final int TOUCH_DISPATCHING_VIEW = 1 << 0;
+    // Touch is being dispatched through the normal view dispatch system, and started at the
+    // system gesture region
+    private static final int TOUCH_DISPATCHING_GESTURE = 1 << 1;
+    // Touch is being dispatched through a proxy from InputMonitor
+    private static final int TOUCH_DISPATCHING_PROXY = 1 << 2;
+
+    @ViewDebug.ExportedProperty(category = "launcher")
+    private final RectF mSystemGestureRegion = new RectF();
+    private int mTouchDispatchState = 0;
+
+    public BaseDragLayer(Context context, AttributeSet attrs, int alphaChannelCount) {
+        super(context, attrs);
+        mActivity = (T) BaseActivity.fromContext(context);
+        mMultiValueAlpha = new MultiValueAlpha(this, alphaChannelCount);
+    }
+
+    public boolean isEventOverView(View view, MotionEvent ev) {
+        getDescendantRectRelativeToSelf(view, mHitRect);
+        return mHitRect.contains((int) ev.getX(), (int) ev.getY());
+    }
+
+    /**
+     * Given a motion event in evView's coordinates, return whether the event is within another
+     * view's bounds.
+     */
+    public boolean isEventOverView(View view, MotionEvent ev, View evView) {
+        int[] xy = new int[] {(int) ev.getX(), (int) ev.getY()};
+        getDescendantCoordRelativeToSelf(evView, xy);
+        getDescendantRectRelativeToSelf(view, mHitRect);
+        return mHitRect.contains(xy[0], xy[1]);
+    }
+
+    @Override
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        int action = ev.getAction();
+
+        if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+            if (mTouchCompleteListener != null) {
+                mTouchCompleteListener.onTouchComplete();
+            }
+            mTouchCompleteListener = null;
+        } else if (action == MotionEvent.ACTION_DOWN) {
+            mActivity.finishAutoCancelActionMode();
+        }
+        return findActiveController(ev);
+    }
+
+    protected boolean findActiveController(MotionEvent ev) {
+        mActiveController = null;
+
+        //TODO: Implement when adding folder grouping.
+        if ((mTouchDispatchState & (TOUCH_DISPATCHING_GESTURE | TOUCH_DISPATCHING_PROXY)) == 0) {
+            // Only look for controllers if we are not dispatching from gesture area and proxy is
+            // not active
+            mActiveController = findControllerToHandleTouch(ev);
+
+            if (mActiveController != null) return true;
+        }
+        return false;
+    }
+
+    private TouchController findControllerToHandleTouch(MotionEvent ev) {
+        if (shouldDisableGestures(ev)) return null;
+
+        AbstractFloatingView topView = AbstractFloatingView.getTopOpenView(mActivity);
+        if (topView != null && topView.onControllerInterceptTouchEvent(ev)) {
+            return topView;
+        }
+
+        for (TouchController controller : mControllers) {
+            if (controller.onControllerInterceptTouchEvent(ev)) {
+                return controller;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public void onViewRemoved(View child) {
+        super.onViewRemoved(child);
+
+        if (child instanceof AbstractFloatingView) {
+            // Handles the case where the view is removed without being properly closed.
+            // This can happen if something goes wrong during a state change/transition.
+            postDelayed(() -> {
+                AbstractFloatingView floatingView = (AbstractFloatingView) child;
+                if (floatingView.isOpen()) {
+                    floatingView.close(false);
+                }
+            }, SINGLE_FRAME_MS);
+        }
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        int action = ev.getAction();
+        if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+            if (mTouchCompleteListener != null) {
+                mTouchCompleteListener.onTouchComplete();
+            }
+            mTouchCompleteListener = null;
+        }
+
+        if (mActiveController != null) {
+            return mActiveController.onControllerTouchEvent(ev);
+        } else {
+            // In case no child view handled the touch event, we may not get onIntercept anymore
+            return findActiveController(ev);
+        }
+    }
+
+    @Override
+    public boolean dispatchTouchEvent(MotionEvent ev) {
+        switch (ev.getAction()) {
+            case ACTION_DOWN: {
+                float x = ev.getX();
+                float y = ev.getY();
+                mTouchDispatchState |= TOUCH_DISPATCHING_VIEW;
+
+                if ((y < mSystemGestureRegion.top
+                    || x < mSystemGestureRegion.left
+                    || x > (getWidth() - mSystemGestureRegion.right)
+                    || y > (getHeight() - mSystemGestureRegion.bottom))) {
+                    mTouchDispatchState |= TOUCH_DISPATCHING_GESTURE;
+                } else {
+                    mTouchDispatchState &= ~TOUCH_DISPATCHING_GESTURE;
+                }
+                break;
+            }
+            case ACTION_CANCEL:
+            case ACTION_UP:
+                mTouchDispatchState &= ~TOUCH_DISPATCHING_GESTURE;
+                mTouchDispatchState &= ~TOUCH_DISPATCHING_VIEW;
+                break;
+        }
+        super.dispatchTouchEvent(ev);
+
+        // We want to get all events so that mTouchDispatchSource is maintained properly
+        return true;
+    }
+
+    /**
+     * Called before we are about to receive proxy events.
+     *
+     * @return false if we can't handle proxy at this time
+     */
+    public boolean prepareProxyEventStarting() {
+        mProxyTouchController = null;
+        if ((mTouchDispatchState & TOUCH_DISPATCHING_VIEW) != 0 && mActiveController != null) {
+            // We are already dispatching using view system and have an active controller, we can't
+            // handle another controller.
+
+            // This flag was already cleared in proxy ACTION_UP or ACTION_CANCEL. Added here just
+            // to be safe
+            mTouchDispatchState &= ~TOUCH_DISPATCHING_PROXY;
+            return false;
+        }
+
+        mTouchDispatchState |= TOUCH_DISPATCHING_PROXY;
+        return true;
+    }
+
+    /**
+     * Determine the rect of the descendant in this DragLayer's coordinates
+     *
+     * @param descendant The descendant whose coordinates we want to find.
+     * @param r The rect into which to place the results.
+     * @return The factor by which this descendant is scaled relative to this DragLayer.
+     */
+    public float getDescendantRectRelativeToSelf(View descendant, Rect r) {
+        mTmpXY[0] = 0;
+        mTmpXY[1] = 0;
+        float scale = getDescendantCoordRelativeToSelf(descendant, mTmpXY);
+
+        r.set(mTmpXY[0], mTmpXY[1],
+            (int) (mTmpXY[0] + scale * descendant.getMeasuredWidth()),
+            (int) (mTmpXY[1] + scale * descendant.getMeasuredHeight()));
+        return scale;
+    }
+
+    public float getLocationInDragLayer(View child, int[] loc) {
+        loc[0] = 0;
+        loc[1] = 0;
+        return getDescendantCoordRelativeToSelf(child, loc);
+    }
+
+    public float getDescendantCoordRelativeToSelf(View descendant, int[] coord) {
+        return getDescendantCoordRelativeToSelf(descendant, coord, false);
+    }
+
+    public float getDescendantCoordRelativeToSelf(View descendant, float[] coord) {
+        return getDescendantCoordRelativeToSelf(descendant, coord, false);
+    }
+
+    /**
+     * Given a coordinate relative to the descendant, find the coordinate in this DragLayer's
+     * coordinates.
+     *
+     * @param descendant The descendant to which the passed coordinate is relative.
+     * @param coord The coordinate that we want mapped.
+     * @param includeRootScroll Whether or not to account for the scroll of the root descendant:
+     *          sometimes this is relevant as in a child's coordinates within the root descendant.
+     * @return The factor by which this descendant is scaled relative to this DragLayer. Caution
+     *         this scale factor is assumed to be equal in X and Y, and so if at any point this
+     *         assumption fails, we will need to return a pair of scale factors.
+     */
+    public float getDescendantCoordRelativeToSelf(View descendant, int[] coord,
+        boolean includeRootScroll) {
+        return Utilities.getDescendantCoordRelativeToAncestor(descendant, this,
+            coord, includeRootScroll);
+    }
+
+    /**
+     * Given a coordinate relative to the descendant, find the coordinate in this DragLayer's
+     * coordinates.
+     *
+     * @param descendant The descendant to which the passed coordinate is relative.
+     * @param coord The coordinate that we want mapped.
+     * @param includeRootScroll Whether or not to account for the scroll of the root descendant:
+     *          sometimes this is relevant as in a child's coordinates within the root descendant.
+     * @return The factor by which this descendant is scaled relative to this DragLayer. Caution
+     *         this scale factor is assumed to be equal in X and Y, and so if at any point this
+     *         assumption fails, we will need to return a pair of scale factors.
+     */
+    public float getDescendantCoordRelativeToSelf(View descendant, float[] coord,
+        boolean includeRootScroll) {
+        return Utilities.getDescendantCoordRelativeToAncestor(descendant, this,
+            coord, includeRootScroll);
+    }
+
+    /**
+     * Inverse of {@link #getDescendantCoordRelativeToSelf(View, int[])}.
+     */
+    public void mapCoordInSelfToDescendant(View descendant, int[] coord) {
+        Utilities.mapCoordInSelfToDescendant(descendant, this, coord);
+    }
+
+    /**
+     * Inverse of {@link #getDescendantCoordRelativeToSelf(View, float[])}.
+     */
+    public void mapCoordInSelfToDescendant(View descendant, float[] coord) {
+        Utilities.mapCoordInSelfToDescendant(descendant, this, coord);
+    }
+
+    public void getViewRectRelativeToSelf(View v, Rect r) {
+        int[] loc = new int[2];
+        getLocationInWindow(loc);
+        int x = loc[0];
+        int y = loc[1];
+
+        int[] temp = new int[2];
+        getLocationOnScreen(temp);
+
+        Log.i("BaseDragLayer", "getViewRectRelativeToSelf iNWindow: "+x+" "+y);
+        v.getLocationInWindow(loc);
+        int vX = loc[0];
+        int vY = loc[1];
+        Log.i("BaseDragLayer", "getViewRectRelativeToSelf ofView: "+vX+" "+vY);
+
+        int left = vX - x;
+        int top = vY - y;
+        r.set(left, top, left + v.getMeasuredWidth(), top + v.getMeasuredHeight());
+    }
+
+    /**
+     * Proxies the touch events to the gesture handlers
+     */
+    public boolean proxyTouchEvent(MotionEvent ev) {
+        boolean handled;
+        if (mProxyTouchController != null) {
+            handled = mProxyTouchController.onControllerTouchEvent(ev);
+        } else {
+            mProxyTouchController = findControllerToHandleTouch(ev);
+            handled = mProxyTouchController != null;
+        }
+        int action = ev.getAction();
+        if (action == ACTION_UP || action == ACTION_CANCEL) {
+            mProxyTouchController = null;
+            mTouchDispatchState &= ~TOUCH_DISPATCHING_PROXY;
+        }
+        return handled;
+    }
+
+    @Override
+    public boolean dispatchUnhandledMove(View focused, int direction) {
+        // Consume the unhandled move if a container is open, to avoid switching pages underneath.
+        return false;
+    }
+
+    @Override
+    protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
+        View topView = AbstractFloatingView.getTopOpenView(mActivity);
+        if (topView != null) {
+            return topView.requestFocus(direction, previouslyFocusedRect);
+        } else {
+            return super.onRequestFocusInDescendants(direction, previouslyFocusedRect);
+        }
+    }
+
+    @Override
+    public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {
+        View topView = AbstractFloatingView.getTopOpenView(mActivity);
+        if (topView != null) {
+            topView.addFocusables(views, direction);
+        } else {
+            super.addFocusables(views, direction, focusableMode);
+        }
+        super.addFocusables(views, direction, focusableMode);
+    }
+
+    public void setTouchCompleteListener(TouchCompleteListener listener) {
+        mTouchCompleteListener = listener;
+    }
+
+    public MultiValueAlpha.AlphaProperty getAlphaProperty(int index) {
+        return mMultiValueAlpha.getProperty(index);
+    }
+
+    public interface TouchCompleteListener {
+        void onTouchComplete();
+    }
+
+    @Override
+    public LayoutParams generateLayoutParams(AttributeSet attrs) {
+        return new LayoutParams(getContext(), attrs);
+    }
+
+    @Override
+    protected LayoutParams generateDefaultLayoutParams() {
+        return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
+    }
+
+    // Override to allow type-checking of LayoutParams.
+    @Override
+    protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
+        return p instanceof LayoutParams;
+    }
+
+    @Override
+    protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
+        return new LayoutParams(p);
+    }
+
+    public static class LayoutParams extends InsettableFrameLayout.LayoutParams {
+        public int x, y;
+        public boolean customPosition = false;
+
+        public LayoutParams(Context c, AttributeSet attrs) {
+            super(c, attrs);
+        }
+
+        public LayoutParams(int width, int height) {
+            super(width, height);
+        }
+
+        public LayoutParams(ViewGroup.LayoutParams lp) {
+            super(lp);
+        }
+
+        public void setWidth(int width) {
+            this.width = width;
+        }
+
+        public int getWidth() {
+            return width;
+        }
+
+        public void setHeight(int height) {
+            this.height = height;
+        }
+
+        public int getHeight() {
+            return height;
+        }
+
+        public void setX(int x) {
+            this.x = x;
+        }
+
+        public int getX() {
+            return x;
+        }
+
+        public void setY(int y) {
+            this.y = y;
+        }
+
+        public int getY() {
+            return y;
+        }
+    }
+
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        super.onLayout(changed, l, t, r, b);
+        int count = getChildCount();
+        for (int i = 0; i < count; i++) {
+            View child = getChildAt(i);
+            final LayoutParams flp = (LayoutParams) child.getLayoutParams();
+            if (flp instanceof LayoutParams) {
+                final LayoutParams lp = flp;
+                if (lp.customPosition) {
+                    child.layout(lp.x, lp.y, lp.x + lp.width, lp.y + lp.height+lp.height);
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/BaseDraggingActivity.java b/app/src/main/java/foundation/e/blisslauncher/features/test/BaseDraggingActivity.java
new file mode 100644
index 0000000000000000000000000000000000000000..48cb035eee638e60a1a8b06a948f36f1347d413c
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/BaseDraggingActivity.java
@@ -0,0 +1,211 @@
+package foundation.e.blisslauncher.features.test;
+
+import android.app.ActivityOptions;
+import android.content.ActivityNotFoundException;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.content.Intent;
+import android.content.pm.LauncherApps;
+import android.graphics.Rect;
+import android.os.Bundle;
+import android.os.Process;
+import android.os.StrictMode;
+import android.os.UserHandle;
+import android.util.Log;
+import android.view.ActionMode;
+import android.view.View;
+import android.widget.Toast;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.database.model.LauncherItem;
+import foundation.e.blisslauncher.core.database.model.ShortcutItem;
+import foundation.e.blisslauncher.core.utils.Constants;
+import foundation.e.blisslauncher.features.shortcuts.DeepShortcutManager;
+
+public abstract class BaseDraggingActivity extends BaseActivity {
+
+    private static final String TAG = "BaseDraggingActivity";
+
+    // The Intent extra that defines whether to ignore the launch animation
+    public static final String INTENT_EXTRA_IGNORE_LAUNCH_ANIMATION =
+        "com.android.launcher3.intent.extra.shortcut.INGORE_LAUNCH_ANIMATION";
+
+    // When starting an action mode, setting this tag will cause the action mode to be cancelled
+    // automatically when user interacts with the launcher.
+    public static final Object AUTO_CANCEL_ACTION_MODE = new Object();
+
+    private ActionMode mCurrentActionMode;
+    protected boolean mIsSafeModeEnabled;
+
+    private OnStartCallback mOnStartCallback;
+
+    private int mThemeRes = R.style.HomeScreenTheme;
+
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mIsSafeModeEnabled = getPackageManager().isSafeMode();
+        setTheme(mThemeRes);
+    }
+
+    protected int getThemeRes() {
+        return mThemeRes;
+    }
+
+    @Override
+    public void onActionModeStarted(ActionMode mode) {
+        super.onActionModeStarted(mode);
+        mCurrentActionMode = mode;
+    }
+
+    @Override
+    public void onActionModeFinished(ActionMode mode) {
+        super.onActionModeFinished(mode);
+        mCurrentActionMode = null;
+    }
+
+    public boolean finishAutoCancelActionMode() {
+        if (mCurrentActionMode != null && AUTO_CANCEL_ACTION_MODE == mCurrentActionMode.getTag()) {
+            mCurrentActionMode.finish();
+            return true;
+        }
+        return false;
+    }
+
+    public abstract BaseDragLayer getDragLayer();
+
+    public abstract <T extends View> T getOverviewPanel();
+
+    public abstract View getRootView();
+
+/*    public abstract BadgeInfo getBadgeInfoForItem(ItemInfo info);
+
+    public abstract void invalidateParent(ItemInfo info);*/
+
+    public static BaseDraggingActivity fromContext(Context context) {
+        if (context instanceof BaseDraggingActivity) {
+            return (BaseDraggingActivity) context;
+        }
+        return ((BaseDraggingActivity) ((ContextWrapper) context).getBaseContext());
+    }
+
+    public Rect getViewBounds(View v) {
+        int[] pos = new int[2];
+        v.getLocationOnScreen(pos);
+        return new Rect(pos[0], pos[1], pos[0] + v.getWidth(), pos[1] + v.getHeight());
+    }
+
+    public final Bundle getActivityLaunchOptionsAsBundle(View v) {
+        ActivityOptions activityOptions = getActivityLaunchOptions(v);
+        return activityOptions == null ? null : activityOptions.toBundle();
+    }
+
+    public abstract ActivityOptions getActivityLaunchOptions(View v);
+
+    public boolean startActivitySafely(View v, Intent intent, LauncherItem item) {
+        if (mIsSafeModeEnabled && !Utilities.isSystemApp(this, intent)) {
+            Toast.makeText(this, R.string.safemode_shortcut_error, Toast.LENGTH_SHORT).show();
+            return false;
+        }
+
+        // Only launch using the new animation if the shortcut has not opted out (this is a
+        // private contract between launcher and may be ignored in the future).
+        boolean useLaunchAnimation = (v != null) &&
+            !intent.hasExtra(INTENT_EXTRA_IGNORE_LAUNCH_ANIMATION);
+        Bundle optsBundle = useLaunchAnimation
+            ? getActivityLaunchOptionsAsBundle(v)
+            : null;
+
+        UserHandle user = item == null ? null : item.user.getRealHandle();
+
+        // Prepare intent
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        if (v != null) {
+            intent.setSourceBounds(getViewBounds(v));
+        }
+        try {
+            boolean isShortcut = Utilities.ATLEAST_MARSHMALLOW
+                && (item instanceof ShortcutItem)
+                && (item.itemType == Constants.ITEM_TYPE_SHORTCUT);
+            if (isShortcut) {
+                // Shortcuts need some special checks due to legacy reasons.
+                startShortcutIntentSafely(intent, optsBundle, item);
+            } else if (user == null || user.equals(Process.myUserHandle())) {
+                // Could be launching some bookkeeping activity
+                startActivity(intent, optsBundle);
+            } else {
+                LauncherApps launcherApps = (LauncherApps) getSystemService(LAUNCHER_APPS_SERVICE);
+                launcherApps.startAppDetailsActivity(
+                    intent.getComponent(), user, intent.getSourceBounds(), optsBundle);
+            }
+            return true;
+        } catch (ActivityNotFoundException |SecurityException e) {
+            Toast.makeText(this, R.string.activity_not_found, Toast.LENGTH_SHORT).show();
+            Log.e(TAG, "Unable to launch. tag=" + item + " intent=" + intent, e);
+        }
+        return false;
+    }
+
+    private void startShortcutIntentSafely(Intent intent, Bundle optsBundle, LauncherItem info) {
+        try {
+            StrictMode.VmPolicy oldPolicy = StrictMode.getVmPolicy();
+            try {
+                // Temporarily disable deathPenalty on all default checks. For eg, shortcuts
+                // containing file Uri's would cause a crash as penaltyDeathOnFileUriExposure
+                // is enabled by default on NYC.
+                StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder().detectAll()
+                    .penaltyLog().build());
+
+                if (info.itemType == Constants.ITEM_TYPE_SHORTCUT) {
+                    String id = ((ShortcutItem) info).id;
+                    String packageName = intent.getPackage();
+                    DeepShortcutManager.getInstance(this).startShortcut(
+                        packageName, id, intent.getSourceBounds(), optsBundle, info.user.getRealHandle());
+                } else {
+                    // Could be launching some bookkeeping activity
+                    startActivity(intent, optsBundle);
+                }
+            } finally {
+                StrictMode.setVmPolicy(oldPolicy);
+            }
+        } catch (SecurityException e) {
+            if (!onErrorStartingShortcut(intent, info)) {
+                throw e;
+            }
+        }
+    }
+
+    protected boolean onErrorStartingShortcut(Intent intent, LauncherItem info) {
+        return false;
+    }
+
+    @Override
+    protected void onStart() {
+        super.onStart();
+
+        if (mOnStartCallback != null) {
+            mOnStartCallback.onActivityStart(this);
+            mOnStartCallback = null;
+        }
+    }
+
+    public <T extends BaseDraggingActivity> void setOnStartCallback(OnStartCallback<T> callback) {
+        mOnStartCallback = callback;
+    }
+
+    protected void onDeviceProfileInitiated() {
+        //TODO: Enable or disable rotation listener here if supporting landscape launcher.
+    }
+
+    protected abstract void reapplyUi();
+
+    /**
+     * Callback for listening for onStart
+     */
+    public interface OnStartCallback<T extends BaseDraggingActivity> {
+
+        void onActivityStart(T activity);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/CellAndSpan.java b/app/src/main/java/foundation/e/blisslauncher/features/test/CellAndSpan.java
new file mode 100644
index 0000000000000000000000000000000000000000..308e4a9c6b10ffdcee5d1070613a7eba68ecd3f6
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/CellAndSpan.java
@@ -0,0 +1,34 @@
+package foundation.e.blisslauncher.features.test;
+
+/**
+ * Base class which represents an area on the grid.
+ */
+public class CellAndSpan {
+
+    /**
+     * Indicates the X position of the associated cell.
+     */
+    public int cellX = -1;
+
+    /**
+     * Indicates the Y position of the associated cell.
+     */
+    public int cellY = -1;
+
+    public CellAndSpan() {
+    }
+
+    public void copyFrom(CellAndSpan copy) {
+        cellX = copy.cellX;
+        cellY = copy.cellY;
+    }
+
+    public CellAndSpan(int cellX, int cellY) {
+        this.cellX = cellX;
+        this.cellY = cellY;
+    }
+
+    public String toString() {
+        return "(" + cellX + ", " + cellY + ")";
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/CellLayout.kt b/app/src/main/java/foundation/e/blisslauncher/features/test/CellLayout.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3d886365944d3517b965caad18f7a61e20b80d2f
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/CellLayout.kt
@@ -0,0 +1,928 @@
+package foundation.e.blisslauncher.features.test
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.TimeInterpolator
+import android.animation.ValueAnimator
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.Point
+import android.graphics.Rect
+import android.util.ArrayMap
+import android.util.AttributeSet
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
+import android.widget.GridLayout
+import androidx.annotation.IntDef
+import foundation.e.blisslauncher.R
+import foundation.e.blisslauncher.core.Utilities
+import foundation.e.blisslauncher.core.database.model.LauncherItem
+import foundation.e.blisslauncher.core.utils.Constants
+import foundation.e.blisslauncher.features.launcher.Hotseat
+import foundation.e.blisslauncher.features.test.anim.Interpolators
+import foundation.e.blisslauncher.features.test.dragndrop.DropTarget
+import foundation.e.blisslauncher.features.test.graphics.DragPreviewProvider
+import java.lang.Double.MAX_VALUE
+import java.lang.annotation.Retention
+import java.lang.annotation.RetentionPolicy
+import java.util.ArrayList
+import java.util.Arrays
+import java.util.Stack
+import kotlin.math.hypot
+
+open class CellLayout @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : GridLayout(context, attrs, defStyleAttr) {
+
+    private var mItemPlacementDirty: Boolean = false
+    private var mIsDragOverlapping: Boolean = false
+
+    // When a drag operation is in progress, holds the nearest cell to the touch point
+    private val mDragCell = IntArray(2)
+    private val BACKGROUND_STATE_ACTIVE = intArrayOf(android.R.attr.state_active)
+    private val BACKGROUND_STATE_DEFAULT = EMPTY_STATE_SET
+    private var mDragging: Boolean = false
+
+    private val DESTRUCTIVE_REORDER = false
+    private val DEBUG_VISUALIZE_OCCUPIED = false
+
+    private var 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.
+    val mTmpPoint = IntArray(2)
+    val mTempLocation = IntArray(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.
+    private val mTmpCellXY = IntArray(2)
+
+    @Retention(RetentionPolicy.SOURCE)
+    @IntDef(WORKSPACE, HOTSEAT)
+    annotation class ContainerType
+
+    @ContainerType
+    private var mContainerType = 0
+
+    private val TAG = "CellLayout"
+
+    private val launcher: TestActivity = TestActivity.getLauncher(context)
+    private val dp = launcher.deviceProfile
+    var mCountX = dp.inv.numColumns
+    var mCountY = dp.inv.numRows
+
+    var mOccupied = GridOccupancy(mCountX, mCountY)
+    var mTmpOccupied = GridOccupancy(mCountX, mCountY)
+
+    private val mIntersectingViews = ArrayList<View>()
+
+    // These arrays are used to implement the drag visualization on x-large screens.
+    // They are used as circular arrays, indexed by mDragOutlineCurrent.
+    val mDragOutlines = arrayOfNulls<Rect>(4)
+
+    val mDragOutlineAlphas = FloatArray(mDragOutlines.size)
+    private val mDragOutlineAnims: Array<InterruptibleInOutAnimator?> =
+        arrayOfNulls<InterruptibleInOutAnimator>(mDragOutlines.size)
+
+    // Used as an index into the above 3 arrays; indicates which is the most current value.
+    private var mDragOutlineCurrent = 0
+    private val mDragOutlinePaint = Paint()
+    private var mEaseOutInterpolator: TimeInterpolator? = null
+
+    open var containerType = Constants.CONTAINER_DESKTOP
+
+    private var cellWidth: Int = 0
+    private var cellHeight: Int = 0
+
+    val mReorderAnimators: ArrayMap<LayoutParams, Animator> = ArrayMap<LayoutParams, Animator>()
+
+    companion object {
+        const val MODE_SHOW_REORDER_HINT = 0
+        const val MODE_DRAG_OVER = 1
+        const val MODE_ON_DROP = 2
+        const val MODE_ON_DROP_EXTERNAL = 3
+        const val MODE_ACCEPT_DROP = 4
+
+        const val WORKSPACE = 0
+        const val HOTSEAT = 1
+    }
+
+    init {
+        val a = context.obtainStyledAttributes(attrs, R.styleable.CellLayout, defStyleAttr, 0)
+        mContainerType = a.getInteger(R.styleable.CellLayout_containerType, WORKSPACE)
+        Log.i(TAG, "Container type: $mContainerType")
+        a.recycle()
+
+        setWillNotDraw(false)
+        clipToPadding = false
+
+        // Initialize the data structures used for the drag visualization.
+        mEaseOutInterpolator = Interpolators.DEACCEL_2_5 // Quint ease out
+
+        for (i in mDragOutlines.indices) {
+            mDragOutlines[i] = Rect(-1, -1, -1, -1)
+        }
+        mDragOutlinePaint.color = Color.RED
+
+        // 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
+        // behind the drag path.
+        // Set up all the animations that are used to implement this fading.
+        val duration = 900
+        val fromAlphaValue = 0f
+        val toAlphaValue = 128f
+
+        Arrays.fill(mDragOutlineAlphas, fromAlphaValue)
+
+        for (i in mDragOutlineAnims.indices) {
+            val anim = InterruptibleInOutAnimator(
+                this,
+                duration.toLong(), fromAlphaValue, toAlphaValue
+            )
+            anim.animator.interpolator = mEaseOutInterpolator
+            anim.animator.addUpdateListener { animation ->
+                val outline = anim.tag as Bitmap?
+
+                // If an animation is started and then stopped very quickly, we can still
+                // get spurious updates we've cleared the tag. Guard against this.
+                if (outline == null) {
+
+                    val `val` = animation.animatedValue
+                    Log.d(
+                        TAG, "anim " + i + " update: " + `val` +
+                            ", isStopped " + anim.isStopped
+                    )
+                    // Try to prevent it from continuing to run
+                    animation.cancel()
+                } else {
+                    mDragOutlineAlphas[i] = animation.animatedValue as Float
+                    this@CellLayout.invalidate(mDragOutlines[i])
+                }
+            }
+            // The animation holds a reference to the drag outline bitmap as long is it's
+            // running. This way the bitmap can be GCed when the animations are complete.
+            anim.animator.addListener(object : AnimatorListenerAdapter() {
+                override fun onAnimationEnd(animation: Animator) {
+                    if ((animation as ValueAnimator).animatedValue as Float == 0f) {
+                        anim.tag = null
+                    }
+                }
+            })
+            mDragOutlineAnims[i] = anim
+        }
+    }
+
+    override fun onMeasure(widthSpec: Int, heightSpec: Int) {
+        super.onMeasure(widthSpec, heightSpec)
+        val widthSpecMode = MeasureSpec.getMode(widthSpec)
+        val heightSpecMode = MeasureSpec.getMode(heightSpec)
+        val widthSize = MeasureSpec.getSize(widthSpec)
+        val heightSize = MeasureSpec.getSize(heightSpec)
+        val childWidthSize = widthSize - (paddingLeft + paddingRight)
+        val childHeightSize = heightSize - (paddingTop + paddingBottom)
+        cellWidth = VariantDeviceProfile.calculateCellWidth(childWidthSize, mCountX)
+        cellHeight = VariantDeviceProfile.calculateCellHeight(childHeightSize, mCountY)
+        setMeasuredDimension(widthSize, heightSize)
+        for (i in 0 until childCount) {
+            val child = getChildAt(i)
+            if (child.visibility != View.GONE) {
+                measureChild(child)
+            }
+        }
+    }
+
+    open fun getCellContentHeight(): Int {
+        return Math.min(
+            measuredHeight,
+            launcher.deviceProfile
+                .getCellHeight(if (parent is Hotseat) Constants.CONTAINER_HOTSEAT else Constants.CONTAINER_DESKTOP)
+        )
+    }
+
+    open fun setGridSize(x: Int, y: Int) {
+        mCountX = x
+        mCountY = y
+        columnCount = x
+        rowCount = y
+        mOccupied = GridOccupancy(mCountX, mCountY)
+        mTmpOccupied = GridOccupancy(mCountX, mCountY)
+        mTempRectStack.clear()
+        requestLayout()
+    }
+
+    fun measureChild(child: View) {
+        val lp = child.layoutParams as LayoutParams
+        lp.rowSpec = spec(UNDEFINED)
+        lp.columnSpec = spec(UNDEFINED)
+        lp.width = cellWidth
+        lp.height = cellHeight
+
+        // Center the icon/folder
+        val cHeight: Int = getCellContentHeight()
+        val cellPaddingY = 0f.coerceAtLeast((lp.height - cHeight) / 2f).toInt()
+        var cellPaddingX: Int
+        if (containerType == Constants.CONTAINER_DESKTOP) {
+            cellPaddingX = dp.workspaceCellPaddingXPx
+        } else {
+            cellPaddingX = (dp.edgeMarginPx / 2f).toInt()
+        }
+        child.setPadding(cellPaddingX, cellPaddingY, cellPaddingX, 0)
+        val childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(lp.width, MeasureSpec.EXACTLY)
+        val childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(lp.height, MeasureSpec.EXACTLY)
+        child.measure(childWidthMeasureSpec, childHeightMeasureSpec)
+    }
+
+    override fun onDraw(canvas: Canvas?) {
+        val paint = mDragOutlinePaint
+        for (i in mDragOutlines.indices) {
+            val alpha = mDragOutlineAlphas[i]
+            if (alpha > 0) {
+                val b = mDragOutlineAnims[i]!!.tag as Bitmap
+                paint.alpha = (alpha + .5f).toInt()
+                canvas!!.drawBitmap(b, null, mDragOutlines[i]!!, paint)
+            }
+        }
+        super.onDraw(canvas)
+    }
+
+    override fun shouldDelayChildPressedState(): Boolean {
+        return false
+    }
+
+    override fun cancelLongPress() {
+        super.cancelLongPress()
+        // Cancel long press for all children
+        val count = childCount
+        for (i in 0 until count) {
+            val child = getChildAt(i)
+            child.cancelLongPress()
+        }
+    }
+
+    override fun onViewAdded(child: View?) {
+        super.onViewAdded(child)
+        Log.d(TAG, "onViewAdded() called with: child = $child")
+    }
+
+    fun addViewToCellLayout(
+        child: View,
+        index: Int,
+        childId: Int,
+        params: LayoutParams,
+        markCells: Boolean
+    ): Boolean {
+        val lp: LayoutParams = params
+
+        // Hotseat icons - remove text
+        if (child is IconTextView) {
+            val bubbleChild: IconTextView = child
+
+            bubbleChild.setTextVisibility(mContainerType != HOTSEAT)
+        }
+
+        child.scaleX = 1f
+        child.scaleY = 1f
+
+        // Generate an id for each view, this assumes we have at most 256x256 cells
+        // per workspace screen
+        if (index >= 0 && index <= mCountX * mCountY - 1) {
+
+            child.id = childId
+/*            val rowSpec = spec(UNDEFINED)
+            val colSpec = spec(UNDEFINED)
+            val iconLayoutParams = LayoutParams(rowSpec, colSpec)
+            iconLayoutParams.height = launcher.deviceProfile.cellHeightPx
+            iconLayoutParams.width = launcher.deviceProfile.cellWidthPx
+            iconLayoutParams.setGravity(Gravity.CENTER)*/
+            addView(child, index, lp)
+
+            if (markCells) markCellsAsOccupiedForView(child)
+            return true
+        }
+        return false
+    }
+
+    override fun removeAllViews() {
+        mOccupied.clear()
+        super.removeAllViews()
+    }
+
+    override fun removeView(view: View) {
+        markCellsAsUnoccupiedForView(view)
+        super.removeView(view)
+    }
+
+    override fun removeViewAt(index: Int) {
+        markCellsAsUnoccupiedForView(getChildAt(index))
+        super.removeViewAt(index)
+    }
+
+    override fun removeViews(start: Int, count: Int) {
+        for (i in start until start + count) {
+            markCellsAsUnoccupiedForView(getChildAt(i))
+        }
+        super.removeViews(start, count)
+    }
+
+    open fun setDropPending(pending: Boolean) {
+        mDropPending = pending
+    }
+
+    open fun isDropPending(): Boolean {
+        return mDropPending
+    }
+
+    open fun setIsDragOverlapping(isDragOverlapping: Boolean) {
+        if (mIsDragOverlapping != isDragOverlapping) {
+            mIsDragOverlapping = isDragOverlapping
+            // mBackground.setState(if (mIsDragOverlapping) BACKGROUND_STATE_ACTIVE else BACKGROUND_STATE_DEFAULT)
+            invalidate()
+        }
+    }
+
+    /**
+     * A drag event has begun over this layout.
+     * It may have begun over this layout (in which case onDragChild is called first),
+     * or it may have begun on another layout.
+     */
+    open fun onDragEnter() {
+        mDragging = true
+    }
+
+    /**
+     * Called when drag has left this CellLayout or has been completed (successfully or not)
+     */
+    open fun onDragExit() {
+        // This can actually be called when we aren't in a drag, e.g. when adding a new
+        // item to this layout via the customize drawer.
+        // Guard against that case.
+        if (mDragging) {
+            mDragging = false
+        }
+
+        // Invalidate the drag data
+        mDragCell[1] = -1
+        mDragCell[0] = -1
+        mDragOutlineAnims[mDragOutlineCurrent]?.animateOut()
+        mDragOutlineCurrent = (mDragOutlineCurrent + 1) % mDragOutlineAnims.size
+        revertTempState()
+        setIsDragOverlapping(false)
+    }
+
+    fun revertTempState() {
+/*        completeAndClearReorderPreviewAnimations()
+        if (isItemPlacementDirty()) {
+            val count: Int = getChildCount()
+            for (i in 0 until count) {
+                val child: View = getChildAt(i)
+                val lp: com.android.launcher3.CellLayout.LayoutParams =
+                    child.layoutParams as com.android.launcher3.CellLayout.LayoutParams
+                if (lp.tmpCellX != lp.cellX || lp.tmpCellY != lp.cellY) {
+                    lp.tmpCellX = lp.cellX
+                    lp.tmpCellY = lp.cellY
+                    animateChildToPosition(
+                        child, lp.cellX, lp.cellY, CellLayout.REORDER_ANIMATION_DURATION,
+                        0, false, false
+                    )
+                }
+            }
+            setItemPlacementDirty(false)
+        }*/
+    }
+
+    /**
+     * Mark a child as having been dropped.
+     * At the beginning of the drag operation, the child may have been on another
+     * screen, but it is re-parented before this method is called.
+     *
+     * @param child The child that is being dropped
+     */
+    fun onDropChild(child: View?) {
+        child?.also {
+            val lp: LayoutParams = it.layoutParams as LayoutParams
+            // lp.dropped = true
+            child.requestLayout()
+            markCellsAsOccupiedForView(child)
+        }
+    }
+
+    open fun markCellsAsOccupiedForView(view: View?) {
+        if (view == null || view.parent == null) return
+        val parent = view.parent as ViewGroup
+        mOccupied.markCells(parent.indexOfChild(view), true)
+    }
+
+    open fun markCellsAsUnoccupiedForView(view: View?) {
+        if (view == null || view.parent == null) return
+        val parent = view.parent as ViewGroup
+        mOccupied.markCells(parent.indexOfChild(view), false)
+    }
+
+    open fun visualizeDropLocation(
+        v: View?,
+        outlineProvider: DragPreviewProvider?,
+        cellX: Int,
+        cellY: Int,
+        resize: Boolean,
+        dragObject: DropTarget.DragObject
+    ) {
+        val oldDragCellX = mDragCell[0]
+        val oldDragCellY = mDragCell[1]
+        if (outlineProvider?.generatedDragOutline == null) {
+            return
+        }
+        val dragOutline: Bitmap = outlineProvider.generatedDragOutline
+        if (cellX != oldDragCellX || cellY != oldDragCellY) {
+            val dragOffset: Point = dragObject.dragView.dragVisualizeOffset
+            val dragRegion: Rect = dragObject.dragView.dragRegion
+            mDragCell[0] = cellX
+            mDragCell[1] = cellY
+            val oldIndex: Int = mDragOutlineCurrent
+            mDragOutlineAnims[oldIndex]?.animateOut()
+            mDragOutlineCurrent = (oldIndex + 1) % mDragOutlines.size
+            val r: Rect = mDragOutlines[mDragOutlineCurrent]!!
+
+            // Find the top left corner of the rect the object will occupy
+            val topLeft = mTmpPoint
+            cellToPoint(cellX, cellY, topLeft)
+            var left = topLeft[0]
+            var top = topLeft[1]
+            if (v != null && dragOffset == null) {
+                // When drawing the drag outline, it did not account for margin offsets
+                // added by the view's parent.
+                val lp = v.layoutParams as MarginLayoutParams
+                left += lp.leftMargin
+                top += lp.topMargin
+
+                // Offsets due to the size difference between the View and the dragOutline.
+                // There is a size difference to account for the outer blur, which may lie
+                // outside the bounds of the view.
+                top += (cellHeight * 1 - dragOutline.height) / 2
+                // We center about the x axis
+                left += (cellWidth * 1 - dragOutline.width) / 2
+            } else {
+                if (dragOffset != null && dragRegion != null) {
+                    // Center the drag region *horizontally* in the cell and apply a drag
+                    // outline offset
+                    left += dragOffset.x + (cellWidth * 1 - dragRegion.width()) / 2
+                    val cHeight: Int = getCellContentHeight()
+                    val cellPaddingY =
+                        Math.max(0f, (cellHeight - cHeight) / 2f).toInt()
+                    top += dragOffset.y + cellPaddingY
+                } else {
+                    // Center the drag outline in the cell
+                    left += (cellWidth * 1 - dragOutline.width) / 2
+                    top += (cellHeight * 1 - dragOutline.height) / 2
+                }
+            }
+            r[left, top, left + dragOutline.width] = top + dragOutline.height
+            Utilities.scaleRectAboutCenter(r, 1f)
+            mDragOutlineAnims[mDragOutlineCurrent]?.setTag(dragOutline)
+            mDragOutlineAnims[mDragOutlineCurrent]?.animateIn()
+        }
+    }
+
+    /**
+     * 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 result Array of 2 ints to hold the x and y coordinate of the point
+     */
+    open fun cellToPoint(cellX: Int, cellY: Int, result: IntArray) {
+        val hStartPadding = paddingLeft
+        val vStartPadding = paddingTop
+        result[0] = hStartPadding + cellX * cellWidth
+        result[1] = vStartPadding + cellY * cellHeight
+    }
+
+    fun getDistanceFromCell(x: Float, y: Float, cell: IntArray): Float {
+        cellToCenterPoint(cell[0], cell[1], mTmpPoint)
+        return Math.hypot((x - mTmpPoint[0]).toDouble(), (y - mTmpPoint[1]).toDouble())
+            .toFloat()
+    }
+
+    // For a given cell and span, fetch the set of views intersecting the region.
+    private fun getViewsIntersectingRegion(
+        cellX: Int,
+        cellY: Int,
+        dragView: View,
+        boundingRect: Rect?,
+        intersectingViews: ArrayList<View>
+    ) {
+        boundingRect?.set(cellX, cellY, cellX + 1, cellY + 1)
+        intersectingViews.clear()
+        val r0 = Rect(cellX, cellY, cellX + 1, cellY + 1)
+        val r1 = Rect()
+        val count: Int = childCount
+        for (i in 0 until count) {
+            val child: View = getChildAt(i)
+            if (child === dragView) continue
+            r1[i % mCountX, i % mCountY, i % mCountX + 1] = i % mCountY + 1
+            if (Rect.intersects(r0, r1)) {
+                mIntersectingViews.add(child)
+                boundingRect?.union(r1)
+            }
+        }
+    }
+
+    open fun isNearestDropLocationOccupied(
+        pixelX: Int,
+        pixelY: Int,
+        dragView: View,
+        result: IntArray?
+    ): Boolean {
+        var result = result
+        result = findNearestArea(pixelX, pixelY, result)
+        getViewsIntersectingRegion(
+            result!![0], result!![1], dragView, null,
+            mIntersectingViews
+        )
+        return !mIntersectingViews.isEmpty()
+    }
+
+    /**
+     * 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 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.
+     */
+    open fun findNearestArea(
+        pixelX: Int,
+        pixelY: Int,
+        result: IntArray?
+    ): IntArray? {
+        return findNearestArea(pixelX, pixelY, false, result, null)
+    }
+
+    /**
+     * 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 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)
+     * @return The X, Y cell of a vacant area that can contain this object,
+     * nearest the requested location.
+     */
+    private fun findNearestArea(
+        pixelX: Int,
+        pixelY: Int,
+        ignoreOccupied: Boolean,
+        result: IntArray?,
+        resultSpan: IntArray?
+    ): IntArray? {
+        var pixelX = pixelX
+        var pixelY = pixelY
+        lazyInitTempRectStack()
+
+        // Keep track of best-scoring drop area
+        val bestXY = result ?: IntArray(2)
+        var bestDistance: Double = MAX_VALUE
+        val bestRect = Rect(-1, -1, -1, -1)
+        val validRegions = Stack<Rect>()
+        val countX: Int = mCountX
+        val countY: Int = mCountY
+
+        val minSpanX = 1
+        val minSpanY = 1
+        val spanX = 1
+        val spanY = 1
+
+        Log.d(TAG, "FINDING START")
+        for (y in 0 until countY - (minSpanY - 1)) {
+            inner@ for (x in 0 until countX - (minSpanX - 1)) {
+                var ySize = -1
+                var xSize = -1
+                if (ignoreOccupied) {
+                    // First, let's see if this thing fits anywhere
+                    for (i in 0 until minSpanX) {
+                        for (j in 0 until minSpanY) {
+                            if (mOccupied.cells[(x + i) * countY + (y + j)]) {
+                                continue@inner
+                            }
+                        }
+                    }
+                    xSize = minSpanX
+                    ySize = minSpanY
+
+                    // We know that the item will fit at _some_ acceptable size, now let's see
+                    // how big we can make it. We'll alternate between incrementing x and y spans
+                    // until we hit a limit.
+                    var incX = true
+                    var hitMaxX = xSize >= spanX
+                    var hitMaxY = ySize >= spanY
+                    while (!(hitMaxX && hitMaxY)) {
+                        if (incX && !hitMaxX) {
+                            for (j in 0 until ySize) {
+                                if (x + xSize > countX - 1 || mOccupied.cells[(x + xSize) * countY + (y + j)]
+                                ) {
+                                    // We can't move out horizontally
+                                    hitMaxX = true
+                                }
+                            }
+                            if (!hitMaxX) {
+                                xSize++
+                            }
+                        } else if (!hitMaxY) {
+                            for (i in 0 until xSize) {
+                                if (y + ySize > countY - 1 || mOccupied.cells[(x + i) * countY + (y + ySize)]
+                                ) {
+                                    // We can't move out vertically
+                                    hitMaxY = true
+                                }
+                            }
+                            if (!hitMaxY) {
+                                ySize++
+                            }
+                        }
+                        hitMaxX = hitMaxX or (xSize >= spanX)
+                        hitMaxY = hitMaxY or (ySize >= spanY)
+                        incX = !incX
+                    }
+                    incX = true
+                    hitMaxX = xSize >= spanX
+                    hitMaxY = ySize >= spanY
+                }
+                val cellXY = mTmpPoint
+                cellToCenterPoint(x, y, cellXY)
+
+                // We verify that the current rect is not a sub-rect of any of our previous
+                // candidates. In this case, the current rect is disqualified in favour of the
+                // containing rect.
+                val currentRect: Rect = mTempRectStack.pop()
+                currentRect[x, y, x + xSize] = y + ySize
+                var contained = false
+                for (r in validRegions) {
+                    if (r.contains(currentRect)) {
+                        contained = true
+                        break
+                    }
+                }
+                validRegions.push(currentRect)
+                val distance =
+                    hypot((cellXY[0] - pixelX).toDouble(), (cellXY[1] - pixelY).toDouble())
+                if (distance <= bestDistance && !contained ||
+                    currentRect.contains(bestRect)
+                ) {
+                    bestDistance = distance
+                    bestXY[0] = x
+                    bestXY[1] = y
+                    if (resultSpan != null) {
+                        resultSpan[0] = xSize
+                        resultSpan[1] = ySize
+                    }
+                    bestRect.set(currentRect)
+                }
+            }
+        }
+
+        // Return -1, -1 if no suitable location found
+        if (bestDistance == MAX_VALUE) {
+            bestXY[0] = -1
+            bestXY[1] = -1
+        }
+        recycleTempRects(validRegions)
+        Log.d(TAG, "FINDING END")
+        return bestXY
+    }
+
+    /**
+     * 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 result Array of 2 ints to hold the x and y coordinate of the point
+     */
+    open fun cellToCenterPoint(cellX: Int, cellY: Int, result: IntArray) {
+        regionToCenterPoint(cellX, cellY, 1, 1, result)
+    }
+
+    /**
+     * Given a cell coordinate and span return the point that represents the center of the regio
+     *
+     * @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
+     */
+    open fun regionToCenterPoint(cellX: Int, cellY: Int, spanX: Int, spanY: Int, result: IntArray) {
+        val hStartPadding = paddingLeft
+        val vStartPadding = paddingTop
+        Log.i(TAG, "regionToCenterPoint: $hStartPadding $vStartPadding")
+        result[0] = hStartPadding + cellX * cellWidth + spanX * cellWidth / 2
+        result[1] = vStartPadding + cellY * cellHeight + spanY * cellHeight / 2
+    }
+
+    /**
+     * 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 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)
+     * @return The X, Y cell of a vacant area that can contain this object,
+     * nearest the requested location.
+     */
+    open fun findNearestVacantArea(
+        pixelX: Int,
+        pixelY: Int,
+        minSpanX: Int,
+        minSpanY: Int,
+        spanX: Int,
+        spanY: Int,
+        result: IntArray?,
+        resultSpan: IntArray?
+    ): IntArray? {
+        return findNearestArea(
+            pixelX, pixelY, true,
+            result, resultSpan
+        )
+    }
+
+    private val mTempRectStack = Stack<Rect>()
+    private fun lazyInitTempRectStack() {
+        if (mTempRectStack.isEmpty()) {
+            for (i in 0 until mCountX * mCountY) {
+                mTempRectStack.push(Rect())
+            }
+        }
+    }
+
+    private fun recycleTempRects(used: Stack<Rect>) {
+        while (!used.isEmpty()) {
+            mTempRectStack.push(used.pop())
+        }
+    }
+
+    fun getChildAt(x: Int, y: Int): View {
+        return getChildAt(y * mCountX + x)
+    }
+
+    open fun performReorder(
+        pixelX: Int,
+        pixelY: Int,
+        minSpanX: Int,
+        minSpanY: Int,
+        spanX: Int,
+        spanY: Int,
+        dragView: View?,
+        result: IntArray?,
+        resultSpan: IntArray?,
+        mode: Int
+    ): IntArray? {
+
+        // First we determine if things have moved enough to cause a different layout
+        var result = result
+        var resultSpan = resultSpan
+        result = findNearestArea(pixelX, pixelY, result)
+        Log.d(
+            TAG,
+            "performReorder() called with: resultX = ${result!![0]} ${result!![1]} mode = $mode"
+        )
+        if (resultSpan == null) {
+            resultSpan = IntArray(2)
+        }
+
+        resultSpan[0] = 1
+        resultSpan[1] = 1
+
+        // We don't need to find for nearest area when the grid is already totally occupied.
+
+        // 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) {
+            val parent = (dragView?.parent as ViewGroup?)
+            parent?.removeView(dragView)
+
+            if (childCount == mCountX * mCountY) {
+                return intArrayOf(-1, -1)
+            }
+            var index = result[1] * mCountX + result[0]
+
+            // Handles the case when the icon is being dragged after the last item on the grid.
+            if (index > childCount) {
+                index = childCount
+                result[0] = index % mCountX
+                result[1] = index / mCountX
+            }
+
+            // appView.findViewById(R.id.app_label).setVisibility(GONE);
+            val rowSpec = spec(UNDEFINED)
+            val colSpec = spec(UNDEFINED)
+            val iconLayoutParams = LayoutParams(rowSpec, colSpec)
+            // iconLayoutParams.setGravity(Gravity.CENTER)
+            iconLayoutParams.height = if (mContainerType == HOTSEAT)
+                dp.hotseatCellHeightPx else dp.cellHeightPx
+            iconLayoutParams.width = dp.cellWidthPx
+            dragView?.also {
+                if (it is IconTextView) it.setTextVisibility(mContainerType != HOTSEAT)
+            }
+            dragView?.setLayoutParams(iconLayoutParams)
+            addView(dragView, index)
+
+            /*copySolutionToTempState(finalSolution, dragView)
+            setItemPlacementDirty(true)
+            animateItemsToSolution(finalSolution, dragView!!, mode == MODE_ON_DROP)
+            if ((mode == MODE_ON_DROP || mode == MODE_ON_DROP_EXTERNAL)) {
+                commitTempPlacement()
+                completeAndClearReorderPreviewAnimations()
+                setItemPlacementDirty(false)
+            } else {
+                beginOrAdjustReorderPreviewAnimations(
+                    finalSolution,
+                    dragView!!,
+                    CellLayout.REORDER_ANIMATION_DURATION,
+                    ReorderPreviewAnimation.MODE_PREVIEW
+                )
+            }*/
+        }
+
+        // May consider this later.
+        /*if ((mode == MODE_ON_DROP || !foundSolution)) {
+            setUseTempCoords(false)
+        }*/
+        // requestLayout()
+        return result
+    }
+
+    open fun setItemPlacementDirty(dirty: Boolean) {
+        mItemPlacementDirty = dirty
+    }
+
+    open fun isItemPlacementDirty(): Boolean {
+        return mItemPlacementDirty
+    }
+
+    /**
+     * 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 resultRect Rect into which to put the results
+     */
+    fun cellToRect(cellX: Int, cellY: Int, cellHSpan: Int, cellVSpan: Int, resultRect: Rect) {
+        val cellWidth: Int = cellWidth
+        val cellHeight: Int = cellHeight
+        val hStartPadding = paddingLeft
+        val vStartPadding = paddingTop
+        val width = cellHSpan * cellWidth
+        val height = cellVSpan * cellHeight
+        val x = hStartPadding + cellX * cellWidth
+        val y = vStartPadding + cellY * cellHeight
+        resultRect[x, y, x + width] = y + height
+    }
+
+    // This class stores info for two purposes:
+    // 1. When dragging items (mDragInfo in Workspace), we store the View, its cellX & cellY,
+    //    its spanX, spanY, and the screen it is on
+    // 2. When long clicking on an empty cell in a CellLayout, we save information about the
+    //    cellX and cellY coordinates and which page was clicked. We then set this as a tag on
+    //    the CellLayout that was long clicked
+    class CellInfo(v: View, info: LauncherItem) {
+        val cell: View
+        val screenId: Long
+        val container: Long
+        val rank: Int
+        override fun toString(): String {
+            return ("Cell[view=${cell.javaClass}, rank=$rank")
+        }
+
+        init {
+            cell = v
+            rank = info.cell
+            screenId = info.screenId
+            container = info.container
+        }
+    }
+
+    fun isOccupied(x: Int, y: Int): Boolean {
+        return if (x < mCountX && y < mCountY) {
+            mOccupied.cells[x * mCountY + y]
+        } else {
+            throw RuntimeException("Position exceeds the bound of this CellLayout")
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/CheckLongPressHelper.java b/app/src/main/java/foundation/e/blisslauncher/features/test/CheckLongPressHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5457b11d7aee20a09c83b8e13be1802c044690e
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/CheckLongPressHelper.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2012 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 foundation.e.blisslauncher.features.test;
+
+import android.view.View;
+
+public class CheckLongPressHelper {
+
+    public static final int DEFAULT_LONG_PRESS_TIMEOUT = 300;
+
+    View mView;
+    View.OnLongClickListener mListener;
+    boolean mHasPerformedLongPress;
+    private int mLongPressTimeout = DEFAULT_LONG_PRESS_TIMEOUT;
+    private CheckForLongPress mPendingCheckForLongPress;
+
+    class CheckForLongPress implements Runnable {
+        public void run() {
+            if ((mView.getParent() != null) && mView.hasWindowFocus()
+                    && !mHasPerformedLongPress) {
+                boolean handled;
+                if (mListener != null) {
+                    handled = mListener.onLongClick(mView);
+                } else {
+                    handled = mView.performLongClick();
+                }
+                if (handled) {
+                    mView.setPressed(false);
+                    mHasPerformedLongPress = true;
+                }
+            }
+        }
+    }
+
+    public CheckLongPressHelper(View v) {
+        mView = v;
+    }
+
+    public CheckLongPressHelper(View v, View.OnLongClickListener listener) {
+        mView = v;
+        mListener = listener;
+    }
+
+    /**
+     * Overrides the default long press timeout.
+     */
+    public void setLongPressTimeout(int longPressTimeout) {
+        mLongPressTimeout = longPressTimeout;
+    }
+
+    public void postCheckForLongPress() {
+        mHasPerformedLongPress = false;
+
+        if (mPendingCheckForLongPress == null) {
+            mPendingCheckForLongPress = new CheckForLongPress();
+        }
+        mView.postDelayed(mPendingCheckForLongPress, mLongPressTimeout);
+    }
+
+    public void cancelLongPress() {
+        mHasPerformedLongPress = false;
+        if (mPendingCheckForLongPress != null) {
+            mView.removeCallbacks(mPendingCheckForLongPress);
+            mPendingCheckForLongPress = null;
+        }
+    }
+
+    public boolean hasPerformedLongPress() {
+        return mHasPerformedLongPress;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/Executors.java b/app/src/main/java/foundation/e/blisslauncher/features/test/Executors.java
new file mode 100644
index 0000000000000000000000000000000000000000..59d2f18db8169b65b885a50b9e03471d165b7f76
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/Executors.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2008 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 foundation.e.blisslauncher.features.test;
+
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Process;
+
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+import foundation.e.blisslauncher.core.executors.LooperExecutor;
+
+/**
+ * Various different executors used in Launcher
+ */
+public class Executors {
+
+    // These values are same as that in {@link AsyncTask}.
+    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
+    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
+    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
+    private static final int KEEP_ALIVE = 1;
+
+    /**
+     * An {@link ThreadPoolExecutor} to be used with async task with no limit on the queue size.
+     */
+    public static final ThreadPoolExecutor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(
+            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
+            TimeUnit.SECONDS, new LinkedBlockingQueue<>());
+
+    /**
+     * Returns the executor for running tasks on the main thread.
+     */
+    public static final LooperExecutor MAIN_EXECUTOR =
+            new LooperExecutor(Looper.getMainLooper());
+
+    /**
+     * A background executor for using time sensitive actions where user is waiting for response.
+     */
+    public static final LooperExecutor UI_HELPER_EXECUTOR =
+            new LooperExecutor(createAndStartNewForegroundLooper("UiThreadHelper"));
+
+    /**
+     * Utility method to get a started handler thread statically
+     */
+    public static Looper createAndStartNewLooper(String name) {
+        return createAndStartNewLooper(name, Process.THREAD_PRIORITY_DEFAULT);
+    }
+
+    /**
+     * Utility method to get a started handler thread statically with the provided priority
+     */
+    public static Looper createAndStartNewLooper(String name, int priority) {
+        HandlerThread thread = new HandlerThread(name, priority);
+        thread.start();
+        return thread.getLooper();
+    }
+
+    /**
+     * Similar to {@link #createAndStartNewLooper(String)}, but starts the thread with
+     * foreground priority.
+     * Think before using
+     */
+    public static Looper createAndStartNewForegroundLooper(String name) {
+        return createAndStartNewLooper(name, Process.THREAD_PRIORITY_FOREGROUND);
+    }
+
+    /**
+     * Executor used for running Launcher model related tasks (eg loading icons or updated db)
+     */
+    public static final LooperExecutor MODEL_EXECUTOR =
+            new LooperExecutor(createAndStartNewLooper("launcher-loader"));
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/GridOccupancy.java b/app/src/main/java/foundation/e/blisslauncher/features/test/GridOccupancy.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd65005d7d16a02c3f9cd04d1b80f08187178bc5
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/GridOccupancy.java
@@ -0,0 +1,40 @@
+package foundation.e.blisslauncher.features.test;
+
+import foundation.e.blisslauncher.core.database.model.LauncherItem;
+
+/**
+ * Utility object to manage the occupancy in a grid.
+ */
+public class GridOccupancy {
+
+    private final int mCountX;
+    private final int mCountY;
+
+    // We use 1-d array for cells because we use index of the cell than x and y.
+    public final boolean[] cells;
+
+    public GridOccupancy(int countX, int countY) {
+        mCountX = countX;
+        mCountY = countY;
+        cells = new boolean[countX * countY];
+    }
+
+    public void markCells(int index, boolean value) {
+        if (index < 0 || index >= mCountX * mCountY) return;
+        cells[index] = value;
+    }
+
+    public void markCells(CellAndSpan cell, boolean value) {
+        markCells(cell.cellY * mCountX + cell.cellX, value);
+    }
+
+    public void markCells(LauncherItem item, boolean value) {
+        markCells(item.cell, value);
+    }
+
+    public void clear() {
+        for(int i = 0; i<mCountX*mCountY; i++) {
+            markCells(i, false);
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/IconTextView.kt b/app/src/main/java/foundation/e/blisslauncher/features/test/IconTextView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e89c6061a73e92b147af9afbfc88411b83574fe4
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/IconTextView.kt
@@ -0,0 +1,196 @@
+package foundation.e.blisslauncher.features.test
+
+import android.R
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.Color
+import android.graphics.Rect
+import android.graphics.drawable.Drawable
+import android.text.TextUtils.TruncateAt
+import android.util.AttributeSet
+import android.util.TypedValue
+import android.view.MotionEvent
+import android.view.ViewConfiguration
+import android.widget.TextView
+import androidx.core.graphics.ColorUtils
+import foundation.e.blisslauncher.core.Utilities
+import foundation.e.blisslauncher.core.database.model.LauncherItem
+
+/**
+ * A text view which displays an icon on top side of it.
+ */
+@SuppressLint("AppCompatCustomView")
+class IconTextView @JvmOverloads constructor(context: Context, attrs: AttributeSet?, defStyle: Int) : TextView(context, attrs, defStyle) {
+
+    companion object {
+        private const val DISPLAY_WORKSPACE = 1
+        private const val DISPLAY_FOLDER = 2
+        private val STATE_PRESSED = intArrayOf(R.attr.state_pressed)
+    }
+
+    private var mStayPressed: Boolean = false
+    val iconBounds: Rect
+        get() {
+            val top = paddingTop
+            val left = (width - defaultIconSize) / 2
+            val right = left + defaultIconSize
+            val bottom = top + defaultIconSize
+            return Rect(left, top, right, bottom)
+        }
+    private val launcher: TestActivity = TestActivity.getLauncher(context)
+    private val dp = launcher.deviceProfile
+    private val defaultIconSize = dp.iconSizePx
+
+    private var mTextAlpha = 1f
+    private var mTextColor = Color.WHITE
+
+    private var disableRelayout = false
+    private var mIcon: Drawable? = null
+    private val slop =
+        ViewConfiguration.get(getContext()).scaledTouchSlop.toFloat()
+
+    private var longPressHelper: CheckLongPressHelper
+
+    constructor(context: Context) : this(context, null, 0)
+
+    constructor(context: Context, attrs: AttributeSet) : this(context, attrs, 0)
+
+    init {
+        setTextSize(TypedValue.COMPLEX_UNIT_PX, dp.iconTextSizePx.toFloat())
+        compoundDrawablePadding = dp.iconDrawablePaddingPx
+        ellipsize = TruncateAt.END
+        longPressHelper = CheckLongPressHelper(this)
+    }
+
+    override fun onFocusChanged(
+        focused: Boolean,
+        direction: Int,
+        previouslyFocusedRect: Rect?
+    ) {
+        // Disable marques when not focused to that, so that updating text does not cause relayout.
+        ellipsize = if (focused) TruncateAt.MARQUEE else TruncateAt.END
+        super.onFocusChanged(focused, direction, previouslyFocusedRect)
+    }
+
+    fun reset() {}
+
+    override fun setTextColor(color: Int) {
+        mTextColor = color
+        super.setTextColor(getModifiedColor())
+    }
+
+    override fun setTextColor(colors: ColorStateList) {
+        mTextColor = colors.defaultColor
+        if (java.lang.Float.compare(mTextAlpha, 1f) == 0) {
+            super.setTextColor(colors)
+        } else {
+            super.setTextColor(getModifiedColor())
+        }
+    }
+
+    fun applyFromShortcutItem(item: LauncherItem) {
+        applyIconAndLabel(item)
+        tag = item
+        applyBadgeState(item, false)
+    }
+
+    private fun applyIconAndLabel(item: LauncherItem) {
+        setIcon(item.icon)
+        text = item.title
+    }
+
+    private fun applyBadgeState(item: LauncherItem, animate: Boolean) {
+    }
+
+    override fun setTag(tag: Any?) {
+        if (tag != null) {
+            // TODO: Check Item info locked
+        }
+        super.setTag(tag)
+    }
+
+    override fun refreshDrawableState() {
+        super.refreshDrawableState()
+    }
+
+    override fun onCreateDrawableState(extraSpace: Int): IntArray? {
+        val drawableState = super.onCreateDrawableState(extraSpace + 1)
+        if (mStayPressed) {
+            mergeDrawableStates(drawableState, STATE_PRESSED)
+        }
+        return drawableState
+    }
+
+    fun getIcon() = mIcon
+
+    /**
+     * Sets the icon for this view based on the layout direction.
+     */
+    private fun setIcon(icon: Drawable) {
+        applyCompoundDrawables(icon)
+        mIcon = icon
+    }
+
+    protected fun applyCompoundDrawables(icon: Drawable) {
+        // If we had already set an icon before, disable relayout as the icon size is the
+        // same as before.
+        disableRelayout = mIcon != null
+        icon.setBounds(0, 0, defaultIconSize, defaultIconSize)
+        setCompoundDrawables(null, icon, null, null)
+        disableRelayout = false
+    }
+
+    override fun requestLayout() {
+        if (!disableRelayout) {
+            super.requestLayout()
+        }
+    }
+
+    fun setTextVisibility(visible: Boolean) {
+        setTextAlpha(if (visible) 1f else 0f)
+    }
+
+    private fun setTextAlpha(alpha: Float) {
+        mTextAlpha = alpha
+        super.setTextColor(getModifiedColor())
+    }
+
+    private fun getModifiedColor(): Int {
+        return if (mTextAlpha == 0f) {
+            // Special case to prevent text shadows in high contrast mode
+            Color.TRANSPARENT
+        } else ColorUtils.setAlphaComponent(
+            mTextColor, Math.round(Color.alpha(mTextColor) * mTextAlpha)
+        )
+    }
+
+    override fun onTouchEvent(event: MotionEvent): Boolean {
+        // Call the superclass onTouchEvent first, because sometimes it changes the state to
+        // isPressed() on an ACTION_UP
+        var result = super.onTouchEvent(event)
+
+        when (event.action) {
+            MotionEvent.ACTION_CANCEL, MotionEvent.ACTION_UP -> longPressHelper.cancelLongPress()
+            MotionEvent.ACTION_MOVE -> if (!Utilities.pointInView(this, event.x, event.y, slop)) {
+                longPressHelper.cancelLongPress()
+            }
+        }
+        return result
+    }
+
+    override fun cancelLongPress() {
+        super.cancelLongPress()
+        longPressHelper.cancelLongPress()
+    }
+
+    fun clearPressedBackground() {
+        isPressed = false
+        setStayPressed(false)
+    }
+
+    fun setStayPressed(stayPressed: Boolean) {
+        mStayPressed = stayPressed
+        refreshDrawableState()
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/InternalStateHandler.java b/app/src/main/java/foundation/e/blisslauncher/features/test/InternalStateHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd9dac7ffb7d279ce9a1648921e885f45c64f797
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/InternalStateHandler.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.features.test;
+
+import android.content.Intent;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.IBinder;
+
+import java.lang.ref.WeakReference;
+
+import foundation.e.blisslauncher.core.executors.MainThreadExecutor;
+
+/**
+ * Utility class to sending state handling logic to Launcher from within the same process.
+ *
+ * Extending {@link Binder} ensures that the platform maintains a single instance of each object
+ * which allows this object to safely navigate the system process.
+ */
+public abstract class InternalStateHandler extends Binder {
+
+    public static final String EXTRA_STATE_HANDLER = "launcher.state_handler";
+
+    private static final Scheduler sScheduler = new Scheduler();
+
+    /**
+     * Initializes the handler when the launcher is ready.
+     * @return true if the handler wants to stay alive.
+     */
+    protected abstract boolean init(TestActivity launcher, boolean alreadyOnHome);
+
+    public final Intent addToIntent(Intent intent) {
+        Bundle extras = new Bundle();
+        extras.putBinder(EXTRA_STATE_HANDLER, this);
+        intent.putExtras(extras);
+        return intent;
+    }
+
+    public final void initWhenReady() {
+        sScheduler.schedule(this);
+    }
+
+    public boolean clearReference() {
+        return sScheduler.clearReference(this);
+    }
+
+    public static boolean hasPending() {
+        return sScheduler.hasPending();
+    }
+
+    public static boolean handleCreate(TestActivity launcher, Intent intent) {
+        return handleIntent(launcher, intent, false, false);
+    }
+
+    public static boolean handleNewIntent(TestActivity launcher, Intent intent, boolean alreadyOnHome) {
+        return handleIntent(launcher, intent, alreadyOnHome, true);
+    }
+
+    private static boolean handleIntent(
+            TestActivity launcher, Intent intent, boolean alreadyOnHome, boolean explicitIntent) {
+        boolean result = false;
+        if (intent != null && intent.getExtras() != null) {
+            IBinder stateBinder = intent.getExtras().getBinder(EXTRA_STATE_HANDLER);
+            if (stateBinder instanceof InternalStateHandler) {
+                InternalStateHandler handler = (InternalStateHandler) stateBinder;
+                if (!handler.init(launcher, alreadyOnHome)) {
+                    intent.getExtras().remove(EXTRA_STATE_HANDLER);
+                }
+                result = true;
+            }
+        }
+        if (!result && !explicitIntent) {
+            result = sScheduler.initIfPending(launcher, alreadyOnHome);
+        }
+        return result;
+    }
+
+    private static class Scheduler implements Runnable {
+
+        private WeakReference<InternalStateHandler> mPendingHandler = new WeakReference<>(null);
+        private MainThreadExecutor mMainThreadExecutor;
+
+        public synchronized void schedule(InternalStateHandler handler) {
+            mPendingHandler = new WeakReference<>(handler);
+            if (mMainThreadExecutor == null) {
+                mMainThreadExecutor = new MainThreadExecutor();
+            }
+            mMainThreadExecutor.execute(this);
+        }
+
+        @Override
+        public void run() {
+            LauncherAppState app = LauncherAppState.getInstanceNoCreate();
+            if (app == null) {
+                return;
+            }
+
+            TestActivity launcher = (TestActivity) app.getLauncher();
+            if(launcher == null) {
+                return;
+            }
+            initIfPending(launcher, launcher.isStarted());
+        }
+
+        public synchronized boolean initIfPending(TestActivity launcher, boolean alreadyOnHome) {
+            InternalStateHandler pendingHandler = mPendingHandler.get();
+            if (pendingHandler != null) {
+                if (!pendingHandler.init(launcher, alreadyOnHome)) {
+                    mPendingHandler.clear();
+                }
+                return true;
+            }
+            return false;
+        }
+
+        public synchronized boolean clearReference(InternalStateHandler handler) {
+            if (mPendingHandler.get() == handler) {
+                mPendingHandler.clear();
+                return true;
+            }
+            return false;
+        }
+
+        public boolean hasPending() {
+            return mPendingHandler.get() != null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/InterruptibleInOutAnimator.java b/app/src/main/java/foundation/e/blisslauncher/features/test/InterruptibleInOutAnimator.java
new file mode 100644
index 0000000000000000000000000000000000000000..29d30f0e15ffcda9ff3f6f3415601eb3ee15f047
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/InterruptibleInOutAnimator.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2010 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 foundation.e.blisslauncher.features.test;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.view.View;
+
+import foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils;
+
+/**
+ * A convenience class for two-way animations, e.g. a fadeIn/fadeOut animation.
+ * With a regular ValueAnimator, if you call reverse to show the 'out' animation, you'll get
+ * a frame-by-frame mirror of the 'in' animation -- i.e., the interpolated values will
+ * be exactly reversed. Using this class, both the 'in' and the 'out' animation use the
+ * interpolator in the same direction.
+ */
+public class InterruptibleInOutAnimator {
+    private long mOriginalDuration;
+    private float mOriginalFromValue;
+    private float mOriginalToValue;
+    private ValueAnimator mAnimator;
+
+    private boolean mFirstRun = true;
+
+    private Object mTag = null;
+
+    private static final int STOPPED = 0;
+    private static final int IN = 1;
+    private static final int OUT = 2;
+
+    // TODO: This isn't really necessary, but is here to help diagnose a bug in the drag viz
+    int mDirection = STOPPED;
+
+    public InterruptibleInOutAnimator(View view, long duration, float fromValue, float toValue) {
+        mAnimator = LauncherAnimUtils.ofFloat(fromValue, toValue).setDuration(duration);
+        mOriginalDuration = duration;
+        mOriginalFromValue = fromValue;
+        mOriginalToValue = toValue;
+
+        mAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mDirection = STOPPED;
+            }
+        });
+    }
+
+    private void animate(int direction) {
+        final long currentPlayTime = mAnimator.getCurrentPlayTime();
+        final float toValue = (direction == IN) ? mOriginalToValue : mOriginalFromValue;
+        final float startValue = mFirstRun ? mOriginalFromValue :
+                ((Float) mAnimator.getAnimatedValue()).floatValue();
+
+        // Make sure it's stopped before we modify any values
+        cancel();
+
+        // TODO: We don't really need to do the animation if startValue == toValue, but
+        // somehow that doesn't seem to work, possibly a quirk of the animation framework
+        mDirection = direction;
+
+        // Ensure we don't calculate a non-sensical duration
+        long duration = mOriginalDuration - currentPlayTime;
+        mAnimator.setDuration(Math.max(0, Math.min(duration, mOriginalDuration)));
+
+        mAnimator.setFloatValues(startValue, toValue);
+        mAnimator.start();
+        mFirstRun = false;
+    }
+
+    public void cancel() {
+        mAnimator.cancel();
+        mDirection = STOPPED;
+    }
+
+    public void end() {
+        mAnimator.end();
+        mDirection = STOPPED;
+    }
+
+    /**
+     * Return true when the animation is not running and it hasn't even been started.
+     */
+    public boolean isStopped() {
+        return mDirection == STOPPED;
+    }
+
+    /**
+     * This is the equivalent of calling Animator.start(), except that it can be called when
+     * the animation is running in the opposite direction, in which case we reverse
+     * direction and animate for a correspondingly shorter duration.
+     */
+    public void animateIn() {
+        animate(IN);
+    }
+
+    /**
+     * This is the roughly the equivalent of calling Animator.reverse(), except that it uses the
+     * same interpolation curve as animateIn(), rather than mirroring it. Also, like animateIn(),
+     * if the animation is currently running in the opposite direction, we reverse
+     * direction and animate for a correspondingly shorter duration.
+     */
+    public void animateOut() {
+        animate(OUT);
+    }
+
+    public void setTag(Object tag) {
+        mTag = tag;
+    }
+
+    public Object getTag() {
+        return mTag;
+    }
+
+    public ValueAnimator getAnimator() {
+        return mAnimator;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/InvariantDeviceProfile.kt b/app/src/main/java/foundation/e/blisslauncher/features/test/InvariantDeviceProfile.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b3eb3b8a531efec5ba99cfefcda6ff1b543468b5
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/InvariantDeviceProfile.kt
@@ -0,0 +1,397 @@
+package foundation.e.blisslauncher.features.test
+/*
+ * Copyright (C) 2015 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.
+ */
+
+import android.content.Context
+import android.content.res.Configuration
+import android.graphics.Point
+import android.util.DisplayMetrics
+import android.util.Log
+import android.util.Xml
+import android.view.WindowManager
+import foundation.e.blisslauncher.R
+import foundation.e.blisslauncher.core.Utilities
+import foundation.e.blisslauncher.quickstep.MainThreadInitializedObject
+import java.io.IOException
+import java.util.ArrayList
+import kotlin.math.hypot
+import kotlin.math.pow
+import org.xmlpull.v1.XmlPullParser
+import org.xmlpull.v1.XmlPullParserException
+
+open class InvariantDeviceProfile {
+    // Profile-defining invariant properties
+    var name: String? = null
+    var minWidthDps = 0f
+    var minHeightDps = 0f
+
+    /**
+     * Number of icons per row and column in the workspace.
+     */
+    var numRows = 0
+    var numColumns = 0
+
+    /**
+     * Number of icons per row and column in the folder.
+     */
+    var numFolderRows = 0
+    var numFolderColumns = 0
+
+    var iconSize = 0f
+    var landscapeIconSize = 0f
+    var iconBitmapSize = 0
+    var fillResIconDpi = 0
+    var iconTextSize = 0f
+
+    /**
+     * Number of icons inside the hotseat area.
+     */
+    var numHotseatIcons = 0
+    var defaultLayoutId = 0
+    var demoModeLayoutId = 0
+    lateinit var landscapeProfile: VariantDeviceProfile
+    lateinit var portraitProfile: VariantDeviceProfile
+    lateinit var defaultWallpaperSize: Point
+
+    // We do not need any synchronization for this variable as its only written on UI thread.
+    val INSTANCE: MainThreadInitializedObject<InvariantDeviceProfile> =
+        MainThreadInitializedObject { InvariantDeviceProfile() }
+
+    constructor()
+
+    constructor(context: Context) {
+        val wm =
+            context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+        val display = wm.defaultDisplay
+        val dm = DisplayMetrics()
+        display.getMetrics(dm)
+        val smallestSize = Point()
+        val largestSize = Point()
+        display.getCurrentSizeRange(smallestSize, largestSize)
+        // This guarantees that width < height
+        minWidthDps = Utilities.dpiFromPx(
+            smallestSize.x.coerceAtMost(smallestSize.y), dm
+        )
+        minHeightDps = Utilities.dpiFromPx(
+            largestSize.x.coerceAtMost(largestSize.y), dm
+        )
+
+        Log.d("ClosestProfiles", "[$minWidthDps], [$minHeightDps]")
+        val closestProfiles =
+            findClosestDeviceProfiles(
+                minWidthDps, minHeightDps, getPredefinedDeviceProfiles(context)
+            )
+        closestProfiles.forEach {
+            Log.d("InvariantDeviceProfile", it.name)
+        }
+        val interpolatedDeviceProfileOut =
+            invDistWeightedInterpolate(minWidthDps, minHeightDps, closestProfiles)
+        val closestProfile = closestProfiles[0]
+        Log.d(
+            "InvariantDevice",
+            "rows and col: ${closestProfile.numRows} * ${closestProfile.numColumns}"
+        )
+        numRows = closestProfile.numRows
+        numColumns = closestProfile.numColumns
+        numHotseatIcons = closestProfile.numHotseatIcons
+        defaultLayoutId = closestProfile.defaultLayoutId
+        demoModeLayoutId = closestProfile.demoModeLayoutId
+        numFolderRows = closestProfile.numFolderRows
+        numFolderColumns = closestProfile.numFolderColumns
+        iconSize = interpolatedDeviceProfileOut.iconSize
+        landscapeIconSize = interpolatedDeviceProfileOut.landscapeIconSize
+        iconBitmapSize =
+            Utilities.pxFromDp(iconSize, dm)
+        iconTextSize = interpolatedDeviceProfileOut.iconTextSize
+        fillResIconDpi = getLauncherIconDensity(iconBitmapSize)
+        // If the partner customization apk contains any grid overrides, apply them
+        // Supported overrides: numRows, numColumns, iconSize
+        // applyPartnerDeviceProfileOverrides(context, dm);
+        val realSize = Point()
+        display.getRealSize(realSize)
+        // The real size never changes. smallSide and largeSide will remain the
+        // same in any orientation.
+        val smallSide = Math.min(realSize.x, realSize.y)
+        val largeSide = Math.max(realSize.x, realSize.y)
+        landscapeProfile = VariantDeviceProfile(
+            context, this, smallestSize, largestSize,
+            largeSide, smallSide, true, false
+        )
+        portraitProfile = VariantDeviceProfile(
+            context, this, smallestSize, largestSize,
+            smallSide, largeSide, false, false
+        )
+        // We need to ensure that there is enough extra space in the wallpaper
+        // for the intended parallax effects
+        defaultWallpaperSize = Point(smallSide, largeSide)
+    }
+
+    private constructor(p: InvariantDeviceProfile) : this(
+        p.name, p.minWidthDps, p.minHeightDps, p.numRows, p.numColumns,
+        p.numFolderRows, p.numFolderColumns,
+        p.iconSize, p.landscapeIconSize, p.iconTextSize, p.numHotseatIcons,
+        p.defaultLayoutId, p.demoModeLayoutId
+    )
+
+    private constructor(
+        n: String?,
+        w: Float,
+        h: Float,
+        r: Int,
+        c: Int,
+        fr: Int,
+        fc: Int,
+        `is`: Float,
+        lis: Float,
+        its: Float,
+        hs: Int,
+        dlId: Int,
+        dmlId: Int
+    ) {
+        name = n
+        minWidthDps = w
+        minHeightDps = h
+        numRows = r
+        numColumns = c
+        numFolderRows = fr
+        numFolderColumns = fc
+        iconSize = `is`
+        landscapeIconSize = lis
+        iconTextSize = its
+        numHotseatIcons = hs
+        defaultLayoutId = dlId
+        demoModeLayoutId = dmlId
+    }
+
+    private fun getPredefinedDeviceProfiles(context: Context): ArrayList<InvariantDeviceProfile> {
+        val profiles =
+            ArrayList<InvariantDeviceProfile>()
+        try {
+            context.resources.getXml(R.xml.device_profiles).use { parser ->
+                val depth = parser.depth
+                var type: Int
+                while ((parser.next().also {
+                        type = it
+                    } != XmlPullParser.END_TAG ||
+                        parser.depth > depth) && type != XmlPullParser.END_DOCUMENT
+                ) {
+                    if (type == XmlPullParser.START_TAG && "profile" == parser.name) {
+                        val a = context.obtainStyledAttributes(
+                            Xml.asAttributeSet(parser),
+                            R.styleable.InvariantDeviceProfile
+                        )
+                        val numRows = a.getInt(
+                            R.styleable.InvariantDeviceProfile_numRows,
+                            0
+                        )
+                        val numColumns = a.getInt(
+                            R.styleable.InvariantDeviceProfile_numColumns,
+                            5
+                        )
+                        Log.d("Invariant", "Num columns here:  $numColumns")
+                        val iconSize = a.getFloat(
+                            R.styleable.InvariantDeviceProfile_iconSize,
+                            0f
+                        )
+                        val name = a.getString(R.styleable.InvariantDeviceProfile_name)
+                        Log.d("Invariant", "Parsing profile name:  $name")
+                        profiles.add(
+                            InvariantDeviceProfile(
+                                a.getString(R.styleable.InvariantDeviceProfile_name),
+                                a.getFloat(
+                                    R.styleable.InvariantDeviceProfile_minWidthDps,
+                                    0f
+                                ),
+                                a.getFloat(
+                                    R.styleable.InvariantDeviceProfile_minHeightDps,
+                                    0f
+                                ),
+                                numRows,
+                                numColumns,
+                                a.getInt(
+                                    R.styleable.InvariantDeviceProfile_numFolderRows,
+                                    numRows
+                                ),
+                                a.getInt(
+                                    R.styleable.InvariantDeviceProfile_numFolderColumns,
+                                    numColumns
+                                ),
+                                iconSize,
+                                a.getFloat(
+                                    R.styleable.InvariantDeviceProfile_landscapeIconSize,
+                                    iconSize
+                                ),
+                                a.getFloat(
+                                    R.styleable.InvariantDeviceProfile_iconTextSize,
+                                    0f
+                                ),
+                                a.getInt(
+                                    R.styleable.InvariantDeviceProfile_numHotseatIcons,
+                                    numColumns
+                                ),
+                                a.getResourceId(
+                                    R.styleable.InvariantDeviceProfile_defaultLayoutId,
+                                    0
+                                ),
+                                a.getResourceId(
+                                    R.styleable.InvariantDeviceProfile_demoModeLayoutId,
+                                    0
+                                )
+                            )
+                        )
+                        a.recycle()
+                    }
+                }
+            }
+        } catch (e: IOException) {
+            throw RuntimeException(e)
+        } catch (e: XmlPullParserException) {
+            throw RuntimeException(e)
+        }
+        return profiles
+    }
+
+    private fun getLauncherIconDensity(requiredSize: Int): Int { // Densities typically defined by an app.
+        val densityBuckets = intArrayOf(
+            DisplayMetrics.DENSITY_LOW,
+            DisplayMetrics.DENSITY_MEDIUM,
+            DisplayMetrics.DENSITY_TV,
+            DisplayMetrics.DENSITY_HIGH,
+            DisplayMetrics.DENSITY_XHIGH,
+            DisplayMetrics.DENSITY_XXHIGH,
+            DisplayMetrics.DENSITY_XXXHIGH
+        )
+        var density = DisplayMetrics.DENSITY_XXXHIGH
+        for (i in densityBuckets.indices.reversed()) {
+            val expectedSize =
+                (ICON_SIZE_DEFINED_IN_APP_DP * densityBuckets[i] /
+                    DisplayMetrics.DENSITY_DEFAULT)
+            if (expectedSize >= requiredSize) {
+                density = densityBuckets[i]
+            }
+        }
+        return density
+    }
+
+    fun dist(x0: Float, y0: Float, x1: Float, y1: Float): Float {
+        return hypot(x1 - x0, y1 - y0)
+    }
+
+    /**
+     * Returns the closest device profiles ordered by closeness to the specified width and height
+     */
+    fun findClosestDeviceProfiles(
+        width: Float,
+        height: Float,
+        points: ArrayList<InvariantDeviceProfile>
+    ): ArrayList<InvariantDeviceProfile> {
+        // Sort the profiles by their closeness to the dimensions
+        var pointsByNearness = points
+        pointsByNearness.sortWith(Comparator { a, b ->
+            java.lang.Float.compare(
+                dist(width, height, a.minWidthDps, a.minHeightDps), dist(
+                    width,
+                    height,
+                    b.minWidthDps,
+                    b.minHeightDps
+                )
+            )
+        })
+        return pointsByNearness
+    }
+
+    // Package private visibility for testing.
+    fun invDistWeightedInterpolate(
+        width: Float,
+        height: Float,
+        points: ArrayList<InvariantDeviceProfile>
+    ): InvariantDeviceProfile {
+        var weights = 0f
+        var p = points[0]
+        if (dist(width, height, p.minWidthDps, p.minHeightDps) == 0f) {
+            return p
+        }
+        val out = InvariantDeviceProfile()
+        var i = 0
+        while (i < points.size && i < KNEARESTNEIGHBOR) {
+            p = InvariantDeviceProfile(points[i])
+            val w = weight(
+                width,
+                height,
+                p.minWidthDps,
+                p.minHeightDps,
+                WEIGHT_POWER
+            )
+            weights += w
+            out.add(p.multiply(w))
+            ++i
+        }
+        return out.multiply(1.0f / weights)
+    }
+
+    private fun add(p: InvariantDeviceProfile) {
+        iconSize += p.iconSize
+        landscapeIconSize += p.landscapeIconSize
+        iconTextSize += p.iconTextSize
+    }
+
+    private fun multiply(w: Float): InvariantDeviceProfile {
+        iconSize *= w
+        landscapeIconSize *= w
+        iconTextSize *= w
+        return this
+    }
+
+    val allAppsButtonRank: Int
+        get() = numHotseatIcons / 2
+
+    fun isAllAppsButtonRank(rank: Int): Boolean {
+        return rank == allAppsButtonRank
+    }
+
+    fun getDeviceProfile(context: Context): VariantDeviceProfile {
+        return if (context.resources.configuration.orientation
+            == Configuration.ORIENTATION_LANDSCAPE
+        ) landscapeProfile else portraitProfile
+    }
+
+    private fun weight(
+        x0: Float,
+        y0: Float,
+        x1: Float,
+        y1: Float,
+        pow: Float
+    ): Float {
+        val d = dist(x0, y0, x1, y1)
+        return if (d.compareTo(0f) == 0) {
+            Float.POSITIVE_INFINITY
+        } else (WEIGHT_EFFICIENT / d.toDouble().pow(pow.toDouble())).toFloat()
+    }
+
+    companion object {
+        // This is a static that we use for the default icon size on a 4/5-inch phone
+        private const val DEFAULT_ICON_SIZE_DP = 60f
+        private const val ICON_SIZE_DEFINED_IN_APP_DP = 48f
+
+        // Constants that affects the interpolation curve between statically defined device profile
+        // buckets.
+        private const val KNEARESTNEIGHBOR = 3f
+        private const val WEIGHT_POWER = 5f
+
+        // used to offset float not being able to express extremely small weights in extreme cases.
+        private const val WEIGHT_EFFICIENT = 100000f
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherAnimationRunner.java b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherAnimationRunner.java
new file mode 100644
index 0000000000000000000000000000000000000000..3f26d5385754bdd328a4847c24e7b512441018c6
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherAnimationRunner.java
@@ -0,0 +1,138 @@
+/*
+ * 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 foundation.e.blisslauncher.features.test;
+
+import static com.android.systemui.shared.recents.utilities.Utilities.postAtFrontOfQueueAsynchronously;
+import static foundation.e.blisslauncher.core.Utilities.SINGLE_FRAME_MS;
+import static foundation.e.blisslauncher.core.Utilities.postAsyncCallback;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.annotation.TargetApi;
+import android.os.Build;
+import android.os.Handler;
+import androidx.annotation.BinderThread;
+import androidx.annotation.UiThread;
+import com.android.systemui.shared.system.RemoteAnimationRunnerCompat;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+
+@TargetApi(Build.VERSION_CODES.P)
+public abstract class LauncherAnimationRunner implements RemoteAnimationRunnerCompat {
+
+    private final Handler mHandler;
+    private final boolean mStartAtFrontOfQueue;
+    private AnimationResult mAnimationResult;
+
+    /**
+     * @param startAtFrontOfQueue If true, the animation start will be posted at the front of the
+     *                            queue to minimize latency.
+     */
+    public LauncherAnimationRunner(Handler handler, boolean startAtFrontOfQueue) {
+        mHandler = handler;
+        mStartAtFrontOfQueue = startAtFrontOfQueue;
+    }
+
+    @BinderThread
+    @Override
+    public void onAnimationStart(RemoteAnimationTargetCompat[] targetCompats, Runnable runnable) {
+        Runnable r = () -> {
+            finishExistingAnimation();
+            mAnimationResult = new AnimationResult(runnable);
+            onCreateAnimation(targetCompats, mAnimationResult);
+        };
+        if (mStartAtFrontOfQueue) {
+            postAtFrontOfQueueAsynchronously(mHandler, r);
+        } else {
+            postAsyncCallback(mHandler, r);
+        }
+    }
+
+    /**
+     * Called on the UI thread when the animation targets are received. The implementation must
+     * call {@link AnimationResult#setAnimation(AnimatorSet)} with the target animation to be run.
+     */
+    @UiThread
+    public abstract void onCreateAnimation(
+            RemoteAnimationTargetCompat[] targetCompats, AnimationResult result);
+
+    @UiThread
+    private void finishExistingAnimation() {
+        if (mAnimationResult != null) {
+            mAnimationResult.finish();
+            mAnimationResult = null;
+        }
+    }
+
+    /**
+     * Called by the system
+     */
+    @BinderThread
+    @Override
+    public void onAnimationCancelled() {
+        postAsyncCallback(mHandler, this::finishExistingAnimation);
+    }
+
+    public static final class AnimationResult {
+
+        private final Runnable mFinishRunnable;
+
+        private AnimatorSet mAnimator;
+        private boolean mFinished = false;
+        private boolean mInitialized = false;
+
+        private AnimationResult(Runnable finishRunnable) {
+            mFinishRunnable = finishRunnable;
+        }
+
+        @UiThread
+        private void finish() {
+            if (!mFinished) {
+                mFinishRunnable.run();
+                mFinished = true;
+            }
+        }
+
+        @UiThread
+        public void setAnimation(AnimatorSet animation) {
+            if (mInitialized) {
+                throw new IllegalStateException("Animation already initialized");
+            }
+            mInitialized = true;
+            mAnimator = animation;
+            if (mAnimator == null) {
+                finish();
+            } else if (mFinished) {
+                // Animation callback was already finished, skip the animation.
+                mAnimator.start();
+                mAnimator.end();
+            } else {
+                // Start the animation
+                mAnimator.addListener(new AnimatorListenerAdapter() {
+                    @Override
+                    public void onAnimationEnd(Animator animation) {
+                        finish();
+                    }
+                });
+                mAnimator.start();
+
+                // Because t=0 has the app icon in its original spot, we can skip the
+                // first frame and have the same movement one frame earlier.
+                mAnimator.setCurrentPlayTime(SINGLE_FRAME_MS);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherAppState.java b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherAppState.java
new file mode 100644
index 0000000000000000000000000000000000000000..d0c5fba970904149be7d9c51ef4f76679c175dac
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherAppState.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2013 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 foundation.e.blisslauncher.features.test;
+
+import android.content.ComponentName;
+import android.content.ContentProviderClient;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Looper;
+import android.util.Log;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.ConfigMonitor;
+import foundation.e.blisslauncher.core.SettingsObserver;
+import foundation.e.blisslauncher.core.UserManagerCompat;
+import foundation.e.blisslauncher.core.executors.MainThreadExecutor;
+import foundation.e.blisslauncher.core.utils.Preconditions;
+
+
+public class LauncherAppState {
+
+    /** Hidden field Settings.Secure.NOTIFICATION_BADGING */
+    public static final String NOTIFICATION_BADGING = "notification_badging";
+    /** Hidden field Settings.Secure.ENABLED_NOTIFICATION_LISTENERS */
+    private static final String NOTIFICATION_ENABLED_LISTENERS = "enabled_notification_listeners";
+
+    public static final String ACTION_FORCE_ROLOAD = "force-reload-launcher";
+
+    // We do not need any synchronization for this variable as its only written on UI thread.
+    private static LauncherAppState INSTANCE;
+
+    private final Context mContext;
+    private final InvariantDeviceProfile mInvariantDeviceProfile;
+
+    private final SettingsObserver mNotificationBadgingObserver;
+    private TestActivity launcher;
+
+    public static LauncherAppState getInstance(final Context context) {
+        if (INSTANCE == null) {
+            if (Looper.myLooper() == Looper.getMainLooper()) {
+                INSTANCE = new LauncherAppState(context.getApplicationContext());
+            } else {
+                try {
+                    return new MainThreadExecutor().submit(new Callable<LauncherAppState>() {
+                        @Override
+                        public LauncherAppState call() throws Exception {
+                            return LauncherAppState.getInstance(context);
+                        }
+                    }).get();
+                } catch (InterruptedException|ExecutionException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+        return INSTANCE;
+    }
+
+    public static LauncherAppState getInstanceNoCreate() {
+        return INSTANCE;
+    }
+
+    public Context getContext() {
+        return mContext;
+    }
+
+    private LauncherAppState(Context context) {
+
+        Log.v(TestActivity.TAG, "LauncherAppState initiated");
+        Preconditions.assertUIThread();
+        mContext = context;
+
+        mInvariantDeviceProfile = new InvariantDeviceProfile(mContext);
+
+        // Register intent receivers
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(Intent.ACTION_LOCALE_CHANGED);
+        // For handling managed profiles
+        filter.addAction(Intent.ACTION_MANAGED_PROFILE_ADDED);
+        filter.addAction(Intent.ACTION_MANAGED_PROFILE_REMOVED);
+        filter.addAction(Intent.ACTION_MANAGED_PROFILE_AVAILABLE);
+        filter.addAction(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE);
+        filter.addAction(Intent.ACTION_MANAGED_PROFILE_UNLOCKED);
+
+        UserManagerCompat.getInstance(mContext).enableAndResetCache();
+        new ConfigMonitor(mContext).register();
+
+        // Register an observer to rebind the notification listener when badging is re-enabled.
+        mNotificationBadgingObserver = new SettingsObserver.Secure(
+            mContext.getContentResolver()) {
+            @Override
+            public void onSettingChanged(boolean isNotificationBadgingEnabled) {
+                if (isNotificationBadgingEnabled) {
+                    // TODO: Fix this when adding notification badging.
+                    /*NotificationListener.requestRebind(new ComponentName(
+                        mContext, NotificationListener.class));*/
+                }
+            }
+        };
+        mNotificationBadgingObserver.register(NOTIFICATION_BADGING);
+    }
+
+    public void setLauncher(TestActivity launcher) {
+        this.launcher = launcher;
+    }
+
+    public TestActivity getLauncher() {
+        return launcher;
+    }
+
+    /**
+     * Call from Application.onTerminate(), which is not guaranteed to ever be called.
+     */
+    public void onTerminate() {
+        if (mNotificationBadgingObserver != null) {
+            mNotificationBadgingObserver.unregister();
+        }
+    }
+
+    public InvariantDeviceProfile getInvariantDeviceProfile() {
+        return mInvariantDeviceProfile;
+    }
+
+    /**
+     * Shorthand for {@link #getInvariantDeviceProfile()}
+     */
+    public static InvariantDeviceProfile getIDP(Context context) {
+        return LauncherAppState.getInstance(context).getInvariantDeviceProfile();
+    }
+
+
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherAppTransitionManager.java b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherAppTransitionManager.java
new file mode 100644
index 0000000000000000000000000000000000000000..4dd75e22baf3be3bc7201e2864ff3c0fca168959
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherAppTransitionManager.java
@@ -0,0 +1,66 @@
+/*
+ * 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 foundation.e.blisslauncher.features.test;
+
+import android.animation.Animator;
+import android.app.ActivityOptions;
+import android.content.Context;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.view.View;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+
+/**
+ * Manages the opening and closing app transitions from Launcher.
+ */
+public class LauncherAppTransitionManager {
+
+    public static LauncherAppTransitionManager newInstance(Context context) {
+        return Utilities.getOverrideObject(LauncherAppTransitionManager.class,
+            context, R.string.app_transition_manager_class);
+    }
+
+    public ActivityOptions getActivityLaunchOptions(TestActivity launcher, View v) {
+        int left = 0, top = 0;
+        int width = v.getMeasuredWidth(), height = v.getMeasuredHeight();
+        if (v instanceof IconTextView) {
+            // Launch from center of icon, not entire view
+            Drawable icon = ((IconTextView) v).getIcon();
+            if (icon != null) {
+                Rect bounds = icon.getBounds();
+                left = (width - bounds.width()) / 2;
+                top = v.getPaddingTop();
+                width = bounds.width();
+                height = bounds.height();
+            }
+        }
+        return ActivityOptions.makeClipRevealAnimation(v, left, top, width, height);
+    }
+
+    /**
+     * Number of animations which run on state properties.
+     */
+    public int getStateElementAnimationsCount() {
+        return 0;
+    }
+
+    public Animator createStateElementAnimation(int index, float... values) {
+        throw new RuntimeException("Unknown gesture animation " + index);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherItemMatcher.java b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherItemMatcher.java
new file mode 100644
index 0000000000000000000000000000000000000000..a40b0dd9ca32e5795a3a8a3a38a3d60b336c4415
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherItemMatcher.java
@@ -0,0 +1,134 @@
+package foundation.e.blisslauncher.features.test;
+
+import android.content.ComponentName;
+import android.os.UserHandle;
+
+import java.util.HashSet;
+
+import foundation.e.blisslauncher.core.database.model.FolderItem;
+import foundation.e.blisslauncher.core.database.model.LauncherItem;
+import foundation.e.blisslauncher.core.database.model.ShortcutItem;
+import foundation.e.blisslauncher.core.utils.Constants;
+import foundation.e.blisslauncher.core.utils.LongArrayMap;
+import foundation.e.blisslauncher.features.shortcuts.ShortcutKey;
+
+public abstract class LauncherItemMatcher {
+
+    public abstract boolean matches(LauncherItem info, ComponentName cn);
+
+    /**
+     * Filters {@param infos} to those satisfying the {@link #matches(LauncherItem, ComponentName)}.
+     */
+    public final HashSet<LauncherItem> filterItemInfos(Iterable<LauncherItem> infos) {
+        HashSet<LauncherItem> filtered = new HashSet<>();
+        for (LauncherItem i : infos) {
+            if (i instanceof ShortcutItem) {
+                ShortcutItem info = (ShortcutItem) i;
+                ComponentName cn = info.getTargetComponent();
+                if (cn != null && matches(info, cn)) {
+                    filtered.add(info);
+                }
+            } else if (i instanceof FolderItem) {
+                FolderItem info = (FolderItem) i;
+                for (LauncherItem s : info.items) {
+                    ComponentName cn = s.getTargetComponent();
+                    if (cn != null && matches(s, cn)) {
+                        filtered.add(s);
+                    }
+                }
+            }
+        }
+        return filtered;
+    }
+
+    /**
+     * Returns a new matcher with returns true if either this or {@param matcher} returns true.
+     */
+    public LauncherItemMatcher or(final LauncherItemMatcher matcher) {
+        final LauncherItemMatcher that = this;
+        return new LauncherItemMatcher() {
+            @Override
+            public boolean matches(LauncherItem info, ComponentName cn) {
+                return that.matches(info, cn) || matcher.matches(info, cn);
+            }
+        };
+    }
+
+    /**
+     * Returns a new matcher with returns true if both this and {@param matcher} returns true.
+     */
+    public LauncherItemMatcher and(final LauncherItemMatcher matcher) {
+        final LauncherItemMatcher that = this;
+        return new LauncherItemMatcher() {
+            @Override
+            public boolean matches(LauncherItem info, ComponentName cn) {
+                return that.matches(info, cn) && matcher.matches(info, cn);
+            }
+        };
+    }
+
+    /**
+     * Returns a new matcher which returns the opposite boolean value of the provided
+     * {@param matcher}.
+     */
+    public static LauncherItemMatcher not(final LauncherItemMatcher matcher) {
+        return new LauncherItemMatcher() {
+            @Override
+            public boolean matches(LauncherItem info, ComponentName cn) {
+                return !matcher.matches(info, cn);
+            }
+        };
+    }
+
+    public static LauncherItemMatcher ofUser(final UserHandle user) {
+        return new LauncherItemMatcher() {
+            @Override
+            public boolean matches(LauncherItem info, ComponentName cn) {
+                return info.user.equals(user);
+            }
+        };
+    }
+
+    public static LauncherItemMatcher ofComponents(
+        final HashSet<ComponentName> components, final UserHandle user
+    ) {
+        return new LauncherItemMatcher() {
+            @Override
+            public boolean matches(LauncherItem info, ComponentName cn) {
+                return components.contains(cn) && info.user.equals(user);
+            }
+        };
+    }
+
+    public static LauncherItemMatcher ofPackages(
+        final HashSet<String> packageNames, final UserHandle user
+    ) {
+        return new LauncherItemMatcher() {
+            @Override
+            public boolean matches(LauncherItem info, ComponentName cn) {
+                return packageNames.contains(cn.getPackageName()) && info.user.equals(user);
+            }
+        };
+    }
+
+    public static LauncherItemMatcher ofShortcutKeys(final HashSet<ShortcutKey> keys) {
+        return new LauncherItemMatcher() {
+            @Override
+            public boolean matches(LauncherItem info, ComponentName cn) {
+                return info.itemType == Constants.ITEM_TYPE_SHORTCUT &&
+                    keys.contains(ShortcutKey.fromItem(((ShortcutItem) info)));
+            }
+        };
+    }
+
+    public static LauncherItemMatcher ofItemIds(
+        final LongArrayMap<Boolean> ids, final Boolean matchDefault
+    ) {
+        return new LauncherItemMatcher() {
+            @Override
+            public boolean matches(LauncherItem info, ComponentName cn) {
+                return ids.get(info.keyId, matchDefault);
+            }
+        };
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherRootView.java b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherRootView.java
new file mode 100644
index 0000000000000000000000000000000000000000..a5982bbab591f7abb14145927268a803b5b388dc
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherRootView.java
@@ -0,0 +1,161 @@
+package foundation.e.blisslauncher.features.test;
+
+import static foundation.e.blisslauncher.features.test.SystemUiController.FLAG_DARK_NAV;
+import static foundation.e.blisslauncher.features.test.SystemUiController.UI_STATE_NORMAL;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.os.Build;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewDebug;
+import android.view.WindowInsets;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.customviews.InsettableFrameLayout;
+import java.util.Collections;
+import java.util.List;
+import org.jetbrains.annotations.Nullable;
+
+public class LauncherRootView extends InsettableFrameLayout {
+
+    private final TestActivity mLauncher;
+
+    private final Paint mOpaquePaint;
+
+    @ViewDebug.ExportedProperty(category = "launcher")
+    private final Rect mConsumedInsets = new Rect();
+
+    private static final List<Rect> SYSTEM_GESTURE_EXCLUSION_RECT =
+        Collections.singletonList(new Rect());
+
+    private View mAlignedView;
+    private WindowStateListener mWindowStateListener;
+    private boolean mDisallowBackGesture;
+
+    public LauncherRootView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+
+        mOpaquePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+        mOpaquePaint.setColor(Color.BLACK);
+        mOpaquePaint.setStyle(Paint.Style.FILL);
+
+        mLauncher = TestActivity.Companion.getLauncher(context);
+    }
+
+    @Override
+    protected void onFinishInflate() {
+        if (getChildCount() > 0) {
+            // LauncherRootView contains only one child, which should be aligned
+            // based on the horizontal insets.
+            mAlignedView = getChildAt(0);
+        }
+        super.onFinishInflate();
+    }
+
+    @Nullable
+    @Override
+    public WindowInsets onApplyWindowInsets(@Nullable WindowInsets insets) {
+        mConsumedInsets.setEmpty();
+        boolean drawInsetBar = false;
+
+        mLauncher.getSystemUiController().updateUiState(
+            UI_STATE_NORMAL, drawInsetBar ? FLAG_DARK_NAV : 0);
+
+        // Update device profile before notifying th children.
+        mLauncher.getDeviceProfile().updateInsets(insets);
+        boolean resetState = !insets.equals(insets);
+        setInsets(insets);
+
+        if (mAlignedView != null) {
+            // Apply margins on aligned view to handle consumed insets.
+            MarginLayoutParams lp = (MarginLayoutParams) mAlignedView.getLayoutParams();
+            if (lp.leftMargin != mConsumedInsets.left || lp.rightMargin != mConsumedInsets.right ||
+                lp.bottomMargin != mConsumedInsets.bottom) {
+                lp.leftMargin = mConsumedInsets.left;
+                lp.rightMargin = mConsumedInsets.right;
+                lp.topMargin = mConsumedInsets.top;
+                lp.bottomMargin = mConsumedInsets.bottom;
+                mAlignedView.setLayoutParams(lp);
+            }
+        }
+        if (resetState) {
+            mLauncher.getStateManager().reapplyState(true /* cancelCurrentAnimation */);
+        }
+
+        return insets; // I'll take it from here
+    }
+
+    @Override
+    public void setInsets(WindowInsets insets) {
+        // If the insets haven't changed, this is a no-op. Avoid unnecessary layout caused by
+        // modifying child layout params.
+        if (!insets.equals(getWindowInsets())) {
+            super.setInsets(insets);
+        }
+    }
+
+    public void dispatchInsets() {
+        mLauncher.getDeviceProfile().updateInsets(getWindowInsets());
+        super.setInsets(getWindowInsets());
+    }
+
+    @Override
+    protected void dispatchDraw(Canvas canvas) {
+        super.dispatchDraw(canvas);
+
+        // If the right inset is opaque, draw a black rectangle to ensure that is stays opaque.
+        if (mConsumedInsets.right > 0) {
+            int width = getWidth();
+            canvas.drawRect(width - mConsumedInsets.right, 0, width, getHeight(), mOpaquePaint);
+        }
+        if (mConsumedInsets.left > 0) {
+            canvas.drawRect(0, 0, mConsumedInsets.left, getHeight(), mOpaquePaint);
+        }
+        if (mConsumedInsets.bottom > 0) {
+            int height = getHeight();
+            canvas.drawRect(0, height - mConsumedInsets.bottom, getWidth(), height, mOpaquePaint);
+        }
+    }
+
+    public void setWindowStateListener(WindowStateListener listener) {
+        mWindowStateListener = listener;
+    }
+
+    @Override
+    public void onWindowFocusChanged(boolean hasWindowFocus) {
+        super.onWindowFocusChanged(hasWindowFocus);
+        if (mWindowStateListener != null) {
+            mWindowStateListener.onWindowFocusChanged(hasWindowFocus);
+        }
+    }
+
+    @Override
+    protected void onWindowVisibilityChanged(int visibility) {
+        super.onWindowVisibilityChanged(visibility);
+        if (mWindowStateListener != null) {
+            mWindowStateListener.onWindowVisibilityChanged(visibility);
+        }
+    }
+
+    @TargetApi(Build.VERSION_CODES.Q)
+    public void setDisallowBackGesture(boolean disallowBackGesture) {
+        if (!Utilities.ATLEAST_Q) {
+            return;
+        }
+        mDisallowBackGesture = disallowBackGesture;
+        setSystemGestureExclusionRects(mDisallowBackGesture
+            ? SYSTEM_GESTURE_EXCLUSION_RECT
+            : Collections.emptyList());
+    }
+
+    public interface WindowStateListener {
+
+        void onWindowFocusChanged(boolean hasFocus);
+
+        void onWindowVisibilityChanged(int visibility);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherState.java b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherState.java
new file mode 100644
index 0000000000000000000000000000000000000000..34ade972aaa745a194b514f450512886d7963740
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherState.java
@@ -0,0 +1,340 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.features.test;
+
+import static android.view.View.IMPORTANT_FOR_ACCESSIBILITY_AUTO;
+import static android.view.View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS;
+import static android.view.View.VISIBLE;
+import static android.view.accessibility.AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED;
+import static foundation.e.blisslauncher.features.test.RotationHelper.REQUEST_NONE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_FADE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_SCALE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_TRANSLATE_X;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_WORKSPACE_FADE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_WORKSPACE_SCALE;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.ACCEL;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.ACCEL_2;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.DEACCEL;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.DEACCEL_1_7;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.clampToProgress;
+
+import android.graphics.Rect;
+import android.view.animation.Interpolator;
+import foundation.e.blisslauncher.core.customviews.LauncherPagedView;
+import foundation.e.blisslauncher.features.launcher.Hotseat;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+import foundation.e.blisslauncher.uioverrides.UiFactory;
+import foundation.e.blisslauncher.uioverrides.states.OverviewState;
+import java.util.Arrays;
+
+/**
+ * Base state for various states used for the Launcher
+ */
+public class LauncherState {
+
+
+    /**
+     * Set of elements indicating various workspace elements which change visibility across states
+     * Note that workspace is not included here as in that case, we animate individual pages
+     */
+    public static final int NONE = 0;
+    public static final int HOTSEAT_ICONS = 1 << 0;
+    public static final int RECENTS_CLEAR_ALL_BUTTON = 1 << 1;
+
+    protected static final int FLAG_MULTI_PAGE = 1 << 0;
+    protected static final int FLAG_DISABLE_ACCESSIBILITY = 1 << 1;
+    protected static final int FLAG_DISABLE_RESTORE = 1 << 2;
+    protected static final int FLAG_WORKSPACE_ICONS_CAN_BE_DRAGGED = 1 << 3;
+    protected static final int FLAG_DISABLE_PAGE_CLIPPING = 1 << 4;
+    protected static final int FLAG_PAGE_BACKGROUNDS = 1 << 5;
+    protected static final int FLAG_DISABLE_INTERACTION = 1 << 6;
+    protected static final int FLAG_OVERVIEW_UI = 1 << 7;
+    protected static final int FLAG_HIDE_BACK_BUTTON = 1 << 8;
+    protected static final int FLAG_HAS_SYS_UI_SCRIM = 1 << 9;
+
+
+    public static final int OVERVIEW_STATE_ORDINAL = 1;
+    public static final int OVERVIEW_PEEK_STATE_ORDINAL = 2;
+    public static final int QUICK_SWITCH_STATE_ORDINAL = 3;
+    public static final int BACKGROUND_APP_STATE_ORDINAL = 4;
+
+    protected static final PageAlphaProvider DEFAULT_ALPHA_PROVIDER =
+            new PageAlphaProvider(ACCEL_2) {
+                @Override
+                public float getPageAlpha(int pageIndex) {
+                    return 1;
+                }
+            };
+
+    private static final LauncherState[] sAllStates = new LauncherState[5];
+
+    /**
+     * TODO: Create a separate class for NORMAL state.
+     */
+    public static final LauncherState NORMAL = new LauncherState(0, 0,
+            FLAG_DISABLE_RESTORE | FLAG_WORKSPACE_ICONS_CAN_BE_DRAGGED | FLAG_HIDE_BACK_BUTTON |
+            FLAG_HAS_SYS_UI_SCRIM);
+
+    /**
+     * Various Launcher states arranged in the increasing order of UI layers
+     */
+    public static final LauncherState OVERVIEW = new OverviewState(OVERVIEW_STATE_ORDINAL);
+    public static final LauncherState OVERVIEW_PEEK =
+        OverviewState.newPeekState(OVERVIEW_PEEK_STATE_ORDINAL);
+    public static final LauncherState QUICK_SWITCH =
+        OverviewState.newSwitchState(QUICK_SWITCH_STATE_ORDINAL);
+    public static final LauncherState BACKGROUND_APP =
+        OverviewState.newBackgroundState(BACKGROUND_APP_STATE_ORDINAL);
+
+    protected static final Rect sTempRect = new Rect();
+
+    public final int ordinal;
+
+    /**
+     * True if the state can be persisted across activity restarts.
+     */
+    public final boolean disableRestore;
+
+    /**
+     * True if workspace has multiple pages visible.
+     */
+    public final boolean hasMultipleVisiblePages;
+
+    /**
+     * Accessibility flag for workspace and its pages.
+     * @see android.view.View#setImportantForAccessibility(int)
+     */
+    public final int workspaceAccessibilityFlag;
+
+    /**
+     * Properties related to state transition animation
+     *
+     */
+    public final boolean hasWorkspacePageBackground;
+
+    public final int transitionDuration;
+
+    /**
+     * True if the state allows workspace icons to be dragged.
+     */
+    public final boolean workspaceIconsCanBeDragged;
+
+    /**
+     * True if the workspace pages should not be clipped relative to the workspace bounds
+     * for this state.
+     */
+    public final boolean disablePageClipping;
+
+    /**
+     * True if launcher can not be directly interacted in this state;
+     */
+    public final boolean disableInteraction;
+
+    /**
+     * True if the state has overview panel visible.
+     */
+    public final boolean overviewUi;
+
+    /**
+     * True if the back button should be hidden when in this state (assuming no floating views are
+     * open, launcher has window focus, etc).
+     */
+    public final boolean hideBackButton;
+
+    public final boolean hasSysUiScrim;
+
+    public LauncherState(int id, int transitionDuration, int flags) {
+        this.transitionDuration = transitionDuration;
+
+        this.hasWorkspacePageBackground = (flags & FLAG_PAGE_BACKGROUNDS) != 0;
+        this.hasMultipleVisiblePages = (flags & FLAG_MULTI_PAGE) != 0;
+        this.workspaceAccessibilityFlag = (flags & FLAG_DISABLE_ACCESSIBILITY) != 0
+                ? IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+                : IMPORTANT_FOR_ACCESSIBILITY_AUTO;
+        this.disableRestore = (flags & FLAG_DISABLE_RESTORE) != 0;
+        this.workspaceIconsCanBeDragged = (flags & FLAG_WORKSPACE_ICONS_CAN_BE_DRAGGED) != 0;
+        this.disablePageClipping = (flags & FLAG_DISABLE_PAGE_CLIPPING) != 0;
+        this.disableInteraction = (flags & FLAG_DISABLE_INTERACTION) != 0;
+        this.overviewUi = (flags & FLAG_OVERVIEW_UI) != 0;
+        this.hideBackButton = (flags & FLAG_HIDE_BACK_BUTTON) != 0;
+        this.hasSysUiScrim = (flags & FLAG_HAS_SYS_UI_SCRIM) != 0;
+
+        this.ordinal = id;
+        sAllStates[id] = this;
+    }
+
+    public static LauncherState[] values() {
+        return Arrays.copyOf(sAllStates, sAllStates.length);
+    }
+
+    public ScaleAndTranslation getHotseatScaleAndTranslation(TestActivity launcher) {
+        // For most states, treat the hotseat as if it were part of the workspace.
+        return getWorkspaceScaleAndTranslation(launcher);
+    }
+
+    public ScaleAndTranslation getWorkspaceScaleAndTranslation(TestActivity launcher) {
+        return new ScaleAndTranslation(1f, 0f, 0f);
+    }
+
+    /**
+     * Returns 2 floats designating how to transition overview:
+     *   scale for the current and adjacent pages
+     *   translationY factor where 0 is top aligned and 0.5 is centered vertically
+     */
+    public float[] getOverviewScaleAndTranslationYFactor(TestActivity launcher) {
+        return new float[] {1.1f, 0f};
+    }
+
+    public void onStateEnabled(TestActivity launcher) {
+        dispatchWindowStateChanged(launcher);
+    }
+
+    public void onStateDisabled(TestActivity launcher) { }
+
+    public int getVisibleElements(TestActivity launcher) {
+        // TODO: Uncomment when supporting landscape mode.
+        /*if (launcher.getDeviceProfile().isVerticalBarLayout()) {
+            return HOTSEAT_ICONS | VERTICAL_SWIPE_INDICATOR;
+        }*/
+        return HOTSEAT_ICONS;
+    }
+
+    public float getVerticalProgress(TestActivity launcher) {
+        return 1f;
+    }
+
+    public float getWorkspaceScrimAlpha(TestActivity launcher) {
+        return 0;
+    }
+
+    public String getDescription(TestActivity launcher) {
+        return launcher.getLauncherPagedView().getCurrentPageDescription();
+    }
+
+    public ScaleAndTranslation getOverviewScaleAndTranslation(TestActivity launcher) {
+        return UiFactory.getOverviewScaleAndTranslationForNormalState(launcher);
+    }
+
+    public PageAlphaProvider getWorkspacePageAlphaProvider(TestActivity launcher) {
+        //TODO: Enable this when supporting landscape mode.
+        /*if (this != NORMAL || !launcher.getDeviceProfile().shouldFadeAdjacentWorkspaceScreens()) {
+            return DEFAULT_ALPHA_PROVIDER;
+        }*/
+        if (this != NORMAL) {
+            return DEFAULT_ALPHA_PROVIDER;
+        }
+        final int centerPage = launcher.getLauncherPagedView().getNextPage();
+        return new PageAlphaProvider(ACCEL_2) {
+            @Override
+            public float getPageAlpha(int pageIndex) {
+                return  pageIndex != centerPage ? 0 : 1f;
+            }
+        };
+    }
+
+    public LauncherState getHistoryForState(LauncherState previousState) {
+        // No history is supported
+        return NORMAL;
+    }
+
+    /**
+     * Called when the start transition ends and the user settles on this particular state.
+     */
+    public void onStateTransitionEnd(TestActivity launcher) {
+        if (this == NORMAL) {
+            // Clear any rotation locks when going to normal state
+            launcher.getRotationHelper().setCurrentStateRequest(REQUEST_NONE);
+        }
+    }
+
+    protected static void dispatchWindowStateChanged(TestActivity launcher) {
+        launcher.getWindow().getDecorView().sendAccessibilityEvent(TYPE_WINDOW_STATE_CHANGED);
+    }
+
+    public void onBackPressed(TestActivity launcher) {
+        if (this != NORMAL) {
+            LauncherStateManager lsm = launcher.getStateManager();
+            LauncherState lastState = lsm.getLastState();
+            lsm.goToState(lastState);
+        }
+    }
+
+    /**
+     * Prepares for a non-user controlled animation from fromState to this state. Preparations
+     * include:
+     * - Setting interpolators for various animations included in the state transition.
+     * - Setting some start values (e.g. scale) for views that are hidden but about to be shown.
+     */
+    public void prepareForAtomicAnimation(TestActivity launcher, LauncherState fromState,
+        AnimatorSetBuilder builder) {
+        if (this == NORMAL && fromState == OVERVIEW) {
+            builder.setInterpolator(ANIM_WORKSPACE_SCALE, DEACCEL);
+            builder.setInterpolator(ANIM_WORKSPACE_FADE, ACCEL);
+            builder.setInterpolator(ANIM_OVERVIEW_SCALE, clampToProgress(ACCEL, 0, 0.9f));
+            builder.setInterpolator(ANIM_OVERVIEW_TRANSLATE_X, ACCEL);
+            builder.setInterpolator(ANIM_OVERVIEW_FADE, DEACCEL_1_7);
+            LauncherPagedView workspace = launcher.getLauncherPagedView();
+
+            // Start from a higher workspace scale, but only if we're invisible so we don't jump.
+            boolean isWorkspaceVisible = workspace.getVisibility() == VISIBLE;
+            if (isWorkspaceVisible) {
+                CellLayout currentChild = (CellLayout) workspace.getChildAt(
+                    workspace.getCurrentPage());
+                isWorkspaceVisible = currentChild.getVisibility() == VISIBLE;
+            }
+            if (!isWorkspaceVisible) {
+                workspace.setScaleX(0.92f);
+                workspace.setScaleY(0.92f);
+            }
+            Hotseat hotseat = launcher.getHotseat();
+            boolean isHotseatVisible = hotseat.getVisibility() == VISIBLE && hotseat.getAlpha() > 0;
+            if (!isHotseatVisible) {
+                hotseat.setScaleX(0.92f);
+                hotseat.setScaleY(0.92f);
+            }
+        } else if (this == NORMAL && fromState == OVERVIEW_PEEK) {
+            // Keep fully visible until the very end (when overview is offscreen) to make invisible.
+            builder.setInterpolator(ANIM_OVERVIEW_FADE, t -> t < 1 ? 0 : 1);
+        }
+    }
+
+    public float getOverviewFullscreenProgress() {
+        return 0;
+    }
+
+    public static abstract class PageAlphaProvider {
+
+        public final Interpolator interpolator;
+
+        public PageAlphaProvider(Interpolator interpolator) {
+            this.interpolator = interpolator;
+        }
+
+        public abstract float getPageAlpha(int pageIndex);
+    }
+
+    public static class ScaleAndTranslation {
+        public float scale;
+        public float translationX;
+        public float translationY;
+
+        public ScaleAndTranslation(float scale, float translationX, float translationY) {
+            this.scale = scale;
+            this.translationX = translationX;
+            this.translationY = translationY;
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherStateManager.java b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherStateManager.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3df2c5b281715da4ab8061d8349e4c582ba8f13
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/LauncherStateManager.java
@@ -0,0 +1,624 @@
+/*
+ * Copyright (C) 2015 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 foundation.e.blisslauncher.features.test;
+
+import static foundation.e.blisslauncher.features.test.LauncherState.NORMAL;
+import static foundation.e.blisslauncher.features.test.anim.PropertySetter.NO_ANIM_PROPERTY_SETTER;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.os.Handler;
+import android.os.Looper;
+import androidx.annotation.IntDef;
+import foundation.e.blisslauncher.features.test.anim.AnimationSuccessListener;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+import foundation.e.blisslauncher.features.test.anim.PropertySetter;
+import foundation.e.blisslauncher.uioverrides.UiFactory;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+
+/**
+ * TODO: figure out what kind of tests we can write for this
+ *
+ * Things to test when changing the following class.
+ *   - Home from workspace
+ *          - from center screen
+ *          - from other screens
+ *   - Home from all apps
+ *          - from center screen
+ *          - from other screens
+ *   - Back from all apps
+ *          - from center screen
+ *          - from other screens
+ *   - Launch app from workspace and quit
+ *          - with back
+ *          - with home
+ *   - Launch app from all apps and quit
+ *          - with back
+ *          - with home
+ *   - Go to a screen that's not the default, then all
+ *     apps, and launch and app, and go back
+ *          - with back
+ *          -with home
+ *   - On workspace, long press power and go back
+ *          - with back
+ *          - with home
+ *   - On all apps, long press power and go back
+ *          - with back
+ *          - with home
+ *   - On workspace, power off
+ *   - On all apps, power off
+ *   - Launch an app and turn off the screen while in that app
+ *          - Go back with home key
+ *          - Go back with back key  TODO: make this not go to workspace
+ *          - From all apps
+ *          - From workspace
+ *   - Enter and exit car mode (becase it causes an extra configuration changed)
+ *          - From all apps
+ *          - From the center workspace
+ *          - From another workspace
+ */
+public class LauncherStateManager {
+
+    public static final String TAG = "StateManager";
+
+
+    // We separate the state animations into "atomic" and "non-atomic" components. The atomic
+    // components may be run atomically - that is, all at once, instead of user-controlled. However,
+    // atomic components are not restricted to this purpose; they can be user-controlled alongside
+    // non atomic components as well.
+    @IntDef(flag = true, value = {
+            NON_ATOMIC_COMPONENT,
+            ATOMIC_OVERVIEW_PEEK_COMPONENT,
+        ATOMIC_OVERVIEW_SCALE_COMPONENT
+    })
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface AnimationComponents {}
+    public static final int NON_ATOMIC_COMPONENT = 1 << 0;
+    public static final int ATOMIC_OVERVIEW_SCALE_COMPONENT = 1 << 1;
+    public static final int ATOMIC_OVERVIEW_PEEK_COMPONENT = 1 << 2;
+
+    public static final int ANIM_ALL = NON_ATOMIC_COMPONENT | ATOMIC_OVERVIEW_PEEK_COMPONENT | ATOMIC_OVERVIEW_SCALE_COMPONENT;
+
+    private final AnimationConfig mConfig = new AnimationConfig();
+    private final Handler mUiHandler;
+    private final TestActivity mLauncher;
+    private final ArrayList<StateListener> mListeners = new ArrayList<>();
+
+    // Animators which are run on properties also controlled by state animations.
+    private Animator[] mStateElementAnimators;
+
+    private StateHandler[] mStateHandlers;
+    private LauncherState mState = NORMAL;
+
+    private LauncherState mLastStableState = NORMAL;
+    private LauncherState mCurrentStableState = NORMAL;
+
+    private LauncherState mRestState;
+
+    public LauncherStateManager(TestActivity l) {
+        mUiHandler = new Handler(Looper.getMainLooper());
+        mLauncher = l;
+    }
+
+    public LauncherState getState() {
+        return mState;
+    }
+
+    public StateHandler[] getStateHandlers() {
+        if (mStateHandlers == null) {
+            mStateHandlers = UiFactory.getStateHandler(mLauncher);
+        }
+        return mStateHandlers;
+    }
+
+    public void addStateListener(StateListener listener) {
+        mListeners.add(listener);
+    }
+
+    public void removeStateListener(StateListener listener) {
+        mListeners.remove(listener);
+    }
+
+    /**
+     * Returns true if the state changes should be animated.
+     */
+    public boolean shouldAnimateStateChange() {
+        return !mLauncher.isForceInvisible() && mLauncher.isStarted();
+    }
+
+    /**
+     * @see #goToState(LauncherState, boolean, Runnable)
+     */
+    public void goToState(LauncherState state) {
+        goToState(state, !mLauncher.isForceInvisible() && mLauncher.isStarted() /* animated */);
+    }
+
+    /**
+     * @see #goToState(LauncherState, boolean, Runnable)
+     */
+    public void goToState(LauncherState state, boolean animated) {
+        goToState(state, animated, 0, null);
+    }
+
+    /**
+     * Changes the Launcher state to the provided state.
+     *
+     * @param animated false if the state should change immediately without any animation,
+     *                true otherwise
+     * @paras onCompleteRunnable any action to perform at the end of the transition, of null.
+     */
+    public void goToState(LauncherState state, boolean animated, Runnable onCompleteRunnable) {
+        goToState(state, animated, 0, onCompleteRunnable);
+    }
+
+    /**
+     * Changes the Launcher state to the provided state after the given delay.
+     */
+    public void goToState(LauncherState state, long delay, Runnable onCompleteRunnable) {
+        goToState(state, true, delay, onCompleteRunnable);
+    }
+
+    /**
+     * Changes the Launcher state to the provided state after the given delay.
+     */
+    public void goToState(LauncherState state, long delay) {
+        goToState(state, true, delay, null);
+    }
+
+    public void reapplyState() {
+        reapplyState(false);
+    }
+
+    public void reapplyState(boolean cancelCurrentAnimation) {
+        if (cancelCurrentAnimation) {
+            cancelAnimation();
+        }
+        if (mConfig.mCurrentAnimation == null) {
+            for (StateHandler handler : getStateHandlers()) {
+                handler.setState(mState);
+            }
+        }
+    }
+
+    private void goToState(LauncherState state, boolean animated, long delay,
+            final Runnable onCompleteRunnable) {
+        if (mLauncher.isInState(state)) {
+            if (mConfig.mCurrentAnimation == null) {
+                // Run any queued runnable
+                if (onCompleteRunnable != null) {
+                    onCompleteRunnable.run();
+                }
+                return;
+            } else if (!mConfig.userControlled && animated && mConfig.mTargetState == state) {
+                // We are running the same animation as requested
+                if (onCompleteRunnable != null) {
+                    mConfig.mCurrentAnimation.addListener(new AnimationSuccessListener() {
+                        @Override
+                        public void onAnimationSuccess(Animator animator) {
+                            onCompleteRunnable.run();
+                        }
+                    });
+                }
+                return;
+            }
+        }
+
+        // Cancel the current animation. This will reset mState to mCurrentStableState, so store it.
+        LauncherState fromState = mState;
+        mConfig.reset();
+
+        if (!animated) {
+            cancelAllStateElementAnimation();
+            onStateTransitionStart(state);
+            for (StateHandler handler : getStateHandlers()) {
+                handler.setState(state);
+            }
+
+            onStateTransitionEnd(state);
+
+            // Run any queued runnable
+            if (onCompleteRunnable != null) {
+                onCompleteRunnable.run();
+            }
+            return;
+        }
+        if (delay > 0) {
+            // Create the animation after the delay as some properties can change between preparing
+            // the animation and running the animation.
+            int startChangeId = mConfig.mChangeId;
+            mUiHandler.postDelayed(() -> {
+                if (mConfig.mChangeId == startChangeId) {
+                    goToStateAnimated(state, fromState, onCompleteRunnable);
+                }
+            }, delay);
+        } else {
+            goToStateAnimated(state, fromState, onCompleteRunnable);
+        }
+    }
+
+    private void goToStateAnimated(LauncherState state, LauncherState fromState,
+        Runnable onCompleteRunnable) {
+        // Since state NORMAL can be reached from multiple states, just assume that the
+        // transition plays in reverse and use the same duration as previous state.
+        mConfig.duration = state == NORMAL ? fromState.transitionDuration : state.transitionDuration;
+
+        AnimatorSetBuilder builder = new AnimatorSetBuilder();
+        prepareForAtomicAnimation(fromState, state, builder);
+        AnimatorSet animation = createAnimationToNewWorkspaceInternal(
+            state, builder, onCompleteRunnable);
+        mUiHandler.post(new StartAnimRunnable(animation));
+    }
+
+    /**
+     * Prepares for a non-user controlled animation from fromState to toState. Preparations include:
+     * - Setting interpolators for various animations included in the state transition.
+     * - Setting some start values (e.g. scale) for views that are hidden but about to be shown.
+     */
+    public void prepareForAtomicAnimation(LauncherState fromState, LauncherState toState,
+        AnimatorSetBuilder builder) {
+        toState.prepareForAtomicAnimation(mLauncher, fromState, builder);
+    }
+
+    public AnimatorSet createAtomicAnimation(LauncherState fromState, LauncherState toState,
+        AnimatorSetBuilder builder, @AnimationComponents int atomicComponent, long duration) {
+        prepareForAtomicAnimation(fromState, toState, builder);
+        AnimationConfig config = new AnimationConfig();
+        config.animComponents = atomicComponent;
+        config.duration = duration;
+        for (StateHandler handler : mLauncher.getStateManager().getStateHandlers()) {
+            handler.setStateWithAnimation(toState, builder, config);
+        }
+        return builder.build();
+    }
+
+    /**
+     * Creates a {@link AnimatorPlaybackController} that can be used for a controlled
+     * state transition.
+     * @param state the final state for the transition.
+     * @param duration intended duration for normal playback. Use higher duration for better
+     *                accuracy.
+     */
+    public AnimatorPlaybackController createAnimationToNewWorkspace(
+            LauncherState state, long duration) {
+        return createAnimationToNewWorkspace(state, duration, LauncherStateManager.ANIM_ALL);
+    }
+
+    public AnimatorPlaybackController createAnimationToNewWorkspace(
+            LauncherState state, long duration, @AnimationComponents int animComponents) {
+        return createAnimationToNewWorkspace(state, new AnimatorSetBuilder(), duration, null,
+                animComponents);
+    }
+
+    public AnimatorPlaybackController createAnimationToNewWorkspace(LauncherState state,
+            AnimatorSetBuilder builder, long duration, Runnable onCancelRunnable,
+            @AnimationComponents int animComponents) {
+        mConfig.reset();
+        mConfig.userControlled = true;
+        mConfig.animComponents = animComponents;
+        mConfig.duration = duration;
+        mConfig.playbackController = AnimatorPlaybackController.wrap(
+                createAnimationToNewWorkspaceInternal(state, builder, null), duration,
+                onCancelRunnable);
+        return mConfig.playbackController;
+    }
+
+    protected AnimatorSet createAnimationToNewWorkspaceInternal(final LauncherState state,
+            AnimatorSetBuilder builder, final Runnable onCompleteRunnable) {
+
+        for (StateHandler handler : getStateHandlers()) {
+            builder.startTag(handler);
+            handler.setStateWithAnimation(state, builder, mConfig);
+        }
+
+        final AnimatorSet animation = builder.build();
+        animation.addListener(new AnimationSuccessListener() {
+
+            @Override
+            public void onAnimationStart(Animator animation) {
+                // Change the internal state only when the transition actually starts
+                onStateTransitionStart(state);
+                for (int i = mListeners.size() - 1; i >= 0; i--) {
+                    mListeners.get(i).onStateTransitionStart(state);
+                }
+            }
+
+            @Override
+            public void onAnimationCancel(Animator animation) {
+                super.onAnimationCancel(animation);
+                mState = mCurrentStableState;
+            }
+
+            @Override
+            public void onAnimationSuccess(Animator animator) {
+                // Run any queued runnables
+                if (onCompleteRunnable != null) {
+                    onCompleteRunnable.run();
+                }
+                onStateTransitionEnd(state);
+                for (int i = mListeners.size() - 1; i >= 0; i--) {
+                    mListeners.get(i).onStateTransitionComplete(state);
+                }
+            }
+        });
+        mConfig.setAnimation(animation, state);
+        return mConfig.mCurrentAnimation;
+    }
+
+    private void onStateTransitionStart(LauncherState state) {
+        mState.onStateDisabled(mLauncher);
+        mState = state;
+        mState.onStateEnabled(mLauncher);
+
+        if (state.disablePageClipping) {
+            // Only disable clipping if needed, otherwise leave it as previous value.
+            mLauncher.getLauncherPagedView().setClipChildren(false);
+        }
+        UiFactory.onLauncherStateOrResumeChanged(mLauncher);
+    }
+
+    private void onStateTransitionEnd(LauncherState state) {
+        // Only change the stable states after the transitions have finished
+        if (state != mCurrentStableState) {
+            mLastStableState = state.getHistoryForState(mCurrentStableState);
+            mCurrentStableState = state;
+        }
+
+        state.onStateTransitionEnd(mLauncher);
+        mLauncher.getLauncherPagedView().setClipChildren(!state.disablePageClipping);
+        mLauncher.finishAutoCancelActionMode();
+
+        if (state == NORMAL) {
+            setRestState(null);
+        }
+
+        UiFactory.onLauncherStateOrResumeChanged(mLauncher);
+
+        mLauncher.getDragLayer().requestFocus();
+    }
+
+    public void onWindowFocusChanged() {
+        UiFactory.onLauncherStateOrFocusChanged(mLauncher);
+    }
+
+    public LauncherState getLastState() {
+        return mLastStableState;
+    }
+
+    public void moveToRestState() {
+        if (mConfig.mCurrentAnimation != null && mConfig.userControlled) {
+            // The user is doing something. Lets not mess it up
+            return;
+        }
+        if (mState.disableRestore) {
+            goToState(getRestState());
+            // Reset history
+            mLastStableState = NORMAL;
+        }
+    }
+
+    public LauncherState getRestState() {
+        return mRestState == null ? NORMAL : mRestState;
+    }
+
+    public void setRestState(LauncherState restState) {
+        mRestState = restState;
+    }
+
+    /**
+     * Cancels the current animation.
+     */
+    public void cancelAnimation() {
+        mConfig.reset();
+    }
+
+    public void setCurrentUserControlledAnimation(AnimatorPlaybackController controller) {
+        setCurrentAnimation(controller.getTarget());
+        mConfig.userControlled = true;
+        mConfig.playbackController = controller;
+    }
+
+    /**
+     * Sets the animation as the current state animation, i.e., canceled when
+     * starting another animation and may block some launcher interactions while running.
+     *
+     * @param childAnimations Set of animations with the new target is controlling.
+     */
+    public void setCurrentAnimation(AnimatorSet anim, Animator... childAnimations) {
+        for (Animator childAnim : childAnimations) {
+            if (childAnim == null) {
+                continue;
+            }
+            if (mConfig.playbackController != null
+                    && mConfig.playbackController.getTarget() == childAnim) {
+                clearCurrentAnimation();
+                break;
+            } else if (mConfig.mCurrentAnimation == childAnim) {
+                clearCurrentAnimation();
+                break;
+            }
+        }
+        boolean reapplyNeeded = mConfig.mCurrentAnimation != null;
+        cancelAnimation();
+        if (reapplyNeeded) {
+            reapplyState();
+        }
+        mConfig.setAnimation(anim, null);
+    }
+
+    private void clearCurrentAnimation() {
+        if (mConfig.mCurrentAnimation != null) {
+            mConfig.mCurrentAnimation.removeListener(mConfig);
+            mConfig.mCurrentAnimation = null;
+        }
+        mConfig.playbackController = null;
+    }
+
+    private class StartAnimRunnable implements Runnable {
+
+        private final AnimatorSet mAnim;
+
+        public StartAnimRunnable(AnimatorSet anim) {
+            mAnim = anim;
+        }
+
+        @Override
+        public void run() {
+            if (mConfig.mCurrentAnimation != mAnim) {
+                return;
+            }
+            mAnim.start();
+        }
+    }
+
+    private void cancelAllStateElementAnimation() {
+        if (mStateElementAnimators == null) {
+            return;
+        }
+
+        for (Animator animator : mStateElementAnimators) {
+            if (animator != null) {
+                animator.cancel();
+            }
+        }
+    }
+
+    /**
+     * Cancels a currently running gesture animation
+     */
+    public void cancelStateElementAnimation(int index) {
+        if (mStateElementAnimators == null) {
+            return;
+        }
+        if (mStateElementAnimators[index] != null) {
+            mStateElementAnimators[index].cancel();
+        }
+    }
+
+    public Animator createStateElementAnimation(int index, float... values) {
+        cancelStateElementAnimation(index);
+        LauncherAppTransitionManager latm = mLauncher.getAppTransitionManager();
+        if (mStateElementAnimators == null) {
+            mStateElementAnimators = new Animator[latm.getStateElementAnimationsCount()];
+        }
+        Animator anim = latm.createStateElementAnimation(index, values);
+        mStateElementAnimators[index] = anim;
+        anim.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mStateElementAnimators[index] = null;
+            }
+        });
+        return anim;
+    }
+
+    public static class AnimationConfig extends AnimatorListenerAdapter {
+        public long duration;
+        public boolean userControlled;
+        public AnimatorPlaybackController playbackController;
+        public @AnimationComponents int animComponents = ANIM_ALL;
+        private PropertySetter mPropertySetter;
+
+        private AnimatorSet mCurrentAnimation;
+        private LauncherState mTargetState;
+
+        // Id to keep track of config changes, to tie an animation with the corresponding request
+        private int mChangeId = 0;
+
+        /**
+         * Cancels the current animation and resets config variables.
+         */
+        public void reset() {
+            duration = 0;
+            userControlled = false;
+            animComponents = ANIM_ALL;
+            mPropertySetter = null;
+            mTargetState = null;
+
+            if (playbackController != null) {
+                playbackController.getAnimationPlayer().cancel();
+                playbackController.dispatchOnCancel();
+            } else if (mCurrentAnimation != null) {
+                mCurrentAnimation.setDuration(0);
+                mCurrentAnimation.cancel();
+            }
+
+            mCurrentAnimation = null;
+            playbackController = null;
+            mChangeId++;
+        }
+
+        public PropertySetter getPropertySetter(AnimatorSetBuilder builder) {
+            if (mPropertySetter == null) {
+                mPropertySetter = duration == 0 ? NO_ANIM_PROPERTY_SETTER
+                        : new PropertySetter.AnimatedPropertySetter(duration, builder);
+            }
+            return mPropertySetter;
+        }
+
+        @Override
+        public void onAnimationEnd(Animator animation) {
+            if (playbackController != null && playbackController.getTarget() == animation) {
+                playbackController = null;
+            }
+            if (mCurrentAnimation == animation) {
+                mCurrentAnimation = null;
+            }
+        }
+
+        public void setAnimation(AnimatorSet animation, LauncherState targetState) {
+            mCurrentAnimation = animation;
+            mTargetState = targetState;
+            mCurrentAnimation.addListener(this);
+        }
+
+        public boolean playAtomicOverviewScaleComponent() {
+            return (animComponents & ATOMIC_OVERVIEW_SCALE_COMPONENT) != 0;
+        }
+
+        public boolean playAtomicOverviewPeekComponent() {
+            return (animComponents & ATOMIC_OVERVIEW_PEEK_COMPONENT) != 0;
+        }
+
+        public boolean playNonAtomicComponent() {
+            return (animComponents & NON_ATOMIC_COMPONENT) != 0;
+        }
+    }
+
+    public interface StateHandler {
+
+        /**
+         * Updates the UI to {@param state} without any animations
+         */
+        void setState(LauncherState state);
+
+        /**
+         * Sets the UI to {@param state} by animating any changes.
+         */
+        void setStateWithAnimation(LauncherState toState,
+                AnimatorSetBuilder builder, AnimationConfig config);
+    }
+
+    public interface StateListener {
+
+        void onStateTransitionStart(LauncherState toState);
+        void onStateTransitionComplete(LauncherState finalState);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/OnAlarmListener.java b/app/src/main/java/foundation/e/blisslauncher/features/test/OnAlarmListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..09d4f198c18a24e9f3a03a2bd203ee87635d994a
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/OnAlarmListener.java
@@ -0,0 +1,5 @@
+package foundation.e.blisslauncher.features.test;
+
+public interface OnAlarmListener {
+    public void onAlarm(Alarm alarm);
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/RotationHelper.java b/app/src/main/java/foundation/e/blisslauncher/features/test/RotationHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..190930eabbc1041a45bf0fb191cd7565b0784de6
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/RotationHelper.java
@@ -0,0 +1,174 @@
+/*
+ * 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 foundation.e.blisslauncher.features.test;
+
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LOCKED;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_NOSENSOR;
+import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
+import static android.util.DisplayMetrics.DENSITY_DEVICE_STABLE;
+
+import android.app.Activity;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.content.res.Resources;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+
+/**
+ * Utility class to manage launcher rotation
+ */
+public class RotationHelper implements OnSharedPreferenceChangeListener {
+
+    public static final String ALLOW_ROTATION_PREFERENCE_KEY = "pref_allowRotation";
+
+    public static boolean getAllowRotationDefaultValue() {
+        // If the device was scaled, used the original dimensions to determine if rotation
+        // is allowed of not.
+        Resources res = Resources.getSystem();
+        int originalSmallestWidth = res.getConfiguration().smallestScreenWidthDp
+            * res.getDisplayMetrics().densityDpi / DENSITY_DEVICE_STABLE;
+        return originalSmallestWidth >= 600;
+    }
+
+    public static final int REQUEST_NONE = 0;
+    public static final int REQUEST_ROTATE = 1;
+    public static final int REQUEST_LOCK = 2;
+
+    private final Activity mActivity;
+    private final SharedPreferences mPrefs;
+
+    private final boolean mIgnoreAutoRotateSettings;
+    private boolean mAutoRotateEnabled;
+
+    /**
+     * Rotation request made by {@link InternalStateHandler}. This supersedes any other request.
+     */
+    private int mStateHandlerRequest = REQUEST_NONE;
+    /**
+     * Rotation request made by an app transition
+     */
+    private int mCurrentTransitionRequest = REQUEST_NONE;
+    /**
+     * Rotation request made by a Launcher State
+     */
+    private int mCurrentStateRequest = REQUEST_NONE;
+
+    // This is used to defer setting rotation flags until the activity is being created
+    private boolean mInitialized;
+    public boolean mDestroyed;
+    private boolean mRotationHasDifferentUI;
+
+    private int mLastActivityFlags = -1;
+
+    public RotationHelper(Activity activity) {
+        mActivity = activity;
+
+        // On large devices we do not handle auto-rotate differently.
+        mIgnoreAutoRotateSettings = mActivity.getResources().getBoolean(R.bool.allow_rotation);
+        if (!mIgnoreAutoRotateSettings) {
+            mPrefs = Utilities.getPrefs(mActivity);
+            mPrefs.registerOnSharedPreferenceChangeListener(this);
+            mAutoRotateEnabled = mPrefs.getBoolean(ALLOW_ROTATION_PREFERENCE_KEY,
+                    getAllowRotationDefaultValue());
+        } else {
+            mPrefs = null;
+        }
+    }
+
+    public void setRotationHadDifferentUI(boolean rotationHasDifferentUI) {
+        mRotationHasDifferentUI = rotationHasDifferentUI;
+    }
+
+    @Override
+    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String s) {
+        mAutoRotateEnabled = mPrefs.getBoolean(ALLOW_ROTATION_PREFERENCE_KEY,
+                getAllowRotationDefaultValue());
+        notifyChange();
+    }
+
+    public void setStateHandlerRequest(int request) {
+        if (mStateHandlerRequest != request) {
+            mStateHandlerRequest = request;
+            notifyChange();
+        }
+    }
+
+    public void setCurrentTransitionRequest(int request) {
+        if (mCurrentTransitionRequest != request) {
+            mCurrentTransitionRequest = request;
+            notifyChange();
+        }
+    }
+
+    public void setCurrentStateRequest(int request) {
+        if (mCurrentStateRequest != request) {
+            mCurrentStateRequest = request;
+            notifyChange();
+        }
+    }
+
+    public void initialize() {
+        if (!mInitialized) {
+            mInitialized = true;
+            notifyChange();
+        }
+    }
+
+    public void destroy() {
+        if (!mDestroyed) {
+            mDestroyed = true;
+            if (mPrefs != null) {
+                mPrefs.unregisterOnSharedPreferenceChangeListener(this);
+            }
+        }
+    }
+
+    private void notifyChange() {
+        if (!mInitialized || mDestroyed) {
+            return;
+        }
+
+        final int activityFlags;
+        if (mStateHandlerRequest != REQUEST_NONE) {
+            activityFlags = mStateHandlerRequest == REQUEST_LOCK ?
+                SCREEN_ORIENTATION_LOCKED : SCREEN_ORIENTATION_UNSPECIFIED;
+        } else if (mCurrentTransitionRequest != REQUEST_NONE) {
+            activityFlags = mCurrentTransitionRequest == REQUEST_LOCK ?
+                SCREEN_ORIENTATION_LOCKED : SCREEN_ORIENTATION_UNSPECIFIED;
+        } else if (mCurrentStateRequest == REQUEST_LOCK) {
+            activityFlags = SCREEN_ORIENTATION_LOCKED;
+        } else if (mIgnoreAutoRotateSettings || mCurrentStateRequest == REQUEST_ROTATE
+            || mAutoRotateEnabled) {
+            activityFlags = SCREEN_ORIENTATION_UNSPECIFIED;
+        } else {
+            // If auto rotation is off, allow rotation on the activity, in case the user is using
+            // forced rotation.
+            activityFlags = SCREEN_ORIENTATION_NOSENSOR;
+        }
+        if (activityFlags != mLastActivityFlags) {
+            mLastActivityFlags = activityFlags;
+            UiThreadHelper.setOrientationAsync(mActivity, activityFlags);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return String.format("[mStateHandlerRequest=%d, mCurrentStateRequest=%d,"
+                + " mLastActivityFlags=%d, mIgnoreAutoRotateSettings=%b, mAutoRotateEnabled=%b]",
+                mStateHandlerRequest, mCurrentStateRequest, mLastActivityFlags,
+                mIgnoreAutoRotateSettings, mAutoRotateEnabled);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/SystemUiController.java b/app/src/main/java/foundation/e/blisslauncher/features/test/SystemUiController.java
new file mode 100644
index 0000000000000000000000000000000000000000..89eb9f022ceccbac2747fe66a124a3e64909c498
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/SystemUiController.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package foundation.e.blisslauncher.features.test;
+
+import android.view.View;
+import android.view.Window;
+
+import java.util.Arrays;
+
+import foundation.e.blisslauncher.core.Utilities;
+
+/**
+ * Utility class to manage various window flags to control system UI.
+ */
+public class SystemUiController {
+
+    // Various UI states in increasing order of priority
+    public static final int UI_STATE_BASE_WINDOW = 0;
+    public static final int UI_STATE_NORMAL = 1;
+    public static final int UI_STATE_OVERVIEW = 2;
+
+
+    public static final int FLAG_LIGHT_NAV = 1 << 0;
+    public static final int FLAG_DARK_NAV = 1 << 1;
+    public static final int FLAG_LIGHT_STATUS = 1 << 2;
+    public static final int FLAG_DARK_STATUS = 1 << 3;
+
+    private final Window mWindow;
+    private final int[] mStates = new int[3];
+
+    public SystemUiController(Window window) {
+        mWindow = window;
+    }
+
+    public void updateUiState(int uiState, boolean isLight) {
+        updateUiState(uiState, isLight
+                ? (FLAG_LIGHT_NAV | FLAG_LIGHT_STATUS) : (FLAG_DARK_NAV | FLAG_DARK_STATUS));
+    }
+
+    public void updateUiState(int uiState, int flags) {
+        if (mStates[uiState] == flags) {
+            return;
+        }
+        mStates[uiState] = flags;
+
+        int oldFlags = mWindow.getDecorView().getSystemUiVisibility();
+        // Apply the state flags in priority order
+        int newFlags = oldFlags;
+        for (int stateFlag : mStates) {
+            if (Utilities.ATLEAST_OREO) {
+                if ((stateFlag & FLAG_LIGHT_NAV) != 0) {
+                    newFlags |= View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR;
+                } else if ((stateFlag & FLAG_DARK_NAV) != 0) {
+                    newFlags &= ~(View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR);
+                }
+            }
+
+            if ((stateFlag & FLAG_LIGHT_STATUS) != 0) {
+                newFlags |= View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
+            } else if ((stateFlag & FLAG_DARK_STATUS) != 0) {
+                newFlags &= ~(View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
+            }
+        }
+        if (newFlags != oldFlags) {
+            mWindow.getDecorView().setSystemUiVisibility(newFlags);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "mStates=" + Arrays.toString(mStates);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/TestActivity.kt b/app/src/main/java/foundation/e/blisslauncher/features/test/TestActivity.kt
new file mode 100644
index 0000000000000000000000000000000000000000..497044bba1323d289617ec2740abba4275278dc0
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/TestActivity.kt
@@ -0,0 +1,1224 @@
+package foundation.e.blisslauncher.features.test
+
+import android.Manifest
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.AnimatorSet
+import android.animation.ObjectAnimator
+import android.app.ActivityOptions
+import android.app.AlertDialog
+import android.app.usage.UsageStats
+import android.appwidget.AppWidgetManager
+import android.appwidget.AppWidgetProviderInfo
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.ContextWrapper
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.ActivityInfo
+import android.content.res.Configuration
+import android.graphics.Point
+import android.location.LocationManager
+import android.os.Bundle
+import android.os.StrictMode
+import android.os.StrictMode.VmPolicy
+import android.provider.Settings
+import android.text.Editable
+import android.text.TextWatcher
+import android.view.KeyEvent
+import android.view.LayoutInflater
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import android.view.animation.LinearInterpolator
+import android.view.inputmethod.EditorInfo
+import android.view.inputmethod.InputMethodManager
+import android.widget.GridLayout
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.RelativeLayout
+import android.widget.SeekBar
+import android.widget.TextView
+import android.widget.Toast
+import androidx.localbroadcastmanager.content.LocalBroadcastManager
+import androidx.recyclerview.widget.DividerItemDecoration
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.jakewharton.rxbinding3.widget.textChanges
+import foundation.e.blisslauncher.BlissLauncher
+import foundation.e.blisslauncher.R
+import foundation.e.blisslauncher.core.Preferences
+import foundation.e.blisslauncher.core.Utilities
+import foundation.e.blisslauncher.core.customviews.AbstractFloatingView
+import foundation.e.blisslauncher.core.customviews.BlissFrameLayout
+import foundation.e.blisslauncher.core.customviews.BlissInput
+import foundation.e.blisslauncher.core.customviews.InsettableFrameLayout
+import foundation.e.blisslauncher.core.customviews.InsettableScrollLayout
+import foundation.e.blisslauncher.core.customviews.LauncherPagedView
+import foundation.e.blisslauncher.core.customviews.RoundedWidgetView
+import foundation.e.blisslauncher.core.customviews.SquareFrameLayout
+import foundation.e.blisslauncher.core.customviews.WidgetHost
+import foundation.e.blisslauncher.core.database.DatabaseManager
+import foundation.e.blisslauncher.core.database.model.FolderItem
+import foundation.e.blisslauncher.core.database.model.LauncherItem
+import foundation.e.blisslauncher.core.executors.AppExecutors
+import foundation.e.blisslauncher.core.utils.AppUtils
+import foundation.e.blisslauncher.core.utils.Constants
+import foundation.e.blisslauncher.core.utils.ListUtil
+import foundation.e.blisslauncher.core.utils.UserHandle
+import foundation.e.blisslauncher.features.launcher.Hotseat
+import foundation.e.blisslauncher.features.launcher.SearchInputDisposableObserver
+import foundation.e.blisslauncher.features.suggestions.AutoCompleteAdapter
+import foundation.e.blisslauncher.features.suggestions.SearchSuggestionUtil
+import foundation.e.blisslauncher.features.suggestions.SuggestionsResult
+import foundation.e.blisslauncher.features.test.LauncherState.*
+import foundation.e.blisslauncher.features.test.RotationHelper.REQUEST_NONE
+import foundation.e.blisslauncher.features.test.dragndrop.DragController
+import foundation.e.blisslauncher.features.test.dragndrop.DragLayer
+import foundation.e.blisslauncher.features.test.graphics.RotationMode
+import foundation.e.blisslauncher.features.usagestats.AppUsageStats
+import foundation.e.blisslauncher.features.weather.DeviceStatusService
+import foundation.e.blisslauncher.features.weather.ForecastBuilder
+import foundation.e.blisslauncher.features.weather.WeatherPreferences
+import foundation.e.blisslauncher.features.weather.WeatherSourceListenerService
+import foundation.e.blisslauncher.features.weather.WeatherUpdateService
+import foundation.e.blisslauncher.features.widgets.WidgetManager
+import foundation.e.blisslauncher.features.widgets.WidgetViewBuilder
+import foundation.e.blisslauncher.features.widgets.WidgetsActivity
+import foundation.e.blisslauncher.uioverrides.OverlayCallbackImpl
+import foundation.e.blisslauncher.uioverrides.UiFactory
+import io.reactivex.Observable
+import io.reactivex.ObservableSource
+import io.reactivex.android.schedulers.AndroidSchedulers
+import io.reactivex.disposables.CompositeDisposable
+import io.reactivex.functions.Function
+import io.reactivex.observers.DisposableObserver
+import io.reactivex.schedulers.Schedulers
+import java.util.ArrayList
+import java.util.Arrays
+import java.util.Comparator
+import java.util.Locale
+import java.util.concurrent.TimeUnit
+
+class TestActivity : BaseDraggingActivity(), AutoCompleteAdapter.OnSuggestionClickListener {
+
+    private var mCancelTouchController: Runnable? = null
+    private var mOnResumeCallback: OnResumeCallback? = null
+    private lateinit var mAppTransitionManager: LauncherAppTransitionManager
+    lateinit var dragController: DragController
+    private lateinit var mOldConfig: Configuration
+    private var mCompositeDisposable: CompositeDisposable? = null
+
+    // Type: int
+    private val RUNTIME_STATE_CURRENT_SCREEN = "launcher.current_screen"
+
+    // Type: int
+    private val RUNTIME_STATE = "launcher.state"
+
+    // Type: PendingRequestArgs
+    private val RUNTIME_STATE_PENDING_REQUEST_ARGS = "launcher.request_args"
+
+    // Type: int
+    private val RUNTIME_STATE_PENDING_REQUEST_CODE = "launcher.request_code"
+
+    // Type: ActivityResultInfo
+    private val RUNTIME_STATE_PENDING_ACTIVITY_RESULT = "launcher.activity_result"
+
+    private lateinit var launcherView: View
+    private lateinit var dragLayer: DragLayer
+    private lateinit var workspace: LauncherPagedView
+    private lateinit var hotseat: Hotseat
+    private lateinit var widgetPage: InsettableFrameLayout
+
+    private lateinit var mSearchInput: BlissInput
+
+    private val REQUEST_LOCATION_SOURCE_SETTING = 267
+
+    private lateinit var rotationHelper: RotationHelper
+    private var mRotationMode = RotationMode.NORMAL
+    private lateinit var mStateManager: LauncherStateManager
+
+    // UI and state for the overview panel
+    private lateinit var overviewPanel: View
+
+    private val mOnResumeCallbacks = ArrayList<OnResumeCallback>()
+
+    private lateinit var mAppWidgetManager: AppWidgetManager
+    private lateinit var mAppWidgetHost: WidgetHost
+    private lateinit var widgetContainer: LinearLayout
+    private var activeRoundedWidgetView: RoundedWidgetView? = null
+
+    private lateinit var mWeatherPanel: View
+    private lateinit var mWeatherSetupTextView: View
+    private val allAppsDisplayed = false
+    private val forceRefreshSuggestedApps = false
+
+    private var mUsageStats: List<UsageStats>? = null
+
+    private var enableLocationDialog: AlertDialog? = null
+
+    private var currentAnimator: AnimatorSet? = null
+
+    private val mWeatherReceiver: BroadcastReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            if (!intent.getBooleanExtra(WeatherUpdateService.EXTRA_UPDATE_CANCELLED, false)) {
+                updateWeatherPanel()
+            }
+        }
+    }
+
+    private val TAG = "TestActivity"
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        if (DEBUG_STRICT_MODE) {
+            StrictMode.setThreadPolicy(
+                StrictMode.ThreadPolicy.Builder()
+                    .detectDiskReads()
+                    .detectDiskWrites()
+                    .detectNetwork() // or .detectAll() for all detectable problems
+                    .penaltyLog()
+                    .build()
+            )
+            StrictMode.setVmPolicy(
+                VmPolicy.Builder()
+                    .detectLeakedSqlLiteObjects()
+                    .detectLeakedClosableObjects()
+                    .penaltyLog()
+                    .penaltyDeath()
+                    .build()
+            )
+        }
+        TraceHelper.beginSection("Launcher-onCreate")
+
+        super.onCreate(savedInstanceState)
+        TraceHelper.partitionSection("Launcher-onCreate", "super call")
+
+        val app = LauncherAppState.getInstance(this)
+        app.launcher = this
+        mOldConfig = Configuration(resources.configuration)
+
+        mAppWidgetManager = BlissLauncher.getApplication(this).appWidgetManager
+        mAppWidgetHost = BlissLauncher.getApplication(this).appWidgetHost
+
+        initDeviceProfile(BlissLauncher.getApplication(this).invariantDeviceProfile)
+        dragController = DragController(this)
+        rotationHelper = RotationHelper(this)
+        mStateManager = LauncherStateManager(this)
+        launcherView = LayoutInflater.from(this).inflate(R.layout.activity_test, null)
+        setupViews()
+
+        mAppTransitionManager = LauncherAppTransitionManager.newInstance(this)
+
+        val internalStateHandled = InternalStateHandler.handleCreate(this, intent)
+        if (internalStateHandled) {
+            savedInstanceState?.remove(RUNTIME_STATE)
+        }
+        restoreState(savedInstanceState)
+        mStateManager.reapplyState()
+
+        setContentView(launcherView)
+        rootView.dispatchInsets()
+
+        systemUiController.updateUiState(
+            SystemUiController.UI_STATE_BASE_WINDOW,
+            false
+        )
+        rotationHelper.initialize()
+        TraceHelper.endSection("Launcher-onCreate")
+        mStateManager.addStateListener(object : LauncherStateManager.StateListener {
+            override fun onStateTransitionStart(toState: LauncherState?) {}
+            override fun onStateTransitionComplete(finalState: LauncherState) {
+                if (finalState === NORMAL) {
+                    // TODO: may use later
+                } else if (finalState === OVERVIEW || finalState === OVERVIEW_PEEK) {
+                    // TODO: may use later
+                } else {
+                    // TODO: may use later
+                }
+            }
+        })
+        createOrUpdateIconGrid()
+        setLauncherOverlay(OverlayCallbackImpl(this))
+    }
+
+    /**
+     * Restores the previous state, if it exists.
+     *
+     * @param savedState The previous state.
+     */
+    private fun restoreState(savedState: Bundle?) {
+        if (savedState == null) {
+            return
+        }
+        val stateOrdinal =
+            savedState.getInt(RUNTIME_STATE, NORMAL.ordinal)
+        val stateValues = LauncherState.values()
+        val state = stateValues[stateOrdinal]
+        if (!state.disableRestore) {
+            mStateManager.goToState(state, false /* animated */)
+        }
+    }
+
+    override fun onEnterAnimationComplete() {
+        super.onEnterAnimationComplete()
+        UiFactory.onEnterAnimationComplete(this)
+        rotationHelper.setCurrentTransitionRequest(REQUEST_NONE)
+    }
+
+    override fun onConfigurationChanged(newConfig: Configuration) {
+        val diff = newConfig.diff(mOldConfig)
+
+        if (diff and ActivityInfo.CONFIG_LOCALE != 0) {
+            // Folder.setLocaleDependentFields(resources, true /* force */)
+            // TODO: Update folder here.
+        }
+
+        if (diff and (ActivityInfo.CONFIG_ORIENTATION or ActivityInfo.CONFIG_SCREEN_SIZE) != 0) {
+            // onIdpChanged(mDeviceProfile.inv)
+            // TODO: update device profile here.
+        }
+
+        mOldConfig.setTo(newConfig)
+        UiFactory.onLauncherStateOrResumeChanged(this)
+        super.onConfigurationChanged(newConfig)
+    }
+
+    private fun setupViews() {
+        dragLayer = findViewById(R.id.drag_layer)
+        workspace = dragLayer.findViewById(R.id.workspace)
+        workspace.initParentViews(dragLayer)
+        overviewPanel = findViewById(R.id.overview_panel)
+        hotseat = findViewById(R.id.hotseat)
+        launcherView.systemUiVisibility = (View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+            or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+            or View.SYSTEM_UI_FLAG_LAYOUT_STABLE)
+        dragLayer.setup(dragController, workspace)
+        mCancelTouchController = UiFactory.enableLiveUIChanges(this)
+        workspace.setup(dragController)
+        setupWidgetPage()
+        workspace.bindAndInitFirstScreen(null)
+        dragController.addDragListener(workspace)
+        dragController.addDropTarget(workspace)
+
+        // Setup the drag controller (drop targets have to be added in reverse order in priority)
+
+        // Setup the drag controller (drop targets have to be added in reverse order in priority)
+        dragController.setMoveTarget(workspace)
+    }
+
+    private fun setupWidgetPage() {
+        widgetPage = layoutInflater.inflate(R.layout.widgets_page, rootView, false) as InsettableFrameLayout
+        rootView.addView(widgetPage)
+
+        widgetContainer = widgetPage.findViewById(R.id.widget_container)
+
+        widgetPage.visibility = View.GONE
+        widgetPage.translationX = (widgetPage.measuredWidth * -1.00f)
+        val scrollView: InsettableScrollLayout =
+            widgetPage.findViewById(R.id.widgets_scroll_container)
+        scrollView.setOnTouchListener { v: View?, event: MotionEvent? ->
+            if (widgetPage.findViewById<View>(R.id.widget_resizer_container)
+                    .visibility
+                == View.VISIBLE
+            ) {
+                hideWidgetResizeContainer()
+            }
+            false
+        }
+        widgetPage.findViewById<View>(R.id.used_apps_layout).clipToOutline = true
+        widgetPage.tag = "Widget page"
+
+        // TODO: replace with app predictions
+        // Prepare app suggestions view
+        // [[BEGIN]]
+        widgetPage.findViewById<View>(R.id.openUsageAccessSettings).setOnClickListener {
+            startActivity(
+                Intent(
+                    Settings.ACTION_USAGE_ACCESS_SETTINGS
+                )
+            )
+        }
+
+        // divided by 2 because of left and right padding.
+
+        // divided by 2 because of left and right padding.
+        val padding = (mDeviceProfile.availableWidthPx / 2 - Utilities.pxFromDp(8, this) -
+            (2 *
+            mDeviceProfile.cellWidthPx)).toInt()
+        widgetPage.findViewById<View>(R.id.suggestedAppGrid).setPadding(padding, 0, padding, 0)
+        // [[END]]
+
+        // Prepare search suggestion view
+        // [[BEGIN]]
+        mSearchInput = widgetPage.findViewById(R.id.search_input)
+        val clearSuggestions: ImageView =
+            widgetPage.findViewById(R.id.clearSuggestionImageView)
+        clearSuggestions.setOnClickListener {
+            mSearchInput.setText("")
+            mSearchInput.clearFocus()
+        }
+
+        mSearchInput.addTextChangedListener(object : TextWatcher {
+            override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {}
+            override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
+                if (s.toString().trim { it <= ' ' }.isEmpty()) {
+                    clearSuggestions.visibility = View.GONE
+                } else {
+                    clearSuggestions.visibility = View.VISIBLE
+                }
+            }
+
+            override fun afterTextChanged(s: Editable) {}
+        })
+        val suggestionRecyclerView: RecyclerView =
+            widgetPage.findViewById(R.id.suggestionRecyclerView)
+        val suggestionAdapter = AutoCompleteAdapter(this)
+        suggestionRecyclerView.setHasFixedSize(true)
+        suggestionRecyclerView.layoutManager =
+            LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false)
+        suggestionRecyclerView.adapter = suggestionAdapter
+        val dividerItemDecoration = DividerItemDecoration(
+            this,
+            DividerItemDecoration.VERTICAL
+        )
+        suggestionRecyclerView.addItemDecoration(dividerItemDecoration)
+        getCompositeDisposable().add(
+            mSearchInput.textChanges()
+                .debounce(300, TimeUnit.MILLISECONDS)
+                .map { obj: CharSequence -> obj.toString() }
+                .distinctUntilChanged()
+                .switchMap { charSequence: String? ->
+                    if (charSequence != null && charSequence.isNotEmpty()) {
+                        searchForQuery(charSequence)
+                    } else {
+                        Observable.just(
+                            SuggestionsResult(charSequence)
+                        )
+                    }
+                }
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribeWith(
+                    SearchInputDisposableObserver(this, suggestionAdapter, widgetPage)
+                )
+        )
+
+        mSearchInput.onFocusChangeListener = View.OnFocusChangeListener { v: View, hasFocus: Boolean ->
+            if (!hasFocus) {
+                hideKeyboard(v)
+            }
+        }
+
+        mSearchInput.setOnEditorActionListener { _: TextView?, action: Int, _: KeyEvent? ->
+            if (action == EditorInfo.IME_ACTION_SEARCH) {
+                hideKeyboard(mSearchInput)
+                runSearch(mSearchInput.text.toString())
+                mSearchInput.setText("")
+                mSearchInput.clearFocus()
+                return@setOnEditorActionListener true
+            }
+            false
+        }
+        // [[END]]
+
+        // Prepare edit widgets button
+        findViewById<View>(R.id.edit_widgets_button).setOnClickListener { view: View? ->
+            startActivity(
+                Intent(
+                    this,
+                    WidgetsActivity::class.java
+                )
+            )
+        }
+
+        // Prepare weather widget view
+        // [[BEGIN]]
+        findViewById<View>(R.id.weather_setting_imageview).setOnClickListener { v: View? ->
+            startActivity(
+                Intent(
+                    this,
+                    WeatherPreferences::class.java
+                )
+            )
+        }
+
+        mWeatherSetupTextView = findViewById<View>(R.id.weather_setup_textview)
+        mWeatherPanel = findViewById(R.id.weather_panel)
+        mWeatherPanel.setOnClickListener(View.OnClickListener { v: View? ->
+            val launchIntent =
+                packageManager.getLaunchIntentForPackage(
+                    "foundation.e.weather"
+                )
+            if (launchIntent != null) {
+                launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                startActivity(launchIntent)
+            }
+        })
+        updateWeatherPanel()
+
+        if (foundation.e.blisslauncher.features.weather.WeatherUtils.isWeatherServiceAvailable(
+                this
+            )
+        ) {
+            startService(Intent(this, WeatherSourceListenerService::class.java))
+            startService(Intent(this, DeviceStatusService::class.java))
+        }
+
+        LocalBroadcastManager.getInstance(this).registerReceiver(
+            mWeatherReceiver, IntentFilter(
+                WeatherUpdateService.ACTION_UPDATE_FINISHED
+            )
+        )
+
+        if (!Preferences.useCustomWeatherLocation(this)) {
+            if (!WeatherPreferences.hasLocationPermission(this)) {
+                val permissions = arrayOf(Manifest.permission.ACCESS_FINE_LOCATION)
+                requestPermissions(
+                    permissions,
+                    WeatherPreferences.LOCATION_PERMISSION_REQUEST_CODE
+                )
+            } else {
+                val lm = getSystemService(LOCATION_SERVICE) as LocationManager
+                if (!lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER) &&
+                    Preferences.getEnableLocation(this)
+                ) {
+                    showLocationEnableDialog()
+                    Preferences.setEnableLocation(this)
+                } else {
+                    startService(
+                        Intent(this, WeatherUpdateService::class.java)
+                            .setAction(WeatherUpdateService.ACTION_FORCE_UPDATE)
+                    )
+                }
+            }
+        } else {
+            startService(
+                Intent(this, WeatherUpdateService::class.java)
+                    .setAction(WeatherUpdateService.ACTION_FORCE_UPDATE)
+            )
+        }
+        // [[END]]
+
+        val widgetIds: IntArray = mAppWidgetHost.appWidgetIds
+        Arrays.sort(widgetIds)
+        for (id in widgetIds) {
+            val appWidgetInfo: AppWidgetProviderInfo? = mAppWidgetManager.getAppWidgetInfo(id)
+            if (appWidgetInfo != null) {
+                val hostView: RoundedWidgetView = mAppWidgetHost.createView(
+                    applicationContext, id,
+                    appWidgetInfo
+                ) as RoundedWidgetView
+                hostView.setAppWidget(id, appWidgetInfo)
+                getCompositeDisposable().add(DatabaseManager.getManager(this).getHeightOfWidget(id)
+                    .subscribeOn(Schedulers.from(AppExecutors.getInstance().diskIO()))
+                    .observeOn(AndroidSchedulers.mainThread())
+                    .subscribe({ height: Int ->
+                        val widgetView = WidgetViewBuilder.create(this, hostView)
+                        if (height != 0) {
+                            val minHeight = hostView.appWidgetInfo.minResizeHeight
+                            val maxHeight = mDeviceProfile.availableHeightPx * 3 / 4
+                            val normalisedDifference = (maxHeight - minHeight) / 100
+                            val newHeight = minHeight + normalisedDifference * height
+                            widgetView.layoutParams.height = newHeight
+                        }
+                        addWidgetToContainer(widgetView)
+                    }) { obj: Throwable -> obj.printStackTrace() })
+            }
+        }
+    }
+
+    private fun addWidgetToContainer(widgetView: RoundedWidgetView) {
+        widgetView.setPadding(0, 0, 0, 0)
+        widgetContainer!!.addView(widgetView)
+    }
+
+    private fun updateWeatherPanel() {
+        if (Preferences.getCachedWeatherInfo(this) == null) {
+            mWeatherSetupTextView.visibility = View.VISIBLE
+            mWeatherPanel.visibility = View.GONE
+            mWeatherSetupTextView.setOnClickListener { v: View? ->
+                startActivity(
+                    Intent(this, WeatherPreferences::class.java)
+                )
+            }
+            return
+        }
+        mWeatherSetupTextView.visibility = View.GONE
+        mWeatherPanel.visibility = View.VISIBLE
+        ForecastBuilder.buildLargePanel(
+            this, mWeatherPanel,
+            Preferences.getCachedWeatherInfo(this)
+        )
+    }
+
+    private fun showLocationEnableDialog() {
+        val builder = AlertDialog.Builder(this)
+        // Build and show the dialog
+        builder.setTitle(R.string.weather_retrieve_location_dialog_title)
+        builder.setMessage(R.string.weather_retrieve_location_dialog_message)
+        builder.setCancelable(false)
+        builder.setPositiveButton(
+            R.string.weather_retrieve_location_dialog_enable_button
+        ) { dialog1, whichButton ->
+            val intent =
+                Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS)
+            intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+            startActivityForResult(
+                intent, REQUEST_LOCATION_SOURCE_SETTING
+            )
+        }
+        builder.setNegativeButton(R.string.cancel, null)
+        enableLocationDialog = builder.create()
+        enableLocationDialog?.show()
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        if (requestCode == REQUEST_LOCATION_SOURCE_SETTING) {
+            val lm = getSystemService(LOCATION_SERVICE) as LocationManager
+            if (!lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER)) {
+                Toast.makeText(
+                    this, "Set custom location in weather settings.",
+                    Toast.LENGTH_SHORT
+                ).show()
+            } else {
+                startService(
+                    Intent(this, WeatherUpdateService::class.java)
+                        .setAction(WeatherUpdateService.ACTION_FORCE_UPDATE)
+                )
+            }
+        } else {
+            super.onActivityResult(requestCode, resultCode, data)
+        }
+    }
+
+    private fun searchForQuery(
+        charSequence: CharSequence
+    ): ObservableSource<SuggestionsResult?>? {
+        val launcherItems = searchForLauncherItems(
+            charSequence.toString()
+        ).subscribeOn(Schedulers.io())
+        val networkItems = searchForNetworkItems(
+            charSequence
+        ).subscribeOn(Schedulers.io())
+        return launcherItems.mergeWith(networkItems)
+    }
+
+    private fun searchForLauncherItems(
+        charSequence: CharSequence
+    ): Observable<SuggestionsResult?> {
+        val query = charSequence.toString().toLowerCase()
+        val suggestionsResult = SuggestionsResult(
+            query
+        )
+        val launcherItems: MutableList<LauncherItem> = ArrayList()
+        workspace.mWorkspaceScreens.forEach { gridLayout: GridLayout ->
+            for (i in 0 until gridLayout.childCount) {
+                val blissFrameLayout = gridLayout.getChildAt(i) as BlissFrameLayout
+                val launcherItem = blissFrameLayout.launcherItem
+                if (launcherItem.itemType == Constants.ITEM_TYPE_FOLDER) {
+                    val folderItem = launcherItem as FolderItem
+                    for (item in folderItem.items) {
+                        if (item.title.toString().toLowerCase().contains(query)) {
+                            launcherItems.add(item)
+                        }
+                    }
+                } else if (launcherItem.title.toString().toLowerCase().contains(query)) {
+                    launcherItems.add(launcherItem)
+                }
+            }
+        }
+        val hotseat = getHotseat()
+        for (i in 0 until hotseat.childCount) {
+            val blissFrameLayout = hotseat.getChildAt(i) as BlissFrameLayout
+            val launcherItem = blissFrameLayout.launcherItem
+            if (launcherItem.itemType == Constants.ITEM_TYPE_FOLDER) {
+                val folderItem = launcherItem as FolderItem
+                for (item in folderItem.items) {
+                    if (item.title.toString().toLowerCase().contains(query)) {
+                        launcherItems.add(item)
+                    }
+                }
+            } else if (launcherItem.title.toString().toLowerCase().contains(query)) {
+                launcherItems.add(launcherItem)
+            }
+        }
+        launcherItems.sortWith(Comparator.comparing { launcherItem: LauncherItem ->
+            launcherItem.title.toString().toLowerCase().indexOf(query)
+        })
+        if (launcherItems.size > 4) {
+            suggestionsResult.launcherItems = launcherItems.subList(0, 4)
+        } else {
+            suggestionsResult.launcherItems = launcherItems
+        }
+        return Observable.just(suggestionsResult)
+            .onErrorReturn { throwable: Throwable? ->
+                suggestionsResult.launcherItems = ArrayList()
+                suggestionsResult
+            }
+    }
+
+    private fun searchForNetworkItems(charSequence: CharSequence): Observable<SuggestionsResult?> {
+        val query = charSequence.toString().lowercase(Locale.getDefault()).trim { it <= ' ' }
+        val suggestionProvider = SearchSuggestionUtil().getSuggestionProvider(
+            this
+        )
+        return suggestionProvider.query(query).toObservable()
+    }
+
+    fun hideWidgetResizeContainer() {
+        val widgetResizeContainer: RelativeLayout = widgetPage.findViewById<RelativeLayout>(
+            R.id.widget_resizer_container
+        )
+        if (widgetResizeContainer.visibility == View.VISIBLE) {
+            currentAnimator?.cancel()
+            val set = AnimatorSet()
+            set.play(
+                ObjectAnimator.ofFloat(
+                    widgetResizeContainer, View.Y,
+                    mDeviceProfile.availableHeightPx
+                        .toFloat()
+                )
+            )
+            set.duration = 200
+            set.interpolator = LinearInterpolator()
+            set.addListener(object : AnimatorListenerAdapter() {
+                override fun onAnimationStart(animation: Animator) {
+                    super.onAnimationStart(animation)
+                    (widgetPage.findViewById<View>(
+                        R.id.widget_resizer_seekbar
+                    ) as SeekBar).setOnSeekBarChangeListener(null)
+                }
+
+                override fun onAnimationCancel(animation: Animator) {
+                    super.onAnimationCancel(animation)
+                    currentAnimator = null
+                    widgetResizeContainer.visibility = View.VISIBLE
+                }
+
+                override fun onAnimationEnd(animation: Animator) {
+                    super.onAnimationEnd(animation)
+                    currentAnimator = null
+                    widgetResizeContainer.visibility = View.GONE
+                    activeRoundedWidgetView?.removeBorder()
+                }
+            }
+            )
+            set.start()
+            currentAnimator = set
+        }
+    }
+
+    fun hideKeyboard(view: View) {
+        val inputMethodManager = (getSystemService(
+            INPUT_METHOD_SERVICE
+        ) as InputMethodManager)
+        inputMethodManager.hideSoftInputFromWindow(view.windowToken, 0)
+    }
+
+    fun showKeyboard(view: View?) {
+        val inputMethodManager = (getSystemService(
+            INPUT_METHOD_SERVICE
+        ) as InputMethodManager)
+        inputMethodManager.showSoftInput(view, 0)
+    }
+
+    private fun runSearch(query: String) {
+        val intent = Intent(
+            Intent.ACTION_VIEW,
+            SearchSuggestionUtil().getUriForQuery(this, query)
+        )
+        startActivity(intent)
+    }
+
+    fun showWidgetResizeContainer(roundedWidgetView: RoundedWidgetView) {
+        val widgetResizeContainer: RelativeLayout = widgetPage.findViewById<RelativeLayout>(
+            R.id.widget_resizer_container
+        )
+        if (widgetResizeContainer.visibility != View.VISIBLE) {
+            activeRoundedWidgetView = roundedWidgetView
+            val seekBar = widgetResizeContainer.findViewById<SeekBar>(R.id.widget_resizer_seekbar)
+            if (currentAnimator != null) {
+                currentAnimator!!.cancel()
+            }
+            seekBar.setOnTouchListener { v: View?, event: MotionEvent? ->
+                seekBar.parent.requestDisallowInterceptTouchEvent(true)
+                false
+            }
+            val set = AnimatorSet()
+            set.play(
+                ObjectAnimator.ofFloat(
+                    widgetResizeContainer, View.Y,
+                    mDeviceProfile.availableHeightPx.toFloat(),
+                    mDeviceProfile.availableHeightPx - Utilities.pxFromDp(48, this)
+                )
+            )
+            set.duration = 200
+            set.interpolator = LinearInterpolator()
+            set.addListener(object : AnimatorListenerAdapter() {
+                override fun onAnimationStart(animation: Animator) {
+                    super.onAnimationStart(animation)
+                    widgetResizeContainer.visibility = View.VISIBLE
+                }
+
+                override fun onAnimationCancel(animation: Animator) {
+                    super.onAnimationCancel(animation)
+                    currentAnimator = null
+                    widgetResizeContainer.visibility = View.GONE
+                    roundedWidgetView.removeBorder()
+                }
+
+                override fun onAnimationEnd(animation: Animator) {
+                    super.onAnimationEnd(animation)
+                    currentAnimator = null
+                    prepareWidgetResizeSeekBar(seekBar)
+                    roundedWidgetView.addBorder()
+                }
+            }
+            )
+            set.start()
+            currentAnimator = set
+        }
+    }
+
+    private fun prepareWidgetResizeSeekBar(seekBar: SeekBar) {
+        val minHeight = activeRoundedWidgetView!!.appWidgetInfo.minResizeHeight
+        val maxHeight = mDeviceProfile.availableHeightPx * 3 / 4
+        val normalisedDifference = (maxHeight - minHeight) / 100
+        val defaultHeight = activeRoundedWidgetView!!.height
+        val currentProgress = (defaultHeight - minHeight) * 100 / (maxHeight - minHeight)
+        seekBar.max = 100
+        seekBar.progress = currentProgress
+        seekBar.setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
+            override fun onProgressChanged(seekBar: SeekBar, progress: Int, fromUser: Boolean) {
+                val newHeight = minHeight + normalisedDifference * progress
+                val layoutParams = activeRoundedWidgetView!!.layoutParams as LinearLayout.LayoutParams
+                layoutParams.height = newHeight
+                activeRoundedWidgetView!!.layoutParams = layoutParams
+                val newOps = Bundle()
+                newOps.putInt(
+                    AppWidgetManager.OPTION_APPWIDGET_MIN_WIDTH,
+                    mDeviceProfile.maxWidgetWidth
+                )
+                newOps.putInt(
+                    AppWidgetManager.OPTION_APPWIDGET_MAX_WIDTH,
+                    mDeviceProfile.maxWidgetWidth
+                )
+                newOps.putInt(AppWidgetManager.OPTION_APPWIDGET_MIN_HEIGHT, newHeight)
+                newOps.putInt(AppWidgetManager.OPTION_APPWIDGET_MAX_HEIGHT, newHeight)
+                activeRoundedWidgetView!!.updateAppWidgetOptions(newOps)
+                activeRoundedWidgetView!!.requestLayout()
+            }
+
+            override fun onStartTrackingTouch(seekBar: SeekBar) {}
+            override fun onStopTrackingTouch(seekBar: SeekBar) {
+                DatabaseManager.getManager(this@TestActivity).saveWidget(
+                    activeRoundedWidgetView!!.appWidgetId, seekBar.progress
+                )
+            }
+        })
+    }
+
+    override fun <T : View> findViewById(id: Int): T {
+        return launcherView.findViewById(id)
+    }
+
+    fun getRotationHelper() = rotationHelper
+
+    private fun initDeviceProfile(idp: InvariantDeviceProfile) {
+        // Load device specific profile
+        mDeviceProfile = idp.getDeviceProfile(this)
+        if (isInMultiWindowMode) {
+            val display = windowManager.defaultDisplay
+            val mwSize = Point()
+            display.getSize(mwSize)
+            mDeviceProfile = mDeviceProfile.getMultiWindowProfile(this, mwSize)
+        }
+        mRotationMode = RotationMode.NORMAL
+        onDeviceProfileInitiated()
+    }
+
+    override fun onPause() {
+        super.onPause()
+        dragController.cancelDrag()
+        dragController.resetLastGestureUpTime()
+    }
+
+    override fun onResume() {
+        super.onResume()
+        if (mOnResumeCallbacks.isNotEmpty()) {
+            val resumeCallbacks = ArrayList(mOnResumeCallbacks)
+            mOnResumeCallbacks.clear()
+            for (i in resumeCallbacks.indices.reversed()) {
+                resumeCallbacks[i].onLauncherResume()
+            }
+            resumeCallbacks.clear()
+        }
+
+        if (mWeatherPanel != null) {
+            updateWeatherPanel()
+        }
+
+        if (widgetPage != null) {
+            refreshSuggestedApps(widgetPage, forceRefreshSuggestedApps)
+        }
+
+        if (widgetContainer != null) {
+            val widgetManager = WidgetManager.getInstance()
+            var id = widgetManager.dequeRemoveId()
+            while (id != null) {
+                for (i in 0 until widgetContainer.childCount) {
+                    if (widgetContainer.getChildAt(i) is RoundedWidgetView) {
+                        val appWidgetHostView = widgetContainer.getChildAt(i) as RoundedWidgetView
+                        if (appWidgetHostView.appWidgetId == id) {
+                            widgetContainer.removeViewAt(i)
+                            DatabaseManager.getManager(this).removeWidget(id)
+                            break
+                        }
+                    }
+                }
+                id = widgetManager.dequeRemoveId()
+            }
+            var widgetView = widgetManager.dequeAddWidgetView()
+            while (widgetView != null) {
+                widgetView = WidgetViewBuilder.create(this, widgetView)
+                addWidgetToContainer(widgetView)
+                widgetView = widgetManager.dequeAddWidgetView()
+            }
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        if (mCancelTouchController != null) {
+            mCancelTouchController!!.run()
+            mCancelTouchController = null
+        }
+
+        rotationHelper.destroy()
+    }
+
+    override fun onUserLeaveHint() {
+        super.onUserLeaveHint()
+        UiFactory.onLauncherStateOrResumeChanged(this)
+    }
+
+    override fun onWindowFocusChanged(hasFocus: Boolean) {
+        super.onWindowFocusChanged(hasFocus)
+        mStateManager.onWindowFocusChanged()
+    }
+
+    fun getRotationMode(): RotationMode {
+        return mRotationMode
+    }
+
+    fun getHotseat() = hotseat
+
+    fun isWorkspaceLoading() = false
+
+    override fun getDragLayer(): DragLayer = dragLayer
+
+    override fun <T : View> getOverviewPanel(): T = overviewPanel as T
+
+    override fun getRootView(): LauncherRootView = launcherView as LauncherRootView
+
+    override fun getActivityLaunchOptions(v: View?): ActivityOptions {
+        return mAppTransitionManager.getActivityLaunchOptions(this, v)
+    }
+
+    fun getLauncherPagedView(): LauncherPagedView = workspace
+
+    fun getStateManager() = mStateManager
+
+    fun getAppTransitionManager() = mAppTransitionManager
+
+    override fun reapplyUi() {
+        rootView.dispatchInsets()
+        getStateManager().reapplyState(true /* cancelCurrentAnimation */)
+    }
+
+    fun isWorkspaceLocked() = false
+
+    private fun getCompositeDisposable(): CompositeDisposable {
+        if (mCompositeDisposable == null || mCompositeDisposable!!.isDisposed) {
+            mCompositeDisposable = CompositeDisposable()
+        }
+        return mCompositeDisposable!!
+    }
+
+    private fun createOrUpdateIconGrid() {
+        getCompositeDisposable().add(
+            BlissLauncher.getApplication(this)
+                .appProvider
+                .appsRepository
+                .appsRelay
+                .distinctUntilChanged()
+                .observeOn(AndroidSchedulers.mainThread())
+                .subscribeWith(object : DisposableObserver<List<LauncherItem?>?>() {
+                    override fun onNext(launcherItems: List<LauncherItem?>) {
+                        showApps(launcherItems)
+                    }
+
+                    override fun onError(e: Throwable) {
+                        e.printStackTrace()
+                    }
+
+                    override fun onComplete() {}
+                })
+        )
+    }
+
+    private fun showApps(launcherItems: List<LauncherItem?>) {
+        if (hotseat != null) hotseat.resetLayout(false)
+        workspace.bindItems(launcherItems)
+    }
+
+    fun getCellLayout(container: Long, screenId: Long): CellLayout? {
+        return if (container == Constants.CONTAINER_HOTSEAT) {
+            if (hotseat != null) {
+                hotseat.getLayout()
+            } else {
+                null
+            }
+        } else {
+            workspace.getScreenWithId(screenId)
+        }
+    }
+
+    fun isHotseatLayout(layout: View?): Boolean =
+        hotseat != null && layout != null && layout is CellLayout && layout == hotseat.layout
+
+    fun getViewIdForItem(info: LauncherItem): Int {
+        // aapt-generated IDs have the high byte nonzero; clamp to the range under that.
+        // This cast is safe as long as the id < 0x00FFFFFF
+        // Since we jail all the dynamically generated views, there should be no clashes
+        // with any other views.
+        return info.keyId
+    }
+
+    fun setOnResumeCallback(callback: OnResumeCallback) {
+        mOnResumeCallback?.onLauncherResume()
+        mOnResumeCallback = callback
+    }
+
+    /**
+     * Call this after onCreate to set or clear overlay.
+     */
+    fun setLauncherOverlay(overlay: LauncherOverlay) {
+        overlay.setOverlayCallbacks(LauncherOverlayCallbacksImpl())
+        workspace.setLauncherOverlay(overlay)
+    }
+
+    fun isInState(state: LauncherState): Boolean {
+        return mStateManager.state === state
+    }
+
+    fun addOnResumeCallback(callback: OnResumeCallback) {
+        mOnResumeCallbacks.add(callback)
+    }
+
+    fun refreshSuggestedApps(viewGroup: ViewGroup, forceRefresh: Boolean) {
+        val openUsageAccessSettingsTv =
+            viewGroup.findViewById<TextView>(R.id.openUsageAccessSettings)
+        val suggestedAppsGridLayout = viewGroup.findViewById<GridLayout>(R.id.suggestedAppGrid)
+        val appUsageStats = AppUsageStats(this)
+        val usageStats = appUsageStats.usageStats
+        if (usageStats.size > 0) {
+            openUsageAccessSettingsTv.visibility = View.GONE
+            suggestedAppsGridLayout.visibility = View.VISIBLE
+
+            // Check if usage stats have been changed or not to avoid unnecessary flickering
+            if (forceRefresh || mUsageStats == null || mUsageStats!!.size != usageStats.size || !ListUtil.areEqualLists(
+                    mUsageStats,
+                    usageStats
+                )
+            ) {
+                mUsageStats = usageStats
+                if (suggestedAppsGridLayout.childCount > 0) {
+                    suggestedAppsGridLayout.removeAllViews()
+                }
+                var i = 0
+                while (suggestedAppsGridLayout.childCount < 4 && i < mUsageStats!!.size) {
+                    val appItem = AppUtils.createAppItem(
+                        this,
+                        mUsageStats!![i].packageName, UserHandle()
+                    )
+                    if (appItem != null) {
+                        val view: BlissFrameLayout = prepareSuggestedApp(appItem)
+                        addAppToGrid(suggestedAppsGridLayout, view)
+                    }
+                    i++
+                }
+            }
+        } else {
+            openUsageAccessSettingsTv.visibility = View.VISIBLE
+            suggestedAppsGridLayout.visibility = View.GONE
+        }
+    }
+
+    fun prepareSuggestedApp(launcherItem: LauncherItem): BlissFrameLayout {
+        val v = layoutInflater.inflate(
+            R.layout.app_view,
+            null
+        ) as BlissFrameLayout
+        v.launcherItem = launcherItem
+        val icon: SquareFrameLayout = v.findViewById(R.id.app_icon)
+        icon.setOnClickListener { view: View? ->
+            startActivitySafely(
+                view,
+                launcherItem.intent,
+                launcherItem
+            )
+        }
+        return v
+    }
+
+    fun addAppToGrid(grid: GridLayout, view: BlissFrameLayout) {
+        val rowSpec = GridLayout.spec(GridLayout.UNDEFINED)
+        val colSpec = GridLayout.spec(GridLayout.UNDEFINED)
+        val iconLayoutParams = GridLayout.LayoutParams(rowSpec, colSpec)
+        iconLayoutParams.height = mDeviceProfile.cellHeightPx
+        iconLayoutParams.width = mDeviceProfile.cellWidthPx
+        view.findViewById<View>(R.id.app_label).visibility = View.VISIBLE
+        view.layoutParams = iconLayoutParams
+        view.setWithText(true)
+        grid.addView(view)
+        // DatabaseManager.getManager(this).saveLayouts(pages, mDock);
+    }
+
+    override fun onNewIntent(intent: Intent?) {
+        TraceHelper.beginSection("NEW_INTENT")
+        super.onNewIntent(intent)
+        val alreadyOnHome = hasWindowFocus() && (intent!!.flags and
+            Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT
+            != Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT)
+
+        // Check this condition before handling isActionMain, as this will get reset.
+        val shouldMoveToDefaultScreen = (alreadyOnHome && isInState(NORMAL) &&
+            AbstractFloatingView.getTopOpenView(this) == null)
+        val isActionMain = Intent.ACTION_MAIN == intent!!.action
+        val internalStateHandled = InternalStateHandler
+            .handleNewIntent(this, intent, isStarted)
+
+        if (isActionMain) {
+            if (!internalStateHandled) {
+                // In all these cases, only animate if we're already on home
+                AbstractFloatingView.closeAllOpenViews(this, isStarted)
+                if (!isInState(NORMAL)) {
+                    // Only change state, if not already the same. This prevents cancelling any
+                    // animations running as part of resume
+                    mStateManager.goToState(NORMAL)
+                }
+
+                // Reset the apps view
+                if (!alreadyOnHome) {
+                    // TODO: maybe stop icon giggling or search view here.
+                }
+                if (shouldMoveToDefaultScreen && !workspace.isHandlingTouch) {
+                    workspace.post(workspace::moveToDefaultScreen)
+                }
+            }
+
+            val v = window.peekDecorView()
+            if (v != null && v.windowToken != null) {
+                UiThreadHelper.hideKeyboardAsync(this, v.windowToken)
+            }
+        }
+
+        TraceHelper.endSection("NEW_INTENT")
+    }
+
+    override fun onBackPressed() {
+        if (finishAutoCancelActionMode()) {
+            return
+        }
+
+        if (dragController.isDragging()) {
+            dragController.cancelDrag()
+            return
+        }
+
+        // Note: There should be at most one log per method call. This is enforced implicitly
+        // by using if-else statements.
+        val topView = AbstractFloatingView.getTopOpenView(this)
+        if (topView != null && topView.onBackPressed()) {
+            // Handled by the floating view.
+        } else {
+            mStateManager.state.onBackPressed(this)
+        }
+    }
+
+    override fun onTrimMemory(level: Int) {
+        super.onTrimMemory(level)
+        UiFactory.onTrimMemory(this, level)
+    }
+
+    companion object {
+        const val TAG = "Launcher"
+        const val LOGD = false
+
+        const val DEBUG_STRICT_MODE = false
+
+        // TODO: Remove after test is finished
+        fun getLauncher(context: Context): TestActivity {
+            return if (context is TestActivity) {
+                context
+            } else (context as ContextWrapper).baseContext as TestActivity
+        }
+    }
+
+    /**
+     * Callback for listening for onResume
+     */
+    interface OnResumeCallback {
+        fun onLauncherResume()
+    }
+
+    interface LauncherOverlay {
+        /**
+         * Touch interaction leading to overscroll has begun
+         */
+        fun onScrollInteractionBegin()
+
+        /**
+         * Touch interaction related to overscroll has ended
+         */
+        fun onScrollInteractionEnd()
+
+        /**
+         * Scroll progress, between 0 and 100, when the user scrolls beyond the leftmost
+         * screen (or in the case of RTL, the rightmost screen).
+         */
+        fun onScrollChange(progress: Float, rtl: Boolean)
+
+        /**
+         * Called when the launcher is ready to use the overlay
+         * @param callbacks A set of callbacks provided by Launcher in relation to the overlay
+         */
+        fun setOverlayCallbacks(callbacks: LauncherOverlayCallbacks?)
+    }
+
+    interface LauncherOverlayCallbacks {
+        fun onScrollChanged(progress: Float)
+        fun onScrollBegin()
+    }
+
+    inner class LauncherOverlayCallbacksImpl : LauncherOverlayCallbacks {
+        override fun onScrollChanged(progress: Float) {
+            if (workspace != null) {
+                workspace.onOverlayScrollChanged(progress)
+                widgetPage.translationX = widgetPage.measuredWidth * (progress - 1)
+            }
+        }
+
+        override fun onScrollBegin() {
+            widgetPage.visibility = View.VISIBLE
+        }
+    }
+
+    override fun onClick(suggestion: String) {
+        mSearchInput.setText(suggestion)
+        runSearch(suggestion)
+        mSearchInput.clearFocus()
+        mSearchInput.setText("")
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/TouchController.java b/app/src/main/java/foundation/e/blisslauncher/features/test/TouchController.java
new file mode 100644
index 0000000000000000000000000000000000000000..99338bd5407d9bbe1e8ea53c0cdae72be9b8fe58
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/TouchController.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2016 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 foundation.e.blisslauncher.features.test;
+
+import android.view.MotionEvent;
+
+public interface TouchController {
+
+    /**
+     * Called when the draglayer receives touch event.
+     */
+    boolean onControllerTouchEvent(MotionEvent ev);
+
+    /**
+     * Called when the draglayer receives a intercept touch event.
+     */
+    boolean onControllerInterceptTouchEvent(MotionEvent ev);
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/TraceHelper.java b/app/src/main/java/foundation/e/blisslauncher/features/test/TraceHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..690cdb3b7797e867018e58cfc59c0da77ca03386
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/TraceHelper.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.features.test;
+
+import static android.util.Log.VERBOSE;
+import static android.util.Log.isLoggable;
+
+import android.os.SystemClock;
+import android.os.Trace;
+import android.util.ArrayMap;
+import android.util.Log;
+import android.util.MutableLong;
+
+/**
+ * A wrapper around {@link Trace} to allow easier proguarding for production builds.
+ *
+ * To enable any tracing log, execute the following command:
+ * $ adb shell setprop log.tag.TAGNAME VERBOSE
+ */
+public class TraceHelper {
+
+    private static final boolean ENABLED = true;
+
+    private static final boolean SYSTEM_TRACE = false;
+    private static final ArrayMap<String, MutableLong> sUpTimes = ENABLED ? new ArrayMap<>() : null;
+
+    public static void beginSection(String sectionName) {
+        if (ENABLED) {
+            MutableLong time = sUpTimes.get(sectionName);
+            if (time == null) {
+                time = new MutableLong(isLoggable(sectionName, VERBOSE) ? 0 : -1);
+                sUpTimes.put(sectionName, time);
+            }
+            if (time.value >= 0) {
+                if (SYSTEM_TRACE) {
+                    Trace.beginSection(sectionName);
+                }
+                time.value = SystemClock.uptimeMillis();
+            }
+        }
+    }
+
+    public static void partitionSection(String sectionName, String partition) {
+        if (ENABLED) {
+            MutableLong time = sUpTimes.get(sectionName);
+            if (time != null && time.value >= 0) {
+
+                if (SYSTEM_TRACE) {
+                    Trace.endSection();
+                    Trace.beginSection(sectionName);
+                }
+
+                long now = SystemClock.uptimeMillis();
+                Log.d(sectionName, partition + " : " + (now - time.value));
+                time.value = now;
+            }
+        }
+    }
+
+    public static void endSection(String sectionName) {
+        if (ENABLED) {
+            endSection(sectionName, "End");
+        }
+    }
+
+    public static void endSection(String sectionName, String msg) {
+        if (ENABLED) {
+            MutableLong time = sUpTimes.get(sectionName);
+            if (time != null && time.value >= 0) {
+                if (SYSTEM_TRACE) {
+                    Trace.endSection();
+                }
+                Log.d(sectionName, msg + " : " + (SystemClock.uptimeMillis() - time.value));
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/UiThreadHelper.java b/app/src/main/java/foundation/e/blisslauncher/features/test/UiThreadHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..522b1743a0ff44c5ece6b088ca625440d02d56fd
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/UiThreadHelper.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.features.test;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.Message;
+import android.os.Process;
+import android.view.inputmethod.InputMethodManager;
+
+/**
+ * Utility class for offloading some class from UI thread
+ */
+public class UiThreadHelper {
+
+    private static HandlerThread sHandlerThread;
+    private static Handler sHandler;
+
+    private static final int MSG_HIDE_KEYBOARD = 1;
+    private static final int MSG_SET_ORIENTATION = 2;
+    private static final int MSG_RUN_COMMAND = 3;
+
+    public static Looper getBackgroundLooper() {
+        if (sHandlerThread == null) {
+            sHandlerThread =
+                    new HandlerThread("UiThreadHelper", Process.THREAD_PRIORITY_FOREGROUND);
+            sHandlerThread.start();
+        }
+        return sHandlerThread.getLooper();
+    }
+
+    private static Handler getHandler(Context context) {
+        if (sHandler == null) {
+            sHandler = new Handler(getBackgroundLooper(),
+                    new UiCallbacks(context.getApplicationContext()));
+        }
+        return sHandler;
+    }
+
+    public static void hideKeyboardAsync(Context context, IBinder token) {
+        Message.obtain(getHandler(context), MSG_HIDE_KEYBOARD, token).sendToTarget();
+    }
+
+    public static void runAsyncCommand(Context context, AsyncCommand command, int arg1, int arg2) {
+        Message.obtain(getHandler(context), MSG_RUN_COMMAND, arg1, arg2, command).sendToTarget();
+    }
+
+    public static void setOrientationAsync(Activity activity, int orientation) {
+        Message.obtain(getHandler(activity), MSG_SET_ORIENTATION, orientation, 0, activity)
+            .sendToTarget();
+    }
+
+    private static class UiCallbacks implements Handler.Callback {
+
+        private final InputMethodManager mIMM;
+
+        UiCallbacks(Context context) {
+            mIMM = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
+        }
+
+        @Override
+        public boolean handleMessage(Message message) {
+            switch (message.what) {
+                case MSG_HIDE_KEYBOARD:
+                    mIMM.hideSoftInputFromWindow((IBinder) message.obj, 0);
+                    return true;
+            }
+            return false;
+        }
+    }
+
+    public interface AsyncCommand {
+
+        void execute(int arg1, int arg2);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/VariantDeviceProfile.kt b/app/src/main/java/foundation/e/blisslauncher/features/test/VariantDeviceProfile.kt
new file mode 100644
index 0000000000000000000000000000000000000000..278f539f3ac7c35d443428f7fdf1536ad7931f0e
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/VariantDeviceProfile.kt
@@ -0,0 +1,527 @@
+package foundation.e.blisslauncher.features.test
+/*
+ * Copyright (C) 2008 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.
+ */
+
+import android.appwidget.AppWidgetHostView
+import android.content.ComponentName
+import android.content.Context
+import android.content.res.Configuration
+import android.content.res.Resources
+import android.graphics.Point
+import android.graphics.PointF
+import android.graphics.Rect
+import android.util.DisplayMetrics
+import android.util.Log
+import android.view.WindowInsets
+import android.view.WindowManager
+import foundation.e.blisslauncher.R
+import foundation.e.blisslauncher.core.Utilities
+import foundation.e.blisslauncher.core.utils.Constants
+import kotlin.math.max
+import kotlin.math.min
+
+class VariantDeviceProfile(
+    val context: Context,
+    val inv: InvariantDeviceProfile,
+    val minSize: Point,
+    val maxSize: Point,
+    val width: Int,
+    val height: Int,
+    val isLandscape: Boolean,
+    @JvmField
+    var isMultiWindowMode: Boolean
+) {
+
+    // Device properties
+    val isTablet: Boolean
+    val isLargeTablet: Boolean
+    val isPhone: Boolean
+    val transposeLayoutWithOrientation: Boolean
+
+    val widthPx: Int
+    val heightPx: Int
+    var availableWidthPx = 0
+    var availableHeightPx = 0
+
+    // Workspace
+    val desiredWorkspaceLeftRightMarginPx: Int
+    val cellLayoutPaddingLeftRightPx: Int
+    val cellLayoutBottomPaddingPx: Int
+    val edgeMarginPx: Int
+    val defaultWidgetPadding: Rect
+    val defaultPageSpacingPx: Int
+    private val topWorkspacePadding: Int
+
+    // Workspace icons
+    var iconSizePx = 0
+    var iconTextSizePx = 0
+    var iconDrawablePaddingPx = 0
+    var iconDrawablePaddingOriginalPx: Int
+    var cellWidthPx = 0
+    var cellHeightPx = 0
+    var workspaceCellPaddingXPx: Int
+    var workspacePageIndicatorHeight: Int
+
+    // Folder
+    var folderIconSizePx = 0
+    var folderIconOffsetYPx = 0
+
+    // Folder cell
+    var folderCellWidthPx = 0
+    var folderCellHeightPx = 0
+
+    // Folder child
+    var folderChildIconSizePx = 0
+    var folderChildTextSizePx = 0
+    var folderChildDrawablePaddingPx = 0
+
+    // Hotseat
+    var hotseatCellHeightPx = 0
+
+    // In portrait: size = height, in landscape: size = width
+    var hotseatBarSizePx: Int
+    val hotseatBarTopPaddingPx: Int
+    var hotseatBarBottomPaddingPx: Int
+    val hotseatBarSidePaddingPx: Int
+
+    val verticalDragHandleSizePx: Int
+
+    // Widget
+    val maxWidgetWidth: Int
+    val maxWidgetHeight: Int
+
+    // Widgets
+    val appWidgetScale = PointF(1.0f, 1.0f)
+
+    private val TAG = "DeviceProfile"
+
+    // Insets
+    val insets = Rect()
+    val workspacePadding = Rect()
+    private val mHotseatPadding = Rect()
+    private var mIsSeascape = false
+
+    fun copy(context: Context): VariantDeviceProfile {
+        val size =
+            Point(availableWidthPx, availableHeightPx)
+        return VariantDeviceProfile(
+            context, inv, size, size, widthPx, heightPx, isLandscape, isMultiWindowMode
+        )
+    }
+
+    /**
+     * Inverse of [.getMultiWindowProfile]
+     * @return device profile corresponding to the current orientation in non multi-window mode.
+     */
+    var fullScreenProfile: VariantDeviceProfile? = null
+        get() = inv.portraitProfile
+
+    fun getMultiWindowProfile(context: Context, mwSize: Point): VariantDeviceProfile {
+        // We take the minimum sizes of this profile and it's multi-window variant to ensure that
+        // the system decor is always excluded.
+        mwSize[Math.min(availableWidthPx, mwSize.x)] =
+            Math.min(availableHeightPx, mwSize.y)
+
+        // In multi-window mode, we can have widthPx = availableWidthPx
+        // and heightPx = availableHeightPx because Launcher uses the InvariantDeviceProfiles'
+        // widthPx and heightPx values where it's needed.
+        val profile = VariantDeviceProfile(
+            context, inv, mwSize, mwSize, mwSize.x, mwSize.y,
+            isLandscape, true
+        )
+
+        // If there isn't enough vertical cell padding with the labels displayed, hide the labels.
+        val workspaceCellPaddingY: Float = (profile.cellSize.y - profile.iconSizePx -
+            iconDrawablePaddingPx - profile.iconTextSizePx).toFloat()
+        if (workspaceCellPaddingY < profile.iconDrawablePaddingPx * 2) {
+            profile.adjustToHideWorkspaceLabels()
+        }
+
+        // We use these scales to measure and layout the widgets using their full invariant profile
+        // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
+        val appWidgetScaleX: Float = profile.cellSize.x as Float / cellSize.x
+        val appWidgetScaleY: Float = profile.cellSize.y as Float / cellSize.y
+        profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY)
+        profile.updateWorkspacePadding()
+        return profile
+    }
+
+    init {
+        var context = context
+        var res = context.resources
+        val dm = res.displayMetrics
+        // Constants from resources
+        isTablet = res.getBoolean(
+            R.bool.is_tablet
+        )
+        isLargeTablet = res.getBoolean(R.bool.is_large_tablet)
+        isPhone = !isTablet && !isLargeTablet
+        // Some more constants
+        transposeLayoutWithOrientation =
+            res.getBoolean(R.bool.hotseat_transpose_layout_with_orientation)
+        context =
+            getContext(
+                context, Configuration.ORIENTATION_PORTRAIT
+            )
+        res = context.resources
+        val cn = ComponentName(
+            context.packageName,
+            this.javaClass.name
+        )
+        defaultWidgetPadding = AppWidgetHostView.getDefaultPaddingForWidget(context, cn, null)
+        edgeMarginPx =
+            res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin)
+        desiredWorkspaceLeftRightMarginPx = edgeMarginPx
+        cellLayoutPaddingLeftRightPx =
+            res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_layout_padding)
+        cellLayoutBottomPaddingPx =
+            res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_layout_bottom_padding)
+        verticalDragHandleSizePx = res.getDimensionPixelSize(
+            R.dimen.vertical_drag_handle_size
+        )
+        defaultPageSpacingPx =
+            res.getDimensionPixelSize(R.dimen.dynamic_grid_workspace_page_spacing)
+        topWorkspacePadding =
+            res.getDimensionPixelSize(R.dimen.dynamic_grid_workspace_top_padding)
+        iconDrawablePaddingOriginalPx =
+            res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding)
+        workspaceCellPaddingXPx =
+            res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x)
+        hotseatBarTopPaddingPx =
+            res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding)
+        hotseatBarBottomPaddingPx =
+            res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_padding)
+        hotseatBarSidePaddingPx =
+            res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding)
+        hotseatBarSizePx =
+            res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_size) + hotseatBarTopPaddingPx + hotseatBarBottomPaddingPx
+        workspacePageIndicatorHeight =
+            res.getDimensionPixelSize(R.dimen.dotSize) * 2 + res.getDimensionPixelSize(R.dimen.dotPadding) * 2
+
+        // Determine sizes.
+        widthPx = width
+        heightPx = height
+        availableWidthPx = minSize.x
+        availableHeightPx = maxSize.y
+        // Calculate all of the remaining variables.
+        updateAvailableDimensions(dm, res)
+        // Now that we have all of the variables calculated, we can tune certain sizes.
+        val aspectRatio =
+            max(widthPx, heightPx).toFloat() / min(
+                widthPx,
+                heightPx
+            )
+        val isTallDevice = aspectRatio.compareTo(TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0
+        if (isPhone && isTallDevice) {
+            // We increase the hotseat size when there is extra space.
+            // ie. For a display with a large aspect ratio, we can keep the icons on the workspace
+            // in portrait mode closer together by adding more height to the hotseat.
+            // Note: This calculation was created after noticing a pattern in the design spec.
+            val extraSpace =
+                cellSize.y - iconSizePx - iconDrawablePaddingPx * 2 - workspacePageIndicatorHeight
+
+            Log.d("DeviceProfile", "$hotseatBarSizePx $extraSpace")
+            val incrementHeight = extraSpace / (inv.numRows + 1)
+            hotseatBarSizePx += incrementHeight
+            cellHeightPx += incrementHeight
+            // Recalculate the available dimensions using the new hotseat size.
+            updateAvailableDimensions(dm, res)
+        }
+        updateWorkspacePadding()
+        // This is done last, after iconSizePx is calculated above.
+        // TODO: mBadgeRenderer = BadgeRenderer(iconSizePx)
+
+        maxWidgetWidth = availableWidthPx - 2 * Utilities.pxFromDp(8f, dm)
+        maxWidgetHeight = cellHeightPx * inv.numRows
+    }
+
+    private fun updateAvailableDimensions(
+        dm: DisplayMetrics,
+        res: Resources
+    ) {
+        updateIconSize(1f, res, dm)
+        // Check to see if the icons fit within the available height.  If not, then scale down.
+        val usedHeight = (cellHeightPx * inv.numRows)
+        val maxHeight = availableHeightPx - totalWorkspacePadding.y
+        if (usedHeight > maxHeight) {
+            val scale = maxHeight / usedHeight.toFloat()
+            updateIconSize(scale, res, dm)
+        }
+
+        updateAvailableFolderCellDimensions(dm, res)
+    }
+
+    private fun updateIconSize(
+        scale: Float,
+        res: Resources,
+        dm: DisplayMetrics
+    ) {
+        val invIconSizePx = inv.iconSize
+        iconSizePx =
+            (Utilities.pxFromDp(
+                invIconSizePx,
+                dm
+            ) * scale).toInt()
+        iconTextSizePx = (Utilities.pxFromSp(
+            inv.iconTextSize,
+            dm
+        ) * scale).toInt()
+        Log.i("Iconsizepx", "" + iconSizePx + " " + invIconSizePx)
+        iconDrawablePaddingPx =
+            res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding)
+        cellHeightPx = (iconSizePx + iconDrawablePaddingPx +
+            Utilities.calculateTextHeight(iconTextSizePx.toFloat()) * 1)
+
+        val cellYPadding = (cellSize.y - cellHeightPx) / 2
+        if (iconDrawablePaddingPx > cellYPadding) {
+            cellHeightPx -= iconDrawablePaddingPx - cellYPadding
+            iconDrawablePaddingPx = cellYPadding
+        }
+        cellWidthPx = iconSizePx + iconDrawablePaddingPx
+        hotseatCellHeightPx = iconSizePx
+
+        // Folder icon
+        folderIconSizePx = iconSizePx
+        folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2
+    }
+
+    private fun updateAvailableFolderCellDimensions(
+        dm: DisplayMetrics,
+        res: Resources
+    ) {
+        val folderBottomPanelSize =
+            (res.getDimensionPixelSize(R.dimen.folder_label_padding_top) +
+                res.getDimensionPixelSize(R.dimen.folder_label_padding_bottom) +
+                Utilities.calculateTextHeight(
+                    res.getDimension(
+                        R.dimen.folder_label_text_size
+                    )
+                ))
+        updateFolderCellSize(1f, dm, res)
+        // Don't let the folder get too close to the edges of the screen.
+        val folderMargin = edgeMarginPx
+        val totalWorkspacePadding = totalWorkspacePadding
+        // Check if the icons fit within the available height.
+        val usedHeight =
+            folderCellHeightPx * inv.numFolderRows + folderBottomPanelSize.toFloat()
+        val maxHeight = availableHeightPx - totalWorkspacePadding.y - folderMargin
+        val scaleY = maxHeight / usedHeight
+        // Check if the icons fit within the available width.
+        val usedWidth = folderCellWidthPx * inv.numFolderColumns.toFloat()
+        val maxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin
+        val scaleX = maxWidth / usedWidth
+        val scale = Math.min(scaleX, scaleY)
+        if (scale < 1f) {
+            updateFolderCellSize(scale, dm, res)
+        }
+    }
+
+    private fun updateFolderCellSize(
+        scale: Float,
+        dm: DisplayMetrics,
+        res: Resources
+    ) {
+        folderChildIconSizePx =
+            (Utilities.pxFromDp(
+                inv.iconSize,
+                dm
+            ) * scale).toInt()
+        folderChildTextSizePx =
+            (res.getDimensionPixelSize(R.dimen.folder_child_text_size) * scale).toInt()
+        val textHeight =
+            Utilities.calculateTextHeight(
+                folderChildTextSizePx.toFloat()
+            )
+        val cellPaddingX =
+            (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding) * scale).toInt()
+        val cellPaddingY =
+            (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding) * scale).toInt()
+        folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX
+        folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight
+        folderChildDrawablePaddingPx = Math.max(
+            0,
+            (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3
+        )
+    }
+
+    fun updateInsets(windowInsets: WindowInsets?) {
+        windowInsets?.let {
+            insets.set(
+                Rect(
+                    it.systemWindowInsetLeft, it.systemWindowInsetTop,
+                    it.systemWindowInsetRight, it.systemWindowInsetBottom
+                )
+            )
+        }
+        updateWorkspacePadding()
+    }
+
+    fun updateInsets(insets: Rect) {
+        this.insets.set(insets)
+        updateWorkspacePadding()
+    }
+
+    // Since we are only concerned with the overall padding, layout direction does not matter.
+    val cellSize: Point
+        get() {
+            val result = Point()
+            val padding = totalWorkspacePadding
+            result.x =
+                calculateCellWidth(
+                    availableWidthPx - padding.x -
+                        cellLayoutPaddingLeftRightPx * 2, inv.numColumns
+                )
+            Log.i("Padding", "$availableHeightPx, $padding, $cellLayoutBottomPaddingPx")
+            result.y =
+                calculateCellHeight(
+                    availableHeightPx - padding.y -
+                        cellLayoutBottomPaddingPx, inv.numRows
+                )
+            return result
+        }
+
+    val totalWorkspacePadding: Point
+        get() {
+            updateWorkspacePadding()
+            return Point(
+                workspacePadding.left + workspacePadding.right,
+                workspacePadding.top + workspacePadding.bottom
+            )
+        }
+
+    /**
+     * Updates [.workspacePadding] as a result of any internal value change to reflect the
+     * new workspace padding
+     */
+    private fun updateWorkspacePadding() {
+        val padding = workspacePadding
+        val paddingBottom = hotseatBarSizePx + workspacePageIndicatorHeight
+        if (isTablet) { // Pad the left and right of the workspace to ensure consistent spacing
+            // between all icons
+            // The amount of screen space available for left/right padding.
+            var availablePaddingX = Math.max(
+                0, widthPx - (inv.numColumns * cellWidthPx +
+                    (inv.numColumns - 1) * cellWidthPx)
+            )
+            availablePaddingX = Math.min(
+                availablePaddingX.toFloat(),
+                widthPx * MAX_HORIZONTAL_PADDING_PERCENT
+            ).toInt()
+            val availablePaddingY = Math.max(
+                0, heightPx - topWorkspacePadding - paddingBottom -
+                    2 * inv.numRows * cellHeightPx - hotseatBarTopPaddingPx -
+                    hotseatBarBottomPaddingPx
+            )
+            padding[availablePaddingX / 2, topWorkspacePadding + availablePaddingY / 2, availablePaddingX / 2] =
+                paddingBottom + availablePaddingY / 2
+        } else { // Pad the top and bottom of the workspace with search/hotseat bar sizes
+            padding[desiredWorkspaceLeftRightMarginPx, topWorkspacePadding, desiredWorkspaceLeftRightMarginPx] =
+                paddingBottom
+        }
+    }
+
+    val hotseatLayoutPadding: Rect
+        get() {
+            // We want the edges of the hotseat to line up with the edges of the workspace, but the
+            // icons in the hotseat are a different size, and so don't line up perfectly. To account
+            // for this, we pad the left and right of the hotseat with half of the difference of a
+            // workspace cell vs a hotseat cell.
+            val workspaceCellWidth = widthPx.toFloat() / inv.numColumns
+            val hotseatCellWidth = widthPx.toFloat() / inv.numHotseatIcons
+            val hotseatAdjustment =
+                Math.round((workspaceCellWidth - hotseatCellWidth) / 2)
+
+            mHotseatPadding[hotseatAdjustment + workspacePadding.left + cellLayoutPaddingLeftRightPx, hotseatBarTopPaddingPx, hotseatAdjustment + workspacePadding.right + cellLayoutPaddingLeftRightPx] =
+                hotseatBarBottomPaddingPx + insets.bottom + cellLayoutBottomPaddingPx
+            Log.d(TAG, "Hotseat padding: $mHotseatPadding, insets: $insets")
+            return mHotseatPadding
+        } // Folders should only appear below the drop target bar and above the hotseat// Folders should only appear right of the drop target bar and left of the hotseat
+
+    /**
+     * @return the bounds for which the open folders should be contained within
+     */
+    val absoluteOpenFolderBounds: Rect
+        get() = Rect(
+            insets.left + edgeMarginPx,
+            insets.top + edgeMarginPx,
+            insets.left + availableWidthPx - edgeMarginPx,
+            insets.top + availableHeightPx - hotseatBarSizePx - -edgeMarginPx
+        )
+
+    fun getCellHeight(containerType: Long): Int {
+        return when (containerType) {
+            Constants.CONTAINER_DESKTOP -> cellHeightPx
+            Constants.CONTAINER_HOTSEAT -> hotseatCellHeightPx
+            else -> 0
+        }
+    }
+
+    /**
+     * Adjusts the profile so that the labels on the Workspace are hidden.
+     * It is important to call this method after the All Apps variables have been set.
+     */
+    private fun adjustToHideWorkspaceLabels() {
+        iconTextSizePx = 0
+        iconDrawablePaddingPx = 0
+        cellHeightPx = iconSizePx
+    }
+
+    fun updateIsSeascape(wm: WindowManager): Boolean {
+        // TODO: Finish it when supporting landscape mode.
+        return false
+    }
+
+    /**
+     * Callback when a component changes the DeviceProfile associated with it, as a result of
+     * configuration change
+     */
+    interface OnDeviceProfileChangeListener {
+        /**
+         * Called when the device profile is reassigned. Note that for layout and measurements, it
+         * is sufficient to listen for inset changes. Use this callback when you need to perform
+         * a one time operation.
+         */
+        fun onDeviceProfileChanged(dp: VariantDeviceProfile?)
+    }
+
+    companion object {
+        /**
+         * The maximum amount of left/right workspace padding as a percentage of the screen width.
+         * To be clear, this means that up to 7% of the screen width can be used as left padding, and
+         * 7% of the screen width can be used as right padding.
+         */
+        private const val MAX_HORIZONTAL_PADDING_PERCENT = 0.14f
+        private const val TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f
+
+        fun calculateCellWidth(width: Int, countX: Int): Int {
+            return width / countX
+        }
+
+        fun calculateCellHeight(height: Int, countY: Int): Int {
+            return height / countY
+        }
+
+        private fun getContext(
+            c: Context,
+            orientation: Int
+        ): Context {
+            val context =
+                Configuration(c.resources.configuration)
+            context.orientation = orientation
+            return c.createConfigurationContext(context)
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/WorkspaceStateTransitionAnimation.java b/app/src/main/java/foundation/e/blisslauncher/features/test/WorkspaceStateTransitionAnimation.java
new file mode 100644
index 0000000000000000000000000000000000000000..84bfbd6a8fe1e2babcaededc240af9d0dd440b79
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/WorkspaceStateTransitionAnimation.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2015 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 foundation.e.blisslauncher.features.test;
+
+import static foundation.e.blisslauncher.features.test.LauncherState.HOTSEAT_ICONS;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_HOTSEAT_SCALE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_HOTSEAT_TRANSLATE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_WORKSPACE_FADE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_WORKSPACE_SCALE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_WORKSPACE_TRANSLATE;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.ZOOM_OUT;
+import static foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils.SCALE_PROPERTY;
+import static foundation.e.blisslauncher.features.test.anim.PropertySetter.NO_ANIM_PROPERTY_SETTER;
+
+import android.view.View;
+import android.view.animation.Interpolator;
+import foundation.e.blisslauncher.core.customviews.LauncherPagedView;
+import foundation.e.blisslauncher.features.launcher.Hotseat;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+import foundation.e.blisslauncher.features.test.anim.PropertySetter;
+import foundation.e.blisslauncher.features.test.dragndrop.DragLayer;
+
+/**
+ * Manages the animations between each of the workspace states.
+ */
+public class WorkspaceStateTransitionAnimation {
+
+    private final TestActivity mLauncher;
+    private final LauncherPagedView mWorkspace;
+
+    private float mNewScale;
+
+    public WorkspaceStateTransitionAnimation(TestActivity launcher, LauncherPagedView workspace) {
+        mLauncher = launcher;
+        mWorkspace = workspace;
+    }
+
+    public void setState(LauncherState toState) {
+        setWorkspaceProperty(toState, NO_ANIM_PROPERTY_SETTER, new AnimatorSetBuilder(),
+                new LauncherStateManager.AnimationConfig());
+    }
+
+    public void setStateWithAnimation(LauncherState toState, AnimatorSetBuilder builder,
+            LauncherStateManager.AnimationConfig config) {
+        setWorkspaceProperty(toState, config.getPropertySetter(builder), builder, config);
+    }
+
+    public float getFinalScale() {
+        return mNewScale;
+    }
+
+    /**
+     * Starts a transition animation for the workspace.
+     */
+    private void setWorkspaceProperty(LauncherState state, PropertySetter propertySetter,
+            AnimatorSetBuilder builder, LauncherStateManager.AnimationConfig config) {
+        LauncherState.ScaleAndTranslation scaleAndTranslation = state.getWorkspaceScaleAndTranslation(mLauncher);
+        LauncherState.ScaleAndTranslation hotseatScaleAndTranslation = state.getHotseatScaleAndTranslation(
+            mLauncher);
+        mNewScale = scaleAndTranslation.scale;
+        LauncherState.PageAlphaProvider pageAlphaProvider = state.getWorkspacePageAlphaProvider(mLauncher);
+        final int childCount = mWorkspace.getChildCount();
+        for (int i = 0; i < childCount; i++) {
+            applyChildState(state, (CellLayout) mWorkspace.getChildAt(i), i, pageAlphaProvider,
+                propertySetter, builder, config);
+        }
+
+        int elements = state.getVisibleElements(mLauncher);
+        Interpolator fadeInterpolator = builder.getInterpolator(ANIM_WORKSPACE_FADE,
+            pageAlphaProvider.interpolator);
+        boolean playAtomicComponent = config.playAtomicOverviewScaleComponent();
+        Hotseat hotseat = mWorkspace.getHotseat();
+        if (playAtomicComponent) {
+            Interpolator scaleInterpolator = builder.getInterpolator(ANIM_WORKSPACE_SCALE, ZOOM_OUT);
+            propertySetter.setFloat(mWorkspace, SCALE_PROPERTY, mNewScale, scaleInterpolator);
+
+            DragLayer dragLayer = mLauncher.getDragLayer();
+            float[] workspacePivot =
+                new float[]{ mWorkspace.getPivotX(), mWorkspace.getPivotY() };
+            dragLayer.getDescendantCoordRelativeToSelf(mWorkspace, workspacePivot);
+            dragLayer.mapCoordInSelfToDescendant(hotseat, workspacePivot);
+            hotseat.setPivotX(workspacePivot[0]);
+            hotseat.setPivotY(workspacePivot[1]);
+            float hotseatScale = hotseatScaleAndTranslation.scale;
+            Interpolator hotseatScaleInterpolator = builder.getInterpolator(ANIM_HOTSEAT_SCALE,
+                scaleInterpolator);
+            propertySetter.setFloat(hotseat, SCALE_PROPERTY, hotseatScale,
+                hotseatScaleInterpolator);
+
+            float hotseatIconsAlpha = (elements & HOTSEAT_ICONS) != 0 ? 1 : 0;
+            propertySetter.setViewAlpha(hotseat, hotseatIconsAlpha, fadeInterpolator);
+            propertySetter.setViewAlpha(mLauncher.getLauncherPagedView().getPageIndicator(),
+                hotseatIconsAlpha, fadeInterpolator);
+        }
+
+        if (!config.playNonAtomicComponent()) {
+            // Only the alpha and scale, handled above, are included in the atomic animation.
+            return;
+        }
+
+        Interpolator translationInterpolator = !playAtomicComponent
+            ? LINEAR
+            : builder.getInterpolator(ANIM_WORKSPACE_TRANSLATE, ZOOM_OUT);
+        propertySetter.setFloat(mWorkspace, View.TRANSLATION_X,
+            scaleAndTranslation.translationX, translationInterpolator);
+        propertySetter.setFloat(mWorkspace, View.TRANSLATION_Y,
+            scaleAndTranslation.translationY, translationInterpolator);
+
+        Interpolator hotseatTranslationInterpolator = builder.getInterpolator(
+            ANIM_HOTSEAT_TRANSLATE, translationInterpolator);
+        propertySetter.setFloat(hotseat, View.TRANSLATION_Y,
+            hotseatScaleAndTranslation.translationY, hotseatTranslationInterpolator);
+        propertySetter.setFloat(mWorkspace.getPageIndicator(), View.TRANSLATION_Y,
+            hotseatScaleAndTranslation.translationY, hotseatTranslationInterpolator);
+
+    }
+
+    public void applyChildState(LauncherState state, CellLayout cl, int childIndex) {
+        applyChildState(state, cl, childIndex, state.getWorkspacePageAlphaProvider(mLauncher),
+                NO_ANIM_PROPERTY_SETTER, new AnimatorSetBuilder(), new LauncherStateManager.AnimationConfig());
+    }
+
+    private void applyChildState(LauncherState state, CellLayout cl, int childIndex,
+            LauncherState.PageAlphaProvider pageAlphaProvider, PropertySetter propertySetter,
+            AnimatorSetBuilder builder, LauncherStateManager.AnimationConfig config) {
+        float pageAlpha = pageAlphaProvider.getPageAlpha(childIndex);
+        int drawableAlpha = Math.round(pageAlpha * (state.hasWorkspacePageBackground ? 255 : 0));
+
+        if (config.playAtomicOverviewScaleComponent()) {
+            Interpolator fadeInterpolator = builder.getInterpolator(ANIM_WORKSPACE_FADE,
+                pageAlphaProvider.interpolator);
+            propertySetter.setFloat(cl, View.ALPHA,
+                pageAlpha, fadeInterpolator);
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/AlphaUpdateListener.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/AlphaUpdateListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6a748cf4247c27f11b69a82569ccf4a3a7bdb02
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/AlphaUpdateListener.java
@@ -0,0 +1,61 @@
+/*
+ * 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 foundation.e.blisslauncher.features.test.anim;
+
+import android.animation.Animator;
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.view.View;
+
+/**
+ * A convenience class to update a view's visibility state after an alpha animation.
+ */
+public class AlphaUpdateListener extends AnimationSuccessListener
+        implements AnimatorUpdateListener {
+    private static final float ALPHA_CUTOFF_THRESHOLD = 0.01f;
+
+    private View mView;
+
+    public AlphaUpdateListener(View v) {
+        mView = v;
+    }
+
+    @Override
+    public void onAnimationUpdate(ValueAnimator arg0) {
+        updateVisibility(mView);
+    }
+
+    @Override
+    public void onAnimationSuccess(Animator animator) {
+        updateVisibility(mView);
+    }
+
+    @Override
+    public void onAnimationStart(Animator arg0) {
+        // We want the views to be visible for animation, so fade-in/out is visible
+        mView.setVisibility(View.VISIBLE);
+    }
+
+    public static void updateVisibility(View view) {
+        if (view.getAlpha() < ALPHA_CUTOFF_THRESHOLD && view.getVisibility() != View.INVISIBLE) {
+            view.setVisibility(View.INVISIBLE);
+        } else if (view.getAlpha() > ALPHA_CUTOFF_THRESHOLD
+                && view.getVisibility() != View.VISIBLE) {
+            view.setVisibility(View.VISIBLE);
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/AnimationSuccessListener.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/AnimationSuccessListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..6272fc3161ef60d199552d682493bc7073d81b1e
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/AnimationSuccessListener.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package foundation.e.blisslauncher.features.test.anim;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+
+/**
+ * Extension of {@link AnimatorListenerAdapter} for listening for non-cancelled animations
+ */
+public abstract class AnimationSuccessListener extends AnimatorListenerAdapter {
+
+    protected boolean mCancelled = false;
+
+    @Override
+    public void onAnimationCancel(Animator animation) {
+        mCancelled = true;
+    }
+
+    @Override
+    public void onAnimationEnd(Animator animation) {
+        if (!mCancelled) {
+            onAnimationSuccess(animation);
+        }
+    }
+
+    public abstract void onAnimationSuccess(Animator animator);
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/AnimatorPlaybackController.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/AnimatorPlaybackController.java
new file mode 100644
index 0000000000000000000000000000000000000000..e12b7fbc013ab5eaa5d896330d3d4704a95d2d24
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/AnimatorPlaybackController.java
@@ -0,0 +1,409 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.features.test.anim;
+
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+
+import android.animation.Animator;
+import android.animation.Animator.AnimatorListener;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.TimeInterpolator;
+import android.animation.ValueAnimator;
+import android.util.Log;
+import androidx.dynamicanimation.animation.DynamicAnimation;
+import androidx.dynamicanimation.animation.SpringAnimation;
+import foundation.e.blisslauncher.core.Flags;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Helper class to control the playback of an {@link AnimatorSet}, with custom interpolators
+ * and durations.
+ *
+ * Note: The implementation does not support start delays on child animations or
+ * sequential playbacks.
+ */
+public abstract class AnimatorPlaybackController implements ValueAnimator.AnimatorUpdateListener {
+
+    private static final String TAG = "AnimatorPlaybackCtrler";
+    private static boolean DEBUG = false;
+
+    public static AnimatorPlaybackController wrap(AnimatorSet anim, long duration) {
+        return wrap(anim, duration, null);
+    }
+
+    /**
+     * Creates an animation controller for the provided animation.
+     * The actual duration does not matter as the animation is manually controlled. It just
+     * needs to be larger than the total number of pixels so that we don't have jittering due
+     * to float (animation-fraction * total duration) to int conversion.
+     */
+    public static AnimatorPlaybackController wrap(AnimatorSet anim, long duration,
+            Runnable onCancelRunnable) {
+
+        /**
+         * TODO: use {@link AnimatorSet#setCurrentPlayTime(long)} once b/68382377 is fixed.
+         */
+        return new AnimatorPlaybackControllerVL(anim, duration, onCancelRunnable);
+    }
+
+    private final ValueAnimator mAnimationPlayer;
+    private final long mDuration;
+
+    protected final AnimatorSet mAnim;
+    private Set<SpringAnimation> mSprings;
+
+    protected float mCurrentFraction;
+    private Runnable mEndAction;
+
+    protected boolean mTargetCancelled = false;
+    protected Runnable mOnCancelRunnable;
+
+    private OnAnimationEndDispatcher mEndListener;
+    private DynamicAnimation.OnAnimationEndListener mSpringEndListener;
+    // We need this variable to ensure the end listener is called immediately, otherwise we run into
+    // issues where the callback interferes with the states of the swipe detector.
+    private boolean mSkipToEnd = false;
+
+    protected AnimatorPlaybackController(AnimatorSet anim, long duration,
+            Runnable onCancelRunnable) {
+        mAnim = anim;
+        mDuration = duration;
+        mOnCancelRunnable = onCancelRunnable;
+
+        mAnimationPlayer = ValueAnimator.ofFloat(0, 1);
+        mAnimationPlayer.setInterpolator(LINEAR);
+        mEndListener = new OnAnimationEndDispatcher();
+        mAnimationPlayer.addListener(mEndListener);
+        mAnimationPlayer.addUpdateListener(this);
+
+        mAnim.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationCancel(Animator animation) {
+                mTargetCancelled = true;
+                if (mOnCancelRunnable != null) {
+                    mOnCancelRunnable.run();
+                    mOnCancelRunnable = null;
+                }
+            }
+
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mTargetCancelled = false;
+                mOnCancelRunnable = null;
+            }
+
+            @Override
+            public void onAnimationStart(Animator animation) {
+                mTargetCancelled = false;
+            }
+        });
+
+        mSprings = new HashSet<>();
+        mSpringEndListener = (animation, canceled, value, velocity1) -> {
+            if (canceled) {
+                mEndListener.onAnimationCancel(mAnimationPlayer);
+            } else {
+                mEndListener.onAnimationEnd(mAnimationPlayer);
+            }
+        };
+    }
+
+    public AnimatorSet getTarget() {
+        return mAnim;
+    }
+
+    public long getDuration() {
+        return mDuration;
+    }
+
+    public TimeInterpolator getInterpolator() {
+        return mAnim.getInterpolator() != null ? mAnim.getInterpolator() : LINEAR;
+    }
+
+    /**
+     * Starts playing the animation forward from current position.
+     */
+    public void start() {
+        mAnimationPlayer.setFloatValues(mCurrentFraction, 1);
+        mAnimationPlayer.setDuration(clampDuration(1 - mCurrentFraction));
+        mAnimationPlayer.start();
+    }
+
+    /**
+     * Starts playing the animation backwards from current position
+     */
+    public void reverse() {
+        mAnimationPlayer.setFloatValues(mCurrentFraction, 0);
+        mAnimationPlayer.setDuration(clampDuration(mCurrentFraction));
+        mAnimationPlayer.start();
+    }
+
+    /**
+     * Pauses the currently playing animation.
+     */
+    public void pause() {
+        mAnimationPlayer.cancel();
+    }
+
+    /**
+     * Returns the underlying animation used for controlling the set.
+     */
+    public ValueAnimator getAnimationPlayer() {
+        return mAnimationPlayer;
+    }
+
+    /**
+     * Sets the current animation position and updates all the child animators accordingly.
+     */
+    public abstract void setPlayFraction(float fraction);
+
+    public float getProgressFraction() {
+        return mCurrentFraction;
+    }
+
+    public float getInterpolatedProgress() {
+        return getInterpolator().getInterpolation(mCurrentFraction);
+    }
+
+    /**
+     * Sets the action to be called when the animation is completed. Also clears any
+     * previously set action.
+     */
+    public void setEndAction(Runnable runnable) {
+        mEndAction = runnable;
+    }
+
+    @Override
+    public void onAnimationUpdate(ValueAnimator valueAnimator) {
+        setPlayFraction((float) valueAnimator.getAnimatedValue());
+    }
+
+    protected long clampDuration(float fraction) {
+        float playPos = mDuration * fraction;
+        if (playPos <= 0) {
+            return 0;
+        } else {
+            return Math.min((long) playPos, mDuration);
+        }
+    }
+
+    /**
+     * Starts playback and sets the spring.
+     */
+    public void dispatchOnStartWithVelocity(float end, float velocity) {
+        if (!Flags.QUICKSTEP_SPRINGS) {
+            dispatchOnStart();
+            return;
+        }
+
+        if (DEBUG) Log.d(TAG, "dispatchOnStartWithVelocity#end=" + end + ", velocity=" + velocity);
+
+        for (Animator a : mAnim.getChildAnimations()) {
+            if (a instanceof SpringObjectAnimator) {
+                if (DEBUG) Log.d(TAG, "Found springAnimator=" + a);
+                SpringObjectAnimator springAnimator = (SpringObjectAnimator) a;
+                mSprings.add(springAnimator.getSpring());
+                springAnimator.startSpring(end, velocity, mSpringEndListener);
+            }
+        }
+
+        dispatchOnStart();
+    }
+
+    public void dispatchOnStart() {
+        dispatchOnStartRecursively(mAnim);
+    }
+
+    private void dispatchOnStartRecursively(Animator animator) {
+        List<AnimatorListener> listeners = animator instanceof SpringObjectAnimator
+                ? nonNullList(((SpringObjectAnimator) animator).getObjectAnimatorListeners())
+                : nonNullList(animator.getListeners());
+
+        for (AnimatorListener l : listeners) {
+            l.onAnimationStart(animator);
+        }
+
+        if (animator instanceof AnimatorSet) {
+            for (Animator anim : nonNullList(((AnimatorSet) animator).getChildAnimations())) {
+                dispatchOnStartRecursively(anim);
+            }
+        }
+    }
+
+    public void dispatchOnCancel() {
+        dispatchOnCancelRecursively(mAnim);
+    }
+
+    private void dispatchOnCancelRecursively(Animator animator) {
+        for (AnimatorListener l : nonNullList(animator.getListeners())) {
+            l.onAnimationCancel(animator);
+        }
+
+        if (animator instanceof AnimatorSet) {
+            for (Animator anim : nonNullList(((AnimatorSet) animator).getChildAnimations())) {
+                dispatchOnCancelRecursively(anim);
+            }
+        }
+    }
+
+    public void dispatchSetInterpolator(TimeInterpolator interpolator) {
+        dispatchSetInterpolatorRecursively(mAnim, interpolator);
+    }
+
+    private void dispatchSetInterpolatorRecursively(Animator anim, TimeInterpolator interpolator) {
+        anim.setInterpolator(interpolator);
+        if (anim instanceof AnimatorSet) {
+            for (Animator child : nonNullList(((AnimatorSet) anim).getChildAnimations())) {
+                dispatchSetInterpolatorRecursively(child, interpolator);
+            }
+        }
+    }
+
+    public void setOnCancelRunnable(Runnable runnable) {
+        mOnCancelRunnable = runnable;
+    }
+
+    public Runnable getOnCancelRunnable() {
+        return mOnCancelRunnable;
+    }
+
+    public void skipToEnd() {
+        mSkipToEnd = true;
+        for (SpringAnimation spring : mSprings) {
+            if (spring.canSkipToEnd()) {
+                spring.skipToEnd();
+            }
+        }
+        mAnimationPlayer.end();
+        mSkipToEnd = false;
+    }
+
+    public static class AnimatorPlaybackControllerVL extends AnimatorPlaybackController {
+
+        private final ValueAnimator[] mChildAnimations;
+
+        private AnimatorPlaybackControllerVL(AnimatorSet anim, long duration,
+                Runnable onCancelRunnable) {
+            super(anim, duration, onCancelRunnable);
+
+            // Build animation list
+            ArrayList<ValueAnimator> childAnims = new ArrayList<>();
+            getAnimationsRecur(mAnim, childAnims);
+            mChildAnimations = childAnims.toArray(new ValueAnimator[childAnims.size()]);
+        }
+
+        private void getAnimationsRecur(AnimatorSet anim, ArrayList<ValueAnimator> out) {
+            long forceDuration = anim.getDuration();
+            TimeInterpolator forceInterpolator = anim.getInterpolator();
+            for (Animator child : anim.getChildAnimations()) {
+                if (forceDuration > 0) {
+                    child.setDuration(forceDuration);
+                }
+                if (forceInterpolator != null) {
+                    child.setInterpolator(forceInterpolator);
+                }
+                if (child instanceof ValueAnimator) {
+                    out.add((ValueAnimator) child);
+                } else if (child instanceof AnimatorSet) {
+                    getAnimationsRecur((AnimatorSet) child, out);
+                } else {
+                    throw new RuntimeException("Unknown animation type " + child);
+                }
+            }
+        }
+
+        @Override
+        public void setPlayFraction(float fraction) {
+            mCurrentFraction = fraction;
+            // Let the animator report the progress but don't apply the progress to child
+            // animations if it has been cancelled.
+            if (mTargetCancelled) {
+                return;
+            }
+            long playPos = clampDuration(fraction);
+            for (ValueAnimator anim : mChildAnimations) {
+                anim.setCurrentPlayTime(Math.min(playPos, anim.getDuration()));
+            }
+        }
+    }
+
+    private boolean isAnySpringRunning() {
+        for (SpringAnimation spring : mSprings) {
+            if (spring.isRunning()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Only dispatches the on end actions once the animator and all springs have completed running.
+     */
+    private class OnAnimationEndDispatcher extends AnimationSuccessListener {
+
+        boolean mAnimatorDone = false;
+        boolean mSpringsDone = false;
+        boolean mDispatched = false;
+
+        @Override
+        public void onAnimationStart(Animator animation) {
+            mCancelled = false;
+            mDispatched = false;
+        }
+
+        @Override
+        public void onAnimationSuccess(Animator animator) {
+            if (mSprings.isEmpty()) {
+                mSpringsDone = mAnimatorDone = true;
+            }
+            if (isAnySpringRunning()) {
+                mAnimatorDone = true;
+            } else {
+                mSpringsDone = true;
+            }
+
+            // We wait for the spring (if any) to finish running before completing the end callback.
+            if (!mDispatched && (mSkipToEnd || (mAnimatorDone && mSpringsDone))) {
+                dispatchOnEndRecursively(mAnim);
+                if (mEndAction != null) {
+                    mEndAction.run();
+                }
+                mDispatched = true;
+            }
+        }
+
+        private void dispatchOnEndRecursively(Animator animator) {
+            for (AnimatorListener l : nonNullList(animator.getListeners())) {
+                l.onAnimationEnd(animator);
+            }
+
+            if (animator instanceof AnimatorSet) {
+                for (Animator anim : nonNullList(((AnimatorSet) animator).getChildAnimations())) {
+                    dispatchOnEndRecursively(anim);
+                }
+            }
+        }
+    }
+
+    private static <T> List<T> nonNullList(ArrayList<T> list) {
+        return list == null ? Collections.emptyList() : list;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/AnimatorSetBuilder.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/AnimatorSetBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..d00f2f3d451f17bcff9d114c73a9a979513a8aa5
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/AnimatorSetBuilder.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.features.test.anim;
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.util.SparseArray;
+import android.view.animation.Interpolator;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Utility class for building animator set
+ */
+public class AnimatorSetBuilder {
+
+    public static final int ANIM_VERTICAL_PROGRESS = 0;
+    public static final int ANIM_WORKSPACE_SCALE = 1;
+    public static final int ANIM_WORKSPACE_TRANSLATE = 2;
+    public static final int ANIM_WORKSPACE_FADE = 3;
+    public static final int ANIM_HOTSEAT_SCALE = 4;
+    public static final int ANIM_HOTSEAT_TRANSLATE = 5;
+    public static final int ANIM_OVERVIEW_SCALE = 6;
+    public static final int ANIM_OVERVIEW_TRANSLATE_X = 7;
+    public static final int ANIM_OVERVIEW_TRANSLATE_Y = 8;
+    public static final int ANIM_OVERVIEW_FADE = 9;
+
+    public static final int FLAG_DONT_ANIMATE_OVERVIEW = 1 << 0;
+
+    protected final ArrayList<Animator> mAnims = new ArrayList<>();
+
+    private final SparseArray<Interpolator> mInterpolators = new SparseArray<>();
+    private List<Runnable> mOnFinishRunnables = new ArrayList<>();
+    private int mFlags = 0;
+
+    /**
+     * Associates a tag with all the animations added after this call.
+     */
+    public void startTag(Object obj) { }
+
+    public void play(Animator anim) {
+        mAnims.add(anim);
+    }
+
+    public void addOnFinishRunnable(Runnable onFinishRunnable) {
+        mOnFinishRunnables.add(onFinishRunnable);
+    }
+
+    public AnimatorSet build() {
+        AnimatorSet anim = LauncherAnimUtils.createAnimatorSet();
+        anim.playTogether(mAnims);
+        if (!mOnFinishRunnables.isEmpty()) {
+            anim.addListener(new AnimationSuccessListener() {
+                @Override
+                public void onAnimationSuccess(Animator animation) {
+                    for (Runnable onFinishRunnable : mOnFinishRunnables) {
+                        onFinishRunnable.run();
+                    }
+                    mOnFinishRunnables.clear();
+                }
+            });
+        }
+        return anim;
+    }
+
+    public Interpolator getInterpolator(int animId, Interpolator fallback) {
+        return mInterpolators.get(animId, fallback);
+    }
+
+    public void setInterpolator(int animId, Interpolator interpolator) {
+        mInterpolators.put(animId, interpolator);
+    }
+
+    public void addFlag(int flag) {
+        mFlags |= flag;
+    }
+
+    public boolean hasFlag(int flag) {
+        return (mFlags & flag) != 0;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/FirstFrameAnimatorHelper.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/FirstFrameAnimatorHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc94383aa951d95c530156cd97daa3ec4373995d
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/FirstFrameAnimatorHelper.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2013 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 foundation.e.blisslauncher.features.test.anim;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewPropertyAnimator;
+import android.view.ViewTreeObserver;
+
+/*
+ *  This is a helper class that listens to updates from the corresponding animation.
+ *  For the first two frames, it adjusts the current play time of the animation to
+ *  prevent jank at the beginning of the animation
+ */
+public class FirstFrameAnimatorHelper extends AnimatorListenerAdapter
+    implements ValueAnimator.AnimatorUpdateListener {
+    private static final String TAG = "FirstFrameAnimatorHlpr";
+    private static final boolean DEBUG = false;
+    private static final int MAX_DELAY = 1000;
+    private static final long SINGLE_FRAME_MS = 16;
+    private final View mTarget;
+    private long mStartFrame;
+    private long mStartTime = -1;
+    private boolean mHandlingOnAnimationUpdate;
+    private boolean mAdjustedSecondFrameTime;
+
+    private static ViewTreeObserver.OnDrawListener sGlobalDrawListener;
+    static long sGlobalFrameCounter;
+    private static boolean sVisible;
+
+    public FirstFrameAnimatorHelper(ValueAnimator animator, View target) {
+        mTarget = target;
+        animator.addUpdateListener(this);
+    }
+
+    public FirstFrameAnimatorHelper(ViewPropertyAnimator vpa, View target) {
+        mTarget = target;
+        vpa.setListener(this);
+    }
+
+    // only used for ViewPropertyAnimators
+    public void onAnimationStart(Animator animation) {
+        final ValueAnimator va = (ValueAnimator) animation;
+        va.addUpdateListener(FirstFrameAnimatorHelper.this);
+        onAnimationUpdate(va);
+    }
+
+    public static void setIsVisible(boolean visible) {
+        sVisible = visible;
+    }
+
+    public static void initializeDrawListener(View view) {
+        if (sGlobalDrawListener != null) {
+            view.getViewTreeObserver().removeOnDrawListener(sGlobalDrawListener);
+        }
+
+        sGlobalDrawListener = () -> sGlobalFrameCounter++;
+        view.getViewTreeObserver().addOnDrawListener(sGlobalDrawListener);
+        sVisible = true;
+    }
+
+    public void onAnimationUpdate(final ValueAnimator animation) {
+        final long currentTime = System.currentTimeMillis();
+        if (mStartTime == -1) {
+            mStartFrame = sGlobalFrameCounter;
+            mStartTime = currentTime;
+        }
+
+        final long currentPlayTime = animation.getCurrentPlayTime();
+        boolean isFinalFrame = Float.compare(1f, animation.getAnimatedFraction()) == 0;
+
+        if (!mHandlingOnAnimationUpdate &&
+            sVisible &&
+            // If the current play time exceeds the duration, or the animated fraction is 1,
+            // the animation will get finished, even if we call setCurrentPlayTime -- therefore
+            // don't adjust the animation in that case
+            currentPlayTime < animation.getDuration() && !isFinalFrame) {
+            mHandlingOnAnimationUpdate = true;
+            long frameNum = sGlobalFrameCounter - mStartFrame;
+            // If we haven't drawn our first frame, reset the time to t = 0
+            // (give up after MAX_DELAY ms of waiting though - might happen, for example, if we
+            // are no longer in the foreground and no frames are being rendered ever)
+            if (frameNum == 0 && currentTime < mStartTime + MAX_DELAY && currentPlayTime > 0) {
+                // The first frame on animations doesn't always trigger an invalidate...
+                // force an invalidate here to make sure the animation continues to advance
+                mTarget.getRootView().invalidate();
+                animation.setCurrentPlayTime(0);
+            // For the second frame, if the first frame took more than 16ms,
+            // adjust the start time and pretend it took only 16ms anyway. This
+            // prevents a large jump in the animation due to an expensive first frame
+            } else if (frameNum == 1 && currentTime < mStartTime + MAX_DELAY &&
+                       !mAdjustedSecondFrameTime &&
+                       currentTime > mStartTime + SINGLE_FRAME_MS &&
+                       currentPlayTime > SINGLE_FRAME_MS) {
+                animation.setCurrentPlayTime(SINGLE_FRAME_MS);
+                mAdjustedSecondFrameTime = true;
+            } else {
+                if (frameNum > 1) {
+                    mTarget.post(new Runnable() {
+                            public void run() {
+                                animation.removeUpdateListener(FirstFrameAnimatorHelper.this);
+                            }
+                        });
+                }
+                if (DEBUG) print(animation);
+            }
+            mHandlingOnAnimationUpdate = false;
+        } else {
+            if (DEBUG) print(animation);
+        }
+    }
+
+    public void print(ValueAnimator animation) {
+        float flatFraction = animation.getCurrentPlayTime() / (float) animation.getDuration();
+        Log.d(TAG, sGlobalFrameCounter +
+              "(" + (sGlobalFrameCounter - mStartFrame) + ") " + mTarget + " dirty? " +
+              mTarget.isDirty() + " " + flatFraction + " " + this + " " + animation);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/FlingSpringAnim.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/FlingSpringAnim.java
new file mode 100644
index 0000000000000000000000000000000000000000..244922ab62723099442073b262d9651b89f8f944
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/FlingSpringAnim.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.features.test.anim;
+
+import androidx.dynamicanimation.animation.DynamicAnimation.OnAnimationEndListener;
+import androidx.dynamicanimation.animation.FlingAnimation;
+import androidx.dynamicanimation.animation.FloatPropertyCompat;
+import androidx.dynamicanimation.animation.SpringAnimation;
+import androidx.dynamicanimation.animation.SpringForce;
+
+/**
+ * Given a property to animate and a target value and starting velocity, first apply friction to
+ * the fling until we pass the target, then apply a spring force to pull towards the target.
+ */
+public class FlingSpringAnim {
+
+    private static final float FLING_FRICTION = 1.5f;
+    private static final float SPRING_STIFFNESS = 200;
+    private static final float SPRING_DAMPING = 0.8f;
+
+    private final FlingAnimation mFlingAnim;
+    private SpringAnimation mSpringAnim;
+
+    private float mTargetPosition;
+
+    public <K> FlingSpringAnim(K object, FloatPropertyCompat<K> property, float startPosition,
+            float targetPosition, float startVelocity, float minVisChange, float minValue,
+            float maxValue, float springVelocityFactor, OnAnimationEndListener onEndListener) {
+        mFlingAnim = new FlingAnimation(object, property)
+                .setFriction(FLING_FRICTION)
+                // Have the spring pull towards the target if we've slowed down too much before
+                // reaching it.
+                .setMinimumVisibleChange(minVisChange)
+                .setStartVelocity(startVelocity)
+                .setMinValue(minValue)
+                .setMaxValue(maxValue);
+        mTargetPosition = targetPosition;
+
+        mFlingAnim.addEndListener(((animation, canceled, value, velocity) -> {
+            mSpringAnim = new SpringAnimation(object, property)
+                    .setStartValue(value)
+                    .setStartVelocity(velocity * springVelocityFactor)
+                    .setSpring(new SpringForce(mTargetPosition)
+                            .setStiffness(SPRING_STIFFNESS)
+                            .setDampingRatio(SPRING_DAMPING));
+            mSpringAnim.addEndListener(onEndListener);
+            mSpringAnim.animateToFinalPosition(mTargetPosition);
+        }));
+    }
+
+    public float getTargetPosition() {
+        return mTargetPosition;
+    }
+
+    public void updatePosition(float startPosition, float targetPosition) {
+        mFlingAnim.setMinValue(Math.min(startPosition, targetPosition))
+                .setMaxValue(Math.max(startPosition, targetPosition));
+        mTargetPosition = targetPosition;
+        if (mSpringAnim != null) {
+            mSpringAnim.animateToFinalPosition(mTargetPosition);
+        }
+    }
+
+    public void start() {
+        mFlingAnim.start();
+    }
+
+    public void end() {
+        mFlingAnim.cancel();
+        if (mSpringAnim.canSkipToEnd()) {
+            mSpringAnim.skipToEnd();
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/Interpolators.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/Interpolators.java
new file mode 100644
index 0000000000000000000000000000000000000000..42415327ffe837ad8f6c0f2e6ad660d458632c92
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/Interpolators.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package foundation.e.blisslauncher.features.test.anim;
+
+import static foundation.e.blisslauncher.core.Utilities.SINGLE_FRAME_MS;
+
+import android.graphics.Path;
+import android.view.animation.AccelerateDecelerateInterpolator;
+import android.view.animation.AccelerateInterpolator;
+import android.view.animation.DecelerateInterpolator;
+import android.view.animation.Interpolator;
+import android.view.animation.LinearInterpolator;
+import android.view.animation.OvershootInterpolator;
+import android.view.animation.PathInterpolator;
+import foundation.e.blisslauncher.core.Utilities;
+
+/**
+ * Common interpolators used in Launcher
+ */
+public class Interpolators {
+
+    public static final Interpolator LINEAR = new LinearInterpolator();
+
+    public static final Interpolator ACCEL = new AccelerateInterpolator();
+    public static final Interpolator ACCEL_1_5 = new AccelerateInterpolator(1.5f);
+    public static final Interpolator ACCEL_2 = new AccelerateInterpolator(2);
+
+    public static final Interpolator DEACCEL = new DecelerateInterpolator();
+    public static final Interpolator DEACCEL_1_5 = new DecelerateInterpolator(1.5f);
+    public static final Interpolator DEACCEL_1_7 = new DecelerateInterpolator(1.7f);
+    public static final Interpolator DEACCEL_2 = new DecelerateInterpolator(2);
+    public static final Interpolator DEACCEL_2_5 = new DecelerateInterpolator(2.5f);
+    public static final Interpolator DEACCEL_3 = new DecelerateInterpolator(3f);
+
+    public static final Interpolator ACCEL_DEACCEL = new AccelerateDecelerateInterpolator();
+
+    public static final Interpolator FAST_OUT_SLOW_IN = new PathInterpolator(0.4f, 0f, 0.2f, 1f);
+
+    public static final Interpolator AGGRESSIVE_EASE = new PathInterpolator(0.2f, 0f, 0f, 1f);
+    public static final Interpolator AGGRESSIVE_EASE_IN_OUT = new PathInterpolator(0.6f,0, 0.4f, 1);
+
+    public static final Interpolator EXAGGERATED_EASE;
+
+    public static final Interpolator INSTANT = t -> 1;
+
+    private static final int MIN_SETTLE_DURATION = 200;
+    private static final float OVERSHOOT_FACTOR = 0.9f;
+
+    static {
+        Path exaggeratedEase = new Path();
+        exaggeratedEase.moveTo(0, 0);
+        exaggeratedEase.cubicTo(0.05f, 0f, 0.133333f, 0.08f, 0.166666f, 0.4f);
+        exaggeratedEase.cubicTo(0.225f, 0.94f, 0.5f, 1f, 1f, 1f);
+        EXAGGERATED_EASE = new PathInterpolator(exaggeratedEase);
+    }
+
+    public static final Interpolator OVERSHOOT_1_2 = new OvershootInterpolator(1.2f);
+    public static final Interpolator OVERSHOOT_1_7 = new OvershootInterpolator(1.7f);
+
+    public static final Interpolator TOUCH_RESPONSE_INTERPOLATOR =
+            new PathInterpolator(0.3f, 0f, 0.1f, 1f);
+
+    /**
+     * Inversion of ZOOM_OUT, compounded with an ease-out.
+     */
+    public static final Interpolator ZOOM_IN = new Interpolator() {
+        @Override
+        public float getInterpolation(float v) {
+            return DEACCEL_3.getInterpolation(1 - ZOOM_OUT.getInterpolation(1 - v));
+        }
+    };
+
+    public static final Interpolator ZOOM_OUT = new Interpolator() {
+
+        private static final float FOCAL_LENGTH = 0.35f;
+
+        @Override
+        public float getInterpolation(float v) {
+            return zInterpolate(v);
+        }
+
+        /**
+         * This interpolator emulates the rate at which the perceived scale of an object changes
+         * as its distance from a camera increases. When this interpolator is applied to a scale
+         * animation on a view, it evokes the sense that the object is shrinking due to moving away
+         * from the camera.
+         */
+        private float zInterpolate(float input) {
+            return (1.0f - FOCAL_LENGTH / (FOCAL_LENGTH + input)) /
+                    (1.0f - FOCAL_LENGTH / (FOCAL_LENGTH + 1.0f));
+        }
+    };
+
+    public static final Interpolator SCROLL = new Interpolator() {
+        @Override
+        public float getInterpolation(float t) {
+            t -= 1.0f;
+            return t*t*t*t*t + 1;
+        }
+    };
+
+    public static final Interpolator SCROLL_CUBIC = new Interpolator() {
+        @Override
+        public float getInterpolation(float t) {
+            t -= 1.0f;
+            return t*t*t + 1;
+        }
+    };
+
+    private static final float FAST_FLING_PX_MS = 10;
+
+    public static Interpolator scrollInterpolatorForVelocity(float velocity) {
+        return Math.abs(velocity) > FAST_FLING_PX_MS ? SCROLL : SCROLL_CUBIC;
+    }
+
+    /**
+     * Runs the given interpolator such that the entire progress is set between the given bounds.
+     * That is, we set the interpolation to 0 until lowerBound and reach 1 by upperBound.
+     */
+    public static Interpolator clampToProgress(
+        Interpolator interpolator, float lowerBound,
+            float upperBound) {
+        if (upperBound <= lowerBound) {
+            throw new IllegalArgumentException("lowerBound must be less than upperBound");
+        }
+        return t -> {
+            if (t < lowerBound) {
+                return 0;
+            }
+            if (t > upperBound) {
+                return 1;
+            }
+            return interpolator.getInterpolation((t - lowerBound) / (upperBound - lowerBound));
+        };
+    }
+
+    /**
+     * Create an OvershootInterpolator with tension directly related to the velocity (in px/ms).
+     * @param velocity The start velocity of the animation we want to overshoot.
+     */
+    public static Interpolator overshootInterpolatorForVelocity(float velocity) {
+        return new OvershootInterpolator(Math.min(Math.abs(velocity), 3f));
+    }
+
+    /**
+     * Runs the given interpolator such that the interpolated value is mapped to the given range.
+     * This is useful, for example, if we only use this interpolator for part of the animation,
+     * such as to take over a user-controlled animation when they let go.
+     */
+    public static Interpolator mapToProgress(Interpolator interpolator, float lowerBound,
+        float upperBound) {
+        return t -> Utilities.mapRange(interpolator.getInterpolation(t), lowerBound, upperBound);
+    }
+
+    /**
+     * Computes parameters necessary for an overshoot effect.
+     */
+    public static class OvershootParams {
+        public Interpolator interpolator;
+        public float start;
+        public float end;
+        public long duration;
+
+        /**
+         * Given the input params, sets OvershootParams variables to be used by the caller.
+         * @param startProgress The progress from 0 to 1 that the overshoot starts from.
+         * @param overshootPastProgress The progress from 0 to 1 where we overshoot past (should
+         *        either be equal to startProgress or endProgress, depending on if we want to
+         *        overshoot immediately or only once we reach the end).
+         * @param endProgress The final progress from 0 to 1 that we will settle to.
+         * @param velocityPxPerMs The initial velocity that causes this overshoot.
+         * @param totalDistancePx The distance against which progress is calculated.
+         */
+        public OvershootParams(float startProgress, float overshootPastProgress,
+            float endProgress, float velocityPxPerMs, int totalDistancePx) {
+            velocityPxPerMs = Math.abs(velocityPxPerMs);
+            start = startProgress;
+            int startPx = (int) (start * totalDistancePx);
+            // Overshoot by about half a frame.
+            float overshootBy = OVERSHOOT_FACTOR * velocityPxPerMs *
+                SINGLE_FRAME_MS / totalDistancePx / 2;
+            overshootBy = Utilities.boundToRange(overshootBy, 0.02f, 0.15f);
+            end = overshootPastProgress + overshootBy;
+            int endPx = (int) (end  * totalDistancePx);
+            int overshootDistance = endPx - startPx;
+            // Calculate deceleration necessary to reach overshoot distance.
+            // Formula: velocityFinal^2 = velocityInitial^2 + 2 * acceleration * distance
+            //          0 = v^2 + 2ad (velocityFinal == 0)
+            //          a = v^2 / -2d
+            float decelerationPxPerMs = velocityPxPerMs * velocityPxPerMs / (2 * overshootDistance);
+            // Calculate time necessary to reach peak of overshoot.
+            // Formula: acceleration = velocity / time
+            //          time = velocity / acceleration
+            duration = (long) (velocityPxPerMs / decelerationPxPerMs);
+
+            // Now that we're at the top of the overshoot, need to settle back to endProgress.
+            float settleDistance = end - endProgress;
+            int settleDistancePx = (int) (settleDistance * totalDistancePx);
+            // Calculate time necessary for the settle.
+            // Formula: distance = velocityInitial * time + 1/2 * acceleration * time^2
+            //          d = 1/2at^2 (velocityInitial = 0, since we just stopped at the top)
+            //          t = sqrt(2d/a)
+            // Above formula assumes constant acceleration. Since we use ACCEL_DEACCEL, we actually
+            // have acceleration to halfway then deceleration the rest. So the formula becomes:
+            //          t = sqrt(d/a) * 2 (half the distance for accel, half for deaccel)
+            long settleDuration = (long) Math.sqrt(settleDistancePx / decelerationPxPerMs) * 4;
+
+            settleDuration = Math.max(MIN_SETTLE_DURATION, settleDuration);
+            // How much of the animation to devote to playing the overshoot (the rest is for settle).
+            float overshootFraction = (float) duration / (duration + settleDuration);
+            duration += settleDuration;
+            // Finally, create the interpolator, composed of two interpolators: an overshoot, which
+            // reaches end > 1, and then a settle to endProgress.
+            Interpolator overshoot = Interpolators.clampToProgress(DEACCEL, 0, overshootFraction);
+            // The settle starts at 1, where 1 is the top of the overshoot, and maps to a fraction
+            // such that final progress is endProgress. For example, if we overshot to 1.1 but want
+            // to end at 1, we need to map to 1/1.1.
+            Interpolator settle = Interpolators.clampToProgress(Interpolators.mapToProgress(
+                ACCEL_DEACCEL, 1, (endProgress - start) / (end - start)), overshootFraction, 1);
+            interpolator = t -> t <= overshootFraction
+                ? overshoot.getInterpolation(t)
+                : settle.getInterpolation(t);
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/LauncherAnimUtils.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/LauncherAnimUtils.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f0b7644eb9da024b292b2a34fa8fda0bd74de8a
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/LauncherAnimUtils.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright (C) 2012 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 foundation.e.blisslauncher.features.test.anim;
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.animation.PropertyValuesHolder;
+import android.animation.ValueAnimator;
+import android.graphics.drawable.Drawable;
+import android.util.FloatProperty;
+import android.util.Property;
+import android.view.View;
+import android.view.ViewTreeObserver;
+
+import java.util.HashSet;
+import java.util.WeakHashMap;
+
+import foundation.e.blisslauncher.core.Utilities;
+
+public class LauncherAnimUtils {
+    /**
+     * Durations for various state animations. These are not defined in resources to allow
+     * easier access from static classes and enums
+     */
+    public static final int OVERVIEW_TRANSITION_MS = 250;
+    public static final int SPRING_LOADED_TRANSITION_MS = 150;
+    public static final int SPRING_LOADED_EXIT_DELAY = 500;
+
+    // The progress of an animation to all apps must be at least this far along to snap to all apps.
+    public static final float MIN_PROGRESS_TO_ALL_APPS = 0.5f;
+
+    static WeakHashMap<Animator, Object> sAnimators = new WeakHashMap<Animator, Object>();
+    static Animator.AnimatorListener sEndAnimListener = new Animator.AnimatorListener() {
+        public void onAnimationStart(Animator animation) {
+            sAnimators.put(animation, null);
+        }
+
+        public void onAnimationRepeat(Animator animation) {
+        }
+
+        public void onAnimationEnd(Animator animation) {
+            sAnimators.remove(animation);
+        }
+
+        public void onAnimationCancel(Animator animation) {
+            sAnimators.remove(animation);
+        }
+    };
+
+    public static void cancelOnDestroyActivity(Animator a) {
+        a.addListener(sEndAnimListener);
+    }
+
+    // Helper method. Assumes a draw is pending, and that if the animation's duration is 0
+    // it should be cancelled
+    public static void startAnimationAfterNextDraw(final Animator animator, final View view) {
+        view.getViewTreeObserver().addOnDrawListener(new ViewTreeObserver.OnDrawListener() {
+            private boolean mStarted = false;
+
+            public void onDraw() {
+                if (mStarted) return;
+                mStarted = true;
+                // Use this as a signal that the animation was cancelled
+                if (animator.getDuration() == 0) {
+                    return;
+                }
+                animator.start();
+
+                final ViewTreeObserver.OnDrawListener listener = this;
+                view.post(new Runnable() {
+                    public void run() {
+                        view.getViewTreeObserver().removeOnDrawListener(listener);
+                    }
+                });
+            }
+        });
+    }
+
+    public static void onDestroyActivity() {
+        HashSet<Animator> animators = new HashSet<Animator>(sAnimators.keySet());
+        for (Animator a : animators) {
+            if (a.isRunning()) {
+                a.cancel();
+            }
+            sAnimators.remove(a);
+        }
+    }
+
+    public static AnimatorSet createAnimatorSet() {
+        AnimatorSet anim = new AnimatorSet();
+        cancelOnDestroyActivity(anim);
+        return anim;
+    }
+
+    public static ValueAnimator ofFloat(float... values) {
+        ValueAnimator anim = new ValueAnimator();
+        anim.setFloatValues(values);
+        cancelOnDestroyActivity(anim);
+        return anim;
+    }
+
+    public static ObjectAnimator ofFloat(
+        View target, Property<View, Float> property,
+            float... values) {
+        ObjectAnimator anim = ObjectAnimator.ofFloat(target, property, values);
+        cancelOnDestroyActivity(anim);
+        new FirstFrameAnimatorHelper(anim, target);
+        return anim;
+    }
+
+    public static ObjectAnimator ofViewAlphaAndScale(
+        View target,
+            float alpha, float scaleX, float scaleY) {
+        return ofPropertyValuesHolder(target,
+                PropertyValuesHolder.ofFloat(View.ALPHA, alpha),
+                PropertyValuesHolder.ofFloat(View.SCALE_X, scaleX),
+                PropertyValuesHolder.ofFloat(View.SCALE_Y, scaleY));
+    }
+
+    public static ObjectAnimator ofPropertyValuesHolder(
+        View target,
+            PropertyValuesHolder... values) {
+        return ofPropertyValuesHolder(target, target, values);
+    }
+
+    public static ObjectAnimator ofPropertyValuesHolder(
+        Object target,
+            View view, PropertyValuesHolder... values) {
+        ObjectAnimator anim = ObjectAnimator.ofPropertyValuesHolder(target, values);
+        cancelOnDestroyActivity(anim);
+        new FirstFrameAnimatorHelper(anim, view);
+        return anim;
+    }
+
+    public static final Property<Drawable, Integer> DRAWABLE_ALPHA =
+            new Property<Drawable, Integer>(Integer.TYPE, "drawableAlpha") {
+                @Override
+                public Integer get(Drawable drawable) {
+                    return drawable.getAlpha();
+                }
+
+                @Override
+                public void set(Drawable drawable, Integer alpha) {
+                    drawable.setAlpha(alpha);
+                }
+            };
+
+    public static final Property<View, Float> SCALE_PROPERTY =
+            new Property<View, Float>(Float.class, "scale") {
+                @Override
+                public Float get(View view) {
+                    return view.getScaleX();
+                }
+
+                @Override
+                public void set(View view, Float scale) {
+                    view.setScaleX(scale);
+                    view.setScaleY(scale);
+                }
+            };
+
+    /** Increase the duration if we prevented the fling, as we are going against a high velocity. */
+    public static int blockedFlingDurationFactor(float velocity) {
+        return (int) Utilities.boundToRange(Math.abs(velocity) / 2, 2f, 6f);
+    }
+
+    public static final FloatProperty<View> VIEW_ALPHA =
+        View.ALPHA instanceof FloatProperty ? (FloatProperty) View.ALPHA
+            : new FloatProperty<View>("alpha") {
+            @Override
+            public void setValue(View view, float v) {
+                view.setAlpha(v);
+            }
+
+            @Override
+            public Float get(View view) {
+                return view.getAlpha();
+            }
+        };
+
+    public static final FloatProperty<View> VIEW_TRANSLATE_X =
+        View.TRANSLATION_X instanceof FloatProperty ? (FloatProperty) View.TRANSLATION_X
+            : new FloatProperty<View>("translateX") {
+            @Override
+            public void setValue(View view, float v) {
+                view.setTranslationX(v);
+            }
+
+            @Override
+            public Float get(View view) {
+                return view.getTranslationX();
+            }
+        };
+
+    public static final FloatProperty<View> VIEW_TRANSLATE_Y =
+        View.TRANSLATION_Y instanceof FloatProperty ? (FloatProperty) View.TRANSLATION_Y
+            : new FloatProperty<View>("translateY") {
+            @Override
+            public void setValue(View view, float v) {
+                view.setTranslationY(v);
+            }
+
+            @Override
+            public Float get(View view) {
+                return view.getTranslationY();
+            }
+        };
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/PendingAnimation.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/PendingAnimation.java
new file mode 100644
index 0000000000000000000000000000000000000000..c25403c64651a4c9d87ab975a1e8f8b27bcfebec
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/PendingAnimation.java
@@ -0,0 +1,61 @@
+/*
+ * 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 foundation.e.blisslauncher.features.test.anim;
+
+import android.animation.AnimatorSet;
+import android.annotation.TargetApi;
+import android.os.Build;
+
+import java.util.ArrayList;
+import java.util.function.Consumer;
+
+/**
+ * Utility class to keep track of a running animation.
+ *
+ * This class allows attaching end callbacks to an animation is intended to be used with
+ * {@link AnimatorPlaybackController}, since in that case
+ * AnimationListeners are not properly dispatched.
+ */
+@TargetApi(Build.VERSION_CODES.O)
+public class PendingAnimation {
+
+    private final ArrayList<Consumer<OnEndListener>> mEndListeners = new ArrayList<>();
+
+    public final AnimatorSet anim;
+
+    public PendingAnimation(AnimatorSet anim) {
+        this.anim = anim;
+    }
+
+    public void finish(boolean isSuccess) {
+        for (Consumer<OnEndListener> listeners : mEndListeners) {
+            listeners.accept(new OnEndListener(isSuccess));
+        }
+        mEndListeners.clear();
+    }
+
+    public void addEndListener(Consumer<OnEndListener> listener) {
+        mEndListeners.add(listener);
+    }
+
+    public static class OnEndListener {
+        public boolean isSuccess;
+
+        public OnEndListener(boolean isSuccess) {
+            this.isSuccess = isSuccess;
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/PropertyListBuilder.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/PropertyListBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..dfbd82d03f7a5ff4ea52556deb28ab39ce98dd30
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/PropertyListBuilder.java
@@ -0,0 +1,52 @@
+package foundation.e.blisslauncher.features.test.anim;
+
+import android.animation.ObjectAnimator;
+import android.animation.PropertyValuesHolder;
+import android.view.View;
+
+import java.util.ArrayList;
+
+/**
+ * Helper class to build a list of {@link PropertyValuesHolder} for view properties
+ */
+public class PropertyListBuilder {
+
+    private final ArrayList<PropertyValuesHolder> mProperties = new ArrayList<>();
+
+    public PropertyListBuilder translationX(float value) {
+        mProperties.add(PropertyValuesHolder.ofFloat(View.TRANSLATION_X, value));
+        return this;
+    }
+
+    public PropertyListBuilder translationY(float value) {
+        mProperties.add(PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, value));
+        return this;
+    }
+
+    public PropertyListBuilder scaleX(float value) {
+        mProperties.add(PropertyValuesHolder.ofFloat(View.SCALE_X, value));
+        return this;
+    }
+
+    public PropertyListBuilder scaleY(float value) {
+        mProperties.add(PropertyValuesHolder.ofFloat(View.SCALE_Y, value));
+        return this;
+    }
+
+    /**
+     * Helper method to set both scaleX and scaleY
+     */
+    public PropertyListBuilder scale(float value) {
+        return scaleX(value).scaleY(value);
+    }
+
+    public PropertyListBuilder alpha(float value) {
+        mProperties.add(PropertyValuesHolder.ofFloat(View.ALPHA, value));
+        return this;
+    }
+
+    public ObjectAnimator build(View view) {
+        return ObjectAnimator.ofPropertyValuesHolder(view,
+                mProperties.toArray(new PropertyValuesHolder[mProperties.size()]));
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/PropertySetter.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/PropertySetter.java
new file mode 100644
index 0000000000000000000000000000000000000000..65624181be2b1b32a83ad68bc4dc0448fa85f4a5
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/PropertySetter.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2016 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 foundation.e.blisslauncher.features.test.anim;
+
+import android.animation.Animator;
+import android.animation.ObjectAnimator;
+import android.animation.TimeInterpolator;
+import android.util.Property;
+import android.view.View;
+
+/**
+ * Utility class for setting a property with or without animation
+ */
+public class PropertySetter {
+
+    public static final PropertySetter NO_ANIM_PROPERTY_SETTER = new PropertySetter();
+
+    public void setViewAlpha(View view, float alpha, TimeInterpolator interpolator) {
+        if (view != null) {
+            view.setAlpha(alpha);
+            AlphaUpdateListener.updateVisibility(view);
+        }
+    }
+
+    public <T> void setFloat(T target, Property<T, Float> property, float value,
+            TimeInterpolator interpolator) {
+        property.set(target, value);
+    }
+
+    public <T> void setInt(T target, Property<T, Integer> property, int value,
+            TimeInterpolator interpolator) {
+        property.set(target, value);
+    }
+
+    public static class AnimatedPropertySetter extends PropertySetter {
+
+        private final long mDuration;
+        private final AnimatorSetBuilder mStateAnimator;
+
+        public AnimatedPropertySetter(long duration, AnimatorSetBuilder builder) {
+            mDuration = duration;
+            mStateAnimator = builder;
+        }
+
+        @Override
+        public void setViewAlpha(View view, float alpha, TimeInterpolator interpolator) {
+            if (view == null || view.getAlpha() == alpha) {
+                return;
+            }
+            ObjectAnimator anim = ObjectAnimator.ofFloat(view, View.ALPHA, alpha);
+            anim.addListener(new AlphaUpdateListener(view));
+            anim.setDuration(mDuration).setInterpolator(interpolator);
+            mStateAnimator.play(anim);
+        }
+
+        @Override
+        public <T> void setFloat(T target, Property<T, Float> property, float value,
+                TimeInterpolator interpolator) {
+            if (property.get(target) == value) {
+                return;
+            }
+            Animator anim = ObjectAnimator.ofFloat(target, property, value);
+            anim.setDuration(mDuration).setInterpolator(interpolator);
+            mStateAnimator.play(anim);
+        }
+
+        @Override
+        public <T> void setInt(T target, Property<T, Integer> property, int value,
+                TimeInterpolator interpolator) {
+            if (property.get(target) == value) {
+                return;
+            }
+            Animator anim = ObjectAnimator.ofInt(target, property, value);
+            anim.setDuration(mDuration).setInterpolator(interpolator);
+            mStateAnimator.play(anim);
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/RevealOutlineAnimation.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/RevealOutlineAnimation.java
new file mode 100644
index 0000000000000000000000000000000000000000..baf7b97543b31d5a99800b5d8780c66cc3c50f2e
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/RevealOutlineAnimation.java
@@ -0,0 +1,79 @@
+package foundation.e.blisslauncher.features.test.anim;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.graphics.Outline;
+import android.graphics.Rect;
+import android.view.View;
+import android.view.ViewOutlineProvider;
+
+/**
+ * A {@link ViewOutlineProvider} that has helper functions to create reveal animations.
+ * This class should be extended so that subclasses can define the reveal shape as the
+ * animation progresses from 0 to 1.
+ */
+public abstract class RevealOutlineAnimation extends ViewOutlineProvider {
+    protected Rect mOutline;
+    protected float mOutlineRadius;
+
+    public RevealOutlineAnimation() {
+        mOutline = new Rect();
+    }
+
+    /** Returns whether elevation should be removed for the duration of the reveal animation. */
+    abstract boolean shouldRemoveElevationDuringAnimation();
+    /** Sets the progress, from 0 to 1, of the reveal animation. */
+    abstract void setProgress(float progress);
+
+    public ValueAnimator createRevealAnimator(final View revealView, boolean isReversed) {
+        ValueAnimator va =
+                isReversed ? ValueAnimator.ofFloat(1f, 0f) : ValueAnimator.ofFloat(0f, 1f);
+        final float elevation = revealView.getElevation();
+
+        va.addListener(new AnimatorListenerAdapter() {
+            private boolean mIsClippedToOutline;
+            private ViewOutlineProvider mOldOutlineProvider;
+
+            public void onAnimationStart(Animator animation) {
+                mIsClippedToOutline = revealView.getClipToOutline();
+                mOldOutlineProvider = revealView.getOutlineProvider();
+
+                revealView.setOutlineProvider(RevealOutlineAnimation.this);
+                revealView.setClipToOutline(true);
+                if (shouldRemoveElevationDuringAnimation()) {
+                    revealView.setTranslationZ(-elevation);
+                }
+            }
+
+            public void onAnimationEnd(Animator animation) {
+                revealView.setOutlineProvider(mOldOutlineProvider);
+                revealView.setClipToOutline(mIsClippedToOutline);
+                if (shouldRemoveElevationDuringAnimation()) {
+                    revealView.setTranslationZ(0);
+                }
+            }
+
+        });
+
+        va.addUpdateListener(valueAnimator -> {
+            float progress = (Float) valueAnimator.getAnimatedValue();
+            setProgress(progress);
+            revealView.invalidateOutline();
+        });
+        return va;
+    }
+
+    @Override
+    public void getOutline(View v, Outline outline) {
+        outline.setRoundRect(mOutline, mOutlineRadius);
+    }
+
+    public float getRadius() {
+        return mOutlineRadius;
+    }
+
+    public void getOutline(Rect out) {
+        out.set(mOutline);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/RoundedRectRevealOutlineProvider.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/RoundedRectRevealOutlineProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..158184be4fbc21e4aefbca5004038e9026bd596c
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/RoundedRectRevealOutlineProvider.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package foundation.e.blisslauncher.features.test.anim;
+
+import android.graphics.Rect;
+
+/**
+ * A {@link RevealOutlineAnimation} that provides an outline that interpolates between two radii
+ * and two {@link Rect}s.
+ *
+ * An example usage of this provider is an outline that starts out as a circle and ends
+ * as a rounded rectangle.
+ */
+public class RoundedRectRevealOutlineProvider extends RevealOutlineAnimation {
+    private final float mStartRadius;
+    private final float mEndRadius;
+
+    private final Rect mStartRect;
+    private final Rect mEndRect;
+
+    public RoundedRectRevealOutlineProvider(float startRadius, float endRadius, Rect startRect,
+            Rect endRect) {
+        mStartRadius = startRadius;
+        mEndRadius = endRadius;
+        mStartRect = startRect;
+        mEndRect = endRect;
+    }
+
+    @Override
+    public boolean shouldRemoveElevationDuringAnimation() {
+        return false;
+    }
+
+    @Override
+    public void setProgress(float progress) {
+        mOutlineRadius = (1 - progress) * mStartRadius + progress * mEndRadius;
+
+        mOutline.left = (int) ((1 - progress) * mStartRect.left + progress * mEndRect.left);
+        mOutline.top = (int) ((1 - progress) * mStartRect.top + progress * mEndRect.top);
+        mOutline.right = (int) ((1 - progress) * mStartRect.right + progress * mEndRect.right);
+        mOutline.bottom = (int) ((1 - progress) * mStartRect.bottom + progress * mEndRect.bottom);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/SpringAnimationBuilder.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/SpringAnimationBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..66f7db4516e848ceca2c41df9b760354c8e5782f
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/SpringAnimationBuilder.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.features.test.anim;
+
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+
+import android.animation.Animator;
+import android.animation.ValueAnimator;
+import android.content.Context;
+import android.util.FloatProperty;
+import androidx.annotation.FloatRange;
+import androidx.dynamicanimation.animation.SpringForce;
+
+/**
+ * Utility class to build an object animator which follows the same path as a spring animation for
+ * an underdamped spring.
+ */
+public class SpringAnimationBuilder {
+
+    private final Context mContext;
+
+    private float mStartValue;
+    private float mEndValue;
+    private float mVelocity = 0;
+
+    private float mStiffness = SpringForce.STIFFNESS_MEDIUM;
+    private float mDampingRatio = SpringForce.DAMPING_RATIO_MEDIUM_BOUNCY;
+    private float mMinVisibleChange = 1;
+
+    // Multiplier to the min visible change value for value threshold
+    private static final float THRESHOLD_MULTIPLIER = 0.65f;
+
+    /**
+     * The spring equation is given as
+     *   x = e^(-beta*t/2) * (a cos(gamma * t) + b sin(gamma * t)
+     *   v = e^(-beta*t/2) * ((2 * a * gamma + beta * b) * sin(gamma * t)
+     *                  + (a * beta - 2 * b * gamma) * cos(gamma * t)) / 2
+     *
+     *   a = x(0)
+     *   b = beta * x(0) / (2 * gamma) + v(0) / gamma
+     */
+    private double beta;
+    private double gamma;
+
+    private double a, b;
+    private double va, vb;
+
+    // Threshold for velocity and value to determine when it's reasonable to assume that the spring
+    // is approximately at rest.
+    private double mValueThreshold;
+    private double mVelocityThreshold;
+
+    private float mDuration = 0;
+
+    public SpringAnimationBuilder(Context context) {
+        mContext = context;
+    }
+
+    public SpringAnimationBuilder setEndValue(float value) {
+        mEndValue = value;
+        return this;
+    }
+
+    public SpringAnimationBuilder setStartValue(float value) {
+        mStartValue = value;
+        return this;
+    }
+
+    public SpringAnimationBuilder setValues(float... values) {
+        if (values.length > 1) {
+            mStartValue = values[0];
+            mEndValue = values[values.length - 1];
+        } else {
+            mEndValue = values[0];
+        }
+        return this;
+    }
+
+    public SpringAnimationBuilder setStiffness(
+            @FloatRange(from = 0.0, fromInclusive = false) float stiffness) {
+        if (stiffness <= 0) {
+            throw new IllegalArgumentException("Spring stiffness constant must be positive.");
+        }
+        mStiffness = stiffness;
+        return this;
+    }
+
+    public SpringAnimationBuilder setDampingRatio(
+            @FloatRange(from = 0.0, to = 1.0, fromInclusive = false, toInclusive = false)
+                    float dampingRatio) {
+        if (dampingRatio <= 0 || dampingRatio >= 1) {
+            throw new IllegalArgumentException("Damping ratio must be between 0 and 1");
+        }
+        mDampingRatio = dampingRatio;
+        return this;
+    }
+
+    public SpringAnimationBuilder setMinimumVisibleChange(
+            @FloatRange(from = 0.0, fromInclusive = false) float minimumVisibleChange) {
+        if (minimumVisibleChange <= 0) {
+            throw new IllegalArgumentException("Minimum visible change must be positive.");
+        }
+        mMinVisibleChange = minimumVisibleChange;
+        return this;
+    }
+
+    public SpringAnimationBuilder setStartVelocity(float startVelocity) {
+        mVelocity = startVelocity;
+        return this;
+    }
+
+    public float getInterpolatedValue(float fraction) {
+        return getValue(mDuration * fraction);
+    }
+
+    private float getValue(float time) {
+        return (float) (exponentialComponent(time) * cosSinX(time)) + mEndValue;
+    }
+
+    public SpringAnimationBuilder computeParams() {
+        // Update it with DefaultDisplay
+        int singleFrameMs = 16;
+        double naturalFreq = Math.sqrt(mStiffness);
+        double dampedFreq = naturalFreq * Math.sqrt(1 - mDampingRatio * mDampingRatio);
+
+        // All the calculations assume the stable position to be 0, shift the values accordingly.
+        beta = 2 * mDampingRatio * naturalFreq;
+        gamma = dampedFreq;
+        a =  mStartValue - mEndValue;
+        b = beta * a / (2 * gamma) + mVelocity / gamma;
+
+        va = a * beta / 2 - b * gamma;
+        vb = a * gamma + beta * b / 2;
+
+        mValueThreshold = mMinVisibleChange * THRESHOLD_MULTIPLIER;
+
+        // This multiplier is used to calculate the velocity threshold given a certain value
+        // threshold. The idea is that if it takes >= 1 frame to move the value threshold amount,
+        // then the velocity is a reasonable threshold.
+        mVelocityThreshold = mValueThreshold * 1000.0 / singleFrameMs;
+
+        // Find the duration (in seconds) for the spring to reach equilibrium.
+        // equilibrium is reached when x = 0
+        double duration = Math.atan2(-a, b) / gamma;
+
+        // Keep moving ahead until the velocity reaches equilibrium.
+        double piByG = Math.PI / gamma;
+        while (duration < 0 || Math.abs(exponentialComponent(duration) * cosSinV(duration))
+                >= mVelocityThreshold) {
+            duration += piByG;
+        }
+
+        // Find the shortest time
+        double edgeTime = Math.max(0, duration - piByG / 2);
+        double minDiff = singleFrameMs / 2000.0;    // Half frame time in seconds
+
+        do {
+            if ((duration - edgeTime) < minDiff) {
+                break;
+            }
+            double mid = (edgeTime + duration) / 2;
+            if (isAtEquilibrium(mid)) {
+                duration = mid;
+            } else {
+                edgeTime = mid;
+            }
+        } while (true);
+
+        mDuration = (float) duration;
+        return this;
+    }
+
+    public long getDuration() {
+        return (long) (1000.0 * mDuration);
+    }
+
+    public <T> ValueAnimator build(T target, FloatProperty<T> property) {
+        computeParams();
+
+        ValueAnimator animator = ValueAnimator.ofFloat(0, mDuration);
+        animator.setDuration(getDuration()).setInterpolator(LINEAR);
+        animator.addUpdateListener(anim ->
+                property.set(target, getInterpolatedValue(anim.getAnimatedFraction())));
+        animator.addListener(new AnimationSuccessListener() {
+            @Override
+            public void onAnimationSuccess(Animator animation) {
+                property.set(target, mEndValue);
+            }
+        });
+        return animator;
+    }
+
+    private boolean isAtEquilibrium(double t) {
+        double ec = exponentialComponent(t);
+
+        if (Math.abs(ec * cosSinX(t)) >= mValueThreshold) {
+            return false;
+        }
+        return Math.abs(ec * cosSinV(t)) < mVelocityThreshold;
+    }
+
+    private double exponentialComponent(double t) {
+        return Math.pow(Math.E, - beta * t / 2);
+    }
+
+    private double cosSinX(double t) {
+        return cosSin(t, a, b);
+    }
+
+    private double cosSinV(double t) {
+        return cosSin(t, va, vb);
+    }
+
+    private double cosSin(double t, double cosFactor, double sinFactor) {
+        double angle = t * gamma;
+        return cosFactor * Math.cos(angle) + sinFactor * Math.sin(angle);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/SpringObjectAnimator.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/SpringObjectAnimator.java
new file mode 100644
index 0000000000000000000000000000000000000000..16f472dd490c161e1cdf7acadafaa6f7d241390f
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/SpringObjectAnimator.java
@@ -0,0 +1,299 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.features.test.anim;
+
+import static androidx.dynamicanimation.animation.FloatPropertyCompat.createFloatPropertyCompat;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.animation.TimeInterpolator;
+import android.animation.ValueAnimator;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.FloatProperty;
+import android.util.Log;
+import androidx.dynamicanimation.animation.DynamicAnimation.OnAnimationEndListener;
+import androidx.dynamicanimation.animation.SpringAnimation;
+import androidx.dynamicanimation.animation.SpringForce;
+import foundation.e.blisslauncher.core.Flags;
+import java.util.ArrayList;
+
+/**
+ * This animator allows for an object's property to be be controlled by an {@link ObjectAnimator} or
+ * a {@link SpringAnimation}. It extends ValueAnimator so it can be used in an AnimatorSet.
+ */
+public class SpringObjectAnimator<T> extends ValueAnimator {
+
+    private static final String TAG = "SpringObjectAnimator";
+    private static boolean DEBUG = false;
+
+    private ObjectAnimator mObjectAnimator;
+    private float[] mValues;
+
+    private SpringAnimation mSpring;
+    private SpringProperty<T> mProperty;
+
+    private ArrayList<AnimatorListener> mListeners;
+    private boolean mSpringEnded = true;
+    private boolean mAnimatorEnded = true;
+    private boolean mEnded = true;
+
+    public SpringObjectAnimator(T object, FloatProperty<T> property, float minimumVisibleChange,
+            float damping, float stiffness, float... values) {
+        mSpring = new SpringAnimation(object, createFloatPropertyCompat(property));
+        mSpring.setMinimumVisibleChange(minimumVisibleChange);
+        mSpring.setSpring(new SpringForce(0)
+                .setDampingRatio(damping)
+                .setStiffness(stiffness));
+        mSpring.setStartVelocity(0.01f);
+        mProperty = new SpringProperty<>(property, mSpring);
+        mObjectAnimator = ObjectAnimator.ofFloat(object, mProperty, values);
+        mValues = values;
+        mListeners = new ArrayList<>();
+        setFloatValues(values);
+
+        // We use this listener and track mListeners so that we can sync the animator and spring
+        // listeners.
+        mObjectAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+                mAnimatorEnded = false;
+                mEnded = false;
+                for (AnimatorListener l : mListeners) {
+                    l.onAnimationStart(animation);
+                }
+            }
+
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mAnimatorEnded = true;
+                tryEnding();
+            }
+
+            @Override
+            public void onAnimationCancel(Animator animation) {
+                for (AnimatorListener l : mListeners) {
+                    l.onAnimationCancel(animation);
+                }
+                mSpring.cancel();
+            }
+        });
+
+        mSpring.addUpdateListener((animation, value, velocity) -> mSpringEnded = false);
+        mSpring.addEndListener((animation, canceled, value, velocity) -> {
+            mSpringEnded = true;
+            tryEnding();
+        });
+    }
+
+    private void tryEnding() {
+        if (DEBUG) {
+            Log.d(TAG, "tryEnding#mAnimatorEnded=" + mAnimatorEnded + ", mSpringEnded="
+                    + mSpringEnded + ", mEnded=" + mEnded);
+        }
+
+        // If springs are disabled, ignore value of mSpringEnded
+        if (mAnimatorEnded && (mSpringEnded || !Flags.QUICKSTEP_SPRINGS) && !mEnded) {
+            for (AnimatorListener l : mListeners) {
+                l.onAnimationEnd(this);
+            }
+            mEnded = true;
+        }
+    }
+
+    public SpringAnimation getSpring() {
+        return mSpring;
+    }
+
+    /**
+     * Initializes and sets up the spring to take over controlling the object.
+     */
+    public void startSpring(float end, float velocity, OnAnimationEndListener endListener) {
+        // Cancel the spring so we can set new start velocity and final position. We need to remove
+        // the listener since the spring is not actually ending.
+        mSpring.removeEndListener(endListener);
+        mSpring.cancel();
+        mSpring.addEndListener(endListener);
+
+        mProperty.switchToSpring();
+
+        mSpring.setStartVelocity(velocity);
+
+        float startValue = end == 0 ? mValues[1] : mValues[0];
+        float endValue = end == 0 ? mValues[0] : mValues[1];
+        mSpring.setStartValue(startValue);
+        new Handler(Looper.getMainLooper()).postDelayed(() -> {
+            mSpring.animateToFinalPosition(endValue);
+        }, getStartDelay());
+    }
+
+    @Override
+    public void addListener(AnimatorListener listener) {
+        mListeners.add(listener);
+    }
+
+    public ArrayList<AnimatorListener> getObjectAnimatorListeners() {
+        return mObjectAnimator.getListeners();
+    }
+
+    @Override
+    public ArrayList<AnimatorListener> getListeners() {
+        return mListeners;
+    }
+
+    @Override
+    public void removeAllListeners() {
+        mListeners.clear();
+    }
+
+    @Override
+    public void removeListener(AnimatorListener listener) {
+        mListeners.remove(listener);
+    }
+
+    @Override
+    public void addPauseListener(AnimatorPauseListener listener) {
+        mObjectAnimator.addPauseListener(listener);
+    }
+
+    @Override
+    public void cancel() {
+        mObjectAnimator.cancel();
+        mSpring.cancel();
+    }
+
+    @Override
+    public void end() {
+        mObjectAnimator.end();
+    }
+
+    @Override
+    public long getDuration() {
+        return mObjectAnimator.getDuration();
+    }
+
+    @Override
+    public TimeInterpolator getInterpolator() {
+        return mObjectAnimator.getInterpolator();
+    }
+
+    @Override
+    public long getStartDelay() {
+        return mObjectAnimator.getStartDelay();
+    }
+
+    @Override
+    public long getTotalDuration() {
+        return mObjectAnimator.getTotalDuration();
+    }
+
+    @Override
+    public boolean isPaused() {
+        return mObjectAnimator.isPaused();
+    }
+
+    @Override
+    public boolean isRunning() {
+        return mObjectAnimator.isRunning();
+    }
+
+    @Override
+    public boolean isStarted() {
+        return mObjectAnimator.isStarted();
+    }
+
+    @Override
+    public void pause() {
+        mObjectAnimator.pause();
+    }
+
+    @Override
+    public void removePauseListener(AnimatorPauseListener listener) {
+        mObjectAnimator.removePauseListener(listener);
+    }
+
+    @Override
+    public void resume() {
+        mObjectAnimator.resume();
+    }
+
+    @Override
+    public ValueAnimator setDuration(long duration) {
+        return mObjectAnimator.setDuration(duration);
+    }
+
+    @Override
+    public void setInterpolator(TimeInterpolator value) {
+        mObjectAnimator.setInterpolator(value);
+    }
+
+    @Override
+    public void setStartDelay(long startDelay) {
+        mObjectAnimator.setStartDelay(startDelay);
+    }
+
+    @Override
+    public void setTarget(Object target) {
+        mObjectAnimator.setTarget(target);
+    }
+
+    @Override
+    public void start() {
+        mObjectAnimator.start();
+    }
+
+    @Override
+    public void setCurrentFraction(float fraction) {
+        mObjectAnimator.setCurrentFraction(fraction);
+    }
+
+    @Override
+    public void setCurrentPlayTime(long playTime) {
+        mObjectAnimator.setCurrentPlayTime(playTime);
+    }
+
+    public static class SpringProperty<T> extends FloatProperty<T> {
+
+        boolean useSpring = false;
+        final FloatProperty<T> mProperty;
+        final SpringAnimation mSpring;
+
+        public SpringProperty(FloatProperty<T> property, SpringAnimation spring) {
+            super(property.getName());
+            mProperty = property;
+            mSpring = spring;
+        }
+
+        public void switchToSpring() {
+            useSpring = true;
+        }
+
+        @Override
+        public Float get(T object) {
+            return mProperty.get(object);
+        }
+
+        @Override
+        public void setValue(T object, float progress) {
+            if (useSpring) {
+                mSpring.animateToFinalPosition(progress);
+            } else {
+                mProperty.setValue(object, progress);
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/anim/SpringProperty.java b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/SpringProperty.java
new file mode 100644
index 0000000000000000000000000000000000000000..2a6021bad365354fa8a7cc2d504f2e614d3826fe
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/anim/SpringProperty.java
@@ -0,0 +1,54 @@
+/*
+ * 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 foundation.e.blisslauncher.features.test.anim;
+
+import androidx.dynamicanimation.animation.SpringForce;
+
+/**
+ * Utility class to store configurations for spring animation
+ */
+public class SpringProperty {
+
+    public static final SpringProperty DEFAULT = new SpringProperty();
+
+    // Play spring when the animation is going towards the end
+    public static final int FLAG_CAN_SPRING_ON_END = 1 << 0;
+    // Play spring when animation is going towards the start (in reverse direction)
+    public static final int FLAG_CAN_SPRING_ON_START = 1 << 1;
+
+    public final int flags;
+
+    float mDampingRatio = SpringForce.DAMPING_RATIO_MEDIUM_BOUNCY;
+    float mStiffness = SpringForce.STIFFNESS_MEDIUM;
+
+    public SpringProperty() {
+        this(0);
+    }
+
+    public SpringProperty(int flags) {
+        this.flags = flags;
+    }
+
+    public SpringProperty setDampingRatio(float dampingRatio) {
+        mDampingRatio = dampingRatio;
+        return this;
+    }
+
+    public SpringProperty setStiffness(float stiffness) {
+        mStiffness = stiffness;
+        return this;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragController.java b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragController.java
new file mode 100644
index 0000000000000000000000000000000000000000..44891234387ed1f19c17a70bd8948e0ba62da483
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragController.java
@@ -0,0 +1,644 @@
+/*
+ * Copyright (C) 2008 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 foundation.e.blisslauncher.features.test.dragndrop;
+
+import android.content.ComponentName;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.os.IBinder;
+import android.util.Log;
+import android.view.DragEvent;
+import android.view.HapticFeedbackConstants;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.View;
+
+import java.util.ArrayList;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.database.model.ApplicationItem;
+import foundation.e.blisslauncher.core.database.model.LauncherItem;
+import foundation.e.blisslauncher.core.database.model.ShortcutItem;
+import foundation.e.blisslauncher.features.test.LauncherItemMatcher;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.TouchController;
+import foundation.e.blisslauncher.features.test.UiThreadHelper;
+
+/**
+ * Class for initiating a drag within a view or across multiple views.
+ */
+public class DragController implements DragDriver.EventListener, TouchController {
+    private static final boolean PROFILE_DRAWING_DURING_DRAG = false;
+
+    TestActivity mLauncher;
+
+    // temporaries to avoid gc thrash
+    private Rect mRectTemp = new Rect();
+    private final int[] mCoordinatesTemp = new int[2];
+
+    /**
+     * Drag driver for the current drag/drop operation, or null if there is no active DND operation.
+     * It's null during accessible drag operations.
+     */
+    private DragDriver mDragDriver = null;
+
+    /** Options controlling the drag behavior. */
+    private DragOptions mOptions;
+
+    /** X coordinate of the down event. */
+    private int mMotionDownX;
+
+    /** Y coordinate of the down event. */
+    private int mMotionDownY;
+
+    private DropTarget.DragObject mDragObject;
+
+    /** Who can receive drop events */
+    private ArrayList<DropTarget> mDropTargets = new ArrayList<>();
+    private ArrayList<DragListener> mListeners = new ArrayList<>();
+
+    /** The window token used as the parent for the DragView. */
+    private IBinder mWindowToken;
+
+    private View mMoveTarget;
+
+    private DropTarget mLastDropTarget;
+
+    int mLastTouch[] = new int[2];
+    long mLastTouchUpTime = -1;
+    int mDistanceSinceScroll = 0;
+
+    private int mTmpPoint[] = new int[2];
+    private Rect mDragLayerRect = new Rect();
+
+    private boolean mIsInPreDrag;
+
+    /**
+     * Interface to receive notifications when a drag starts or stops
+     */
+    public interface DragListener {
+        /**
+         * A drag has begun
+         *
+         * @param dragObject The object being dragged
+         * @param options Options used to start the drag
+         */
+        void onDragStart(DropTarget.DragObject dragObject, DragOptions options);
+
+        /**
+         * The drag has ended
+         */
+        void onDragEnd();
+    }
+
+    /**
+     * Used to create a new DragLayer from XML.
+     */
+    public DragController(TestActivity launcher) {
+        mLauncher = launcher;
+    }
+
+    /**
+     * Starts a drag.
+     * When the drag is started, the UI automatically goes into spring loaded mode. On a successful
+     * drop, it is the responsibility of the {@link DropTarget} to exit out of the spring loaded
+     * mode. If the drop was cancelled for some reason, the UI will automatically exit out of this mode.
+     *
+     * @param b The bitmap to display as the drag image.  It will be re-scaled to the
+     *          enlarged size.
+     * @param dragLayerX The x position in the DragLayer of the left-top of the bitmap.
+     * @param dragLayerY The y position in the DragLayer of the left-top of the bitmap.
+     * @param source An object representing where the drag originated
+     * @param dragInfo The data associated with the object that is being dragged
+     * @param dragRegion Coordinates within the bitmap b for the position of item being dragged.
+     *          Makes dragging feel more precise, e.g. you can clip out a transparent border
+     */
+    public DragView startDrag(
+        Bitmap b, int dragLayerX, int dragLayerY,
+            DragSource source, LauncherItem dragInfo, Point dragOffset, Rect dragRegion,
+            float initialDragViewScale, float dragViewScaleOnDrop, DragOptions options) {
+        Log.d(
+            "DragController",
+            "startDrag() called with: b = [" + b + "], dragLayerX = [" + dragLayerX + "], dragLayerY = [" + dragLayerY + "], source = [" + source + "], dragInfo = [" + dragInfo + "], dragOffset = [" + dragOffset + "], dragRegion = [" + dragRegion + "], initialDragViewScale = [" + initialDragViewScale + "], dragViewScaleOnDrop = [" + dragViewScaleOnDrop + "], options = [" + options + "]"
+        );
+        if (PROFILE_DRAWING_DURING_DRAG) {
+            android.os.Debug.startMethodTracing("Launcher");
+        }
+
+        // Hide soft keyboard, if visible
+        UiThreadHelper.hideKeyboardAsync(mLauncher, mWindowToken);
+
+        mOptions = options;
+        if (mOptions.systemDndStartPoint != null) {
+            mMotionDownX = mOptions.systemDndStartPoint.x;
+            mMotionDownY = mOptions.systemDndStartPoint.y;
+        }
+
+        final int registrationX = mMotionDownX - dragLayerX;
+        final int registrationY = mMotionDownY - dragLayerY;
+
+        final int dragRegionLeft = dragRegion == null ? 0 : dragRegion.left;
+        final int dragRegionTop = dragRegion == null ? 0 : dragRegion.top;
+
+        mLastDropTarget = null;
+
+        mDragObject = new DropTarget.DragObject();
+
+        mIsInPreDrag = mOptions.preDragCondition != null
+                && !mOptions.preDragCondition.shouldStartDrag(0);
+
+        final Resources res = mLauncher.getResources();
+        final float scaleDps = mIsInPreDrag
+                ? res.getDimensionPixelSize(R.dimen.pre_drag_view_scale) : 0f;
+        final DragView dragView = mDragObject.dragView = new DragView(mLauncher, b, registrationX,
+            registrationY, initialDragViewScale, dragViewScaleOnDrop, scaleDps);
+        mDragObject.dragComplete = false;
+        mDragObject.xOffset = mMotionDownX - (dragLayerX + dragRegionLeft);
+        mDragObject.yOffset = mMotionDownY - (dragLayerY + dragRegionTop);
+        mDragDriver = DragDriver.create(mLauncher, this, mDragObject, mOptions);
+
+        mDragObject.dragSource = source;
+        mDragObject.dragInfo = dragInfo;
+        mDragObject.originalDragInfo = new LauncherItem();
+        mDragObject.originalDragInfo.copyFrom(dragInfo);
+
+        if (dragOffset != null) {
+            dragView.setDragVisualizeOffset(new Point(dragOffset));
+        }
+        if (dragRegion != null) {
+            dragView.setDragRegion(new Rect(dragRegion));
+        }
+
+        mLauncher.getDragLayer().performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
+        dragView.show(mMotionDownX, mMotionDownY);
+        mDistanceSinceScroll = 0;
+
+        if (!mIsInPreDrag) {
+            callOnDragStart();
+        } else if (mOptions.preDragCondition != null) {
+            mOptions.preDragCondition.onPreDragStart(mDragObject);
+        }
+
+        mLastTouch[0] = mMotionDownX;
+        mLastTouch[1] = mMotionDownY;
+        handleMoveEvent(mMotionDownX, mMotionDownY);
+        return dragView;
+    }
+
+    private void callOnDragStart() {
+        if (mOptions.preDragCondition != null) {
+            mOptions.preDragCondition.onPreDragEnd(mDragObject, true /* dragStarted*/);
+        }
+        mIsInPreDrag = false;
+        for (DragListener listener : new ArrayList<>(mListeners)) {
+            listener.onDragStart(mDragObject, mOptions);
+        }
+    }
+
+    /**
+     * Call this from a drag source view like this:
+     *
+     * <pre>
+     *  @Override
+     *  public boolean dispatchKeyEvent(KeyEvent event) {
+     *      return mDragController.dispatchKeyEvent(this, event)
+     *              || super.dispatchKeyEvent(event);
+     * </pre>
+     */
+    public boolean dispatchKeyEvent(KeyEvent event) {
+        return mDragDriver != null;
+    }
+
+    public boolean isDragging() {
+        return mDragDriver != null;
+    }
+
+    /**
+     * Stop dragging without dropping.
+     */
+    public void cancelDrag() {
+        if (isDragging()) {
+            if (mLastDropTarget != null) {
+                mLastDropTarget.onDragExit(mDragObject);
+            }
+            mDragObject.deferDragViewCleanupPostAnimation = false;
+            mDragObject.cancelled = true;
+            mDragObject.dragComplete = true;
+            if (!mIsInPreDrag) {
+                dispatchDropComplete(null, false);
+            }
+        }
+        endDrag();
+    }
+
+    private void dispatchDropComplete(View dropTarget, boolean accepted) {
+        if (!accepted) {
+            // If it was not accepted, cleanup the state. If it was accepted, it is the
+            // responsibility of the drop target to cleanup the state.
+            // mLauncher.getStateManager().goToState(NORMAL, SPRING_LOADED_EXIT_DELAY);
+            //TODO: Go to normal state here.
+            mDragObject.deferDragViewCleanupPostAnimation = false;
+        }
+
+        mDragObject.dragSource.onDropCompleted(dropTarget, mDragObject, accepted);
+    }
+
+    public void onAppsRemoved(LauncherItemMatcher matcher) {
+        // Cancel the current drag if we are removing an app that we are dragging
+        if (mDragObject != null) {
+            LauncherItem dragInfo = mDragObject.dragInfo;
+            if ((dragInfo instanceof ShortcutItem) || (dragInfo instanceof ApplicationItem)) {
+                ComponentName cn = dragInfo.getTargetComponent();
+                if (cn != null && matcher.matches(dragInfo, cn)) {
+                    cancelDrag();
+                }
+            }
+        }
+    }
+
+    private void endDrag() {
+        if (isDragging()) {
+            mDragDriver = null;
+            boolean isDeferred = false;
+            if (mDragObject.dragView != null) {
+                isDeferred = mDragObject.deferDragViewCleanupPostAnimation;
+                if (!isDeferred) {
+                    //mDragObject.dragView.remove();
+                } else if (mIsInPreDrag) {
+                    animateDragViewToOriginalPosition(null, null, -1);
+                }
+                mDragObject.dragView = null;
+            }
+
+            // Only end the drag if we are not deferred
+            if (!isDeferred) {
+                callOnDragEnd();
+            }
+        }
+    }
+
+    public void animateDragViewToOriginalPosition(final Runnable onComplete,
+            final View originalIcon, int duration) {
+        Runnable onCompleteRunnable = new Runnable() {
+            @Override
+            public void run() {
+                if (originalIcon != null) {
+                    originalIcon.setVisibility(View.VISIBLE);
+                }
+                if (onComplete != null) {
+                    onComplete.run();
+                }
+            }
+        };
+        //mDragObject.dragView.animateTo(mMotionDownX, mMotionDownY, onCompleteRunnable, duration);
+    }
+
+    private void callOnDragEnd() {
+        if (mIsInPreDrag && mOptions.preDragCondition != null) {
+            mOptions.preDragCondition.onPreDragEnd(mDragObject, false /* dragStarted*/);
+        }
+        mIsInPreDrag = false;
+        mOptions = null;
+        for (DragListener listener : new ArrayList<>(mListeners)) {
+            listener.onDragEnd();
+        }
+    }
+
+    /**
+     * This only gets called as a result of drag view cleanup being deferred in endDrag();
+     */
+    void onDeferredEndDrag(DragView dragView) {
+        dragView.remove();
+
+        if (mDragObject.deferDragViewCleanupPostAnimation) {
+            // If we skipped calling onDragEnd() before, do it now
+            callOnDragEnd();
+        }
+    }
+
+    /**
+     * Clamps the position to the drag layer bounds.
+     */
+    private int[] getClampedDragLayerPos(float x, float y) {
+        mLauncher.getDragLayer().getLocalVisibleRect(mDragLayerRect);
+        Log.d("DragController", "Rect: "+mDragLayerRect);
+        mTmpPoint[0] = (int) Math.max(mDragLayerRect.left, Math.min(x, mDragLayerRect.right - 1));
+        mTmpPoint[1] = (int) Math.max(mDragLayerRect.top, Math.min(y, mDragLayerRect.bottom - 1));
+        Log.d("DragController", "TmpPoint: "+mTmpPoint[0]+", "+mTmpPoint[1]);
+        return mTmpPoint;
+    }
+
+    public long getLastGestureUpTime() {
+        if (mDragDriver != null) {
+            return System.currentTimeMillis();
+        } else {
+            return mLastTouchUpTime;
+        }
+    }
+
+    public void resetLastGestureUpTime() {
+        mLastTouchUpTime = -1;
+    }
+
+    @Override
+    public void onDriverDragMove(float x, float y) {
+        final int[] dragLayerPos = getClampedDragLayerPos(x, y);
+
+        handleMoveEvent(dragLayerPos[0], dragLayerPos[1]);
+    }
+
+    @Override
+    public void onDriverDragExitWindow() {
+        if (mLastDropTarget != null) {
+            mLastDropTarget.onDragExit(mDragObject);
+            mLastDropTarget = null;
+        }
+    }
+
+    @Override
+    public void onDriverDragEnd(float x, float y) {
+        DropTarget dropTarget;
+        dropTarget = findDropTarget((int) x, (int) y, mCoordinatesTemp);
+        drop(dropTarget, null);
+        endDrag();
+    }
+
+    @Override
+    public void onDriverDragCancel() {
+        cancelDrag();
+    }
+
+    /**
+     * Call this from a drag source view.
+     */
+    public boolean onControllerInterceptTouchEvent(MotionEvent ev) {
+        Log.d("DragController", "onControllerInterceptTouchEvent() called with: ev = [" + ev + "]");
+        final int action = ev.getAction();
+        final int[] dragLayerPos = getClampedDragLayerPos(ev.getX(), ev.getY());
+        final int dragLayerX = dragLayerPos[0];
+        final int dragLayerY = dragLayerPos[1];
+
+        switch (action) {
+            case MotionEvent.ACTION_DOWN:
+                // Remember location of down touch
+                mMotionDownX = dragLayerX;
+                mMotionDownY = dragLayerY;
+                break;
+            case MotionEvent.ACTION_UP:
+                mLastTouchUpTime = System.currentTimeMillis();
+                break;
+        }
+
+        return mDragDriver != null && mDragDriver.onInterceptTouchEvent(ev);
+    }
+
+    /**
+     * Call this from a drag source view.
+     */
+    public boolean onDragEvent(long dragStartTime, DragEvent event) {
+        return mDragDriver != null && mDragDriver.onDragEvent(event);
+    }
+
+    /**
+     * Call this from a drag view.
+     */
+    public void onDragViewAnimationEnd() {
+        if (mDragDriver != null) {
+            mDragDriver.onDragViewAnimationEnd();
+        }
+    }
+
+    /**
+     * Sets the view that should handle move events.
+     */
+    public void setMoveTarget(View view) {
+        mMoveTarget = view;
+    }
+
+    public boolean dispatchUnhandledMove(View focused, int direction) {
+        return mMoveTarget != null && mMoveTarget.dispatchUnhandledMove(focused, direction);
+    }
+
+    private void handleMoveEvent(int x, int y) {
+        Log.d("DropTarget", "handleMoveEvent() called with: x = [" + x + "], y = [" + y + "]");
+        mDragObject.dragView.move(x, y);
+
+        // Drop on someone?
+        final int[] coordinates = mCoordinatesTemp;
+        DropTarget dropTarget = findDropTarget(x, y, coordinates);
+        mDragObject.x = coordinates[0];
+        mDragObject.y = coordinates[1];
+        checkTouchMove(dropTarget);
+
+        // Check if we are hovering over the scroll areas
+        mDistanceSinceScroll += Math.hypot(mLastTouch[0] - x, mLastTouch[1] - y);
+        mLastTouch[0] = x;
+        mLastTouch[1] = y;
+
+        if (mIsInPreDrag && mOptions.preDragCondition != null
+                && mOptions.preDragCondition.shouldStartDrag(mDistanceSinceScroll)) {
+            callOnDragStart();
+        }
+    }
+
+    public float getDistanceDragged() {
+        return mDistanceSinceScroll;
+    }
+
+    public void forceTouchMove() {
+        int[] dummyCoordinates = mCoordinatesTemp;
+        DropTarget dropTarget = findDropTarget(mLastTouch[0], mLastTouch[1], dummyCoordinates);
+        mDragObject.x = dummyCoordinates[0];
+        mDragObject.y = dummyCoordinates[1];
+        checkTouchMove(dropTarget);
+    }
+
+    private void checkTouchMove(DropTarget dropTarget) {
+        if (dropTarget != null) {
+            if (mLastDropTarget != dropTarget) {
+                if (mLastDropTarget != null) {
+                    mLastDropTarget.onDragExit(mDragObject);
+                }
+                dropTarget.onDragEnter(mDragObject);
+            }
+            dropTarget.onDragOver(mDragObject);
+        } else {
+            if (mLastDropTarget != null) {
+                mLastDropTarget.onDragExit(mDragObject);
+            }
+        }
+        mLastDropTarget = dropTarget;
+    }
+
+    /**
+     * Call this from a drag source view.
+     */
+    public boolean onControllerTouchEvent(MotionEvent ev) {
+        Log.d("DragController", "onControllerTouchEvent() called with: ev = [" + ev + "]");
+        if (mDragDriver == null || mOptions == null) {
+            return false;
+        }
+
+        final int action = ev.getAction();
+        final int[] dragLayerPos = getClampedDragLayerPos(ev.getX(), ev.getY());
+        final int dragLayerX = dragLayerPos[0];
+        final int dragLayerY = dragLayerPos[1];
+
+        switch (action) {
+            case MotionEvent.ACTION_DOWN:
+                // Remember where the motion event started
+                mMotionDownX = dragLayerX;
+                mMotionDownY = dragLayerY;
+                break;
+        }
+
+        return mDragDriver.onTouchEvent(ev);
+    }
+
+    /**
+     * Since accessible drag and drop won't cause the same sequence of touch events, we manually
+     * inject the appropriate state.
+     */
+    public void prepareAccessibleDrag(int x, int y) {
+        mMotionDownX = x;
+        mMotionDownY = y;
+    }
+
+    /**
+     * As above, since accessible drag and drop won't cause the same sequence of touch events,
+     * we manually ensure appropriate drag and drop events get emulated for accessible drag.
+     */
+    public void completeAccessibleDrag(int[] location) {
+        final int[] coordinates = mCoordinatesTemp;
+
+        // We make sure that we prime the target for drop.
+        DropTarget dropTarget = findDropTarget(location[0], location[1], coordinates);
+        mDragObject.x = coordinates[0];
+        mDragObject.y = coordinates[1];
+        checkTouchMove(dropTarget);
+
+        dropTarget.prepareAccessibilityDrop();
+        // Perform the drop
+        drop(dropTarget, null);
+        endDrag();
+    }
+
+    private void drop(DropTarget dropTarget, Runnable flingAnimation) {
+        final int[] coordinates = mCoordinatesTemp;
+        mDragObject.x = coordinates[0];
+        mDragObject.y = coordinates[1];
+
+        // Move dragging to the final target.
+        if (dropTarget != mLastDropTarget) {
+            if (mLastDropTarget != null) {
+                mLastDropTarget.onDragExit(mDragObject);
+            }
+            mLastDropTarget = dropTarget;
+            if (dropTarget != null) {
+                dropTarget.onDragEnter(mDragObject);
+            }
+        }
+
+        mDragObject.dragComplete = true;
+        if (mIsInPreDrag) {
+            if (dropTarget != null) {
+                dropTarget.onDragExit(mDragObject);
+            }
+            return;
+        }
+
+        // Drop onto the target.
+        boolean accepted = false;
+        if (dropTarget != null) {
+            dropTarget.onDragExit(mDragObject);
+            if (dropTarget.acceptDrop(mDragObject)) {
+                if (flingAnimation != null) {
+                    flingAnimation.run();
+                } else {
+                    dropTarget.onDrop(mDragObject, mOptions);
+                }
+                accepted = true;
+            }
+        }
+        final View dropTargetAsView = dropTarget instanceof View ? (View) dropTarget : null;
+        dispatchDropComplete(dropTargetAsView, accepted);
+    }
+
+    private DropTarget findDropTarget(int x, int y, int[] dropCoordinates) {
+        mDragObject.x = x;
+        mDragObject.y = y;
+
+        final Rect r = mRectTemp;
+        final ArrayList<DropTarget> dropTargets = mDropTargets;
+        final int count = dropTargets.size();
+        for (int i = count - 1; i >= 0; i--) {
+            DropTarget target = dropTargets.get(i);
+            if (!target.isDropEnabled())
+                continue;
+
+            target.getHitRectRelativeToDragLayer(r);
+            if (r.contains(x, y)) {
+                dropCoordinates[0] = x;
+                dropCoordinates[1] = y;
+                mLauncher.getDragLayer().mapCoordInSelfToDescendant((View) target, dropCoordinates);
+                return target;
+            }
+        }
+        // Pass all unhandled drag to workspace. Workspace finds the correct
+        // cell layout to drop to in the existing drag/drop logic.
+        dropCoordinates[0] = x;
+        dropCoordinates[1] = y;
+        mLauncher.getDragLayer().mapCoordInSelfToDescendant(mLauncher.getLauncherPagedView(),
+                dropCoordinates);
+        return mLauncher.getLauncherPagedView();
+    }
+
+    public void setWindowToken(IBinder token) {
+        mWindowToken = token;
+    }
+
+    /**
+     * Sets the drag listener which will be notified when a drag starts or ends.
+     */
+    public void addDragListener(DragListener l) {
+        mListeners.add(l);
+    }
+
+    /**
+     * Remove a previously installed drag listener.
+     */
+    public void removeDragListener(DragListener l) {
+        mListeners.remove(l);
+    }
+
+    /**
+     * Add a DropTarget to the list of potential places to receive drop events.
+     */
+    public void addDropTarget(DropTarget target) {
+        mDropTargets.add(target);
+    }
+
+    /**
+     * Don't send drop events to <em>target</em> any more.
+     */
+    public void removeDropTarget(DropTarget target) {
+        mDropTargets.remove(target);
+    }
+
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragDriver.java b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragDriver.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff9c304aaafa45068da44d959f187d7d96d302b1
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragDriver.java
@@ -0,0 +1,142 @@
+package foundation.e.blisslauncher.features.test.dragndrop;
+
+import android.content.Context;
+import android.view.DragEvent;
+import android.view.MotionEvent;
+
+/**
+ * Base class for driving a drag/drop operation.
+ */
+public abstract class DragDriver {
+    protected final EventListener mEventListener;
+
+    public interface EventListener {
+        void onDriverDragMove(float x, float y);
+        void onDriverDragExitWindow();
+        void onDriverDragEnd(float x, float y);
+        void onDriverDragCancel();
+    }
+
+    public DragDriver(EventListener eventListener) {
+        mEventListener = eventListener;
+    }
+
+    /**
+     * Handles ending of the DragView animation.
+     */
+    public void onDragViewAnimationEnd() { }
+
+    public boolean onTouchEvent(MotionEvent ev) {
+        final int action = ev.getAction();
+
+        switch (action) {
+            case MotionEvent.ACTION_MOVE:
+                mEventListener.onDriverDragMove(ev.getX(), ev.getY());
+                break;
+            case MotionEvent.ACTION_UP:
+                mEventListener.onDriverDragMove(ev.getX(), ev.getY());
+                mEventListener.onDriverDragEnd(ev.getX(), ev.getY());
+                break;
+            case MotionEvent.ACTION_CANCEL:
+                mEventListener.onDriverDragCancel();
+                break;
+        }
+
+        return true;
+    }
+
+    public abstract boolean onDragEvent (DragEvent event);
+
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        final int action = ev.getAction();
+
+        switch (action) {
+            case MotionEvent.ACTION_UP:
+                mEventListener.onDriverDragEnd(ev.getX(), ev.getY());
+                break;
+            case MotionEvent.ACTION_CANCEL:
+                mEventListener.onDriverDragCancel();
+                break;
+        }
+
+        return true;
+    }
+
+    public static DragDriver create(
+        Context context, DragController dragController,
+        DropTarget.DragObject dragObject, DragOptions options) {
+        //return new SystemDragDriver(dragController, context, dragObject);
+        return new InternalDragDriver(dragController);
+    }
+}
+
+/**
+ * Class for driving a system (i.e. framework) drag/drop operation.
+ */
+class SystemDragDriver extends DragDriver {
+
+    float mLastX = 0;
+    float mLastY = 0;
+
+    SystemDragDriver(DragController dragController, Context context, DropTarget.DragObject dragObject) {
+        super(dragController);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        return false;
+    }
+
+    @Override
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        return false;
+    }
+
+    @Override
+    public boolean onDragEvent (DragEvent event) {
+        final int action = event.getAction();
+
+        switch (action) {
+            case DragEvent.ACTION_DRAG_STARTED:
+                mLastX = event.getX();
+                mLastY = event.getY();
+                return true;
+
+            case DragEvent.ACTION_DRAG_ENTERED:
+                return true;
+
+            case DragEvent.ACTION_DRAG_LOCATION:
+                mLastX = event.getX();
+                mLastY = event.getY();
+                mEventListener.onDriverDragMove(event.getX(), event.getY());
+                return true;
+
+            case DragEvent.ACTION_DROP:
+                mLastX = event.getX();
+                mLastY = event.getY();
+                mEventListener.onDriverDragMove(event.getX(), event.getY());
+                mEventListener.onDriverDragEnd(mLastX, mLastY);
+                return true;
+            case DragEvent.ACTION_DRAG_EXITED:
+                mEventListener.onDriverDragExitWindow();
+                return true;
+
+            case DragEvent.ACTION_DRAG_ENDED:
+                mEventListener.onDriverDragCancel();
+                return true;
+
+            default:
+                return false;
+        }
+    }
+}
+
+class InternalDragDriver extends DragDriver {
+
+    public InternalDragDriver(EventListener eventListener) {
+        super(eventListener);
+    }
+
+    @Override
+    public boolean onDragEvent (DragEvent event) { return false; }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragLayer.java b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragLayer.java
new file mode 100644
index 0000000000000000000000000000000000000000..d15440530957ed72d5ca8036db49b68fb8dd0c40
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragLayer.java
@@ -0,0 +1,520 @@
+/*
+ * Copyright (C) 2008 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 foundation.e.blisslauncher.features.test.dragndrop;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.TimeInterpolator;
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.util.AttributeSet;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.WindowInsets;
+import android.view.animation.Interpolator;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.customviews.LauncherPagedView;
+import foundation.e.blisslauncher.features.test.BaseDragLayer;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.TouchController;
+import foundation.e.blisslauncher.features.test.anim.Interpolators;
+
+/**
+ * A ViewGroup that coordinates dragging across its descendants
+ */
+public class DragLayer extends BaseDragLayer<TestActivity> {
+
+    public static final int ALPHA_INDEX_OVERLAY = 0;
+    public static final int ALPHA_INDEX_LAUNCHER_LOAD = 1;
+    public static final int ALPHA_INDEX_TRANSITIONS = 2;
+    public static final int ALPHA_INDEX_SWIPE_UP = 3;
+    private static final int ALPHA_CHANNEL_COUNT = 4;
+
+    public static final int ANIMATION_END_DISAPPEAR = 0;
+    public static final int ANIMATION_END_REMAIN_VISIBLE = 2;
+
+    DragController mDragController;
+
+    // Variables relating to animation of views after drop
+    private ValueAnimator mDropAnim = null;
+    private final TimeInterpolator mCubicEaseOutInterpolator = Interpolators.DEACCEL_1_5;
+    DragView mDropView = null;
+    int mAnchorViewInitialScrollX = 0;
+
+    View mAnchorView = null;
+
+    private boolean mHoverPointClosesFolder = false;
+
+    private int mTopViewIndex;
+    private int mChildCountOnLastUpdate = -1;
+
+    /**
+     * Used to create a new DragLayer from XML.
+     *
+     * @param context The application's context.
+     * @param attrs   The attributes set containing the Workspace's customization values.
+     */
+    public DragLayer(Context context, AttributeSet attrs) {
+        super(context, attrs, ALPHA_CHANNEL_COUNT);
+
+        // Disable multitouch across the workspace/all apps/customize tray
+        setMotionEventSplittingEnabled(false);
+        setChildrenDrawingOrderEnabled(true);
+    }
+
+    public void setup(DragController dragController, LauncherPagedView workspace) {
+        mDragController = dragController;
+        recreateControllers();
+    }
+
+    public void recreateControllers() {
+        mControllers = new TouchController[] {
+            mActivity.getDragController()};
+    }
+
+    @Override
+    public boolean dispatchKeyEvent(KeyEvent event) {
+        return mDragController.dispatchKeyEvent(event) || super.dispatchKeyEvent(event);
+    }
+
+    @Override
+    protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
+        return super.drawChild(canvas, child, drawingTime);
+    }
+
+    @Override
+    protected boolean findActiveController(MotionEvent ev) {
+        //TODO: Enable when implementing state manager.
+        /*if (mActivity.getStateManager().getState().disableInteraction) {
+            // You Shall Not Pass!!!
+            mActiveController = null;
+            return true;
+        }*/
+        return super.findActiveController(ev);
+    }
+
+    @Override
+    public boolean onInterceptHoverEvent(MotionEvent ev) {
+        if (mActivity == null || mActivity.getLauncherPagedView() == null) {
+            return false;
+        }
+        /*AbstractFloatingView topView = AbstractFloatingView.getTopOpenView(mActivity);
+        if (!(topView instanceof Folder)) {
+            return false;
+        } else {
+            AccessibilityManager accessibilityManager = (AccessibilityManager)
+                getContext().getSystemService(Context.ACCESSIBILITY_SERVICE);
+            if (accessibilityManager.isTouchExplorationEnabled()) {
+                Folder currentFolder = (Folder) topView;
+                final int action = ev.getAction();
+                boolean isOverFolderOrSearchBar;
+                switch (action) {
+                    case MotionEvent.ACTION_HOVER_ENTER:
+                        isOverFolderOrSearchBar = isEventOverView(topView, ev) ||
+                            isEventOverAccessibleDropTargetBar(ev);
+                        if (!isOverFolderOrSearchBar) {
+                            sendTapOutsideFolderAccessibilityEvent(currentFolder.isEditingName());
+                            mHoverPointClosesFolder = true;
+                            return true;
+                        }
+                        mHoverPointClosesFolder = false;
+                        break;
+                    case MotionEvent.ACTION_HOVER_MOVE:
+                        isOverFolderOrSearchBar = isEventOverView(topView, ev) ||
+                            isEventOverAccessibleDropTargetBar(ev);
+                        if (!isOverFolderOrSearchBar && !mHoverPointClosesFolder) {
+                            sendTapOutsideFolderAccessibilityEvent(currentFolder.isEditingName());
+                            mHoverPointClosesFolder = true;
+                            return true;
+                        } else if (!isOverFolderOrSearchBar) {
+                            return true;
+                        }
+                        mHoverPointClosesFolder = false;
+                }
+            }
+        }*/
+        return false;
+    }
+
+    @Override
+    public boolean onHoverEvent(MotionEvent ev) {
+        // If we've received this, we've already done the necessary handling
+        // in onInterceptHoverEvent. Return true to consume the event.
+        return false;
+    }
+
+    @Override
+    public boolean dispatchUnhandledMove(View focused, int direction) {
+        return super.dispatchUnhandledMove(focused, direction)
+            || mDragController.dispatchUnhandledMove(focused, direction);
+    }
+
+    @Override
+    public boolean dispatchTouchEvent(MotionEvent ev) {
+        ev.offsetLocation(getTranslationX(), 0);
+        try {
+            return super.dispatchTouchEvent(ev);
+        } finally {
+            ev.offsetLocation(-getTranslationX(), 0);
+        }
+    }
+
+    public void animateViewIntoPosition(
+        DragView dragView, final int[] pos, float alpha,
+        float scaleX, float scaleY, int animationEndStyle, Runnable onFinishRunnable,
+        int duration
+    ) {
+        Rect r = new Rect();
+        getViewRectRelativeToSelf(dragView, r);
+        final int fromX = r.left;
+        final int fromY = r.top;
+
+        animateViewIntoPosition(dragView, fromX, fromY, pos[0], pos[1], alpha, 1, 1, scaleX, scaleY,
+            onFinishRunnable, animationEndStyle, duration, null
+        );
+    }
+
+    public void animateViewIntoPosition(DragView dragView, final View child, View anchorView) {
+        animateViewIntoPosition(dragView, child, -1, anchorView);
+    }
+
+    public void animateViewIntoPosition(
+        DragView dragView, final View child, int duration,
+        View anchorView
+    ) {
+
+        //TODO: Fix animation once the drag and drop is completed.
+        /*CellLayout cellLayout = (CellLayout) child.getParent();
+        GridLayout.LayoutParams lp = (GridLayout.LayoutParams) child.getLayoutParams();
+        cellLayout.measureChild(child);
+
+        Log.i("DragLayer", "Child index: "+cellLayout.indexOfChild(child)+" "+child.getX()+" "+child.getY());
+
+        Rect r = new Rect();
+        getViewRectRelativeToSelf(dragView, r);
+
+        int coord[] = new int[2];
+        float childScale = child.getScaleX();
+        coord[0] = (int) (lp.x + (int) (child.getMeasuredWidth() * (1 - childScale) / 2));
+        coord[1] = (int) (child.getY() + (int) (child.getMeasuredHeight() * (1 - childScale) / 2));
+        Log.i("DragLayer", "animateViewIntoPosition before relative: "+coord[0]+" "+coord[1]);
+
+        // Since the child hasn't necessarily been laid out, we force the lp to be updated with
+        // the correct coordinates (above) and use these to determine the final location
+        float scale = getDescendantCoordRelativeToSelf((View) child.getParent(), coord);
+        Log.i("DragLayer", "animateViewIntoPosition: "+coord[0]+" "+coord[1]+" "+scale);
+
+        // We need to account for the scale of the child itself, as the above only accounts for
+        // for the scale in parents.
+        scale *= childScale;
+        int toX = coord[0];
+        int toY = coord[1];
+        float toScale = scale;
+        if (child instanceof TextView) {
+            TextView tv = (TextView) child;
+            // Account for the source scale of the icon (ie. from AllApps to Workspace, in which
+            // the workspace may have smaller icon bounds).
+            toScale = scale / dragView.getIntrinsicIconScaleFactor();
+
+            // The child may be scaled (always about the center of the view) so to account for it,
+            // we have to offset the position by the scaled size.  Once we do that, we can center
+            // the drag view about the scaled child view.
+            toY += Math.round(toScale * tv.getPaddingTop());
+            toY -= dragView.getMeasuredHeight() * (1 - toScale) / 2;
+            if (dragView.getDragVisualizeOffset() != null) {
+                toY -= Math.round(toScale * dragView.getDragVisualizeOffset().y);
+            }
+
+            toX -= (dragView.getMeasuredWidth() - Math.round(scale * child.getMeasuredWidth())) / 2;
+        } *//*else if (child instanceof FolderIcon) {
+            // Account for holographic blur padding on the drag view
+            toY += Math.round(scale * (child.getPaddingTop() - dragView.getDragRegionTop()));
+            toY -= scale * dragView.getBlurSizeOutline() / 2;
+            toY -= (1 - scale) * dragView.getMeasuredHeight() / 2;
+            // Center in the x coordinate about the target's drawable
+            toX -= (dragView.getMeasuredWidth() - Math.round(scale * child.getMeasuredWidth())) / 2;
+        } *//*else {
+            toY -= (Math.round(scale * (dragView.getHeight() - child.getMeasuredHeight()))) / 2;
+            toX -= (Math.round(scale * (dragView.getMeasuredWidth()
+                - child.getMeasuredWidth()))) / 2;
+        }
+
+        final int fromX = r.left;
+        final int fromY = r.top;*/
+        child.setVisibility(INVISIBLE);
+        Runnable onCompleteRunnable = () -> child.setVisibility(VISIBLE);
+        /*animateViewIntoPosition(dragView, fromX, fromY, toX, toY, 1, 1, 1, toScale, toScale,
+            onCompleteRunnable, ANIMATION_END_DISAPPEAR, duration, anchorView
+        );*/
+        // Show the drop view if it was previously hidden
+        mDropView = dragView;
+        mDropView.requestLayout();
+        child.setVisibility(VISIBLE);
+        if (mDropView != null) {
+            mDragController.onDeferredEndDrag(mDropView);
+        }
+        mDropView = null;
+        invalidate();
+    }
+
+    public void animateViewIntoPosition(
+        final DragView view, final int fromX, final int fromY,
+        final int toX, final int toY, float finalAlpha, float initScaleX, float initScaleY,
+        float finalScaleX, float finalScaleY, Runnable onCompleteRunnable,
+        int animationEndStyle, int duration, View anchorView
+    ) {
+        Rect from = new Rect(fromX, fromY, fromX +
+            view.getMeasuredWidth(), fromY + view.getMeasuredHeight());
+        Rect to = new Rect(toX, toY, toX + view.getMeasuredWidth(), toY + view.getMeasuredHeight());
+        animateView(view,
+            from,
+            to,
+            finalAlpha,
+            initScaleX,
+            initScaleY,
+            finalScaleX,
+            finalScaleY,
+            duration,
+            null,
+            null,
+            onCompleteRunnable,
+            animationEndStyle,
+            anchorView
+        );
+    }
+
+    /**
+     * This method animates a view at the end of a drag and drop animation.
+     *
+     * @param view               The view to be animated. This view is drawn directly into DragLayer, and so
+     *                           doesn't need to be a child of DragLayer.
+     * @param from               The initial location of the view. Only the left and top parameters are used.
+     * @param to                 The final location of the view. Only the left and top parameters are used. This
+     *                           location doesn't account for scaling, and so should be centered about the desired
+     *                           final location (including scaling).
+     * @param finalAlpha         The final alpha of the view, in case we want it to fade as it animates.
+     * @param finalScaleX        The final scale of the view. The view is scaled about its center.
+     * @param finalScaleY        The final scale of the view. The view is scaled about its center.
+     * @param duration           The duration of the animation.
+     * @param motionInterpolator The interpolator to use for the location of the view.
+     * @param alphaInterpolator  The interpolator to use for the alpha of the view.
+     * @param onCompleteRunnable Optional runnable to run on animation completion.
+     * @param animationEndStyle  Whether or not to fade out the view once the animation completes.
+     *                           {@link #ANIMATION_END_DISAPPEAR} or {@link #ANIMATION_END_REMAIN_VISIBLE}.
+     * @param anchorView         If not null, this represents the view which the animated view stays
+     *                           anchored to in case scrolling is currently taking place. Note: currently this is
+     *                           only used for the X dimension for the case of the workspace.
+     */
+    public void animateView(
+        final DragView view, final Rect from, final Rect to,
+        final float finalAlpha, final float initScaleX, final float initScaleY,
+        final float finalScaleX, final float finalScaleY, int duration,
+        final Interpolator motionInterpolator, final Interpolator alphaInterpolator,
+        final Runnable onCompleteRunnable, final int animationEndStyle, View anchorView
+    ) {
+
+        // Calculate the duration of the animation based on the object's distance
+        final float dist = (float) Math.hypot(to.left - from.left, to.top - from.top);
+        final Resources res = getResources();
+        final float maxDist = (float) res.getInteger(R.integer.config_dropAnimMaxDist);
+
+        // If duration < 0, this is a cue to compute the duration based on the distance
+        if (duration < 0) {
+            duration = res.getInteger(R.integer.config_dropAnimMaxDuration);
+            if (dist < maxDist) {
+                duration *= mCubicEaseOutInterpolator.getInterpolation(dist / maxDist);
+            }
+            duration = Math.max(duration, res.getInteger(R.integer.config_dropAnimMinDuration));
+        }
+
+        // Fall back to cubic ease out interpolator for the animation if none is specified
+        TimeInterpolator interpolator = null;
+        if (alphaInterpolator == null || motionInterpolator == null) {
+            interpolator = mCubicEaseOutInterpolator;
+        }
+
+        // Animate the view
+        final float initAlpha = view.getAlpha();
+        final float dropViewScale = view.getScaleX();
+        AnimatorUpdateListener updateCb = new AnimatorUpdateListener() {
+            @Override
+            public void onAnimationUpdate(ValueAnimator animation) {
+                final float percent = (Float) animation.getAnimatedValue();
+                final int width = view.getMeasuredWidth();
+                final int height = view.getMeasuredHeight();
+
+                float alphaPercent = alphaInterpolator == null ? percent :
+                    alphaInterpolator.getInterpolation(percent);
+                float motionPercent = motionInterpolator == null ? percent :
+                    motionInterpolator.getInterpolation(percent);
+
+                float initialScaleX = initScaleX * dropViewScale;
+                float initialScaleY = initScaleY * dropViewScale;
+                float scaleX = finalScaleX * percent + initialScaleX * (1 - percent);
+                float scaleY = finalScaleY * percent + initialScaleY * (1 - percent);
+                float alpha = finalAlpha * alphaPercent + initAlpha * (1 - alphaPercent);
+
+                float fromLeft = from.left + (initialScaleX - 1f) * width / 2;
+                float fromTop = from.top + (initialScaleY - 1f) * height / 2;
+
+                int x = (int) (fromLeft + Math.round(((to.left - fromLeft) * motionPercent)));
+                int y = (int) (fromTop + Math.round(((to.top - fromTop) * motionPercent)));
+
+                int anchorAdjust = mAnchorView == null ? 0 : (int) (mAnchorView.getScaleX() *
+                    (mAnchorViewInitialScrollX - mAnchorView.getScrollX()));
+
+                int xPos = x - mDropView.getScrollX() + anchorAdjust;
+                int yPos = y - mDropView.getScrollY();
+
+                mDropView.setTranslationX(xPos);
+                mDropView.setTranslationY(yPos);
+                mDropView.setScaleX(scaleX);
+                mDropView.setScaleY(scaleY);
+                mDropView.setAlpha(alpha);
+            }
+        };
+        animateView(view, updateCb, duration, interpolator, onCompleteRunnable, animationEndStyle,
+            anchorView
+        );
+    }
+
+    public void animateView(
+        final DragView view, AnimatorUpdateListener updateCb, int duration,
+        TimeInterpolator interpolator, final Runnable onCompleteRunnable,
+        final int animationEndStyle, View anchorView
+    ) {
+        // Clean up the previous animations
+        if (mDropAnim != null) mDropAnim.cancel();
+
+        // Show the drop view if it was previously hidden
+        mDropView = view;
+        mDropView.requestLayout();
+
+        // Set the anchor view if the page is scrolling
+        if (anchorView != null) {
+            mAnchorViewInitialScrollX = anchorView.getScrollX();
+        }
+        mAnchorView = anchorView;
+
+        // Create and start the animation
+        mDropAnim = new ValueAnimator();
+        mDropAnim.setInterpolator(interpolator);
+        mDropAnim.setDuration(duration);
+        mDropAnim.setFloatValues(0f, 1f);
+        mDropAnim.addUpdateListener(updateCb);
+        mDropAnim.addListener(new AnimatorListenerAdapter() {
+            public void onAnimationEnd(Animator animation) {
+                if (onCompleteRunnable != null) {
+                    onCompleteRunnable.run();
+                }
+                switch (animationEndStyle) {
+                    case ANIMATION_END_DISAPPEAR:
+                        clearAnimatedView();
+                        break;
+                    case ANIMATION_END_REMAIN_VISIBLE:
+                        break;
+                }
+                mDropAnim = null;
+            }
+        });
+        mDropAnim.start();
+    }
+
+    public void clearAnimatedView() {
+        if (mDropAnim != null) {
+            mDropAnim.cancel();
+        }
+        mDropAnim = null;
+        if (mDropView != null) {
+            mDragController.onDeferredEndDrag(mDropView);
+        }
+        mDropView = null;
+        invalidate();
+    }
+
+    public View getAnimatedView() {
+        return mDropView;
+    }
+
+    @Override
+    public void onViewAdded(View child) {
+        super.onViewAdded(child);
+        updateChildIndices();
+        //UiFactory.onLauncherStateOrFocusChanged(mActivity);
+    }
+
+    @Override
+    public void onViewRemoved(View child) {
+        super.onViewRemoved(child);
+        updateChildIndices();
+        //UiFactory.onLauncherStateOrFocusChanged(mActivity);
+    }
+
+    @Override
+    public void bringChildToFront(View child) {
+        super.bringChildToFront(child);
+        updateChildIndices();
+    }
+
+    private void updateChildIndices() {
+        mTopViewIndex = -1;
+        int childCount = getChildCount();
+        for (int i = 0; i < childCount; i++) {
+            if (getChildAt(i) instanceof View) {
+                mTopViewIndex = i;
+            }
+        }
+        mChildCountOnLastUpdate = childCount;
+    }
+
+    @Override
+    protected int getChildDrawingOrder(int childCount, int i) {
+        if (mChildCountOnLastUpdate != childCount) {
+            // between platform versions 17 and 18, behavior for onChildViewRemoved / Added changed.
+            // Pre-18, the child was not added / removed by the time of those callbacks. We need to
+            // force update our representation of things here to avoid crashing on pre-18 devices
+            // in certain instances.
+            updateChildIndices();
+        }
+
+        // i represents the current draw iteration
+        if (mTopViewIndex == -1) {
+            // in general we do nothing
+            return i;
+        } else if (i == childCount - 1) {
+            // if we have a top index, we return it when drawing last item (highest z-order)
+            return mTopViewIndex;
+        } else if (i < mTopViewIndex) {
+            return i;
+        } else {
+            // for indexes greater than the top index, we fetch one item above to shift for the
+            // displacement of the top index
+            return i + 1;
+        }
+    }
+
+    @Override
+    public void setInsets(WindowInsets insets) {
+        super.setInsets(insets);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragOptions.java b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragOptions.java
new file mode 100644
index 0000000000000000000000000000000000000000..b090469c2b3ec6d74d307f35e6bd92c9b71445d5
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragOptions.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2016 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 foundation.e.blisslauncher.features.test.dragndrop;
+
+import android.graphics.Point;
+
+/**
+ * Set of options to control the drag and drop behavior.
+ */
+public class DragOptions {
+
+    /** Specifies the start location for the system DnD, null when using internal DnD */
+    public Point systemDndStartPoint = null;
+
+    /** Determines when a pre-drag should transition to a drag. By default, this is immediate. */
+    public PreDragCondition preDragCondition = null;
+
+    /** Scale of the icons over the workspace icon size. */
+    public float intrinsicIconScaleFactor = 1f;
+
+    /**
+     * Specifies a condition that must be met before DragListener#onDragStart() is called.
+     * By default, there is no condition and onDragStart() is called immediately following
+     * DragController#startDrag().
+     *
+     * This condition can be overridden, and callbacks are provided for the following cases:
+     * - The pre-drag starts, but onDragStart() is deferred (onPreDragStart()).
+     * - The pre-drag ends before the condition is met (onPreDragEnd(false)).
+     * - The actual drag starts when the condition is met (onPreDragEnd(true)).
+     */
+    public interface PreDragCondition {
+
+        public boolean shouldStartDrag(double distanceDragged);
+
+        /**
+         * The pre-drag has started, but onDragStart() is
+         * deferred until shouldStartDrag() returns true.
+         */
+        void onPreDragStart(DropTarget.DragObject dragObject);
+
+        /**
+         * The pre-drag has ended. This gets called at the same time as onDragStart()
+         * if the condition is met, otherwise at the same time as onDragEnd().
+         * @param dragStarted Whether the pre-drag ended because the actual drag started.
+         *                    This will be true if the condition was met, otherwise false.
+         */
+        void onPreDragEnd(DropTarget.DragObject dragObject, boolean dragStarted);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragSource.java b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragSource.java
new file mode 100644
index 0000000000000000000000000000000000000000..94d1d861be6cec59b5b98b90127f6db4c5f84107
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragSource.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2008 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 foundation.e.blisslauncher.features.test.dragndrop;
+
+import android.view.View;
+
+/**
+ * Interface defining an object that can originate a drag.
+ */
+public interface DragSource {
+
+    /**
+     * A callback made back to the source after an item from this source has been dropped on a
+     * DropTarget.
+     */
+    void onDropCompleted(View target, DropTarget.DragObject d, boolean success);
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragView.java b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragView.java
new file mode 100644
index 0000000000000000000000000000000000000000..0de69878505cd859399baac2063f14658cb30061
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DragView.java
@@ -0,0 +1,559 @@
+/*
+ * Copyright (C) 2008 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 foundation.e.blisslauncher.features.test.dragndrop;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.FloatArrayEvaluator;
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.annotation.TargetApi;
+import android.content.pm.LauncherActivityInfo;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.ColorMatrix;
+import android.graphics.ColorMatrixColorFilter;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.graphics.drawable.ColorDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.view.View;
+
+import androidx.dynamicanimation.animation.FloatPropertyCompat;
+import androidx.dynamicanimation.animation.SpringAnimation;
+import androidx.dynamicanimation.animation.SpringForce;
+
+import java.util.Arrays;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.database.model.LauncherItem;
+import foundation.e.blisslauncher.core.utils.Constants;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.anim.Interpolators;
+import foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils;
+
+public class DragView extends View {
+    private static final ColorMatrix sTempMatrix1 = new ColorMatrix();
+    private static final ColorMatrix sTempMatrix2 = new ColorMatrix();
+
+    public static final int COLOR_CHANGE_DURATION = 120;
+    public static final int VIEW_ZOOM_DURATION = 150;
+
+    static float sDragAlpha = 1f;
+
+    private boolean mDrawBitmap = true;
+    private Bitmap mBitmap;
+    private Bitmap mCrossFadeBitmap;
+    
+    Paint mPaint;
+    private final int mBlurSizeOutline;
+    private final int mRegistrationX;
+    private final int mRegistrationY;
+    private final float mInitialScale;
+    private final float mScaleOnDrop;
+    private final int[] mTempLoc = new int[2];
+
+    private Point mDragVisualizeOffset = null;
+    private Rect mDragRegion = null;
+    private final TestActivity mLauncher;
+    private final DragLayer mDragLayer;
+     final DragController mDragController;
+    private boolean mHasDrawn = false;
+     float mCrossFadeProgress = 0f;
+    private boolean mAnimationCancelled = false;
+
+    ValueAnimator mAnim;
+    // The intrinsic icon scale factor is the scale factor for a drag icon over the workspace
+    // size.  This is ignored for non-icons.
+    private float mIntrinsicIconScale = 1f;
+
+     float[] mCurrentFilter;
+    private ValueAnimator mFilterAnimator;
+
+    private int mLastTouchX;
+    private int mLastTouchY;
+    private int mAnimatedShiftX;
+    private int mAnimatedShiftY;
+
+    // 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;
+    private ColorMatrixColorFilter mBaseFilter;
+
+    /**
+     * Construct the drag view.
+     * <p>
+     * The registration point is the point inside our view that the touch events should
+     * be centered upon.
+     * @param launcher The Launcher instance
+     * @param bitmap 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.
+     */
+    public DragView(TestActivity launcher, Bitmap bitmap, int registrationX, int registrationY,
+                    final float initialScale, final float scaleOnDrop, final float finalScaleDps) {
+        super(launcher);
+        mLauncher = launcher;
+        mDragLayer = launcher.getDragLayer();
+        mDragController = launcher.getDragController();
+
+        final float scale = (bitmap.getWidth() + finalScaleDps) / bitmap.getWidth();
+
+        // Set the initial scale to avoid any jumps
+        setScaleX(initialScale);
+        setScaleY(initialScale);
+
+        // Animate the view into the correct position
+        mAnim = LauncherAnimUtils.ofFloat(0f, 1f);
+        mAnim.setDuration(VIEW_ZOOM_DURATION);
+        mAnim.addUpdateListener(animation -> {
+            final float value = (Float) animation.getAnimatedValue();
+
+            setScaleX(initialScale + (value * (scale - initialScale)));
+            setScaleY(initialScale + (value * (scale - initialScale)));
+            if (sDragAlpha != 1f) {
+                setAlpha(sDragAlpha * value + (1f - value));
+            }
+
+            if (getParent() == null) {
+                animation.cancel();
+            }
+        });
+
+        mAnim.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                if (!mAnimationCancelled) {
+                    mDragController.onDragViewAnimationEnd();
+                }
+            }
+        });
+
+        mBitmap = bitmap;
+        setDragRegion(new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight()));
+
+        // The point in our scaled bitmap that the touch events are located
+        mRegistrationX = registrationX;
+        mRegistrationY = registrationY;
+
+        mInitialScale = initialScale;
+        mScaleOnDrop = scaleOnDrop;
+
+        // Force a measure, because Workspace uses getMeasuredHeight() before the layout pass
+        int ms = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
+        measure(ms, ms);
+        mPaint = new Paint(Paint.FILTER_BITMAP_FLAG);
+
+        mBlurSizeOutline = getResources().getDimensionPixelSize(R.dimen.blur_size_medium_outline);
+        setElevation(getResources().getDimension(R.dimen.drag_elevation));
+    }
+
+    @TargetApi(Build.VERSION_CODES.O)
+    private void updateColorFilter() {
+        if (mCurrentFilter == null) {
+            mPaint.setColorFilter(null);
+
+            if (mScaledMaskPath != null) {
+                mBgSpringDrawable.setColorFilter(mBaseFilter);
+                mFgSpringDrawable.setColorFilter(mBaseFilter);
+                mBadge.setColorFilter(mBaseFilter);
+            }
+        } else {
+            ColorMatrixColorFilter currentFilter = new ColorMatrixColorFilter(mCurrentFilter);
+            mPaint.setColorFilter(currentFilter);
+
+            if (mScaledMaskPath != null) {
+                if (mBaseFilter != null) {
+                    mBaseFilter.getColorMatrix(sTempMatrix1);
+                    sTempMatrix2.set(mCurrentFilter);
+                    sTempMatrix1.postConcat(sTempMatrix2);
+
+                    currentFilter = new ColorMatrixColorFilter(sTempMatrix1);
+                }
+
+                mBgSpringDrawable.setColorFilter(currentFilter);
+                mFgSpringDrawable.setColorFilter(currentFilter);
+                mBadge.setColorFilter(currentFilter);
+            }
+        }
+
+        invalidate();
+    }
+
+    /**
+     * Returns the full drawable for {@param info}.
+     * @param outObj this is set to the internal data associated with {@param info},
+     *               eg {@link LauncherActivityInfo}.
+     */
+    private Drawable getFullDrawable(LauncherItem info, Object[] outObj) {
+        if (info.itemType == Constants.ITEM_TYPE_APPLICATION) {
+            return info.icon;
+        }
+        //TODO: Enable when support folder and shortcut.
+        /*else if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT) {
+            if (info instanceof PendingAddShortcutInfo) {
+                ShortcutConfigActivityInfo activityInfo =
+                        ((PendingAddShortcutInfo) info).activityInfo;
+                outObj[0] = activityInfo;
+                return activityInfo.getFullResIcon(appState.getIconCache());
+            }
+            ShortcutKey key = ShortcutKey.fromItemInfo(info);
+            DeepShortcutManager sm = DeepShortcutManager.getInstance(mLauncher);
+            List<ShortcutInfoCompat> si = sm.queryForFullDetails(
+                    key.componentName.getPackageName(), Arrays.asList(key.getId()), key.user);
+            if (si.isEmpty()) {
+                return null;
+            } else {
+                outObj[0] = si.get(0);
+                return sm.getShortcutIconDrawable(si.get(0),
+                        appState.getInvariantDeviceProfile().fillResIconDpi);
+            }
+        }
+        else if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_FOLDER) {
+            FolderAdaptiveIcon icon =  FolderAdaptiveIcon.createFolderAdaptiveIcon(
+                    mLauncher, info.id, new Point(mBitmap.getWidth(), mBitmap.getHeight()));
+            if (icon == null) {
+                return null;
+            }
+            outObj[0] = icon;
+            return icon;
+        } else {
+            return null;
+        }*/
+        return null;
+    }
+
+    /**
+     * For apps icons and shortcut icons that have badges, this method creates a drawable that can
+     * later on be rendered on top of the layers for the badges. For app icons, work profile badges
+     * can only be applied. For deep shortcuts, when dragged from the pop up container, there's no
+     * badge. When dragged from workspace or folder, it may contain app AND/OR work profile badge
+     **/
+
+    @TargetApi(Build.VERSION_CODES.O)
+    //TODO: Enable when adding badge support
+    /*private Drawable getBadge(ItemInfo info, LauncherAppState appState, Object obj) {
+        int iconSize = appState.getInvariantDeviceProfile().iconBitmapSize;
+        if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_DEEP_SHORTCUT) {
+            boolean iconBadged = (info instanceof ItemInfoWithIcon)
+                    && (((ItemInfoWithIcon) info).runtimeStatusFlags & FLAG_ICON_BADGED) > 0;
+            if ((info.id == ItemInfo.NO_ID && !iconBadged)
+                    || !(obj instanceof ShortcutInfoCompat)) {
+                // The item is not yet added on home screen.
+                return new FixedSizeEmptyDrawable(iconSize);
+            }
+            ShortcutInfoCompat si = (ShortcutInfoCompat) obj;
+            LauncherIcons li = LauncherIcons.obtain(appState.getContext());
+            Bitmap badge = li.getShortcutInfoBadge(si, appState.getIconCache()).iconBitmap;
+            li.recycle();
+            float badgeSize = mLauncher.getResources().getDimension(R.dimen.profile_badge_size);
+            float insetFraction = (iconSize - badgeSize) / iconSize;
+            return new InsetDrawable(new FastBitmapDrawable(badge),
+                    insetFraction, insetFraction, 0, 0);
+        } else if (info.itemType == LauncherSettings.Favorites.ITEM_TYPE_FOLDER) {
+            return ((FolderAdaptiveIcon) obj).getBadge();
+        } else {
+            return mLauncher.getPackageManager()
+                    .getUserBadgedIcon(new FixedSizeEmptyDrawable(iconSize), info.user);
+        }
+    }*/
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        setMeasuredDimension(mBitmap.getWidth(), mBitmap.getHeight());
+    }
+
+    /** Sets the scale of the view over the normal workspace icon size. */
+    public void setIntrinsicIconScaleFactor(float scale) {
+        mIntrinsicIconScale = scale;
+    }
+
+    public float getIntrinsicIconScaleFactor() {
+        return mIntrinsicIconScale;
+    }
+
+    public int getDragRegionLeft() {
+        return mDragRegion.left;
+    }
+
+    public int getDragRegionTop() {
+        return mDragRegion.top;
+    }
+
+    public int getDragRegionWidth() {
+        return mDragRegion.width();
+    }
+
+    public int getDragRegionHeight() {
+        return mDragRegion.height();
+    }
+
+    public void setDragVisualizeOffset(Point p) {
+        mDragVisualizeOffset = p;
+    }
+
+    public Point getDragVisualizeOffset() {
+        return mDragVisualizeOffset;
+    }
+
+    public void setDragRegion(Rect r) {
+        mDragRegion = r;
+    }
+
+    public Rect getDragRegion() {
+        return mDragRegion;
+    }
+
+    public Bitmap getPreviewBitmap() {
+        return mBitmap;
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        mHasDrawn = true;
+
+        if (mDrawBitmap) {
+            // Always draw the bitmap to mask anti aliasing due to clipPath
+            boolean crossFade = mCrossFadeProgress > 0 && mCrossFadeBitmap != null;
+            if (crossFade) {
+                int alpha = crossFade ? (int) (255 * (1 - mCrossFadeProgress)) : 255;
+                mPaint.setAlpha(alpha);
+            }
+            canvas.drawBitmap(mBitmap, 0.0f, 0.0f, mPaint);
+            if (crossFade) {
+                mPaint.setAlpha((int) (255 * mCrossFadeProgress));
+                final int saveCount = canvas.save();
+                float sX = (mBitmap.getWidth() * 1.0f) / mCrossFadeBitmap.getWidth();
+                float sY = (mBitmap.getHeight() * 1.0f) / mCrossFadeBitmap.getHeight();
+                canvas.scale(sX, sY);
+                canvas.drawBitmap(mCrossFadeBitmap, 0.0f, 0.0f, mPaint);
+                canvas.restoreToCount(saveCount);
+            }
+        }
+
+        if (mScaledMaskPath != null) {
+            int cnt = canvas.save();
+            canvas.clipPath(mScaledMaskPath);
+            mBgSpringDrawable.draw(canvas);
+            canvas.translate(mTranslateX.mValue, mTranslateY.mValue);
+            mFgSpringDrawable.draw(canvas);
+            canvas.restoreToCount(cnt);
+            mBadge.draw(canvas);
+        }
+    }
+
+    public void setCrossFadeBitmap(Bitmap crossFadeBitmap) {
+        mCrossFadeBitmap = crossFadeBitmap;
+    }
+
+    public void crossFade(int duration) {
+        ValueAnimator va = LauncherAnimUtils.ofFloat(0f, 1f);
+        va.setDuration(duration);
+        va.setInterpolator(Interpolators.DEACCEL_1_5);
+        va.addUpdateListener(animation -> {
+            mCrossFadeProgress = animation.getAnimatedFraction();
+            invalidate();
+        });
+        va.start();
+    }
+
+    private void animateFilterTo(float[] targetFilter) {
+        float[] oldFilter = mCurrentFilter == null ? new ColorMatrix().getArray() : mCurrentFilter;
+        mCurrentFilter = Arrays.copyOf(oldFilter, oldFilter.length);
+
+        if (mFilterAnimator != null) {
+            mFilterAnimator.cancel();
+        }
+        mFilterAnimator = ValueAnimator.ofObject(new FloatArrayEvaluator(mCurrentFilter),
+                oldFilter, targetFilter);
+        mFilterAnimator.setDuration(COLOR_CHANGE_DURATION);
+        mFilterAnimator.addUpdateListener(animation -> updateColorFilter());
+        mFilterAnimator.start();
+    }
+
+    public boolean hasDrawn() {
+        return mHasDrawn;
+    }
+
+    @Override
+    public void setAlpha(float alpha) {
+        super.setAlpha(alpha);
+        mPaint.setAlpha((int) (255 * alpha));
+        invalidate();
+    }
+
+    /**
+     * Create a window containing this view and show it.
+     *
+     * @param touchX the x coordinate the user touched in DragLayer coordinates
+     * @param touchY the y coordinate the user touched in DragLayer coordinates
+     */
+    public void show(int touchX, int touchY) {
+        mDragLayer.addView(this);
+
+        // Start the pick-up animation
+        DragLayer.LayoutParams lp = new DragLayer.LayoutParams(0, 0);
+        lp.width = mBitmap.getWidth();
+        lp.height = mBitmap.getHeight();
+        lp.customPosition = true;
+        setLayoutParams(lp);
+        move(touchX, touchY);
+        // Post the animation to skip other expensive work happening on the first frame
+        post(new Runnable() {
+            public void run() {
+                mAnim.start();
+            }
+        });
+    }
+
+    public void cancelAnimation() {
+        mAnimationCancelled = true;
+        if (mAnim != null && mAnim.isRunning()) {
+            mAnim.cancel();
+        }
+    }
+
+    /**
+     * Move the window containing this view.
+     *
+     * @param touchX the x coordinate the user touched in DragLayer coordinates
+     * @param touchY the y coordinate the user touched in DragLayer coordinates
+     */
+    public void move(int touchX, int touchY) {
+        if (touchX > 0 && touchY > 0 && mLastTouchX > 0 && mLastTouchY > 0
+                && mScaledMaskPath != null) {
+            mTranslateX.animateToPos(mLastTouchX - touchX);
+            mTranslateY.animateToPos(mLastTouchY - touchY);
+        }
+        mLastTouchX = touchX;
+        mLastTouchY = touchY;
+        applyTranslation();
+    }
+
+    public void animateTo(int toTouchX, int toTouchY, Runnable onCompleteRunnable, int duration) {
+        mTempLoc[0] = toTouchX - mRegistrationX;
+        mTempLoc[1] = toTouchY - mRegistrationY;
+        mDragLayer.animateViewIntoPosition(this, mTempLoc, 1f, mScaleOnDrop, mScaleOnDrop,
+                DragLayer.ANIMATION_END_DISAPPEAR, onCompleteRunnable, duration);
+    }
+
+    public void animateShift(final int shiftX, final int shiftY) {
+        if (mAnim.isStarted()) {
+            return;
+        }
+        mAnimatedShiftX = shiftX;
+        mAnimatedShiftY = shiftY;
+        applyTranslation();
+        mAnim.addUpdateListener(new AnimatorUpdateListener() {
+            @Override
+            public void onAnimationUpdate(ValueAnimator animation) {
+                float fraction = 1 - animation.getAnimatedFraction();
+                mAnimatedShiftX = (int) (fraction * shiftX);
+                mAnimatedShiftY = (int) (fraction * shiftY);
+                applyTranslation();
+            }
+        });
+    }
+
+    private void applyTranslation() {
+        setTranslationX(mLastTouchX - mRegistrationX + mAnimatedShiftX);
+        setTranslationY(mLastTouchY - mRegistrationY + mAnimatedShiftY);
+    }
+
+    public void remove() {
+        if (getParent() != null) {
+            mDragLayer.removeView(DragView.this);
+        }
+    }
+
+    public int getBlurSizeOutline() {
+        return mBlurSizeOutline;
+    }
+
+    public float getInitialScale() {
+        return mInitialScale;
+    }
+
+    private static class SpringFloatValue {
+
+        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();
+                    }
+                };
+
+        // Following three values are fine tuned with motion ux designer
+        private final static int STIFFNESS = 4000;
+        private final static float DAMPENING_RATIO = 1f;
+        private final static int PARALLAX_MAX_IN_DP = 8;
+
+        private final View mView;
+        private final SpringAnimation mSpring;
+        private final float mDelta;
+
+        private float mValue;
+
+        public SpringFloatValue(View view, float range) {
+            mView = view;
+            mSpring = new SpringAnimation(this, VALUE, 0)
+                    .setMinValue(-range).setMaxValue(range)
+                    .setSpring(new SpringForce(0)
+                            .setDampingRatio(DAMPENING_RATIO)
+                            .setStiffness(STIFFNESS));
+            mDelta = view.getResources().getDisplayMetrics().density * PARALLAX_MAX_IN_DP;
+        }
+
+        public void animateToPos(float value) {
+            mSpring.animateToFinalPosition(Utilities.boundToRange(value, -mDelta, mDelta));
+        }
+    }
+
+    private static class FixedSizeEmptyDrawable extends ColorDrawable {
+
+        private final int mSize;
+
+        public FixedSizeEmptyDrawable(int size) {
+            super(Color.TRANSPARENT);
+            mSize = size;
+        }
+
+        @Override
+        public int getIntrinsicHeight() {
+            return mSize;
+        }
+
+        @Override
+        public int getIntrinsicWidth() {
+            return mSize;
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DropTarget.java b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DropTarget.java
new file mode 100644
index 0000000000000000000000000000000000000000..94dbfd33a90e38da0dc86bb0254ee58306609851
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/DropTarget.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2008 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 foundation.e.blisslauncher.features.test.dragndrop;
+
+import android.graphics.Rect;
+import android.util.Log;
+
+import foundation.e.blisslauncher.core.database.model.LauncherItem;
+
+/**
+ * Interface defining an object that can receive a drag.
+ */
+public interface DropTarget {
+
+    class DragObject {
+        public int x = -1;
+        public int y = -1;
+
+        /**
+         * X offset from the upper-left corner of the cell to where we touched.
+         */
+        public int xOffset = -1;
+
+        /**
+         * Y offset from the upper-left corner of the cell to where we touched.
+         */
+        public int yOffset = -1;
+
+        /**
+         * This indicates whether a drag is in final stages, either drop or cancel. It
+         * differentiates onDragExit, since this is called when the drag is ending, above
+         * the current drag target, or when the drag moves off the current drag object.
+         */
+        public boolean dragComplete = false;
+
+        /**
+         * The view that moves around while you drag.
+         */
+        public DragView dragView = null;
+
+        /**
+         * The data associated with the object, after item is dropped.
+         */
+        public LauncherItem dragInfo = null;
+
+        /**
+         * The data associated with the object being dragged
+         */
+        public LauncherItem originalDragInfo = null;
+
+        /**
+         * Where the drag originated
+         */
+        public DragSource dragSource = null;
+
+        /**
+         * The object is part of an accessible drag operation
+         */
+        public boolean accessibleDrag;
+
+        /**
+         * Indicates that the drag operation was cancelled
+         */
+        public boolean cancelled = false;
+
+        /**
+         * Defers removing the DragView from the DragLayer until after the drop animation.
+         */
+        public boolean deferDragViewCleanupPostAnimation = true;
+
+        public DragObject() {
+        }
+
+        /**
+         * This is used to compute the visual center of the dragView. This point is then
+         * used to visualize drop locations and determine where to drop an item. The idea is that
+         * the visual center represents the user's interpretation of where the item is, and hence
+         * is the appropriate point to use when determining drop location.
+         */
+        public final float[] getVisualCenter(float[] recycle) {
+            final float res[] = (recycle == null) ? new float[2] : recycle;
+
+            // These represent the visual top and left of drag view if a dragRect was provided.
+            // If a dragRect was not provided, then they correspond to the actual view left and
+            // top, as the dragRect is in that case taken to be the entire dragView.
+            // R.dimen.dragViewOffsetY.
+
+            Log.d("DropTarget", "X: "+x+", Y: "+y+", xoffset: "+xOffset+", yoffset: "+yOffset);
+            int left = x - xOffset;
+            int top = y - yOffset;
+
+            // In order to find the visual center, we shift by half the dragRect
+            res[0] = left + dragView.getWidth() / 2;
+            res[1] = top + dragView.getHeight() / 2;
+
+            return res;
+        }
+    }
+
+    /**
+     * Used to temporarily disable certain drop targets
+     *
+     * @return boolean specifying whether this drop target is currently enabled
+     */
+    boolean isDropEnabled();
+
+    /**
+     * Handle an object being dropped on the DropTarget.
+     * <p>
+     * This will be called only if this target previously returned true for {@link #acceptDrop}. It
+     * is the responsibility of this target to exit out of the spring loaded mode (either
+     * immediately or after any pending animations).
+     * <p>
+     * If the drop was cancelled for some reason, onDrop will never get called, the UI will
+     * automatically exit out of this mode.
+     */
+    void onDrop(DragObject dragObject, DragOptions options);
+
+    void onDragEnter(DragObject dragObject);
+
+    void onDragOver(DragObject dragObject);
+
+    void onDragExit(DragObject dragObject);
+
+    /**
+     * Check if a drop action can occur at, or near, the requested location.
+     * This will be called just before onDrop.
+     *
+     * @return True if the drop will be accepted, false otherwise.
+     */
+    boolean acceptDrop(DragObject dragObject);
+
+    void prepareAccessibilityDrop();
+
+    // These methods are implemented in Views
+    void getHitRectRelativeToDragLayer(Rect outRect);
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/SpringLoadedDragController.java b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/SpringLoadedDragController.java
new file mode 100644
index 0000000000000000000000000000000000000000..bf594d2aef28b2dfa3240dab0d669156e75f4697
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/dragndrop/SpringLoadedDragController.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2010 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 foundation.e.blisslauncher.features.test.dragndrop;
+
+import android.widget.GridLayout;
+
+import foundation.e.blisslauncher.core.customviews.LauncherPagedView;
+import foundation.e.blisslauncher.features.test.Alarm;
+import foundation.e.blisslauncher.features.test.OnAlarmListener;
+import foundation.e.blisslauncher.features.test.TestActivity;
+
+public class SpringLoadedDragController implements OnAlarmListener {
+    // how long the user must hover over a mini-screen before it unshrinks
+    final long ENTER_SPRING_LOAD_HOVER_TIME = 500;
+    final long ENTER_SPRING_LOAD_CANCEL_HOVER_TIME = 950;
+
+    Alarm mAlarm;
+
+    // the screen the user is currently hovering over, if any
+    private GridLayout mScreen;
+    private TestActivity mLauncher;
+
+    public SpringLoadedDragController(TestActivity launcher) {
+        mLauncher = launcher;
+        mAlarm = new Alarm();
+        mAlarm.setOnAlarmListener(this);
+    }
+
+    public void cancel() {
+        mAlarm.cancelAlarm();
+    }
+
+    // Set a new alarm to expire for the screen that we are hovering over now
+    public void setAlarm(GridLayout cl) {
+        mAlarm.cancelAlarm();
+        mAlarm.setAlarm((cl == null) ? ENTER_SPRING_LOAD_CANCEL_HOVER_TIME :
+            ENTER_SPRING_LOAD_HOVER_TIME);
+        mScreen = cl;
+    }
+
+    // this is called when our timer runs out
+    public void onAlarm(Alarm alarm) {
+        if (mScreen != null) {
+            // Snap to the screen that we are hovering over now
+            LauncherPagedView w = mLauncher.getLauncherPagedView();
+            int page = w.indexOfChild(mScreen);
+            if (page != w.getCurrentPage()) {
+                w.snapToPage(page);
+            }
+        } else {
+            mLauncher.getDragController().cancelDrag();
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/graphics/BitmapRenderer.java b/app/src/main/java/foundation/e/blisslauncher/features/test/graphics/BitmapRenderer.java
new file mode 100644
index 0000000000000000000000000000000000000000..6c48f6601dc0292f5c09464d7f314333b1f022f5
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/graphics/BitmapRenderer.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.features.test.graphics;
+
+import android.annotation.TargetApi;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Picture;
+import android.os.Build;
+
+import foundation.e.blisslauncher.core.Utilities;
+
+public class BitmapRenderer {
+
+     public static final boolean USE_HARDWARE_BITMAP = Utilities.ATLEAST_P;
+
+     public static Bitmap createSoftwareBitmap(int width, int height, Renderer renderer) {
+          Bitmap result = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+          renderer.draw(new Canvas(result));
+          return result;
+     }
+
+     @TargetApi(Build.VERSION_CODES.P)
+     public static Bitmap createHardwareBitmap(int width, int height, Renderer renderer) {
+          if (!USE_HARDWARE_BITMAP) {
+               return createSoftwareBitmap(width, height, renderer);
+          }
+
+          Picture picture = new Picture();
+          renderer.draw(picture.beginRecording(width, height));
+          picture.endRecording();
+          return Bitmap.createBitmap(picture);
+     }
+
+     /**
+      * Interface representing a bitmap draw operation.
+      */
+     public interface Renderer {
+          void draw(Canvas out);
+     }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/graphics/DragPreviewProvider.java b/app/src/main/java/foundation/e/blisslauncher/features/test/graphics/DragPreviewProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..3142c9cb1ec52273f190152f86ef233081e8b943
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/graphics/DragPreviewProvider.java
@@ -0,0 +1,252 @@
+/*
+ * Copyright (C) 2016 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 foundation.e.blisslauncher.features.test.graphics;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BlurMaskFilter;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.os.Handler;
+import android.util.Log;
+import android.view.View;
+
+import java.nio.ByteBuffer;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.features.test.IconTextView;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.UiThreadHelper;
+
+/**
+ * A utility class to generate preview bitmap for dragging.
+ */
+public class DragPreviewProvider {
+
+    private final Rect mTempRect = new Rect();
+
+    protected final View mView;
+
+    // The padding added to the drag view during the preview generation.
+    public final int previewPadding;
+
+    protected final int blurSizeOutline;
+
+    private OutlineGeneratorCallback mOutlineGeneratorCallback;
+    public Bitmap generatedDragOutline;
+
+    public DragPreviewProvider(View view) {
+        this(view, view.getContext());
+    }
+
+    public DragPreviewProvider(View view, Context context) {
+        mView = view;
+        blurSizeOutline =
+                context.getResources().getDimensionPixelSize(R.dimen.blur_size_medium_outline);
+
+        if (mView instanceof IconTextView) {
+            Drawable d = ((IconTextView) mView).getIcon();
+            Rect bounds = getDrawableBounds(d);
+            previewPadding = blurSizeOutline - bounds.left - bounds.top;
+        } else {
+            previewPadding = blurSizeOutline;
+        }
+        Log.i("DragPreview", "PreviewPadding: "+previewPadding);
+    }
+
+    /**
+     * Draws the {@link #mView} into the given {@param destCanvas}.
+     */
+    protected void drawDragView(Canvas destCanvas, float scale) {
+        destCanvas.save();
+        destCanvas.scale(scale, scale);
+
+        if (mView instanceof IconTextView) {
+            Drawable d = ((IconTextView) mView).getIcon();
+            Rect bounds = getDrawableBounds(d);
+            destCanvas.translate(blurSizeOutline / 2 - bounds.left,
+                    blurSizeOutline / 2 - bounds.top);
+            d.draw(destCanvas);
+        } else {
+            //TODO: When enabling folder support
+/*            final Rect clipRect = mTempRect;
+            mView.getDrawingRect(clipRect);
+
+            boolean textVisible = false;
+            if (mView instanceof FolderIcon) {
+                // For FolderIcons the text can bleed into the icon area, and so we need to
+                // hide the text completely (which can't be achieved by clipping).
+                if (((FolderIcon) mView).getTextVisible()) {
+                    ((FolderIcon) mView).setTextVisible(false);
+                    textVisible = true;
+                }
+            }
+            destCanvas.translate(-mView.getScrollX() + blurSizeOutline / 2,
+                    -mView.getScrollY() + blurSizeOutline / 2);
+            destCanvas.clipRect(clipRect);
+            mView.draw(destCanvas);
+
+            // Restore text visibility of FolderIcon if necessary
+            if (textVisible) {
+                ((FolderIcon) mView).setTextVisible(true);
+            }*/
+        }
+        destCanvas.restore();
+    }
+
+    /**
+     * Returns a new bitmap to show when the {@link #mView} is being dragged around.
+     * Responsibility for the bitmap is transferred to the caller.
+     */
+    public Bitmap createDragBitmap() {
+        int width = mView.getWidth();
+        int height = mView.getHeight();
+
+        if (mView instanceof IconTextView) {
+            Drawable d = ((IconTextView) mView).getIcon();
+            Rect bounds = getDrawableBounds(d);
+            width = bounds.width();
+            height = bounds.height();
+        }
+
+        return BitmapRenderer.createHardwareBitmap(width + blurSizeOutline,
+                height + blurSizeOutline, (c) -> drawDragView(c, 1));
+    }
+
+    public final void generateDragOutline(Bitmap preview) {
+        if (mOutlineGeneratorCallback != null) {
+            throw new RuntimeException("Drag outline generated twice");
+        }
+
+        mOutlineGeneratorCallback = new OutlineGeneratorCallback(preview);
+        new Handler(UiThreadHelper.getBackgroundLooper()).post(mOutlineGeneratorCallback);
+    }
+
+    protected static Rect getDrawableBounds(Drawable d) {
+        Rect bounds = new Rect();
+        d.copyBounds(bounds);
+        if (bounds.width() == 0 || bounds.height() == 0) {
+            bounds.set(0, 0, d.getIntrinsicWidth(), d.getIntrinsicHeight());
+        } else {
+            bounds.offsetTo(0, 0);
+        }
+        return bounds;
+    }
+
+    public float getScaleAndPosition(Bitmap preview, int[] outPos) {
+        float scale = TestActivity.Companion.getLauncher(mView.getContext())
+                .getDragLayer().getLocationInDragLayer(mView, outPos);
+        Log.i("DragPreview", "getScaleAndPosition: "+outPos[0]+" "+outPos[1]+" "+preview.getWidth()+" "+mView.getWidth());
+        outPos[0] = Math.round(outPos[0] -
+                (preview.getWidth() - scale * mView.getWidth() * mView.getScaleX()) / 2);
+        outPos[1] = Math.round(outPos[1] - (1 - scale) * preview.getHeight() / 2
+                - previewPadding / 2);
+        Log.i("DragPreview", "getScaleAndPosition: "+outPos[0]+" "+outPos[1] + " "+scale);
+
+
+        return scale;
+    }
+
+    protected Bitmap convertPreviewToAlphaBitmap(Bitmap preview) {
+        return preview.copy(Bitmap.Config.ALPHA_8, true);
+    }
+
+    private class OutlineGeneratorCallback implements Runnable {
+
+        private final Bitmap mPreviewSnapshot;
+        private final Context mContext;
+
+        OutlineGeneratorCallback(Bitmap preview) {
+            mPreviewSnapshot = preview;
+            mContext = mView.getContext();
+        }
+
+        @Override
+        public void run() {
+            Bitmap preview = convertPreviewToAlphaBitmap(mPreviewSnapshot);
+
+            // We start by removing most of the alpha channel so as to ignore shadows, and
+            // other types of partial transparency when defining the shape of the object
+            byte[] pixels = new byte[preview.getWidth() * preview.getHeight()];
+            ByteBuffer buffer = ByteBuffer.wrap(pixels);
+            buffer.rewind();
+            preview.copyPixelsToBuffer(buffer);
+
+            for (int i = 0; i < pixels.length; i++) {
+                if ((pixels[i] & 0xFF) < 188) {
+                    pixels[i] = 0;
+                }
+            }
+
+            buffer.rewind();
+            preview.copyPixelsFromBuffer(buffer);
+
+            final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
+            Canvas canvas = new Canvas();
+
+            // calculate the outer blur first
+            paint.setMaskFilter(new BlurMaskFilter(blurSizeOutline, BlurMaskFilter.Blur.OUTER));
+            int[] outerBlurOffset = new int[2];
+            Bitmap thickOuterBlur = preview.extractAlpha(paint, outerBlurOffset);
+
+            paint.setMaskFilter(new BlurMaskFilter(
+                    mContext.getResources().getDimension(R.dimen.blur_size_thin_outline),
+                    BlurMaskFilter.Blur.OUTER));
+            int[] brightOutlineOffset = new int[2];
+            Bitmap brightOutline = preview.extractAlpha(paint, brightOutlineOffset);
+
+            // calculate the inner blur
+            canvas.setBitmap(preview);
+            canvas.drawColor(0xFF000000, PorterDuff.Mode.SRC_OUT);
+            paint.setMaskFilter(new BlurMaskFilter(blurSizeOutline, BlurMaskFilter.Blur.NORMAL));
+            int[] thickInnerBlurOffset = new int[2];
+            Bitmap thickInnerBlur = preview.extractAlpha(paint, thickInnerBlurOffset);
+
+            // mask out the inner blur
+            paint.setMaskFilter(null);
+            paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT));
+            canvas.setBitmap(thickInnerBlur);
+            canvas.drawBitmap(preview, -thickInnerBlurOffset[0],
+                    -thickInnerBlurOffset[1], paint);
+            canvas.drawRect(0, 0, -thickInnerBlurOffset[0], thickInnerBlur.getHeight(), paint);
+            canvas.drawRect(0, 0, thickInnerBlur.getWidth(), -thickInnerBlurOffset[1], paint);
+
+            // draw the inner and outer blur
+            paint.setXfermode(null);
+            canvas.setBitmap(preview);
+            canvas.drawColor(0, PorterDuff.Mode.CLEAR);
+            canvas.drawBitmap(thickInnerBlur, thickInnerBlurOffset[0], thickInnerBlurOffset[1],
+                    paint);
+            canvas.drawBitmap(thickOuterBlur, outerBlurOffset[0], outerBlurOffset[1], paint);
+
+            // draw the bright outline
+            canvas.drawBitmap(brightOutline, brightOutlineOffset[0], brightOutlineOffset[1], paint);
+
+            // cleanup
+            canvas.setBitmap(null);
+            brightOutline.recycle();
+            thickOuterBlur.recycle();
+            thickInnerBlur.recycle();
+
+            generatedDragOutline = preview;
+        }
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/graphics/RotationMode.java b/app/src/main/java/foundation/e/blisslauncher/features/test/graphics/RotationMode.java
new file mode 100644
index 0000000000000000000000000000000000000000..0aae310000a390ba73db23befc31cc60d6a5ae3b
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/graphics/RotationMode.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.features.test.graphics;
+
+import android.content.Context;
+import android.graphics.Rect;
+
+public abstract class RotationMode {
+
+    public static RotationMode NORMAL = new RotationMode(0) { };
+
+    public final float surfaceRotation;
+    public final boolean isTransposed;
+
+    public RotationMode(float surfaceRotation) {
+        this.surfaceRotation = surfaceRotation;
+        isTransposed = surfaceRotation != 0;
+    }
+
+    public final void mapRect(Rect rect, Rect out) {
+        mapRect(rect.left, rect.top, rect.right, rect.bottom, out);
+    }
+
+    public void mapRect(int left, int top, int right, int bottom, Rect out) {
+        out.set(left, top, right, bottom);
+    }
+
+    public void mapInsets(Context context, Rect insets, Rect out) {
+        out.set(insets);
+    }
+
+    public int toNaturalGravity(int absoluteGravity) {
+        return absoluteGravity;
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/test/graphics/ViewScrim.java b/app/src/main/java/foundation/e/blisslauncher/features/test/graphics/ViewScrim.java
new file mode 100644
index 0000000000000000000000000000000000000000..52e5f7b44e3c9846dcf6766d5ab463689815005b
--- /dev/null
+++ b/app/src/main/java/foundation/e/blisslauncher/features/test/graphics/ViewScrim.java
@@ -0,0 +1,77 @@
+/*
+ * 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 foundation.e.blisslauncher.features.test.graphics;
+
+import android.graphics.Canvas;
+import android.util.Property;
+import android.view.View;
+import android.view.ViewParent;
+
+import foundation.e.blisslauncher.R;
+
+/**
+ * A utility class that can be used to draw a scrim behind a view
+ */
+public abstract class ViewScrim<T extends View> {
+
+    public static Property<ViewScrim, Float> PROGRESS =
+            new Property<ViewScrim, Float>(Float.TYPE, "progress") {
+                @Override
+                public Float get(ViewScrim viewScrim) {
+                    return viewScrim.mProgress;
+                }
+
+                @Override
+                public void set(ViewScrim object, Float value) {
+                    object.setProgress(value);
+                }
+            };
+
+    protected final T mView;
+    protected float mProgress = 0;
+
+    public ViewScrim(T view) {
+        mView = view;
+    }
+
+    public void attach() {
+        mView.setTag(R.id.view_scrim, this);
+    }
+
+    public void setProgress(float progress) {
+        if (mProgress != progress) {
+            mProgress = progress;
+            onProgressChanged();
+            invalidate();
+        }
+    }
+
+    public abstract void draw(Canvas canvas, int width, int height);
+
+    protected void onProgressChanged() { }
+
+    public void invalidate() {
+        ViewParent parent = mView.getParent();
+        if (parent != null) {
+            ((View) parent).invalidate();
+        }
+    }
+
+    public static ViewScrim get(View view) {
+        return (ViewScrim) view.getTag(R.id.view_scrim);
+    }
+}
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/usagestats/AppUsageStats.java b/app/src/main/java/foundation/e/blisslauncher/features/usagestats/AppUsageStats.java
index a5de1448838f115b059e21c3e1e6b2defb821463..b1ea3292d89a1310a1c940ade23ec9f6b303fe5d 100755
--- a/app/src/main/java/foundation/e/blisslauncher/features/usagestats/AppUsageStats.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/usagestats/AppUsageStats.java
@@ -9,7 +9,8 @@ import android.content.Intent;
 import android.provider.Settings;
 import android.util.Log;
 import android.widget.Toast;
-
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Preferences;
 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Collections;
@@ -18,9 +19,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import foundation.e.blisslauncher.R;
-import foundation.e.blisslauncher.core.Preferences;
-
 public class AppUsageStats {
 
     private final Context mContext;
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/widgets/AddedWidgetsAdapter.java b/app/src/main/java/foundation/e/blisslauncher/features/widgets/AddedWidgetsAdapter.java
index 099b1c22c04fe1263a3012b0b6586b73a29ab5ce..493395071278f1e7495a7f5769c35cce7b641061 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/widgets/AddedWidgetsAdapter.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/widgets/AddedWidgetsAdapter.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.widgets;
 
+
 import android.appwidget.AppWidgetProviderInfo;
 import android.content.Context;
 import android.view.LayoutInflater;
@@ -7,15 +8,12 @@ import android.view.View;
 import android.view.ViewGroup;
 import android.widget.ImageView;
 import android.widget.TextView;
-
 import androidx.annotation.NonNull;
 import androidx.recyclerview.widget.RecyclerView;
-
+import foundation.e.blisslauncher.R;
 import java.util.ArrayList;
 import java.util.List;
 
-import foundation.e.blisslauncher.R;
-
 public class AddedWidgetsAdapter extends
         RecyclerView.Adapter<AddedWidgetsAdapter.WidgetsViewHolder> {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/widgets/CheckLongPressHelper.java b/app/src/main/java/foundation/e/blisslauncher/features/widgets/CheckLongPressHelper.java
index 9563d20f6299a38b784ba06ace9aea53aec8caea..2e6e6e6a8431d0c8857ab3d1ca5f71d975dd72a8 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/widgets/CheckLongPressHelper.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/widgets/CheckLongPressHelper.java
@@ -16,9 +16,9 @@
 
 package foundation.e.blisslauncher.features.widgets;
 
+
 import android.util.Log;
 import android.view.View;
-
 import foundation.e.blisslauncher.BlissLauncher;
 
 public class CheckLongPressHelper {
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/widgets/Widget.java b/app/src/main/java/foundation/e/blisslauncher/features/widgets/Widget.java
index ac6e45355106ec66b425215cca2768a5d850b84b..c4246cc2a8b5a30920bad5390ec333d9f2856d1d 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/widgets/Widget.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/widgets/Widget.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.widgets;
 
+
 import android.appwidget.AppWidgetProviderInfo;
 
 public class Widget {
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetManager.java b/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetManager.java
index 234c9c070abc373c35452dcdb1ffd88334714c20..e4bf9c612a37412edd6cb584678836a71138b993 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetManager.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetManager.java
@@ -1,11 +1,11 @@
 package foundation.e.blisslauncher.features.widgets;
 
+
+import foundation.e.blisslauncher.core.customviews.RoundedWidgetView;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.Queue;
 
-import foundation.e.blisslauncher.core.customviews.RoundedWidgetView;
-
 public class WidgetManager {
     private static final WidgetManager ourInstance = new WidgetManager();
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetPicker.java b/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetPicker.java
index 6c99bc829fcdb325612b17deff78dde2c9e75f73..6d5e6f71ac5ab5989fdaaa8c308d0f81b9d0eee7 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetPicker.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetPicker.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.widgets;
 
+
 import android.app.Activity;
 import android.appwidget.AppWidgetManager;
 import android.appwidget.AppWidgetProviderInfo;
@@ -13,19 +14,16 @@ import android.os.Parcelable;
 import android.util.DisplayMetrics;
 import android.util.Log;
 import android.widget.Toast;
-
 import androidx.recyclerview.widget.DividerItemDecoration;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
-
+import foundation.e.blisslauncher.R;
 import java.text.Collator;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 
-import foundation.e.blisslauncher.R;
-
 public class WidgetPicker extends Activity implements WidgetPickerAdapter.OnClickListener {
 
     private static final int REQUEST_BIND_APPWIDGET = 111;
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetPickerAdapter.java b/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetPickerAdapter.java
index 50b2b7fda764df06d4eda709fcd88677aa0c598e..670aace52a752962c4d8b3d6aabbfd76c7fcc64f 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetPickerAdapter.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetPickerAdapter.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.widgets;
 
+
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
@@ -12,15 +13,12 @@ import android.view.View;
 import android.view.ViewGroup;
 import android.widget.ImageView;
 import android.widget.TextView;
-
 import androidx.annotation.NonNull;
 import androidx.recyclerview.widget.RecyclerView;
-
+import foundation.e.blisslauncher.R;
 import java.util.ArrayList;
 import java.util.List;
 
-import foundation.e.blisslauncher.R;
-
 public class WidgetPickerAdapter extends
         RecyclerView.Adapter<WidgetPickerAdapter.WidgetsViewHolder> {
 
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetViewBuilder.java b/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetViewBuilder.java
index d1829fa4d38c9bde552afa6751fb6fb692628f7a..4fbf14b8d139254f8783ca4468d248fc46e8a839 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetViewBuilder.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetViewBuilder.java
@@ -1,22 +1,23 @@
 package foundation.e.blisslauncher.features.widgets;
 
+
 import android.appwidget.AppWidgetManager;
 import android.appwidget.AppWidgetProviderInfo;
 import android.content.Context;
 import android.os.Bundle;
 import android.widget.LinearLayout;
 import android.widget.Toast;
-
 import androidx.annotation.NonNull;
-
 import foundation.e.blisslauncher.BlissLauncher;
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.customviews.RoundedWidgetView;
 import foundation.e.blisslauncher.features.launcher.LauncherActivity;
+import foundation.e.blisslauncher.features.test.TestActivity;
 
 public class WidgetViewBuilder {
 
-    public static RoundedWidgetView create(LauncherActivity launcherActivity,
+    public static RoundedWidgetView create(
+        TestActivity launcherActivity,
             @NonNull RoundedWidgetView roundedWidgetView) {
         if (BlissLauncher.getApplication(launcherActivity).getAppWidgetHost() == null) return null;
         roundedWidgetView.post(() -> updateWidgetOption(launcherActivity, roundedWidgetView,
diff --git a/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetsActivity.java b/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetsActivity.java
index a0ea7d1c2d2ba73c2c1be3bb55e8d7c131644591..69b935614832bb779ae686f534a3867c67885a99 100644
--- a/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetsActivity.java
+++ b/app/src/main/java/foundation/e/blisslauncher/features/widgets/WidgetsActivity.java
@@ -1,5 +1,6 @@
 package foundation.e.blisslauncher.features.widgets;
 
+
 import android.app.Activity;
 import android.appwidget.AppWidgetManager;
 import android.appwidget.AppWidgetProviderInfo;
@@ -8,19 +9,16 @@ import android.content.Intent;
 import android.os.Bundle;
 import android.util.DisplayMetrics;
 import android.widget.Toast;
-
 import androidx.recyclerview.widget.DividerItemDecoration;
 import androidx.recyclerview.widget.LinearLayoutManager;
 import androidx.recyclerview.widget.RecyclerView;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
 import foundation.e.blisslauncher.BlissLauncher;
 import foundation.e.blisslauncher.R;
 import foundation.e.blisslauncher.core.customviews.RoundedWidgetView;
 import foundation.e.blisslauncher.core.customviews.WidgetHost;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
 public class WidgetsActivity extends Activity implements AddedWidgetsAdapter.OnActionClickListener {
 
diff --git a/app/src/main/res/drawable/all_apps_divider.xml b/app/src/main/res/drawable/all_apps_divider.xml
new file mode 100644
index 0000000000000000000000000000000000000000..4bd274dd4bf9ec935a8d9fd596c5b02e3d4e5ce9
--- /dev/null
+++ b/app/src/main/res/drawable/all_apps_divider.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2016 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+       android:shape="rectangle">
+    <solid android:color="?android:attr/colorControlHighlight" />
+    <size android:height="1dp" />
+</shape>
\ No newline at end of file
diff --git a/app/src/main/res/drawable/ic_info_no_shadow.xml b/app/src/main/res/drawable/ic_info_no_shadow.xml
new file mode 100644
index 0000000000000000000000000000000000000000..b5512c31326287e6ceb3b91a65b60d67a61074f9
--- /dev/null
+++ b/app/src/main/res/drawable/ic_info_no_shadow.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0"
+        android:tint="?android:attr/textColorPrimary" >
+    <path
+        android:fillColor="#FFFFFFFF"
+        android:pathData="M12,17L12,17c0.55,0,1-0.45,1-1v-4c0-0.55-0.45-1-1-1l0,0c-0.55,0-1,0.45-1,1v4C11,16.55,11.45,17,12,17z M12,2C6.48,
+        2,2,6.48,2,12s4.48,10,10,10s10-4.48,10-10S17.52,2,12,2z M12,20c-4.41,0-8-3.59-8-8s3.59-8,8-8s8,3.59,8,8S16.41,20,12,20zM12,
+        9.1L12,9.1c0.61,0,1.1-0.49,1.1-1.1l0,0c0-0.61-0.49-1.1-1.1-1.1l0,0c-0.61,0-1.1,0.49-1.1,1.1l0,0C10.9,8.61,11.39,9.1,12,9.1z"/>
+</vector>
diff --git a/app/src/main/res/layout/activity_test.xml b/app/src/main/res/layout/activity_test.xml
new file mode 100644
index 0000000000000000000000000000000000000000..e3306dbaa904ae9881768a22fa5fb2f638b2744b
--- /dev/null
+++ b/app/src/main/res/layout/activity_test.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<foundation.e.blisslauncher.features.test.LauncherRootView xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:launcher="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/launcher"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:fitsSystemWindows="true">
+
+    <foundation.e.blisslauncher.features.test.dragndrop.DragLayer
+        android:id="@+id/drag_layer"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:clipChildren="false"
+        android:clipToPadding="false"
+        android:fitsSystemWindows="true"
+        android:importantForAccessibility="no">
+
+        <foundation.e.blisslauncher.core.customviews.LauncherPagedView
+            android:id="@+id/workspace"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:layout_gravity="center"
+            app:pageIndicator="@+id/page_indicator" />
+
+        <foundation.e.blisslauncher.core.customviews.pageindicators.PageIndicatorDots
+            android:id="@+id/page_indicator"
+            android:layout_width="match_parent"
+            android:layout_height="4dp"
+            android:layout_gravity="bottom|center_horizontal" />
+
+        <foundation.e.blisslauncher.features.launcher.Hotseat
+            android:id="@+id/hotseat"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            launcher:containerType="hotseat"
+            android:layout_gravity="center" />
+
+        <include
+            android:id="@+id/overview_panel"
+            layout="@layout/overview_panel"
+            android:visibility="gone" />
+
+    </foundation.e.blisslauncher.features.test.dragndrop.DragLayer>
+
+</foundation.e.blisslauncher.features.test.LauncherRootView>
\ No newline at end of file
diff --git a/app/src/main/res/layout/app_icon.xml b/app/src/main/res/layout/app_icon.xml
new file mode 100644
index 0000000000000000000000000000000000000000..4da5455fffd2d726e69e97b66c06f2a3716765ae
--- /dev/null
+++ b/app/src/main/res/layout/app_icon.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2008 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.
+-->
+
+<foundation.e.blisslauncher.features.test.IconTextView style="@style/BaseIcon" />
diff --git a/app/src/main/res/layout/app_view.xml b/app/src/main/res/layout/app_view.xml
index 1458006f6dd52bc12cd1b8b9bfbb7a7ec9abf6af..0032328db61fa8e02d07578c682e23a9d25ac893 100755
--- a/app/src/main/res/layout/app_view.xml
+++ b/app/src/main/res/layout/app_view.xml
@@ -49,7 +49,7 @@
             android:layout_marginTop="4dp"
             android:ellipsize="end"
             android:gravity="center"
-            android:maxLines="1"
+            android:maxLines="2"
             android:textColor="@color/app_label_color"
             android:textSize="@dimen/labelSize" />
 
diff --git a/app/src/main/res/layout/layout_search_suggestion.xml b/app/src/main/res/layout/layout_search_suggestion.xml
index a9f705449c9beea3c966d04757dd2df37788798c..225f8ec3690cddf02f203bfacca6f4d37857e661 100644
--- a/app/src/main/res/layout/layout_search_suggestion.xml
+++ b/app/src/main/res/layout/layout_search_suggestion.xml
@@ -9,7 +9,8 @@
         android:layout_height="wrap_content"
         android:background="@drawable/search_widget"
         android:focusableInTouchMode="true"
-        android:padding="8dp">
+        android:paddingTop="8dp"
+        android:paddingBottom="8dp">
 
         <foundation.e.blisslauncher.core.customviews.BlissInput
             android:id="@+id/search_input"
diff --git a/app/src/main/res/layout/system_shortcut.xml b/app/src/main/res/layout/system_shortcut.xml
new file mode 100644
index 0000000000000000000000000000000000000000..3c9cf47ec27acf46b30499aaae4b457d7c4ae3c0
--- /dev/null
+++ b/app/src/main/res/layout/system_shortcut.xml
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<foundation.e.blisslauncher.features.quickstep.views.DeepShortcutView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:launcher="http://schemas.android.com/apk/res-auto"
+    android:layout_width="@dimen/bg_popup_item_width"
+    android:layout_height="@dimen/bg_popup_item_height"
+    android:theme="@style/PopupItem" >
+
+    <foundation.e.blisslauncher.features.test.IconTextView
+        style="@style/BaseIcon"
+        android:id="@+id/bubble_text"
+        android:background="?android:attr/selectableItemBackground"
+        android:gravity="start|center_vertical"
+        android:textAlignment="viewStart"
+        android:paddingStart="@dimen/deep_shortcuts_text_padding_start"
+        android:paddingEnd="@dimen/popup_padding_end"
+        android:textSize="14sp"
+        android:textColor="?android:attr/textColorPrimary"
+        android:fontFamily="sans-serif"
+        android:focusable="false" />
+
+    <View
+        android:id="@+id/icon"
+        android:layout_width="@dimen/system_shortcut_icon_size"
+        android:layout_height="@dimen/system_shortcut_icon_size"
+        android:layout_marginStart="@dimen/system_shortcut_margin_start"
+        android:layout_gravity="start|center_vertical"
+        android:backgroundTint="?android:attr/textColorTertiary"/>
+
+    <View
+        android:id="@+id/divider"
+        android:layout_width="@dimen/deep_shortcuts_divider_width"
+        android:layout_height="@dimen/popup_item_divider_height"
+        android:layout_gravity="end|bottom"
+        android:visibility="gone"
+        android:background="#E0E0E0" />
+
+</foundation.e.blisslauncher.features.quickstep.views.DeepShortcutView>
diff --git a/app/src/main/res/layout/test_page_view.xml b/app/src/main/res/layout/test_page_view.xml
new file mode 100644
index 0000000000000000000000000000000000000000..effef470bf5c1cf8aaae1508dd0506d58bfee36d
--- /dev/null
+++ b/app/src/main/res/layout/test_page_view.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent" android:layout_height="match_parent"
+    android:id="@+id/root">
+
+</GridLayout>
\ No newline at end of file
diff --git a/app/src/main/res/layout/widgets_page.xml b/app/src/main/res/layout/widgets_page.xml
index cd4b3abb93c37c543b70721e97cbb1f70c95629a..56b5b7211a9688a05f9fc6fa06a1f308a7dc5bbe 100755
--- a/app/src/main/res/layout/widgets_page.xml
+++ b/app/src/main/res/layout/widgets_page.xml
@@ -3,6 +3,7 @@
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
+    android:fitsSystemWindows="true"
     android:animateLayoutChanges="true">
 
     <foundation.e.blisslauncher.core.customviews.InsettableScrollLayout
diff --git a/app/src/main/res/layout/workspace_screen.xml b/app/src/main/res/layout/workspace_screen.xml
new file mode 100644
index 0000000000000000000000000000000000000000..b4950a575173f006427bf8a73d1e6ece7ae7abcb
--- /dev/null
+++ b/app/src/main/res/layout/workspace_screen.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<foundation.e.blisslauncher.features.test.CellLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:hapticFeedbackEnabled="false">
+
+</foundation.e.blisslauncher.features.test.CellLayout>
\ No newline at end of file
diff --git a/app/src/main/res/values-sw600dp/config.xml b/app/src/main/res/values-sw600dp/config.xml
new file mode 100644
index 0000000000000000000000000000000000000000..108e7e2faf02b2d2dbac102f9b757c108e0ee593
--- /dev/null
+++ b/app/src/main/res/values-sw600dp/config.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <bool name="is_tablet">true</bool>
+    <bool name="allow_rotation">true</bool>
+</resources>
diff --git a/app/src/main/res/values-sw720dp/config.xml b/app/src/main/res/values-sw720dp/config.xml
new file mode 100644
index 0000000000000000000000000000000000000000..e32870dede449c64f0fff26552f04499b493f8d3
--- /dev/null
+++ b/app/src/main/res/values-sw720dp/config.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <bool name="config_largeHeap">true</bool>
+    <bool name="is_large_tablet">true</bool>
+
+    <bool name="hotseat_transpose_layout_with_orientation">true</bool>
+</resources>
diff --git a/app/src/main/res/values/attrs.xml b/app/src/main/res/values/attrs.xml
index 394476d03704ebd586b8b9b62a57d4678db67a02..36b8c2530f66b0e3d23f68e1a68bfff5b8109d0f 100755
--- a/app/src/main/res/values/attrs.xml
+++ b/app/src/main/res/values/attrs.xml
@@ -26,15 +26,41 @@
         <attr name="numHotseatIcons" format="integer" />
 
         <attr name="iconSize" format="float" />
+        <!-- landscapeIconSize defaults to iconSize, if not specified -->
+        <attr name="landscapeIconSize" format="float" />
         <attr name="iconTextSize" format="float" />
         <!-- hotseatIconSize defaults to iconSize, if not specified -->
         <attr name="hotseatIconSize" format="float" />
 
         <attr name="defaultLayoutId" format="reference" />
+        <attr name="demoModeLayoutId" format="reference" />
     </declare-styleable>
 
     <declare-styleable name="InsettableFrameLayout_Layout">
         <attr name="layout_ignoreInsets" format="boolean" />
     </declare-styleable>
 
+    <!-- XML attributes used by default_workspace.xml -->
+    <declare-styleable name="Favorite">
+        <attr name="className" format="string" />
+        <attr name="packageName" format="string" />
+        <attr name="container" format="string" />
+        <attr name="screen" format="string" />
+        <attr name="x" format="string" />
+        <attr name="y" format="string" />
+        <attr name="spanX" format="string" />
+        <attr name="spanY" format="string" />
+        <attr name="icon" format="reference" />
+        <attr name="title" format="string" />
+        <attr name="uri" format="string" />
+    </declare-styleable>
+
+    <declare-styleable name="CellLayout">
+        <attr name="containerType" format="integer">
+            <enum name="workspace" value="0" />
+            <enum name="hotseat" value="1" />
+            <enum name="folder" value="2" />
+        </attr>
+    </declare-styleable>
+
 </resources>
\ No newline at end of file
diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml
index fc56cd62e36efb473d1d6e038c0b1fb5634a21d6..e97578812da245d8e088a1c510dc62b6010f25f2 100755
--- a/app/src/main/res/values/colors.xml
+++ b/app/src/main/res/values/colors.xml
@@ -21,4 +21,5 @@
     <color name="white">#FFFFFF</color>
     <color name="color_blue">#0088ED</color>
 
+    <color name="workspaceTextColor">@android:color/white</color>
 </resources>
diff --git a/app/src/main/res/values/config.xml b/app/src/main/res/values/config.xml
new file mode 100644
index 0000000000000000000000000000000000000000..3a793dc9f7180ecd4fc8d97a811992b958e17459
--- /dev/null
+++ b/app/src/main/res/values/config.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <bool name="config_largeHeap">false</bool>
+    <bool name="is_tablet">false</bool>
+    <bool name="is_large_tablet">false</bool>
+    <bool name="allow_rotation">false</bool>
+
+    <!-- Hotseat -->
+    <bool name="hotseat_transpose_layout_with_orientation">true</bool>
+    <integer name="config_workspaceSpringLoadShrinkPercentage">90</integer>
+
+    <!-- Tag id used for view scrim -->
+    <item type="id" name="view_scrim" />
+
+    <!-- Recents -->
+    <item type="id" name="overview_panel"/>
+    <integer name="config_recentsMaxThumbnailCacheSize">6</integer>
+    <integer name="config_recentsMaxIconCacheSize">12</integer>
+</resources>
diff --git a/app/src/main/res/values/dimens.xml b/app/src/main/res/values/dimens.xml
index 54be3054abe82f9fbb44d095f5a790cfcc3fc847..557ad868c6d6158b200cb94aebaa0a224a815369 100755
--- a/app/src/main/res/values/dimens.xml
+++ b/app/src/main/res/values/dimens.xml
@@ -8,9 +8,64 @@
     <dimen name="dp_40">40dp</dimen>
 
     <dimen name="dotSize">@dimen/dp_8</dimen>
+    <dimen name="dotPadding">4dp</dimen>
     <dimen name="forecast_icon_size">@dimen/dp_36</dimen>
     <dimen name="forecast_item_padding_side">@dimen/dp_16</dimen>
     <dimen name="corner_radius">@dimen/dp_12</dimen>
     <dimen name="widget_margin">@dimen/dp_8</dimen>
     <dimen name="min_widget_height">200dp</dimen>
+
+    <!-- Dynamic Grid -->
+    <dimen name="dynamic_grid_edge_margin">8dp</dimen>
+    <dimen name="dynamic_grid_page_indicator_line_height">1dp</dimen>
+    <dimen name="dynamic_grid_icon_drawable_padding">8dp</dimen>
+    <dimen name="dynamic_grid_workspace_top_padding">8dp</dimen>
+    <dimen name="dynamic_grid_workspace_page_spacing">8dp</dimen>
+    <!-- Minimum space between workspace and hotseat in spring loaded mode -->
+    <dimen name="dynamic_grid_min_spring_loaded_space">8dp</dimen>
+
+    <dimen name="dynamic_grid_cell_layout_padding">5.5dp</dimen>
+    <dimen name="dynamic_grid_cell_layout_bottom_padding">0dp</dimen>
+    <dimen name="dynamic_grid_cell_padding_x">8dp</dimen>
+    <!-- Hotseat -->
+    <dimen name="dynamic_grid_hotseat_top_padding">8dp</dimen>
+    <dimen name="dynamic_grid_hotseat_bottom_padding">2dp</dimen>
+    <dimen name="dynamic_grid_hotseat_size">80dp</dimen>
+    <dimen name="dynamic_grid_hotseat_side_padding">0dp</dimen>
+
+    <dimen name="folder_cell_x_padding">9dp</dimen>
+    <dimen name="folder_cell_y_padding">6dp</dimen>
+    <dimen name="folder_child_text_size">13sp</dimen>
+    <dimen name="folder_label_padding_top">4dp</dimen>
+    <dimen name="folder_label_padding_bottom">12dp</dimen>
+    <dimen name="folder_label_text_size">14sp</dimen>
+    <dimen name="dynamic_grid_drop_target_size">48dp</dimen>
+    <dimen name="vertical_drag_handle_size">24dp</dimen>
+    <dimen name="pre_drag_view_scale">6dp</dimen>
+    <dimen name="blur_size_medium_outline">2dp</dimen>
+    <dimen name="drag_elevation">30dp</dimen>
+    <dimen name="blur_size_thin_outline">1dp</dimen>
+
+    <!-- Width of the space behind the last task in Overview. In the center of it, there is "Clear all" button. -->
+    <dimen name="clear_all_container_width">168dp</dimen>
+
+    <dimen name="shelf_surface_radius">16dp</dimen>
+
+    <!-- popup_padding_start + icon_size + 10dp -->
+    <dimen name="deep_shortcuts_text_padding_start">56dp</dimen>
+    <!-- popup_item_width - deep_shortcuts_text_padding_start -->
+    <dimen name="deep_shortcuts_divider_width">164dp</dimen>
+    <dimen name="system_shortcut_icon_size">24dp</dimen>
+    <!-- popup_arrow_center_start - system_shortcut_icon_size / 2 -->
+    <dimen name="system_shortcut_margin_start">16dp</dimen>
+    <dimen name="system_shortcut_header_height">40dp</dimen>
+    <dimen name="system_shortcut_header_icon_touch_size">48dp</dimen>
+    <!-- (touch_size - icon_size) / 2 -->
+    <dimen name="system_shortcut_header_icon_padding">12dp</dimen>
+    <dimen name="popup_padding_end">16dp</dimen>
+    <dimen name="popup_item_divider_height">0.5dp</dimen>
+    <dimen name="deep_shortcuts_elevation">9dp</dimen>
+    <dimen name="bg_popup_item_width">220dp</dimen>
+    <dimen name="bg_popup_item_height">56dp</dimen>
+    <dimen name="default_dialog_corner_radius">8dp</dimen>
 </resources>
\ No newline at end of file
diff --git a/app/src/main/res/values/integers.xml b/app/src/main/res/values/integers.xml
new file mode 100644
index 0000000000000000000000000000000000000000..1b9261212756242e783825180c0489deb325b2b2
--- /dev/null
+++ b/app/src/main/res/values/integers.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <integer name="config_dropAnimMaxDist">800</integer>
+    <integer name="config_dropAnimMaxDuration">500</integer>
+    <integer name="config_dropAnimMinDuration">100</integer>
+</resources>
\ No newline at end of file
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 844893752df2e8791d7616d53c586591d56147d9..93f804d7fdda8a9aedead7303d60d521b9167839 100755
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -151,7 +151,7 @@
     <string name="icon_set">Icon set image</string>
 
     <!-- Permissions: -->
-    <skip/>
+    <skip />
     <!-- Permission short label -->
     <string name="permlab_install_shortcut">install shortcuts</string>
     <string name="permlab_uninstall_shortcut">uninstall shortcuts</string>
@@ -176,4 +176,13 @@
     <string name="widgets">Widgets</string>
     <string name="uninstall_shortcut_dialog">Do you want to uninstall this shortcut?</string>
     <string name="ok">ok</string>
+    <string name="safemode_shortcut_error">Downloaded app disabled in safe mode</string>
+
+    <!-- Error message when user has filled a home screen -->
+    <string name="out_of_space">No more room on this Home screen.</string>
+    <!-- Error message when user has filled the hotseat -->
+    <string name="hotseat_out_of_space">No more room in the Favorites tray</string>
+
+    <string name="app_info_drop_target_label">App Info</string>
+    <string name="activity_not_available">App isn\'t available</string>
 </resources>
diff --git a/app/src/main/res/values/styles.xml b/app/src/main/res/values/styles.xml
index d25380ce2e4632c7ed278179b0a2dad2957ab70c..c7829d5fd4bd721ec2d7e2291a77e2fe69748590 100755
--- a/app/src/main/res/values/styles.xml
+++ b/app/src/main/res/values/styles.xml
@@ -32,4 +32,31 @@
         <item name="android:typeface">normal</item>
         <item name="android:background">@color/white</item>
     </style>
+
+    <style name="BaseIcon">
+        <item name="android:layout_width">match_parent</item>
+        <item name="android:layout_height">match_parent</item>
+        <item name="android:layout_gravity">center</item>
+        <item name="android:focusable">true</item>
+        <item name="android:gravity">center_horizontal</item>
+        <item name="android:maxLines">2</item>
+        <item name="android:textColor">?android:attr/textColorSecondary</item>
+    </style>
+
+    <!-- Theme for the popup container -->
+    <style name="PopupItem">
+        <item name="android:colorControlHighlight">#E0E0E0</item>
+    </style>
+
+    <style name="OverviewTheme">
+        <item name="android:colorEdgeEffect">@color/workspaceTextColor</item>
+        <item name="android:textColorPrimary">@color/workspaceTextColor</item>
+        <item name="android:textColorSecondary">@color/workspaceTextColor</item>
+    </style>
+
+    <style name="HomeScreenElementTheme">
+        <item name="android:colorEdgeEffect">@color/workspaceTextColor</item>
+        <item name="android:textColorPrimary">@color/workspaceTextColor</item>
+        <item name="android:textColorSecondary">@color/workspaceTextColor</item>
+    </style>
 </resources>
diff --git a/app/src/main/res/xml/device_profiles.xml b/app/src/main/res/xml/device_profiles.xml
new file mode 100644
index 0000000000000000000000000000000000000000..78d03ac9eb4d0b7df2b1a60946307b89188a700c
--- /dev/null
+++ b/app/src/main/res/xml/device_profiles.xml
@@ -0,0 +1,269 @@
+<?xml version="1.0" encoding="utf-8"?>
+<profiles xmlns:launcher="http://schemas.android.com/apk/res-auto">
+
+    <profile
+        launcher:name="Pixel (Display Size set to Largest)"
+        launcher:minWidthDps="296"
+        launcher:minHeightDps="496"
+        launcher:numRows="4"
+        launcher:numColumns="4"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="3"
+        launcher:numHotseatIcons="4"
+        launcher:iconSize="56"
+        launcher:iconTextSize="13.0"
+        launcher:defaultLayoutId="@xml/dw_hotseat_4"
+        />
+
+    <profile
+        launcher:name="High DPI (4x4)"
+        launcher:minWidthDps="296"
+        launcher:minHeightDps="545"
+        launcher:numRows="4"
+        launcher:numColumns="4"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="3"
+        launcher:numHotseatIcons="4"
+        launcher:iconSize="56"
+        launcher:iconTextSize="13.0"
+        launcher:defaultLayoutId="@xml/dw_hotseat_4"
+        />
+
+    <profile
+        launcher:name="Taimen (Display size set to Largest)"
+        launcher:minWidthDps="296"
+        launcher:minHeightDps="568"
+        launcher:numRows="5"
+        launcher:numColumns="4"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="3"
+        launcher:numHotseatIcons="4"
+        launcher:iconSize="54"
+        launcher:iconTextSize="13.0"
+        launcher:defaultLayoutId="@xml/dw_hotseat_5"
+        />
+
+    <profile
+        launcher:name="High DPI (4x4)"
+        launcher:minWidthDps="322"
+        launcher:minHeightDps="557"
+        launcher:numRows="4"
+        launcher:numColumns="4"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="3"
+        launcher:numHotseatIcons="4"
+        launcher:iconSize="56"
+        launcher:iconTextSize="13.0"
+        launcher:defaultLayoutId="@xml/dw_hotseat_5"
+        />
+
+    <profile
+        launcher:name="Pixel"
+        launcher:minWidthDps="387"
+        launcher:minHeightDps="659"
+        launcher:numRows="5"
+        launcher:numColumns="4"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="3"
+        launcher:numHotseatIcons="4"
+        launcher:iconSize="56"
+        launcher:iconTextSize="13.0"
+        launcher:defaultLayoutId="@xml/dw_hotseat_5"
+        />
+
+    <profile
+        launcher:name="Taimen"
+        launcher:minWidthDps="387"
+        launcher:minHeightDps="750"
+        launcher:numRows="5"
+        launcher:numColumns="4"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="3"
+        launcher:numHotseatIcons="4"
+        launcher:iconSize="54"
+        launcher:iconTextSize="13.0"
+        launcher:defaultLayoutId="@xml/dw_hotseat_5"
+        />
+
+    <profile
+        launcher:name="Low DPI"
+        launcher:minWidthDps="525"
+        launcher:minHeightDps="750"
+        launcher:numRows="6"
+        launcher:numColumns="4"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="3"
+        launcher:numHotseatIcons="4"
+        launcher:iconSize="52"
+        launcher:iconTextSize="13.0"
+        launcher:defaultLayoutId="@xml/dw_hotseat_6"
+        />
+
+    <profile
+        launcher:name="Pixel C"
+        launcher:minWidthDps="820"
+        launcher:minHeightDps="1200"
+        launcher:numRows="5"
+        launcher:numColumns="6"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="3"
+        launcher:numHotseatIcons="6"
+        launcher:iconSize="64"
+        launcher:iconTextSize="13.0"
+        launcher:defaultLayoutId="@xml/dw_hotseat_6"
+        />
+<!--    <profile
+        launcher:name="Super Short Stubby"
+        launcher:minWidthDps="255"
+        launcher:minHeightDps="300"
+        launcher:numRows="2"
+        launcher:numColumns="3"
+        launcher:numFolderRows="2"
+        launcher:numFolderColumns="3"
+        launcher:iconSize="48"
+        launcher:iconTextSize="13.0"
+        launcher:numHotseatIcons="3"
+        launcher:defaultLayoutId="@xml/dw_hotseat_3"
+        />
+
+    <profile
+        launcher:name="Shorter Stubby"
+        launcher:minWidthDps="255"
+        launcher:minHeightDps="400"
+        launcher:numRows="3"
+        launcher:numColumns="3"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="3"
+        launcher:iconSize="48"
+        launcher:iconTextSize="13.0"
+        launcher:numHotseatIcons="3"
+        launcher:defaultLayoutId="@xml/dw_hotseat_3"
+        />
+
+    <profile
+        launcher:name="Short Stubby"
+        launcher:minWidthDps="275"
+        launcher:minHeightDps="420"
+        launcher:numRows="3"
+        launcher:numColumns="4"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="4"
+        launcher:iconSize="48"
+        launcher:iconTextSize="13.0"
+        launcher:numHotseatIcons="4"
+        launcher:defaultLayoutId="@xml/dw_hotseat_4"
+        />
+
+    <profile
+        launcher:name="Stubby"
+        launcher:minWidthDps="255"
+        launcher:minHeightDps="450"
+        launcher:numRows="3"
+        launcher:numColumns="4"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="4"
+        launcher:iconSize="48"
+        launcher:iconTextSize="13.0"
+        launcher:numHotseatIcons="4"
+        launcher:defaultLayoutId="@xml/dw_hotseat_4"
+        />
+
+    <profile
+        launcher:name="Nexus S"
+        launcher:minWidthDps="296"
+        launcher:minHeightDps="491.33"
+        launcher:numRows="4"
+        launcher:numColumns="4"
+        launcher:numFolderRows="4"
+        launcher:numFolderColumns="4"
+        launcher:iconSize="48"
+        launcher:iconTextSize="13.0"
+        launcher:numHotseatIcons="4"
+        launcher:defaultLayoutId="@xml/dw_hotseat_4"
+        />
+
+    <profile
+        launcher:name="Nexus 4"
+        launcher:minWidthDps="359"
+        launcher:minHeightDps="567"
+        launcher:numRows="4"
+        launcher:numColumns="4"
+        launcher:numFolderRows="4"
+        launcher:numFolderColumns="4"
+        launcher:iconSize="54"
+        launcher:iconTextSize="13.0"
+        launcher:numHotseatIcons="4"
+        launcher:defaultLayoutId="@xml/dw_hotseat_4"
+        />
+
+    <profile
+        launcher:name="Nexus 5"
+        launcher:minWidthDps="335"
+        launcher:minHeightDps="567"
+        launcher:numRows="4"
+        launcher:numColumns="4"
+        launcher:numFolderRows="4"
+        launcher:numFolderColumns="4"
+        launcher:iconSize="54"
+        launcher:iconTextSize="13.0"
+        launcher:numHotseatIcons="4"
+        launcher:defaultLayoutId="@xml/dw_hotseat_4"
+        />
+
+    <profile
+        launcher:name="Large Phone"
+        launcher:minWidthDps="406"
+        launcher:minHeightDps="694"
+        launcher:numRows="5"
+        launcher:numColumns="5"
+        launcher:numFolderRows="4"
+        launcher:numFolderColumns="4"
+        launcher:iconSize="56"
+        launcher:iconTextSize="14.4"
+        launcher:numHotseatIcons="5"
+        launcher:defaultLayoutId="@xml/dw_hotseat_5"
+        />
+
+    <profile
+        launcher:name="Nexus 7"
+        launcher:minWidthDps="575"
+        launcher:minHeightDps="904"
+        launcher:numRows="5"
+        launcher:numColumns="6"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="3"
+        launcher:iconSize="64"
+        launcher:iconTextSize="14.4"
+        launcher:numHotseatIcons="6"
+        launcher:defaultLayoutId="@xml/dw_hotseat_6"
+        />
+
+    <profile
+        launcher:name="Nexus 10"
+        launcher:minWidthDps="727"
+        launcher:minHeightDps="1207"
+        launcher:numRows="5"
+        launcher:numColumns="6"
+        launcher:numFolderRows="3"
+        launcher:numFolderColumns="3"
+        launcher:iconSize="76"
+        launcher:iconTextSize="14.4"
+        launcher:numHotseatIcons="6"
+        launcher:defaultLayoutId="@xml/dw_hotseat_6"
+        />
+
+    <profile
+        launcher:name="20-inch Tablet"
+        launcher:minWidthDps="1527"
+        launcher:minHeightDps="2527"
+        launcher:numRows="7"
+        launcher:numColumns="7"
+        launcher:numFolderRows="6"
+        launcher:numFolderColumns="6"
+        launcher:iconSize="100"
+        launcher:iconTextSize="20.0"
+        launcher:numHotseatIcons="7"
+        launcher:defaultLayoutId="@xml/dw_hotseat_6"
+        />-->
+
+</profiles>
diff --git a/app/src/main/res/xml/dw_hotseat_3.xml b/app/src/main/res/xml/dw_hotseat_3.xml
new file mode 100644
index 0000000000000000000000000000000000000000..3306993fa1d6557e96b1f71b83293ba98afecabd
--- /dev/null
+++ b/app/src/main/res/xml/dw_hotseat_3.xml
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 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.
+-->
+
+<hotseat xmlns:launcher="http://schemas.android.com/apk/res-auto">
+    <!-- Hotseat (We use the screen as the position of the item in the hotseat of 3 column layout) -->
+    <!-- Dialer, Messaging, Browser -->
+    <resolve
+        launcher:container="-101"
+        launcher:screen="0"
+        launcher:x="0"
+        launcher:y="0" >
+        <favorite launcher:uri="#Intent;action=android.intent.action.DIAL;end" />
+        <favorite launcher:uri="tel:123" />
+        <favorite launcher:uri="#Intent;action=android.intent.action.CALL_BUTTON;end" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="1"
+        launcher:x="1"
+        launcher:y="0" >
+        <favorite launcher:uri="#Intent;action=android.intent.action.MAIN;category=android.intent.category.APP_MESSAGING;end" />
+        <favorite launcher:uri="sms:" />
+        <favorite launcher:uri="smsto:" />
+        <favorite launcher:uri="mms:" />
+        <favorite launcher:uri="mmsto:" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="2"
+        launcher:x="2"
+        launcher:y="0" >
+        <favorite
+            launcher:uri="#Intent;action=android.intent.action.MAIN;category=android.intent.category.APP_BROWSER;end" />
+        <favorite launcher:uri="http://www.example.com/" />
+    </resolve>
+
+
+</hotseat>
diff --git a/app/src/main/res/xml/dw_hotseat_4.xml b/app/src/main/res/xml/dw_hotseat_4.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2f5940d9e56918ad2fb500f2ea89d505b0cc8631
--- /dev/null
+++ b/app/src/main/res/xml/dw_hotseat_4.xml
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 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.
+-->
+
+<hotseat xmlns:launcher="http://schemas.android.com/apk/res-auto">
+    <!-- Hotseat (We use the screen as the position of the item in the hotseat of the 4 column layout) -->
+    <!-- Dialer, Messaging, Browser, Camera -->
+    <resolve
+        launcher:container="-101"
+        launcher:screen="0"
+        launcher:x="0"
+        launcher:y="0">
+        <favorite launcher:uri="#Intent;action=android.intent.action.DIAL;end" />
+        <favorite launcher:uri="tel:123" />
+        <favorite launcher:uri="#Intent;action=android.intent.action.CALL_BUTTON;end" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="1"
+        launcher:x="1"
+        launcher:y="0">
+        <favorite launcher:uri="#Intent;action=android.intent.action.MAIN;category=android.intent.category.APP_MESSAGING;end" />
+        <favorite launcher:uri="sms:" />
+        <favorite launcher:uri="smsto:" />
+        <favorite launcher:uri="mms:" />
+        <favorite launcher:uri="mmsto:" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="2"
+        launcher:x="2"
+        launcher:y="0">
+        <favorite launcher:uri="#Intent;action=android.intent.action.MAIN;category=android.intent.category.APP_BROWSER;end" />
+        <favorite launcher:uri="http://www.example.com/" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="3"
+        launcher:x="3"
+        launcher:y="0">
+        <favorite launcher:uri="#Intent;action=android.media.action.STILL_IMAGE_CAMERA;end" />
+        <favorite launcher:uri="#Intent;action=android.intent.action.CAMERA_BUTTON;end" />
+    </resolve>
+
+</hotseat>
diff --git a/app/src/main/res/xml/dw_hotseat_5.xml b/app/src/main/res/xml/dw_hotseat_5.xml
new file mode 100644
index 0000000000000000000000000000000000000000..74f73869481de586610bca79cb6953cd4b94d4ff
--- /dev/null
+++ b/app/src/main/res/xml/dw_hotseat_5.xml
@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 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.
+-->
+
+<hotseat xmlns:launcher="http://schemas.android.com/apk/res-auto">
+    <!-- Hotseat (We use the screen as the position of the item in the hotseat of the 5 column layout) -->
+    <!-- Dialer, Messaging, Browser, Camera -->
+    <resolve
+        launcher:container="-101"
+        launcher:screen="0"
+        launcher:x="0"
+        launcher:y="0" >
+        <favorite launcher:uri="#Intent;action=android.intent.action.DIAL;end" />
+        <favorite launcher:uri="tel:123" />
+        <favorite launcher:uri="#Intent;action=android.intent.action.CALL_BUTTON;end" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="1"
+        launcher:x="1"
+        launcher:y="0" >
+        <favorite launcher:uri="#Intent;action=android.intent.action.MAIN;category=android.intent.category.APP_MESSAGING;end" />
+        <favorite launcher:uri="sms:" />
+        <favorite launcher:uri="smsto:" />
+        <favorite launcher:uri="mms:" />
+        <favorite launcher:uri="mmsto:" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="2"
+        launcher:x="2"
+        launcher:y="0">
+        <favorite launcher:uri="#Intent;action=android.intent.action.MAIN;category=android.intent.category.APP_EMAIL;end" />
+        <favorite launcher:uri="mailto:" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="3"
+        launcher:x="3"
+        launcher:y="0" >
+        <favorite
+            launcher:uri="#Intent;action=android.intent.action.MAIN;category=android.intent.category.APP_BROWSER;end" />
+        <favorite launcher:uri="http://www.example.com/" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="4"
+        launcher:x="4"
+        launcher:y="0" >
+        <favorite launcher:uri="#Intent;action=android.media.action.STILL_IMAGE_CAMERA;end" />
+        <favorite launcher:uri="#Intent;action=android.intent.action.CAMERA_BUTTON;end" />
+    </resolve>
+
+</hotseat>
diff --git a/app/src/main/res/xml/dw_hotseat_6.xml b/app/src/main/res/xml/dw_hotseat_6.xml
new file mode 100644
index 0000000000000000000000000000000000000000..a08ffb3807b11afad24db160f61d04ae0a9eaa7f
--- /dev/null
+++ b/app/src/main/res/xml/dw_hotseat_6.xml
@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 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.
+-->
+
+<hotseat xmlns:launcher="http://schemas.android.com/apk/res-auto">
+    <!-- Hotseat (We use the screen as the position of the item in the hotseat of the 6 column layout) -->
+    <!-- (This is used as default only for tablets)-->
+    <!-- Messaging, Email, Browser, Music, Gallery, Camera -->
+    <resolve
+        launcher:container="-101"
+        launcher:screen="0"
+        launcher:x="0"
+        launcher:y="0">
+        <favorite launcher:uri="#Intent;action=android.intent.action.MAIN;category=android.intent.category.APP_MESSAGING;end" />
+        <favorite launcher:uri="sms:" />
+        <favorite launcher:uri="smsto:" />
+        <favorite launcher:uri="mms:" />
+        <favorite launcher:uri="mmsto:" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="1"
+        launcher:x="1"
+        launcher:y="0">
+        <favorite launcher:uri="#Intent;action=android.intent.action.MAIN;category=android.intent.category.APP_EMAIL;end" />
+        <favorite launcher:uri="mailto:" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="2"
+        launcher:x="2"
+        launcher:y="0">
+        <favorite launcher:uri="#Intent;action=android.intent.action.MAIN;category=android.intent.category.APP_BROWSER;end" />
+        <favorite launcher:uri="http://www.example.com/" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="3"
+        launcher:x="3"
+        launcher:y="0">
+        <favorite launcher:uri="#Intent;action=android.intent.action.MAIN;category=android.intent.category.APP_MUSIC;end" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="4"
+        launcher:x="4"
+        launcher:y="0">
+        <favorite launcher:uri="#Intent;action=android.intent.action.MAIN;category=android.intent.category.APP_GALLERY;end" />
+        <favorite launcher:uri="#Intent;type=images/*;end" />
+    </resolve>
+
+    <resolve
+        launcher:container="-101"
+        launcher:screen="5"
+        launcher:x="5"
+        launcher:y="0">
+        <favorite launcher:uri="#Intent;action=android.media.action.STILL_IMAGE_CAMERA;end" />
+        <favorite launcher:uri="#Intent;action=android.intent.action.CAMERA_BUTTON;end" />
+    </resolve>
+
+</hotseat>
diff --git a/app/src/quickstep/recents_ui_overrides/res/drawable/arrow_toast_rounded_background.xml b/app/src/quickstep/recents_ui_overrides/res/drawable/arrow_toast_rounded_background.xml
new file mode 100644
index 0000000000000000000000000000000000000000..52cc6fcb6270f122f31af260a03f2a2e3161f32a
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/res/drawable/arrow_toast_rounded_background.xml
@@ -0,0 +1,19 @@
+<!--
+    Copyright (C) 2018 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
+    <solid android:color="?android:attr/colorAccent" />
+    <corners android:radius="8dp" />
+</shape>
diff --git a/app/src/quickstep/recents_ui_overrides/res/drawable/chip_hint_background_light.xml b/app/src/quickstep/recents_ui_overrides/res/drawable/chip_hint_background_light.xml
new file mode 100644
index 0000000000000000000000000000000000000000..7b4da839819f25116ed0dd8010c8e93711a64247
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/res/drawable/chip_hint_background_light.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2019 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
+    <stroke
+        android:color="@color/chip_hint_foreground_color"
+        android:width="@dimen/chip_hint_border_width"/>
+    <corners android:radius="@dimen/chip_hint_corner_radius"/>
+    <padding
+        android:left="@dimen/chip_hint_outer_padding"
+        android:top="@dimen/chip_hint_outer_padding"
+        android:right="@dimen/chip_hint_outer_padding"
+        android:bottom="@dimen/chip_hint_outer_padding"/>
+</shape>
\ No newline at end of file
diff --git a/app/src/quickstep/recents_ui_overrides/res/drawable/ic_remove_no_shadow.xml b/app/src/quickstep/recents_ui_overrides/res/drawable/ic_remove_no_shadow.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2c706dbb3017ddc7d6146bee82709bca6e7fef34
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/res/drawable/ic_remove_no_shadow.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportHeight="24.0"
+    android:viewportWidth="24.0"
+    android:tint="?android:attr/textColorPrimary">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M19,6.41L17.59,5L12,10.59L6.41,5L5,6.41L10.59,12L5,17.59L6.41,19L12,13.41L17.59,19L19,17.59L13.41,12L19,6.41z" />
+</vector>
diff --git a/app/src/quickstep/recents_ui_overrides/res/layout/arrow_toast.xml b/app/src/quickstep/recents_ui_overrides/res/layout/arrow_toast.xml
new file mode 100644
index 0000000000000000000000000000000000000000..db46cedfaed41f6c0888d9993ed70b6140eedf79
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/res/layout/arrow_toast.xml
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<merge xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_height="wrap_content"
+    android:layout_width="wrap_content">
+
+    <LinearLayout
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:paddingStart="24dp"
+        android:paddingEnd="4dp"
+        android:background="@drawable/arrow_toast_rounded_background"
+        android:layout_gravity="center_horizontal"
+        android:elevation="2dp"
+        android:orientation="horizontal">
+
+        <TextView
+            android:id="@+id/text"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:layout_gravity="center_vertical"
+            android:textColor="@android:color/white"
+            android:textSize="16sp"/>
+        <ImageView
+            android:id="@+id/dismiss"
+            android:layout_width="40dp"
+            android:layout_height="40dp"
+            android:layout_gravity="center_vertical"
+            android:padding="10dp"
+            android:layout_marginStart="2dp"
+            android:layout_marginEnd="2dp"
+            android:alpha="0.7"
+            android:src="@drawable/ic_remove_no_shadow"
+            app:tint="@android:color/white"
+            android:background="?android:attr/selectableItemBackgroundBorderless"
+            android:contentDescription="@string/accessibility_close_task"/>
+    </LinearLayout>
+
+    <View
+        android:id="@+id/arrow"
+        android:elevation="2dp"
+        android:layout_width="10dp"
+        android:layout_height="8dp"
+        android:layout_marginTop="-2dp"
+        android:layout_gravity="center_horizontal"/>
+</merge>
diff --git a/app/src/quickstep/recents_ui_overrides/res/layout/fallback_recents_activity.xml b/app/src/quickstep/recents_ui_overrides/res/layout/fallback_recents_activity.xml
new file mode 100644
index 0000000000000000000000000000000000000000..bd8ae59158f94125f6c208e82ffc64599554917f
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/res/layout/fallback_recents_activity.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+     Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<foundation.e.blisslauncher.quickstep.fallback.RecentsRootView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/drag_layer"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:fitsSystemWindows="true">
+
+    <foundation.e.blisslauncher.quickstep.fallback.FallbackRecentsView
+        android:id="@id/overview_panel"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:clipChildren="false"
+        android:clipToPadding="false"
+        android:outlineProvider="none"
+        android:theme="@style/HomeScreenElementTheme" />
+</foundation.e.blisslauncher.quickstep.fallback.RecentsRootView>
diff --git a/app/src/quickstep/recents_ui_overrides/res/layout/overview_panel.xml b/app/src/quickstep/recents_ui_overrides/res/layout/overview_panel.xml
new file mode 100644
index 0000000000000000000000000000000000000000..adb512dcde6da4d66d8460cc726b1df0794ec7f4
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/res/layout/overview_panel.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2017 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<foundation.e.blisslauncher.quickstep.views.LauncherRecentsView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:theme="@style/HomeScreenElementTheme"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:clipChildren="false"
+    android:clipToPadding="false"
+    android:accessibilityPaneTitle="@string/accessibility_recent_apps"
+    android:visibility="invisible" />
\ No newline at end of file
diff --git a/app/src/quickstep/recents_ui_overrides/res/values/colors.xml b/app/src/quickstep/recents_ui_overrides/res/values/colors.xml
new file mode 100644
index 0000000000000000000000000000000000000000..7426e3039688b53926ecdf417d8445289852803a
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/res/values/colors.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="chip_hint_foreground_color">#fff</color>
+
+    <color name="all_apps_label_text">#61000000</color>
+    <color name="all_apps_label_text_dark">#61FFFFFF</color>
+    <color name="all_apps_prediction_row_separator">#3c000000</color>
+    <color name="all_apps_prediction_row_separator_dark">#3cffffff</color>
+</resources>
\ No newline at end of file
diff --git a/app/src/quickstep/recents_ui_overrides/res/values/dimens.xml b/app/src/quickstep/recents_ui_overrides/res/values/dimens.xml
new file mode 100644
index 0000000000000000000000000000000000000000..863a8ba528ffb8ef780420f899b761198ff34259
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/res/values/dimens.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <dimen name="chip_hint_border_width">1dp</dimen>
+    <dimen name="chip_hint_corner_radius">20dp</dimen>
+    <dimen name="chip_hint_outer_padding">20dp</dimen>
+    <dimen name="chip_hint_start_padding">10dp</dimen>
+    <dimen name="chip_hint_end_padding">12dp</dimen>
+    <dimen name="chip_hint_horizontal_margin">20dp</dimen>
+    <dimen name="chip_hint_elevation">2dp</dimen>
+    <dimen name="chip_icon_size">16dp</dimen>
+    <dimen name="chip_text_height">26dp</dimen>
+    <dimen name="chip_text_top_padding">4dp</dimen>
+    <dimen name="chip_text_start_padding">10dp</dimen>
+    <dimen name="chip_text_size">14sp</dimen>
+
+    <dimen name="all_apps_prediction_row_divider_height">17dp</dimen>
+    <dimen name="all_apps_label_top_padding">16dp</dimen>
+    <dimen name="all_apps_label_bottom_padding">8dp</dimen>
+    <dimen name="all_apps_label_text_size">14sp</dimen>
+    <dimen name="all_apps_tip_bottom_margin">8dp</dimen>
+    <!-- The size of corner radius of the arrow in the arrow toast. -->
+    <dimen name="arrow_toast_corner_radius">2dp</dimen>
+
+    <!-- Minimum distance to swipe to trigger accessibility gesture -->
+    <dimen name="accessibility_gesture_min_swipe_distance">80dp</dimen>
+
+    <!-- Swipe up to home related -->
+    <dimen name="swipe_up_fling_min_visible_change">18dp</dimen>
+    <dimen name="swipe_up_y_overshoot">10dp</dimen>
+    <dimen name="swipe_up_max_workspace_trans_y">-60dp</dimen>
+</resources>
\ No newline at end of file
diff --git a/app/src/quickstep/recents_ui_overrides/res/values/override.xml b/app/src/quickstep/recents_ui_overrides/res/values/override.xml
new file mode 100644
index 0000000000000000000000000000000000000000..28d0dc00505f0745a903cb5811a9329ac11659c5
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/res/values/override.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<!-- Class overrides for launcher with quickstep. -->
+
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="app_transition_manager_class" translatable="false">foundation.e.blisslauncher.LauncherAppTransitionManagerImpl</string>
+
+  <string name="main_process_initializer_class" translatable="false">foundation.e.blisslauncher.quickstep.QuickstepProcessInitializer</string>
+</resources>
+
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/LauncherAppTransitionManagerImpl.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/LauncherAppTransitionManagerImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..502777524b2e472f1be389e0ca33735c0b6e8087
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/LauncherAppTransitionManagerImpl.java
@@ -0,0 +1,156 @@
+/*
+ * 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 foundation.e.blisslauncher;
+
+import static androidx.dynamicanimation.animation.DynamicAnimation.MIN_VISIBLE_CHANGE_PIXELS;
+import static foundation.e.blisslauncher.features.test.LauncherState.NORMAL;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.AGGRESSIVE_EASE;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+import static foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils.VIEW_TRANSLATE_X;
+import static foundation.e.blisslauncher.quickstep.TaskViewUtils.findTaskViewToLaunch;
+import static foundation.e.blisslauncher.quickstep.TaskViewUtils.getRecentsWindowAnimator;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.content.Context;
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+import foundation.e.blisslauncher.features.test.anim.Interpolators;
+import foundation.e.blisslauncher.features.test.anim.SpringObjectAnimator;
+import foundation.e.blisslauncher.quickstep.util.ClipAnimationHelper;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+
+/**
+ * A {@link QuickstepAppTransitionManagerImpl} that also implements recents transitions from
+ * {@link RecentsView}.
+ */
+public final class LauncherAppTransitionManagerImpl extends QuickstepAppTransitionManagerImpl {
+
+    public static final int INDEX_SHELF_ANIM = 0;
+    public static final int INDEX_RECENTS_FADE_ANIM = 1;
+    public static final int INDEX_RECENTS_TRANSLATE_X_ANIM = 2;
+
+    public LauncherAppTransitionManagerImpl(Context context) {
+        super(context);
+    }
+
+    @Override
+    protected boolean isLaunchingFromRecents(@NonNull View v,
+            @Nullable RemoteAnimationTargetCompat[] targets) {
+        return mLauncher.getStateManager().getState().overviewUi
+                && findTaskViewToLaunch(mLauncher, v, targets) != null;
+    }
+
+    @Override
+    protected void composeRecentsLaunchAnimator(@NonNull AnimatorSet anim, @NonNull View v,
+            @NonNull RemoteAnimationTargetCompat[] targets, boolean launcherClosing) {
+        RecentsView recentsView = mLauncher.getOverviewPanel();
+        boolean skipLauncherChanges = !launcherClosing;
+
+        TaskView taskView = findTaskViewToLaunch(mLauncher, v, targets);
+
+        ClipAnimationHelper helper = new ClipAnimationHelper(mLauncher);
+        anim.play(getRecentsWindowAnimator(taskView, skipLauncherChanges, targets, helper)
+                .setDuration(RECENTS_LAUNCH_DURATION));
+
+        Animator childStateAnimation = null;
+        // Found a visible recents task that matches the opening app, lets launch the app from there
+        Animator launcherAnim;
+        final AnimatorListenerAdapter windowAnimEndListener;
+        if (launcherClosing) {
+            launcherAnim = recentsView.createAdjacentPageAnimForTaskLaunch(taskView, helper);
+            launcherAnim.setInterpolator(Interpolators.TOUCH_RESPONSE_INTERPOLATOR);
+            launcherAnim.setDuration(RECENTS_LAUNCH_DURATION);
+
+            // Make sure recents gets fixed up by resetting task alphas and scales, etc.
+            windowAnimEndListener = new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    mLauncher.getStateManager().moveToRestState();
+                    mLauncher.getStateManager().reapplyState();
+                }
+            };
+        } else {
+            AnimatorPlaybackController controller =
+                    mLauncher.getStateManager().createAnimationToNewWorkspace(NORMAL,
+                            RECENTS_LAUNCH_DURATION);
+            controller.dispatchOnStart();
+            childStateAnimation = controller.getTarget();
+            launcherAnim = controller.getAnimationPlayer().setDuration(RECENTS_LAUNCH_DURATION);
+            windowAnimEndListener = new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    mLauncher.getStateManager().goToState(NORMAL, false);
+                }
+            };
+        }
+        anim.play(launcherAnim);
+
+        // 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).
+        mLauncher.getStateManager().setCurrentAnimation(anim, childStateAnimation);
+        anim.addListener(windowAnimEndListener);
+    }
+
+    @Override
+    protected Runnable composeViewContentAnimator(@NonNull AnimatorSet anim, float[] alphas,
+            float[] trans) {
+        RecentsView overview = mLauncher.getOverviewPanel();
+        ObjectAnimator alpha = ObjectAnimator.ofFloat(overview,
+                RecentsView.CONTENT_ALPHA, alphas);
+        alpha.setDuration(CONTENT_ALPHA_DURATION);
+        alpha.setInterpolator(LINEAR);
+        anim.play(alpha);
+        overview.setFreezeViewVisibility(true);
+
+        ObjectAnimator transY = ObjectAnimator.ofFloat(overview, View.TRANSLATION_Y, trans);
+        transY.setInterpolator(AGGRESSIVE_EASE);
+        transY.setDuration(CONTENT_TRANSLATION_DURATION);
+        anim.play(transY);
+
+        return () -> {
+            overview.setFreezeViewVisibility(false);
+            mLauncher.getStateManager().reapplyState();
+        };
+    }
+
+    @Override
+    public int getStateElementAnimationsCount() {
+        return 3;
+    }
+
+    @Override
+    public Animator createStateElementAnimation(int index, float... values) {
+        switch (index) {
+            case INDEX_RECENTS_FADE_ANIM:
+                return ObjectAnimator.ofFloat(mLauncher.getOverviewPanel(),
+                        RecentsView.CONTENT_ALPHA, values);
+            case INDEX_RECENTS_TRANSLATE_X_ANIM:
+                return new SpringObjectAnimator<>(mLauncher.getOverviewPanel(),
+                        VIEW_TRANSLATE_X, MIN_VISIBLE_CHANGE_PIXELS, 0.8f, 250, values);
+            default:
+                return super.createStateElementAnimation(index, values);
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/LauncherInitListenerEx.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/LauncherInitListenerEx.java
new file mode 100644
index 0000000000000000000000000000000000000000..1746b600bfdbbf476aaad0b5204e92ba0e80dc14
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/LauncherInitListenerEx.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher;
+
+import foundation.e.blisslauncher.features.test.TestActivity;
+
+import java.util.function.BiPredicate;
+
+public class LauncherInitListenerEx extends LauncherInitListener {
+
+    public LauncherInitListenerEx(BiPredicate<TestActivity, Boolean> onInitListener) {
+        super(onInitListener);
+    }
+
+    @Override
+    protected boolean init(TestActivity launcher, boolean alreadyOnHome) {
+        return super.init(launcher, alreadyOnHome);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/AppToOverviewAnimationProvider.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/AppToOverviewAnimationProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..5d44e23b9058ab00ecb12090944d2a8d7b5fa9b7
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/AppToOverviewAnimationProvider.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep;
+
+import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_CLOSING;
+import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_OPENING;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.FAST_OUT_SLOW_IN;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.TOUCH_RESPONSE_INTERPOLATOR;
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.animation.ValueAnimator;
+import android.graphics.Rect;
+import android.util.Log;
+import android.view.View;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat;
+import com.android.systemui.shared.system.TransactionCompat;
+import foundation.e.blisslauncher.core.customviews.AbstractFloatingView;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.features.test.anim.AnimationSuccessListener;
+import foundation.e.blisslauncher.quickstep.util.ClipAnimationHelper;
+import foundation.e.blisslauncher.quickstep.util.RemoteAnimationProvider;
+import foundation.e.blisslauncher.quickstep.util.RemoteAnimationTargetSet;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+
+/**
+ * Provider for the atomic remote window animation from the app to the overview.
+ *
+ * @param <T> activity that contains the overview
+ */
+final class AppToOverviewAnimationProvider<T extends BaseDraggingActivity> implements
+        RemoteAnimationProvider {
+
+    private static final long RECENTS_LAUNCH_DURATION = 250;
+    private static final String TAG = "AppToOverviewAnimationProvider";
+
+    private final ActivityControlHelper<T> mHelper;
+    // The id of the currently running task that is transitioning to overview.
+    private final int mTargetTaskId;
+
+    private T mActivity;
+    private RecentsView mRecentsView;
+
+    AppToOverviewAnimationProvider(ActivityControlHelper<T> helper, int targetTaskId) {
+        mHelper = helper;
+        mTargetTaskId = targetTaskId;
+    }
+
+    /**
+     * Callback for when the activity is ready/initialized.
+     *
+     * @param activity the activity that is ready
+     * @param wasVisible true if it was visible before
+     */
+    boolean onActivityReady(T activity, Boolean wasVisible) {
+        activity.<RecentsView>getOverviewPanel().showCurrentTask(mTargetTaskId);
+        AbstractFloatingView.closeAllOpenViews(activity, wasVisible);
+        ActivityControlHelper.AnimationFactory factory =
+                mHelper.prepareRecentsUI(activity, wasVisible,
+                false /* animate activity */, (controller) -> {
+                    controller.dispatchOnStart();
+                    ValueAnimator anim = controller.getAnimationPlayer()
+                            .setDuration(RECENTS_LAUNCH_DURATION);
+                    anim.setInterpolator(FAST_OUT_SLOW_IN);
+                    anim.start();
+                });
+        factory.onRemoteAnimationReceived(null);
+        factory.createActivityController(RECENTS_LAUNCH_DURATION);
+        mActivity = activity;
+        mRecentsView = mActivity.getOverviewPanel();
+        return false;
+    }
+
+    /**
+     * Create remote window animation from the currently running app to the overview panel.
+     *
+     * @param targetCompats the target apps
+     * @return animation from app to overview
+     */
+    @Override
+    public AnimatorSet createWindowAnimation(RemoteAnimationTargetCompat[] targetCompats) {
+        if (mRecentsView != null) {
+            mRecentsView.setRunningTaskIconScaledDown(true);
+        }
+        AnimatorSet anim = new AnimatorSet();
+        anim.addListener(new AnimationSuccessListener() {
+            @Override
+            public void onAnimationSuccess(Animator animator) {
+                if (mRecentsView != null) {
+                    mRecentsView.animateUpRunningTaskIconScale();
+                }
+            }
+        });
+        if (mActivity == null) {
+            Log.e(TAG, "Animation created, before activity");
+            anim.play(ValueAnimator.ofInt(0, 1).setDuration(RECENTS_LAUNCH_DURATION));
+            return anim;
+        }
+
+        RemoteAnimationTargetSet targetSet =
+                new RemoteAnimationTargetSet(targetCompats, MODE_CLOSING);
+
+        // Use the top closing app to determine the insets for the animation
+        RemoteAnimationTargetCompat runningTaskTarget = targetSet.findTask(mTargetTaskId);
+        if (runningTaskTarget == null) {
+            Log.e(TAG, "No closing app");
+            anim.play(ValueAnimator.ofInt(0, 1).setDuration(RECENTS_LAUNCH_DURATION));
+            return anim;
+        }
+
+        final ClipAnimationHelper clipHelper = new ClipAnimationHelper(mActivity);
+
+        // At this point, the activity is already started and laid-out. Get the home-bounds
+        // relative to the screen using the rootView of the activity.
+        int loc[] = new int[2];
+        View rootView = mActivity.getRootView();
+        rootView.getLocationOnScreen(loc);
+        Rect homeBounds = new Rect(loc[0], loc[1],
+                loc[0] + rootView.getWidth(), loc[1] + rootView.getHeight());
+        clipHelper.updateSource(homeBounds, runningTaskTarget);
+
+        Rect targetRect = new Rect();
+        mHelper.getSwipeUpDestinationAndLength(mActivity.getDeviceProfile(), mActivity, targetRect);
+        clipHelper.updateTargetRect(targetRect);
+        clipHelper.prepareAnimation(mActivity.getDeviceProfile(), false /* isOpening */);
+
+        ClipAnimationHelper.TransformParams params = new ClipAnimationHelper.TransformParams()
+                .setSyncTransactionApplier(new SyncRtSurfaceTransactionApplierCompat(rootView));
+        ValueAnimator valueAnimator = ValueAnimator.ofFloat(0, 1);
+        valueAnimator.setDuration(RECENTS_LAUNCH_DURATION);
+        valueAnimator.setInterpolator(TOUCH_RESPONSE_INTERPOLATOR);
+        valueAnimator.addUpdateListener((v) -> {
+            params.setProgress((float) v.getAnimatedValue());
+            clipHelper.applyTransform(targetSet, params);
+        });
+
+        if (targetSet.isAnimatingHome()) {
+            // If we are animating home, fade in the opening targets
+            RemoteAnimationTargetSet openingSet =
+                    new RemoteAnimationTargetSet(targetCompats, MODE_OPENING);
+
+            TransactionCompat transaction = new TransactionCompat();
+            valueAnimator.addUpdateListener((v) -> {
+                for (RemoteAnimationTargetCompat app : openingSet.apps) {
+                    transaction.setAlpha(app.leash, (float) v.getAnimatedValue());
+                }
+                transaction.apply();
+            });
+        }
+        anim.play(valueAnimator);
+        return anim;
+    }
+
+    /**
+     * Get duration of animation from app to overview.
+     *
+     * @return duration of animation
+     */
+    long getRecentsLaunchDuration() {
+        return RECENTS_LAUNCH_DURATION;
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/FallbackActivityControllerHelper.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/FallbackActivityControllerHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..6498276d392c983e29d57e92982ede107059b95f
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/FallbackActivityControllerHelper.java
@@ -0,0 +1,215 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep;
+
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.content.Context;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.features.test.anim.AnimationSuccessListener;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+import foundation.e.blisslauncher.quickstep.fallback.FallbackRecentsView;
+import foundation.e.blisslauncher.quickstep.util.LayoutUtils;
+import foundation.e.blisslauncher.quickstep.util.RemoteAnimationTargetSet;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import java.util.function.BiPredicate;
+import java.util.function.Consumer;
+
+/**
+ * {@link ActivityControlHelper} for recents when the default launcher is different than the
+ * currently running one and apps should interact with the {@link RecentsActivity} as opposed
+ * to the in-launcher one.
+ */
+public final class FallbackActivityControllerHelper implements
+        ActivityControlHelper<RecentsActivity> {
+
+    public FallbackActivityControllerHelper() { }
+
+    @Override
+    public void onTransitionCancelled(RecentsActivity activity, boolean activityVisible) {
+        // TODO:
+    }
+
+    @Override
+    public int getSwipeUpDestinationAndLength(VariantDeviceProfile dp, Context context, Rect outRect) {
+        LayoutUtils.calculateFallbackTaskSize(context, dp, outRect);
+        return dp.getHeightPx() - outRect.bottom;
+    }
+
+    @Override
+    public void onSwipeUpToRecentsComplete(RecentsActivity activity) {
+        RecentsView recentsView = activity.getOverviewPanel();
+        recentsView.getClearAllButton().setVisibilityAlpha(1);
+        recentsView.setDisallowScrollToClearAll(false);
+    }
+
+    @Override
+    public void onAssistantVisibilityChanged(float visibility) {
+        // TODO:
+    }
+
+    @NonNull
+    @Override
+    public HomeAnimationFactory prepareHomeUI(RecentsActivity activity) {
+        RecentsView recentsView = activity.getOverviewPanel();
+
+        return new HomeAnimationFactory() {
+            @NonNull
+            @Override
+            public RectF getWindowTargetRect() {
+                float centerX = recentsView.getPivotX();
+                float centerY = recentsView.getPivotY();
+                return new RectF(centerX, centerY, centerX, centerY);
+            }
+
+            @NonNull
+            @Override
+            public AnimatorPlaybackController createActivityAnimationToHome() {
+                Animator anim = ObjectAnimator.ofFloat(recentsView, RecentsView.CONTENT_ALPHA, 0);
+                anim.addListener(new AnimationSuccessListener() {
+                    @Override
+                    public void onAnimationSuccess(Animator animator) {
+                        recentsView.startHome();
+                    }
+                });
+                AnimatorSet animatorSet = new AnimatorSet();
+                animatorSet.play(anim);
+                long accuracy = 2 * Math.max(recentsView.getWidth(), recentsView.getHeight());
+                return AnimatorPlaybackController.wrap(animatorSet, accuracy);
+            }
+        };
+    }
+
+    @Override
+    public AnimationFactory prepareRecentsUI(RecentsActivity activity, boolean activityVisible,
+            boolean animateActivity, Consumer<AnimatorPlaybackController> callback) {
+        if (activityVisible) {
+            return (transitionLength) -> { };
+        }
+
+        FallbackRecentsView rv = activity.getOverviewPanel();
+        rv.setContentAlpha(0);
+        rv.getClearAllButton().setVisibilityAlpha(0);
+        rv.setDisallowScrollToClearAll(true);
+
+        boolean fromState = !animateActivity;
+        rv.setInOverviewState(fromState);
+
+        return new AnimationFactory() {
+
+            boolean isAnimatingToRecents = false;
+
+            @Override
+            public void onRemoteAnimationReceived(RemoteAnimationTargetSet targets) {
+                isAnimatingToRecents = targets != null && targets.isAnimatingHome();
+                if (!isAnimatingToRecents) {
+                    rv.setContentAlpha(1);
+                }
+                createActivityController(getSwipeUpDestinationAndLength(
+                        activity.getDeviceProfile(), activity, new Rect()));
+            }
+
+            @Override
+            public void createActivityController(long transitionLength) {
+                AnimatorSet animatorSet = new AnimatorSet();
+                if (isAnimatingToRecents) {
+                    ObjectAnimator anim = ObjectAnimator.ofFloat(rv, RecentsView.CONTENT_ALPHA, 0, 1);
+                    anim.setDuration(transitionLength).setInterpolator(LINEAR);
+                    animatorSet.play(anim);
+                }
+
+                ObjectAnimator anim = ObjectAnimator.ofFloat(rv, FallbackRecentsView.ZOOM_PROGRESS, 1, 0);
+                anim.setDuration(transitionLength).setInterpolator(LINEAR);
+                animatorSet.play(anim);
+
+                AnimatorPlaybackController controller =
+                        AnimatorPlaybackController.wrap(animatorSet, transitionLength);
+
+                // Since we are changing the start position of the UI, reapply the state, at the end
+                controller.setEndAction(() -> {
+                    boolean endState = true;
+                    rv.setInOverviewState(controller.getInterpolatedProgress() > 0.5 ?
+                                    endState : fromState);
+                });
+
+                callback.accept(controller);
+            }
+        };
+    }
+
+    @Override
+    public ActivityInitListener createActivityInitListener(
+            BiPredicate<RecentsActivity, Boolean> onInitListener) {
+        return new RecentsActivityTracker(onInitListener);
+    }
+
+    @Nullable
+    @Override
+    public RecentsActivity getCreatedActivity() {
+        return RecentsActivityTracker.getCurrentActivity();
+    }
+
+    @Nullable
+    @Override
+    public RecentsView getVisibleRecentsView() {
+        RecentsActivity activity = getCreatedActivity();
+        if (activity != null && activity.hasWindowFocus()) {
+            return activity.getOverviewPanel();
+        }
+        return null;
+    }
+
+    @Override
+    public boolean switchToRecentsIfVisible(Runnable onCompleteCallback) {
+        return false;
+    }
+
+    @Override
+    public Rect getOverviewWindowBounds(Rect homeBounds, RemoteAnimationTargetCompat target) {
+        // TODO: Remove this once b/77875376 is fixed
+        return target.sourceContainerBounds;
+    }
+
+    @Override
+    public boolean shouldMinimizeSplitScreen() {
+        // TODO: Remove this once b/77875376 is fixed
+        return false;
+    }
+
+    @Override
+    public boolean isInLiveTileMode() {
+        return false;
+    }
+
+    @Override
+    public void onLaunchTaskFailed(RecentsActivity activity) {
+        // TODO: probably go back to overview instead.
+        activity.<RecentsView>getOverviewPanel().startHome();
+    }
+
+    @Override
+    public void onLaunchTaskSuccess(RecentsActivity activity) {
+        activity.onTaskLaunched();
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/LauncherActivityControllerHelper.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/LauncherActivityControllerHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..d124f224cea7878ee2bba93dc060c1e995280f81
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/LauncherActivityControllerHelper.java
@@ -0,0 +1,451 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep;
+
+import static android.view.View.TRANSLATION_Y;
+import static foundation.e.blisslauncher.features.test.LauncherState.BACKGROUND_APP;
+import static foundation.e.blisslauncher.features.test.LauncherState.NORMAL;
+import static foundation.e.blisslauncher.features.test.LauncherState.OVERVIEW;
+import static foundation.e.blisslauncher.features.test.LauncherStateManager.ANIM_ALL;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.ACCEL_2;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.ACCEL_DEACCEL;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.INSTANT;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+import static foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils.SCALE_PROPERTY;
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.animation.TimeInterpolator;
+import android.content.Context;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.Region;
+import android.os.UserHandle;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.animation.Interpolator;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.UiThread;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import foundation.e.blisslauncher.LauncherAppTransitionManagerImpl;
+import foundation.e.blisslauncher.LauncherInitListenerEx;
+import foundation.e.blisslauncher.features.test.LauncherAppState;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.LauncherStateManager;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode.Mode;
+import foundation.e.blisslauncher.quickstep.util.LayoutUtils;
+import foundation.e.blisslauncher.quickstep.views.LauncherRecentsView;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+import foundation.e.blisslauncher.uioverrides.states.OverviewState;
+import java.util.function.BiPredicate;
+import java.util.function.Consumer;
+
+/**
+ * {@link ActivityControlHelper} for the in-launcher recents.
+ */
+public final class LauncherActivityControllerHelper implements ActivityControlHelper<TestActivity> {
+
+    private Runnable mAdjustInterpolatorsRunnable;
+
+    @Override
+    public int getSwipeUpDestinationAndLength(VariantDeviceProfile dp, Context context, Rect outRect) {
+        LayoutUtils.calculateLauncherTaskSize(context, dp, outRect);
+        return LayoutUtils.getShelfTrackingDistance(context, dp);
+    }
+
+    @Override
+    public void onTransitionCancelled(TestActivity activity, boolean activityVisible) {
+        LauncherState startState = activity.getStateManager().getRestState();
+        activity.getStateManager().goToState(startState, activityVisible);
+    }
+
+    @Override
+    public void onSwipeUpToRecentsComplete(TestActivity activity) {
+        // Re apply state in case we did something funky during the transition.
+        activity.getStateManager().reapplyState();
+    }
+
+    @Override
+    public void onSwipeUpToHomeComplete(TestActivity activity) {
+        // Ensure recents is at the correct position for NORMAL state. For example, when we detach
+        // recents, we assume the first task is invisible, making translation off by one task.
+        activity.getStateManager().reapplyState();
+    }
+
+    @Override
+    public void onAssistantVisibilityChanged(float visibility) {
+        TestActivity launcher = getCreatedActivity();
+        // TODO: may use it later.
+    }
+
+    @NonNull
+    @Override
+    public HomeAnimationFactory prepareHomeUI(TestActivity activity) {
+        final VariantDeviceProfile dp = activity.getDeviceProfile();
+        final RecentsView recentsView = activity.getOverviewPanel();
+        final TaskView runningTaskView = recentsView.getRunningTaskView();
+        final View workspaceView;
+        if (runningTaskView != null && runningTaskView.getTask().key.getComponent() != null) {
+            workspaceView = activity.getLauncherPagedView().getFirstMatchForAppClose(
+                    runningTaskView.getTask().key.getComponent().getPackageName(),
+                    UserHandle.of(runningTaskView.getTask().key.userId));
+        } else {
+            workspaceView = null;
+        }
+        final RectF iconLocation = new RectF();
+        boolean canUseWorkspaceView = workspaceView != null && workspaceView.isAttachedToWindow();
+
+        return new HomeAnimationFactory() {
+            @Nullable
+            @Override
+            public View getFloatingView() {
+                return null;
+            }
+
+            @NonNull
+            @Override
+            public RectF getWindowTargetRect() {
+                final int halfIconSize = dp.getIconSizePx() / 2;
+                final float targetCenterX = dp.getAvailableWidthPx() / 2f;
+                final float targetCenterY = dp.getAvailableHeightPx() - dp.getHotseatBarSizePx();
+
+                if (canUseWorkspaceView) {
+                    return iconLocation;
+                } else {
+                    // Fallback to animate to center of screen.
+                    return new RectF(targetCenterX - halfIconSize, targetCenterY - halfIconSize,
+                            targetCenterX + halfIconSize, targetCenterY + halfIconSize);
+                }
+            }
+
+            @NonNull
+            @Override
+            public AnimatorPlaybackController createActivityAnimationToHome() {
+                // Return an empty APC here since we have an non-user controlled animation to home.
+                long accuracy = 2 * Math.max(dp.getWidthPx(), dp.getHeightPx());
+                return activity.getStateManager().createAnimationToNewWorkspace(NORMAL, accuracy,
+                        0 /* animComponents */);
+            }
+
+            @Override
+            public void playAtomicAnimation(float velocity) {
+                // Setup workspace with 0 duration to prepare for our staggered animation.
+                LauncherStateManager stateManager = activity.getStateManager();
+                AnimatorSetBuilder builder = new AnimatorSetBuilder();
+                // setRecentsAttachedToAppWindow() will animate recents out.
+                builder.addFlag(AnimatorSetBuilder.FLAG_DONT_ANIMATE_OVERVIEW);
+                stateManager.createAtomicAnimation(BACKGROUND_APP, NORMAL, builder, ANIM_ALL, 0);
+                builder.build().start();
+
+                // Stop scrolling so that it doesn't interfere with the translation offscreen.
+                recentsView.getScroller().forceFinished(true);
+
+                //new StaggeredWorkspaceAnim(activity, workspaceView, velocity).start();
+            }
+        };
+    }
+
+    @Override
+    public AnimationFactory prepareRecentsUI(TestActivity activity, boolean activityVisible,
+            boolean animateActivity, Consumer<AnimatorPlaybackController> callback) {
+        final LauncherState startState = activity.getStateManager().getState();
+
+        LauncherState resetState = startState;
+        if (startState.disableRestore) {
+            resetState = activity.getStateManager().getRestState();
+        }
+        activity.getStateManager().setRestState(resetState);
+
+        final LauncherState fromState = animateActivity ? BACKGROUND_APP : OVERVIEW;
+        activity.getStateManager().goToState(fromState, false);
+
+        return new AnimationFactory() {
+            private ShelfAnimState mShelfState;
+            private boolean mIsAttachedToWindow;
+
+            @Override
+            public void createActivityController(long transitionLength) {
+                createActivityControllerInternal(activity, fromState, transitionLength, callback);
+                // Creating the activity controller animation sometimes reapplies the launcher state
+                // (because we set the animation as the current state animation), so we reapply the
+                // attached state here as well to ensure recents is shown/hidden appropriately.
+                if (SysUINavigationMode.getMode(activity) == Mode.NO_BUTTON) {
+                    setRecentsAttachedToAppWindow(mIsAttachedToWindow, false);
+                }
+            }
+
+            @Override
+            public void adjustActivityControllerInterpolators() {
+                if (mAdjustInterpolatorsRunnable != null) {
+                    mAdjustInterpolatorsRunnable.run();
+                }
+            }
+
+            @Override
+            public void onTransitionCancelled() {
+                activity.getStateManager().goToState(startState, false /* animate */);
+            }
+
+            @Override
+            public void setShelfState(ShelfAnimState shelfState, Interpolator interpolator,
+                    long duration) {
+                if (mShelfState == shelfState) {
+                    return;
+                }
+                mShelfState = shelfState;
+                activity.getStateManager().cancelStateElementAnimation(
+                    LauncherAppTransitionManagerImpl.INDEX_SHELF_ANIM);
+                if (mShelfState == ShelfAnimState.CANCEL) {
+                    return;
+                }
+                float shelfHiddenProgress = BACKGROUND_APP.getVerticalProgress(activity);
+                float shelfOverviewProgress = OVERVIEW.getVerticalProgress(activity);
+                // Peek based on default overview progress so we can see hotseat if we're showing
+                // that instead of predictions in overview.
+                float defaultOverviewProgress = OverviewState.getDefaultVerticalProgress(activity);
+                float shelfPeekingProgress = shelfHiddenProgress
+                        - (shelfHiddenProgress - defaultOverviewProgress) * 0.25f;
+                float toProgress = mShelfState == ShelfAnimState.HIDE
+                        ? shelfHiddenProgress
+                        : mShelfState == ShelfAnimState.PEEK
+                                ? shelfPeekingProgress
+                                : shelfOverviewProgress;
+                Animator shelfAnim = activity.getStateManager()
+                        .createStateElementAnimation(LauncherAppTransitionManagerImpl.INDEX_SHELF_ANIM, toProgress);
+                shelfAnim.setInterpolator(interpolator);
+                shelfAnim.setDuration(duration).start();
+            }
+
+            @Override
+            public void setRecentsAttachedToAppWindow(boolean attached, boolean animate) {
+                if (mIsAttachedToWindow == attached && animate) {
+                    return;
+                }
+                mIsAttachedToWindow = attached;
+                LauncherRecentsView recentsView = activity.getOverviewPanel();
+                Animator fadeAnim = activity.getStateManager()
+                        .createStateElementAnimation(
+                        LauncherAppTransitionManagerImpl.INDEX_RECENTS_FADE_ANIM, attached ? 1 : 0);
+
+                int runningTaskIndex = recentsView.getRunningTaskIndex();
+                if (runningTaskIndex == 0) {
+                    // If we are on the first task (we haven't quick switched), translate recents in
+                    // from the side. Calculate the start translation based on current scale/scroll.
+                    float currScale = recentsView.getScaleX();
+                    float scrollOffsetX = recentsView.getScrollOffset();
+
+                    float offscreenX = NORMAL.getOverviewScaleAndTranslation(activity).translationX;
+                    // The first task is hidden, so offset by its width.
+                    int firstTaskWidth = recentsView.getTaskViewAt(0).getWidth();
+                    offscreenX -= (firstTaskWidth + recentsView.getPageSpacing()) * currScale;
+                    // Offset since scale pushes tasks outwards.
+                    offscreenX += firstTaskWidth * (currScale - 1) / 2;
+                    offscreenX = Math.max(0, offscreenX);
+                    if (recentsView.isRtl()) {
+                        offscreenX = -offscreenX;
+                    }
+
+                    float fromTranslationX = attached ? offscreenX - scrollOffsetX : 0;
+                    float toTranslationX = attached ? 0 : offscreenX - scrollOffsetX;
+                    activity.getStateManager()
+                            .cancelStateElementAnimation(LauncherAppTransitionManagerImpl.INDEX_RECENTS_TRANSLATE_X_ANIM);
+
+                    if (!recentsView.isShown() && animate) {
+                        recentsView.setTranslationX(fromTranslationX);
+                    } else {
+                        fromTranslationX = recentsView.getTranslationX();
+                    }
+
+                    if (!animate) {
+                        recentsView.setTranslationX(toTranslationX);
+                    } else {
+                        activity.getStateManager().createStateElementAnimation(
+                                LauncherAppTransitionManagerImpl.INDEX_RECENTS_TRANSLATE_X_ANIM,
+                                fromTranslationX, toTranslationX).start();
+                    }
+
+                    fadeAnim.setInterpolator(attached ? INSTANT : ACCEL_2);
+                } else {
+                    fadeAnim.setInterpolator(ACCEL_DEACCEL);
+                }
+                fadeAnim.setDuration(animate ? WindowTransformSwipeHandler.RECENTS_ATTACH_DURATION : 0).start();
+            }
+        };
+    }
+
+    private void createActivityControllerInternal(TestActivity activity, LauncherState fromState,
+            long transitionLength, Consumer<AnimatorPlaybackController> callback) {
+        LauncherState endState = OVERVIEW;
+        if (fromState == endState) {
+            return;
+        }
+
+        AnimatorSet anim = new AnimatorSet();
+        if (SysUINavigationMode.getMode(activity) != Mode.NO_BUTTON) {
+            // Don't animate the shelf when the mode is NO_BUTTON, because we update it atomically.
+            anim.play(activity.getStateManager().createStateElementAnimation(
+                    LauncherAppTransitionManagerImpl.INDEX_SHELF_ANIM,
+                    fromState.getVerticalProgress(activity),
+                    endState.getVerticalProgress(activity)));
+        }
+        playScaleDownAnim(anim, activity, fromState, endState);
+
+        anim.setDuration(transitionLength * 2);
+        anim.setInterpolator(LINEAR);
+        AnimatorPlaybackController controller =
+                AnimatorPlaybackController.wrap(anim, transitionLength * 2);
+        activity.getStateManager().setCurrentUserControlledAnimation(controller);
+
+        // Since we are changing the start position of the UI, reapply the state, at the end
+        controller.setEndAction(() -> {
+            activity.getStateManager().goToState(
+                    controller.getInterpolatedProgress() > 0.5 ? endState : fromState, false);
+        });
+        callback.accept(controller);
+    }
+
+    /**
+     * Scale down recents from the center task being full screen to being in overview.
+     */
+    private void playScaleDownAnim(AnimatorSet anim, TestActivity launcher, LauncherState fromState,
+            LauncherState endState) {
+        RecentsView recentsView = launcher.getOverviewPanel();
+        TaskView v = recentsView.getTaskViewAt(recentsView.getCurrentPage());
+        if (v == null) {
+            return;
+        }
+
+        LauncherState.ScaleAndTranslation fromScaleAndTranslation
+                = fromState.getOverviewScaleAndTranslation(launcher);
+        LauncherState.ScaleAndTranslation endScaleAndTranslation
+                = endState.getOverviewScaleAndTranslation(launcher);
+        float fromTranslationY = fromScaleAndTranslation.translationY;
+        float endTranslationY = endScaleAndTranslation.translationY;
+        float fromFullscreenProgress = fromState.getOverviewFullscreenProgress();
+        float endFullscreenProgress = endState.getOverviewFullscreenProgress();
+
+        Animator scale = ObjectAnimator.ofFloat(recentsView, SCALE_PROPERTY,
+                fromScaleAndTranslation.scale, endScaleAndTranslation.scale);
+        Animator translateY = ObjectAnimator.ofFloat(recentsView, TRANSLATION_Y,
+                fromTranslationY, endTranslationY);
+        Animator applyFullscreenProgress = ObjectAnimator.ofFloat(recentsView,
+                RecentsView.FULLSCREEN_PROGRESS, fromFullscreenProgress, endFullscreenProgress);
+        anim.playTogether(scale, translateY, applyFullscreenProgress);
+
+        mAdjustInterpolatorsRunnable = () -> {
+            // Adjust the translateY interpolator to account for the running task's top inset.
+            // When progress <= 1, this is handled by each task view as they set their fullscreen
+            // progress. However, once we go to progress > 1, fullscreen progress stays at 0, so
+            // recents as a whole needs to translate further to keep up with the app window.
+            TaskView runningTaskView = recentsView.getRunningTaskView();
+            if (runningTaskView == null) {
+                runningTaskView = recentsView.getTaskViewAt(recentsView.getCurrentPage());
+            }
+            TimeInterpolator oldInterpolator = translateY.getInterpolator();
+            Rect fallbackInsets = launcher.getDeviceProfile().getInsets();
+            float extraTranslationY = runningTaskView.getThumbnail().getInsets(fallbackInsets).top;
+            float normalizedTranslationY = extraTranslationY / (fromTranslationY - endTranslationY);
+            translateY.setInterpolator(t -> {
+                float newT = oldInterpolator.getInterpolation(t);
+                return newT <= 1f ? newT : newT + normalizedTranslationY * (newT - 1);
+            });
+        };
+    }
+
+    @Override
+    public ActivityInitListener createActivityInitListener(
+            BiPredicate<TestActivity, Boolean> onInitListener) {
+        return new LauncherInitListenerEx(onInitListener);
+    }
+
+    @Nullable
+    @Override
+    public TestActivity getCreatedActivity() {
+        LauncherAppState app = LauncherAppState.getInstanceNoCreate();
+        if (app == null) {
+            return null;
+        }
+        return app.getLauncher();
+    }
+
+    @Nullable
+    @UiThread
+    private TestActivity getVisibleLauncher() {
+        TestActivity launcher = getCreatedActivity();
+        return (launcher != null) && launcher.isStarted() && launcher.hasWindowFocus() ?
+                launcher : null;
+    }
+
+    @Nullable
+    @Override
+    public RecentsView getVisibleRecentsView() {
+        TestActivity launcher = getVisibleLauncher();
+        return launcher != null && launcher.getStateManager().getState().overviewUi
+                ? launcher.getOverviewPanel() : null;
+    }
+
+    @Override
+    public boolean switchToRecentsIfVisible(Runnable onCompleteCallback) {
+        TestActivity launcher = getVisibleLauncher();
+        if (launcher == null) {
+            return false;
+        }
+
+        launcher.getStateManager().goToState(OVERVIEW,
+                launcher.getStateManager().shouldAnimateStateChange(), onCompleteCallback);
+        return true;
+    }
+
+    @Override
+    public boolean deferStartingActivity(Region activeNavBarRegion, MotionEvent ev) {
+        return activeNavBarRegion.contains((int) ev.getX(), (int) ev.getY());
+    }
+
+    @Override
+    public Rect getOverviewWindowBounds(Rect homeBounds, RemoteAnimationTargetCompat target) {
+        return homeBounds;
+    }
+
+    @Override
+    public boolean shouldMinimizeSplitScreen() {
+        return true;
+    }
+
+
+    @Override
+    public boolean isInLiveTileMode() {
+        TestActivity launcher = getCreatedActivity();
+        return launcher != null && launcher.getStateManager().getState() == OVERVIEW &&
+                launcher.isStarted();
+    }
+
+    @Override
+    public void onLaunchTaskFailed(TestActivity launcher) {
+        launcher.getStateManager().goToState(OVERVIEW);
+    }
+
+    @Override
+    public void onLaunchTaskSuccess(TestActivity launcher) {
+        launcher.getStateManager().moveToRestState();
+    }
+}
\ No newline at end of file
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/LockScreenRecentsActivity.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/LockScreenRecentsActivity.java
new file mode 100644
index 0000000000000000000000000000000000000000..59630010ab061c794bac803fb180dff5a309e6a5
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/LockScreenRecentsActivity.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+/**
+ * Empty activity to start a recents transition
+ */
+public class LockScreenRecentsActivity extends Activity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        finish();
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/MultiStateCallback.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/MultiStateCallback.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f958b504a728c913506842a333e3b0567e99d2e
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/MultiStateCallback.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.quickstep;
+
+import android.util.Log;
+import android.util.SparseArray;
+import java.util.StringJoiner;
+import java.util.function.Consumer;
+
+/**
+ * Utility class to help manage multiple callbacks based on different states.
+ */
+public class MultiStateCallback {
+
+    private static final String TAG = "MultiStateCallback";
+    public static final boolean DEBUG_STATES = false;
+
+    private final SparseArray<Runnable> mCallbacks = new SparseArray<>();
+    private final SparseArray<Consumer<Boolean>> mStateChangeHandlers = new SparseArray<>();
+
+    private final String[] mStateNames;
+
+    public MultiStateCallback(String[] stateNames) {
+        mStateNames = DEBUG_STATES ? stateNames : null;
+    }
+
+    private int mState = 0;
+
+    /**
+     * Adds the provided state flags to the global state and executes any callbacks as a result.
+     */
+    public void setState(int stateFlag) {
+        if (DEBUG_STATES) {
+            Log.d(TAG, "[" + System.identityHashCode(this) + "] Adding "
+                    + convertToFlagNames(stateFlag) + " to " + convertToFlagNames(mState));
+        }
+
+        int oldState = mState;
+        mState = mState | stateFlag;
+
+        int count = mCallbacks.size();
+        for (int i = 0; i < count; i++) {
+            int state = mCallbacks.keyAt(i);
+
+            if ((mState & state) == state) {
+                Runnable callback = mCallbacks.valueAt(i);
+                if (callback != null) {
+                    // Set the callback to null, so that it does not run again.
+                    mCallbacks.setValueAt(i, null);
+                    callback.run();
+                }
+            }
+        }
+        notifyStateChangeHandlers(oldState);
+    }
+
+    /**
+     * Adds the provided state flags to the global state and executes any change handlers
+     * as a result.
+     */
+    public void clearState(int stateFlag) {
+        if (DEBUG_STATES) {
+            Log.d(TAG, "[" + System.identityHashCode(this) + "] Removing "
+                    + convertToFlagNames(stateFlag) + " from " + convertToFlagNames(mState));
+        }
+
+        int oldState = mState;
+        mState = mState & ~stateFlag;
+        notifyStateChangeHandlers(oldState);
+    }
+
+    private void notifyStateChangeHandlers(int oldState) {
+        int count = mStateChangeHandlers.size();
+        for (int i = 0; i < count; i++) {
+            int state = mStateChangeHandlers.keyAt(i);
+            boolean wasOn = (state & oldState) == state;
+            boolean isOn = (state & mState) == state;
+
+            if (wasOn != isOn) {
+                mStateChangeHandlers.valueAt(i).accept(isOn);
+            }
+        }
+    }
+
+    /**
+     * Sets the callbacks to be run when the provided states are enabled.
+     * The callback is only run once.
+     */
+    public void addCallback(int stateMask, Runnable callback) {
+        // TODO: gracefully ignore in production release.
+        if (mCallbacks.get(stateMask) != null) {
+            throw new IllegalStateException("Multiple callbacks on same state");
+        }
+        mCallbacks.put(stateMask, callback);
+    }
+
+    /**
+     * Sets the handler to be called when the provided states are enabled or disabled.
+     */
+    public void addChangeHandler(int stateMask, Consumer<Boolean> handler) {
+        mStateChangeHandlers.put(stateMask, handler);
+    }
+
+    public int getState() {
+        return mState;
+    }
+
+    public boolean hasStates(int stateMask) {
+        return (mState & stateMask) == stateMask;
+    }
+
+    private String convertToFlagNames(int flags) {
+        StringJoiner joiner = new StringJoiner(", ", "[", " (" + flags + ")]");
+        for (int i = 0; i < mStateNames.length; i++) {
+            if ((flags & (1 << i)) != 0) {
+                joiner.add(mStateNames[i]);
+            }
+        }
+        return joiner.toString();
+    }
+
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/OverviewCommandHelper.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/OverviewCommandHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..b04b3d8db14c7d6ec9868676d3169cf8df7435b5
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/OverviewCommandHelper.java
@@ -0,0 +1,222 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import static com.android.systemui.shared.system.ActivityManagerWrapper.CLOSE_SYSTEM_WINDOWS_REASON_RECENTS;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.os.Build;
+import android.os.SystemClock;
+import android.view.ViewConfiguration;
+import com.android.systemui.shared.system.ActivityManagerWrapper;
+import com.android.systemui.shared.system.LatencyTrackerCompat;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import foundation.e.blisslauncher.core.executors.MainThreadExecutor;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.quickstep.ActivityControlHelper.ActivityInitListener;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+
+/**
+ * Helper class to handle various atomic commands for switching between Overview.
+ */
+@TargetApi(Build.VERSION_CODES.P)
+public class OverviewCommandHelper {
+
+    private final Context mContext;
+    private final ActivityManagerWrapper mAM;
+    private final RecentsModel mRecentsModel;
+    private final MainThreadExecutor mMainThreadExecutor;
+    private final OverviewComponentObserver mOverviewComponentObserver;
+
+    private long mLastToggleTime;
+
+    public OverviewCommandHelper(Context context, OverviewComponentObserver observer) {
+        mContext = context;
+        mAM = ActivityManagerWrapper.getInstance();
+        mMainThreadExecutor = new MainThreadExecutor();
+        mRecentsModel = RecentsModel.INSTANCE.get(mContext);
+        mOverviewComponentObserver = observer;
+    }
+
+    public void onOverviewToggle() {
+        // If currently screen pinning, do not enter overview
+        if (mAM.isScreenPinningActive()) {
+            return;
+        }
+
+        mAM.closeSystemWindows(CLOSE_SYSTEM_WINDOWS_REASON_RECENTS);
+        mMainThreadExecutor.execute(new RecentsActivityCommand<>());
+    }
+
+    public void onOverviewShown(boolean triggeredFromAltTab) {
+        mMainThreadExecutor.execute(new ShowRecentsCommand(triggeredFromAltTab));
+    }
+
+    public void onOverviewHidden() {
+        mMainThreadExecutor.execute(new HideRecentsCommand());
+    }
+
+    public void onTip(int actionType, int viewType) {
+    }
+
+    private class ShowRecentsCommand extends RecentsActivityCommand {
+
+        private final boolean mTriggeredFromAltTab;
+
+        ShowRecentsCommand(boolean triggeredFromAltTab) {
+            mTriggeredFromAltTab = triggeredFromAltTab;
+        }
+
+        @Override
+        protected boolean handleCommand(long elapsedTime) {
+            // TODO: Go to the next page if started from alt-tab.
+            return mHelper.getVisibleRecentsView() != null;
+        }
+
+        @Override
+        protected void onTransitionComplete() {
+            if (mTriggeredFromAltTab) {
+                RecentsView rv = (RecentsView) mHelper.getVisibleRecentsView();
+                if (rv == null) {
+                    return;
+                }
+
+                // Ensure that recents view has focus so that it receives the followup key inputs
+                TaskView taskView = rv.getNextTaskView();
+                if (taskView == null) {
+                    if (rv.getTaskViewCount() > 0) {
+                        taskView = (TaskView) rv.getPageAt(0);
+                        taskView.requestFocus();
+                    } else {
+                        rv.requestFocus();
+                    }
+                } else {
+                    taskView.requestFocus();
+                }
+            }
+        }
+    }
+
+    private class HideRecentsCommand extends RecentsActivityCommand {
+
+        @Override
+        protected boolean handleCommand(long elapsedTime) {
+            RecentsView recents = (RecentsView) mHelper.getVisibleRecentsView();
+            if (recents == null) {
+                return false;
+            }
+            int currentPage = recents.getNextPage();
+            if (currentPage >= 0 && currentPage < recents.getTaskViewCount()) {
+                ((TaskView) recents.getPageAt(currentPage)).launchTask(true);
+            } else {
+                recents.startHome();
+            }
+            return true;
+        }
+    }
+
+    private class RecentsActivityCommand<T extends BaseDraggingActivity> implements Runnable {
+
+        protected final ActivityControlHelper<T> mHelper;
+        private final long mCreateTime;
+        private final AppToOverviewAnimationProvider<T> mAnimationProvider;
+
+        private final long mToggleClickedTime = SystemClock.uptimeMillis();
+        private boolean mUserEventLogged;
+        private ActivityInitListener mListener;
+
+        public RecentsActivityCommand() {
+            mHelper = mOverviewComponentObserver.getActivityControlHelper();
+            mCreateTime = SystemClock.elapsedRealtime();
+            mAnimationProvider =
+                    new AppToOverviewAnimationProvider<>(mHelper, RecentsModel.getRunningTaskId());
+
+            // Preload the plan
+            mRecentsModel.getTasks(null);
+        }
+
+        @Override
+        public void run() {
+            long elapsedTime = mCreateTime - mLastToggleTime;
+            mLastToggleTime = mCreateTime;
+
+            if (handleCommand(elapsedTime)) {
+                // Command already handled.
+                return;
+            }
+
+            if (mHelper.switchToRecentsIfVisible(this::onTransitionComplete)) {
+                // If successfully switched, then return
+                return;
+            }
+
+            // Otherwise, start overview.
+            mListener = mHelper.createActivityInitListener(this::onActivityReady);
+            mListener.registerAndStartActivity(mOverviewComponentObserver.getOverviewIntent(),
+                    this::createWindowAnimation, mContext, mMainThreadExecutor.getHandler(),
+                    mAnimationProvider.getRecentsLaunchDuration());
+        }
+
+        protected boolean handleCommand(long elapsedTime) {
+            // TODO: We need to fix this case with PIP, when an activity first enters PIP, it shows
+            //       the menu activity which takes window focus, preventing the right condition from
+            //       being run below
+            RecentsView recents = mHelper.getVisibleRecentsView();
+            if (recents != null) {
+                // Launch the next task
+                recents.showNextTask();
+                return true;
+            } else if (elapsedTime < ViewConfiguration.getDoubleTapTimeout()) {
+                // The user tried to launch back into overview too quickly, either after
+                // launching an app, or before overview has actually shown, just ignore for now
+                return true;
+            }
+            return false;
+        }
+
+        private boolean onActivityReady(T activity, Boolean wasVisible) {
+            if (!mUserEventLogged) {
+                mUserEventLogged = true;
+            }
+            return mAnimationProvider.onActivityReady(activity, wasVisible);
+        }
+
+        private AnimatorSet createWindowAnimation(RemoteAnimationTargetCompat[] targetCompats) {
+            if (LatencyTrackerCompat.isEnabled(mContext)) {
+                LatencyTrackerCompat.logToggleRecents(
+                        (int) (SystemClock.uptimeMillis() - mToggleClickedTime));
+            }
+
+            mListener.unregister();
+
+            AnimatorSet animatorSet = mAnimationProvider.createWindowAnimation(targetCompats);
+            animatorSet.addListener(new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    onTransitionComplete();
+                }
+            });
+            return animatorSet;
+        }
+
+        protected void onTransitionComplete() { }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/RecentsActivity.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/RecentsActivity.java
new file mode 100644
index 0000000000000000000000000000000000000000..be058e6d23c715d81ee3af0b2d8e74b8cc2c149d
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/RecentsActivity.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep;
+
+import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_CLOSING;
+import static foundation.e.blisslauncher.QuickstepAppTransitionManagerImpl.RECENTS_LAUNCH_DURATION;
+import static foundation.e.blisslauncher.QuickstepAppTransitionManagerImpl.STATUS_BAR_TRANSITION_DURATION;
+import static foundation.e.blisslauncher.QuickstepAppTransitionManagerImpl.STATUS_BAR_TRANSITION_PRE_DELAY;
+import static foundation.e.blisslauncher.quickstep.TaskUtils.taskIsATargetWithMode;
+import static foundation.e.blisslauncher.quickstep.TaskViewUtils.getRecentsWindowAnimator;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.app.ActivityOptions;
+import android.content.res.Configuration;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.View;
+import com.android.systemui.shared.system.ActivityOptionsCompat;
+import com.android.systemui.shared.system.RemoteAnimationAdapterCompat;
+import com.android.systemui.shared.system.RemoteAnimationRunnerCompat;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import foundation.e.blisslauncher.BlissLauncher;
+import foundation.e.blisslauncher.LauncherAnimationRunner;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.features.test.BaseDragLayer;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.features.test.anim.Interpolators;
+import foundation.e.blisslauncher.quickstep.fallback.FallbackRecentsView;
+import foundation.e.blisslauncher.quickstep.fallback.RecentsRootView;
+import foundation.e.blisslauncher.quickstep.util.ClipAnimationHelper;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+
+/**
+ * A recents activity that shows the recently launched tasks as swipable task cards.
+ * See {@link RecentsView}.
+ */
+public final class RecentsActivity extends BaseRecentsActivity {
+
+    private Handler mUiHandler = new Handler(Looper.getMainLooper());
+    private RecentsRootView mRecentsRootView;
+    private FallbackRecentsView mFallbackRecentsView;
+
+    @Override
+    protected void initViews() {
+        setContentView(R.layout.fallback_recents_activity);
+        mRecentsRootView = findViewById(R.id.drag_layer);
+        mFallbackRecentsView = findViewById(R.id.overview_panel);
+        mRecentsRootView.setup();
+    }
+
+    @Override
+    public void onMultiWindowModeChanged(boolean isInMultiWindowMode, Configuration newConfig) {
+        onHandleConfigChanged();
+        super.onMultiWindowModeChanged(isInMultiWindowMode, newConfig);
+    }
+
+    public void onRootViewSizeChanged() {
+        if (isInMultiWindowMode()) {
+            onHandleConfigChanged();
+        }
+    }
+
+    @Override
+    protected void onHandleConfigChanged() {
+        super.onHandleConfigChanged();
+        mRecentsRootView.setup();
+    }
+
+    @Override
+    protected void reapplyUi() {
+        mRecentsRootView.dispatchInsets();
+    }
+
+    @Override
+    protected VariantDeviceProfile createDeviceProfile() {
+        VariantDeviceProfile dp = BlissLauncher.getApplication(this).getInvariantDeviceProfile().getDeviceProfile(this);
+        return (mRecentsRootView != null) && isInMultiWindowMode()
+                ? dp.getMultiWindowProfile(this, mRecentsRootView.getLastKnownSize())
+                : super.createDeviceProfile();
+    }
+
+    @Override
+    public BaseDragLayer getDragLayer() {
+        return mRecentsRootView;
+    }
+
+    @Override
+    public View getRootView() {
+        return mRecentsRootView;
+    }
+
+    @Override
+    public <T extends View> T getOverviewPanel() {
+        return (T) mFallbackRecentsView;
+    }
+
+    @Override
+    public ActivityOptions getActivityLaunchOptions(final View v) {
+        if (!(v instanceof TaskView)) {
+            return null;
+        }
+
+        final TaskView taskView = (TaskView) v;
+        RemoteAnimationRunnerCompat runner = new LauncherAnimationRunner(mUiHandler,
+                true /* startAtFrontOfQueue */) {
+
+            @Override
+            public void onCreateAnimation(RemoteAnimationTargetCompat[] targetCompats,
+                    AnimationResult result) {
+                AnimatorSet anim = composeRecentsLaunchAnimator(taskView, targetCompats);
+                anim.addListener(new AnimatorListenerAdapter() {
+                    @Override
+                    public void onAnimationEnd(Animator animation) {
+                        mFallbackRecentsView.resetViewUI();
+                    }
+                });
+                result.setAnimation(anim);
+            }
+        };
+        return ActivityOptionsCompat.makeRemoteAnimation(new RemoteAnimationAdapterCompat(
+                runner, RECENTS_LAUNCH_DURATION,
+                RECENTS_LAUNCH_DURATION - STATUS_BAR_TRANSITION_DURATION
+                        - STATUS_BAR_TRANSITION_PRE_DELAY));
+    }
+
+    /**
+     * Composes the animations for a launch from the recents list if possible.
+     */
+    private AnimatorSet composeRecentsLaunchAnimator(TaskView taskView,
+            RemoteAnimationTargetCompat[] targets) {
+        AnimatorSet target = new AnimatorSet();
+        boolean activityClosing = taskIsATargetWithMode(targets, getTaskId(), MODE_CLOSING);
+        ClipAnimationHelper helper = new ClipAnimationHelper(this);
+        target.play(getRecentsWindowAnimator(taskView, !activityClosing, targets, helper)
+                .setDuration(RECENTS_LAUNCH_DURATION));
+
+        // Found a visible recents task that matches the opening app, lets launch the app from there
+        if (activityClosing) {
+            Animator adjacentAnimation = mFallbackRecentsView
+                    .createAdjacentPageAnimForTaskLaunch(taskView, helper);
+            adjacentAnimation.setInterpolator(Interpolators.TOUCH_RESPONSE_INTERPOLATOR);
+            adjacentAnimation.setDuration(RECENTS_LAUNCH_DURATION);
+            adjacentAnimation.addListener(new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    mFallbackRecentsView.resetTaskVisuals();
+                }
+            });
+            target.play(adjacentAnimation);
+        }
+        return target;
+    }
+
+    @Override
+    protected void onStart() {
+        // Set the alpha to 1 before calling super, as it may get set back to 0 due to
+        // onActivityStart callback.
+        mFallbackRecentsView.setContentAlpha(1);
+        super.onStart();
+        mFallbackRecentsView.resetTaskVisuals();
+    }
+
+    public void onTaskLaunched() {
+        mFallbackRecentsView.resetTaskVisuals();
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/RecentsAnimationWrapper.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/RecentsAnimationWrapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..a5e882947f60ad46c087df6d5d3e264945327a38
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/RecentsAnimationWrapper.java
@@ -0,0 +1,201 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import static android.view.MotionEvent.ACTION_CANCEL;
+import static android.view.MotionEvent.ACTION_DOWN;
+import static android.view.MotionEvent.ACTION_UP;
+import static foundation.e.blisslauncher.core.Utilities.FLAG_NO_GESTURES;
+
+import android.view.InputEvent;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import androidx.annotation.UiThread;
+import com.android.systemui.shared.system.InputConsumerController;
+import foundation.e.blisslauncher.core.utils.Preconditions;
+import foundation.e.blisslauncher.quickstep.inputconsumers.InputConsumer;
+import foundation.e.blisslauncher.quickstep.util.SwipeAnimationTargetSet;
+import java.util.ArrayList;
+import java.util.function.Supplier;
+
+/**
+ * Wrapper around RecentsAnimationController to help with some synchronization
+ */
+public class RecentsAnimationWrapper {
+
+    // A list of callbacks to run when we receive the recents animation target. There are different
+    // than the state callbacks as these run on the current worker thread.
+    private final ArrayList<Runnable> mCallbacks = new ArrayList<>();
+
+    public SwipeAnimationTargetSet targetSet;
+
+    private boolean mWindowThresholdCrossed = false;
+
+    private final InputConsumerController mInputConsumerController;
+    private final Supplier<InputConsumer> mInputProxySupplier;
+
+    private InputConsumer mInputConsumer;
+    private boolean mTouchInProgress;
+
+    private boolean mFinishPending;
+
+    public RecentsAnimationWrapper(InputConsumerController inputConsumerController,
+            Supplier<InputConsumer> inputProxySupplier) {
+        mInputConsumerController = inputConsumerController;
+        mInputProxySupplier = inputProxySupplier;
+    }
+
+    public boolean hasTargets() {
+        return targetSet != null && targetSet.hasTargets();
+    }
+
+    @UiThread
+    public synchronized void setController(SwipeAnimationTargetSet targetSet) {
+        Preconditions.assertUIThread();
+        this.targetSet = targetSet;
+
+        if (targetSet == null) {
+            return;
+        }
+        targetSet.setWindowThresholdCrossed(mWindowThresholdCrossed);
+
+        if (!mCallbacks.isEmpty()) {
+            for (Runnable action : new ArrayList<>(mCallbacks)) {
+                action.run();
+            }
+            mCallbacks.clear();
+        }
+    }
+
+    public synchronized void runOnInit(Runnable action) {
+        if (targetSet == null) {
+            mCallbacks.add(action);
+        } else {
+            action.run();
+        }
+    }
+
+    /** See {@link #finish(boolean, Runnable, boolean)} */
+    @UiThread
+    public void finish(boolean toRecents, Runnable onFinishComplete) {
+        finish(toRecents, onFinishComplete, false /* sendUserLeaveHint */);
+    }
+
+    /**
+     * @param onFinishComplete A callback that runs on the main thread after the animation
+     *                         controller has finished on the background thread.
+     * @param sendUserLeaveHint Determines whether userLeaveHint flag will be set on the pausing
+     *                          activity. If userLeaveHint is true, the activity will enter into
+     *                          picture-in-picture mode upon being paused.
+     */
+    @UiThread
+    public void finish(boolean toRecents, Runnable onFinishComplete, boolean sendUserLeaveHint) {
+        Preconditions.assertUIThread();
+        if (!toRecents) {
+            finishAndClear(false, onFinishComplete, sendUserLeaveHint);
+        } else {
+            if (mTouchInProgress) {
+                mFinishPending = true;
+                // Execute the callback
+                if (onFinishComplete != null) {
+                    onFinishComplete.run();
+                }
+            } else {
+                finishAndClear(true, onFinishComplete, sendUserLeaveHint);
+            }
+        }
+    }
+
+    private void finishAndClear(boolean toRecents, Runnable onFinishComplete,
+            boolean sendUserLeaveHint) {
+        SwipeAnimationTargetSet controller = targetSet;
+        targetSet = null;
+        if (controller != null) {
+            controller.finishController(toRecents, onFinishComplete, sendUserLeaveHint);
+        }
+    }
+
+    public void enableInputConsumer() {
+        if (targetSet != null) {
+            targetSet.enableInputConsumer();
+        }
+    }
+
+    /**
+     * Indicates that the gesture has crossed the window boundary threshold and system UI can be
+     * update the represent the window behind
+     */
+    public void setWindowThresholdCrossed(boolean windowThresholdCrossed) {
+        if (mWindowThresholdCrossed != windowThresholdCrossed) {
+            mWindowThresholdCrossed = windowThresholdCrossed;
+            if (targetSet != null) {
+                targetSet.setWindowThresholdCrossed(windowThresholdCrossed);
+            }
+        }
+    }
+
+    public void enableInputProxy() {
+        mInputConsumerController.setInputListener(this::onInputConsumerEvent);
+    }
+
+    private boolean onInputConsumerEvent(InputEvent ev) {
+        if (ev instanceof MotionEvent) {
+            onInputConsumerMotionEvent((MotionEvent) ev);
+        } else if (ev instanceof KeyEvent) {
+            if (mInputConsumer == null) {
+                mInputConsumer = mInputProxySupplier.get();
+            }
+            mInputConsumer.onKeyEvent((KeyEvent) ev);
+            return true;
+        }
+        return false;
+    }
+
+    private boolean onInputConsumerMotionEvent(MotionEvent ev) {
+        int action = ev.getAction();
+        if (action == ACTION_DOWN) {
+            mTouchInProgress = true;
+            if (mInputConsumer == null) {
+                mInputConsumer = mInputProxySupplier.get();
+            }
+        } else if (action == ACTION_CANCEL || action == ACTION_UP) {
+            // Finish any pending actions
+            mTouchInProgress = false;
+            if (mFinishPending) {
+                mFinishPending = false;
+                finishAndClear(true /* toRecents */, null, false /* sendUserLeaveHint */);
+            }
+        }
+        if (mInputConsumer != null) {
+            int flags = ev.getEdgeFlags();
+            ev.setEdgeFlags(flags | FLAG_NO_GESTURES);
+            mInputConsumer.onMotionEvent(ev);
+            ev.setEdgeFlags(flags);
+        }
+
+        return true;
+    }
+
+    public void setCancelWithDeferredScreenshot(boolean deferredWithScreenshot) {
+        if (targetSet != null) {
+            targetSet.controller.setCancelWithDeferredScreenshot(deferredWithScreenshot);
+        }
+    }
+
+    public SwipeAnimationTargetSet getController() {
+        return targetSet;
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/SwipeSharedState.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/SwipeSharedState.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc08cbbcab4be1709340640ab72f633b815c456f
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/SwipeSharedState.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep;
+
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.utils.Preconditions;
+import foundation.e.blisslauncher.quickstep.util.RecentsAnimationListenerSet;
+import foundation.e.blisslauncher.quickstep.util.SwipeAnimationTargetSet;
+
+import java.io.PrintWriter;
+
+/**
+ * Utility class used to store state information shared across multiple transitions.
+ */
+public class SwipeSharedState implements SwipeAnimationTargetSet.SwipeAnimationListener {
+
+    private OverviewComponentObserver mOverviewComponentObserver;
+
+    private RecentsAnimationListenerSet mRecentsAnimationListener;
+    private SwipeAnimationTargetSet mLastAnimationTarget;
+
+    private boolean mLastAnimationCancelled = false;
+    private boolean mLastAnimationRunning = false;
+
+    public boolean canGestureBeContinued;
+    public boolean goingToLauncher;
+    public boolean recentsAnimationFinishInterrupted;
+    public int nextRunningTaskId = -1;
+
+    public void setOverviewComponentObserver(OverviewComponentObserver observer) {
+        mOverviewComponentObserver = observer;
+    }
+
+    @Override
+    public final void onRecentsAnimationStart(SwipeAnimationTargetSet targetSet) {
+        mLastAnimationTarget = targetSet;
+
+        mLastAnimationCancelled = false;
+        mLastAnimationRunning = true;
+    }
+
+    private void clearAnimationTarget() {
+        if (mLastAnimationTarget != null) {
+            mLastAnimationTarget.release();
+            mLastAnimationTarget = null;
+        }
+    }
+
+    @Override
+    public final void onRecentsAnimationCanceled() {
+        clearAnimationTarget();
+
+        mLastAnimationCancelled = true;
+        mLastAnimationRunning = false;
+    }
+
+    private void clearListenerState(boolean finishAnimation) {
+        if (mRecentsAnimationListener != null) {
+            mRecentsAnimationListener.removeListener(this);
+            mRecentsAnimationListener.cancelListener();
+            if (mLastAnimationRunning && mLastAnimationTarget != null) {
+                Utilities.postAsyncCallback(
+                    TouchInteractionService.MAIN_THREAD_EXECUTOR.getHandler(),
+                        finishAnimation
+                                ? mLastAnimationTarget::finishAnimation
+                                : mLastAnimationTarget::cancelAnimation);
+                mLastAnimationTarget = null;
+            }
+        }
+        mRecentsAnimationListener = null;
+        clearAnimationTarget();
+        mLastAnimationCancelled = false;
+        mLastAnimationRunning = false;
+    }
+
+    private void onSwipeAnimationFinished(SwipeAnimationTargetSet targetSet) {
+        if (mLastAnimationTarget == targetSet) {
+            mLastAnimationRunning = false;
+        }
+    }
+
+    public RecentsAnimationListenerSet newRecentsAnimationListenerSet() {
+        Preconditions.assertUIThread();
+
+        if (mLastAnimationRunning) {
+            String msg = "New animation started before completing old animation";
+            // TODO: gracefully ignore in production
+            throw new IllegalArgumentException(msg);
+        }
+
+        clearListenerState(false /* finishAnimation */);
+        boolean shouldMinimiseSplitScreen = mOverviewComponentObserver == null ? false
+                : mOverviewComponentObserver.getActivityControlHelper().shouldMinimizeSplitScreen();
+        mRecentsAnimationListener = new RecentsAnimationListenerSet(
+                shouldMinimiseSplitScreen, this::onSwipeAnimationFinished);
+        mRecentsAnimationListener.addListener(this);
+        return mRecentsAnimationListener;
+    }
+
+    public RecentsAnimationListenerSet getActiveListener() {
+        return mRecentsAnimationListener;
+    }
+
+    public void applyActiveRecentsAnimationState(SwipeAnimationTargetSet.SwipeAnimationListener listener) {
+        if (mLastAnimationTarget != null) {
+            listener.onRecentsAnimationStart(mLastAnimationTarget);
+        } else if (mLastAnimationCancelled) {
+            listener.onRecentsAnimationCanceled();
+        }
+    }
+
+    /**
+     * Called when a recents animation has finished, but was interrupted before the next task was
+     * launched. The given {@param runningTaskId} should be used as the running task for the
+     * continuing input consumer.
+     */
+    public void setRecentsAnimationFinishInterrupted(int runningTaskId) {
+        recentsAnimationFinishInterrupted = true;
+        nextRunningTaskId = runningTaskId;
+        mLastAnimationTarget = mLastAnimationTarget.cloneWithoutTargets();
+    }
+
+    public void clearAllState(boolean finishAnimation) {
+        clearListenerState(finishAnimation);
+        canGestureBeContinued = false;
+        recentsAnimationFinishInterrupted = false;
+        nextRunningTaskId = -1;
+        goingToLauncher = false;
+    }
+
+    public void dump(String prefix, PrintWriter pw) {
+        pw.println(prefix + "goingToLauncher=" + goingToLauncher);
+        pw.println(prefix + "canGestureBeContinued=" + canGestureBeContinued);
+        pw.println(prefix + "recentsAnimationFinishInterrupted=" + recentsAnimationFinishInterrupted);
+        pw.println(prefix + "nextRunningTaskId=" + nextRunningTaskId);
+        pw.println(prefix + "lastAnimationCancelled=" + mLastAnimationCancelled);
+        pw.println(prefix + "lastAnimationRunning=" + mLastAnimationRunning);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/TaskOverlayFactory.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/TaskOverlayFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..97dbebdb3590a5d4b481faea7a6a8424966ccfaa
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/TaskOverlayFactory.java
@@ -0,0 +1,80 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.graphics.Matrix;
+import android.view.View;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.features.test.BaseActivity;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.quickstep.util.ResourceBasedOverride;
+import foundation.e.blisslauncher.quickstep.views.TaskThumbnailView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+import com.android.systemui.shared.recents.model.Task;
+import com.android.systemui.shared.recents.model.ThumbnailData;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Factory class to create and add an overlays on the TaskView
+ */
+public class TaskOverlayFactory implements ResourceBasedOverride {
+
+    /** Note that these will be shown in order from top to bottom, if available for the task. */
+    private static final TaskSystemShortcut[] MENU_OPTIONS = new TaskSystemShortcut[]{
+            new TaskSystemShortcut.AppInfo(),
+            new TaskSystemShortcut.SplitScreen(),
+            new TaskSystemShortcut.Pin(),
+    };
+
+    public static final MainThreadInitializedObject<TaskOverlayFactory> INSTANCE =
+            new MainThreadInitializedObject<>(c -> Overrides.getObject(TaskOverlayFactory.class,
+                    c, R.string.task_overlay_factory_class));
+
+    public List<TaskSystemShortcut> getEnabledShortcuts(TaskView taskView) {
+        final ArrayList<TaskSystemShortcut> shortcuts = new ArrayList<>();
+        final BaseDraggingActivity activity =
+            (BaseDraggingActivity) BaseActivity.fromContext(taskView.getContext());
+        for (TaskSystemShortcut menuOption : MENU_OPTIONS) {
+            View.OnClickListener onClickListener =
+                    menuOption.getOnClickListener(activity, taskView);
+            if (onClickListener != null) {
+                shortcuts.add(menuOption);
+            }
+        }
+        return shortcuts;
+    }
+
+    public TaskOverlay createOverlay(TaskThumbnailView thumbnailView) {
+        return new TaskOverlay();
+    }
+
+    public static class TaskOverlay {
+
+        /**
+         * Called when the current task is interactive for the user
+         */
+        public void initOverlay(Task task, ThumbnailData thumbnail, Matrix matrix) { }
+
+        /**
+         * Called when the overlay is no longer used.
+         */
+        public void reset() { }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/TaskSystemShortcut.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/TaskSystemShortcut.java
new file mode 100644
index 0000000000000000000000000000000000000000..acc3a0e85b9fbaed0a06421ebda60016b57ddb7d
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/TaskSystemShortcut.java
@@ -0,0 +1,329 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import static android.view.Display.DEFAULT_DISPLAY;
+
+import android.app.Activity;
+import android.app.ActivityOptions;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.graphics.Color;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.RemoteException;
+import android.util.Log;
+import android.view.View;
+import android.widget.TextView;
+import com.android.systemui.shared.recents.ISystemUiProxy;
+import com.android.systemui.shared.recents.model.Task;
+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.ActivityCompat;
+import com.android.systemui.shared.system.ActivityManagerWrapper;
+import com.android.systemui.shared.system.ActivityOptionsCompat;
+import com.android.systemui.shared.system.WindowManagerWrapper;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.customviews.AbstractFloatingView;
+import foundation.e.blisslauncher.core.database.model.LauncherItem;
+import foundation.e.blisslauncher.core.database.model.ShortcutItem;
+import foundation.e.blisslauncher.core.utils.PackageManagerHelper;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskThumbnailView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+
+/**
+ * Represents a system shortcut that can be shown for a recent task.
+ */
+public class TaskSystemShortcut {
+
+    private static final String TAG = "TaskSystemShortcut";
+
+    public final int iconResId;
+    public final int labelResId;
+
+    private final CharSequence mLabel;
+    private final CharSequence mContentDescription;
+    private final Drawable mIcon;
+
+    public TaskSystemShortcut(int iconResId, int labelResId) {
+        this.iconResId = iconResId;
+        this.labelResId = labelResId;
+        mIcon = null;
+        mLabel = null;
+        mContentDescription = null;
+    }
+
+    public View.OnClickListener getOnClickListener(
+        BaseDraggingActivity activity, LauncherItem itemInfo) {
+        return null;
+    }
+
+    public View.OnClickListener getOnClickListener(BaseDraggingActivity activity, TaskView view) {
+        Task task = view.getTask();
+
+        ShortcutItem dummyInfo = new ShortcutItem();
+        dummyInfo.launchIntent = new Intent();
+        ComponentName component = task.getTopComponent();
+        dummyInfo.launchIntent.setComponent(component);
+        dummyInfo.user = new foundation.e.blisslauncher.core.utils.UserHandle(task.key.userId, android.os.UserHandle.of(task.key.userId));
+        dummyInfo.title = TaskUtils.getTitle(activity, task);
+
+        return getOnClickListenerForTask(activity, dummyInfo);
+    }
+
+    protected View.OnClickListener getOnClickListenerForTask(
+        BaseDraggingActivity activity, LauncherItem dummyInfo) {
+        return getOnClickListener(activity, dummyInfo);
+    }
+
+    public void setIconAndLabelFor(View iconView, TextView labelView) {
+        if (mIcon != null) {
+            iconView.setBackground(mIcon);
+        } else {
+            iconView.setBackgroundResource(iconResId);
+        }
+
+        if (mLabel != null) {
+            labelView.setText(mLabel);
+        } else {
+            labelView.setText(labelResId);
+        }
+    }
+
+    public static class AppInfo extends TaskSystemShortcut {
+        public AppInfo() {
+            super(R.drawable.ic_info_no_shadow, R.string.app_info_drop_target_label);
+        }
+
+        @Override
+        public View.OnClickListener getOnClickListener(
+            BaseDraggingActivity activity, LauncherItem itemInfo) {
+            return (view) -> {
+                Rect sourceBounds = activity.getViewBounds(view);
+                Bundle opts = activity.getActivityLaunchOptionsAsBundle(view);
+                new PackageManagerHelper(activity).startDetailsActivityForInfo(
+                    itemInfo, sourceBounds, opts);
+            };
+        }
+    }
+
+    public static abstract class MultiWindow extends TaskSystemShortcut {
+
+        private Handler mHandler;
+
+        public MultiWindow(int iconRes, int textRes) {
+            super(iconRes, textRes);
+            mHandler = new Handler(Looper.getMainLooper());
+        }
+
+        protected abstract boolean isAvailable(BaseDraggingActivity activity, int displayId);
+        protected abstract ActivityOptions makeLaunchOptions(Activity activity);
+        protected abstract boolean onActivityStarted(BaseDraggingActivity activity);
+
+        @Override
+        public View.OnClickListener getOnClickListener(
+            BaseDraggingActivity activity, TaskView taskView) {
+            final Task task  = taskView.getTask();
+            final int taskId = task.key.id;
+            final int displayId = task.key.displayId;
+            if (!task.isDockable) {
+                return null;
+            }
+            if (!isAvailable(activity, displayId)) {
+                return null;
+            }
+            final RecentsView recentsView = activity.getOverviewPanel();
+
+            final TaskThumbnailView thumbnailView = taskView.getThumbnail();
+            return (v -> {
+                final View.OnLayoutChangeListener onLayoutChangeListener =
+                    new View.OnLayoutChangeListener() {
+                        @Override
+                        public void onLayoutChange(View v, int l, int t, int r, int b,
+                            int oldL, int oldT, int oldR, int oldB) {
+                            taskView.getRootView().removeOnLayoutChangeListener(this);
+                            recentsView.clearIgnoreResetTask(taskId);
+
+                            // Start animating in the side pages once launcher has been resized
+                            recentsView.dismissTask(taskView, false, false);
+                        }
+                    };
+
+                final VariantDeviceProfile.OnDeviceProfileChangeListener onDeviceProfileChangeListener =
+                    new VariantDeviceProfile.OnDeviceProfileChangeListener() {
+                        @Override
+                        public void onDeviceProfileChanged(VariantDeviceProfile dp) {
+                            activity.removeOnDeviceProfileChangeListener(this);
+                            if (dp.isMultiWindowMode) {
+                                taskView.getRootView().addOnLayoutChangeListener(
+                                    onLayoutChangeListener);
+                            }
+                        }
+                    };
+
+                dismissTaskMenuView(activity);
+
+                ActivityOptions options = makeLaunchOptions(activity);
+                if (options != null
+                    && ActivityManagerWrapper.getInstance().startActivityFromRecents(taskId,
+                    options)) {
+                    if (!onActivityStarted(activity)) {
+                        return;
+                    }
+                    // Add a device profile change listener to kick off animating the side tasks
+                    // once we enter multiwindow mode and relayout
+                    activity.addOnDeviceProfileChangeListener(onDeviceProfileChangeListener);
+
+                    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
+                        recentsView.setIgnoreResetTask(taskId);
+                        taskView.setAlpha(0f);
+                    };
+
+                    final int[] position = new int[2];
+                    thumbnailView.getLocationOnScreen(position);
+                    final int width = (int) (thumbnailView.getWidth() * taskView.getScaleX());
+                    final int height = (int) (thumbnailView.getHeight() * taskView.getScaleY());
+                    final Rect taskBounds = new 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
+                    float alpha = thumbnailView.getDimAlpha();
+                    thumbnailView.setDimAlpha(0);
+                    Bitmap thumbnail = RecentsTransition.drawViewIntoHardwareBitmap(
+                        taskBounds.width(), taskBounds.height(), thumbnailView, 1f,
+                        Color.BLACK);
+                    thumbnailView.setDimAlpha(alpha);
+
+                    AppTransitionAnimationSpecsFuture future =
+                        new AppTransitionAnimationSpecsFuture(mHandler) {
+                            @Override
+                            public List<AppTransitionAnimationSpecCompat> composeSpecs() {
+                                return Collections.singletonList(new AppTransitionAnimationSpecCompat(
+                                    taskId, thumbnail, taskBounds));
+                            }
+                        };
+                    WindowManagerWrapper.getInstance().overridePendingAppTransitionMultiThumbFuture(
+                        future, animStartedListener, mHandler, true /* scaleUp */,
+                        v.getDisplay().getDisplayId());
+                }
+            });
+        }
+    }
+
+
+    public static class SplitScreen extends MultiWindow {
+        public SplitScreen() {
+            super(R.drawable.ic_split_screen, R.string.recent_task_option_split_screen);
+        }
+
+        @Override
+        protected boolean isAvailable(BaseDraggingActivity activity, int displayId) {
+            // Don't show menu-item if already in multi-window and the task is from
+            // the secondary display.
+            // TODO(b/118266305): Temporarily disable splitscreen for secondary display while new
+            // implementation is enabled
+            return !activity.getDeviceProfile().isMultiWindowMode
+                    && (displayId == -1 || displayId == DEFAULT_DISPLAY);
+        }
+
+        @Override
+        protected ActivityOptions makeLaunchOptions(Activity activity) {
+            final ActivityCompat act = new ActivityCompat(activity);
+            final int navBarPosition = WindowManagerWrapper.getInstance().getNavBarPosition(
+                    act.getDisplayId());
+            if (navBarPosition == WindowManagerWrapper.NAV_BAR_POS_INVALID) {
+                return null;
+            }
+            boolean dockTopOrLeft = navBarPosition != WindowManagerWrapper.NAV_BAR_POS_LEFT;
+            return ActivityOptionsCompat.makeSplitScreenOptions(dockTopOrLeft);
+        }
+
+        @Override
+        protected boolean onActivityStarted(BaseDraggingActivity activity) {
+            ISystemUiProxy sysUiProxy = RecentsModel.INSTANCE.get(activity).getSystemUiProxy();
+            try {
+                sysUiProxy.onSplitScreenInvoked();
+            } catch (RemoteException e) {
+                Log.w(TAG, "Failed to notify SysUI of split screen: ", e);
+                return false;
+            }
+            return true;
+        }
+    }
+
+    public static class Pin extends TaskSystemShortcut {
+
+        private static final String TAG = Pin.class.getSimpleName();
+
+        private Handler mHandler;
+
+        public Pin() {
+            super(R.drawable.ic_pin, R.string.recent_task_option_pin);
+            mHandler = new Handler(Looper.getMainLooper());
+        }
+
+        @Override
+        public View.OnClickListener getOnClickListener(
+                BaseDraggingActivity activity, TaskView taskView) {
+            ISystemUiProxy sysUiProxy = RecentsModel.INSTANCE.get(activity).getSystemUiProxy();
+            if (sysUiProxy == null) {
+                return null;
+            }
+            if (!ActivityManagerWrapper.getInstance().isScreenPinningEnabled()) {
+                return null;
+            }
+            if (ActivityManagerWrapper.getInstance().isLockToAppActive()) {
+                // We shouldn't be able to pin while an app is locked.
+                return null;
+            }
+            return view -> {
+                Consumer<Boolean> resultCallback = success -> {
+                    if (success) {
+                        try {
+                            sysUiProxy.startScreenPinning(taskView.getTask().key.id);
+                        } catch (RemoteException e) {
+                            Log.w(TAG, "Failed to start screen pinning: ", e);
+                        }
+                    } else {
+                        taskView.notifyTaskLaunchFailed(TAG);
+                    }
+                };
+                taskView.launchTask(true, resultCallback, mHandler);
+                dismissTaskMenuView(activity);
+            };
+        }
+    }
+
+    protected static void dismissTaskMenuView(BaseDraggingActivity activity) {
+        AbstractFloatingView.closeOpenViews(activity, true,
+            AbstractFloatingView.TYPE_ALL);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/TaskViewUtils.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/TaskViewUtils.java
new file mode 100644
index 0000000000000000000000000000000000000000..51d2b68582a713d07118fa1577fd81909babdc1e
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/TaskViewUtils.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep;
+
+import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_OPENING;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.TOUCH_RESPONSE_INTERPOLATOR;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.content.ComponentName;
+import android.graphics.RectF;
+import android.view.View;
+import com.android.systemui.shared.recents.model.Task;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.database.model.LauncherItem;
+import foundation.e.blisslauncher.features.test.BaseActivity;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.quickstep.util.ClipAnimationHelper;
+import foundation.e.blisslauncher.quickstep.util.MultiValueUpdateListener;
+import foundation.e.blisslauncher.quickstep.util.RemoteAnimationTargetSet;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+
+/**
+ * Utility class for helpful methods related to {@link TaskView} objects and their tasks.
+ */
+public final class TaskViewUtils {
+
+    private TaskViewUtils() {}
+
+    /**
+     * 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.
+     */
+    public static TaskView findTaskViewToLaunch(
+            BaseDraggingActivity activity, View v, RemoteAnimationTargetCompat[] targets) {
+        RecentsView recentsView = activity.getOverviewPanel();
+        if (v instanceof TaskView) {
+            TaskView taskView = (TaskView) v;
+            return recentsView.isTaskViewVisible(taskView) ? taskView : null;
+        }
+
+        // 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 LauncherItem) {
+            LauncherItem itemInfo = (LauncherItem) v.getTag();
+            ComponentName componentName = itemInfo.getTargetComponent();
+            int userId = itemInfo.user.getRealHandle().getIdentifier();
+            if (componentName != null) {
+                for (int i = 0; i < recentsView.getTaskViewCount(); i++) {
+                    TaskView taskView = recentsView.getTaskViewAt(i);
+                    if (recentsView.isTaskViewVisible(taskView)) {
+                        Task.TaskKey key = taskView.getTask().key;
+                        if (componentName.equals(key.getComponent()) && userId == key.userId) {
+                            return taskView;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (targets == null) {
+            return null;
+        }
+        // Resolve the opening task id
+        int openingTaskId = -1;
+        for (RemoteAnimationTargetCompat target : targets) {
+            if (target.mode == MODE_OPENING) {
+                openingTaskId = target.taskId;
+                break;
+            }
+        }
+
+        // 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
+        // icon launch animation
+        TaskView taskView = recentsView.getTaskView(openingTaskId);
+        if (taskView == null || !recentsView.isTaskViewVisible(taskView)) {
+            return null;
+        }
+        return taskView;
+    }
+
+    /**
+     * @return Animator that controls the window of the opening targets for the recents launch
+     * animation.
+     */
+    public static ValueAnimator getRecentsWindowAnimator(TaskView v, boolean skipViewChanges,
+            RemoteAnimationTargetCompat[] targets, final ClipAnimationHelper inOutHelper) {
+        SyncRtSurfaceTransactionApplierCompat applier =
+                new SyncRtSurfaceTransactionApplierCompat(v);
+        ClipAnimationHelper.TransformParams params = new ClipAnimationHelper.TransformParams()
+                .setSyncTransactionApplier(applier);
+
+        final RemoteAnimationTargetSet targetSet =
+                new RemoteAnimationTargetSet(targets, MODE_OPENING);
+        targetSet.addDependentTransactionApplier(applier);
+
+        final RecentsView recentsView = v.getRecentsView();
+        final ValueAnimator appAnimator = ValueAnimator.ofFloat(0, 1);
+        appAnimator.setInterpolator(TOUCH_RESPONSE_INTERPOLATOR);
+        appAnimator.addUpdateListener(new MultiValueUpdateListener() {
+
+            // Defer fading out the view until after the app window gets faded in
+            final FloatProp mViewAlpha = new FloatProp(1f, 0f, 75, 75, LINEAR);
+            final FloatProp mTaskAlpha = new FloatProp(0f, 1f, 0, 75, LINEAR);
+
+
+            final RectF mThumbnailRect;
+
+            {
+                inOutHelper.setTaskAlphaCallback((t, alpha) -> mTaskAlpha.value);
+
+                inOutHelper.prepareAnimation(
+                        BaseActivity.fromContext(v.getContext()).getDeviceProfile(),
+                        true /* isOpening */);
+                inOutHelper.fromTaskThumbnailView(v.getThumbnail(), (RecentsView) v.getParent(),
+                        targetSet.apps.length == 0 ? null : targetSet.apps[0]);
+
+                mThumbnailRect = new RectF(inOutHelper.getTargetRect());
+                mThumbnailRect.offset(-v.getTranslationX(), -v.getTranslationY());
+                Utilities.scaleRectFAboutCenter(mThumbnailRect, 1 / v.getScaleX());
+            }
+
+            @Override
+            public void onUpdate(float percent) {
+                // TODO: Take into account the current fullscreen progress for animating the insets
+                params.setProgress(1 - percent);
+                RectF taskBounds = inOutHelper.applyTransform(targetSet, params);
+                int taskIndex = recentsView.indexOfChild(v);
+                int centerTaskIndex = recentsView.getCurrentPage();
+                boolean parallaxCenterAndAdjacentTask = taskIndex != centerTaskIndex;
+                if (!skipViewChanges && parallaxCenterAndAdjacentTask) {
+                    float scale = taskBounds.width() / mThumbnailRect.width();
+                    v.setScaleX(scale);
+                    v.setScaleY(scale);
+                    v.setTranslationX(taskBounds.centerX() - mThumbnailRect.centerX());
+                    v.setTranslationY(taskBounds.centerY() - mThumbnailRect.centerY());
+                    v.setAlpha(mViewAlpha.value);
+                }
+            }
+        });
+        appAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                targetSet.release();
+            }
+        });
+        return appAnimator;
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/TouchInteractionService.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/TouchInteractionService.java
new file mode 100644
index 0000000000000000000000000000000000000000..f9edc33cfa52d75f307ba7e0ee585a112b4257d9
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/TouchInteractionService.java
@@ -0,0 +1,664 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.quickstep;
+
+import static android.view.MotionEvent.ACTION_DOWN;
+import static com.android.systemui.shared.system.QuickStepContract.KEY_EXTRA_INPUT_MONITOR;
+import static com.android.systemui.shared.system.QuickStepContract.KEY_EXTRA_SYSUI_PROXY;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_A11Y_BUTTON_CLICKABLE;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_A11Y_BUTTON_LONG_CLICKABLE;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_HOME_DISABLED;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_NAV_BAR_HIDDEN;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_OVERVIEW_DISABLED;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_SCREEN_PINNING;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED;
+import static foundation.e.blisslauncher.core.Flags.ENABLE_QUICKSTEP_LIVE_TILE;
+
+import android.annotation.TargetApi;
+import android.app.ActivityManager.RunningTaskInfo;
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.graphics.Point;
+import android.graphics.RectF;
+import android.graphics.Region;
+import android.hardware.display.DisplayManager;
+import android.hardware.display.DisplayManager.DisplayListener;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.Process;
+import android.os.RemoteException;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.Choreographer;
+import android.view.Display;
+import android.view.InputEvent;
+import android.view.MotionEvent;
+import android.view.Surface;
+import android.view.WindowManager;
+import androidx.annotation.BinderThread;
+import androidx.annotation.UiThread;
+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;
+import com.android.systemui.shared.system.QuickStepContract.SystemUiStateFlags;
+import com.android.systemui.shared.system.SystemGestureExclusionListenerCompat;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.UserManagerCompat;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.executors.LooperExecutor;
+import foundation.e.blisslauncher.core.executors.MainThreadExecutor;
+import foundation.e.blisslauncher.core.utils.ResourceUtils;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.features.test.UiThreadHelper;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode.Mode;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode.NavigationModeChangeListener;
+import foundation.e.blisslauncher.quickstep.inputconsumers.AccessibilityInputConsumer;
+import foundation.e.blisslauncher.quickstep.inputconsumers.AssistantTouchConsumer;
+import foundation.e.blisslauncher.quickstep.inputconsumers.DeviceLockedInputConsumer;
+import foundation.e.blisslauncher.quickstep.inputconsumers.FallbackNoButtonInputConsumer;
+import foundation.e.blisslauncher.quickstep.inputconsumers.InputConsumer;
+import foundation.e.blisslauncher.quickstep.inputconsumers.OtherActivityInputConsumer;
+import foundation.e.blisslauncher.quickstep.inputconsumers.OverviewInputConsumer;
+import foundation.e.blisslauncher.quickstep.inputconsumers.OverviewWithoutFocusInputConsumer;
+import foundation.e.blisslauncher.quickstep.inputconsumers.ResetGestureInputConsumer;
+import foundation.e.blisslauncher.quickstep.inputconsumers.ScreenPinnedInputConsumer;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Wrapper around a list for processing arguments.
+ */
+class ArgList extends LinkedList<String> {
+    public ArgList(List<String> l) {
+        super(l);
+    }
+
+    public String peekArg() {
+        return peekFirst();
+    }
+
+    public String nextArg() {
+        return pollFirst().toLowerCase();
+    }
+
+    public String nextArgExact() {
+        return pollFirst();
+    }
+}
+
+/**
+ * Service connected by system-UI for handling touch interaction.
+ */
+@TargetApi(Build.VERSION_CODES.Q)
+public class TouchInteractionService extends Service implements
+        NavigationModeChangeListener, DisplayListener {
+
+    public static final MainThreadExecutor MAIN_THREAD_EXECUTOR = new MainThreadExecutor();
+    public static final LooperExecutor BACKGROUND_EXECUTOR =
+            new LooperExecutor(UiThreadHelper.getBackgroundLooper());
+
+    private static final String TAG = "TouchInteractionService";
+
+    private final IBinder mMyBinder = new IOverviewProxy.Stub() {
+
+        public void onActiveNavBarRegionChanges(Region region) {
+            mActiveNavBarRegion = region;
+        }
+
+        public void onInitialize(Bundle bundle) {
+            mISystemUiProxy = ISystemUiProxy.Stub
+                    .asInterface(bundle.getBinder(KEY_EXTRA_SYSUI_PROXY));
+            MAIN_THREAD_EXECUTOR.execute(TouchInteractionService.this::initInputMonitor);
+            MAIN_THREAD_EXECUTOR.execute(TouchInteractionService.this::onSystemUiProxySet);
+        }
+
+        @Override
+        public void onOverviewToggle() {
+            mOverviewCommandHelper.onOverviewToggle();
+        }
+
+        @Override
+        public void onOverviewShown(boolean triggeredFromAltTab) {
+            mOverviewCommandHelper.onOverviewShown(triggeredFromAltTab);
+        }
+
+        @Override
+        public void onOverviewHidden(boolean triggeredFromAltTab, boolean triggeredFromHomeKey) {
+            if (triggeredFromAltTab && !triggeredFromHomeKey) {
+                // onOverviewShownFromAltTab hides the overview and ends at the target app
+                mOverviewCommandHelper.onOverviewHidden();
+            }
+        }
+
+        @Override
+        public void onTip(int actionType, int viewType) {
+            mOverviewCommandHelper.onTip(actionType, viewType);
+        }
+
+        @Override
+        public void onAssistantAvailable(boolean available) {
+            mAssistantAvailable = available;
+        }
+
+        @Override
+        public void onAssistantVisibilityChanged(float visibility) {
+            mLastAssistantVisibility = visibility;
+            MAIN_THREAD_EXECUTOR.execute(
+                    TouchInteractionService.this::onAssistantVisibilityChanged);
+        }
+
+        public void onBackAction(boolean completed, int downX, int downY, boolean isButton,
+                boolean gestureSwipeLeft) {
+            if (mOverviewComponentObserver == null) {
+                return;
+            }
+
+            final ActivityControlHelper activityControl =
+                    mOverviewComponentObserver.getActivityControlHelper();
+        }
+
+        public void onSystemUiStateChanged(int stateFlags) {
+            mSystemUiStateFlags = stateFlags;
+            MAIN_THREAD_EXECUTOR.execute(TouchInteractionService.this::onSystemUiFlagsChanged);
+        }
+
+        /** Deprecated methods **/
+        public void onQuickStep(MotionEvent motionEvent) { }
+
+        public void onQuickScrubEnd() { }
+
+        public void onQuickScrubProgress(float progress) { }
+
+        public void onQuickScrubStart() { }
+
+        public void onPreMotionEvent(int downHitTarget) { }
+
+        public void onMotionEvent(MotionEvent ev) {
+            ev.recycle();
+        }
+
+        public void onBind(ISystemUiProxy iSystemUiProxy) { }
+    };
+
+    private static boolean sConnected = false;
+    private static final SwipeSharedState sSwipeSharedState = new SwipeSharedState();
+
+    public static boolean isConnected() {
+        return sConnected;
+    }
+
+    public static SwipeSharedState getSwipeSharedState() {
+        return sSwipeSharedState;
+    }
+
+    private final InputConsumer mResetGestureInputConsumer =
+            new ResetGestureInputConsumer(sSwipeSharedState);
+
+    private ActivityManagerWrapper mAM;
+    private RecentsModel mRecentsModel;
+    private ISystemUiProxy mISystemUiProxy;
+    private OverviewCommandHelper mOverviewCommandHelper;
+    private OverviewComponentObserver mOverviewComponentObserver;
+    private OverviewInteractionState mOverviewInteractionState;
+    private OverviewCallbacks mOverviewCallbacks;
+    private TaskOverlayFactory mTaskOverlayFactory;
+    private InputConsumerController mInputConsumer;
+    private boolean mAssistantAvailable;
+    private float mLastAssistantVisibility = 0;
+    private @SystemUiStateFlags int mSystemUiStateFlags;
+
+    private boolean mIsUserUnlocked;
+    private BroadcastReceiver mUserUnlockedReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (Intent.ACTION_USER_UNLOCKED.equals(intent.getAction())) {
+                initWhenUserUnlocked();
+            }
+        }
+    };
+
+    private InputConsumer mUncheckedConsumer = InputConsumer.NO_OP;
+    private InputConsumer mConsumer = InputConsumer.NO_OP;
+    private Choreographer mMainChoreographer;
+
+    private Region mActiveNavBarRegion = new Region();
+
+    private InputMonitorCompat mInputMonitorCompat;
+    private InputEventReceiver mInputEventReceiver;
+    private Mode mMode = Mode.THREE_BUTTONS;
+    private int mDefaultDisplayId;
+    private final RectF mSwipeTouchRegion = new RectF();
+    private final RectF mAssistantLeftRegion = new RectF();
+    private final RectF mAssistantRightRegion = new RectF();
+
+    private ComponentName mGestureBlockingActivity;
+
+    private Region mExclusionRegion;
+    private SystemGestureExclusionListenerCompat mExclusionListener;
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        // Initialize anything here that is needed in direct boot mode.
+        // Everything else should be initialized in initWhenUserUnlocked() below.
+        mMainChoreographer = Choreographer.getInstance();
+        mAM = ActivityManagerWrapper.getInstance();
+
+        if (UserManagerCompat.getInstance(this).isUserUnlocked(Process.myUserHandle())) {
+            initWhenUserUnlocked();
+        } else {
+            mIsUserUnlocked = false;
+            registerReceiver(mUserUnlockedReceiver, new IntentFilter(Intent.ACTION_USER_UNLOCKED));
+        }
+
+        mDefaultDisplayId = getSystemService(WindowManager.class).getDefaultDisplay()
+                .getDisplayId();
+        String blockingActivity = getString(R.string.gesture_blocking_activity);
+        mGestureBlockingActivity = TextUtils.isEmpty(blockingActivity) ? null :
+                ComponentName.unflattenFromString(blockingActivity);
+
+        mExclusionListener = new SystemGestureExclusionListenerCompat(mDefaultDisplayId) {
+            @Override
+            @BinderThread
+            public void onExclusionChanged(Region region) {
+                // Assignments are atomic, it should be safe on binder thread
+                mExclusionRegion = region;
+            }
+        };
+
+        onNavigationModeChanged(SysUINavigationMode.INSTANCE.get(this).addModeChangeListener(this));
+        sConnected = true;
+    }
+
+    private void disposeEventHandlers() {
+        if (mInputEventReceiver != null) {
+            mInputEventReceiver.dispose();
+            mInputEventReceiver = null;
+        }
+        if (mInputMonitorCompat != null) {
+            mInputMonitorCompat.dispose();
+            mInputMonitorCompat = null;
+        }
+    }
+
+    private void initInputMonitor() {
+        if (!mMode.hasGestures || mISystemUiProxy == null) {
+            return;
+        }
+        disposeEventHandlers();
+
+        try {
+            mInputMonitorCompat = InputMonitorCompat.fromBundle(mISystemUiProxy
+                    .monitorGestureInput("swipe-up", mDefaultDisplayId), KEY_EXTRA_INPUT_MONITOR);
+            mInputEventReceiver = mInputMonitorCompat.getInputReceiver(Looper.getMainLooper(),
+                    mMainChoreographer, this::onInputEvent);
+        } catch (RemoteException e) {
+            Log.e(TAG, "Unable to create input monitor", e);
+        }
+        initTouchBounds();
+    }
+
+    private int getNavbarSize(String resName) {
+        return ResourceUtils.getNavbarSize(resName, getResources());
+    }
+
+    private void initTouchBounds() {
+        if (!mMode.hasGestures) {
+            return;
+        }
+
+        Display defaultDisplay = getSystemService(WindowManager.class).getDefaultDisplay();
+        Point realSize = new Point();
+        defaultDisplay.getRealSize(realSize);
+        mSwipeTouchRegion.set(0, 0, realSize.x, realSize.y);
+        if (mMode == Mode.NO_BUTTON) {
+            int touchHeight = getNavbarSize(ResourceUtils.NAVBAR_BOTTOM_GESTURE_SIZE);
+            mSwipeTouchRegion.top = mSwipeTouchRegion.bottom - touchHeight;
+
+            final int assistantWidth = getResources()
+                    .getDimensionPixelSize(R.dimen.gestures_assistant_width);
+            final float assistantHeight = Math.max(touchHeight,
+                    QuickStepContract.getWindowCornerRadius(getResources()));
+            mAssistantLeftRegion.bottom = mAssistantRightRegion.bottom = mSwipeTouchRegion.bottom;
+            mAssistantLeftRegion.top = mAssistantRightRegion.top =
+                    mSwipeTouchRegion.bottom - assistantHeight;
+
+            mAssistantLeftRegion.left = 0;
+            mAssistantLeftRegion.right = assistantWidth;
+
+            mAssistantRightRegion.right = mSwipeTouchRegion.right;
+            mAssistantRightRegion.left = mSwipeTouchRegion.right - assistantWidth;
+        } else {
+            mAssistantLeftRegion.setEmpty();
+            mAssistantRightRegion.setEmpty();
+            switch (defaultDisplay.getRotation()) {
+                case Surface.ROTATION_90:
+                    mSwipeTouchRegion.left = mSwipeTouchRegion.right
+                            - getNavbarSize(ResourceUtils.NAVBAR_LANDSCAPE_LEFT_RIGHT_SIZE);
+                    break;
+                case Surface.ROTATION_270:
+                    mSwipeTouchRegion.right = mSwipeTouchRegion.left
+                            + getNavbarSize(ResourceUtils.NAVBAR_LANDSCAPE_LEFT_RIGHT_SIZE);
+                    break;
+                default:
+                    mSwipeTouchRegion.top = mSwipeTouchRegion.bottom
+                            - getNavbarSize(ResourceUtils.NAVBAR_BOTTOM_GESTURE_SIZE);
+            }
+        }
+    }
+
+    @Override
+    public void onNavigationModeChanged(Mode newMode) {
+        if (mMode.hasGestures != newMode.hasGestures) {
+            if (newMode.hasGestures) {
+                getSystemService(DisplayManager.class).registerDisplayListener(
+                        this, MAIN_THREAD_EXECUTOR.getHandler());
+            } else {
+                getSystemService(DisplayManager.class).unregisterDisplayListener(this);
+            }
+        }
+        mMode = newMode;
+
+        disposeEventHandlers();
+        initInputMonitor();
+
+        if (mMode == Mode.NO_BUTTON) {
+            mExclusionListener.register();
+        } else {
+            mExclusionListener.unregister();
+        }
+    }
+
+    @Override
+    public void onDisplayAdded(int i) { }
+
+    @Override
+    public void onDisplayRemoved(int i) { }
+
+    @Override
+    public void onDisplayChanged(int displayId) {
+        if (displayId != mDefaultDisplayId) {
+            return;
+        }
+
+        initTouchBounds();
+    }
+
+    private void initWhenUserUnlocked() {
+        mRecentsModel = RecentsModel.INSTANCE.get(this);
+        mOverviewComponentObserver = new OverviewComponentObserver(this);
+
+        mOverviewCommandHelper = new OverviewCommandHelper(this, mOverviewComponentObserver);
+        mOverviewInteractionState = OverviewInteractionState.INSTANCE.get(this);
+        mOverviewCallbacks = OverviewCallbacks.get(this);
+        mTaskOverlayFactory = TaskOverlayFactory.INSTANCE.get(this);
+        mInputConsumer = InputConsumerController.getRecentsAnimationInputConsumer();
+        mIsUserUnlocked = true;
+
+        sSwipeSharedState.setOverviewComponentObserver(mOverviewComponentObserver);
+        mInputConsumer.registerInputConsumer();
+        onSystemUiProxySet();
+        onSystemUiFlagsChanged();
+        onAssistantVisibilityChanged();
+
+        // Temporarily disable model preload
+        // new ModelPreload().start(this);
+
+        Utilities.unregisterReceiverSafely(this, mUserUnlockedReceiver);
+    }
+
+    @UiThread
+    private void onSystemUiProxySet() {
+        if (mIsUserUnlocked) {
+            mRecentsModel.setSystemUiProxy(mISystemUiProxy);
+            mOverviewInteractionState.setSystemUiProxy(mISystemUiProxy);
+        }
+    }
+
+    @UiThread
+    private void onSystemUiFlagsChanged() {
+        if (mIsUserUnlocked) {
+            mOverviewInteractionState.setSystemUiStateFlags(mSystemUiStateFlags);
+            mOverviewComponentObserver.onSystemUiStateChanged(mSystemUiStateFlags);
+        }
+    }
+
+    @UiThread
+    private void onAssistantVisibilityChanged() {
+        if (mIsUserUnlocked) {
+            mOverviewComponentObserver.getActivityControlHelper().onAssistantVisibilityChanged(
+                    mLastAssistantVisibility);
+        }
+    }
+
+    @Override
+    public void onDestroy() {
+        if (mIsUserUnlocked) {
+            mInputConsumer.unregisterInputConsumer();
+            mOverviewComponentObserver.onDestroy();
+        }
+        disposeEventHandlers();
+        if (mMode.hasGestures) {
+            getSystemService(DisplayManager.class).unregisterDisplayListener(this);
+        }
+
+        sConnected = false;
+        Utilities.unregisterReceiverSafely(this, mUserUnlockedReceiver);
+        SysUINavigationMode.INSTANCE.get(this).removeModeChangeListener(this);
+        mExclusionListener.unregister();
+
+        super.onDestroy();
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        Log.d(TAG, "Touch service connected");
+        return mMyBinder;
+    }
+
+    private void onInputEvent(InputEvent ev) {
+        if (!(ev instanceof MotionEvent)) {
+            Log.e(TAG, "Unknown event " + ev);
+            return;
+        }
+        MotionEvent event = (MotionEvent) ev;
+        if (event.getAction() == ACTION_DOWN) {
+            if (mSwipeTouchRegion.contains(event.getX(), event.getY())) {
+                boolean useSharedState = mConsumer.useSharedSwipeState();
+                mConsumer.onConsumerAboutToBeSwitched();
+                mConsumer = newConsumer(useSharedState, event);
+                mUncheckedConsumer = mConsumer;
+            } else if (mIsUserUnlocked && mMode == Mode.NO_BUTTON
+                    && canTriggerAssistantAction(event)) {
+                // Do not change mConsumer as if there is an ongoing QuickSwitch gesture, we should
+                // not interrupt it. QuickSwitch assumes that interruption can only happen if the
+                // next gesture is also quick switch.
+                mUncheckedConsumer =
+                        new AssistantTouchConsumer(this, mISystemUiProxy,
+                                mOverviewComponentObserver.getActivityControlHelper(),
+                                InputConsumer.NO_OP, mInputMonitorCompat);
+            } else {
+                mUncheckedConsumer = InputConsumer.NO_OP;
+            }
+        }
+        mUncheckedConsumer.onMotionEvent(event);
+    }
+
+    private boolean validSystemUiFlags() {
+        return (mSystemUiStateFlags & SYSUI_STATE_NAV_BAR_HIDDEN) == 0
+                && (mSystemUiStateFlags & SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED) == 0
+                && ((mSystemUiStateFlags & SYSUI_STATE_HOME_DISABLED) == 0
+                        || (mSystemUiStateFlags & SYSUI_STATE_OVERVIEW_DISABLED) == 0);
+    }
+
+    private boolean canTriggerAssistantAction(MotionEvent ev) {
+        return mAssistantAvailable
+                && !QuickStepContract.isAssistantGestureDisabled(mSystemUiStateFlags)
+                && (mAssistantLeftRegion.contains(ev.getX(), ev.getY()) ||
+                    mAssistantRightRegion.contains(ev.getX(), ev.getY()))
+                && !ActivityManagerWrapper.getInstance().isLockToAppActive();
+    }
+
+    private InputConsumer newConsumer(boolean useSharedState, MotionEvent event) {
+        boolean isInValidSystemUiState = validSystemUiFlags();
+
+        if (!mIsUserUnlocked) {
+            if (isInValidSystemUiState) {
+                // 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).
+                return createDeviceLockedInputConsumer(mAM.getRunningTask(0));
+            } else {
+                return mResetGestureInputConsumer;
+            }
+        }
+
+        // When using sharedState, bypass systemState check as this is a followup gesture and the
+        // first gesture started in a valid system state.
+        InputConsumer base = isInValidSystemUiState || useSharedState
+                ? newBaseConsumer(useSharedState, event) : mResetGestureInputConsumer;
+        if (mMode == Mode.NO_BUTTON) {
+            final ActivityControlHelper activityControl =
+                    mOverviewComponentObserver.getActivityControlHelper();
+            if (canTriggerAssistantAction(event)) {
+                base = new AssistantTouchConsumer(this, mISystemUiProxy, activityControl, base,
+                        mInputMonitorCompat);
+            }
+
+            if ((mSystemUiStateFlags & SYSUI_STATE_SCREEN_PINNING) != 0) {
+                // 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 = new ScreenPinnedInputConsumer(this, mISystemUiProxy, activityControl);
+            }
+
+            if ((mSystemUiStateFlags & SYSUI_STATE_A11Y_BUTTON_CLICKABLE) != 0) {
+                base = new AccessibilityInputConsumer(this, mISystemUiProxy,
+                        (mSystemUiStateFlags & SYSUI_STATE_A11Y_BUTTON_LONG_CLICKABLE) != 0, base,
+                        mInputMonitorCompat, mSwipeTouchRegion);
+            }
+        } else {
+            if ((mSystemUiStateFlags & SYSUI_STATE_SCREEN_PINNING) != 0) {
+                base = mResetGestureInputConsumer;
+            }
+        }
+        return base;
+    }
+
+    private InputConsumer newBaseConsumer(boolean useSharedState, MotionEvent event) {
+        final RunningTaskInfo runningTaskInfo = mAM.getRunningTask(0);
+        if (!useSharedState) {
+            sSwipeSharedState.clearAllState(false /* finishAnimation */);
+        }
+        if ((mSystemUiStateFlags & SYSUI_STATE_STATUS_BAR_KEYGUARD_SHOWING_OCCLUDED) != 0) {
+            // This handles apps showing over the lockscreen (e.g. camera)
+            return createDeviceLockedInputConsumer(runningTaskInfo);
+        }
+
+        final ActivityControlHelper activityControl =
+                mOverviewComponentObserver.getActivityControlHelper();
+
+        if (runningTaskInfo == null && !sSwipeSharedState.goingToLauncher
+                && !sSwipeSharedState.recentsAnimationFinishInterrupted) {
+            return mResetGestureInputConsumer;
+        } else if (sSwipeSharedState.recentsAnimationFinishInterrupted) {
+            // If the finish animation was interrupted, then continue using the other activity input
+            // consumer but with the next task as the running task
+            RunningTaskInfo info = new RunningTaskInfo();
+            info.id = sSwipeSharedState.nextRunningTaskId;
+            return createOtherActivityInputConsumer(event, info);
+        } else if (sSwipeSharedState.goingToLauncher || activityControl.isResumed()) {
+            return createOverviewInputConsumer(event);
+        } else if (ENABLE_QUICKSTEP_LIVE_TILE && activityControl.isInLiveTileMode()) {
+            return createOverviewInputConsumer(event);
+        } else if (mGestureBlockingActivity != null && runningTaskInfo != null
+                && mGestureBlockingActivity.equals(runningTaskInfo.topActivity)) {
+            return mResetGestureInputConsumer;
+        } else if (mMode == Mode.NO_BUTTON && !mOverviewComponentObserver.isHomeAndOverviewSame()) {
+            return new FallbackNoButtonInputConsumer(this, activityControl,
+                    mInputMonitorCompat, sSwipeSharedState, mSwipeTouchRegion,
+                    mOverviewComponentObserver, disableHorizontalSwipe(event), runningTaskInfo);
+        } else {
+            return createOtherActivityInputConsumer(event, runningTaskInfo);
+        }
+    }
+
+    private boolean disableHorizontalSwipe(MotionEvent event) {
+        // mExclusionRegion can change on binder thread, use a local instance here.
+        Region exclusionRegion = mExclusionRegion;
+        return mMode == Mode.NO_BUTTON && exclusionRegion != null
+                && exclusionRegion.contains((int) event.getX(), (int) event.getY());
+    }
+
+    private OtherActivityInputConsumer createOtherActivityInputConsumer(MotionEvent event,
+            RunningTaskInfo runningTaskInfo) {
+        final ActivityControlHelper activityControl =
+                mOverviewComponentObserver.getActivityControlHelper();
+        boolean shouldDefer = activityControl.deferStartingActivity(mActiveNavBarRegion, event);
+
+        return new OtherActivityInputConsumer(this, runningTaskInfo, mRecentsModel,
+                mOverviewComponentObserver.getOverviewIntent(), activityControl,
+                shouldDefer, mOverviewCallbacks, mInputConsumer, this::onConsumerInactive,
+                sSwipeSharedState, mInputMonitorCompat, mSwipeTouchRegion,
+                disableHorizontalSwipe(event));
+    }
+
+    private InputConsumer createDeviceLockedInputConsumer(RunningTaskInfo taskInfo) {
+        if (mMode == Mode.NO_BUTTON && taskInfo != null) {
+            return new DeviceLockedInputConsumer(this, sSwipeSharedState, mInputMonitorCompat,
+                    mSwipeTouchRegion, taskInfo.taskId);
+        } else {
+            return mResetGestureInputConsumer;
+        }
+    }
+
+    public InputConsumer createOverviewInputConsumer(MotionEvent event) {
+        final ActivityControlHelper activityControl =
+                mOverviewComponentObserver.getActivityControlHelper();
+        BaseDraggingActivity activity = activityControl.getCreatedActivity();
+        if (activity == null) {
+            return mResetGestureInputConsumer;
+        }
+
+        if (activity.getRootView().hasWindowFocus() || sSwipeSharedState.goingToLauncher) {
+            return new OverviewInputConsumer(activity, mInputMonitorCompat,
+                    false /* startingInActivityBounds */);
+        } else {
+            return new OverviewWithoutFocusInputConsumer(this, mInputMonitorCompat,
+                    disableHorizontalSwipe(event));
+        }
+    }
+
+    /**
+     * To be called by the consumer when it's no longer active.
+     */
+    private void onConsumerInactive(InputConsumer caller) {
+        if (mConsumer == caller) {
+            mConsumer = mResetGestureInputConsumer;
+            mUncheckedConsumer = mConsumer;
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/WindowTransformSwipeHandler.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/WindowTransformSwipeHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa2632b810cb5444522320e0d96d8b24769ef326
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/WindowTransformSwipeHandler.java
@@ -0,0 +1,1383 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_OVERVIEW_DISABLED;
+import static foundation.e.blisslauncher.core.Flags.ENABLE_QUICKSTEP_LIVE_TILE;
+import static foundation.e.blisslauncher.core.Flags.QUICKSTEP_SPRINGS;
+import static foundation.e.blisslauncher.core.Utilities.SINGLE_FRAME_MS;
+import static foundation.e.blisslauncher.core.Utilities.postAsyncCallback;
+import static foundation.e.blisslauncher.features.test.BaseActivity.INVISIBLE_BY_STATE_HANDLER;
+import static foundation.e.blisslauncher.features.test.BaseActivity.STATE_HANDLER_INVISIBILITY_FLAGS;
+import static foundation.e.blisslauncher.features.test.SystemUiController.UI_STATE_OVERVIEW;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.ACCEL_1_5;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.DEACCEL;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.OVERSHOOT_1_2;
+import static foundation.e.blisslauncher.quickstep.ActivityControlHelper.AnimationFactory.ShelfAnimState.HIDE;
+import static foundation.e.blisslauncher.quickstep.ActivityControlHelper.AnimationFactory.ShelfAnimState.PEEK;
+import static foundation.e.blisslauncher.quickstep.MultiStateCallback.DEBUG_STATES;
+import static foundation.e.blisslauncher.quickstep.TouchInteractionService.MAIN_THREAD_EXECUTOR;
+import static foundation.e.blisslauncher.quickstep.WindowTransformSwipeHandler.GestureEndTarget.HOME;
+import static foundation.e.blisslauncher.quickstep.WindowTransformSwipeHandler.GestureEndTarget.LAST_TASK;
+import static foundation.e.blisslauncher.quickstep.WindowTransformSwipeHandler.GestureEndTarget.NEW_TASK;
+import static foundation.e.blisslauncher.quickstep.WindowTransformSwipeHandler.GestureEndTarget.RECENTS;
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.animation.TimeInterpolator;
+import android.animation.ValueAnimator;
+import android.annotation.TargetApi;
+import android.app.ActivityManager.RunningTaskInfo;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Point;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.SystemClock;
+import android.view.HapticFeedbackConstants;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnApplyWindowInsetsListener;
+import android.view.ViewTreeObserver.OnDrawListener;
+import android.view.WindowInsets;
+import android.view.WindowManager;
+import android.view.animation.Interpolator;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.UiThread;
+import com.android.systemui.shared.recents.model.ThumbnailData;
+import com.android.systemui.shared.system.InputConsumerController;
+import com.android.systemui.shared.system.LatencyTrackerCompat;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat;
+import com.android.systemui.shared.system.WindowCallbacksCompat;
+import foundation.e.blisslauncher.BlissLauncher;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.features.test.TraceHelper;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.features.test.anim.AnimationSuccessListener;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+import foundation.e.blisslauncher.features.test.anim.Interpolators;
+import foundation.e.blisslauncher.features.test.graphics.RotationMode;
+import foundation.e.blisslauncher.quickstep.ActivityControlHelper.ActivityInitListener;
+import foundation.e.blisslauncher.quickstep.ActivityControlHelper.AnimationFactory;
+import foundation.e.blisslauncher.quickstep.ActivityControlHelper.AnimationFactory.ShelfAnimState;
+import foundation.e.blisslauncher.quickstep.ActivityControlHelper.HomeAnimationFactory;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode.Mode;
+import foundation.e.blisslauncher.quickstep.inputconsumers.InputConsumer;
+import foundation.e.blisslauncher.quickstep.inputconsumers.OverviewInputConsumer;
+import foundation.e.blisslauncher.quickstep.util.ClipAnimationHelper;
+import foundation.e.blisslauncher.quickstep.util.RectFSpringAnim;
+import foundation.e.blisslauncher.quickstep.util.RemoteAnimationTargetSet;
+import foundation.e.blisslauncher.quickstep.util.SwipeAnimationTargetSet;
+import foundation.e.blisslauncher.quickstep.views.LiveTileOverlay;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+
+@TargetApi(Build.VERSION_CODES.O)
+public class WindowTransformSwipeHandler<T extends BaseDraggingActivity>
+        implements SwipeAnimationTargetSet.SwipeAnimationListener, OnApplyWindowInsetsListener {
+    private static final String TAG = WindowTransformSwipeHandler.class.getSimpleName();
+
+    private static final Rect TEMP_RECT = new Rect();
+
+    private static final String[] STATE_NAMES = DEBUG_STATES ? new String[16] : null;
+
+    private static int getFlagForIndex(int index, String name) {
+        if (DEBUG_STATES) {
+            STATE_NAMES[index] = name;
+        }
+        return 1 << index;
+    }
+
+    // Launcher UI related states
+    private static final int STATE_LAUNCHER_PRESENT = getFlagForIndex(0, "STATE_LAUNCHER_PRESENT");
+    private static final int STATE_LAUNCHER_STARTED = getFlagForIndex(1, "STATE_LAUNCHER_STARTED");
+    private static final int STATE_LAUNCHER_DRAWN = getFlagForIndex(2, "STATE_LAUNCHER_DRAWN");
+
+    // Internal initialization states
+    private static final int STATE_APP_CONTROLLER_RECEIVED =
+            getFlagForIndex(3, "STATE_APP_CONTROLLER_RECEIVED");
+
+    // Interaction finish states
+    private static final int STATE_SCALED_CONTROLLER_HOME =
+            getFlagForIndex(4, "STATE_SCALED_CONTROLLER_HOME");
+    private static final int STATE_SCALED_CONTROLLER_RECENTS =
+            getFlagForIndex(5, "STATE_SCALED_CONTROLLER_RECENTS");
+
+    private static final int STATE_HANDLER_INVALIDATED =
+            getFlagForIndex(6, "STATE_HANDLER_INVALIDATED");
+    private static final int STATE_GESTURE_STARTED =
+            getFlagForIndex(7, "STATE_GESTURE_STARTED");
+    private static final int STATE_GESTURE_CANCELLED =
+            getFlagForIndex(8, "STATE_GESTURE_CANCELLED");
+    private static final int STATE_GESTURE_COMPLETED =
+            getFlagForIndex(9, "STATE_GESTURE_COMPLETED");
+
+    private static final int STATE_CAPTURE_SCREENSHOT =
+            getFlagForIndex(10, "STATE_CAPTURE_SCREENSHOT");
+    private static final int STATE_SCREENSHOT_CAPTURED =
+            getFlagForIndex(11, "STATE_SCREENSHOT_CAPTURED");
+    private static final int STATE_SCREENSHOT_VIEW_SHOWN =
+            getFlagForIndex(12, "STATE_SCREENSHOT_VIEW_SHOWN");
+
+    private static final int STATE_RESUME_LAST_TASK =
+            getFlagForIndex(13, "STATE_RESUME_LAST_TASK");
+    private static final int STATE_START_NEW_TASK =
+            getFlagForIndex(14, "STATE_START_NEW_TASK");
+    private static final int STATE_CURRENT_TASK_FINISHED =
+            getFlagForIndex(15, "STATE_CURRENT_TASK_FINISHED");
+
+    private static final int LAUNCHER_UI_STATES =
+            STATE_LAUNCHER_PRESENT | STATE_LAUNCHER_DRAWN | STATE_LAUNCHER_STARTED;
+
+    public enum GestureEndTarget {
+        HOME(1, STATE_SCALED_CONTROLLER_HOME | STATE_CAPTURE_SCREENSHOT, true, false,
+            false),
+
+        RECENTS(1, STATE_SCALED_CONTROLLER_RECENTS | STATE_CAPTURE_SCREENSHOT
+                | STATE_SCREENSHOT_VIEW_SHOWN, true, false, true),
+
+        NEW_TASK(0, STATE_START_NEW_TASK | STATE_CAPTURE_SCREENSHOT, false, true,
+                true),
+
+        LAST_TASK(0, STATE_RESUME_LAST_TASK, false, true, false);
+
+        GestureEndTarget(float endShift, int endState, boolean isLauncher, boolean canBeContinued,
+            boolean recentsAttachedToAppWindow) {
+            this.endShift = endShift;
+            this.endState = endState;
+            this.isLauncher = isLauncher;
+            this.canBeContinued = canBeContinued;
+            this.recentsAttachedToAppWindow = recentsAttachedToAppWindow;
+        }
+
+        /** 0 is app, 1 is overview */
+        public final float endShift;
+        /** The state to apply when we reach this final target */
+        public final int endState;
+        /** Whether the target is in the launcher activity */
+        public final boolean isLauncher;
+        /** Whether the user can start a new gesture while this one is finishing */
+        public final boolean canBeContinued;
+        /** Whether RecentsView should be attached to the window as we animate to this target */
+        public final boolean recentsAttachedToAppWindow;
+    }
+
+    public static final long MAX_SWIPE_DURATION = 350;
+    public static final long MIN_SWIPE_DURATION = 80;
+    public static final long MIN_OVERSHOOT_DURATION = 120;
+
+    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 String SCREENSHOT_CAPTURED_EVT = "ScreenshotCaptured";
+
+    private static final long SHELF_ANIM_DURATION = 240;
+    public static final long RECENTS_ATTACH_DURATION = 300;
+
+    // Start resisting when swiping past this factor of mTransitionDragLength.
+    private static final float DRAG_LENGTH_FACTOR_START_PULLBACK = 1.4f;
+    // This is how far down we can scale down, where 0f is full screen and 1f is recents.
+    private static final float DRAG_LENGTH_FACTOR_MAX_PULLBACK = 1.8f;
+    private static final Interpolator PULLBACK_INTERPOLATOR = DEACCEL;
+
+    /**
+     * 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;
+
+    private final ClipAnimationHelper mClipAnimationHelper;
+    private final ClipAnimationHelper.TransformParams mTransformParams;
+
+    private Runnable mGestureEndCallback;
+    private GestureEndTarget mGestureEndTarget;
+    // Either RectFSpringAnim (if animating home) or ObjectAnimator (from mCurrentShift) otherwise
+    private RunningWindowAnim mRunningWindowAnim;
+    private boolean mIsShelfPeeking;
+    private VariantDeviceProfile mDp;
+    // The distance needed to drag to reach the task size in recents.
+    private int mTransitionDragLength;
+    // How much further we can drag past recents, as a factor of mTransitionDragLength.
+    private float mDragLengthFactor = 1;
+
+    // Shift in the range of [0, 1].
+    // 0 => preview snapShot is completely visible, and hotseat is completely translated down
+    // 1 => preview snapShot is completely aligned with the recents view and hotseat is completely
+    // visible.
+    private final AnimatedFloat mCurrentShift = new AnimatedFloat(this::updateFinalShift);
+    private boolean mContinuingLastGesture;
+    // To avoid UI jump when gesture is started, we offset the animation by the threshold.
+    private float mShiftAtGestureStart = 0;
+
+    private final Handler mMainThreadHandler = MAIN_THREAD_EXECUTOR.getHandler();
+
+    private final Context mContext;
+    private final ActivityControlHelper<T> mActivityControlHelper;
+    private final ActivityInitListener mActivityInitListener;
+
+    private final Mode mMode;
+
+    private final int mRunningTaskId;
+    private ThumbnailData mTaskSnapshot;
+
+    private MultiStateCallback mStateCallback;
+    // Used to control launcher components throughout the swipe gesture.
+    private AnimatorPlaybackController mLauncherTransitionController;
+    private boolean mHasLauncherTransitionControllerStarted;
+
+    private T mActivity;
+    private RecentsView mRecentsView;
+    private AnimationFactory mAnimationFactory = (t) -> { };
+    private LiveTileOverlay mLiveTileOverlay = new LiveTileOverlay();
+
+    private boolean mCanceled;
+    private boolean mWasLauncherAlreadyVisible;
+    private int mFinishingRecentsAnimationForNewTaskId = -1;
+
+    private boolean mPassedOverviewThreshold;
+    private boolean mGestureStarted;
+    private PointF mDownPos;
+    private boolean mIsLikelyToStartNewTask;
+
+    private final RecentsAnimationWrapper mRecentsAnimationWrapper;
+
+    private final long mTouchTimeMs;
+    private long mLauncherFrameDrawnTime;
+
+    public WindowTransformSwipeHandler(RunningTaskInfo runningTaskInfo, Context context,
+            long touchTimeMs, ActivityControlHelper<T> controller, boolean continuingLastGesture,
+            InputConsumerController inputConsumer) {
+        mContext = context;
+        mRunningTaskId = runningTaskInfo.id;
+        mTouchTimeMs = touchTimeMs;
+        mActivityControlHelper = controller;
+        mActivityInitListener = mActivityControlHelper
+                .createActivityInitListener(this::onActivityInit);
+        mContinuingLastGesture = continuingLastGesture;
+        mRecentsAnimationWrapper = new RecentsAnimationWrapper(inputConsumer,
+                this::createNewInputProxyHandler);
+        mClipAnimationHelper = new ClipAnimationHelper(context);
+        mTransformParams = new ClipAnimationHelper.TransformParams();
+
+        mMode = SysUINavigationMode.getMode(context);
+        initStateCallbacks();
+
+        VariantDeviceProfile dp = BlissLauncher.getApplication(context).getInvariantDeviceProfile().getDeviceProfile(context);
+        initTransitionEndpoints(dp);
+    }
+
+    private void initStateCallbacks() {
+        mStateCallback = new MultiStateCallback(STATE_NAMES);
+
+        mStateCallback.addCallback(STATE_LAUNCHER_PRESENT | STATE_GESTURE_STARTED,
+                this::onLauncherPresentAndGestureStarted);
+
+        mStateCallback.addCallback(STATE_LAUNCHER_DRAWN | STATE_GESTURE_STARTED,
+                this::initializeLauncherAnimationController);
+
+        mStateCallback.addCallback(STATE_LAUNCHER_PRESENT | STATE_LAUNCHER_DRAWN,
+                this::launcherFrameDrawn);
+
+        mStateCallback.addCallback(STATE_LAUNCHER_PRESENT | STATE_LAUNCHER_STARTED
+                        | STATE_GESTURE_CANCELLED,
+                this::resetStateForAnimationCancel);
+
+        mStateCallback.addCallback(STATE_LAUNCHER_STARTED | STATE_APP_CONTROLLER_RECEIVED,
+                this::sendRemoteAnimationsToAnimationFactory);
+
+        mStateCallback.addCallback(STATE_RESUME_LAST_TASK | STATE_APP_CONTROLLER_RECEIVED,
+                this::resumeLastTask);
+        mStateCallback.addCallback(STATE_START_NEW_TASK | STATE_SCREENSHOT_CAPTURED,
+                this::startNewTask);
+
+        mStateCallback.addCallback(STATE_LAUNCHER_PRESENT | STATE_APP_CONTROLLER_RECEIVED
+                        | STATE_LAUNCHER_DRAWN | STATE_CAPTURE_SCREENSHOT,
+                this::switchToScreenshot);
+
+        mStateCallback.addCallback(STATE_SCREENSHOT_CAPTURED | STATE_GESTURE_COMPLETED
+                        | STATE_SCALED_CONTROLLER_RECENTS,
+                this::finishCurrentTransitionToRecents);
+
+        mStateCallback.addCallback(STATE_SCREENSHOT_CAPTURED | STATE_GESTURE_COMPLETED
+                        | STATE_SCALED_CONTROLLER_HOME,
+                this::finishCurrentTransitionToHome);
+        mStateCallback.addCallback(STATE_SCALED_CONTROLLER_HOME | STATE_CURRENT_TASK_FINISHED,
+                this::reset);
+
+        mStateCallback.addCallback(STATE_LAUNCHER_PRESENT | STATE_APP_CONTROLLER_RECEIVED
+                        | STATE_LAUNCHER_DRAWN | STATE_SCALED_CONTROLLER_RECENTS
+                        | STATE_CURRENT_TASK_FINISHED | STATE_GESTURE_COMPLETED
+                        | STATE_GESTURE_STARTED,
+                this::setupLauncherUiAfterSwipeUpToRecentsAnimation);
+
+        mStateCallback.addCallback(STATE_HANDLER_INVALIDATED, this::invalidateHandler);
+        mStateCallback.addCallback(STATE_LAUNCHER_PRESENT | STATE_HANDLER_INVALIDATED,
+                this::invalidateHandlerWithLauncher);
+        mStateCallback.addCallback(STATE_HANDLER_INVALIDATED | STATE_RESUME_LAST_TASK,
+                this::notifyTransitionCancelled);
+
+        mStateCallback.addCallback(STATE_APP_CONTROLLER_RECEIVED | STATE_GESTURE_STARTED,
+                mRecentsAnimationWrapper::enableInputConsumer);
+
+        if (!ENABLE_QUICKSTEP_LIVE_TILE) {
+            mStateCallback.addChangeHandler(STATE_APP_CONTROLLER_RECEIVED | STATE_LAUNCHER_PRESENT
+                            | STATE_SCREENSHOT_VIEW_SHOWN | STATE_CAPTURE_SCREENSHOT,
+                    (b) -> mRecentsView.setRunningTaskHidden(!b));
+        }
+    }
+
+    private void setStateOnUiThread(int stateFlag) {
+        if (Looper.myLooper() == mMainThreadHandler.getLooper()) {
+            mStateCallback.setState(stateFlag);
+        } else {
+            postAsyncCallback(mMainThreadHandler, () -> mStateCallback.setState(stateFlag));
+        }
+    }
+
+    private void initTransitionEndpoints(VariantDeviceProfile dp) {
+        mDp = dp;
+
+        Rect tempRect = new Rect();
+        mTransitionDragLength = mActivityControlHelper.getSwipeUpDestinationAndLength(
+                dp, mContext, tempRect);
+        mClipAnimationHelper.updateTargetRect(tempRect);
+        if (mMode == Mode.NO_BUTTON) {
+            // We can drag all the way to the top of the screen.
+            mDragLengthFactor = (float) dp.getHeightPx() / mTransitionDragLength;
+        }
+    }
+
+    private long getFadeInDuration() {
+        if (mCurrentShift.getCurrentAnimation() != null) {
+            ObjectAnimator anim = mCurrentShift.getCurrentAnimation();
+            long theirDuration = anim.getDuration() - anim.getCurrentPlayTime();
+
+            // TODO: Find a better heuristic
+            return Math.min(MAX_SWIPE_DURATION, Math.max(theirDuration, MIN_SWIPE_DURATION));
+        } else {
+            return MAX_SWIPE_DURATION;
+        }
+    }
+
+    public void initWhenReady() {
+        mActivityInitListener.register();
+    }
+
+    private boolean onActivityInit(final T activity, Boolean alreadyOnHome) {
+        if (mActivity == activity) {
+            return true;
+        }
+        if (mActivity != null) {
+            // The launcher may have been recreated as a result of device rotation.
+            int oldState = mStateCallback.getState() & ~LAUNCHER_UI_STATES;
+            initStateCallbacks();
+            mStateCallback.setState(oldState);
+        }
+        mWasLauncherAlreadyVisible = alreadyOnHome;
+        mActivity = activity;
+        // 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) {
+            mActivity.clearForceInvisibleFlag(STATE_HANDLER_INVISIBILITY_FLAGS);
+        } else {
+            mActivity.addForceInvisibleFlag(STATE_HANDLER_INVISIBILITY_FLAGS);
+        }
+
+        mRecentsView = activity.getOverviewPanel();
+        SyncRtSurfaceTransactionApplierCompat.create(mRecentsView, applier -> {
+            mTransformParams.setSyncTransactionApplier(applier);
+            mRecentsAnimationWrapper.runOnInit(() ->
+                    mRecentsAnimationWrapper.targetSet.addDependentTransactionApplier(applier));
+            });
+
+        mRecentsView.setOnScrollChangeListener((v, scrollX, scrollY, oldScrollX, oldScrollY) -> {
+            if (mGestureEndTarget != HOME) {
+                updateFinalShift();
+            }
+        });
+        mRecentsView.setRecentsAnimationWrapper(mRecentsAnimationWrapper);
+        mRecentsView.setClipAnimationHelper(mClipAnimationHelper);
+        mRecentsView.setLiveTileOverlay(mLiveTileOverlay);
+        mActivity.getRootView().getOverlay().add(mLiveTileOverlay);
+
+        mStateCallback.setState(STATE_LAUNCHER_PRESENT);
+        if (alreadyOnHome) {
+            onLauncherStart(activity);
+        } else {
+            activity.setOnStartCallback(this::onLauncherStart);
+        }
+
+        setupRecentsViewUi();
+        return true;
+    }
+
+    private void onLauncherStart(final T activity) {
+        if (mActivity != activity) {
+            return;
+        }
+        if (mStateCallback.hasStates(STATE_HANDLER_INVALIDATED)) {
+            return;
+        }
+
+        // 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 (mGestureEndTarget != HOME) {
+            Runnable initAnimFactory = () -> {
+                mAnimationFactory = mActivityControlHelper.prepareRecentsUI(mActivity,
+                        mWasLauncherAlreadyVisible, true,
+                        this::onAnimatorPlaybackControllerCreated);
+                maybeUpdateRecentsAttachedState(false /* animate */);
+            };
+            if (mWasLauncherAlreadyVisible) {
+                // Launcher is visible, but might be about to stop. Thus, if we prepare recents
+                // now, it might get overridden by moveToRestState() in onStop(). To avoid this,
+                // wait until the next gesture (and possibly launcher) starts.
+                mStateCallback.addCallback(STATE_GESTURE_STARTED, initAnimFactory);
+            } else {
+                initAnimFactory.run();
+            }
+        }
+
+        if (mWasLauncherAlreadyVisible) {
+            mStateCallback.setState(STATE_LAUNCHER_DRAWN);
+        } else {
+            TraceHelper.beginSection("WTS-init");
+            View dragLayer = activity.getDragLayer();
+            dragLayer.getViewTreeObserver().addOnDrawListener(new OnDrawListener() {
+
+                @Override
+                public void onDraw() {
+                    TraceHelper.endSection("WTS-init", "Launcher frame is drawn");
+                    dragLayer.post(() ->
+                            dragLayer.getViewTreeObserver().removeOnDrawListener(this));
+                    if (activity != mActivity) {
+                        return;
+                    }
+
+                    mStateCallback.setState(STATE_LAUNCHER_DRAWN);
+                }
+            });
+        }
+
+        activity.getRootView().setOnApplyWindowInsetsListener(this);
+        mStateCallback.setState(STATE_LAUNCHER_STARTED);
+    }
+
+    private void onLauncherPresentAndGestureStarted() {
+        // Re-setup the recents UI when gesture starts, as the state could have been changed during
+        // that time by a previous window transition.
+        setupRecentsViewUi();
+
+        notifyGestureStartedAsync();
+    }
+
+    private void setupRecentsViewUi() {
+        if (mContinuingLastGesture) {
+            updateSysUiFlags(mCurrentShift.value);
+            return;
+        }
+        mRecentsView.onGestureAnimationStart(mRunningTaskId);
+    }
+
+    private void launcherFrameDrawn() {
+        mLauncherFrameDrawnTime = SystemClock.uptimeMillis();
+    }
+
+    private void sendRemoteAnimationsToAnimationFactory() {
+        mAnimationFactory.onRemoteAnimationReceived(mRecentsAnimationWrapper.targetSet);
+    }
+
+    private void initializeLauncherAnimationController() {
+        buildAnimationController();
+
+        if (LatencyTrackerCompat.isEnabled(mContext)) {
+            LatencyTrackerCompat.logToggleRecents((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
+        RecentsModel.INSTANCE.get(mContext).getThumbnailCache()
+                .getHighResLoadingState().setVisible(true);
+    }
+
+    private float getTaskCurveScaleForOffsetX(float offsetX, float taskWidth) {
+        float distanceToReachEdge = mDp.getWidthPx() / 2 + taskWidth / 2 +
+                mContext.getResources().getDimensionPixelSize(R.dimen.recents_page_spacing);
+        float interpolation = Math.min(1, offsetX / distanceToReachEdge);
+        return TaskView.getCurveScaleForInterpolation(interpolation);
+    }
+
+    public Consumer<MotionEvent> getRecentsViewDispatcher(RotationMode rotationMode) {
+        return mRecentsView != null ? mRecentsView.getEventDispatcher(rotationMode) : null;
+    }
+
+    @UiThread
+    public void updateDisplacement(float displacement) {
+        // We are moving in the negative x/y direction
+        displacement = -displacement;
+        if (displacement > mTransitionDragLength * mDragLengthFactor && mTransitionDragLength > 0) {
+            mCurrentShift.updateValue(mDragLengthFactor);
+        } else {
+            float translation = Math.max(displacement, 0);
+            float shift = mTransitionDragLength == 0 ? 0 : translation / mTransitionDragLength;
+            if (shift > DRAG_LENGTH_FACTOR_START_PULLBACK) {
+                float pullbackProgress = Utilities.getProgress(shift,
+                        DRAG_LENGTH_FACTOR_START_PULLBACK, mDragLengthFactor);
+                pullbackProgress = PULLBACK_INTERPOLATOR.getInterpolation(pullbackProgress);
+                shift = DRAG_LENGTH_FACTOR_START_PULLBACK + pullbackProgress
+                        * (DRAG_LENGTH_FACTOR_MAX_PULLBACK - DRAG_LENGTH_FACTOR_START_PULLBACK);
+            }
+            mCurrentShift.updateValue(shift);
+        }
+    }
+
+    public void onMotionPauseChanged(boolean isPaused) {
+        setShelfState(isPaused ? PEEK : HIDE, OVERSHOOT_1_2, SHELF_ANIM_DURATION);
+    }
+
+    public void maybeUpdateRecentsAttachedState() {
+        maybeUpdateRecentsAttachedState(true /* animate */);
+    }
+
+    /**
+     * Determines whether to show or hide RecentsView. The window is always
+     * synchronized with its corresponding TaskView in RecentsView, so if
+     * 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.
+     */
+    private void maybeUpdateRecentsAttachedState(boolean animate) {
+        if (mMode != Mode.NO_BUTTON || mRecentsView == null) {
+            return;
+        }
+        RemoteAnimationTargetCompat runningTaskTarget = mRecentsAnimationWrapper.targetSet == null
+                ? null
+                : mRecentsAnimationWrapper.targetSet.findTask(mRunningTaskId);
+        final boolean recentsAttachedToAppWindow;
+        int runningTaskIndex = mRecentsView.getRunningTaskIndex();
+        if (mGestureEndTarget != null) {
+            recentsAttachedToAppWindow = mGestureEndTarget.recentsAttachedToAppWindow;
+        } else if (mContinuingLastGesture
+                && mRecentsView.getRunningTaskIndex() != mRecentsView.getNextPage()) {
+            recentsAttachedToAppWindow = true;
+            animate = false;
+        } else if (runningTaskTarget != null && isNotInRecents(runningTaskTarget)) {
+            // The window is going away so make sure recents is always visible in this case.
+            recentsAttachedToAppWindow = true;
+            animate = false;
+        } else {
+            recentsAttachedToAppWindow = mIsShelfPeeking || mIsLikelyToStartNewTask;
+            if (animate) {
+                // Only animate if an adjacent task view is visible on screen.
+                TaskView adjacentTask1 = mRecentsView.getTaskViewAt(runningTaskIndex + 1);
+                TaskView adjacentTask2 = mRecentsView.getTaskViewAt(runningTaskIndex - 1);
+                float prevTranslationX = mRecentsView.getTranslationX();
+                mRecentsView.setTranslationX(0);
+                animate = (adjacentTask1 != null && adjacentTask1.getGlobalVisibleRect(TEMP_RECT))
+                        || (adjacentTask2 != null && adjacentTask2.getGlobalVisibleRect(TEMP_RECT));
+                mRecentsView.setTranslationX(prevTranslationX);
+            }
+        }
+        mAnimationFactory.setRecentsAttachedToAppWindow(recentsAttachedToAppWindow, animate);
+    }
+
+    public void setIsLikelyToStartNewTask(boolean isLikelyToStartNewTask) {
+        if (mIsLikelyToStartNewTask != isLikelyToStartNewTask) {
+            mIsLikelyToStartNewTask = isLikelyToStartNewTask;
+            maybeUpdateRecentsAttachedState();
+        }
+    }
+
+    @UiThread
+    public void setShelfState(ShelfAnimState shelfState, Interpolator interpolator, long duration) {
+        mAnimationFactory.setShelfState(shelfState, interpolator, duration);
+        boolean wasShelfPeeking = mIsShelfPeeking;
+        mIsShelfPeeking = shelfState == PEEK;
+        if (mIsShelfPeeking != wasShelfPeeking) {
+            maybeUpdateRecentsAttachedState();
+        }
+        if (mRecentsView != null && shelfState.shouldPreformHaptic) {
+            mRecentsView.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY,
+                    HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
+        }
+    }
+
+    private void buildAnimationController() {
+        if (mGestureEndTarget == HOME || mHasLauncherTransitionControllerStarted) {
+            // We don't want a new mLauncherTransitionController if mGestureEndTarget == HOME (it
+            // has its own animation) or if we're already animating the current controller.
+            return;
+        }
+        initTransitionEndpoints(mActivity.getDeviceProfile());
+        mAnimationFactory.createActivityController(mTransitionDragLength);
+    }
+
+    @Override
+    public WindowInsets onApplyWindowInsets(View view, WindowInsets windowInsets) {
+        WindowInsets result = view.onApplyWindowInsets(windowInsets);
+        buildAnimationController();
+        return result;
+    }
+
+    private void onAnimatorPlaybackControllerCreated(AnimatorPlaybackController anim) {
+        mLauncherTransitionController = anim;
+        mLauncherTransitionController.dispatchSetInterpolator(t -> t * mDragLengthFactor);
+        mAnimationFactory.adjustActivityControllerInterpolators();
+        mLauncherTransitionController.dispatchOnStart();
+        updateLauncherTransitionProgress();
+    }
+
+    @UiThread
+    private void updateFinalShift() {
+        float shift = mCurrentShift.value;
+
+        SwipeAnimationTargetSet controller = mRecentsAnimationWrapper.getController();
+        if (controller != null) {
+            float offsetX = mRecentsView == null ? 0 : mRecentsView.getScrollOffset();
+            float offsetScale = getTaskCurveScaleForOffsetX(offsetX,
+                    mClipAnimationHelper.getTargetRect().width());
+            mTransformParams.setProgress(shift).setOffsetX(offsetX).setOffsetScale(offsetScale);
+            mClipAnimationHelper.applyTransform(mRecentsAnimationWrapper.targetSet,
+                    mTransformParams);
+            updateSysUiFlags(shift);
+        }
+
+        if (ENABLE_QUICKSTEP_LIVE_TILE) {
+            if (mRecentsAnimationWrapper.getController() != null) {
+                mLiveTileOverlay.update(mClipAnimationHelper.getCurrentRectWithInsets(),
+                        mClipAnimationHelper.getCurrentCornerRadius());
+            }
+        }
+
+        final boolean passed = mCurrentShift.value >= MIN_PROGRESS_FOR_OVERVIEW;
+        if (passed != mPassedOverviewThreshold) {
+            mPassedOverviewThreshold = passed;
+            if (mRecentsView != null && mMode != Mode.NO_BUTTON) {
+                mRecentsView.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY,
+                    HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
+            }
+        }
+
+        if (mLauncherTransitionController == null || mLauncherTransitionController
+                .getAnimationPlayer().isStarted()) {
+            return;
+        }
+        updateLauncherTransitionProgress();
+    }
+
+    private void updateLauncherTransitionProgress() {
+        if (mGestureEndTarget == HOME) {
+            return;
+        }
+        // Normalize the progress to 0 to 1, as the animation controller will clamp it to that
+        // anyway. The controller mimics the drag length factor by applying it to its interpolators.
+        float progress = mCurrentShift.value / mDragLengthFactor;
+        mLauncherTransitionController.setPlayFraction(
+                progress <= mShiftAtGestureStart || mShiftAtGestureStart >= 1
+                        ? 0 : (progress - mShiftAtGestureStart) / (1 - mShiftAtGestureStart));
+    }
+
+    /**
+     * @param windowProgress 0 == app, 1 == overview
+     */
+    private void updateSysUiFlags(float windowProgress) {
+        if (mRecentsView != null) {
+            TaskView centermostTask = mRecentsView.getTaskViewAt(mRecentsView
+                    .getPageNearestToCenterOfScreen());
+            int centermostTaskFlags = centermostTask == null ? 0
+                    : centermostTask.getThumbnail().getSysUiStatusNavFlags();
+            boolean useHomeScreenFlags = windowProgress > 1 - RecentsView.UPDATE_SYSUI_FLAGS_THRESHOLD;
+            // We will handle the sysui flags based on the centermost task view.
+            mRecentsAnimationWrapper.setWindowThresholdCrossed(centermostTaskFlags != 0
+                    || useHomeScreenFlags);
+            int sysuiFlags = useHomeScreenFlags ? 0 : centermostTaskFlags;
+            mActivity.getSystemUiController().updateUiState(UI_STATE_OVERVIEW, sysuiFlags);
+        }
+    }
+
+    @Override
+    public void onRecentsAnimationStart(SwipeAnimationTargetSet targetSet) {
+        VariantDeviceProfile dp = BlissLauncher.getApplication(mContext).getInvariantDeviceProfile().getDeviceProfile(mContext);
+        final Rect overviewStackBounds;
+        RemoteAnimationTargetCompat runningTaskTarget = targetSet.findTask(mRunningTaskId);
+
+        if (targetSet.minimizedHomeBounds != null && runningTaskTarget != null) {
+            overviewStackBounds = mActivityControlHelper
+                    .getOverviewWindowBounds(targetSet.minimizedHomeBounds, runningTaskTarget);
+            dp = dp.getMultiWindowProfile(mContext, new Point(
+                    targetSet.minimizedHomeBounds.width(), targetSet.minimizedHomeBounds.height()));
+            dp.updateInsets(targetSet.homeContentInsets);
+        } else {
+            if (mActivity != null) {
+                int loc[] = new int[2];
+                View rootView = mActivity.getRootView();
+                rootView.getLocationOnScreen(loc);
+                overviewStackBounds = new Rect(loc[0], loc[1], loc[0] + rootView.getWidth(),
+                        loc[1] + rootView.getHeight());
+            } else {
+                overviewStackBounds = new Rect(0, 0, dp.getWidthPx(), dp.getHeightPx());
+            }
+            // If we are not in multi-window mode, home insets should be same as system insets.
+            dp = dp.copy(mContext);
+            dp.updateInsets(targetSet.homeContentInsets);
+        }
+        dp.updateIsSeascape(mContext.getSystemService(WindowManager.class));
+
+        if (runningTaskTarget != null) {
+            mClipAnimationHelper.updateSource(overviewStackBounds, runningTaskTarget);
+        }
+        mClipAnimationHelper.prepareAnimation(dp, false /* isOpening */);
+        initTransitionEndpoints(dp);
+
+        mRecentsAnimationWrapper.setController(targetSet);
+        setStateOnUiThread(STATE_APP_CONTROLLER_RECEIVED);
+
+        mPassedOverviewThreshold = false;
+    }
+
+    @Override
+    public void onRecentsAnimationCanceled() {
+        mRecentsAnimationWrapper.setController(null);
+        mActivityInitListener.unregister();
+        setStateOnUiThread(STATE_GESTURE_CANCELLED | STATE_HANDLER_INVALIDATED);
+    }
+
+    @UiThread
+    public void onGestureStarted() {
+        notifyGestureStartedAsync();
+        mShiftAtGestureStart = mCurrentShift.value;
+        setStateOnUiThread(STATE_GESTURE_STARTED);
+        mGestureStarted = true;
+    }
+
+    /**
+     * Notifies the launcher that the swipe gesture has started. This can be called multiple times.
+     */
+    @UiThread
+    private void notifyGestureStartedAsync() {
+        final T curActivity = mActivity;
+        if (curActivity != null) {
+            // Once the gesture starts, we can no longer transition home through the button, so
+            // reset the force override of the activity visibility
+            mActivity.clearForceInvisibleFlag(STATE_HANDLER_INVISIBILITY_FLAGS);
+        }
+    }
+
+    /**
+     * Called as a result on ACTION_CANCEL to return the UI to the start state.
+     */
+    @UiThread
+    public void onGestureCancelled() {
+        updateDisplacement(0);
+        setStateOnUiThread(STATE_GESTURE_COMPLETED);
+        handleNormalGestureEnd(0, false, new PointF(), true /* isCancel */);
+    }
+
+    /**
+     * @param endVelocity The velocity in the direction of the nav bar to the middle of the screen.
+     * @param velocity The x and y components of the velocity when the gesture ends.
+     * @param downPos The x and y value of where the gesture started.
+     */
+    @UiThread
+    public void onGestureEnded(float endVelocity, PointF velocity, PointF downPos) {
+        float flingThreshold = mContext.getResources()
+                .getDimension(R.dimen.quickstep_fling_threshold_velocity);
+        boolean isFling = mGestureStarted && Math.abs(endVelocity) > flingThreshold;
+        setStateOnUiThread(STATE_GESTURE_COMPLETED);
+
+        boolean isVelocityVertical = Math.abs(velocity.y) > Math.abs(velocity.x);
+        mDownPos = downPos;
+        handleNormalGestureEnd(endVelocity, isFling, velocity, false /* isCancel */);
+    }
+
+    @UiThread
+    private InputConsumer createNewInputProxyHandler() {
+        endRunningWindowAnim();
+        endLauncherTransitionController();
+        if (!ENABLE_QUICKSTEP_LIVE_TILE) {
+            // Hide the task view, if not already hidden
+            setTargetAlphaProvider(WindowTransformSwipeHandler::getHiddenTargetAlpha);
+        }
+
+        BaseDraggingActivity activity = mActivityControlHelper.getCreatedActivity();
+        return activity == null
+                ? InputConsumer.NO_OP : new OverviewInputConsumer(activity, null, true);
+    }
+
+    private void endRunningWindowAnim() {
+        if (mRunningWindowAnim != null) {
+            mRunningWindowAnim.end();
+        }
+    }
+
+    private GestureEndTarget calculateEndTarget(PointF velocity, float endVelocity, boolean isFling,
+            boolean isCancel) {
+        final GestureEndTarget endTarget;
+        final boolean goingToNewTask;
+        if (mRecentsView != null) {
+            if (!mRecentsAnimationWrapper.hasTargets()) {
+                // 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
+                goingToNewTask = true;
+            } else {
+                final int runningTaskIndex = mRecentsView.getRunningTaskIndex();
+                final int taskToLaunch = mRecentsView.getNextPage();
+                goingToNewTask = runningTaskIndex >= 0 && taskToLaunch != runningTaskIndex;
+            }
+        } else {
+            goingToNewTask = false;
+        }
+        final boolean reachedOverviewThreshold = mCurrentShift.value >= MIN_PROGRESS_FOR_OVERVIEW;
+        if (!isFling) {
+            if (isCancel) {
+                endTarget = LAST_TASK;
+            } else if (mMode == Mode.NO_BUTTON) {
+                if (mIsShelfPeeking) {
+                    endTarget = RECENTS;
+                } else if (goingToNewTask) {
+                    endTarget = NEW_TASK;
+                } else {
+                    endTarget = !reachedOverviewThreshold ? LAST_TASK : HOME;
+                }
+            } else {
+                endTarget = reachedOverviewThreshold && mGestureStarted
+                        ? RECENTS
+                        : goingToNewTask
+                                ? NEW_TASK
+                                : LAST_TASK;
+            }
+        } else {
+            // If swiping at a diagonal, base end target on the faster velocity.
+            boolean isSwipeUp = endVelocity < 0;
+            boolean willGoToNewTaskOnSwipeUp =
+                    goingToNewTask && Math.abs(velocity.x) > Math.abs(endVelocity);
+
+            if (mMode == Mode.NO_BUTTON && isSwipeUp && !willGoToNewTaskOnSwipeUp) {
+                endTarget = HOME;
+            } else if (mMode == Mode.NO_BUTTON && isSwipeUp && !mIsShelfPeeking) {
+                // If swiping at a diagonal, base end target on the faster velocity.
+                endTarget = NEW_TASK;
+            } else if (isSwipeUp) {
+                endTarget = !reachedOverviewThreshold && willGoToNewTaskOnSwipeUp
+                        ? NEW_TASK : RECENTS;
+            } else {
+                endTarget = goingToNewTask ? NEW_TASK : LAST_TASK;
+            }
+        }
+
+        int stateFlags = OverviewInteractionState.INSTANCE.get(mActivity).getSystemUiStateFlags();
+        if ((stateFlags & SYSUI_STATE_OVERVIEW_DISABLED) != 0
+                && (endTarget == RECENTS || endTarget == LAST_TASK)) {
+            return LAST_TASK;
+        }
+        return endTarget;
+    }
+
+    @UiThread
+    private void handleNormalGestureEnd(float endVelocity, boolean isFling, PointF velocity,
+            boolean isCancel) {
+        PointF velocityPxPerMs = new PointF(velocity.x / 1000, velocity.y / 1000);
+        long duration = MAX_SWIPE_DURATION;
+        float currentShift = mCurrentShift.value;
+        final GestureEndTarget endTarget = calculateEndTarget(velocity, endVelocity,
+                isFling, isCancel);
+        float endShift = endTarget.endShift;
+        final float startShift;
+        Interpolator interpolator = DEACCEL;
+        if (!isFling) {
+            long expectedDuration = Math.abs(Math.round((endShift - currentShift)
+                    * MAX_SWIPE_DURATION * SWIPE_DURATION_MULTIPLIER));
+            duration = Math.min(MAX_SWIPE_DURATION, expectedDuration);
+            startShift = currentShift;
+            interpolator = endTarget == RECENTS ? OVERSHOOT_1_2 : DEACCEL;
+        } else {
+            startShift = Utilities.boundToRange(currentShift - velocityPxPerMs.y
+                    * SINGLE_FRAME_MS / mTransitionDragLength, 0, mDragLengthFactor);
+            float minFlingVelocity = mContext.getResources()
+                    .getDimension(R.dimen.quickstep_fling_min_velocity);
+            if (Math.abs(endVelocity) > minFlingVelocity && mTransitionDragLength > 0) {
+                if (endTarget == RECENTS && mMode != Mode.NO_BUTTON) {
+                    Interpolators.OvershootParams overshoot = new Interpolators.OvershootParams(
+                            startShift, endShift, endShift, velocityPxPerMs.y,
+                            mTransitionDragLength);
+                    endShift = overshoot.end;
+                    interpolator = overshoot.interpolator;
+                    duration = Utilities.boundToRange(overshoot.duration, MIN_OVERSHOOT_DURATION,
+                            MAX_SWIPE_DURATION);
+                } else {
+                    float distanceToTravel = (endShift - currentShift) * mTransitionDragLength;
+
+                    // we want the page's snap velocity to approximately match the velocity at
+                    // which the user flings, so we scale the duration by a value near to the
+                    // derivative of the scroll interpolator at zero, ie. 2.
+                    long baseDuration = Math.round(Math.abs(distanceToTravel / velocityPxPerMs.y));
+                    duration = Math.min(MAX_SWIPE_DURATION, 2 * baseDuration);
+
+                    if (endTarget == RECENTS) {
+                        interpolator = OVERSHOOT_1_2;
+                    }
+                }
+            }
+        }
+
+        if (endTarget.isLauncher) {
+            mRecentsAnimationWrapper.enableInputProxy();
+        }
+
+        if (endTarget == HOME) {
+            setShelfState(ShelfAnimState.CANCEL, LINEAR, 0);
+            duration = Math.max(MIN_OVERSHOOT_DURATION, duration);
+        } else if (endTarget == RECENTS) {
+            mLiveTileOverlay.startIconAnimation();
+            if (mRecentsView != null) {
+                int nearestPage = mRecentsView.getPageNearestToCenterOfScreen();
+                if (mRecentsView.getNextPage() != nearestPage) {
+                    // We shouldn't really scroll to the next page when swiping up to recents.
+                    // Only allow settling on the next page if it's nearest to the center.
+                    mRecentsView.snapToPage(nearestPage, Math.toIntExact(duration));
+                }
+                if (mRecentsView.getScroller().getDuration() > MAX_SWIPE_DURATION) {
+                    mRecentsView.snapToPage(mRecentsView.getNextPage(), (int) MAX_SWIPE_DURATION);
+                }
+                duration = Math.max(duration, mRecentsView.getScroller().getDuration());
+            }
+            if (mMode == Mode.NO_BUTTON) {
+                setShelfState(ShelfAnimState.OVERVIEW, interpolator, duration);
+            }
+        } else if (endTarget == NEW_TASK || endTarget == LAST_TASK) {
+            // Let RecentsView handle the scrolling to the task, which we launch in startNewTask()
+            // or resumeLastTask().
+            if (mRecentsView != null) {
+                duration = Math.max(duration, mRecentsView.getScroller().getDuration());
+            }
+        }
+        animateToProgress(startShift, endShift, duration, interpolator, endTarget, velocityPxPerMs);
+    }
+
+    /** 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) {
+        mRecentsAnimationWrapper.runOnInit(() -> animateToProgressInternal(start, end, duration,
+                interpolator, target, velocityPxPerMs));
+    }
+
+    @UiThread
+    private void animateToProgressInternal(float start, float end, long duration,
+            Interpolator interpolator, GestureEndTarget target, PointF velocityPxPerMs) {
+        mGestureEndTarget = target;
+
+        maybeUpdateRecentsAttachedState();
+
+        if (mGestureEndTarget == HOME) {
+            HomeAnimationFactory homeAnimFactory;
+            if (mActivity != null) {
+                homeAnimFactory = mActivityControlHelper.prepareHomeUI(mActivity);
+            } else {
+                homeAnimFactory = new HomeAnimationFactory() {
+                    @NonNull
+                    @Override
+                    public RectF getWindowTargetRect() {
+                        RectF fallbackTarget = new RectF(mClipAnimationHelper.getTargetRect());
+                        Utilities.scaleRectFAboutCenter(fallbackTarget, 0.25f);
+                        return fallbackTarget;
+                    }
+
+                    @NonNull
+                    @Override
+                    public AnimatorPlaybackController createActivityAnimationToHome() {
+                        return AnimatorPlaybackController.wrap(new AnimatorSet(), duration);
+                    }
+                };
+                mStateCallback.addChangeHandler(STATE_LAUNCHER_PRESENT | STATE_HANDLER_INVALIDATED,
+                        isPresent -> mRecentsView.startHome());
+            }
+            RectFSpringAnim windowAnim = createWindowAnimationToHome(start, homeAnimFactory);
+            windowAnim.addAnimatorListener(new AnimationSuccessListener() {
+                @Override
+                public void onAnimationSuccess(Animator animator) {
+                    setStateOnUiThread(target.endState);
+                }
+            });
+            windowAnim.start(velocityPxPerMs);
+            homeAnimFactory.playAtomicAnimation(velocityPxPerMs.y);
+            mRunningWindowAnim = RunningWindowAnim.wrap(windowAnim);
+            mLauncherTransitionController = null;
+        } else {
+            ValueAnimator windowAnim = mCurrentShift.animateToValue(start, end);
+            windowAnim.setDuration(duration).setInterpolator(interpolator);
+            windowAnim.addUpdateListener(valueAnimator -> {
+                if (mRecentsView != null && mRecentsView.getVisibility() != View.VISIBLE) {
+                    // Views typically don't compute scroll when invisible as an optimization,
+                    // but in our case we need to since the window offset depends on the scroll.
+                    mRecentsView.computeScroll();
+                }
+            });
+            windowAnim.addListener(new AnimationSuccessListener() {
+                @Override
+                public void onAnimationSuccess(Animator animator) {
+                    setStateOnUiThread(target.endState);
+                }
+            });
+            windowAnim.start();
+            mRunningWindowAnim = RunningWindowAnim.wrap(windowAnim);
+        }
+        // Always play the entire launcher animation when going home, since it is separate from
+        // the animation that has been controlled thus far.
+        if (mGestureEndTarget == HOME) {
+            start = 0;
+        }
+
+        // We want to use the same interpolator as the window, but need to adjust it to
+        // interpolate over the remaining progress (end - start).
+        TimeInterpolator adjustedInterpolator = Interpolators.mapToProgress(
+                interpolator, start, end);
+        if (mLauncherTransitionController == null) {
+            return;
+        }
+        if (start == end || duration <= 0) {
+            mLauncherTransitionController.dispatchSetInterpolator(t -> end);
+        } else {
+            mLauncherTransitionController.dispatchSetInterpolator(adjustedInterpolator);
+            mAnimationFactory.adjustActivityControllerInterpolators();
+        }
+        mLauncherTransitionController.getAnimationPlayer().setDuration(Math.max(0, duration));
+
+        if (QUICKSTEP_SPRINGS) {
+            mLauncherTransitionController.dispatchOnStartWithVelocity(end, velocityPxPerMs.y);
+        }
+        mLauncherTransitionController.getAnimationPlayer().start();
+        mHasLauncherTransitionControllerStarted = true;
+    }
+
+    /**
+     * 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.
+     */
+    private RectFSpringAnim createWindowAnimationToHome(float startProgress,
+            HomeAnimationFactory homeAnimationFactory) {
+        final RemoteAnimationTargetSet targetSet = mRecentsAnimationWrapper.targetSet;
+        final RectF startRect = new RectF(mClipAnimationHelper.applyTransform(targetSet,
+                mTransformParams.setProgress(startProgress), false /* launcherOnTop */));
+        final RectF targetRect = homeAnimationFactory.getWindowTargetRect();
+
+        final View floatingView = homeAnimationFactory.getFloatingView();
+        RectFSpringAnim anim = new RectFSpringAnim(startRect, targetRect, mActivity.getResources());
+
+        AnimatorPlaybackController homeAnim = homeAnimationFactory.createActivityAnimationToHome();
+
+        // End on a "round-enough" radius so that the shape reveal doesn't have to do too much
+        // rounding at the end of the animation.
+        float startRadius = mClipAnimationHelper.getCurrentCornerRadius();
+        float endRadius = startRect.width() / 6f;
+        // We want the window alpha to be 0 once this threshold is met, so that the
+        // FolderIconView can be seen morphing into the icon shape.
+        final float windowAlphaThreshold = 1f;
+        anim.addOnUpdateListener((currentRect, progress) -> {
+            homeAnim.setPlayFraction(progress);
+
+            float alphaProgress = ACCEL_1_5.getInterpolation(progress);
+            float windowAlpha = Utilities.boundToRange(Utilities.mapToRange(alphaProgress, 0,
+                    windowAlphaThreshold, 1.5f, 0f, LINEAR), 0, 1);
+            mTransformParams.setProgress(progress)
+                    .setCurrentRectAndTargetAlpha(currentRect, windowAlpha);
+            mClipAnimationHelper.applyTransform(targetSet, mTransformParams,
+                    false /* launcherOnTop */);
+
+            updateSysUiFlags(Math.max(progress, mCurrentShift.value));
+        });
+        anim.addAnimatorListener(new AnimationSuccessListener() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+                homeAnim.dispatchOnStart();
+                if (mActivity != null) {
+                    mActivity.getRootView().getOverlay().remove(mLiveTileOverlay);
+                }
+            }
+
+            @Override
+            public void onAnimationSuccess(Animator animator) {
+                homeAnim.getAnimationPlayer().end();
+                if (mRecentsView != null) {
+                    mRecentsView.post(mRecentsView::resetTaskVisuals);
+                }
+                // Make sure recents is in its final state
+                maybeUpdateRecentsAttachedState(false);
+                mActivityControlHelper.onSwipeUpToHomeComplete(mActivity);
+            }
+        });
+        return anim;
+    }
+
+    /**
+     * @return The GestureEndTarget if the gesture has ended, else null.
+     */
+    public @Nullable GestureEndTarget getGestureEndTarget() {
+        return mGestureEndTarget;
+    }
+
+    @UiThread
+    private void resumeLastTask() {
+        mRecentsAnimationWrapper.finish(false /* toRecents */, null);
+        reset();
+    }
+
+    @UiThread
+    private void startNewTask() {
+        // Launch the task user scrolled to (mRecentsView.getNextPage()).
+        if (ENABLE_QUICKSTEP_LIVE_TILE) {
+            // We finish recents animation inside launchTask() when live tile is enabled.
+            mRecentsView.getTaskViewAt(mRecentsView.getNextPage()).launchTask(false /* animate */,
+                    true /* freezeTaskList */);
+        } else {
+            int taskId = mRecentsView.getTaskViewAt(mRecentsView.getNextPage()).getTask().key.id;
+            mFinishingRecentsAnimationForNewTaskId = taskId;
+            mRecentsAnimationWrapper.finish(true /* toRecents */, () -> {
+                if (!mCanceled) {
+                    TaskView nextTask = mRecentsView.getTaskView(taskId);
+                    if (nextTask != null) {
+                        nextTask.launchTask(false /* animate */, true /* freezeTaskList */,
+                                success -> {
+                            if (!success) {
+                                // We couldn't launch the task, so take user to overview so they can
+                                // decide what to do instead of staying in this broken state.
+                                endLauncherTransitionController();
+                                mActivityControlHelper.onLaunchTaskFailed(mActivity);
+                                nextTask.notifyTaskLaunchFailed(TAG);
+                                updateSysUiFlags(1 /* windowProgress == overview */);
+                            } else {
+                                mActivityControlHelper.onLaunchTaskSuccess(mActivity);
+                            }
+                        }, mMainThreadHandler);
+                    }
+                    reset();
+                }
+                mCanceled = false;
+                mFinishingRecentsAnimationForNewTaskId = -1;
+            });
+        }
+    }
+
+    public void reset() {
+        setStateOnUiThread(STATE_HANDLER_INVALIDATED);
+    }
+
+    /**
+     * Cancels any running animation so that the active target can be overriden by a new swipe
+     * handle (in case of quick switch).
+     */
+    public void cancelCurrentAnimation(SwipeSharedState sharedState) {
+        mCanceled = true;
+        mCurrentShift.cancelAnimation();
+        if (mLauncherTransitionController != null && mLauncherTransitionController
+                .getAnimationPlayer().isStarted()) {
+            mLauncherTransitionController.getAnimationPlayer().cancel();
+        }
+
+        if (mFinishingRecentsAnimationForNewTaskId != -1) {
+            // If we are canceling mid-starting a new task, switch to the screenshot since the
+            // recents animation has finished
+            switchToScreenshot();
+            TaskView newRunningTaskView = mRecentsView.getTaskView(
+                    mFinishingRecentsAnimationForNewTaskId);
+            int newRunningTaskId = newRunningTaskView != null
+                    ? newRunningTaskView.getTask().key.id
+                    : -1;
+            mRecentsView.setCurrentTask(newRunningTaskId);
+            sharedState.setRecentsAnimationFinishInterrupted(newRunningTaskId);
+        }
+    }
+
+    private void invalidateHandler() {
+        endRunningWindowAnim();
+
+        if (mGestureEndCallback != null) {
+            mGestureEndCallback.run();
+        }
+
+        mActivityInitListener.unregister();
+        mTaskSnapshot = null;
+    }
+
+    private void invalidateHandlerWithLauncher() {
+        endLauncherTransitionController();
+
+        mRecentsView.onGestureAnimationEnd();
+
+        mActivity.getRootView().setOnApplyWindowInsetsListener(null);
+        mActivity.getRootView().getOverlay().remove(mLiveTileOverlay);
+    }
+
+    private void endLauncherTransitionController() {
+        setShelfState(ShelfAnimState.CANCEL, LINEAR, 0);
+        if (mLauncherTransitionController != null) {
+            mLauncherTransitionController.getAnimationPlayer().end();
+            mLauncherTransitionController = null;
+        }
+    }
+
+    private void notifyTransitionCancelled() {
+        mAnimationFactory.onTransitionCancelled();
+    }
+
+    private void resetStateForAnimationCancel() {
+        boolean wasVisible = mWasLauncherAlreadyVisible || mGestureStarted;
+        mActivityControlHelper.onTransitionCancelled(mActivity, wasVisible);
+
+        // Leave the pending invisible flag, as it may be used by wallpaper open animation.
+        mActivity.clearForceInvisibleFlag(INVISIBLE_BY_STATE_HANDLER);
+    }
+
+    private void switchToScreenshot() {
+        if (ENABLE_QUICKSTEP_LIVE_TILE) {
+            setStateOnUiThread(STATE_SCREENSHOT_CAPTURED);
+        } else if (!mRecentsAnimationWrapper.hasTargets()) {
+            // If there are no targets, then we don't need to capture anything
+            setStateOnUiThread(STATE_SCREENSHOT_CAPTURED);
+        } else {
+            boolean finishTransitionPosted = false;
+            SwipeAnimationTargetSet controller = mRecentsAnimationWrapper.getController();
+            if (controller != null) {
+                // Update the screenshot of the task
+                if (mTaskSnapshot == null) {
+                    mTaskSnapshot = controller.screenshotTask(mRunningTaskId);
+                }
+                final TaskView taskView;
+                if (mGestureEndTarget == HOME) {
+                    // Capture the screenshot before finishing the transition to home to ensure it's
+                    // taken in the correct orientation, but no need to update the thumbnail.
+                    taskView = null;
+                } else {
+                    taskView = mRecentsView.updateThumbnail(mRunningTaskId, mTaskSnapshot);
+                }
+                if (taskView != null && !mCanceled) {
+                    // Defer finishing the animation until the next launcher frame with the
+                    // new thumbnail
+                    finishTransitionPosted = new WindowCallbacksCompat(taskView) {
+
+                        // The number of frames to defer until we actually finish the animation
+                        private int mDeferFrameCount = 2;
+
+                        @Override
+                        public void onPostDraw(Canvas canvas) {
+                            // If we were cancelled after this was attached, do not update
+                            // the state.
+                            if (mCanceled) {
+                                detach();
+                                return;
+                            }
+
+                            if (mDeferFrameCount > 0) {
+                                mDeferFrameCount--;
+                                // Workaround, detach and reattach to invalidate the root node for
+                                // another draw
+                                detach();
+                                attach();
+                                taskView.invalidate();
+                                return;
+                            }
+
+                            setStateOnUiThread(STATE_SCREENSHOT_CAPTURED);
+                            detach();
+                        }
+                    }.attach();
+                }
+            }
+            if (!finishTransitionPosted) {
+                // If we haven't posted a draw callback, set the state immediately.
+                setStateOnUiThread(STATE_SCREENSHOT_CAPTURED);
+            }
+        }
+    }
+
+    private void finishCurrentTransitionToRecents() {
+        if (ENABLE_QUICKSTEP_LIVE_TILE) {
+            setStateOnUiThread(STATE_CURRENT_TASK_FINISHED);
+        } else if (!mRecentsAnimationWrapper.hasTargets()) {
+            // If there are no targets, then there is nothing to finish
+            setStateOnUiThread(STATE_CURRENT_TASK_FINISHED);
+        } else {
+            synchronized (mRecentsAnimationWrapper) {
+                mRecentsAnimationWrapper.finish(true /* toRecents */,
+                        () -> setStateOnUiThread(STATE_CURRENT_TASK_FINISHED));
+            }
+        }
+    }
+
+    private void finishCurrentTransitionToHome() {
+        synchronized (mRecentsAnimationWrapper) {
+            mRecentsAnimationWrapper.finish(true /* toRecents */,
+                    () -> setStateOnUiThread(STATE_CURRENT_TASK_FINISHED),
+                    true /* sendUserLeaveHint */);
+        }
+    }
+
+    private void setupLauncherUiAfterSwipeUpToRecentsAnimation() {
+        endLauncherTransitionController();
+        mActivityControlHelper.onSwipeUpToRecentsComplete(mActivity);
+        mRecentsAnimationWrapper.setCancelWithDeferredScreenshot(true);
+        mRecentsView.onSwipeUpAnimationSuccess();
+
+        RecentsModel.INSTANCE.get(mContext).onOverviewShown(false, TAG);
+        reset();
+    }
+
+    public void setGestureEndCallback(Runnable gestureEndCallback) {
+        mGestureEndCallback = gestureEndCallback;
+    }
+
+    private void setTargetAlphaProvider(
+            BiFunction<RemoteAnimationTargetCompat, Float, Float> provider) {
+        mClipAnimationHelper.setTaskAlphaCallback(provider);
+        updateFinalShift();
+    }
+
+    public static float getHiddenTargetAlpha(RemoteAnimationTargetCompat app, Float expectedAlpha) {
+        if (!isNotInRecents(app)) {
+            return 0;
+        }
+        return expectedAlpha;
+    }
+
+    private static boolean isNotInRecents(RemoteAnimationTargetCompat app) {
+        return app.isNotInRecents
+                || app.activityType == RemoteAnimationTargetCompat.ACTIVITY_TYPE_HOME;
+    }
+
+    private interface RunningWindowAnim {
+        void end();
+
+        static RunningWindowAnim wrap(Animator animator) {
+            return animator::end;
+        }
+
+        static RunningWindowAnim wrap(RectFSpringAnim rectFSpringAnim) {
+            return rectFSpringAnim::end;
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/fallback/FallbackRecentsView.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/fallback/FallbackRecentsView.java
new file mode 100644
index 0000000000000000000000000000000000000000..af7d3a291eb77ec4577313faeb739799baa3603f
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/fallback/FallbackRecentsView.java
@@ -0,0 +1,141 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.fallback;
+
+import static foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils.SCALE_PROPERTY;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.util.AttributeSet;
+import android.util.FloatProperty;
+import android.view.View;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.quickstep.RecentsActivity;
+import foundation.e.blisslauncher.quickstep.util.LayoutUtils;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+
+public class FallbackRecentsView extends RecentsView<RecentsActivity> {
+
+    public static final FloatProperty<FallbackRecentsView> ZOOM_PROGRESS =
+            new FloatProperty<FallbackRecentsView> ("zoomInProgress") {
+
+                @Override
+                public void setValue(FallbackRecentsView view, float value) {
+                    view.setZoomProgress(value);
+                }
+
+                @Override
+                public Float get(FallbackRecentsView view) {
+                    return view.mZoomInProgress;
+                }
+            };
+
+    private float mZoomInProgress = 0;
+    private boolean mInOverviewState = true;
+
+    private float mZoomScale = 1f;
+    private float mZoomTranslationY = 0f;
+
+    public FallbackRecentsView(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public FallbackRecentsView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        setOverviewStateEnabled(true);
+        setOverlayEnabled(true);
+    }
+
+    @Override
+    public void startHome() {
+        mActivity.startHome();
+    }
+
+    @Override
+    public void onViewAdded(View child) {
+        super.onViewAdded(child);
+        updateEmptyMessage();
+    }
+
+    @Override
+    public void onViewRemoved(View child) {
+        super.onViewRemoved(child);
+        updateEmptyMessage();
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        maybeDrawEmptyMessage(canvas);
+        super.draw(canvas);
+    }
+
+    @Override
+    protected void getTaskSize(VariantDeviceProfile dp, Rect outRect) {
+        LayoutUtils.calculateFallbackTaskSize(getContext(), dp, outRect);
+    }
+
+    @Override
+    public boolean shouldUseMultiWindowTaskSizeStrategy() {
+        // Just use the activity task size for multi-window as well.
+        return false;
+    }
+
+    public void resetViewUI() {
+        setZoomProgress(0);
+        resetTaskVisuals();
+    }
+
+    public void setInOverviewState(boolean inOverviewState) {
+        if (mInOverviewState != inOverviewState) {
+            mInOverviewState = inOverviewState;
+            if (mInOverviewState) {
+                resetTaskVisuals();
+            } else {
+                setZoomProgress(1);
+            }
+        }
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        super.onLayout(changed, left, top, right, bottom);
+
+        if (getTaskViewCount() == 0) {
+            mZoomScale = 1f;
+            mZoomTranslationY = 0f;
+        } else {
+            TaskView dummyTask = getTaskViewAt(0);
+            LauncherState.ScaleAndTranslation sat = getTempClipAnimationHelper()
+                    .updateForFullscreenOverview(dummyTask)
+                    .getScaleAndTranslation();
+            mZoomScale = sat.scale;
+            mZoomTranslationY = sat.translationY;
+        }
+
+        setZoomProgress(mZoomInProgress);
+    }
+
+    public void setZoomProgress(float progress) {
+        mZoomInProgress = progress;
+        SCALE_PROPERTY.set(this, Utilities.mapRange(mZoomInProgress, 1, mZoomScale));
+        TRANSLATION_Y.set(this, Utilities.mapRange(mZoomInProgress, 0, mZoomTranslationY));
+        FULLSCREEN_PROGRESS.set(this, mZoomInProgress);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/fallback/RecentsRootView.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/fallback/RecentsRootView.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb3179e33845c4b497d78a6288113661f301e6c1
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/fallback/RecentsRootView.java
@@ -0,0 +1,88 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.fallback;
+
+import android.content.Context;
+import android.graphics.Point;
+import android.util.AttributeSet;
+import android.view.WindowInsets;
+
+import org.jetbrains.annotations.Nullable;
+
+import foundation.e.blisslauncher.features.test.BaseActivity;
+import foundation.e.blisslauncher.features.test.BaseDragLayer;
+import foundation.e.blisslauncher.features.test.TouchController;
+import foundation.e.blisslauncher.quickstep.RecentsActivity;
+
+public class RecentsRootView extends BaseDragLayer<RecentsActivity> {
+
+    private static final int MIN_SIZE = 10;
+    private final RecentsActivity mActivity;
+
+    private final Point mLastKnownSize = new Point(MIN_SIZE, MIN_SIZE);
+
+    public RecentsRootView(Context context, AttributeSet attrs) {
+        super(context, attrs, 1 /* alphaChannelCount */);
+        mActivity = (RecentsActivity) BaseActivity.fromContext(context);
+        setSystemUiVisibility(SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+                | SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                | SYSTEM_UI_FLAG_LAYOUT_STABLE);
+    }
+
+    public Point getLastKnownSize() {
+        return mLastKnownSize;
+    }
+
+    public void setup() {
+        mControllers = new TouchController[] { new RecentsTaskController(mActivity) };
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        // Check size changes before the actual measure, to avoid multiple measure calls.
+        int width = Math.max(MIN_SIZE, MeasureSpec.getSize(widthMeasureSpec));
+        int height = Math.max(MIN_SIZE, MeasureSpec.getSize(heightMeasureSpec));
+        if (mLastKnownSize.x != width || mLastKnownSize.y != height) {
+            mLastKnownSize.set(width, height);
+            mActivity.onRootViewSizeChanged();
+        }
+
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+    }
+
+    @Nullable
+    @Override
+    public WindowInsets onApplyWindowInsets(@Nullable WindowInsets insets) {
+        // Update device profile before notifying the children.
+        mActivity.getDeviceProfile().updateInsets(insets);
+        setInsets(insets);
+        return insets;
+    }
+
+    @Override
+    public void setInsets(WindowInsets insets) {
+        // If the insets haven't changed, this is a no-op. Avoid unnecessary layout caused by
+        // modifying child layout params.
+        if (!insets.equals(getWindowInsets())) {
+            super.setInsets(insets);
+        };
+    }
+
+    public void dispatchInsets() {
+        mActivity.getDeviceProfile().updateInsets(getWindowInsets());
+        super.setInsets(getWindowInsets());
+    }
+}
\ No newline at end of file
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/fallback/RecentsTaskController.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/fallback/RecentsTaskController.java
new file mode 100644
index 0000000000000000000000000000000000000000..83190a9fb796f725314657ef14f8a71356cac1c2
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/fallback/RecentsTaskController.java
@@ -0,0 +1,31 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.fallback;
+
+import foundation.e.blisslauncher.uioverrides.touchcontrollers.TaskViewTouchController;
+import foundation.e.blisslauncher.quickstep.RecentsActivity;
+
+public class RecentsTaskController extends TaskViewTouchController<RecentsActivity> {
+
+    public RecentsTaskController(RecentsActivity activity) {
+        super(activity);
+    }
+
+    @Override
+    protected boolean isRecentsInteractive() {
+        return mActivity.hasWindowFocus();
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/AccessibilityInputConsumer.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/AccessibilityInputConsumer.java
new file mode 100644
index 0000000000000000000000000000000000000000..c95450a5692fc09f4bde2eaa6f381e5ac5fc5c29
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/AccessibilityInputConsumer.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.inputconsumers;
+
+import static android.view.MotionEvent.ACTION_CANCEL;
+import static android.view.MotionEvent.ACTION_DOWN;
+import static android.view.MotionEvent.ACTION_MOVE;
+import static android.view.MotionEvent.ACTION_POINTER_DOWN;
+import static android.view.MotionEvent.ACTION_POINTER_UP;
+import static android.view.MotionEvent.ACTION_UP;
+
+import android.content.Context;
+import android.graphics.RectF;
+import android.os.RemoteException;
+import android.util.Log;
+import android.view.Display;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.ViewConfiguration;
+import com.android.systemui.shared.recents.ISystemUiProxy;
+import com.android.systemui.shared.system.InputMonitorCompat;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.quickstep.util.MotionPauseDetector;
+
+/**
+ * Touch consumer for two finger swipe actions for accessibility actions
+ */
+public class AccessibilityInputConsumer extends DelegateInputConsumer {
+
+    private static final String TAG = "A11yInputConsumer";
+
+    private final ISystemUiProxy mSystemUiProxy;
+    private final VelocityTracker mVelocityTracker;
+    private final MotionPauseDetector mMotionPauseDetector;
+    private final boolean mAllowLongClick;
+    private final RectF mSwipeTouchRegion;
+
+    private final float mMinGestureDistance;
+    private final float mMinFlingVelocity;
+
+    private int mActivePointerId = -1;
+    private float mDownY;
+    private float mTotalY;
+
+    public AccessibilityInputConsumer(Context context, ISystemUiProxy systemUiProxy,
+            boolean allowLongClick, InputConsumer delegate, InputMonitorCompat inputMonitor,
+            RectF swipeTouchRegion) {
+        super(delegate, inputMonitor);
+        mSystemUiProxy = systemUiProxy;
+        mVelocityTracker = VelocityTracker.obtain();
+        mMinGestureDistance = context.getResources()
+                .getDimension(R.dimen.accessibility_gesture_min_swipe_distance);
+        mMinFlingVelocity = ViewConfiguration.get(context).getScaledMinimumFlingVelocity();
+        mSwipeTouchRegion = swipeTouchRegion;
+
+        mMotionPauseDetector = new MotionPauseDetector(context);
+        mAllowLongClick = allowLongClick;
+    }
+
+    @Override
+    public int getType() {
+        return TYPE_ACCESSIBILITY | mDelegate.getType();
+    }
+
+    @Override
+    public void onMotionEvent(MotionEvent ev) {
+        if (mState != STATE_DELEGATE_ACTIVE) {
+            mVelocityTracker.addMovement(ev);
+        }
+
+        switch (ev.getActionMasked()) {
+            case ACTION_DOWN: {
+                break;
+            }
+            case ACTION_POINTER_UP: {
+                if (mState == STATE_ACTIVE) {
+                    int pointerIndex = ev.getActionIndex();
+                    int pointerId = ev.getPointerId(pointerIndex);
+                    if (pointerId == mActivePointerId) {
+                        final int newPointerIdx = pointerIndex == 0 ? 1 : 0;
+
+                        mTotalY += (ev.getY(pointerIndex) - mDownY);
+                        mDownY = ev.getY(newPointerIdx);
+                        mActivePointerId = ev.getPointerId(newPointerIdx);
+                    }
+                }
+                break;
+            }
+            case ACTION_POINTER_DOWN: {
+                if (mState == STATE_INACTIVE) {
+                    int pointerIndex = ev.getActionIndex();
+                    if (mSwipeTouchRegion.contains(ev.getX(pointerIndex), ev.getY(pointerIndex))
+                            && mDelegate.allowInterceptByParent()) {
+                        setActive(ev);
+
+                        mActivePointerId = ev.getPointerId(pointerIndex);
+                        mDownY = ev.getY(pointerIndex);
+                    } else {
+                        mState = STATE_DELEGATE_ACTIVE;
+                    }
+                }
+                break;
+            }
+            case ACTION_MOVE: {
+                if (mState == STATE_ACTIVE && mAllowLongClick) {
+                    int pointerIndex = ev.findPointerIndex(mActivePointerId);
+                    if (pointerIndex == -1) {
+                        break;
+                    }
+
+                    mMotionPauseDetector.addPosition(ev.getY(pointerIndex) - mDownY,
+                            ev.getEventTime());
+                }
+                break;
+            }
+            case ACTION_UP:
+                if (mState == STATE_ACTIVE) {
+                    try {
+                        if (mAllowLongClick && mMotionPauseDetector.isPaused()) {
+                            mSystemUiProxy.notifyAccessibilityButtonLongClicked();
+                        } else {
+                            mTotalY += (ev.getY() - mDownY);
+                            mVelocityTracker.computeCurrentVelocity(1000);
+
+                            if ((-mTotalY) > mMinGestureDistance
+                                    || (-mVelocityTracker.getYVelocity()) > mMinFlingVelocity) {
+                                mSystemUiProxy.notifyAccessibilityButtonClicked(
+                                        Display.DEFAULT_DISPLAY);
+                            }
+                        }
+                    } catch (RemoteException e) {
+                        Log.e(TAG, "Unable to notify accessibility event", e);
+                    }
+                }
+                // Follow through
+            case ACTION_CANCEL: {
+                mVelocityTracker.recycle();
+                mMotionPauseDetector.clear();
+                break;
+            }
+        }
+
+        if (mState != STATE_ACTIVE) {
+            mDelegate.onMotionEvent(ev);
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/AssistantTouchConsumer.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/AssistantTouchConsumer.java
new file mode 100644
index 0000000000000000000000000000000000000000..3af3acef72069d4d29698a74195c4a8de99eb149
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/AssistantTouchConsumer.java
@@ -0,0 +1,278 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.inputconsumers;
+
+import static android.view.MotionEvent.ACTION_CANCEL;
+import static android.view.MotionEvent.ACTION_DOWN;
+import static android.view.MotionEvent.ACTION_MOVE;
+import static android.view.MotionEvent.ACTION_POINTER_DOWN;
+import static android.view.MotionEvent.ACTION_POINTER_UP;
+import static android.view.MotionEvent.ACTION_UP;
+
+import android.animation.ValueAnimator;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.PointF;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.os.SystemClock;
+import android.util.Log;
+import android.view.GestureDetector;
+import android.view.GestureDetector.SimpleOnGestureListener;
+import android.view.HapticFeedbackConstants;
+import android.view.MotionEvent;
+import android.view.ViewConfiguration;
+import com.android.systemui.shared.recents.ISystemUiProxy;
+import com.android.systemui.shared.system.InputMonitorCompat;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.features.test.anim.Interpolators;
+import foundation.e.blisslauncher.quickstep.ActivityControlHelper;
+
+/**
+ * Touch consumer for handling events to launch assistant from launcher
+ */
+public class AssistantTouchConsumer extends DelegateInputConsumer {
+
+    private static final String TAG = "AssistantTouchConsumer";
+    private static final long RETRACT_ANIMATION_DURATION_MS = 300;
+
+    // From //java/com/google/android/apps/gsa/search/shared/util/OpaContract.java.
+    private static final String OPA_BUNDLE_TRIGGER = "triggered_by";
+    // From //java/com/google/android/apps/gsa/assistant/shared/proto/opa_trigger.proto.
+    private static final int OPA_BUNDLE_TRIGGER_DIAG_SWIPE_GESTURE = 83;
+    private static final String INVOCATION_TYPE_KEY = "invocation_type";
+    private static final int INVOCATION_TYPE_GESTURE = 1;
+
+    private final PointF mDownPos = new PointF();
+    private final PointF mLastPos = new PointF();
+    private final PointF mStartDragPos = new PointF();
+
+    private int mActivePointerId = -1;
+    private boolean mPassedSlop;
+    private boolean mLaunchedAssistant;
+    private float mDistance;
+    private float mTimeFraction;
+    private long mDragTime;
+    private float mLastProgress;
+    private int mDirection;
+    private ActivityControlHelper mActivityControlHelper;
+
+    private final float mDistThreshold;
+    private final long mTimeThreshold;
+    private final int mAngleThreshold;
+    private final float mSquaredSlop;
+    private final ISystemUiProxy mSysUiProxy;
+    private final Context mContext;
+    private final GestureDetector mGestureDetector;
+
+    public AssistantTouchConsumer(Context context, ISystemUiProxy systemUiProxy,
+            ActivityControlHelper activityControlHelper, InputConsumer delegate,
+            InputMonitorCompat inputMonitor) {
+        super(delegate, inputMonitor);
+        final Resources res = context.getResources();
+        mContext = context;
+        mSysUiProxy = systemUiProxy;
+        mDistThreshold = res.getDimension(R.dimen.gestures_assistant_drag_threshold);
+        mTimeThreshold = res.getInteger(R.integer.assistant_gesture_min_time_threshold);
+        mAngleThreshold = res.getInteger(R.integer.assistant_gesture_corner_deg_threshold);
+
+        float slop = ViewConfiguration.get(context).getScaledTouchSlop();
+
+        mSquaredSlop = slop * slop;
+        mActivityControlHelper = activityControlHelper;
+
+        mGestureDetector = new GestureDetector(context, new AssistantGestureListener());
+    }
+
+    @Override
+    public int getType() {
+        return TYPE_ASSISTANT | mDelegate.getType();
+    }
+
+    @Override
+    public void onMotionEvent(MotionEvent ev) {
+        // TODO add logging
+        mGestureDetector.onTouchEvent(ev);
+
+        switch (ev.getActionMasked()) {
+            case ACTION_DOWN: {
+                mActivePointerId = ev.getPointerId(0);
+                mDownPos.set(ev.getX(), ev.getY());
+                mLastPos.set(mDownPos);
+                mTimeFraction = 0;
+                break;
+            }
+            case ACTION_POINTER_DOWN: {
+                if (mState != STATE_ACTIVE) {
+                    mState = STATE_DELEGATE_ACTIVE;
+                    break;
+                }
+            }
+            case ACTION_POINTER_UP: {
+                int ptrIdx = ev.getActionIndex();
+                int ptrId = ev.getPointerId(ptrIdx);
+                if (ptrId == mActivePointerId) {
+                    final int newPointerIdx = ptrIdx == 0 ? 1 : 0;
+                    mDownPos.set(
+                        ev.getX(newPointerIdx) - (mLastPos.x - mDownPos.x),
+                        ev.getY(newPointerIdx) - (mLastPos.y - mDownPos.y));
+                    mLastPos.set(ev.getX(newPointerIdx), ev.getY(newPointerIdx));
+                    mActivePointerId = ev.getPointerId(newPointerIdx);
+                }
+                break;
+            }
+            case ACTION_MOVE: {
+                if (mState == STATE_DELEGATE_ACTIVE) {
+                    break;
+                }
+                if (!mDelegate.allowInterceptByParent()) {
+                    mState = STATE_DELEGATE_ACTIVE;
+                    break;
+                }
+                int pointerIndex = ev.findPointerIndex(mActivePointerId);
+                if (pointerIndex == -1) {
+                    break;
+                }
+                mLastPos.set(ev.getX(pointerIndex), ev.getY(pointerIndex));
+
+                if (!mPassedSlop) {
+                    // Normal gesture, ensure we pass the slop before we start tracking the gesture
+                    if (Utilities.squaredHypot(mLastPos.x - mDownPos.x, mLastPos.y - mDownPos.y)
+                            > mSquaredSlop) {
+
+                        mPassedSlop = true;
+                        mStartDragPos.set(mLastPos.x, mLastPos.y);
+                        mDragTime = SystemClock.uptimeMillis();
+
+                        if (isValidAssistantGestureAngle(
+                            mDownPos.x - mLastPos.x, mDownPos.y - mLastPos.y)) {
+                            setActive(ev);
+                        } else {
+                            mState = STATE_DELEGATE_ACTIVE;
+                        }
+                    }
+                } else {
+                    // Movement
+                    mDistance = (float) Math.hypot(mLastPos.x - mStartDragPos.x,
+                        mLastPos.y - mStartDragPos.y);
+                    if (mDistance >= 0) {
+                        final long diff = SystemClock.uptimeMillis() - mDragTime;
+                        mTimeFraction = Math.min(diff * 1f / mTimeThreshold, 1);
+                        updateAssistantProgress();
+                    }
+                }
+                break;
+            }
+            case ACTION_CANCEL:
+            case ACTION_UP:
+                if (mState != STATE_DELEGATE_ACTIVE && !mLaunchedAssistant) {
+                    ValueAnimator animator = ValueAnimator.ofFloat(mLastProgress, 0)
+                        .setDuration(RETRACT_ANIMATION_DURATION_MS);
+                    animator.addUpdateListener(valueAnimator -> {
+                        float progress = (float) valueAnimator.getAnimatedValue();
+                        try {
+
+                            mSysUiProxy.onAssistantProgress(progress);
+                        } catch (RemoteException e) {
+                            Log.w(TAG, "Failed to send SysUI start/send assistant progress: "
+                                + progress, e);
+                        }
+                    });
+                    animator.setInterpolator(Interpolators.DEACCEL_2);
+                    animator.start();
+                }
+                mPassedSlop = false;
+                mState = STATE_INACTIVE;
+                break;
+        }
+
+        if (mState != STATE_ACTIVE) {
+            mDelegate.onMotionEvent(ev);
+        }
+    }
+
+    private void updateAssistantProgress() {
+        if (!mLaunchedAssistant) {
+            mLastProgress = Math.min(mDistance * 1f / mDistThreshold, 1) * mTimeFraction;
+            try {
+                if (mDistance >= mDistThreshold && mTimeFraction >= 1) {
+                    mSysUiProxy.onAssistantGestureCompletion(0);
+                    startAssistantInternal();
+
+                    Bundle args = new Bundle();
+                    args.putInt(OPA_BUNDLE_TRIGGER, OPA_BUNDLE_TRIGGER_DIAG_SWIPE_GESTURE);
+                    args.putInt(INVOCATION_TYPE_KEY, INVOCATION_TYPE_GESTURE);
+                    mSysUiProxy.startAssistant(args);
+                    mLaunchedAssistant = true;
+                } else {
+                    mSysUiProxy.onAssistantProgress(mLastProgress);
+                }
+            } catch (RemoteException e) {
+                Log.w(TAG, "Failed to send SysUI start/send assistant progress: " + mLastProgress,
+                    e);
+            }
+        }
+    }
+
+    private void startAssistantInternal() {
+        BaseDraggingActivity launcherActivity = mActivityControlHelper
+            .getCreatedActivity();
+        if (launcherActivity != null) {
+            launcherActivity.getRootView().performHapticFeedback(
+                13, // HapticFeedbackConstants.GESTURE_END
+                HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
+        }
+    }
+
+    /**
+     * Determine if angle is larger than threshold for assistant detection
+     */
+    private boolean isValidAssistantGestureAngle(float deltaX, float deltaY) {
+        float angle = (float) Math.toDegrees(Math.atan2(deltaY, deltaX));
+        // normalize so that angle is measured clockwise from horizontal in the bottom right corner
+        // and counterclockwise from horizontal in the bottom left corner
+        angle = angle > 90 ? 180 - angle : angle;
+        return (angle > mAngleThreshold && angle < 90);
+    }
+
+    private class AssistantGestureListener extends SimpleOnGestureListener {
+        @Override
+        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
+            if (isValidAssistantGestureAngle(velocityX, -velocityY)
+                && !mLaunchedAssistant && mState != STATE_DELEGATE_ACTIVE) {
+                mLastProgress = 1;
+                try {
+                    mSysUiProxy.onAssistantGestureCompletion(
+                        (float) Math.sqrt(velocityX * velocityX + velocityY * velocityY));
+                    startAssistantInternal();
+
+                    Bundle args = new Bundle();
+                    args.putInt(INVOCATION_TYPE_KEY, INVOCATION_TYPE_GESTURE);
+                    mSysUiProxy.startAssistant(args);
+                    mLaunchedAssistant = true;
+                } catch (RemoteException e) {
+                    Log.w(TAG,
+                        "Failed to send SysUI start/send assistant progress: " + mLastProgress,
+                        e);
+                }
+            }
+            return true;
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/DelegateInputConsumer.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/DelegateInputConsumer.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f9d932d203d55a04632d59d72004aa8769b7a1c
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/DelegateInputConsumer.java
@@ -0,0 +1,49 @@
+package foundation.e.blisslauncher.quickstep.inputconsumers;
+
+import android.view.MotionEvent;
+
+import com.android.systemui.shared.system.InputMonitorCompat;
+
+public abstract class DelegateInputConsumer implements InputConsumer {
+
+    protected static final int STATE_INACTIVE = 0;
+    protected static final int STATE_ACTIVE = 1;
+    protected static final int STATE_DELEGATE_ACTIVE = 2;
+
+    protected final InputConsumer mDelegate;
+    protected final InputMonitorCompat mInputMonitor;
+
+    protected int mState;
+
+    public DelegateInputConsumer(InputConsumer delegate, InputMonitorCompat inputMonitor) {
+        mDelegate = delegate;
+        mInputMonitor = inputMonitor;
+        mState = STATE_INACTIVE;
+    }
+
+    @Override
+    public boolean useSharedSwipeState() {
+        return mDelegate.useSharedSwipeState();
+    }
+
+    @Override
+    public boolean allowInterceptByParent() {
+        return mDelegate.allowInterceptByParent() && mState != STATE_ACTIVE;
+    }
+
+    @Override
+    public void onConsumerAboutToBeSwitched() {
+        mDelegate.onConsumerAboutToBeSwitched();
+    }
+
+    protected void setActive(MotionEvent ev) {
+        mState = STATE_ACTIVE;
+        mInputMonitor.pilferPointers();
+
+        // Send cancel event
+        MotionEvent event = MotionEvent.obtain(ev);
+        event.setAction(MotionEvent.ACTION_CANCEL);
+        mDelegate.onMotionEvent(event);
+        event.recycle();
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/DeviceLockedInputConsumer.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/DeviceLockedInputConsumer.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8d322695972299fa0f42b7e1c8715c4ebfe5a57
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/DeviceLockedInputConsumer.java
@@ -0,0 +1,254 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.inputconsumers;
+
+import static android.view.MotionEvent.ACTION_CANCEL;
+import static android.view.MotionEvent.ACTION_POINTER_DOWN;
+import static android.view.MotionEvent.ACTION_UP;
+import static foundation.e.blisslauncher.core.Utilities.squaredHypot;
+import static foundation.e.blisslauncher.core.Utilities.squaredTouchSlop;
+import static foundation.e.blisslauncher.quickstep.MultiStateCallback.DEBUG_STATES;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Point;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.ViewConfiguration;
+import android.view.WindowManager;
+import com.android.systemui.shared.system.ActivityManagerWrapper;
+import com.android.systemui.shared.system.BackgroundExecutor;
+import com.android.systemui.shared.system.InputMonitorCompat;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.quickstep.LockScreenRecentsActivity;
+import foundation.e.blisslauncher.quickstep.MultiStateCallback;
+import foundation.e.blisslauncher.quickstep.SwipeSharedState;
+import foundation.e.blisslauncher.quickstep.WindowTransformSwipeHandler;
+import foundation.e.blisslauncher.quickstep.util.ClipAnimationHelper;
+import foundation.e.blisslauncher.quickstep.util.RecentsAnimationListenerSet;
+import foundation.e.blisslauncher.quickstep.util.SwipeAnimationTargetSet;
+
+/**
+ * A dummy input consumer used when the device is still locked, e.g. from secure camera.
+ */
+public class DeviceLockedInputConsumer implements InputConsumer,
+    SwipeAnimationTargetSet.SwipeAnimationListener {
+
+    private static final float SCALE_DOWN = 0.75f;
+
+    private static final String[] STATE_NAMES = DEBUG_STATES ? new String[2] : null;
+    private static int getFlagForIndex(int index, String name) {
+        if (DEBUG_STATES) {
+            STATE_NAMES[index] = name;
+        }
+        return 1 << index;
+    }
+
+    private static final int STATE_TARGET_RECEIVED =
+            getFlagForIndex(0, "STATE_TARGET_RECEIVED");
+    private static final int STATE_HANDLER_INVALIDATED =
+            getFlagForIndex(1, "STATE_HANDLER_INVALIDATED");
+
+    private final Context mContext;
+    private final float mTouchSlopSquared;
+    private final SwipeSharedState mSwipeSharedState;
+    private final InputMonitorCompat mInputMonitorCompat;
+
+    private final PointF mTouchDown = new PointF();
+    private final ClipAnimationHelper mClipAnimationHelper;
+    private final ClipAnimationHelper.TransformParams mTransformParams;
+    private final Point mDisplaySize;
+    private final MultiStateCallback mStateCallback;
+    private final RectF mSwipeTouchRegion;
+    public final int mRunningTaskId;
+
+    private VelocityTracker mVelocityTracker;
+    private float mProgress;
+
+    private boolean mThresholdCrossed = false;
+
+    private SwipeAnimationTargetSet mTargetSet;
+
+    public DeviceLockedInputConsumer(Context context, SwipeSharedState swipeSharedState,
+            InputMonitorCompat inputMonitorCompat, RectF swipeTouchRegion, int runningTaskId) {
+        mContext = context;
+        mTouchSlopSquared = squaredTouchSlop(context);
+        mSwipeSharedState = swipeSharedState;
+        mClipAnimationHelper = new ClipAnimationHelper(context);
+        mTransformParams = new ClipAnimationHelper.TransformParams();
+        mInputMonitorCompat = inputMonitorCompat;
+        mSwipeTouchRegion = swipeTouchRegion;
+        mRunningTaskId = runningTaskId;
+
+        // Do not use DeviceProfile as the user data might be locked
+        mDisplaySize = new Point();
+        context.getSystemService(WindowManager.class).getDefaultDisplay().getRealSize(mDisplaySize);
+
+        // Init states
+        mStateCallback = new MultiStateCallback(STATE_NAMES);
+        mStateCallback.addCallback(STATE_TARGET_RECEIVED | STATE_HANDLER_INVALIDATED,
+                this::endRemoteAnimation);
+
+        mVelocityTracker = VelocityTracker.obtain();
+    }
+
+    @Override
+    public int getType() {
+        return TYPE_DEVICE_LOCKED;
+    }
+
+    @Override
+    public void onMotionEvent(MotionEvent ev) {
+        if (mVelocityTracker == null) {
+            return;
+        }
+        mVelocityTracker.addMovement(ev);
+
+        float x = ev.getX();
+        float y = ev.getY();
+        switch (ev.getAction()) {
+            case MotionEvent.ACTION_DOWN:
+                mTouchDown.set(x, y);
+                break;
+            case ACTION_POINTER_DOWN: {
+                if (!mThresholdCrossed) {
+                    // Cancel interaction in case of multi-touch interaction
+                    int ptrIdx = ev.getActionIndex();
+                    if (!mSwipeTouchRegion.contains(ev.getX(ptrIdx), ev.getY(ptrIdx))) {
+                        int action = ev.getAction();
+                        ev.setAction(ACTION_CANCEL);
+                        finishTouchTracking(ev);
+                        ev.setAction(action);
+                    }
+                }
+                break;
+            }
+            case MotionEvent.ACTION_MOVE: {
+                if (!mThresholdCrossed) {
+                    if (squaredHypot(x - mTouchDown.x, y - mTouchDown.y) > mTouchSlopSquared) {
+                        startRecentsTransition();
+                    }
+                } else {
+                    float dy = Math.max(mTouchDown.y - y, 0);
+                    mProgress = dy / mDisplaySize.y;
+                    mTransformParams.setProgress(mProgress);
+                    if (mTargetSet != null) {
+                        mClipAnimationHelper.applyTransform(mTargetSet, mTransformParams);
+                    }
+                }
+                break;
+            }
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP:
+                finishTouchTracking(ev);
+                break;
+        }
+    }
+
+    /**
+     * Called when the gesture has ended. Does not correlate to the completion of the interaction as
+     * the animation can still be running.
+     */
+    private void finishTouchTracking(MotionEvent ev) {
+        mStateCallback.setState(STATE_HANDLER_INVALIDATED);
+        if (mThresholdCrossed && ev.getAction() == ACTION_UP) {
+            mVelocityTracker.computeCurrentVelocity(1000,
+                    ViewConfiguration.get(mContext).getScaledMaximumFlingVelocity());
+
+            float velocityY = mVelocityTracker.getYVelocity();
+            float flingThreshold = mContext.getResources()
+                    .getDimension(R.dimen.quickstep_fling_threshold_velocity);
+
+            boolean dismissTask;
+            if (Math.abs(velocityY) > flingThreshold) {
+                // Is fling
+                dismissTask = velocityY < 0;
+            } else {
+                dismissTask = mProgress >= (1 - WindowTransformSwipeHandler.MIN_PROGRESS_FOR_OVERVIEW);
+            }
+            if (dismissTask) {
+                // For now, just start the home intent so user is prompted to unlock the device.
+                mContext.startActivity(new Intent(Intent.ACTION_MAIN)
+                        .addCategory(Intent.CATEGORY_HOME)
+                        .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
+            }
+        }
+        mVelocityTracker.recycle();
+        mVelocityTracker = null;
+    }
+
+    private void startRecentsTransition() {
+        mThresholdCrossed = true;
+        RecentsAnimationListenerSet newListenerSet =
+                mSwipeSharedState.newRecentsAnimationListenerSet();
+        newListenerSet.addListener(this);
+        Intent intent = new Intent(Intent.ACTION_MAIN)
+                .addCategory(Intent.CATEGORY_DEFAULT)
+                .setComponent(new ComponentName(mContext, LockScreenRecentsActivity.class))
+                .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
+
+        mInputMonitorCompat.pilferPointers();
+        BackgroundExecutor.get().submit(
+                () -> ActivityManagerWrapper.getInstance().startRecentsActivity(
+                        intent, null, newListenerSet, null, null));
+    }
+
+    @Override
+    public void onRecentsAnimationStart(SwipeAnimationTargetSet targetSet) {
+        mTargetSet = targetSet;
+
+        Rect displaySize = new Rect(0, 0, mDisplaySize.x, mDisplaySize.y);
+        RemoteAnimationTargetCompat targetCompat = targetSet.findTask(mRunningTaskId);
+        if (targetCompat != null) {
+            mClipAnimationHelper.updateSource(displaySize, targetCompat);
+        }
+
+        Utilities.scaleRectAboutCenter(displaySize, SCALE_DOWN);
+        displaySize.offsetTo(displaySize.left, 0);
+        mClipAnimationHelper.updateTargetRect(displaySize);
+        mClipAnimationHelper.applyTransform(mTargetSet, mTransformParams);
+
+        mStateCallback.setState(STATE_TARGET_RECEIVED);
+    }
+
+    @Override
+    public void onRecentsAnimationCanceled() {
+        mTargetSet = null;
+    }
+
+    private void endRemoteAnimation() {
+        if (mTargetSet != null) {
+            mTargetSet.finishController(
+                    false /* toRecents */, null /* callback */, false /* sendUserLeaveHint */);
+        }
+    }
+
+    @Override
+    public void onConsumerAboutToBeSwitched() {
+        mStateCallback.setState(STATE_HANDLER_INVALIDATED);
+    }
+
+    @Override
+    public boolean allowInterceptByParent() {
+        return !mThresholdCrossed;
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/FallbackNoButtonInputConsumer.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/FallbackNoButtonInputConsumer.java
new file mode 100644
index 0000000000000000000000000000000000000000..451dadda345eeda6ca4d2671410fa4f2b591ab59
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/FallbackNoButtonInputConsumer.java
@@ -0,0 +1,354 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.inputconsumers;
+
+import static android.view.MotionEvent.ACTION_CANCEL;
+import static android.view.MotionEvent.ACTION_DOWN;
+import static android.view.MotionEvent.ACTION_MOVE;
+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 android.view.MotionEvent.INVALID_POINTER_ID;
+import static com.android.systemui.shared.system.ActivityManagerWrapper.CLOSE_SYSTEM_WINDOWS_REASON_RECENTS;
+import static foundation.e.blisslauncher.quickstep.inputconsumers.OtherActivityInputConsumer.QUICKSTEP_TOUCH_SLOP_RATIO;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.app.ActivityManager.RunningTaskInfo;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.ViewConfiguration;
+import android.view.WindowManager;
+import com.android.systemui.shared.system.ActivityManagerWrapper;
+import com.android.systemui.shared.system.BackgroundExecutor;
+import com.android.systemui.shared.system.InputMonitorCompat;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import foundation.e.blisslauncher.BlissLauncher;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.quickstep.ActivityControlHelper;
+import foundation.e.blisslauncher.quickstep.OverviewComponentObserver;
+import foundation.e.blisslauncher.quickstep.SwipeSharedState;
+import foundation.e.blisslauncher.quickstep.WindowTransformSwipeHandler;
+import foundation.e.blisslauncher.quickstep.util.ClipAnimationHelper;
+import foundation.e.blisslauncher.quickstep.util.NavBarPosition;
+import foundation.e.blisslauncher.quickstep.util.RecentsAnimationListenerSet;
+import foundation.e.blisslauncher.quickstep.util.SwipeAnimationTargetSet;
+
+public class FallbackNoButtonInputConsumer implements InputConsumer,
+    SwipeAnimationTargetSet.SwipeAnimationListener {
+
+    private static final int STATE_NOT_FINISHED = 0;
+    private static final int STATE_FINISHED_TO_HOME = 1;
+    private static final int STATE_FINISHED_TO_APP = 2;
+
+    private static final float PROGRESS_TO_END_GESTURE = -2;
+
+    private final ActivityControlHelper mActivityControlHelper;
+    private final InputMonitorCompat mInputMonitor;
+    private final Context mContext;
+    private final NavBarPosition mNavBarPosition;
+    private final SwipeSharedState mSwipeSharedState;
+    private final OverviewComponentObserver mOverviewComponentObserver;
+    private final int mRunningTaskId;
+
+    private final ClipAnimationHelper mClipAnimationHelper;
+    private final ClipAnimationHelper.TransformParams
+        mTransformParams = new ClipAnimationHelper.TransformParams();
+    private final float mTransitionDragLength;
+    private final VariantDeviceProfile mDP;
+
+    private final RectF mSwipeTouchRegion;
+    private final boolean mDisableHorizontalSwipe;
+
+    private final PointF mDownPos = new PointF();
+    private final PointF mLastPos = new PointF();
+
+    private int mActivePointerId = -1;
+    // Slop used to determine when we say that the gesture has started.
+    private boolean mPassedPilferInputSlop;
+
+    private VelocityTracker mVelocityTracker;
+
+    // Distance after which we start dragging the window.
+    private final float mTouchSlop;
+
+    // Might be displacement in X or Y, depending on the direction we are swiping from the nav bar.
+    private float mStartDisplacement;
+    private SwipeAnimationTargetSet mSwipeAnimationTargetSet;
+    private float mProgress;
+
+    private int mState = STATE_NOT_FINISHED;
+
+    public FallbackNoButtonInputConsumer(Context context,
+            ActivityControlHelper activityControlHelper, InputMonitorCompat inputMonitor,
+            SwipeSharedState swipeSharedState, RectF swipeTouchRegion,
+            OverviewComponentObserver overviewComponentObserver,
+            boolean disableHorizontalSwipe, RunningTaskInfo runningTaskInfo) {
+        mContext = context;
+        mActivityControlHelper = activityControlHelper;
+        mInputMonitor = inputMonitor;
+        mOverviewComponentObserver = overviewComponentObserver;
+        mRunningTaskId = runningTaskInfo.id;
+
+        mSwipeSharedState = swipeSharedState;
+        mSwipeTouchRegion = swipeTouchRegion;
+        mDisableHorizontalSwipe = disableHorizontalSwipe;
+
+        mNavBarPosition = new NavBarPosition(context);
+        mVelocityTracker = VelocityTracker.obtain();
+
+        mTouchSlop = QUICKSTEP_TOUCH_SLOP_RATIO
+                * ViewConfiguration.get(context).getScaledTouchSlop();
+
+        mClipAnimationHelper = new ClipAnimationHelper(context);
+
+        mDP = BlissLauncher.getApplication(context).getInvariantDeviceProfile().getDeviceProfile(context);
+        Rect tempRect = new Rect();
+        mTransitionDragLength = mActivityControlHelper.getSwipeUpDestinationAndLength(
+                mDP, context, tempRect);
+        mClipAnimationHelper.updateTargetRect(tempRect);
+    }
+
+    @Override
+    public int getType() {
+        return TYPE_FALLBACK_NO_BUTTON;
+    }
+
+    @Override
+    public void onMotionEvent(MotionEvent ev) {
+        if (mVelocityTracker == null) {
+            return;
+        }
+
+        mVelocityTracker.addMovement(ev);
+        if (ev.getActionMasked() == ACTION_POINTER_UP) {
+            mVelocityTracker.clear();
+        }
+
+        switch (ev.getActionMasked()) {
+            case ACTION_DOWN: {
+                mActivePointerId = ev.getPointerId(0);
+                mDownPos.set(ev.getX(), ev.getY());
+                mLastPos.set(mDownPos);
+                break;
+            }
+            case ACTION_POINTER_DOWN: {
+                if (!mPassedPilferInputSlop) {
+                    // Cancel interaction in case of multi-touch interaction
+                    int ptrIdx = ev.getActionIndex();
+                    if (!mSwipeTouchRegion.contains(ev.getX(ptrIdx), ev.getY(ptrIdx))) {
+                        forceCancelGesture(ev);
+                    }
+                }
+                break;
+            }
+            case ACTION_POINTER_UP: {
+                int ptrIdx = ev.getActionIndex();
+                int ptrId = ev.getPointerId(ptrIdx);
+                if (ptrId == mActivePointerId) {
+                    final int newPointerIdx = ptrIdx == 0 ? 1 : 0;
+                    mDownPos.set(
+                            ev.getX(newPointerIdx) - (mLastPos.x - mDownPos.x),
+                            ev.getY(newPointerIdx) - (mLastPos.y - mDownPos.y));
+                    mLastPos.set(ev.getX(newPointerIdx), ev.getY(newPointerIdx));
+                    mActivePointerId = ev.getPointerId(newPointerIdx);
+                }
+                break;
+            }
+            case ACTION_MOVE: {
+                int pointerIndex = ev.findPointerIndex(mActivePointerId);
+                if (pointerIndex == INVALID_POINTER_ID) {
+                    break;
+                }
+                mLastPos.set(ev.getX(pointerIndex), ev.getY(pointerIndex));
+                float displacement = getDisplacement(ev);
+
+                if (!mPassedPilferInputSlop) {
+                    if (mDisableHorizontalSwipe && Math.abs(mLastPos.x - mDownPos.x)
+                            > Math.abs(mLastPos.y - mDownPos.y)) {
+                        // Horizontal gesture is not allowed in this region
+                        forceCancelGesture(ev);
+                        break;
+                    }
+
+                    if (Math.abs(displacement) >= mTouchSlop) {
+                        mPassedPilferInputSlop = true;
+
+                        // Deferred gesture, start the animation and gesture tracking once
+                        // we pass the actual touch slop
+                        startTouchTrackingForWindowAnimation(displacement);
+                    }
+                } else {
+                    updateDisplacement(displacement - mStartDisplacement);
+                }
+                break;
+            }
+            case ACTION_CANCEL:
+            case ACTION_UP: {
+                finishTouchTracking(ev);
+                break;
+            }
+        }
+    }
+
+    private void startTouchTrackingForWindowAnimation(float displacement) {
+        mStartDisplacement = Math.min(displacement, -mTouchSlop);
+
+        RecentsAnimationListenerSet listenerSet =
+                mSwipeSharedState.newRecentsAnimationListenerSet();
+        listenerSet.addListener(this);
+        Intent homeIntent = mOverviewComponentObserver.getHomeIntent();
+        BackgroundExecutor.get().submit(
+                () -> ActivityManagerWrapper.getInstance().startRecentsActivity(
+                        homeIntent, null, listenerSet, null, null));
+
+        ActivityManagerWrapper.getInstance().closeSystemWindows(
+                CLOSE_SYSTEM_WINDOWS_REASON_RECENTS);
+        mInputMonitor.pilferPointers();
+    }
+
+    private void updateDisplacement(float displacement) {
+        mProgress = displacement / mTransitionDragLength;
+        mTransformParams.setProgress(mProgress);
+
+        if (mSwipeAnimationTargetSet != null) {
+            mClipAnimationHelper.applyTransform(mSwipeAnimationTargetSet, mTransformParams);
+        }
+    }
+
+    private void forceCancelGesture(MotionEvent ev) {
+        int action = ev.getAction();
+        ev.setAction(ACTION_CANCEL);
+        finishTouchTracking(ev);
+        ev.setAction(action);
+    }
+
+    /**
+     * Called when the gesture has ended. Does not correlate to the completion of the interaction as
+     * the animation can still be running.
+     */
+    private void finishTouchTracking(MotionEvent ev) {
+        if (ev.getAction() == ACTION_CANCEL) {
+            mState = STATE_FINISHED_TO_APP;
+        } else {
+            mVelocityTracker.computeCurrentVelocity(1000,
+                    ViewConfiguration.get(mContext).getScaledMaximumFlingVelocity());
+            float velocityX = mVelocityTracker.getXVelocity(mActivePointerId);
+            float velocityY = mVelocityTracker.getYVelocity(mActivePointerId);
+            float velocity = mNavBarPosition.isRightEdge() ? velocityX
+                    : mNavBarPosition.isLeftEdge() ? -velocityX
+                            : velocityY;
+            float flingThreshold = mContext.getResources()
+                    .getDimension(R.dimen.quickstep_fling_threshold_velocity);
+            boolean isFling = Math.abs(velocity) > flingThreshold;
+
+            boolean goingHome;
+            if (!isFling) {
+                goingHome = -mProgress >= WindowTransformSwipeHandler.MIN_PROGRESS_FOR_OVERVIEW;
+            } else {
+                goingHome = velocity < 0;
+            }
+
+            if (goingHome) {
+                mState = STATE_FINISHED_TO_HOME;
+            } else {
+                mState = STATE_FINISHED_TO_APP;
+            }
+        }
+
+        if (mSwipeAnimationTargetSet != null) {
+            finishAnimationTargetSet();
+        }
+    }
+
+    private void finishAnimationTargetSet() {
+        if (mState == STATE_FINISHED_TO_APP) {
+            mSwipeAnimationTargetSet.finishController(false, null, false);
+        } else {
+            if (mProgress < PROGRESS_TO_END_GESTURE) {
+                mSwipeAnimationTargetSet.finishController(true, null, true);
+            } else {
+                long duration = (long) (Math.min(mProgress - PROGRESS_TO_END_GESTURE, 1)
+                        * WindowTransformSwipeHandler.MAX_SWIPE_DURATION / Math.abs(PROGRESS_TO_END_GESTURE));
+                if (duration < 0) {
+                    duration = WindowTransformSwipeHandler.MIN_SWIPE_DURATION;
+                }
+
+                ValueAnimator anim = ValueAnimator.ofFloat(mProgress, PROGRESS_TO_END_GESTURE);
+                anim.addUpdateListener(a -> {
+                    float p = (Float) anim.getAnimatedValue();
+                    mTransformParams.setProgress(p);
+                    mClipAnimationHelper.applyTransform(mSwipeAnimationTargetSet, mTransformParams);
+                });
+                anim.setDuration(duration);
+                anim.addListener(new AnimatorListenerAdapter() {
+                    @Override
+                    public void onAnimationEnd(Animator animation) {
+                        mSwipeAnimationTargetSet.finishController(true, null, true);
+                    }
+                });
+                anim.start();
+            }
+        }
+    }
+
+    @Override
+    public void onRecentsAnimationStart(SwipeAnimationTargetSet targetSet) {
+        mSwipeAnimationTargetSet = targetSet;
+        Rect overviewStackBounds = new Rect(0, 0, mDP.getWidthPx(), mDP.getHeightPx());
+        RemoteAnimationTargetCompat runningTaskTarget = targetSet.findTask(mRunningTaskId);
+
+        mDP.updateIsSeascape(mContext.getSystemService(WindowManager.class));
+        if (runningTaskTarget != null) {
+            mClipAnimationHelper.updateSource(overviewStackBounds, runningTaskTarget);
+        }
+        mClipAnimationHelper.prepareAnimation(mDP, false /* isOpening */);
+
+        overviewStackBounds
+                .inset(-overviewStackBounds.width() / 5, -overviewStackBounds.height() / 5);
+        mClipAnimationHelper.updateTargetRect(overviewStackBounds);
+        mClipAnimationHelper.applyTransform(mSwipeAnimationTargetSet, mTransformParams);
+
+        if (mState != STATE_NOT_FINISHED) {
+            finishAnimationTargetSet();
+        }
+    }
+
+    @Override
+    public void onRecentsAnimationCanceled() { }
+
+    private float getDisplacement(MotionEvent ev) {
+        if (mNavBarPosition.isRightEdge()) {
+            return ev.getX() - mDownPos.x;
+        } else if (mNavBarPosition.isLeftEdge()) {
+            return mDownPos.x - ev.getX();
+        } else {
+            return ev.getY() - mDownPos.y;
+        }
+    }
+
+    @Override
+    public boolean allowInterceptByParent() {
+        return !mPassedPilferInputSlop;
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/InputConsumer.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/InputConsumer.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5734159dba9c0534263e48891d910bcee47b90e
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/InputConsumer.java
@@ -0,0 +1,95 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.inputconsumers;
+
+import android.annotation.TargetApi;
+import android.os.Build;
+import android.view.InputEvent;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+
+@TargetApi(Build.VERSION_CODES.O)
+public interface InputConsumer {
+
+    int TYPE_NO_OP = 1 << 0;
+    int TYPE_OVERVIEW = 1 << 1;
+    int TYPE_OTHER_ACTIVITY = 1 << 2;
+    int TYPE_ASSISTANT = 1 << 3;
+    int TYPE_DEVICE_LOCKED = 1 << 4;
+    int TYPE_ACCESSIBILITY = 1 << 5;
+    int TYPE_SCREEN_PINNED = 1 << 6;
+    int TYPE_OVERVIEW_WITHOUT_FOCUS = 1 << 7;
+    int TYPE_RESET_GESTURE = 1 << 8;
+    int TYPE_FALLBACK_NO_BUTTON = 1 << 9;
+
+    String[] NAMES = new String[] {
+           "TYPE_NO_OP",                    // 0
+            "TYPE_OVERVIEW",                // 1
+            "TYPE_OTHER_ACTIVITY",          // 2
+            "TYPE_ASSISTANT",               // 3
+            "TYPE_DEVICE_LOCKED",           // 4
+            "TYPE_ACCESSIBILITY",           // 5
+            "TYPE_SCREEN_PINNED",           // 6
+            "TYPE_OVERVIEW_WITHOUT_FOCUS",  // 7
+            "TYPE_RESET_GESTURE",           // 8
+            "TYPE_FALLBACK_NO_BUTTON",      // 9
+    };
+
+    InputConsumer NO_OP = () -> TYPE_NO_OP;
+
+    int getType();
+
+    default boolean useSharedSwipeState() {
+        return false;
+    }
+
+    /**
+     * Returns true if the user has crossed the threshold for it to be an explicit action.
+     */
+    default boolean allowInterceptByParent() {
+        return true;
+    }
+
+    /**
+     * Called by the event queue when the consumer is about to be switched to a new consumer.
+     */
+    default void onConsumerAboutToBeSwitched() { }
+
+    default void onMotionEvent(MotionEvent ev) { }
+
+    default void onKeyEvent(KeyEvent ev) { }
+
+    default void onInputEvent(InputEvent ev) {
+        if (ev instanceof MotionEvent) {
+            onMotionEvent((MotionEvent) ev);
+        } else {
+            onKeyEvent((KeyEvent) ev);
+        }
+    }
+
+    default String getName() {
+        String name = "";
+        for (int i = 0; i < NAMES.length; i++) {
+            if ((getType() & (1 << i)) != 0) {
+                if (name.length() > 0) {
+                    name += ":";
+                }
+                name += NAMES[i];
+            }
+        }
+        return name;
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/OtherActivityInputConsumer.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/OtherActivityInputConsumer.java
new file mode 100644
index 0000000000000000000000000000000000000000..4aec0c13b8676c4b2baca043aa873b2a1767b178
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/OtherActivityInputConsumer.java
@@ -0,0 +1,440 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.inputconsumers;
+
+import static android.view.MotionEvent.ACTION_CANCEL;
+import static android.view.MotionEvent.ACTION_DOWN;
+import static android.view.MotionEvent.ACTION_MOVE;
+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 android.view.MotionEvent.INVALID_POINTER_ID;
+import static com.android.systemui.shared.system.ActivityManagerWrapper.CLOSE_SYSTEM_WINDOWS_REASON_RECENTS;
+import static foundation.e.blisslauncher.core.Utilities.EDGE_NAV_BAR;
+import static foundation.e.blisslauncher.core.Utilities.squaredHypot;
+
+import android.annotation.TargetApi;
+import android.app.ActivityManager.RunningTaskInfo;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.content.Intent;
+import android.graphics.PointF;
+import android.graphics.RectF;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.ViewConfiguration;
+import androidx.annotation.UiThread;
+import com.android.systemui.shared.system.ActivityManagerWrapper;
+import com.android.systemui.shared.system.BackgroundExecutor;
+import com.android.systemui.shared.system.InputConsumerController;
+import com.android.systemui.shared.system.InputMonitorCompat;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.utils.Preconditions;
+import foundation.e.blisslauncher.features.test.TraceHelper;
+import foundation.e.blisslauncher.quickstep.ActivityControlHelper;
+import foundation.e.blisslauncher.quickstep.OverviewCallbacks;
+import foundation.e.blisslauncher.quickstep.RecentsModel;
+import foundation.e.blisslauncher.quickstep.SwipeSharedState;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode.Mode;
+import foundation.e.blisslauncher.quickstep.WindowTransformSwipeHandler;
+import foundation.e.blisslauncher.quickstep.util.CachedEventDispatcher;
+import foundation.e.blisslauncher.quickstep.util.MotionPauseDetector;
+import foundation.e.blisslauncher.quickstep.util.NavBarPosition;
+import foundation.e.blisslauncher.quickstep.util.RecentsAnimationListenerSet;
+import java.util.function.Consumer;
+
+/**
+ * Input consumer for handling events originating from an activity other than Launcher
+ */
+@TargetApi(Build.VERSION_CODES.P)
+public class OtherActivityInputConsumer extends ContextWrapper implements InputConsumer {
+
+    public static final String DOWN_EVT = "OtherActivityInputConsumer.DOWN";
+    private static final String UP_EVT = "OtherActivityInputConsumer.UP";
+
+    // TODO: Move to quickstep contract
+    public static final float QUICKSTEP_TOUCH_SLOP_RATIO = 3;
+
+    private final CachedEventDispatcher mRecentsViewDispatcher = new CachedEventDispatcher();
+    private final RunningTaskInfo mRunningTask;
+    private final RecentsModel mRecentsModel;
+    private final Intent mHomeIntent;
+    private final ActivityControlHelper mActivityControlHelper;
+    private final OverviewCallbacks mOverviewCallbacks;
+    private final InputConsumerController mInputConsumer;
+    private final SwipeSharedState mSwipeSharedState;
+    private final InputMonitorCompat mInputMonitorCompat;
+    private final Mode mMode;
+    private final RectF mSwipeTouchRegion;
+
+    private final NavBarPosition mNavBarPosition;
+
+    private final Consumer<OtherActivityInputConsumer> mOnCompleteCallback;
+    private final MotionPauseDetector mMotionPauseDetector;
+    private final float mMotionPauseMinDisplacement;
+    private VelocityTracker mVelocityTracker;
+
+    private WindowTransformSwipeHandler mInteractionHandler;
+
+    private final boolean mIsDeferredDownTarget;
+    private final PointF mDownPos = new PointF();
+    private final PointF mLastPos = new PointF();
+    private int mActivePointerId = INVALID_POINTER_ID;
+
+    // Distance after which we start dragging the window.
+    private final float mTouchSlop;
+
+    private final float mSquaredTouchSlop;
+    private final boolean mDisableHorizontalSwipe;
+
+    // Slop used to check when we start moving window.
+    private boolean mPaddedWindowMoveSlop;
+    // Slop used to determine when we say that the gesture has started.
+    private boolean mPassedPilferInputSlop;
+
+    // Might be displacement in X or Y, depending on the direction we are swiping from the nav bar.
+    private float mStartDisplacement;
+
+    private Handler mMainThreadHandler;
+    private Runnable mCancelRecentsAnimationRunnable = () -> {
+        ActivityManagerWrapper.getInstance().cancelRecentsAnimation(
+                true /* restoreHomeStackPosition */);
+    };
+
+    public OtherActivityInputConsumer(Context base, RunningTaskInfo runningTaskInfo,
+            RecentsModel recentsModel, Intent homeIntent, ActivityControlHelper activityControl,
+            boolean isDeferredDownTarget, OverviewCallbacks overviewCallbacks,
+            InputConsumerController inputConsumer,
+            Consumer<OtherActivityInputConsumer> onCompleteCallback,
+            SwipeSharedState swipeSharedState, InputMonitorCompat inputMonitorCompat,
+            RectF swipeTouchRegion, boolean disableHorizontalSwipe) {
+        super(base);
+
+        mMainThreadHandler = new Handler(Looper.getMainLooper());
+        mRunningTask = runningTaskInfo;
+        mRecentsModel = recentsModel;
+        mHomeIntent = homeIntent;
+        mMode = SysUINavigationMode.getMode(base);
+        mSwipeTouchRegion = swipeTouchRegion;
+
+        mMotionPauseDetector = new MotionPauseDetector(base);
+        mMotionPauseMinDisplacement = base.getResources().getDimension(
+                R.dimen.motion_pause_detector_min_displacement_from_app);
+        mOnCompleteCallback = onCompleteCallback;
+        mVelocityTracker = VelocityTracker.obtain();
+        mInputMonitorCompat = inputMonitorCompat;
+
+        mActivityControlHelper = activityControl;
+        boolean continuingPreviousGesture = swipeSharedState.getActiveListener() != null;
+        mIsDeferredDownTarget = !continuingPreviousGesture && isDeferredDownTarget;
+        mOverviewCallbacks = overviewCallbacks;
+        mInputConsumer = inputConsumer;
+        mSwipeSharedState = swipeSharedState;
+
+        mNavBarPosition = new NavBarPosition(base);
+        mTouchSlop = ViewConfiguration.get(this).getScaledTouchSlop();
+
+        float slop = QUICKSTEP_TOUCH_SLOP_RATIO * mTouchSlop;
+        mSquaredTouchSlop = slop * slop;
+
+        mPassedPilferInputSlop = mPaddedWindowMoveSlop = continuingPreviousGesture;
+        mDisableHorizontalSwipe = !mPassedPilferInputSlop && disableHorizontalSwipe;
+    }
+
+    @Override
+    public int getType() {
+        return TYPE_OTHER_ACTIVITY;
+    }
+
+    private void forceCancelGesture(MotionEvent ev) {
+        int action = ev.getAction();
+        ev.setAction(ACTION_CANCEL);
+        finishTouchTracking(ev);
+        ev.setAction(action);
+    }
+
+    @Override
+    public void onMotionEvent(MotionEvent ev) {
+        if (mVelocityTracker == null) {
+            return;
+        }
+
+        // Proxy events to recents view
+        if (mPaddedWindowMoveSlop && mInteractionHandler != null
+                && !mRecentsViewDispatcher.hasConsumer()) {
+            mRecentsViewDispatcher.setConsumer(mInteractionHandler.getRecentsViewDispatcher(
+                    mNavBarPosition.getRotationMode()));
+        }
+        int edgeFlags = ev.getEdgeFlags();
+        ev.setEdgeFlags(edgeFlags | EDGE_NAV_BAR);
+        mRecentsViewDispatcher.dispatchEvent(ev);
+        ev.setEdgeFlags(edgeFlags);
+
+        mVelocityTracker.addMovement(ev);
+        if (ev.getActionMasked() == ACTION_POINTER_UP) {
+            mVelocityTracker.clear();
+            mMotionPauseDetector.clear();
+        }
+
+        switch (ev.getActionMasked()) {
+            case ACTION_DOWN: {
+                TraceHelper.beginSection("TouchInt");
+                mActivePointerId = ev.getPointerId(0);
+                mDownPos.set(ev.getX(), ev.getY());
+                mLastPos.set(mDownPos);
+
+                // Start the window animation on down to give more time for launcher to draw if the
+                // user didn't start the gesture over the back button
+                if (!mIsDeferredDownTarget) {
+                    startTouchTrackingForWindowAnimation(ev.getEventTime());
+                }
+                break;
+            }
+            case ACTION_POINTER_DOWN: {
+                if (!mPassedPilferInputSlop) {
+                    // Cancel interaction in case of multi-touch interaction
+                    int ptrIdx = ev.getActionIndex();
+                    if (!mSwipeTouchRegion.contains(ev.getX(ptrIdx), ev.getY(ptrIdx))) {
+                        forceCancelGesture(ev);
+                    }
+                }
+                break;
+            }
+            case ACTION_POINTER_UP: {
+                int ptrIdx = ev.getActionIndex();
+                int ptrId = ev.getPointerId(ptrIdx);
+                if (ptrId == mActivePointerId) {
+                    final int newPointerIdx = ptrIdx == 0 ? 1 : 0;
+                    mDownPos.set(
+                            ev.getX(newPointerIdx) - (mLastPos.x - mDownPos.x),
+                            ev.getY(newPointerIdx) - (mLastPos.y - mDownPos.y));
+                    mLastPos.set(ev.getX(newPointerIdx), ev.getY(newPointerIdx));
+                    mActivePointerId = ev.getPointerId(newPointerIdx);
+                }
+                break;
+            }
+            case ACTION_MOVE: {
+                int pointerIndex = ev.findPointerIndex(mActivePointerId);
+                if (pointerIndex == INVALID_POINTER_ID) {
+                    break;
+                }
+                mLastPos.set(ev.getX(pointerIndex), ev.getY(pointerIndex));
+                float displacement = getDisplacement(ev);
+                float displacementX = mLastPos.x - mDownPos.x;
+
+                if (!mPaddedWindowMoveSlop) {
+                    if (!mIsDeferredDownTarget) {
+                        // Normal gesture, ensure we pass the drag slop before we start tracking
+                        // the gesture
+                        if (Math.abs(displacement) > mTouchSlop) {
+                            mPaddedWindowMoveSlop = true;
+                            mStartDisplacement = Math.min(displacement, -mTouchSlop);
+                        }
+                    }
+                }
+
+                if (!mPassedPilferInputSlop) {
+                    float displacementY = mLastPos.y - mDownPos.y;
+                    if (squaredHypot(displacementX, displacementY) >= mSquaredTouchSlop) {
+                        if (mDisableHorizontalSwipe
+                                && Math.abs(displacementX) > Math.abs(displacementY)) {
+                            // Horizontal gesture is not allowed in this region
+                            forceCancelGesture(ev);
+                            break;
+                        }
+
+                        mPassedPilferInputSlop = true;
+
+                        if (mIsDeferredDownTarget) {
+                            // Deferred gesture, start the animation and gesture tracking once
+                            // we pass the actual touch slop
+                            startTouchTrackingForWindowAnimation(ev.getEventTime());
+                        }
+                        if (!mPaddedWindowMoveSlop) {
+                            mPaddedWindowMoveSlop = true;
+                            mStartDisplacement = Math.min(displacement, -mTouchSlop);
+
+                        }
+                        notifyGestureStarted();
+                    }
+                }
+
+                if (mInteractionHandler != null) {
+                    if (mPaddedWindowMoveSlop) {
+                        // Move
+                        mInteractionHandler.updateDisplacement(displacement - mStartDisplacement);
+                    }
+
+                    if (mMode == Mode.NO_BUTTON) {
+                        float horizontalDist = Math.abs(displacementX);
+                        float upDist = -displacement;
+                        boolean isLikelyToStartNewTask = horizontalDist > upDist;
+                        mMotionPauseDetector.setDisallowPause(upDist < mMotionPauseMinDisplacement
+                                || isLikelyToStartNewTask);
+                        mMotionPauseDetector.addPosition(displacement, ev.getEventTime());
+                        mInteractionHandler.setIsLikelyToStartNewTask(isLikelyToStartNewTask);
+                    }
+                }
+                break;
+            }
+            case ACTION_CANCEL:
+            case ACTION_UP: {
+                finishTouchTracking(ev);
+                break;
+            }
+        }
+    }
+
+    private void notifyGestureStarted() {
+        if (mInteractionHandler == null) {
+            return;
+        }
+        mInputMonitorCompat.pilferPointers();
+
+        mOverviewCallbacks.closeAllWindows();
+        ActivityManagerWrapper.getInstance().closeSystemWindows(
+                CLOSE_SYSTEM_WINDOWS_REASON_RECENTS);
+
+        // Notify the handler that the gesture has actually started
+        mInteractionHandler.onGestureStarted();
+    }
+
+    private void startTouchTrackingForWindowAnimation(long touchTimeMs) {
+        RecentsAnimationListenerSet listenerSet = mSwipeSharedState.getActiveListener();
+        final WindowTransformSwipeHandler handler = new WindowTransformSwipeHandler(
+                mRunningTask, this, touchTimeMs, mActivityControlHelper,
+                listenerSet != null, mInputConsumer);
+
+        // Preload the plan
+        mRecentsModel.getTasks(null);
+        mInteractionHandler = handler;
+        handler.setGestureEndCallback(this::onInteractionGestureFinished);
+        mMotionPauseDetector.setOnMotionPauseListener(handler::onMotionPauseChanged);
+        handler.initWhenReady();
+
+        if (listenerSet != null) {
+            listenerSet.addListener(handler);
+            mSwipeSharedState.applyActiveRecentsAnimationState(handler);
+            notifyGestureStarted();
+        } else {
+            RecentsAnimationListenerSet newListenerSet =
+                    mSwipeSharedState.newRecentsAnimationListenerSet();
+            newListenerSet.addListener(handler);
+            BackgroundExecutor.get().submit(
+                    () -> ActivityManagerWrapper.getInstance().startRecentsActivity(
+                            mHomeIntent, null, newListenerSet, null, null));
+        }
+    }
+
+    /**
+     * Called when the gesture has ended. Does not correlate to the completion of the interaction as
+     * the animation can still be running.
+     */
+    private void finishTouchTracking(MotionEvent ev) {
+        TraceHelper.endSection("TouchInt");
+
+        if (mPaddedWindowMoveSlop && mInteractionHandler != null) {
+            if (ev.getActionMasked() == ACTION_CANCEL) {
+                mInteractionHandler.onGestureCancelled();
+            } else {
+                mVelocityTracker.computeCurrentVelocity(1000,
+                        ViewConfiguration.get(this).getScaledMaximumFlingVelocity());
+                float velocityX = mVelocityTracker.getXVelocity(mActivePointerId);
+                float velocityY = mVelocityTracker.getYVelocity(mActivePointerId);
+                float velocity = mNavBarPosition.isRightEdge() ? velocityX
+                        : mNavBarPosition.isLeftEdge() ? -velocityX
+                                : velocityY;
+
+                mInteractionHandler.updateDisplacement(getDisplacement(ev) - mStartDisplacement);
+                mInteractionHandler.onGestureEnded(velocity, new PointF(velocityX, velocityY),
+                        mDownPos);
+            }
+        } else {
+            // Since we start touch tracking on DOWN, we may reach this state without actually
+            // starting the gesture. In that case, just cleanup immediately.
+            onConsumerAboutToBeSwitched();
+            onInteractionGestureFinished();
+
+            // Cancel the recents animation if SysUI happens to handle UP before we have a chance
+            // to start the recents animation. In addition, workaround for b/126336729 by delaying
+            // the cancel of the animation for a period, in case SysUI is slow to handle UP and we
+            // handle DOWN & UP and move the home stack before SysUI can start the activity
+            mMainThreadHandler.removeCallbacks(mCancelRecentsAnimationRunnable);
+            mMainThreadHandler.postDelayed(mCancelRecentsAnimationRunnable, 100);
+        }
+        mVelocityTracker.recycle();
+        mVelocityTracker = null;
+        mMotionPauseDetector.clear();
+    }
+
+    @Override
+    public void onConsumerAboutToBeSwitched() {
+        Preconditions.assertUIThread();
+        mMainThreadHandler.removeCallbacks(mCancelRecentsAnimationRunnable);
+        if (mInteractionHandler != null) {
+            // The consumer is being switched while we are active. Set up the shared state to be
+            // used by the next animation
+            removeListener();
+            WindowTransformSwipeHandler.GestureEndTarget endTarget = mInteractionHandler.getGestureEndTarget();
+            mSwipeSharedState.canGestureBeContinued = endTarget != null && endTarget.canBeContinued;
+            mSwipeSharedState.goingToLauncher = endTarget != null && endTarget.isLauncher;
+            if (mSwipeSharedState.canGestureBeContinued) {
+                mInteractionHandler.cancelCurrentAnimation(mSwipeSharedState);
+            } else {
+                mInteractionHandler.reset();
+            }
+        }
+    }
+
+    @UiThread
+    private void onInteractionGestureFinished() {
+        Preconditions.assertUIThread();
+        removeListener();
+        mInteractionHandler = null;
+        mOnCompleteCallback.accept(this);
+    }
+
+    private void removeListener() {
+        RecentsAnimationListenerSet listenerSet = mSwipeSharedState.getActiveListener();
+        if (listenerSet != null) {
+            listenerSet.removeListener(mInteractionHandler);
+        }
+    }
+
+    private float getDisplacement(MotionEvent ev) {
+        if (mNavBarPosition.isRightEdge()) {
+            return ev.getX() - mDownPos.x;
+        } else if (mNavBarPosition.isLeftEdge()) {
+            return mDownPos.x - ev.getX();
+        } else {
+            return ev.getY() - mDownPos.y;
+        }
+    }
+
+    @Override
+    public boolean useSharedSwipeState() {
+        return mInteractionHandler != null;
+    }
+
+    @Override
+    public boolean allowInterceptByParent() {
+        return !mPassedPilferInputSlop;
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/OverviewInputConsumer.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/OverviewInputConsumer.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3f4a0710f432fd2b9ac48f9faf62b9240d84504
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/OverviewInputConsumer.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.inputconsumers;
+
+import static com.android.systemui.shared.system.ActivityManagerWrapper.CLOSE_SYSTEM_WINDOWS_REASON_RECENTS;
+import static foundation.e.blisslauncher.core.Flags.ENABLE_QUICKSTEP_LIVE_TILE;
+
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import androidx.annotation.Nullable;
+import com.android.systemui.shared.system.ActivityManagerWrapper;
+import com.android.systemui.shared.system.InputMonitorCompat;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.features.test.BaseDragLayer;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.quickstep.OverviewCallbacks;
+import java.util.function.Predicate;
+
+/**
+ * Input consumer for handling touch on the recents/Launcher activity.
+ */
+public class OverviewInputConsumer<T extends BaseDraggingActivity>
+        implements InputConsumer {
+
+    private final T mActivity;
+    private final BaseDragLayer mTarget;
+    private final InputMonitorCompat mInputMonitor;
+
+    private final int[] mLocationOnScreen = new int[2];
+    private final boolean mProxyTouch;
+    private final Predicate<MotionEvent> mEventReceiver;
+
+    private final boolean mStartingInActivityBounds;
+    private boolean mTargetHandledTouch;
+
+    public OverviewInputConsumer(T activity, @Nullable InputMonitorCompat inputMonitor,
+            boolean startingInActivityBounds) {
+        mActivity = activity;
+        mInputMonitor = inputMonitor;
+        mStartingInActivityBounds = startingInActivityBounds;
+
+        mTarget = activity.getDragLayer();
+        if (startingInActivityBounds) {
+            mEventReceiver = mTarget::dispatchTouchEvent;
+            mProxyTouch = true;
+        } else {
+            // Only proxy touches to controllers if we are starting touch from nav bar.
+            mEventReceiver = mTarget::proxyTouchEvent;
+            mTarget.getLocationOnScreen(mLocationOnScreen);
+            mProxyTouch = mTarget.prepareProxyEventStarting();
+        }
+    }
+
+    @Override
+    public int getType() {
+        return TYPE_OVERVIEW;
+    }
+
+    @Override
+    public boolean allowInterceptByParent() {
+        return !mTargetHandledTouch;
+    }
+
+    @Override
+    public void onMotionEvent(MotionEvent ev) {
+        if (!mProxyTouch) {
+            return;
+        }
+
+        int flags = ev.getEdgeFlags();
+        if (!mStartingInActivityBounds) {
+            ev.setEdgeFlags(flags | Utilities.EDGE_NAV_BAR);
+        }
+        ev.offsetLocation(-mLocationOnScreen[0], -mLocationOnScreen[1]);
+        boolean handled = mEventReceiver.test(ev);
+        ev.offsetLocation(mLocationOnScreen[0], mLocationOnScreen[1]);
+        ev.setEdgeFlags(flags);
+
+        if (!mTargetHandledTouch && handled) {
+            mTargetHandledTouch = true;
+            if (!mStartingInActivityBounds) {
+                OverviewCallbacks.get(mActivity).closeAllWindows();
+                ActivityManagerWrapper.getInstance()
+                        .closeSystemWindows(CLOSE_SYSTEM_WINDOWS_REASON_RECENTS);
+            }
+            if (mInputMonitor != null) {
+                mInputMonitor.pilferPointers();
+            }
+        }
+    }
+
+    @Override
+    public void onKeyEvent(KeyEvent ev) {
+        if (ENABLE_QUICKSTEP_LIVE_TILE) {
+            mActivity.dispatchKeyEvent(ev);
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/OverviewWithoutFocusInputConsumer.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/OverviewWithoutFocusInputConsumer.java
new file mode 100644
index 0000000000000000000000000000000000000000..d35af5b31348b34714ad9960ff6210255fe1189c
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/OverviewWithoutFocusInputConsumer.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.inputconsumers;
+
+import static android.view.MotionEvent.ACTION_CANCEL;
+import static android.view.MotionEvent.ACTION_DOWN;
+import static android.view.MotionEvent.ACTION_MOVE;
+import static android.view.MotionEvent.ACTION_UP;
+import static com.android.systemui.shared.system.ActivityManagerWrapper.CLOSE_SYSTEM_WINDOWS_REASON_RECENTS;
+import static foundation.e.blisslauncher.core.Utilities.squaredHypot;
+
+import android.content.Context;
+import android.graphics.PointF;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.ViewConfiguration;
+import com.android.systemui.shared.system.ActivityManagerWrapper;
+import com.android.systemui.shared.system.InputMonitorCompat;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.quickstep.OverviewCallbacks;
+import foundation.e.blisslauncher.quickstep.util.NavBarPosition;
+
+public class OverviewWithoutFocusInputConsumer implements InputConsumer {
+
+    private final InputMonitorCompat mInputMonitor;
+    private final boolean mDisableHorizontalSwipe;
+    private final PointF mDownPos = new PointF();
+    private final float mSquaredTouchSlop;
+    private final Context mContext;
+    private final NavBarPosition mNavBarPosition;
+
+    private boolean mInterceptedTouch;
+    private VelocityTracker mVelocityTracker;
+
+
+    public OverviewWithoutFocusInputConsumer(Context context, InputMonitorCompat inputMonitor,
+            boolean disableHorizontalSwipe) {
+        mInputMonitor = inputMonitor;
+        mDisableHorizontalSwipe = disableHorizontalSwipe;
+        mContext = context;
+        mSquaredTouchSlop = Utilities.squaredTouchSlop(context);
+        mNavBarPosition = new NavBarPosition(context);
+
+        mVelocityTracker = VelocityTracker.obtain();
+    }
+
+    @Override
+    public int getType() {
+        return TYPE_OVERVIEW_WITHOUT_FOCUS;
+    }
+
+    @Override
+    public boolean allowInterceptByParent() {
+        return !mInterceptedTouch;
+    }
+
+    private void endTouchTracking() {
+        if (mVelocityTracker != null) {
+            mVelocityTracker.recycle();
+            mVelocityTracker = null;
+        }
+    }
+
+    @Override
+    public void onMotionEvent(MotionEvent ev) {
+        if (mVelocityTracker == null) {
+            return;
+        }
+
+        mVelocityTracker.addMovement(ev);
+        switch (ev.getActionMasked()) {
+            case ACTION_DOWN: {
+                mDownPos.set(ev.getX(), ev.getY());
+                break;
+            }
+            case ACTION_MOVE: {
+                if (!mInterceptedTouch) {
+                    float displacementX = ev.getX() - mDownPos.x;
+                    float displacementY = ev.getY() - mDownPos.y;
+                    if (squaredHypot(displacementX, displacementY) >= mSquaredTouchSlop) {
+                        if (mDisableHorizontalSwipe
+                                && Math.abs(displacementX) > Math.abs(displacementY)) {
+                            // Horizontal gesture is not allowed in this region
+                            endTouchTracking();
+                            break;
+                        }
+
+                        mInterceptedTouch = true;
+
+                        if (mInputMonitor != null) {
+                            mInputMonitor.pilferPointers();
+                        }
+                    }
+                }
+                break;
+            }
+
+            case ACTION_CANCEL:
+                endTouchTracking();
+                break;
+
+            case ACTION_UP: {
+                finishTouchTracking(ev);
+                endTouchTracking();
+                break;
+            }
+        }
+    }
+
+    private void finishTouchTracking(MotionEvent ev) {
+        mVelocityTracker.computeCurrentVelocity(100);
+        float velocityX = mVelocityTracker.getXVelocity();
+        float velocityY = mVelocityTracker.getYVelocity();
+        float velocity = mNavBarPosition.isRightEdge()
+                ? -velocityX : (mNavBarPosition.isLeftEdge() ? velocityX : -velocityY);
+
+        final boolean triggerQuickstep;
+        if (Math.abs(velocity) >= ViewConfiguration.get(mContext).getScaledMinimumFlingVelocity()) {
+            triggerQuickstep = velocity > 0;
+        } else {
+            float displacementX = mDisableHorizontalSwipe ? 0 : (ev.getX() - mDownPos.x);
+            float displacementY = ev.getY() - mDownPos.y;
+            triggerQuickstep = squaredHypot(displacementX, displacementY) >= mSquaredTouchSlop;
+        }
+
+        if (triggerQuickstep) {
+            OverviewCallbacks.get(mContext).closeAllWindows();
+            ActivityManagerWrapper.getInstance()
+                    .closeSystemWindows(CLOSE_SYSTEM_WINDOWS_REASON_RECENTS);
+        } else {
+            // ignore
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/ResetGestureInputConsumer.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/ResetGestureInputConsumer.java
new file mode 100644
index 0000000000000000000000000000000000000000..50889132461f203eabb1cf100572fb536321e4f1
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/ResetGestureInputConsumer.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.inputconsumers;
+
+import android.view.MotionEvent;
+
+import foundation.e.blisslauncher.quickstep.SwipeSharedState;
+
+/**
+ * A NO_OP input consumer which also resets any pending gesture
+ */
+public class ResetGestureInputConsumer implements InputConsumer {
+
+    private final SwipeSharedState mSwipeSharedState;
+
+    public ResetGestureInputConsumer(SwipeSharedState swipeSharedState) {
+        mSwipeSharedState = swipeSharedState;
+    }
+
+    @Override
+    public int getType() {
+        return TYPE_RESET_GESTURE;
+    }
+
+    @Override
+    public void onMotionEvent(MotionEvent ev) {
+        if (ev.getAction() == MotionEvent.ACTION_DOWN
+                && mSwipeSharedState.getActiveListener() != null) {
+            mSwipeSharedState.clearAllState(false /* finishAnimation */);
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/ScreenPinnedInputConsumer.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/ScreenPinnedInputConsumer.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f207591d9dc36f67654950713153f3e4c02f5a4
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/inputconsumers/ScreenPinnedInputConsumer.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.inputconsumers;
+
+import android.content.Context;
+import android.os.RemoteException;
+import android.util.Log;
+import android.view.HapticFeedbackConstants;
+import android.view.MotionEvent;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.quickstep.ActivityControlHelper;
+import foundation.e.blisslauncher.quickstep.util.MotionPauseDetector;
+import com.android.systemui.shared.recents.ISystemUiProxy;
+
+/**
+ * An input consumer that detects swipe up and hold to exit screen pinning mode.
+ */
+public class ScreenPinnedInputConsumer implements InputConsumer {
+
+    private static final String TAG = "ScreenPinnedConsumer";
+
+    private final float mMotionPauseMinDisplacement;
+    private final MotionPauseDetector mMotionPauseDetector;
+
+    private float mTouchDownY;
+
+    public ScreenPinnedInputConsumer(Context context, ISystemUiProxy sysuiProxy,
+            ActivityControlHelper activityControl) {
+        mMotionPauseMinDisplacement = context.getResources().getDimension(
+                R.dimen.motion_pause_detector_min_displacement_from_app);
+        mMotionPauseDetector = new MotionPauseDetector(context, true /* makePauseHarderToTrigger*/);
+        mMotionPauseDetector.setOnMotionPauseListener(isPaused -> {
+            if (isPaused) {
+                try {
+                    sysuiProxy.stopScreenPinning();
+                    BaseDraggingActivity launcherActivity = activityControl.getCreatedActivity();
+                    if (launcherActivity != null) {
+                        launcherActivity.getRootView().performHapticFeedback(
+                                HapticFeedbackConstants.LONG_PRESS,
+                                HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
+                    }
+                    mMotionPauseDetector.clear();
+                } catch (RemoteException e) {
+                    Log.e(TAG, "Unable to stop screen pinning ", e);
+                }
+            }
+        });
+    }
+
+    @Override
+    public int getType() {
+        return TYPE_SCREEN_PINNED;
+    }
+
+    @Override
+    public void onMotionEvent(MotionEvent ev) {
+        float y = ev.getY();
+        switch (ev.getAction()) {
+            case MotionEvent.ACTION_DOWN:
+                mTouchDownY = y;
+                break;
+            case MotionEvent.ACTION_MOVE:
+                float displacement = mTouchDownY - y;
+                mMotionPauseDetector.setDisallowPause(displacement < mMotionPauseMinDisplacement);
+                mMotionPauseDetector.addPosition(y, ev.getEventTime());
+                break;
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP:
+                mMotionPauseDetector.clear();
+                break;
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/ClipAnimationHelper.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/ClipAnimationHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a61482d921232e690fd60e77e7cdb51c593925c
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/ClipAnimationHelper.java
@@ -0,0 +1,411 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.util;
+
+import static com.android.systemui.shared.system.QuickStepContract.getWindowCornerRadius;
+import static com.android.systemui.shared.system.QuickStepContract.supportsRoundedCornersOnWindows;
+import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_CLOSING;
+import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_OPENING;
+import static foundation.e.blisslauncher.core.Flags.ENABLE_QUICKSTEP_LIVE_TILE;
+
+import android.annotation.TargetApi;
+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.os.RemoteException;
+import androidx.annotation.Nullable;
+import com.android.systemui.shared.recents.ISystemUiProxy;
+import com.android.systemui.shared.recents.utilities.RectFEvaluator;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat;
+import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat.SurfaceParams;
+import com.android.systemui.shared.system.TransactionCompat;
+import com.android.systemui.shared.system.WindowManagerWrapper;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.features.test.BaseDragLayer;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.quickstep.RecentsModel;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskThumbnailView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+import java.util.function.BiFunction;
+
+/**
+ * Utility class to handle window clip animation
+ */
+@TargetApi(Build.VERSION_CODES.P)
+public class ClipAnimationHelper {
+
+    // The bounds of the source app in device coordinates
+    private final Rect mSourceStackBounds = new Rect();
+    // The insets of the source app
+    private final Rect mSourceInsets = new Rect();
+    // The source app bounds with the source insets applied, in the source app window coordinates
+    private final RectF mSourceRect = new RectF();
+    // The bounds of the task view in launcher window coordinates
+    private final RectF mTargetRect = new RectF();
+    // The insets to be used for clipping the app window, which can be larger than mSourceInsets
+    // if the aspect ratio of the target is smaller than the aspect ratio of the source rect. In
+    // app window coordinates.
+    private final RectF mSourceWindowClipInsets = new RectF();
+    // The insets to be used for clipping the app window. For live tile, we don't transform the clip
+    // relative to the target rect.
+    private final RectF mSourceWindowClipInsetsForLiveTile = new RectF();
+
+    // The bounds of launcher (not including insets) in device coordinates
+    public final Rect mHomeStackBounds = new Rect();
+
+    // The clip rect in source app window coordinates
+    private final RectF mClipRectF = new RectF();
+    private final RectFEvaluator mRectFEvaluator = new RectFEvaluator();
+    private final Matrix mTmpMatrix = new Matrix();
+    private final Rect mTmpRect = new Rect();
+    private final RectF mTmpRectF = new RectF();
+    private final RectF mCurrentRectWithInsets = new RectF();
+    // Corner radius of windows, in pixels
+    private final float mWindowCornerRadius;
+    // Corner radius of windows when they're in overview mode.
+    private final float mTaskCornerRadius;
+    // If windows can have real time rounded corners.
+    private final boolean mSupportsRoundedCornersOnWindows;
+    // Whether or not to actually use the rounded cornders on windows
+    private boolean mUseRoundedCornersOnWindows;
+
+    // Corner radius currently applied to transformed window.
+    private float mCurrentCornerRadius;
+
+    // Whether to boost the opening animation target layers, or the closing
+    private int mBoostModeTargetLayers = -1;
+
+    private BiFunction<RemoteAnimationTargetCompat, Float, Float> mTaskAlphaCallback =
+            (t, a1) -> a1;
+
+    public ClipAnimationHelper(Context context) {
+        mWindowCornerRadius = getWindowCornerRadius(context.getResources());
+        mSupportsRoundedCornersOnWindows = supportsRoundedCornersOnWindows(context.getResources());
+        mTaskCornerRadius = TaskCornerRadius.get(context);
+        mUseRoundedCornersOnWindows = mSupportsRoundedCornersOnWindows;
+    }
+
+    private void updateSourceStack(RemoteAnimationTargetCompat target) {
+        mSourceInsets.set(target.contentInsets);
+        mSourceStackBounds.set(target.sourceContainerBounds);
+
+        // TODO: Should sourceContainerBounds already have this offset?
+        mSourceStackBounds.offsetTo(target.position.x, target.position.y);
+
+    }
+
+    public void updateSource(Rect homeStackBounds, RemoteAnimationTargetCompat target) {
+        mHomeStackBounds.set(homeStackBounds);
+        updateSourceStack(target);
+    }
+
+    public void updateTargetRect(Rect targetRect) {
+        mSourceRect.set(mSourceInsets.left, mSourceInsets.top,
+                mSourceStackBounds.width() - mSourceInsets.right,
+                mSourceStackBounds.height() - mSourceInsets.bottom);
+        mTargetRect.set(targetRect);
+        mTargetRect.offset(mHomeStackBounds.left - mSourceStackBounds.left,
+                mHomeStackBounds.top - mSourceStackBounds.top);
+
+        // Calculate the clip based on the target rect (since the content insets and the
+        // launcher insets may differ, so the aspect ratio of the target rect can differ
+        // from the source rect. The difference between the target rect (scaled to the
+        // source rect) is the amount to clip on each edge.
+        RectF scaledTargetRect = new RectF(mTargetRect);
+        Utilities.scaleRectFAboutCenter(scaledTargetRect,
+                mSourceRect.width() / mTargetRect.width());
+        scaledTargetRect.offsetTo(mSourceRect.left, mSourceRect.top);
+        mSourceWindowClipInsets.set(
+                Math.max(scaledTargetRect.left, 0),
+                Math.max(scaledTargetRect.top, 0),
+                Math.max(mSourceStackBounds.width() - scaledTargetRect.right, 0),
+                Math.max(mSourceStackBounds.height() - scaledTargetRect.bottom, 0));
+        mSourceWindowClipInsetsForLiveTile.set(mSourceWindowClipInsets);
+        mSourceRect.set(scaledTargetRect);
+    }
+
+    public void prepareAnimation(VariantDeviceProfile dp, boolean isOpening) {
+        mBoostModeTargetLayers = isOpening ? MODE_OPENING : MODE_CLOSING;
+        mUseRoundedCornersOnWindows = mSupportsRoundedCornersOnWindows && !dp.isMultiWindowMode;
+    }
+
+    public RectF applyTransform(RemoteAnimationTargetSet targetSet, TransformParams params) {
+        return applyTransform(targetSet, params, true /* launcherOnTop */);
+    }
+
+    public RectF applyTransform(RemoteAnimationTargetSet targetSet, TransformParams params,
+            boolean launcherOnTop) {
+        float progress = params.progress;
+        if (params.currentRect == null) {
+            RectF currentRect;
+            mTmpRectF.set(mTargetRect);
+            Utilities.scaleRectFAboutCenter(mTmpRectF, params.offsetScale);
+            currentRect = mRectFEvaluator.evaluate(progress, mSourceRect, mTmpRectF);
+            currentRect.offset(params.offsetX, 0);
+
+            // Don't clip past progress > 1.
+            progress = Math.min(1, progress);
+            final RectF sourceWindowClipInsets = params.forLiveTile
+                    ? mSourceWindowClipInsetsForLiveTile : mSourceWindowClipInsets;
+            mClipRectF.left = sourceWindowClipInsets.left * progress;
+            mClipRectF.top = sourceWindowClipInsets.top * progress;
+            mClipRectF.right =
+                    mSourceStackBounds.width() - (sourceWindowClipInsets.right * progress);
+            mClipRectF.bottom =
+                    mSourceStackBounds.height() - (sourceWindowClipInsets.bottom * progress);
+            params.setCurrentRectAndTargetAlpha(currentRect, 1);
+        }
+
+        SurfaceParams[] surfaceParams = new SurfaceParams[targetSet.unfilteredApps.length];
+        for (int i = 0; i < targetSet.unfilteredApps.length; i++) {
+            RemoteAnimationTargetCompat app = targetSet.unfilteredApps[i];
+            mTmpMatrix.setTranslate(app.position.x, app.position.y);
+            Rect crop = mTmpRect;
+            crop.set(app.sourceContainerBounds);
+            crop.offsetTo(0, 0);
+            float alpha = 1f;
+            int layer = RemoteAnimationProvider.getLayer(app, mBoostModeTargetLayers);
+            float cornerRadius = 0f;
+            float scale = Math.max(params.currentRect.width(), mTargetRect.width()) / crop.width();
+            if (app.mode == targetSet.targetMode) {
+                alpha = mTaskAlphaCallback.apply(app, params.targetAlpha);
+                if (app.activityType != RemoteAnimationTargetCompat.ACTIVITY_TYPE_HOME) {
+                    mTmpMatrix.setRectToRect(mSourceRect, params.currentRect, ScaleToFit.FILL);
+                    mTmpMatrix.postTranslate(app.position.x, app.position.y);
+                    mClipRectF.roundOut(crop);
+                    if (mSupportsRoundedCornersOnWindows) {
+                        if (params.cornerRadius > -1) {
+                            cornerRadius = params.cornerRadius;
+                            scale = params.currentRect.width() / crop.width();
+                        } else {
+                            float windowCornerRadius = mUseRoundedCornersOnWindows
+                                    ? mWindowCornerRadius : 0;
+                            cornerRadius = Utilities.mapRange(progress, windowCornerRadius,
+                                    mTaskCornerRadius);
+                        }
+                        mCurrentCornerRadius = cornerRadius;
+                    }
+                } else if (targetSet.hasRecents) {
+                    // If home has a different target then recents, reverse anim the
+                    // home target.
+                    alpha = 1 - (progress * params.targetAlpha);
+                }
+            } else if (ENABLE_QUICKSTEP_LIVE_TILE && launcherOnTop) {
+                crop = null;
+                layer = Integer.MAX_VALUE;
+            }
+
+            // Since radius is in Surface space, but we draw the rounded corners in screen space, we
+            // have to undo the scale.
+            surfaceParams[i] = new SurfaceParams(app.leash, alpha, mTmpMatrix, crop, layer,
+                    cornerRadius / scale);
+        }
+        applySurfaceParams(params.syncTransactionApplier, surfaceParams);
+        return params.currentRect;
+    }
+
+    public RectF getCurrentRectWithInsets() {
+        mTmpMatrix.mapRect(mCurrentRectWithInsets, mClipRectF);
+        return mCurrentRectWithInsets;
+    }
+
+    private void applySurfaceParams(@Nullable SyncRtSurfaceTransactionApplierCompat
+            syncTransactionApplier, SurfaceParams[] params) {
+        if (syncTransactionApplier != null) {
+            syncTransactionApplier.scheduleApply(params);
+        } else {
+            TransactionCompat t = new TransactionCompat();
+            for (SurfaceParams param : params) {
+                SyncRtSurfaceTransactionApplierCompat.applyParams(t, param);
+            }
+            t.setEarlyWakeup();
+            t.apply();
+        }
+    }
+
+    public void setTaskAlphaCallback(
+            BiFunction<RemoteAnimationTargetCompat, Float, Float> callback) {
+        mTaskAlphaCallback = callback;
+    }
+
+    public void fromTaskThumbnailView(TaskThumbnailView ttv, RecentsView rv) {
+        fromTaskThumbnailView(ttv, rv, null);
+    }
+
+    public void fromTaskThumbnailView(TaskThumbnailView ttv, RecentsView rv,
+            @Nullable RemoteAnimationTargetCompat target) {
+        BaseDraggingActivity activity = BaseDraggingActivity.fromContext(ttv.getContext());
+        BaseDragLayer dl = activity.getDragLayer();
+
+        int[] pos = new int[2];
+        dl.getLocationOnScreen(pos);
+        mHomeStackBounds.set(0, 0, dl.getWidth(), dl.getHeight());
+        mHomeStackBounds.offset(pos[0], pos[1]);
+
+        if (target != null) {
+            updateSourceStack(target);
+        } else  if (rv.shouldUseMultiWindowTaskSizeStrategy()) {
+            updateStackBoundsToMultiWindowTaskSize(activity);
+        } else {
+            mSourceStackBounds.set(mHomeStackBounds);
+            Rect fallback = dl.getInsets();
+            mSourceInsets.set(ttv.getInsets(fallback));
+        }
+
+        Rect targetRect = new Rect();
+        dl.getDescendantRectRelativeToSelf(ttv, targetRect);
+        updateTargetRect(targetRect);
+
+        if (target == null) {
+            // Transform the clip relative to the target rect. Only do this in the case where we
+            // aren't applying the insets to the app windows (where the clip should be in target app
+            // space)
+            float scale = mTargetRect.width() / mSourceRect.width();
+            mSourceWindowClipInsets.left = mSourceWindowClipInsets.left * scale;
+            mSourceWindowClipInsets.top = mSourceWindowClipInsets.top * scale;
+            mSourceWindowClipInsets.right = mSourceWindowClipInsets.right * scale;
+            mSourceWindowClipInsets.bottom = mSourceWindowClipInsets.bottom * scale;
+        }
+    }
+
+    /**
+     * Compute scale and translation y such that the specified task view fills the screen.
+     */
+    public ClipAnimationHelper updateForFullscreenOverview(TaskView v) {
+        TaskThumbnailView thumbnailView = v.getThumbnail();
+        RecentsView recentsView = v.getRecentsView();
+        fromTaskThumbnailView(thumbnailView, recentsView);
+        Rect taskSize = new Rect();
+        recentsView.getTaskSize(taskSize);
+        updateTargetRect(taskSize);
+        return this;
+    }
+
+    /**
+     * @return The source rect's scale and translation relative to the target rect.
+     */
+    public LauncherState.ScaleAndTranslation getScaleAndTranslation() {
+        float scale = mSourceRect.width() / mTargetRect.width();
+        float translationY = mSourceRect.centerY() - mSourceRect.top - mTargetRect.centerY();
+        return new LauncherState.ScaleAndTranslation(scale, 0, translationY);
+    }
+
+    private void updateStackBoundsToMultiWindowTaskSize(BaseDraggingActivity activity) {
+        ISystemUiProxy sysUiProxy = RecentsModel.INSTANCE.get(activity).getSystemUiProxy();
+        if (sysUiProxy != null) {
+            try {
+                mSourceStackBounds.set(sysUiProxy.getNonMinimizedSplitScreenSecondaryBounds());
+                return;
+            } catch (RemoteException e) {
+                // Use half screen size
+            }
+        }
+
+        // Assume that the task size is half screen size (minus the insets and the divider size)
+        VariantDeviceProfile fullDp = activity.getDeviceProfile().getFullScreenProfile();
+        // Use availableWidthPx and availableHeightPx instead of widthPx and heightPx to
+        // account for system insets
+        int taskWidth = fullDp.getAvailableWidthPx();
+        int taskHeight = fullDp.getAvailableHeightPx();
+        int halfDividerSize = activity.getResources()
+                .getDimensionPixelSize(R.dimen.multi_window_task_divider_size) / 2;
+
+        Rect insets = new Rect();
+        WindowManagerWrapper.getInstance().getStableInsets(insets);
+        taskHeight = taskHeight / 2 - halfDividerSize;
+
+        // Align the task to bottom left/right edge (closer to nav bar).
+        int left = (insets.left + fullDp.getAvailableWidthPx() - taskWidth);
+        mSourceStackBounds.set(0, 0, taskWidth, taskHeight);
+        mSourceStackBounds.offset(left, insets.top + fullDp.getAvailableHeightPx() - taskHeight);
+    }
+
+    public RectF getTargetRect() {
+        return mTargetRect;
+    }
+
+    public float getCurrentCornerRadius() {
+        return mCurrentCornerRadius;
+    }
+
+    public static class TransformParams {
+        float progress;
+        public float offsetX;
+        public float offsetScale;
+        @Nullable RectF currentRect;
+        float targetAlpha;
+        boolean forLiveTile;
+        float cornerRadius;
+
+        SyncRtSurfaceTransactionApplierCompat syncTransactionApplier;
+
+        public TransformParams() {
+            progress = 0;
+            offsetX = 0;
+            offsetScale = 1;
+            currentRect = null;
+            targetAlpha = 0;
+            forLiveTile = false;
+            cornerRadius = -1;
+        }
+
+        public TransformParams setProgress(float progress) {
+            this.progress = progress;
+            this.currentRect = null;
+            return this;
+        }
+
+        public TransformParams setCornerRadius(float cornerRadius) {
+            this.cornerRadius = cornerRadius;
+            return this;
+        }
+
+        public TransformParams setCurrentRectAndTargetAlpha(RectF currentRect, float targetAlpha) {
+            this.currentRect = currentRect;
+            this.targetAlpha = targetAlpha;
+            return this;
+        }
+
+        public TransformParams setOffsetX(float offsetX) {
+            this.offsetX = offsetX;
+            return this;
+        }
+
+        public TransformParams setOffsetScale(float offsetScale) {
+            this.offsetScale = offsetScale;
+            return this;
+        }
+
+        public TransformParams setForLiveTile(boolean forLiveTile) {
+            this.forLiveTile = forLiveTile;
+            return this;
+        }
+
+        public TransformParams setSyncTransactionApplier(
+                SyncRtSurfaceTransactionApplierCompat applier) {
+            this.syncTransactionApplier = applier;
+            return this;
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/NavBarPosition.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/NavBarPosition.java
new file mode 100644
index 0000000000000000000000000000000000000000..f9a6a4f6b9a54ead89b005fd781e1dd49ba73fd2
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/NavBarPosition.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.util;
+
+import static foundation.e.blisslauncher.quickstep.SysUINavigationMode.Mode.NO_BUTTON;
+import static foundation.e.blisslauncher.uioverrides.RecentsUiFactory.ROTATION_LANDSCAPE;
+import static foundation.e.blisslauncher.uioverrides.RecentsUiFactory.ROTATION_SEASCAPE;
+
+import android.content.Context;
+import android.view.Surface;
+import android.view.WindowManager;
+import foundation.e.blisslauncher.features.test.graphics.RotationMode;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode;
+
+/**
+ * Utility class to check nav bar position
+ */
+public class NavBarPosition {
+
+    private final SysUINavigationMode.Mode mMode;
+    private final int mDisplayRotation;
+
+    public NavBarPosition(Context context) {
+        mMode = SysUINavigationMode.getMode(context);
+        mDisplayRotation = context.getSystemService(WindowManager.class)
+                .getDefaultDisplay().getRotation();
+    }
+
+    public boolean isRightEdge() {
+        return mMode != NO_BUTTON && mDisplayRotation == Surface.ROTATION_90;
+    }
+
+    public boolean isLeftEdge() {
+        return mMode != NO_BUTTON && mDisplayRotation == Surface.ROTATION_270;
+    }
+
+    public RotationMode getRotationMode() {
+        return isLeftEdge() ? ROTATION_SEASCAPE
+                : (isRightEdge() ? ROTATION_LANDSCAPE : RotationMode.NORMAL);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/RecentsAnimationListenerSet.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/RecentsAnimationListenerSet.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac5042592f5765c462d394c37b4aeaf254da191a
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/RecentsAnimationListenerSet.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.util;
+
+import static foundation.e.blisslauncher.quickstep.TouchInteractionService.MAIN_THREAD_EXECUTOR;
+
+import android.graphics.Rect;
+import android.util.ArraySet;
+import androidx.annotation.UiThread;
+import com.android.systemui.shared.system.RecentsAnimationControllerCompat;
+import com.android.systemui.shared.system.RecentsAnimationListener;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.utils.Preconditions;
+import foundation.e.blisslauncher.quickstep.util.SwipeAnimationTargetSet.SwipeAnimationListener;
+import java.util.Set;
+import java.util.function.Consumer;
+
+/**
+ * Wrapper around {@link RecentsAnimationListener} which delegates callbacks to multiple listeners
+ * on the main thread
+ */
+public class RecentsAnimationListenerSet implements RecentsAnimationListener {
+
+    // The actual app surface is replaced by a screenshot upon recents animation cancelation when
+    // deferredWithScreenshot is true. Launcher takes the responsibility to clean up this screenshot
+    // after app transition is finished. This delay is introduced to cover the app transition
+    // period of time.
+    private final int TRANSITION_DELAY = 100;
+
+    private final Set<SwipeAnimationListener> mListeners = new ArraySet<>();
+    private final boolean mShouldMinimizeSplitScreen;
+    private final Consumer<SwipeAnimationTargetSet> mOnFinishListener;
+    private RecentsAnimationControllerCompat mController;
+
+    private boolean mCancelled;
+
+    public RecentsAnimationListenerSet(boolean shouldMinimizeSplitScreen,
+            Consumer<SwipeAnimationTargetSet> onFinishListener) {
+        mShouldMinimizeSplitScreen = shouldMinimizeSplitScreen;
+        mOnFinishListener = onFinishListener;
+    }
+
+    @UiThread
+    public void addListener(SwipeAnimationListener listener) {
+        Preconditions.assertUIThread();
+        mListeners.add(listener);
+    }
+
+    @UiThread
+    public void removeListener(SwipeAnimationListener listener) {
+        Preconditions.assertUIThread();
+        mListeners.remove(listener);
+    }
+
+    @Override
+    public final void onAnimationStart(RecentsAnimationControllerCompat controller,
+            RemoteAnimationTargetCompat[] targets, Rect homeContentInsets,
+            Rect minimizedHomeBounds) {
+        mController = controller;
+        SwipeAnimationTargetSet targetSet = new SwipeAnimationTargetSet(controller, targets,
+                homeContentInsets, minimizedHomeBounds, mShouldMinimizeSplitScreen,
+                mOnFinishListener);
+
+        if (mCancelled) {
+            targetSet.cancelAnimation();
+        } else {
+            Utilities.postAsyncCallback(MAIN_THREAD_EXECUTOR.getHandler(), () -> {
+                for (SwipeAnimationListener listener : getListeners()) {
+                    listener.onRecentsAnimationStart(targetSet);
+                }
+            });
+        }
+    }
+
+    @Override
+    public final void onAnimationCanceled(boolean deferredWithScreenshot) {
+        Utilities.postAsyncCallback(MAIN_THREAD_EXECUTOR.getHandler(), () -> {
+            for (SwipeAnimationListener listener : getListeners()) {
+                listener.onRecentsAnimationCanceled();
+            }
+        });
+        // TODO: handle the transition better instead of simply using a transition delay.
+        if (deferredWithScreenshot) {
+            MAIN_THREAD_EXECUTOR.getHandler().postDelayed(() -> mController.cleanupScreenshot(),
+                    TRANSITION_DELAY);
+        }
+    }
+
+    private SwipeAnimationListener[] getListeners() {
+        return mListeners.toArray(new SwipeAnimationListener[mListeners.size()]);
+    }
+
+    public void cancelListener() {
+        mCancelled = true;
+        onAnimationCanceled(false);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/RectFSpringAnim.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/RectFSpringAnim.java
new file mode 100644
index 0000000000000000000000000000000000000000..203fa53cae05ac469c61f69a88e39fa578b5b10d
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/RectFSpringAnim.java
@@ -0,0 +1,230 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.util;
+
+import android.animation.Animator;
+import android.content.res.Resources;
+import android.graphics.PointF;
+import android.graphics.RectF;
+
+import androidx.dynamicanimation.animation.DynamicAnimation.OnAnimationEndListener;
+import androidx.dynamicanimation.animation.FloatPropertyCompat;
+import androidx.dynamicanimation.animation.SpringAnimation;
+import androidx.dynamicanimation.animation.SpringForce;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.features.test.anim.FlingSpringAnim;
+
+/**
+ * Applies spring forces to animate from a starting rect to a target rect,
+ * while providing update callbacks to the caller.
+ */
+public class RectFSpringAnim {
+
+    private static final FloatPropertyCompat<RectFSpringAnim> RECT_CENTER_X =
+            new FloatPropertyCompat<RectFSpringAnim>("rectCenterXSpring") {
+                @Override
+                public float getValue(RectFSpringAnim anim) {
+                    return anim.mCurrentCenterX;
+                }
+
+                @Override
+                public void setValue(RectFSpringAnim anim, float currentCenterX) {
+                    anim.mCurrentCenterX = currentCenterX;
+                    anim.onUpdate();
+                }
+            };
+
+    private static final FloatPropertyCompat<RectFSpringAnim> RECT_Y =
+            new FloatPropertyCompat<RectFSpringAnim>("rectYSpring") {
+                @Override
+                public float getValue(RectFSpringAnim anim) {
+                    return anim.mCurrentY;
+                }
+
+                @Override
+                public void setValue(RectFSpringAnim anim, float y) {
+                    anim.mCurrentY = y;
+                    anim.onUpdate();
+                }
+            };
+
+    private static final FloatPropertyCompat<RectFSpringAnim> RECT_SCALE_PROGRESS =
+            new FloatPropertyCompat<RectFSpringAnim>("rectScaleProgress") {
+                @Override
+                public float getValue(RectFSpringAnim object) {
+                    return object.mCurrentScaleProgress;
+                }
+
+                @Override
+                public void setValue(RectFSpringAnim object, float value) {
+                    object.mCurrentScaleProgress = value;
+                    object.onUpdate();
+                }
+            };
+
+    private final RectF mStartRect;
+    private final RectF mTargetRect;
+    private final RectF mCurrentRect = new RectF();
+    private final List<OnUpdateListener> mOnUpdateListeners = new ArrayList<>();
+    private final List<Animator.AnimatorListener> mAnimatorListeners = new ArrayList<>();
+
+    private float mCurrentCenterX;
+    private float mCurrentY;
+    // If true, tracking the bottom of the rects, else tracking the top.
+    private boolean mTrackingBottomY;
+    private float mCurrentScaleProgress;
+    private FlingSpringAnim mRectXAnim;
+    private FlingSpringAnim mRectYAnim;
+    private SpringAnimation mRectScaleAnim;
+    private boolean mAnimsStarted;
+    private boolean mRectXAnimEnded;
+    private boolean mRectYAnimEnded;
+    private boolean mRectScaleAnimEnded;
+
+    private float mMinVisChange;
+    private float mYOvershoot;
+
+    public RectFSpringAnim(RectF startRect, RectF targetRect, Resources resources) {
+        mStartRect = startRect;
+        mTargetRect = targetRect;
+        mCurrentCenterX = mStartRect.centerX();
+
+        mTrackingBottomY = startRect.bottom < targetRect.bottom;
+        mCurrentY = mTrackingBottomY ? mStartRect.bottom : mStartRect.top;
+
+        mMinVisChange = resources.getDimensionPixelSize(R.dimen.swipe_up_fling_min_visible_change);
+        mYOvershoot = resources.getDimensionPixelSize(R.dimen.swipe_up_y_overshoot);
+    }
+
+    public void onTargetPositionChanged() {
+        if (mRectXAnim != null && mRectXAnim.getTargetPosition() != mTargetRect.centerX()) {
+            mRectXAnim.updatePosition(mCurrentCenterX, mTargetRect.centerX());
+        }
+
+        if (mRectYAnim != null) {
+            if (mTrackingBottomY && mRectYAnim.getTargetPosition() != mTargetRect.bottom) {
+                mRectYAnim.updatePosition(mCurrentY, mTargetRect.bottom);
+            } else if (!mTrackingBottomY && mRectYAnim.getTargetPosition() != mTargetRect.top) {
+                mRectYAnim.updatePosition(mCurrentY, mTargetRect.top);
+            }
+        }
+    }
+
+    public void addOnUpdateListener(OnUpdateListener onUpdateListener) {
+        mOnUpdateListeners.add(onUpdateListener);
+    }
+
+    public void addAnimatorListener(Animator.AnimatorListener animatorListener) {
+        mAnimatorListeners.add(animatorListener);
+    }
+
+    public void start(PointF velocityPxPerMs) {
+        // Only tell caller that we ended if both x and y animations have ended.
+        OnAnimationEndListener onXEndListener = ((animation, canceled, centerX, velocityX) -> {
+            mRectXAnimEnded = true;
+            maybeOnEnd();
+        });
+        OnAnimationEndListener onYEndListener = ((animation, canceled, centerY, velocityY) -> {
+            mRectYAnimEnded = true;
+            maybeOnEnd();
+        });
+
+        float startX = mCurrentCenterX;
+        float endX = mTargetRect.centerX();
+        float minXValue = Math.min(startX, endX);
+        float maxXValue = Math.max(startX, endX);
+        mRectXAnim = new FlingSpringAnim(this, RECT_CENTER_X, startX, endX,
+                velocityPxPerMs.x * 1000, mMinVisChange, minXValue, maxXValue, 1f, onXEndListener);
+
+        float startVelocityY = velocityPxPerMs.y * 1000;
+        // Scale the Y velocity based on the initial velocity to tune the curves.
+        float springVelocityFactor = 0.1f + 0.9f * Math.abs(startVelocityY) / 20000.0f;
+        float startY = mCurrentY;
+        float endY = mTrackingBottomY ? mTargetRect.bottom : mTargetRect.top;
+        float minYValue = Math.min(startY, endY - mYOvershoot);
+        float maxYValue = Math.max(startY, endY);
+        mRectYAnim = new FlingSpringAnim(this, RECT_Y, startY, endY, startVelocityY,
+                mMinVisChange, minYValue, maxYValue, springVelocityFactor, onYEndListener);
+
+        float minVisibleChange = 1f / mStartRect.height();
+        mRectScaleAnim = new SpringAnimation(this, RECT_SCALE_PROGRESS)
+                .setSpring(new SpringForce(1f)
+                .setDampingRatio(SpringForce.DAMPING_RATIO_LOW_BOUNCY)
+                .setStiffness(SpringForce.STIFFNESS_LOW))
+                .setStartVelocity(velocityPxPerMs.y * minVisibleChange)
+                .setMaxValue(1f)
+                .setMinimumVisibleChange(minVisibleChange)
+                .addEndListener((animation, canceled, value, velocity) -> {
+                    mRectScaleAnimEnded = true;
+                    maybeOnEnd();
+                });
+
+        mRectXAnim.start();
+        mRectYAnim.start();
+        mRectScaleAnim.start();
+        mAnimsStarted = true;
+        for (Animator.AnimatorListener animatorListener : mAnimatorListeners) {
+            animatorListener.onAnimationStart(null);
+        }
+    }
+
+    public void end() {
+        if (mAnimsStarted) {
+            mRectXAnim.end();
+            mRectYAnim.end();
+            if (mRectScaleAnim.canSkipToEnd()) {
+                mRectScaleAnim.skipToEnd();
+            }
+        }
+    }
+
+    private void onUpdate() {
+        if (!mOnUpdateListeners.isEmpty()) {
+            float currentWidth = Utilities.mapRange(mCurrentScaleProgress, mStartRect.width(),
+                    mTargetRect.width());
+            float currentHeight = Utilities.mapRange(mCurrentScaleProgress, mStartRect.height(),
+                    mTargetRect.height());
+            if (mTrackingBottomY) {
+                mCurrentRect.set(mCurrentCenterX - currentWidth / 2, mCurrentY - currentHeight,
+                        mCurrentCenterX + currentWidth / 2, mCurrentY);
+            } else {
+                mCurrentRect.set(mCurrentCenterX - currentWidth / 2, mCurrentY,
+                        mCurrentCenterX + currentWidth / 2, mCurrentY + currentHeight);
+            }
+            for (OnUpdateListener onUpdateListener : mOnUpdateListeners) {
+                onUpdateListener.onUpdate(mCurrentRect, mCurrentScaleProgress);
+            }
+        }
+    }
+
+    private void maybeOnEnd() {
+        if (mAnimsStarted && mRectXAnimEnded && mRectYAnimEnded && mRectScaleAnimEnded) {
+            mAnimsStarted = false;
+            for (Animator.AnimatorListener animatorListener : mAnimatorListeners) {
+                animatorListener.onAnimationEnd(null);
+            }
+        }
+    }
+
+    public interface OnUpdateListener {
+        void onUpdate(RectF currentRect, float progress);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/SwipeAnimationTargetSet.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/SwipeAnimationTargetSet.java
new file mode 100644
index 0000000000000000000000000000000000000000..96bc8eceb4a585c1ad52066162ece172409df13e
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/SwipeAnimationTargetSet.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.util;
+
+import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_CLOSING;
+import static foundation.e.blisslauncher.quickstep.TouchInteractionService.BACKGROUND_EXECUTOR;
+import static foundation.e.blisslauncher.quickstep.TouchInteractionService.MAIN_THREAD_EXECUTOR;
+
+import android.graphics.Rect;
+import com.android.systemui.shared.recents.model.ThumbnailData;
+import com.android.systemui.shared.system.RecentsAnimationControllerCompat;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import java.util.function.Consumer;
+
+/**
+ * Extension of {@link RemoteAnimationTargetSet} with additional information about swipe
+ * up animation
+ */
+public class SwipeAnimationTargetSet extends RemoteAnimationTargetSet {
+
+    private final boolean mShouldMinimizeSplitScreen;
+    private final Consumer<SwipeAnimationTargetSet> mOnFinishListener;
+
+    public final RecentsAnimationControllerCompat controller;
+    public final Rect homeContentInsets;
+    public final Rect minimizedHomeBounds;
+
+    public SwipeAnimationTargetSet(RecentsAnimationControllerCompat controller,
+            RemoteAnimationTargetCompat[] targets, Rect homeContentInsets,
+            Rect minimizedHomeBounds, boolean shouldMinimizeSplitScreen,
+            Consumer<SwipeAnimationTargetSet> onFinishListener) {
+        super(targets, MODE_CLOSING);
+        this.controller = controller;
+        this.homeContentInsets = homeContentInsets;
+        this.minimizedHomeBounds = minimizedHomeBounds;
+        this.mShouldMinimizeSplitScreen = shouldMinimizeSplitScreen;
+        this.mOnFinishListener = onFinishListener;
+    }
+
+    public boolean hasTargets() {
+        return unfilteredApps.length != 0;
+    }
+
+    /**
+     * Clones the target set without any actual targets. Used only when continuing a gesture after
+     * the actual recents animation has finished.
+     */
+    public SwipeAnimationTargetSet cloneWithoutTargets() {
+        return new SwipeAnimationTargetSet(controller, new RemoteAnimationTargetCompat[0],
+                homeContentInsets, minimizedHomeBounds, mShouldMinimizeSplitScreen,
+                mOnFinishListener);
+    }
+
+    public void finishController(boolean toRecents, Runnable callback, boolean sendUserLeaveHint) {
+        mOnFinishListener.accept(this);
+        BACKGROUND_EXECUTOR.execute(() -> {
+            controller.setInputConsumerEnabled(false);
+            controller.finish(toRecents, sendUserLeaveHint);
+
+            if (callback != null) {
+                MAIN_THREAD_EXECUTOR.execute(callback);
+            }
+        });
+    }
+
+    public void enableInputConsumer() {
+        BACKGROUND_EXECUTOR.submit(() -> {
+            controller.hideCurrentInputMethod();
+            controller.setInputConsumerEnabled(true);
+        });
+    }
+
+    public void setWindowThresholdCrossed(boolean thresholdCrossed) {
+        BACKGROUND_EXECUTOR.execute(() -> {
+            controller.setAnimationTargetsBehindSystemBars(!thresholdCrossed);
+            if (mShouldMinimizeSplitScreen && thresholdCrossed) {
+                // NOTE: As a workaround for conflicting animations (Launcher animating the task
+                // leash, and SystemUI resizing the docked stack, which resizes the task), we
+                // currently only set the minimized mode, and not the inverse.
+                // TODO: Synchronize the minimize animation with the launcher animation
+                controller.setSplitScreenMinimized(thresholdCrossed);
+            }
+        });
+    }
+
+    public ThumbnailData screenshotTask(int taskId) {
+        return controller != null ? controller.screenshotTask(taskId) : null;
+    }
+
+    public void cancelAnimation() {
+        finishController(false /* toRecents */, null, false /* sendUserLeaveHint */);
+    }
+
+    public void finishAnimation() {
+        finishController(true /* toRecents */, null, false /* sendUserLeaveHint */);
+    }
+
+    public interface SwipeAnimationListener {
+
+        void onRecentsAnimationStart(SwipeAnimationTargetSet targetSet);
+
+        void onRecentsAnimationCanceled();
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/TaskCornerRadius.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/TaskCornerRadius.java
new file mode 100644
index 0000000000000000000000000000000000000000..5be10c87a81231aca77f3c5238e497ee251b0fcb
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/TaskCornerRadius.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.util;
+
+import static com.android.systemui.shared.system.QuickStepContract.supportsRoundedCornersOnWindows;
+
+import android.content.Context;
+import foundation.e.blisslauncher.R;
+
+public class TaskCornerRadius {
+
+    public static float get(Context context) {
+        return supportsRoundedCornersOnWindows(context.getResources()) ?
+                Themes.getDialogCornerRadius(context):
+                context.getResources().getDimension(R.dimen.task_corner_radius_small);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/ViewPool.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/ViewPool.java
new file mode 100644
index 0000000000000000000000000000000000000000..98bab2b0b0c75fd8c4a576451432af0f340768d0
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/util/ViewPool.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.util;
+
+import android.content.Context;
+import android.os.Handler;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.AnyThread;
+import androidx.annotation.Nullable;
+import androidx.annotation.UiThread;
+
+import foundation.e.blisslauncher.core.utils.Preconditions;
+
+/**
+ * Utility class to maintain a pool of reusable views.
+ * During initialization, views are inflated on the background thread.
+ */
+public class ViewPool<T extends View & ViewPool.Reusable> {
+
+    private final Object[] mPool;
+
+    private final LayoutInflater mInflater;
+    private final ViewGroup mParent;
+    private final int mLayoutId;
+
+    private int mCurrentSize = 0;
+
+    public ViewPool(Context context, @Nullable ViewGroup parent,
+            int layoutId, int maxSize, int initialSize) {
+        mLayoutId = layoutId;
+        mParent = parent;
+        mInflater = LayoutInflater.from(context);
+        mPool = new Object[maxSize];
+
+        if (initialSize > 0) {
+            initPool(initialSize);
+        }
+    }
+
+    @UiThread
+    private void initPool(int initialSize) {
+        Preconditions.assertUIThread();
+        Handler handler = new Handler();
+
+        // Inflate views on a non looper thread. This allows us to catch errors like calling
+        // "new Handler()" in constructor easily.
+        new Thread(() -> {
+            for (int i = 0; i < initialSize; i++) {
+                T view = inflateNewView();
+                handler.post(() -> addToPool(view));
+            }
+        }).start();
+    }
+
+    @UiThread
+    public void recycle(T view) {
+        Preconditions.assertUIThread();
+        view.onRecycle();
+        addToPool(view);
+    }
+
+    @UiThread
+    private void addToPool(T view) {
+        Preconditions.assertUIThread();
+        if (mCurrentSize >= mPool.length) {
+            // pool is full
+            return;
+        }
+
+        mPool[mCurrentSize] = view;
+        mCurrentSize++;
+    }
+
+    @UiThread
+    public T getView() {
+        Preconditions.assertUIThread();
+        if (mCurrentSize > 0) {
+            mCurrentSize--;
+            return (T) mPool[mCurrentSize];
+        }
+        return inflateNewView();
+    }
+
+    @AnyThread
+    private T inflateNewView() {
+        return (T) mInflater.inflate(mLayoutId, mParent, false);
+    }
+
+    /**
+     * Interface to indicate that a view is reusable
+     */
+    public interface Reusable {
+
+        /**
+         * Called when a view is recycled / added back to the pool
+         */
+        void onRecycle();
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/ClearAllButton.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/ClearAllButton.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c2f1e0a45dbddc6fec40380d1f534ff75282bff
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/ClearAllButton.java
@@ -0,0 +1,101 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.views;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.util.Property;
+import android.widget.Button;
+
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.quickstep.views.RecentsView.PageCallbacks;
+import foundation.e.blisslauncher.quickstep.views.RecentsView.ScrollState;
+
+public class ClearAllButton extends Button implements PageCallbacks {
+
+    public static final Property<ClearAllButton, Float> VISIBILITY_ALPHA =
+            new Property<ClearAllButton, Float>(Float.class, "visibilityAlpha") {
+                @Override
+                public Float get(ClearAllButton view) {
+                    return view.mVisibilityAlpha;
+                }
+
+                @Override
+                public void set(ClearAllButton view, Float visibilityAlpha) {
+                    view.setVisibilityAlpha(visibilityAlpha);
+                }
+            };
+
+    private float mScrollAlpha = 1;
+    private float mContentAlpha = 1;
+    private float mVisibilityAlpha = 1;
+
+    private final boolean mIsRtl;
+
+    private int mScrollOffset;
+
+    public ClearAllButton(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        mIsRtl = Utilities.isRtl(context.getResources());
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        super.onLayout(changed, left, top, right, bottom);
+
+        RecentsView parent = (RecentsView) getParent();
+        mScrollOffset = mIsRtl ? parent.getPaddingRight() / 2 : - parent.getPaddingLeft() / 2;
+    }
+
+    @Override
+    public boolean hasOverlappingRendering() {
+        return false;
+    }
+
+    public void setContentAlpha(float alpha) {
+        if (mContentAlpha != alpha) {
+            mContentAlpha = alpha;
+            updateAlpha();
+        }
+    }
+
+    public void setVisibilityAlpha(float alpha) {
+        if (mVisibilityAlpha != alpha) {
+            mVisibilityAlpha = alpha;
+            updateAlpha();
+        }
+    }
+
+    @Override
+    public void onPageScroll(ScrollState scrollState) {
+        float width = getWidth();
+        if (width == 0) {
+            return;
+        }
+
+        float shift = Math.min(scrollState.scrollFromEdge, width);
+        setTranslationX(mIsRtl ? (mScrollOffset - shift) : (mScrollOffset + shift));
+        mScrollAlpha = 1 - shift / width;
+        updateAlpha();
+    }
+
+    private void updateAlpha() {
+        final float alpha = mScrollAlpha * mContentAlpha * mVisibilityAlpha;
+        setAlpha(alpha);
+        setClickable(alpha == 1);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/IconView.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/IconView.java
new file mode 100644
index 0000000000000000000000000000000000000000..37b8082d1440220393457fbe76c68e6a22bde69e
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/IconView.java
@@ -0,0 +1,116 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.views;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.view.View;
+
+import java.util.ArrayList;
+
+/**
+ * A view which draws a drawable stretched to fit its size. Unlike ImageView, it avoids relayout
+ * when the drawable changes.
+ */
+public class IconView extends View {
+
+    public interface OnScaleUpdateListener {
+        public void onScaleUpdate(float scale);
+    }
+
+    private Drawable mDrawable;
+
+    private ArrayList<OnScaleUpdateListener> mScaleListeners;
+
+    public IconView(Context context) {
+        super(context);
+    }
+
+    public IconView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public IconView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    public void setDrawable(Drawable d) {
+        if (mDrawable != null) {
+            mDrawable.setCallback(null);
+        }
+        mDrawable = d;
+        if (mDrawable != null) {
+            mDrawable.setCallback(this);
+            mDrawable.setBounds(0, 0, getWidth(), getHeight());
+        }
+        invalidate();
+    }
+
+    public Drawable getDrawable() {
+        return mDrawable;
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+        if (mDrawable != null) {
+            mDrawable.setBounds(0, 0, w, h);
+        }
+    }
+
+    @Override
+    protected boolean verifyDrawable(Drawable who) {
+        return super.verifyDrawable(who) || who == mDrawable;
+    }
+
+    @Override
+    protected void drawableStateChanged() {
+        super.drawableStateChanged();
+
+        final Drawable drawable = mDrawable;
+        if (drawable != null && drawable.isStateful()
+                && drawable.setState(getDrawableState())) {
+            invalidateDrawable(drawable);
+        }
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        if (mDrawable != null) {
+            mDrawable.draw(canvas);
+        }
+    }
+
+    @Override
+    public boolean hasOverlappingRendering() {
+        return false;
+    }
+
+    public void addUpdateScaleListener(OnScaleUpdateListener listener) {
+        if (mScaleListeners == null) {
+            mScaleListeners = new ArrayList<>();
+        }
+        mScaleListeners.add(listener);
+    }
+
+    public void removeUpdateScaleListener(OnScaleUpdateListener listener) {
+        if (mScaleListeners != null) {
+            mScaleListeners.remove(listener);
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/LauncherRecentsView.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/LauncherRecentsView.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f611cf2ea29aaa2ce3a19d1a6696ff4287864a4
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/LauncherRecentsView.java
@@ -0,0 +1,234 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.views;
+
+import static foundation.e.blisslauncher.core.Flags.ENABLE_QUICKSTEP_LIVE_TILE;
+import static foundation.e.blisslauncher.features.test.LauncherState.NORMAL;
+import static foundation.e.blisslauncher.features.test.LauncherState.OVERVIEW;
+import static foundation.e.blisslauncher.features.test.LauncherState.RECENTS_CLEAR_ALL_BUTTON;
+
+import android.animation.AnimatorSet;
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.os.Build;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.View;
+import foundation.e.blisslauncher.features.launcher.Hotseat;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.LauncherStateManager;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode;
+import foundation.e.blisslauncher.quickstep.util.ClipAnimationHelper;
+import foundation.e.blisslauncher.quickstep.util.ClipAnimationHelper.TransformParams;
+import foundation.e.blisslauncher.quickstep.util.LayoutUtils;
+
+/**
+ * {@link RecentsView} used in Launcher activity
+ */
+@TargetApi(Build.VERSION_CODES.O)
+public class LauncherRecentsView extends RecentsView<TestActivity> implements
+    LauncherStateManager.StateListener {
+
+    private final TransformParams mTransformParams = new TransformParams();
+
+    public LauncherRecentsView(Context context) {
+        this(context, null);
+    }
+
+    public LauncherRecentsView(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public LauncherRecentsView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        setContentAlpha(0);
+        mActivity.getStateManager().addStateListener(this);
+    }
+
+    @Override
+    public void startHome() {
+        mActivity.getStateManager().goToState(NORMAL);
+    }
+
+    @Override
+    public void setTranslationY(float translationY) {
+        super.setTranslationY(translationY);
+        if (ENABLE_QUICKSTEP_LIVE_TILE) {
+            LauncherState state = mActivity.getStateManager().getState();
+            if (state == OVERVIEW) {
+                redrawLiveTile(false);
+            }
+        }
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        maybeDrawEmptyMessage(canvas);
+        super.draw(canvas);
+    }
+
+    @Override
+    public void onViewAdded(View child) {
+        super.onViewAdded(child);
+        updateEmptyMessage();
+    }
+
+    @Override
+    protected void onTaskStackUpdated() {
+        // Lazily update the empty message only when the task stack is reapplied
+        updateEmptyMessage();
+    }
+
+    /**
+     * Animates adjacent tasks and translate hotseat off screen as well.
+     */
+    @Override
+    public AnimatorSet createAdjacentPageAnimForTaskLaunch(TaskView tv,
+            ClipAnimationHelper helper) {
+        AnimatorSet anim = super.createAdjacentPageAnimForTaskLaunch(tv, helper);
+
+        if (!SysUINavigationMode.getMode(mActivity).hasGestures) {
+            // Hotseat doesn't move when opening recents with the button,
+            // so don't animate it here either.
+            return anim;
+        }
+        return anim;
+    }
+
+    @Override
+    protected void getTaskSize(VariantDeviceProfile dp, Rect outRect) {
+        LayoutUtils.calculateLauncherTaskSize(getContext(), dp, outRect);
+    }
+
+    @Override
+    protected void onTaskLaunchAnimationUpdate(float progress, TaskView tv) {
+        if (ENABLE_QUICKSTEP_LIVE_TILE) {
+            if (mRecentsAnimationWrapper.targetSet != null && tv.isRunningTask()) {
+                mTransformParams.setProgress(1 - progress)
+                        .setSyncTransactionApplier(mSyncTransactionApplier)
+                        .setForLiveTile(true);
+                mClipAnimationHelper.applyTransform(mRecentsAnimationWrapper.targetSet,
+                        mTransformParams);
+            } else {
+                redrawLiveTile(true);
+            }
+        }
+    }
+
+    @Override
+    protected void onTaskLaunched(boolean success) {
+        if (success) {
+            mActivity.getStateManager().goToState(NORMAL, false /* animate */);
+        }
+        super.onTaskLaunched(success);
+    }
+
+    @Override
+    public boolean shouldUseMultiWindowTaskSizeStrategy() {
+        return mActivity.isInMultiWindowMode();
+    }
+
+    @Override
+    public void scrollTo(int x, int y) {
+        super.scrollTo(x, y);
+        if (ENABLE_QUICKSTEP_LIVE_TILE && mEnableDrawingLiveTile) {
+            redrawLiveTile(true);
+        }
+    }
+
+    @Override
+    public void redrawLiveTile(boolean mightNeedToRefill) {
+        if (!mEnableDrawingLiveTile || mRecentsAnimationWrapper == null
+                || mClipAnimationHelper == null) {
+            return;
+        }
+        TaskView taskView = getRunningTaskView();
+        if (taskView != null) {
+            taskView.getThumbnail().getGlobalVisibleRect(mTempRect);
+            int offsetX = (int) (mTaskWidth * taskView.getScaleX() * getScaleX()
+                    - mTempRect.width());
+            int offsetY = (int) (mTaskHeight * taskView.getScaleY() * getScaleY()
+                    - mTempRect.height());
+            if (((mCurrentPage != 0) || mightNeedToRefill) && offsetX > 0) {
+                if (mTempRect.left - offsetX < 0) {
+                    mTempRect.left -= offsetX;
+                } else {
+                    mTempRect.right += offsetX;
+                }
+            }
+            if (mightNeedToRefill && offsetY > 0) {
+                mTempRect.top -= offsetY;
+            }
+            mTempRectF.set(mTempRect);
+            mTransformParams.setProgress(1f)
+                    .setCurrentRectAndTargetAlpha(mTempRectF, taskView.getAlpha())
+                    .setSyncTransactionApplier(mSyncTransactionApplier);
+            if (mRecentsAnimationWrapper.targetSet != null) {
+                mClipAnimationHelper.applyTransform(mRecentsAnimationWrapper.targetSet,
+                        mTransformParams);
+            }
+        }
+    }
+
+    @Override
+    public void reset() {
+        super.reset();
+        // TODO: May use it when adding predictions.
+    }
+
+    @Override
+    public void onStateTransitionStart(LauncherState toState) {
+        setOverviewStateEnabled(toState.overviewUi);
+        setFreezeViewVisibility(true);
+    }
+
+    @Override
+    public void onStateTransitionComplete(LauncherState finalState) {
+        if (finalState == NORMAL) {
+            // Clean-up logic that occurs when recents is no longer in use/visible.
+            reset();
+        }
+        setOverlayEnabled(finalState == OVERVIEW);
+        setFreezeViewVisibility(false);
+    }
+
+    @Override
+    public void setOverviewStateEnabled(boolean enabled) {
+        super.setOverviewStateEnabled(enabled);
+        if (enabled) {
+            LauncherState state = mActivity.getStateManager().getState();
+            boolean hasClearAllButton = (state.getVisibleElements(mActivity)
+                    & RECENTS_CLEAR_ALL_BUTTON) != 0;
+            setDisallowScrollToClearAll(!hasClearAllButton);
+        }
+    }
+
+    @Override
+    protected boolean shouldStealTouchFromSiblingsBelow(MotionEvent ev) {
+        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
+            // Allow touches to go through to the hotseat.
+            Hotseat hotseat = mActivity.getHotseat();
+            boolean touchingHotseat = hotseat.isShown()
+                    && mActivity.getDragLayer().isEventOverView(hotseat, ev, this);
+            return !touchingHotseat;
+        }
+        return super.shouldStealTouchFromSiblingsBelow(ev);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/LiveTileOverlay.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/LiveTileOverlay.java
new file mode 100644
index 0000000000000000000000000000000000000000..47e8d1c5f25db964587605b66932968095ad5b74
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/LiveTileOverlay.java
@@ -0,0 +1,130 @@
+package foundation.e.blisslauncher.quickstep.views;
+
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.FAST_OUT_SLOW_IN;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Paint;
+import android.graphics.PixelFormat;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.drawable.Drawable;
+import android.util.FloatProperty;
+import foundation.e.blisslauncher.features.test.anim.Interpolators;
+
+public class LiveTileOverlay extends Drawable {
+
+    private static final long ICON_ANIM_DURATION = 120;
+
+    private static final FloatProperty<LiveTileOverlay> PROGRESS =
+            new FloatProperty<LiveTileOverlay>("progress") {
+                @Override
+                public void setValue(LiveTileOverlay liveTileOverlay, float progress) {
+                    liveTileOverlay.setIconAnimationProgress(progress);
+                }
+
+                @Override
+                public Float get(LiveTileOverlay liveTileOverlay) {
+                    return liveTileOverlay.mIconAnimationProgress;
+                }
+            };
+
+    private final Paint mPaint = new Paint();
+
+    private Rect mBoundsRect = new Rect();
+    private RectF mCurrentRect;
+    private float mCornerRadius;
+    private Drawable mIcon;
+    private Animator mIconAnimator;
+
+    private boolean mDrawEnabled = true;
+    private float mIconAnimationProgress = 0f;
+
+    public LiveTileOverlay() {
+        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
+    }
+
+    public void update(RectF currentRect, float cornerRadius) {
+        invalidateSelf();
+
+        mCurrentRect = currentRect;
+        mCornerRadius = cornerRadius;
+
+        mCurrentRect.roundOut(mBoundsRect);
+        setBounds(mBoundsRect);
+        invalidateSelf();
+    }
+
+    public void setIcon(Drawable icon) {
+        mIcon = icon;
+    }
+
+    public void startIconAnimation() {
+        if (mIconAnimator != null) {
+            mIconAnimator.cancel();
+        }
+        // This animator must match the icon part of {@link TaskView#FOCUS_TRANSITION} animation.
+        mIconAnimator = ObjectAnimator.ofFloat(this, PROGRESS, 1);
+        mIconAnimator.setDuration(ICON_ANIM_DURATION).setInterpolator(LINEAR);
+        mIconAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mIconAnimator = null;
+            }
+        });
+        mIconAnimator.start();
+    }
+
+    public float cancelIconAnimation() {
+        if (mIconAnimator != null) {
+            mIconAnimator.cancel();
+        }
+        return mIconAnimationProgress;
+    }
+
+    public void setDrawEnabled(boolean drawEnabled) {
+        if (mDrawEnabled != drawEnabled) {
+            mDrawEnabled = drawEnabled;
+            invalidateSelf();
+        }
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        if (mCurrentRect != null && mDrawEnabled) {
+            canvas.drawRoundRect(mCurrentRect, mCornerRadius, mCornerRadius, mPaint);
+            if (mIcon != null && mIconAnimationProgress > 0f) {
+                canvas.save();
+                float scale = Interpolators.clampToProgress(FAST_OUT_SLOW_IN, 0f,
+                        1f).getInterpolation(mIconAnimationProgress);
+                canvas.translate(mCurrentRect.centerX() - mIcon.getBounds().width() / 2 * scale,
+                        mCurrentRect.top - mIcon.getBounds().height() / 2 * scale);
+                canvas.scale(scale, scale);
+                mIcon.draw(canvas);
+                canvas.restore();
+            }
+        }
+    }
+
+    @Override
+    public void setAlpha(int i) { }
+
+    @Override
+    public void setColorFilter(ColorFilter colorFilter) { }
+
+    @Override
+    public int getOpacity() {
+        return PixelFormat.TRANSLUCENT;
+    }
+
+    private void setIconAnimationProgress(float progress) {
+        mIconAnimationProgress = progress;
+        invalidateSelf();
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/RecentsView.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/RecentsView.java
new file mode 100644
index 0000000000000000000000000000000000000000..d180124c6f517375a7e8a4ef2a1366f74b00ded8
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/RecentsView.java
@@ -0,0 +1,1685 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package foundation.e.blisslauncher.quickstep.views;
+
+import static androidx.dynamicanimation.animation.DynamicAnimation.MIN_VISIBLE_CHANGE_PIXELS;
+import static foundation.e.blisslauncher.core.Flags.ENABLE_QUICKSTEP_LIVE_TILE;
+import static foundation.e.blisslauncher.core.Flags.QUICKSTEP_SPRINGS;
+import static foundation.e.blisslauncher.core.Utilities.EDGE_NAV_BAR;
+import static foundation.e.blisslauncher.core.Utilities.squaredHypot;
+import static foundation.e.blisslauncher.core.Utilities.squaredTouchSlop;
+import static foundation.e.blisslauncher.features.test.BaseActivity.STATE_HANDLER_INVISIBILITY_FLAGS;
+import static foundation.e.blisslauncher.features.test.SystemUiController.UI_STATE_OVERVIEW;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.ACCEL;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.ACCEL_2;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.FAST_OUT_SLOW_IN;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+import static foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils.SCALE_PROPERTY;
+import static foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils.VIEW_TRANSLATE_X;
+import static foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils.VIEW_TRANSLATE_Y;
+import static foundation.e.blisslauncher.quickstep.TaskUtils.checkCurrentOrManagedUserId;
+import static foundation.e.blisslauncher.uioverrides.touchcontrollers.TaskViewTouchController.SUCCESS_TRANSITION_PROGRESS;
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.animation.LayoutTransition;
+import android.animation.LayoutTransition.TransitionListener;
+import android.animation.ObjectAnimator;
+import android.animation.TimeInterpolator;
+import android.animation.ValueAnimator;
+import android.annotation.TargetApi;
+import android.app.ActivityManager;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.os.Handler;
+import android.text.Layout;
+import android.text.StaticLayout;
+import android.text.TextPaint;
+import android.util.AttributeSet;
+import android.util.FloatProperty;
+import android.util.SparseBooleanArray;
+import android.view.HapticFeedbackConstants;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewDebug;
+import android.view.ViewGroup;
+import android.view.WindowInsets;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.widget.ListView;
+import androidx.annotation.Nullable;
+import androidx.dynamicanimation.animation.SpringForce;
+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.BackgroundExecutor;
+import com.android.systemui.shared.system.PackageManagerWrapper;
+import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat;
+import com.android.systemui.shared.system.TaskStackChangeListener;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.customviews.Insettable;
+import foundation.e.blisslauncher.core.customviews.PagedView;
+import foundation.e.blisslauncher.core.utils.OverScroller;
+import foundation.e.blisslauncher.features.test.BaseActivity;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+import foundation.e.blisslauncher.features.test.anim.PendingAnimation;
+import foundation.e.blisslauncher.features.test.anim.PropertyListBuilder;
+import foundation.e.blisslauncher.features.test.anim.SpringObjectAnimator;
+import foundation.e.blisslauncher.features.test.graphics.RotationMode;
+import foundation.e.blisslauncher.quickstep.RecentsAnimationWrapper;
+import foundation.e.blisslauncher.quickstep.RecentsModel;
+import foundation.e.blisslauncher.quickstep.RecentsModel.TaskThumbnailChangeListener;
+import foundation.e.blisslauncher.quickstep.TaskThumbnailCache;
+import foundation.e.blisslauncher.quickstep.util.ClipAnimationHelper;
+import foundation.e.blisslauncher.quickstep.util.Themes;
+import foundation.e.blisslauncher.quickstep.util.ViewPool;
+import java.util.ArrayList;
+import java.util.function.Consumer;
+
+/**
+ * A list of recent tasks.
+ */
+@TargetApi(Build.VERSION_CODES.P)
+public abstract class RecentsView<T extends BaseActivity> extends PagedView implements Insettable,
+        TaskThumbnailCache.HighResLoadingState.HighResLoadingStateChangedCallback, TaskThumbnailChangeListener {
+
+    private static final String TAG = RecentsView.class.getSimpleName();
+
+    public static final FloatProperty<RecentsView> CONTENT_ALPHA =
+            new FloatProperty<RecentsView>("contentAlpha") {
+                @Override
+                public void setValue(RecentsView view, float v) {
+                    view.setContentAlpha(v);
+                }
+
+                @Override
+                public Float get(RecentsView view) {
+                    return view.getContentAlpha();
+                }
+            };
+
+    public static final FloatProperty<RecentsView> FULLSCREEN_PROGRESS =
+            new FloatProperty<RecentsView>("fullscreenProgress") {
+                @Override
+                public void setValue(RecentsView recentsView, float v) {
+                    recentsView.setFullscreenProgress(v);
+                }
+
+                @Override
+                public Float get(RecentsView recentsView) {
+                    return recentsView.mFullscreenProgress;
+                }
+            };
+
+    protected RecentsAnimationWrapper mRecentsAnimationWrapper;
+    protected ClipAnimationHelper mClipAnimationHelper;
+    protected SyncRtSurfaceTransactionApplierCompat mSyncTransactionApplier;
+    protected int mTaskWidth;
+    protected int mTaskHeight;
+    protected boolean mEnableDrawingLiveTile = false;
+    protected final Rect mTempRect = new Rect();
+    protected final RectF mTempRectF = new RectF();
+
+    private static final int DISMISS_TASK_DURATION = 300;
+    private static final int ADDITION_TASK_DURATION = 200;
+    // The threshold at which we update the SystemUI flags when animating from the task into the app
+    public static final float UPDATE_SYSUI_FLAGS_THRESHOLD = 0.85f;
+
+    protected final T mActivity;
+    private final float mFastFlingVelocity;
+    private final RecentsModel mModel;
+    private final int mTaskTopMargin;
+    private final ClearAllButton mClearAllButton;
+    private final Rect mClearAllButtonDeadZoneRect = new Rect();
+    private final Rect mTaskViewDeadZoneRect = new Rect();
+    protected final ClipAnimationHelper mTempClipAnimationHelper;
+
+    private final ScrollState mScrollState = new ScrollState();
+    // Keeps track of the previously known visible tasks for purposes of loading/unloading task data
+    private final SparseBooleanArray mHasVisibleTaskData = new SparseBooleanArray();
+
+    private final ViewPool<TaskView> mTaskViewPool;
+
+    private boolean mDwbToastShown;
+    private boolean mDisallowScrollToClearAll;
+    private boolean mOverlayEnabled;
+    private boolean mFreezeViewVisibility;
+
+    /**
+     * TODO: Call reloadIdNeeded in onTaskStackChanged.
+     */
+    private final TaskStackChangeListener mTaskStackListener = new TaskStackChangeListener() {
+        @Override
+        public void onActivityPinned(String packageName, int userId, int taskId, int stackId) {
+            if (!mHandleTaskStackChanges) {
+                return;
+            }
+            // Check this is for the right user
+            if (!checkCurrentOrManagedUserId(userId, getContext())) {
+                return;
+            }
+
+            // Remove the task immediately from the task list
+            TaskView taskView = getTaskView(taskId);
+            if (taskView != null) {
+                removeView(taskView);
+            }
+        }
+
+        @Override
+        public void onActivityUnpinned() {
+            if (!mHandleTaskStackChanges) {
+                return;
+            }
+
+            reloadIfNeeded();
+            enableLayoutTransitions();
+        }
+
+        @Override
+        public void onTaskRemoved(int taskId) {
+            if (!mHandleTaskStackChanges) {
+                return;
+            }
+
+            BackgroundExecutor.get().submit(() -> {
+                TaskView taskView = getTaskView(taskId);
+                if (taskView == null) {
+                    return;
+                }
+                Handler handler = taskView.getHandler();
+                if (handler == null) {
+                    return;
+                }
+
+                // TODO: Add callbacks from AM reflecting adding/removing from the recents list, and
+                //       remove all these checks
+                Task.TaskKey taskKey = taskView.getTask().key;
+                if (PackageManagerWrapper.getInstance().getActivityInfo(taskKey.getComponent(),
+                        taskKey.userId) == null) {
+                    // The package was uninstalled
+                    handler.post(() ->
+                            dismissTask(taskView, true /* animate */, false /* removeTask */));
+                } else {
+                    mModel.findTaskWithId(taskKey.id, (key) -> {
+                        if (key == null) {
+                            // The task was removed from the recents list
+                            handler.post(() -> dismissTask(taskView, true /* animate */,
+                                    false /* removeTask */));
+                        }
+                    });
+                }
+            });
+        }
+
+        @Override
+        public void onPinnedStackAnimationStarted() {
+            // Needed for activities that auto-enter PiP, which will not trigger a remote
+            // animation to be created
+            mActivity.clearForceInvisibleFlag(STATE_HANDLER_INVISIBILITY_FLAGS);
+        }
+    };
+
+    // Used to keep track of the last requested task list id, so that we do not request to load the
+    // tasks again if we have already requested it and the task list has not changed
+    private int mTaskListChangeId = -1;
+
+    // Only valid until the launcher state changes to NORMAL
+    private int mRunningTaskId = -1;
+    private boolean mRunningTaskTileHidden;
+    private Task mTmpRunningTask;
+
+    private boolean mRunningTaskIconScaledDown = false;
+
+    private boolean mOverviewStateEnabled;
+    private boolean mHandleTaskStackChanges;
+    private boolean mSwipeDownShouldLaunchApp;
+    private boolean mTouchDownToStartHome;
+    private final float mSquaredTouchSlop;
+    private int mDownX;
+    private int mDownY;
+
+    private PendingAnimation mPendingAnimation;
+    private LayoutTransition mLayoutTransition;
+
+    @ViewDebug.ExportedProperty(category = "launcher")
+    private float mContentAlpha = 1;
+    @ViewDebug.ExportedProperty(category = "launcher")
+    private float mFullscreenProgress = 0;
+
+    // Keeps track of task id whose visual state should not be reset
+    private int mIgnoreResetTaskId = -1;
+
+    // Variables for empty state
+    private final Drawable mEmptyIcon;
+    private final CharSequence mEmptyMessage;
+    private final TextPaint mEmptyMessagePaint;
+    private final Point mLastMeasureSize = new Point();
+    private final int mEmptyMessagePadding;
+    private boolean mShowEmptyMessage;
+    private Layout mEmptyTextLayout;
+    private LiveTileOverlay mLiveTileOverlay;
+
+    private BaseActivity.MultiWindowModeChangedListener mMultiWindowModeChangedListener =
+            (inMultiWindowMode) -> {
+        if (!inMultiWindowMode && mOverviewStateEnabled) {
+            // TODO: Re-enable layout transitions for addition of the unpinned task
+            reloadIfNeeded();
+        }
+    };
+
+    public RecentsView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        setPageSpacing(getResources().getDimensionPixelSize(R.dimen.recents_page_spacing));
+        setEnableFreeScroll(true);
+
+        mFastFlingVelocity = getResources()
+                .getDimensionPixelSize(R.dimen.recents_fast_fling_velocity);
+        mActivity = (T) BaseActivity.fromContext(context);
+        mModel = RecentsModel.INSTANCE.get(context);
+        mTempClipAnimationHelper = new ClipAnimationHelper(context);
+
+        mClearAllButton = (ClearAllButton) LayoutInflater.from(context)
+                .inflate(R.layout.overview_clear_all_button, this, false);
+        mClearAllButton.setOnClickListener(this::dismissAllTasks);
+
+        mTaskViewPool = new ViewPool<>(context, this, R.layout.task, 20 /* max size */,
+                10 /* initial size */);
+
+        mIsRtl = !Utilities.isRtl(getResources());
+        setLayoutDirection(mIsRtl ? View.LAYOUT_DIRECTION_RTL : View.LAYOUT_DIRECTION_LTR);
+        mTaskTopMargin = getResources()
+                .getDimensionPixelSize(R.dimen.task_thumbnail_top_margin);
+        mSquaredTouchSlop = squaredTouchSlop(context);
+
+        mEmptyIcon = context.getDrawable(R.drawable.ic_empty_recents);
+        mEmptyIcon.setCallback(this);
+        mEmptyMessage = context.getText(R.string.recents_empty_message);
+        mEmptyMessagePaint = new TextPaint();
+        mEmptyMessagePaint.setColor(Themes.getAttrColor(context, android.R.attr.textColorPrimary));
+        mEmptyMessagePaint.setTextSize(getResources()
+                .getDimension(R.dimen.recents_empty_message_text_size));
+        mEmptyMessagePadding = getResources()
+                .getDimensionPixelSize(R.dimen.recents_empty_message_text_padding);
+        setWillNotDraw(false);
+        updateEmptyMessage();
+
+        // Initialize quickstep specific cache params here, as this is constructed only once
+        mActivity.getViewCache().setCacheSize(R.layout.digital_wellbeing_toast, 5);
+    }
+
+    public OverScroller getScroller() {
+        return mScroller;
+    }
+
+    public boolean isRtl() {
+        return mIsRtl;
+    }
+
+    @Override
+    public Task onTaskThumbnailChanged(int taskId, ThumbnailData thumbnailData) {
+        if (mHandleTaskStackChanges) {
+            TaskView taskView = getTaskView(taskId);
+            if (taskView != null) {
+                Task task = taskView.getTask();
+                taskView.getThumbnail().setThumbnail(task, thumbnailData);
+                return task;
+            }
+        }
+        return null;
+    }
+
+    public TaskView updateThumbnail(int taskId, ThumbnailData thumbnailData) {
+        TaskView taskView = getTaskView(taskId);
+        if (taskView != null) {
+            taskView.getThumbnail().setThumbnail(taskView.getTask(), thumbnailData);
+        }
+        return taskView;
+    }
+
+    @Override
+    protected void onWindowVisibilityChanged(int visibility) {
+        super.onWindowVisibilityChanged(visibility);
+        updateTaskStackListenerState();
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        updateTaskStackListenerState();
+        mModel.getThumbnailCache().getHighResLoadingState().addCallback(this);
+        mActivity.addMultiWindowModeChangedListener(mMultiWindowModeChangedListener);
+        ActivityManagerWrapper.getInstance().registerTaskStackListener(mTaskStackListener);
+        mSyncTransactionApplier = new SyncRtSurfaceTransactionApplierCompat(this);
+        RecentsModel.INSTANCE.get(getContext()).addThumbnailChangeListener(this);
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        updateTaskStackListenerState();
+        mModel.getThumbnailCache().getHighResLoadingState().removeCallback(this);
+        mActivity.removeMultiWindowModeChangedListener(mMultiWindowModeChangedListener);
+        ActivityManagerWrapper.getInstance().unregisterTaskStackListener(mTaskStackListener);
+        mSyncTransactionApplier = null;
+        RecentsModel.INSTANCE.get(getContext()).removeThumbnailChangeListener(this);
+    }
+
+    @Override
+    public void onViewRemoved(View child) {
+        super.onViewRemoved(child);
+
+        // Clear the task data for the removed child if it was visible
+        if (child != mClearAllButton) {
+            TaskView taskView = (TaskView) child;
+            mHasVisibleTaskData.delete(taskView.getTask().key.id);
+            mTaskViewPool.recycle(taskView);
+        }
+    }
+
+    public boolean isTaskViewVisible(TaskView tv) {
+        // For now, just check if it's the active task or an adjacent task
+        return Math.abs(indexOfChild(tv) - getNextPage()) <= 1;
+    }
+
+    public TaskView getTaskView(int taskId) {
+        for (int i = 0; i < getTaskViewCount(); i++) {
+            TaskView tv = (TaskView) getChildAt(i);
+            if (tv.getTask() != null && tv.getTask().key != null && tv.getTask().key.id == taskId) {
+                return tv;
+            }
+        }
+        return null;
+    }
+
+    public void setOverviewStateEnabled(boolean enabled) {
+        mOverviewStateEnabled = enabled;
+        updateTaskStackListenerState();
+    }
+
+    @Override
+    protected void onPageEndTransition() {
+        super.onPageEndTransition();
+        if (getNextPage() > 0) {
+            setSwipeDownShouldLaunchApp(true);
+        }
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        super.onTouchEvent(ev);
+        final int x = (int) ev.getX();
+        final int y = (int) ev.getY();
+        switch (ev.getAction()) {
+            case MotionEvent.ACTION_UP:
+                if (mTouchDownToStartHome) {
+                    startHome();
+                }
+                mTouchDownToStartHome = false;
+                break;
+            case MotionEvent.ACTION_CANCEL:
+                mTouchDownToStartHome = false;
+                break;
+            case MotionEvent.ACTION_MOVE:
+                // Passing the touch slop will not allow dismiss to home
+                if (mTouchDownToStartHome &&
+                        (isHandlingTouch() ||
+                                squaredHypot(mDownX - x, mDownY - y) > mSquaredTouchSlop)) {
+                    mTouchDownToStartHome = false;
+                }
+                break;
+            case MotionEvent.ACTION_DOWN:
+                // Touch down anywhere but the deadzone around the visible clear all button and
+                // between the task views will start home on touch up
+                if (!isHandlingTouch()) {
+                    if (mShowEmptyMessage) {
+                        mTouchDownToStartHome = true;
+                    } else {
+                        updateDeadZoneRects();
+                        final boolean clearAllButtonDeadZoneConsumed =
+                                mClearAllButton.getAlpha() == 1
+                                        && mClearAllButtonDeadZoneRect.contains(x, y);
+                        final boolean cameFromNavBar = (ev.getEdgeFlags() & EDGE_NAV_BAR) != 0;
+                        if (!clearAllButtonDeadZoneConsumed && !cameFromNavBar
+                                && !mTaskViewDeadZoneRect.contains(x + getScrollX(), y)) {
+                            mTouchDownToStartHome = true;
+                        }
+                    }
+                }
+                mDownX = x;
+                mDownY = y;
+                break;
+        }
+
+
+        // Do not let touch escape to siblings below this view.
+        return isHandlingTouch() || shouldStealTouchFromSiblingsBelow(ev);
+    }
+
+    protected boolean shouldStealTouchFromSiblingsBelow(MotionEvent ev) {
+        return true;
+    }
+
+    private void applyLoadPlan(ArrayList<Task> tasks) {
+        if (mPendingAnimation != null) {
+            mPendingAnimation.addEndListener((onEndListener) -> applyLoadPlan(tasks));
+            return;
+        }
+
+        if (tasks == null || tasks.isEmpty()) {
+            removeAllViews();
+            onTaskStackUpdated();
+            return;
+        }
+
+        int oldChildCount = getChildCount();
+
+        // Unload existing visible task data
+        unloadVisibleTaskData();
+
+        TaskView ignoreRestTaskView =
+                mIgnoreResetTaskId == -1 ? null : getTaskView(mIgnoreResetTaskId);
+
+        final int requiredTaskCount = tasks.size();
+        if (getTaskViewCount() != requiredTaskCount) {
+            if (oldChildCount > 0) {
+                removeView(mClearAllButton);
+            }
+            for (int i = getChildCount(); i < requiredTaskCount; i++) {
+                addView(mTaskViewPool.getView());
+            }
+            while (getChildCount() > requiredTaskCount) {
+                removeView(getChildAt(getChildCount() - 1));
+            }
+            if (requiredTaskCount > 0) {
+                addView(mClearAllButton);
+            }
+        }
+
+        // Rebind and reset all task views
+        for (int i = requiredTaskCount - 1; i >= 0; i--) {
+            final int pageIndex = requiredTaskCount - i - 1;
+            final Task task = tasks.get(i);
+            final TaskView taskView = (TaskView) getChildAt(pageIndex);
+            taskView.bind(task);
+        }
+        TaskView runningTaskView = getRunningTaskView();
+        if (runningTaskView != null) {
+            setCurrentPage(indexOfChild(runningTaskView));
+        }
+
+        if (mIgnoreResetTaskId != -1 && getTaskView(mIgnoreResetTaskId) != ignoreRestTaskView) {
+            // If the taskView mapping is changing, do not preserve the visuals. Since we are
+            // mostly preserving the first task, and new taskViews are added to the end, it should
+            // generally map to the same task.
+            mIgnoreResetTaskId = -1;
+        }
+        resetTaskVisuals();
+        onTaskStackUpdated();
+        updateEnabledOverlays();
+    }
+
+    public int getTaskViewCount() {
+        // Account for the clear all button.
+        int childCount = getChildCount();
+        return childCount == 0 ? 0 : childCount - 1;
+    }
+
+    protected void onTaskStackUpdated() { }
+
+    public void resetTaskVisuals() {
+        for (int i = getTaskViewCount() - 1; i >= 0; i--) {
+            TaskView taskView = (TaskView) getChildAt(i);
+            if (mIgnoreResetTaskId != taskView.getTask().key.id) {
+                taskView.resetVisualProperties();
+            }
+        }
+        if (mRunningTaskTileHidden) {
+            setRunningTaskHidden(mRunningTaskTileHidden);
+        }
+
+        // Force apply the scale.
+        if (mIgnoreResetTaskId != mRunningTaskId) {
+            applyRunningTaskIconScale();
+        }
+
+        updateCurveProperties();
+        // Update the set of visible task's data
+        loadVisibleTaskData();
+    }
+
+    public void setFullscreenProgress(float fullscreenProgress) {
+        mFullscreenProgress = fullscreenProgress;
+        int taskCount = getTaskViewCount();
+        for (int i = 0; i < taskCount; i++) {
+            getTaskViewAt(i).setFullscreenProgress(mFullscreenProgress);
+        }
+    }
+
+    private void updateTaskStackListenerState() {
+        boolean handleTaskStackChanges = mOverviewStateEnabled && isAttachedToWindow()
+                && getWindowVisibility() == VISIBLE;
+        if (handleTaskStackChanges != mHandleTaskStackChanges) {
+            mHandleTaskStackChanges = handleTaskStackChanges;
+            if (handleTaskStackChanges) {
+                reloadIfNeeded();
+            }
+        }
+    }
+
+    @Override
+    public void setInsets(WindowInsets insets) {
+        Rect rectInsets = new Rect();
+        if (insets != null) {
+            rectInsets.left = insets.getSystemWindowInsetLeft();
+            rectInsets.top = insets.getSystemWindowInsetTop();
+            rectInsets.right = insets.getSystemWindowInsetRight();
+            rectInsets.bottom = insets.getSystemWindowInsetBottom();
+        }
+        mInsets.set(rectInsets);
+        VariantDeviceProfile dp = mActivity.getDeviceProfile();
+        getTaskSize(dp, mTempRect);
+
+        // Keep this logic in sync with ActivityControlHelper.getTranslationYForQuickScrub.
+        mTempRect.top -= mTaskTopMargin;
+        setPadding(mTempRect.left - mInsets.left, mTempRect.top - mInsets.top,
+            dp.getAvailableWidthPx() + mInsets.left - mTempRect.right,
+            dp.getAvailableHeightPx() + mInsets.top - mTempRect.bottom);
+    }
+
+    protected abstract void getTaskSize(VariantDeviceProfile dp, Rect outRect);
+
+    public void getTaskSize(Rect outRect) {
+        getTaskSize(mActivity.getDeviceProfile(), outRect);
+    }
+
+    @Override
+    protected boolean computeScrollHelper() {
+        boolean scrolling = super.computeScrollHelper();
+        boolean isFlingingFast = false;
+        updateCurveProperties();
+        if (scrolling || isHandlingTouch()) {
+            if (scrolling) {
+                // Check if we are flinging quickly to disable high res thumbnail loading
+                isFlingingFast = mScroller.getCurrVelocity() > mFastFlingVelocity;
+            }
+
+            // After scrolling, update the visible task's data
+            loadVisibleTaskData();
+        }
+
+        // Update the high res thumbnail loader state
+        mModel.getThumbnailCache().getHighResLoadingState().setFlingingFast(isFlingingFast);
+        return scrolling;
+    }
+
+    /**
+     * Scales and adjusts translation of adjacent pages as if on a curved carousel.
+     */
+    public void updateCurveProperties() {
+        if (getPageCount() == 0 || getPageAt(0).getMeasuredWidth() == 0) {
+            return;
+        }
+        int scrollX = getScrollX();
+        final int halfPageWidth = getNormalChildWidth() / 2;
+        final int screenCenter = mInsets.left + getPaddingLeft() + scrollX + halfPageWidth;
+        final int halfScreenWidth = getMeasuredWidth() / 2;
+        final int pageSpacing = mPageSpacing;
+        mScrollState.scrollFromEdge = mIsRtl ? scrollX : (mMaxScroll - scrollX);
+
+        final int pageCount = getPageCount();
+        for (int i = 0; i < pageCount; i++) {
+            View page = getPageAt(i);
+            float pageCenter = page.getLeft() + page.getTranslationX() + halfPageWidth;
+            float distanceFromScreenCenter = screenCenter - pageCenter;
+            float distanceToReachEdge = halfScreenWidth + halfPageWidth + pageSpacing;
+            mScrollState.linearInterpolation = Math.min(1,
+                    Math.abs(distanceFromScreenCenter) / distanceToReachEdge);
+            ((PageCallbacks) page).onPageScroll(mScrollState);
+        }
+    }
+
+    /**
+     * Iterates through all thet asks, and loads the associated task data for newly visible tasks,
+     * and unloads the associated task data for tasks that are no longer visible.
+     */
+    public void loadVisibleTaskData() {
+        if (!mOverviewStateEnabled || mTaskListChangeId == -1) {
+            // Skip loading visible task data if we've already left the overview state, or if the
+            // task list hasn't been loaded yet (the task views will not reflect the task list)
+            return;
+        }
+
+        int centerPageIndex = getPageNearestToCenterOfScreen();
+        int numChildren = getTaskViewCount();
+        int lower = Math.max(0, centerPageIndex - 2);
+        int upper = Math.min(centerPageIndex + 2, numChildren - 1);
+
+        // Update the task data for the in/visible children
+        for (int i = 0; i < numChildren; i++) {
+            TaskView taskView = (TaskView) getChildAt(i);
+            Task task = taskView.getTask();
+            boolean visible = lower <= i && i <= upper;
+            if (visible) {
+                if (task == mTmpRunningTask) {
+                    // Skip loading if this is the task that we are animating into
+                    continue;
+                }
+                if (!mHasVisibleTaskData.get(task.key.id)) {
+                    taskView.onTaskListVisibilityChanged(true /* visible */);
+                }
+                mHasVisibleTaskData.put(task.key.id, visible);
+            } else {
+                if (mHasVisibleTaskData.get(task.key.id)) {
+                    taskView.onTaskListVisibilityChanged(false /* visible */);
+                }
+                mHasVisibleTaskData.delete(task.key.id);
+            }
+        }
+    }
+
+    /**
+     * Unloads any associated data from the currently visible tasks
+     */
+    private void unloadVisibleTaskData() {
+        for (int i = 0; i < mHasVisibleTaskData.size(); i++) {
+            if (mHasVisibleTaskData.valueAt(i)) {
+                TaskView taskView = getTaskView(mHasVisibleTaskData.keyAt(i));
+                if (taskView != null) {
+                    taskView.onTaskListVisibilityChanged(false /* visible */);
+                }
+            }
+        }
+        mHasVisibleTaskData.clear();
+    }
+
+    @Override
+    public void onHighResLoadingStateChanged(boolean enabled) {
+        // Whenever the high res loading state changes, poke each of the visible tasks to see if
+        // they want to updated their thumbnail state
+        for (int i = 0; i < mHasVisibleTaskData.size(); i++) {
+            if (mHasVisibleTaskData.valueAt(i)) {
+                TaskView taskView = getTaskView(mHasVisibleTaskData.keyAt(i));
+                if (taskView != null) {
+                    // Poke the view again, which will trigger it to load high res if the state
+                    // is enabled
+                    taskView.onTaskListVisibilityChanged(true /* visible */);
+                }
+            }
+        }
+    }
+
+    public abstract void startHome();
+
+    public void reset() {
+        setCurrentTask(-1);
+        mIgnoreResetTaskId = -1;
+        mTaskListChangeId = -1;
+
+        mRecentsAnimationWrapper = null;
+        mClipAnimationHelper = null;
+
+        unloadVisibleTaskData();
+        setCurrentPage(0);
+        mDwbToastShown = false;
+        mActivity.getSystemUiController().updateUiState(UI_STATE_OVERVIEW, 0);
+    }
+
+    public @Nullable TaskView getRunningTaskView() {
+        return getTaskView(mRunningTaskId);
+    }
+
+    public int getRunningTaskIndex() {
+        TaskView tv = getRunningTaskView();
+        return tv == null ? -1 : indexOfChild(tv);
+    }
+
+    /**
+     * Reloads the view if anything in recents changed.
+     */
+    public void reloadIfNeeded() {
+        if (!mModel.isTaskListValid(mTaskListChangeId)) {
+            mTaskListChangeId = mModel.getTasks(this::applyLoadPlan);
+        }
+    }
+
+    /**
+     * Called when a gesture from an app is starting.
+     */
+    public void onGestureAnimationStart(int runningTaskId) {
+        // This needs to be called before the other states are set since it can create the task view
+        showCurrentTask(runningTaskId);
+        setEnableFreeScroll(false);
+        setEnableDrawingLiveTile(false);
+        setRunningTaskHidden(true);
+        setRunningTaskIconScaledDown(true);
+    }
+
+    /**
+     * Called only when a swipe-up gesture from an app has completed. Only called after
+     * {@link #onGestureAnimationStart} and {@link #onGestureAnimationEnd()}.
+     */
+    public void onSwipeUpAnimationSuccess() {
+        if (getRunningTaskView() != null) {
+            float startProgress = ENABLE_QUICKSTEP_LIVE_TILE
+                    ? mLiveTileOverlay.cancelIconAnimation()
+                    : 0f;
+            animateUpRunningTaskIconScale(startProgress);
+        }
+        setSwipeDownShouldLaunchApp(true);
+    }
+
+    /**
+     * Called when a gesture from an app has finished.
+     */
+    public void onGestureAnimationEnd() {
+        setEnableFreeScroll(true);
+        setEnableDrawingLiveTile(true);
+        setOnScrollChangeListener(null);
+        setRunningTaskViewShowScreenshot(true);
+        setRunningTaskHidden(false);
+        animateUpRunningTaskIconScale();
+    }
+
+    /**
+     * Creates a task view (if necessary) to represent the task with the {@param runningTaskId}.
+     *
+     * All subsequent calls to reload will keep the task as the first item until {@link #reset()}
+     * is called.  Also scrolls the view to this task.
+     */
+    public void showCurrentTask(int runningTaskId) {
+        if (getChildCount() == 0) {
+            // Add an empty view for now until the task plan is loaded and applied
+            final TaskView taskView = mTaskViewPool.getView();
+            addView(taskView);
+            addView(mClearAllButton);
+
+            // The temporary running task is only used for the duration between the start of the
+            // gesture and the task list is loaded and applied
+            mTmpRunningTask = new Task(new Task.TaskKey(runningTaskId, 0, new Intent(),
+                    new ComponentName(getContext(), getClass()), 0, 0), null, null, "", "", 0, 0,
+                    false, true, false, false, new ActivityManager.TaskDescription(), 0,
+                    new ComponentName("", ""), false);
+            taskView.bind(mTmpRunningTask);
+        }
+
+        boolean runningTaskTileHidden = mRunningTaskTileHidden;
+        setCurrentTask(runningTaskId);
+        setCurrentPage(getRunningTaskIndex());
+        setRunningTaskViewShowScreenshot(false);
+        setRunningTaskHidden(runningTaskTileHidden);
+
+        // Reload the task list
+        mTaskListChangeId = mModel.getTasks(this::applyLoadPlan);
+    }
+
+    /**
+     * Sets the running task id, cleaning up the old running task if necessary.
+     * @param runningTaskId
+     */
+    public void setCurrentTask(int runningTaskId) {
+        if (mRunningTaskId == runningTaskId) {
+            return;
+        }
+
+        if (mRunningTaskId != -1) {
+            // Reset the state on the old running task view
+            setRunningTaskIconScaledDown(false);
+            setRunningTaskViewShowScreenshot(true);
+            setRunningTaskHidden(false);
+        }
+        mRunningTaskId = runningTaskId;
+    }
+
+    /**
+     * Hides the tile associated with {@link #mRunningTaskId}
+     */
+    public void setRunningTaskHidden(boolean isHidden) {
+        mRunningTaskTileHidden = isHidden;
+        TaskView runningTask = getRunningTaskView();
+        if (runningTask != null) {
+            runningTask.setStableAlpha(isHidden ? 0 : mContentAlpha);
+        }
+    }
+
+    private void setRunningTaskViewShowScreenshot(boolean showScreenshot) {
+        if (ENABLE_QUICKSTEP_LIVE_TILE) {
+            TaskView runningTaskView = getRunningTaskView();
+            if (runningTaskView != null) {
+                runningTaskView.setShowScreenshot(showScreenshot);
+            }
+        }
+    }
+
+    public void showNextTask() {
+        TaskView runningTaskView = getRunningTaskView();
+        if (runningTaskView == null) {
+            // Launch the first task
+            if (getTaskViewCount() > 0) {
+                getTaskViewAt(0).launchTask(true /* animate */);
+            }
+        } else {
+            TaskView nextTaskView = getNextTaskView();
+            if (nextTaskView != null) {
+                nextTaskView.launchTask(true /* animate */);
+            } else {
+                runningTaskView.launchTask(true /* animate */);
+            }
+        }
+    }
+
+    public void setRunningTaskIconScaledDown(boolean isScaledDown) {
+        if (mRunningTaskIconScaledDown != isScaledDown) {
+            mRunningTaskIconScaledDown = isScaledDown;
+            applyRunningTaskIconScale();
+        }
+    }
+
+    private void applyRunningTaskIconScale() {
+        TaskView firstTask = getRunningTaskView();
+        if (firstTask != null) {
+            firstTask.setIconScaleAndDim(mRunningTaskIconScaledDown ? 0 : 1);
+        }
+    }
+
+    public void animateUpRunningTaskIconScale() {
+        animateUpRunningTaskIconScale(0);
+    }
+
+    public void animateUpRunningTaskIconScale(float startProgress) {
+        mRunningTaskIconScaledDown = false;
+        TaskView firstTask = getRunningTaskView();
+        if (firstTask != null) {
+            firstTask.animateIconScaleAndDimIntoView();
+            firstTask.setIconScaleAnimStartProgress(startProgress);
+        }
+    }
+
+    private void enableLayoutTransitions() {
+        if (mLayoutTransition == null) {
+            mLayoutTransition = new LayoutTransition();
+            mLayoutTransition.enableTransitionType(LayoutTransition.APPEARING);
+            mLayoutTransition.setDuration(ADDITION_TASK_DURATION);
+            mLayoutTransition.setStartDelay(LayoutTransition.APPEARING, 0);
+
+            mLayoutTransition.addTransitionListener(new TransitionListener() {
+                @Override
+                public void startTransition(LayoutTransition transition, ViewGroup viewGroup,
+                    View view, int i) {
+                }
+
+                @Override
+                public void endTransition(LayoutTransition transition, ViewGroup viewGroup,
+                    View view, int i) {
+                    // When the unpinned task is added, snap to first page and disable transitions
+                    if (view instanceof TaskView) {
+                        snapToPage(0);
+                        disableLayoutTransitions();
+                    }
+
+                }
+            });
+        }
+        setLayoutTransition(mLayoutTransition);
+    }
+
+    private void disableLayoutTransitions() {
+        setLayoutTransition(null);
+    }
+
+    public void setSwipeDownShouldLaunchApp(boolean swipeDownShouldLaunchApp) {
+        mSwipeDownShouldLaunchApp = swipeDownShouldLaunchApp;
+    }
+
+    public boolean shouldSwipeDownLaunchApp() {
+        return mSwipeDownShouldLaunchApp;
+    }
+
+    public interface PageCallbacks {
+
+        /**
+         * Updates the page UI based on scroll params.
+         */
+        default void onPageScroll(ScrollState scrollState) {}
+    }
+
+    public static class ScrollState {
+
+        /**
+         * The progress from 0 to 1, where 0 is the center
+         * of the screen and 1 is the edge of the screen.
+         */
+        public float linearInterpolation;
+
+        /**
+         * The amount by which all the content is scrolled relative to the end of the list.
+         */
+        public float scrollFromEdge;
+    }
+
+    public void setIgnoreResetTask(int taskId) {
+        mIgnoreResetTaskId = taskId;
+    }
+
+    public void clearIgnoreResetTask(int taskId) {
+        if (mIgnoreResetTaskId == taskId) {
+            mIgnoreResetTaskId = -1;
+        }
+    }
+
+    private void addDismissedTaskAnimations(View taskView, AnimatorSet anim, long duration) {
+        addAnim(ObjectAnimator.ofFloat(taskView, ALPHA, 0), duration, ACCEL_2, anim);
+        if (QUICKSTEP_SPRINGS && taskView instanceof TaskView)
+            addAnim(new SpringObjectAnimator<>(taskView, VIEW_TRANSLATE_Y,
+                            MIN_VISIBLE_CHANGE_PIXELS, SpringForce.DAMPING_RATIO_MEDIUM_BOUNCY,
+                            SpringForce.STIFFNESS_MEDIUM,
+                            0, -taskView.getHeight()),
+                    duration, LINEAR, anim);
+        else {
+            addAnim(ObjectAnimator.ofFloat(taskView, TRANSLATION_Y, -taskView.getHeight()),
+                    duration, LINEAR, anim);
+        }
+    }
+
+    private void removeTask(Task task, int index, PendingAnimation.OnEndListener onEndListener,
+                            boolean shouldLog) {
+        if (task != null) {
+            ActivityManagerWrapper.getInstance().removeTask(task.key.id);
+        }
+    }
+
+    public PendingAnimation createTaskDismissAnimation(TaskView taskView, boolean animateTaskView,
+            boolean shouldRemoveTask, long duration) {
+        if (mPendingAnimation != null) {
+            mPendingAnimation.finish(false);
+        }
+        AnimatorSet anim = new AnimatorSet();
+        PendingAnimation pendingAnimation = new PendingAnimation(anim);
+
+        int count = getPageCount();
+        if (count == 0) {
+            return pendingAnimation;
+        }
+
+        int[] oldScroll = new int[count];
+        getPageScrolls(oldScroll, false, SIMPLE_SCROLL_LOGIC);
+
+        int[] newScroll = new int[count];
+        getPageScrolls(newScroll, false, (v) -> v.getVisibility() != GONE && v != taskView);
+
+        int taskCount = getTaskViewCount();
+        int scrollDiffPerPage = 0;
+        if (count > 1) {
+            scrollDiffPerPage = Math.abs(oldScroll[1] - oldScroll[0]);
+        }
+        int draggedIndex = indexOfChild(taskView);
+
+        boolean needsCurveUpdates = false;
+        for (int i = 0; i < count; i++) {
+            View child = getChildAt(i);
+            if (child == taskView) {
+                if (animateTaskView) {
+                    addDismissedTaskAnimations(taskView, anim, duration);
+                }
+            } else {
+                // If we just take newScroll - oldScroll, everything to the right of dragged task
+                // translates to the left. We need to offset this in some cases:
+                // - In RTL, add page offset to all pages, since we want pages to move to the right
+                // Additionally, add a page offset if:
+                // - Current page is rightmost page (leftmost for RTL)
+                // - Dragging an adjacent page on the left side (right side for RTL)
+                int offset = mIsRtl ? scrollDiffPerPage : 0;
+                if (mCurrentPage == draggedIndex) {
+                    int lastPage = taskCount - 1;
+                    if (mCurrentPage == lastPage) {
+                        offset += mIsRtl ? -scrollDiffPerPage : scrollDiffPerPage;
+                    }
+                } else {
+                    // Dragging an adjacent page.
+                    int negativeAdjacent = mCurrentPage - 1; // (Right in RTL, left in LTR)
+                    if (draggedIndex == negativeAdjacent) {
+                        offset += mIsRtl ? -scrollDiffPerPage : scrollDiffPerPage;
+                    }
+                }
+                int scrollDiff = newScroll[i] - oldScroll[i] + offset;
+                if (scrollDiff != 0) {
+                    if (QUICKSTEP_SPRINGS && child instanceof TaskView) {
+                        addAnim(new SpringObjectAnimator<>(child, VIEW_TRANSLATE_X,
+                                MIN_VISIBLE_CHANGE_PIXELS, SpringForce.DAMPING_RATIO_MEDIUM_BOUNCY,
+                                SpringForce.STIFFNESS_MEDIUM,
+                                0, scrollDiff), duration, ACCEL, anim);
+                    } else {
+                        addAnim(ObjectAnimator.ofFloat(child, TRANSLATION_X, scrollDiff), duration,
+                                ACCEL, anim);
+                    }
+
+                    needsCurveUpdates = true;
+                }
+            }
+        }
+
+        if (needsCurveUpdates) {
+            ValueAnimator va = ValueAnimator.ofFloat(0, 1);
+            va.addUpdateListener((a) -> updateCurveProperties());
+            anim.play(va);
+        }
+
+        // Add a tiny bit of translation Z, so that it draws on top of other views
+        if (animateTaskView) {
+            taskView.setTranslationZ(0.1f);
+        }
+
+        mPendingAnimation = pendingAnimation;
+        mPendingAnimation.addEndListener(new Consumer<PendingAnimation.OnEndListener>() {
+            @Override
+            public void accept(PendingAnimation.OnEndListener onEndListener) {
+                if (ENABLE_QUICKSTEP_LIVE_TILE &&
+                        taskView.isRunningTask() && onEndListener.isSuccess) {
+                    finishRecentsAnimation(true /* toHome */, () -> onEnd(onEndListener));
+                } else {
+                    onEnd(onEndListener);
+                }
+            }
+
+            private void onEnd(PendingAnimation.OnEndListener onEndListener) {
+                if (onEndListener.isSuccess) {
+                    if (shouldRemoveTask) {
+                        removeTask(taskView.getTask(), draggedIndex, onEndListener, true);
+                    }
+
+                    int pageToSnapTo = mCurrentPage;
+                    if (draggedIndex < pageToSnapTo ||
+                            pageToSnapTo == (getTaskViewCount() - 1)) {
+                        pageToSnapTo -= 1;
+                    }
+                    removeView(taskView);
+
+                    if (getTaskViewCount() == 0) {
+                        removeView(mClearAllButton);
+                        startHome();
+                    } else {
+                        snapToPageImmediately(pageToSnapTo);
+                    }
+                }
+                resetTaskVisuals();
+                mPendingAnimation = null;
+            }
+        });
+        return pendingAnimation;
+    }
+
+    public PendingAnimation createAllTasksDismissAnimation(long duration) {
+        AnimatorSet anim = new AnimatorSet();
+        PendingAnimation pendingAnimation = new PendingAnimation(anim);
+
+        int count = getTaskViewCount();
+        for (int i = 0; i < count; i++) {
+            addDismissedTaskAnimations(getChildAt(i), anim, duration);
+        }
+
+        mPendingAnimation = pendingAnimation;
+        mPendingAnimation.addEndListener((onEndListener) -> {
+            if (onEndListener.isSuccess) {
+                // Remove all the task views now
+                ActivityManagerWrapper.getInstance().removeAllRecentTasks();
+                removeAllViews();
+                startHome();
+            }
+            mPendingAnimation = null;
+        });
+        return pendingAnimation;
+    }
+
+    private static void addAnim(Animator anim, long duration,
+            TimeInterpolator interpolator, AnimatorSet set) {
+        anim.setDuration(duration).setInterpolator(interpolator);
+        set.play(anim);
+    }
+
+    private boolean snapToPageRelative(int pageCount, int delta, boolean cycle) {
+        if (pageCount == 0) {
+            return false;
+        }
+        final int newPageUnbound = getNextPage() + delta;
+        if (!cycle && (newPageUnbound < 0 || newPageUnbound >= pageCount)) {
+            return false;
+        }
+        snapToPage((newPageUnbound + pageCount) % pageCount);
+        getChildAt(getNextPage()).requestFocus();
+        return true;
+    }
+
+    private void runDismissAnimation(PendingAnimation pendingAnim) {
+        AnimatorPlaybackController controller = AnimatorPlaybackController.wrap(
+                pendingAnim.anim, DISMISS_TASK_DURATION);
+        controller.dispatchOnStart();
+        controller.setEndAction(() -> pendingAnim.finish(true));
+        controller.getAnimationPlayer().setInterpolator(FAST_OUT_SLOW_IN);
+        controller.start();
+    }
+
+    public void dismissTask(TaskView taskView, boolean animateTaskView, boolean removeTask) {
+        runDismissAnimation(createTaskDismissAnimation(taskView, animateTaskView, removeTask,
+                DISMISS_TASK_DURATION));
+    }
+
+    @SuppressWarnings("unused")
+    private void dismissAllTasks(View view) {
+        runDismissAnimation(createAllTasksDismissAnimation(DISMISS_TASK_DURATION));
+    }
+
+    private void dismissCurrentTask() {
+        TaskView taskView = getTaskView(getNextPage());
+        if (taskView != null) {
+            dismissTask(taskView, true /*animateTaskView*/, true /*removeTask*/);
+        }
+    }
+
+    @Override
+    public boolean dispatchKeyEvent(KeyEvent event) {
+        if (event.getAction() == KeyEvent.ACTION_DOWN) {
+            switch (event.getKeyCode()) {
+                case KeyEvent.KEYCODE_TAB:
+                    return snapToPageRelative(getTaskViewCount(), event.isShiftPressed() ? -1 : 1,
+                            event.isAltPressed() /* cycle */);
+                case KeyEvent.KEYCODE_DPAD_RIGHT:
+                    return snapToPageRelative(getPageCount(), mIsRtl ? -1 : 1, false /* cycle */);
+                case KeyEvent.KEYCODE_DPAD_LEFT:
+                    return snapToPageRelative(getPageCount(), mIsRtl ? 1 : -1, false /* cycle */);
+                case KeyEvent.KEYCODE_DEL:
+                case KeyEvent.KEYCODE_FORWARD_DEL:
+                    dismissCurrentTask();
+                    return true;
+                case KeyEvent.KEYCODE_NUMPAD_DOT:
+                    if (event.isAltPressed()) {
+                        // Numpad DEL pressed while holding Alt.
+                        dismissCurrentTask();
+                        return true;
+                    }
+            }
+        }
+        return super.dispatchKeyEvent(event);
+    }
+
+    @Override
+    protected void onFocusChanged(boolean gainFocus, int direction,
+            @Nullable Rect previouslyFocusedRect) {
+        super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
+        if (gainFocus && getChildCount() > 0) {
+            switch (direction) {
+                case FOCUS_FORWARD:
+                    setCurrentPage(0);
+                    break;
+                case FOCUS_BACKWARD:
+                case FOCUS_RIGHT:
+                case FOCUS_LEFT:
+                    setCurrentPage(getChildCount() - 1);
+                    break;
+            }
+        }
+    }
+
+    public float getContentAlpha() {
+        return mContentAlpha;
+    }
+
+    public void setContentAlpha(float alpha) {
+        if (alpha == mContentAlpha) {
+            return;
+        }
+        alpha = Utilities.boundToRange(alpha, 0, 1);
+        mContentAlpha = alpha;
+        for (int i = getTaskViewCount() - 1; i >= 0; i--) {
+            TaskView child = getTaskViewAt(i);
+            if (!mRunningTaskTileHidden || child.getTask().key.id != mRunningTaskId) {
+                child.setStableAlpha(alpha);
+            }
+        }
+        mClearAllButton.setContentAlpha(mContentAlpha);
+
+        int alphaInt = Math.round(alpha * 255);
+        mEmptyMessagePaint.setAlpha(alphaInt);
+        mEmptyIcon.setAlpha(alphaInt);
+
+        if (alpha > 0) {
+            setVisibility(VISIBLE);
+        } else if (!mFreezeViewVisibility) {
+            setVisibility(GONE);
+        }
+    }
+
+    /**
+     * Freezes the view visibility change. When frozen, the view will not change its visibility
+     * to gone due to alpha changes.
+     */
+    public void setFreezeViewVisibility(boolean freezeViewVisibility) {
+        if (mFreezeViewVisibility != freezeViewVisibility) {
+            mFreezeViewVisibility = freezeViewVisibility;
+
+            if (!mFreezeViewVisibility) {
+                setVisibility(mContentAlpha > 0 ? VISIBLE : GONE);
+            }
+        }
+    }
+
+    @Override
+    public void onViewAdded(View child) {
+        super.onViewAdded(child);
+        child.setAlpha(mContentAlpha);
+    }
+
+    /**
+     * @return The most recent task that is older than the currently running task. If there is
+     * currently no running task or there is no task older than it, then return null.
+     */
+    @Nullable
+    public TaskView getNextTaskView() {
+        TaskView runningTaskView = getRunningTaskView();
+        if (runningTaskView == null) {
+            return null;
+        }
+        return getTaskViewAt(indexOfChild(runningTaskView) + 1);
+    }
+
+    public TaskView getTaskViewAt(int index) {
+        View child = getChildAt(index);
+        return child == mClearAllButton ? null : (TaskView) child;
+    }
+
+    public void updateEmptyMessage() {
+        boolean isEmpty = getChildCount() == 0;
+        boolean hasSizeChanged = mLastMeasureSize.x != getWidth()
+                || mLastMeasureSize.y != getHeight();
+        if (isEmpty == mShowEmptyMessage && !hasSizeChanged) {
+            return;
+        }
+        setContentDescription(isEmpty ? mEmptyMessage : "");
+        mShowEmptyMessage = isEmpty;
+        updateEmptyStateUi(hasSizeChanged);
+        invalidate();
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        super.onLayout(changed, left, top, right, bottom);
+        updateEmptyStateUi(changed);
+
+        // Set the pivot points to match the task preview center
+        setPivotY(((mInsets.top + getPaddingTop() + mTaskTopMargin)
+                + (getHeight() - mInsets.bottom - getPaddingBottom())) / 2);
+        setPivotX(((mInsets.left + getPaddingLeft())
+                + (getWidth() - mInsets.right - getPaddingRight())) / 2);
+    }
+
+    private void updateDeadZoneRects() {
+        // Get the deadzone rect surrounding the clear all button to not dismiss overview to home
+        mClearAllButtonDeadZoneRect.setEmpty();
+        if (mClearAllButton.getWidth() > 0) {
+            int verticalMargin = getResources()
+                    .getDimensionPixelSize(R.dimen.recents_clear_all_deadzone_vertical_margin);
+            mClearAllButton.getHitRect(mClearAllButtonDeadZoneRect);
+            mClearAllButtonDeadZoneRect.inset(-getPaddingRight() / 2, -verticalMargin);
+        }
+
+        // Get the deadzone rect between the task views
+        mTaskViewDeadZoneRect.setEmpty();
+        int count = getTaskViewCount();
+        if (count > 0) {
+            final View taskView = getTaskViewAt(0);
+            getTaskViewAt(count - 1).getHitRect(mTaskViewDeadZoneRect);
+            mTaskViewDeadZoneRect.union(taskView.getLeft(), taskView.getTop(), taskView.getRight(),
+                    taskView.getBottom());
+        }
+    }
+
+    private void updateEmptyStateUi(boolean sizeChanged) {
+        boolean hasValidSize = getWidth() > 0 && getHeight() > 0;
+        if (sizeChanged && hasValidSize) {
+            mEmptyTextLayout = null;
+            mLastMeasureSize.set(getWidth(), getHeight());
+        }
+
+        if (mShowEmptyMessage && hasValidSize && mEmptyTextLayout == null) {
+            int availableWidth = mLastMeasureSize.x - mEmptyMessagePadding - mEmptyMessagePadding;
+            mEmptyTextLayout = StaticLayout.Builder.obtain(mEmptyMessage, 0, mEmptyMessage.length(),
+                    mEmptyMessagePaint, availableWidth)
+                    .setAlignment(Layout.Alignment.ALIGN_CENTER)
+                    .build();
+            int totalHeight = mEmptyTextLayout.getHeight()
+                    + mEmptyMessagePadding + mEmptyIcon.getIntrinsicHeight();
+
+            int top = (mLastMeasureSize.y - totalHeight) / 2;
+            int left = (mLastMeasureSize.x - mEmptyIcon.getIntrinsicWidth()) / 2;
+            mEmptyIcon.setBounds(left, top, left + mEmptyIcon.getIntrinsicWidth(),
+                    top + mEmptyIcon.getIntrinsicHeight());
+        }
+    }
+
+    @Override
+    protected boolean verifyDrawable(Drawable who) {
+        return super.verifyDrawable(who) || (mShowEmptyMessage && who == mEmptyIcon);
+    }
+
+    protected void maybeDrawEmptyMessage(Canvas canvas) {
+        if (mShowEmptyMessage && mEmptyTextLayout != null) {
+            // Offset to center in the visible (non-padded) part of RecentsView
+            mTempRect.set(mInsets.left + getPaddingLeft(), mInsets.top + getPaddingTop(),
+                    mInsets.right + getPaddingRight(), mInsets.bottom + getPaddingBottom());
+            canvas.save();
+            canvas.translate(getScrollX() + (mTempRect.left - mTempRect.right) / 2,
+                    (mTempRect.top - mTempRect.bottom) / 2);
+            mEmptyIcon.draw(canvas);
+            canvas.translate(mEmptyMessagePadding,
+                    mEmptyIcon.getBounds().bottom + mEmptyMessagePadding);
+            mEmptyTextLayout.draw(canvas);
+            canvas.restore();
+        }
+    }
+
+    /**
+     * Animate adjacent tasks off screen while scaling up.
+     *
+     * If launching one of the adjacent tasks, parallax the center task and other adjacent task
+     * to the right.
+     */
+    public AnimatorSet createAdjacentPageAnimForTaskLaunch(
+            TaskView tv, ClipAnimationHelper clipAnimationHelper) {
+        AnimatorSet anim = new AnimatorSet();
+
+        int taskIndex = indexOfChild(tv);
+        int centerTaskIndex = getCurrentPage();
+        boolean launchingCenterTask = taskIndex == centerTaskIndex;
+
+        LauncherState.ScaleAndTranslation toScaleAndTranslation = clipAnimationHelper
+                .getScaleAndTranslation();
+        float toScale = toScaleAndTranslation.scale;
+        float toTranslationY = toScaleAndTranslation.translationY;
+        if (launchingCenterTask) {
+            RecentsView recentsView = tv.getRecentsView();
+            anim.play(ObjectAnimator.ofFloat(recentsView, SCALE_PROPERTY, toScale));
+            anim.play(ObjectAnimator.ofFloat(recentsView, TRANSLATION_Y, toTranslationY));
+            anim.play(ObjectAnimator.ofFloat(recentsView, FULLSCREEN_PROGRESS, 1));
+        } else {
+            // We are launching an adjacent task, so parallax the center and other adjacent task.
+            float displacementX = tv.getWidth() * (toScale - tv.getCurveScale());
+            anim.play(ObjectAnimator.ofFloat(getPageAt(centerTaskIndex), TRANSLATION_X,
+                    mIsRtl ? -displacementX : displacementX));
+
+            int otherAdjacentTaskIndex = centerTaskIndex + (centerTaskIndex - taskIndex);
+            if (otherAdjacentTaskIndex >= 0 && otherAdjacentTaskIndex < getPageCount()) {
+                anim.play(new PropertyListBuilder()
+                        .translationX(mIsRtl ? -displacementX : displacementX)
+                        .scale(1)
+                        .build(getPageAt(otherAdjacentTaskIndex)));
+            }
+        }
+        return anim;
+    }
+
+    public PendingAnimation createTaskLauncherAnimation(TaskView tv, long duration) {
+
+        int count = getChildCount();
+        if (count == 0) {
+            return new PendingAnimation(new AnimatorSet());
+        }
+
+        int targetSysUiFlags = tv.getThumbnail().getSysUiStatusNavFlags();
+        final boolean[] passedOverviewThreshold = new boolean[] {false};
+        ValueAnimator progressAnim = ValueAnimator.ofFloat(0, 1);
+        progressAnim.setInterpolator(LINEAR);
+        progressAnim.addUpdateListener(animator -> {
+            // Once we pass a certain threshold, update the sysui flags to match the target
+            // tasks' flags
+            mActivity.getSystemUiController().updateUiState(UI_STATE_OVERVIEW,
+                    animator.getAnimatedFraction() > UPDATE_SYSUI_FLAGS_THRESHOLD
+                            ? targetSysUiFlags
+                            : 0);
+
+            onTaskLaunchAnimationUpdate(animator.getAnimatedFraction(), tv);
+
+            // Passing the threshold from taskview to fullscreen app will vibrate
+            final boolean passed = animator.getAnimatedFraction() >=
+                    SUCCESS_TRANSITION_PROGRESS;
+            if (passed != passedOverviewThreshold[0]) {
+                passedOverviewThreshold[0] = passed;
+                performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY,
+                        HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
+            }
+        });
+
+        ClipAnimationHelper clipAnimationHelper = new ClipAnimationHelper(mActivity);
+        clipAnimationHelper.fromTaskThumbnailView(tv.getThumbnail(), this);
+        clipAnimationHelper.prepareAnimation(mActivity.getDeviceProfile(), true /* isOpening */);
+        AnimatorSet anim = createAdjacentPageAnimForTaskLaunch(tv, clipAnimationHelper);
+        anim.play(progressAnim);
+        anim.setDuration(duration);
+
+        Consumer<Boolean> onTaskLaunchFinish = this::onTaskLaunched;
+
+        mPendingAnimation = new PendingAnimation(anim);
+        mPendingAnimation.addEndListener((onEndListener) -> {
+            if (onEndListener.isSuccess) {
+                Consumer<Boolean> onLaunchResult = (result) -> {
+                    onTaskLaunchFinish.accept(result);
+                    if (!result) {
+                        tv.notifyTaskLaunchFailed(TAG);
+                    }
+                };
+                tv.launchTask(false, onLaunchResult, getHandler());
+            } else {
+                onTaskLaunchFinish.accept(false);
+            }
+            mPendingAnimation = null;
+        });
+        return mPendingAnimation;
+    }
+
+    protected void onTaskLaunchAnimationUpdate(float progress, TaskView tv) {
+    }
+
+    public abstract boolean shouldUseMultiWindowTaskSizeStrategy();
+
+    protected void onTaskLaunched(boolean success) {
+        if (success) {
+            resetTaskVisuals();
+        }
+    }
+
+    @Override
+    protected void notifyPageSwitchListener(int prevPage) {
+        super.notifyPageSwitchListener(prevPage);
+        loadVisibleTaskData();
+        updateEnabledOverlays();
+    }
+
+    @Override
+    public String getCurrentPageDescription() {
+        return "";
+    }
+
+    @Override
+    public void addChildrenForAccessibility(ArrayList<View> outChildren) {
+        // Add children in reverse order
+        for (int i = getChildCount() - 1; i >= 0; --i) {
+            outChildren.add(getChildAt(i));
+        }
+    }
+
+    @Override
+    public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
+        super.onInitializeAccessibilityNodeInfo(info);
+        final AccessibilityNodeInfo.CollectionInfo
+                collectionInfo = AccessibilityNodeInfo.CollectionInfo.obtain(
+                1, getTaskViewCount(), false,
+                AccessibilityNodeInfo.CollectionInfo.SELECTION_MODE_NONE);
+        info.setCollectionInfo(collectionInfo);
+    }
+
+    @Override
+    public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
+        super.onInitializeAccessibilityEvent(event);
+
+        final int taskViewCount = getTaskViewCount();
+        event.setScrollable(taskViewCount > 0);
+
+        if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_SCROLLED) {
+            final int[] visibleTasks = getVisibleChildrenRange();
+            event.setFromIndex(taskViewCount - visibleTasks[1] - 1);
+            event.setToIndex(taskViewCount - visibleTasks[0] - 1);
+            event.setItemCount(taskViewCount);
+        }
+    }
+
+    @Override
+    public CharSequence getAccessibilityClassName() {
+        // To hear position-in-list related feedback from Talkback.
+        return ListView.class.getName();
+    }
+
+    @Override
+    protected boolean isPageOrderFlipped() {
+        return true;
+    }
+
+    public void setEnableDrawingLiveTile(boolean enableDrawingLiveTile) {
+        mEnableDrawingLiveTile = enableDrawingLiveTile;
+    }
+
+    public void redrawLiveTile(boolean mightNeedToRefill) { }
+
+    public void setRecentsAnimationWrapper(RecentsAnimationWrapper recentsAnimationWrapper) {
+        mRecentsAnimationWrapper = recentsAnimationWrapper;
+    }
+
+    public void setClipAnimationHelper(ClipAnimationHelper clipAnimationHelper) {
+        mClipAnimationHelper = clipAnimationHelper;
+    }
+
+    public void setLiveTileOverlay(LiveTileOverlay liveTileOverlay) {
+        mLiveTileOverlay = liveTileOverlay;
+    }
+
+    public void updateLiveTileIcon(Drawable icon) {
+        if (mLiveTileOverlay != null) {
+            mLiveTileOverlay.setIcon(icon);
+        }
+    }
+
+    public void finishRecentsAnimation(boolean toRecents, Runnable onFinishComplete) {
+        if (mRecentsAnimationWrapper == null) {
+            if (onFinishComplete != null) {
+                onFinishComplete.run();
+            }
+            return;
+        }
+
+        mRecentsAnimationWrapper.finish(toRecents, onFinishComplete);
+    }
+
+    public void setDisallowScrollToClearAll(boolean disallowScrollToClearAll) {
+        if (mDisallowScrollToClearAll != disallowScrollToClearAll) {
+            mDisallowScrollToClearAll = disallowScrollToClearAll;
+            updateMinAndMaxScrollX();
+        }
+    }
+
+    @Override
+    protected int computeMinScrollX() {
+        if (mIsRtl && mDisallowScrollToClearAll) {
+            // We aren't showing the clear all button, so use the leftmost task as the min scroll.
+            return getScrollForPage(getTaskViewCount() - 1);
+        }
+        return super.computeMinScrollX();
+    }
+
+    @Override
+    protected int computeMaxScrollX() {
+        if (!mIsRtl && mDisallowScrollToClearAll) {
+            // We aren't showing the clear all button, so use the rightmost task as the max scroll.
+            return getScrollForPage(getTaskViewCount() - 1);
+        }
+        return super.computeMaxScrollX();
+    }
+
+    public ClearAllButton getClearAllButton() {
+        return mClearAllButton;
+    }
+
+    /**
+     * @return How many pixels the running task is offset on the x-axis due to the current scrollX.
+     */
+    public float getScrollOffset() {
+        int startScroll = getScrollForPage(getRunningTaskIndex());
+        int offsetX = startScroll - getScrollX();
+        offsetX *= getScaleX();
+        return offsetX;
+    }
+
+    public Consumer<MotionEvent> getEventDispatcher(RotationMode rotationMode) {
+        if (rotationMode.isTransposed) {
+            Matrix transform = new Matrix();
+            transform.setRotate(-rotationMode.surfaceRotation);
+
+            if (getWidth() > 0 && getHeight() > 0) {
+                float scale = ((float) getWidth()) / getHeight();
+                transform.postScale(scale, 1 / scale);
+            }
+
+            Matrix inverse = new Matrix();
+            transform.invert(inverse);
+            return e -> {
+                e.transform(transform);
+                super.onTouchEvent(e);
+                e.transform(inverse);
+            };
+        } else {
+            return super::onTouchEvent;
+        }
+    }
+
+    public ClipAnimationHelper getTempClipAnimationHelper() {
+        return mTempClipAnimationHelper;
+    }
+
+    private void updateEnabledOverlays() {
+        int overlayEnabledPage = mOverlayEnabled ? getNextPage() : -1;
+        int taskCount = getTaskViewCount();
+        for (int i = 0; i < taskCount; i++) {
+            ((TaskView) getChildAt(i)).setOverlayEnabled(i == overlayEnabledPage);
+        }
+    }
+
+    public void setOverlayEnabled(boolean overlayEnabled) {
+        if (mOverlayEnabled != overlayEnabled) {
+            mOverlayEnabled = overlayEnabled;
+            updateEnabledOverlays();
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/TaskMenuView.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/TaskMenuView.java
new file mode 100644
index 0000000000000000000000000000000000000000..bcac63fa2fc103dce088141c2680d1159557175b
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/TaskMenuView.java
@@ -0,0 +1,245 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.views;
+
+import static foundation.e.blisslauncher.quickstep.views.TaskThumbnailView.DIM_ALPHA;
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.content.Context;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.view.Gravity;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.customviews.AbstractFloatingView;
+import foundation.e.blisslauncher.features.test.BaseDragLayer;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.features.test.anim.AnimationSuccessListener;
+import foundation.e.blisslauncher.features.test.anim.Interpolators;
+import foundation.e.blisslauncher.features.test.anim.RoundedRectRevealOutlineProvider;
+import foundation.e.blisslauncher.quickstep.TaskOverlayFactory;
+import foundation.e.blisslauncher.quickstep.TaskSystemShortcut;
+import foundation.e.blisslauncher.quickstep.TaskUtils;
+import foundation.e.blisslauncher.quickstep.util.Themes;
+import java.util.List;
+
+/**
+ * Contains options for a recent task when long-pressing its icon.
+ */
+public class TaskMenuView extends AbstractFloatingView {
+
+    private static final Rect sTempRect = new Rect();
+
+    private static final int REVEAL_OPEN_DURATION = 150;
+    private static final int REVEAL_CLOSE_DURATION = 100;
+
+    private final float mThumbnailTopMargin;
+    private BaseDraggingActivity mActivity;
+    private TextView mTaskName;
+    private IconView mTaskIcon;
+    private AnimatorSet mOpenCloseAnimator;
+    private TaskView mTaskView;
+    private LinearLayout mOptionLayout;
+
+    public TaskMenuView(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public TaskMenuView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+
+        mActivity = BaseDraggingActivity.fromContext(context);
+        mThumbnailTopMargin = getResources().getDimension(R.dimen.task_thumbnail_top_margin);
+    }
+
+    @Override
+    protected void onFinishInflate() {
+        super.onFinishInflate();
+        mTaskName = findViewById(R.id.task_name);
+        mTaskIcon = findViewById(R.id.task_icon);
+        mOptionLayout = findViewById(R.id.menu_option_layout);
+    }
+
+    @Override
+    public boolean onControllerInterceptTouchEvent(MotionEvent ev) {
+        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
+            BaseDragLayer dl = mActivity.getDragLayer();
+            if (!dl.isEventOverView(this, ev)) {
+                // TODO: log this once we have a new container type for it?
+                close(true);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    protected void handleClose(boolean animate) {
+        if (animate) {
+            animateClose();
+        } else {
+            closeComplete();
+        }
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+    }
+
+    @Override
+    protected boolean isOfType(int type) {
+        return (type & TYPE_TASK_MENU) != 0;
+    }
+
+    public void setPosition(float x, float y) {
+        setX(x);
+        setY(y + mThumbnailTopMargin);
+    }
+
+    public static TaskMenuView showForTask(TaskView taskView) {
+        BaseDraggingActivity activity = BaseDraggingActivity.fromContext(taskView.getContext());
+        final TaskMenuView taskMenuView = (TaskMenuView) activity.getLayoutInflater().inflate(
+                        R.layout.task_menu, activity.getDragLayer(), false);
+        return taskMenuView.populateAndShowForTask(taskView) ? taskMenuView : null;
+    }
+
+    private boolean populateAndShowForTask(TaskView taskView) {
+        if (isAttachedToWindow()) {
+            return false;
+        }
+        mActivity.getDragLayer().addView(this);
+        mTaskView = taskView;
+        addMenuOptions(mTaskView);
+        orientAroundTaskView(mTaskView);
+        post(this::animateOpen);
+        return true;
+    }
+
+    private void addMenuOptions(TaskView taskView) {
+        Drawable icon = taskView.getTask().icon.getConstantState().newDrawable();
+        mTaskIcon.setDrawable(icon);
+        mTaskIcon.setOnClickListener(v -> close(true));
+        mTaskName.setText(TaskUtils.getTitle(getContext(), taskView.getTask()));
+        mTaskName.setOnClickListener(v -> close(true));
+
+        // Move the icon and text up half an icon size to lay over the TaskView
+        LinearLayout.LayoutParams params =
+                (LinearLayout.LayoutParams) mTaskIcon.getLayoutParams();
+        params.topMargin = (int) -mThumbnailTopMargin;
+        mTaskIcon.setLayoutParams(params);
+
+        final BaseDraggingActivity activity = BaseDraggingActivity.fromContext(getContext());
+        final List<TaskSystemShortcut> shortcuts =
+                TaskOverlayFactory.INSTANCE.get(getContext()).getEnabledShortcuts(taskView);
+        final int count = shortcuts.size();
+        for (int i = 0; i < count; ++i) {
+            final TaskSystemShortcut menuOption = shortcuts.get(i);
+            addMenuOption(menuOption, menuOption.getOnClickListener(activity, taskView));
+        }
+    }
+
+    private void addMenuOption(TaskSystemShortcut menuOption, OnClickListener onClickListener) {
+        ViewGroup menuOptionView = (ViewGroup) mActivity.getLayoutInflater().inflate(
+                R.layout.task_view_menu_option, this, false);
+        menuOption.setIconAndLabelFor(
+                menuOptionView.findViewById(R.id.icon), menuOptionView.findViewById(R.id.text));
+        menuOptionView.setOnClickListener(onClickListener);
+        mOptionLayout.addView(menuOptionView);
+    }
+
+    private void orientAroundTaskView(TaskView taskView) {
+        measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
+        mActivity.getDragLayer().getDescendantRectRelativeToSelf(taskView, sTempRect);
+        Rect insets = mActivity.getDragLayer().getInsets();
+        BaseDragLayer.LayoutParams params = (BaseDragLayer.LayoutParams) getLayoutParams();
+        params.width = taskView.getMeasuredWidth();
+        params.gravity = Gravity.START;
+        setLayoutParams(params);
+        setScaleX(taskView.getScaleX());
+        setScaleY(taskView.getScaleY());
+        setPosition(sTempRect.left - insets.left, sTempRect.top - insets.top);
+    }
+
+    private void animateOpen() {
+        animateOpenOrClosed(false);
+        mIsOpen = true;
+    }
+
+    private void animateClose() {
+        animateOpenOrClosed(true);
+    }
+
+    private void animateOpenOrClosed(boolean closing) {
+        if (mOpenCloseAnimator != null && mOpenCloseAnimator.isRunning()) {
+            mOpenCloseAnimator.end();
+        }
+        mOpenCloseAnimator = new AnimatorSet();
+
+        final Animator revealAnimator = createOpenCloseOutlineProvider()
+                .createRevealAnimator(this, closing);
+        revealAnimator.setInterpolator(Interpolators.DEACCEL);
+        mOpenCloseAnimator.play(revealAnimator);
+        mOpenCloseAnimator.play(ObjectAnimator.ofFloat(mTaskView.getThumbnail(), DIM_ALPHA,
+                closing ? 0 : TaskView.MAX_PAGE_SCRIM_ALPHA));
+        mOpenCloseAnimator.addListener(new AnimationSuccessListener() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+                setVisibility(VISIBLE);
+            }
+
+            @Override
+            public void onAnimationSuccess(Animator animator) {
+                if (closing) {
+                    closeComplete();
+                }
+            }
+        });
+        mOpenCloseAnimator.play(ObjectAnimator.ofFloat(this, ALPHA, closing ? 0 : 1));
+        mOpenCloseAnimator.setDuration(closing ? REVEAL_CLOSE_DURATION: REVEAL_OPEN_DURATION);
+        mOpenCloseAnimator.start();
+    }
+
+    private void closeComplete() {
+        mIsOpen = false;
+        mActivity.getDragLayer().removeView(this);
+    }
+
+    private RoundedRectRevealOutlineProvider createOpenCloseOutlineProvider() {
+        float radius = Themes.getDialogCornerRadius(getContext());
+        Rect fromRect = new Rect(0, 0, getWidth(), 0);
+        Rect toRect = new Rect(0, 0, getWidth(), getHeight());
+        return new RoundedRectRevealOutlineProvider(radius, radius, fromRect, toRect);
+    }
+
+    public View findMenuItemByText(String text) {
+        for (int i = mOptionLayout.getChildCount() - 1; i >= 0; --i) {
+            final ViewGroup menuOptionView = (ViewGroup) mOptionLayout.getChildAt(i);
+            if (text.equals(menuOptionView.<TextView>findViewById(R.id.text).getText())) {
+                return menuOptionView;
+            }
+        }
+        return null;
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/TaskThumbnailView.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/TaskThumbnailView.java
new file mode 100644
index 0000000000000000000000000000000000000000..86b82dd1222417f73927b29fdd3be2a3e3fb4f21
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/TaskThumbnailView.java
@@ -0,0 +1,408 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package foundation.e.blisslauncher.quickstep.views;
+
+import static com.android.systemui.shared.system.WindowManagerWrapper.WINDOWING_MODE_FULLSCREEN;
+import static foundation.e.blisslauncher.core.Flags.ENABLE_QUICKSTEP_LIVE_TILE;
+
+import android.content.Context;
+import android.content.res.Configuration;
+import android.graphics.Bitmap;
+import android.graphics.BitmapShader;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.ColorFilter;
+import android.graphics.ColorMatrix;
+import android.graphics.ColorMatrixColorFilter;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.Shader;
+import android.util.AttributeSet;
+import android.util.FloatProperty;
+import android.util.Property;
+import android.view.View;
+import com.android.systemui.shared.recents.model.Task;
+import com.android.systemui.shared.recents.model.ThumbnailData;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.features.test.BaseActivity;
+import foundation.e.blisslauncher.features.test.SystemUiController;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.quickstep.TaskOverlayFactory;
+import foundation.e.blisslauncher.quickstep.TaskOverlayFactory.TaskOverlay;
+import foundation.e.blisslauncher.quickstep.util.TaskCornerRadius;
+
+/**
+ * A task in the Recents view.
+ */
+public class TaskThumbnailView extends View {
+
+    private final static ColorMatrix COLOR_MATRIX = new ColorMatrix();
+    private final static ColorMatrix SATURATION_COLOR_MATRIX = new ColorMatrix();
+    private final static RectF EMPTY_RECT_F = new RectF();
+
+    public static final Property<TaskThumbnailView, Float> DIM_ALPHA =
+            new FloatProperty<TaskThumbnailView>("dimAlpha") {
+                @Override
+                public void setValue(TaskThumbnailView thumbnail, float dimAlpha) {
+                    thumbnail.setDimAlpha(dimAlpha);
+                }
+
+                @Override
+                public Float get(TaskThumbnailView thumbnailView) {
+                    return thumbnailView.mDimAlpha;
+                }
+            };
+
+    private final BaseActivity mActivity;
+    private final TaskOverlay mOverlay;
+    private final boolean mIsDarkTextTheme;
+    private final Paint mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+    private final Paint mBackgroundPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+    private final Paint mClearPaint = new Paint();
+    private final Paint mDimmingPaintAfterClearing = new Paint();
+
+    private final Matrix mMatrix = new Matrix();
+
+    private float mClipBottom = -1;
+    // Contains the portion of the thumbnail that is clipped when fullscreen progress = 0.
+    private RectF mClippedInsets = new RectF();
+    private TaskView.FullscreenDrawParams mFullscreenParams;
+
+    private Task mTask;
+    private ThumbnailData mThumbnailData;
+    protected BitmapShader mBitmapShader;
+
+    private float mDimAlpha = 1f;
+    private float mDimAlphaMultiplier = 1f;
+    private float mSaturation = 1f;
+
+    private boolean mOverlayEnabled;
+    private boolean mRotated;
+
+    public TaskThumbnailView(Context context) {
+        this(context, null);
+    }
+
+    public TaskThumbnailView(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public TaskThumbnailView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        mOverlay = TaskOverlayFactory.INSTANCE.get(context).createOverlay(this);
+        mPaint.setFilterBitmap(true);
+        mBackgroundPaint.setColor(Color.WHITE);
+        mClearPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
+        mDimmingPaintAfterClearing.setColor(Color.BLACK);
+        mActivity = BaseActivity.fromContext(context);
+        mIsDarkTextTheme = false;
+        mFullscreenParams = new TaskView.FullscreenDrawParams(TaskCornerRadius.get(context));
+    }
+
+    public void bind(Task task) {
+        mOverlay.reset();
+        mTask = task;
+        int color = task == null ? Color.BLACK : task.colorBackground | 0xFF000000;
+        mPaint.setColor(color);
+        mBackgroundPaint.setColor(color);
+    }
+
+    /**
+     * Updates this thumbnail.
+     */
+    public void setThumbnail(Task task, ThumbnailData thumbnailData) {
+        mTask = task;
+        if (thumbnailData != null && thumbnailData.thumbnail != null) {
+            Bitmap bm = thumbnailData.thumbnail;
+            bm.prepareToDraw();
+            mBitmapShader = new BitmapShader(bm, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
+            mPaint.setShader(mBitmapShader);
+            mThumbnailData = thumbnailData;
+            updateThumbnailMatrix();
+        } else {
+            mBitmapShader = null;
+            mThumbnailData = null;
+            mPaint.setShader(null);
+            mOverlay.reset();
+        }
+        updateThumbnailPaintFilter();
+    }
+
+    public void setDimAlphaMultipler(float dimAlphaMultipler) {
+        mDimAlphaMultiplier = dimAlphaMultipler;
+        setDimAlpha(mDimAlpha);
+    }
+
+    /**
+     * Sets the alpha of the dim layer on top of this view.
+     * <p>
+     * If dimAlpha is 0, no dimming is applied; if dimAlpha is 1, the thumbnail will be black.
+     */
+    public void setDimAlpha(float dimAlpha) {
+        mDimAlpha = dimAlpha;
+        updateThumbnailPaintFilter();
+    }
+
+    public void setSaturation(float saturation) {
+        mSaturation = saturation;
+        updateThumbnailPaintFilter();
+    }
+
+    public float getDimAlpha() {
+        return mDimAlpha;
+    }
+
+    public Rect getInsets(Rect fallback) {
+        if (mThumbnailData != null) {
+            return mThumbnailData.insets;
+        }
+        return fallback;
+    }
+
+    public int getSysUiStatusNavFlags() {
+        if (mThumbnailData != null) {
+            int flags = 0;
+            flags |= (mThumbnailData.systemUiVisibility & SYSTEM_UI_FLAG_LIGHT_STATUS_BAR) != 0
+                    ? SystemUiController.FLAG_LIGHT_STATUS
+                    : SystemUiController.FLAG_DARK_STATUS;
+            flags |= (mThumbnailData.systemUiVisibility & SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR) != 0
+                    ? SystemUiController.FLAG_LIGHT_NAV
+                    : SystemUiController.FLAG_DARK_NAV;
+            return flags;
+        }
+        return 0;
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        RectF currentDrawnInsets = mFullscreenParams.mCurrentDrawnInsets;
+        canvas.save();
+        canvas.translate(currentDrawnInsets.left, currentDrawnInsets.top);
+        canvas.scale(mFullscreenParams.mScale, mFullscreenParams.mScale);
+        // Draw the insets if we're being drawn fullscreen (we do this for quick switch).
+        drawOnCanvas(canvas,
+                -currentDrawnInsets.left,
+                -currentDrawnInsets.top,
+                getMeasuredWidth() + currentDrawnInsets.right,
+                getMeasuredHeight() + currentDrawnInsets.bottom,
+                mFullscreenParams.mCurrentDrawnCornerRadius);
+        canvas.restore();
+    }
+
+    public RectF getInsetsToDrawInFullscreen(boolean isMultiWindowMode) {
+        // Don't show insets in multi window mode.
+        return isMultiWindowMode ? EMPTY_RECT_F : mClippedInsets;
+    }
+
+    public void setFullscreenParams(TaskView.FullscreenDrawParams fullscreenParams) {
+        mFullscreenParams = fullscreenParams;
+        invalidate();
+    }
+
+    public void drawOnCanvas(Canvas canvas, float x, float y, float width, float height,
+            float cornerRadius) {
+        if (ENABLE_QUICKSTEP_LIVE_TILE) {
+            if (mTask != null && getTaskView().isRunningTask() && !getTaskView().showScreenshot()) {
+                canvas.drawRoundRect(x, y, width, height, cornerRadius, cornerRadius, mClearPaint);
+                canvas.drawRoundRect(x, y, width, height, cornerRadius, cornerRadius,
+                        mDimmingPaintAfterClearing);
+                return;
+            }
+        }
+
+        // Draw the background in all cases, except when the thumbnail data is opaque
+        final boolean drawBackgroundOnly = mTask == null || mTask.isLocked || mBitmapShader == null
+                || mThumbnailData == null;
+        if (drawBackgroundOnly || mClipBottom > 0 || mThumbnailData.isTranslucent) {
+            canvas.drawRoundRect(x, y, width, height, cornerRadius, cornerRadius, mBackgroundPaint);
+            if (drawBackgroundOnly) {
+                return;
+            }
+        }
+
+        if (mClipBottom > 0) {
+            canvas.save();
+            canvas.clipRect(x, y, width, mClipBottom);
+            canvas.drawRoundRect(x, y, width, height, cornerRadius, cornerRadius, mPaint);
+            canvas.restore();
+        } else {
+            canvas.drawRoundRect(x, y, width, height, cornerRadius, cornerRadius, mPaint);
+        }
+    }
+
+    public TaskView getTaskView() {
+        return (TaskView) getParent();
+    }
+
+    public void setOverlayEnabled(boolean overlayEnabled) {
+        if (mOverlayEnabled != overlayEnabled) {
+            mOverlayEnabled = overlayEnabled;
+            updateOverlay();
+        }
+    }
+
+    private void updateOverlay() {
+        // The overlay doesn't really work when the screenshot is rotated, so don't add it.
+        if (mOverlayEnabled && !mRotated && mBitmapShader != null && mThumbnailData != null) {
+            mOverlay.initOverlay(mTask, mThumbnailData, mMatrix);
+        } else {
+            mOverlay.reset();
+        }
+    }
+
+    private void updateThumbnailPaintFilter() {
+        int mul = (int) ((1 - mDimAlpha * mDimAlphaMultiplier) * 255);
+        ColorFilter filter = getColorFilter(mul, mIsDarkTextTheme, mSaturation);
+        mBackgroundPaint.setColorFilter(filter);
+        mDimmingPaintAfterClearing.setAlpha(255 - mul);
+        if (mBitmapShader != null) {
+            mPaint.setColorFilter(filter);
+        } else {
+            mPaint.setColorFilter(null);
+            mPaint.setColor(Color.argb(255, mul, mul, mul));
+        }
+        invalidate();
+    }
+
+    private void updateThumbnailMatrix() {
+        boolean isRotated = false;
+        mClipBottom = -1;
+        if (mBitmapShader != null && mThumbnailData != null) {
+            float scale = mThumbnailData.scale;
+            Rect thumbnailInsets = mThumbnailData.insets;
+            final float thumbnailWidth = mThumbnailData.thumbnail.getWidth() -
+                    (thumbnailInsets.left + thumbnailInsets.right) * scale;
+            final float thumbnailHeight = mThumbnailData.thumbnail.getHeight() -
+                    (thumbnailInsets.top + thumbnailInsets.bottom) * scale;
+
+            final float thumbnailScale;
+            final VariantDeviceProfile profile = mActivity.getDeviceProfile();
+
+            if (getMeasuredWidth() == 0) {
+                // If we haven't measured , skip the thumbnail drawing and only draw the background
+                // color
+                thumbnailScale = 0f;
+            } else {
+                final Configuration configuration =
+                        getContext().getResources().getConfiguration();
+                // Rotate the screenshot if not in multi-window mode
+                isRotated = configuration.orientation != mThumbnailData.orientation &&
+                        !mActivity.isInMultiWindowMode() &&
+                        mThumbnailData.windowingMode == WINDOWING_MODE_FULLSCREEN;
+                // Scale the screenshot to always fit the width of the card.
+                thumbnailScale = isRotated
+                        ? getMeasuredWidth() / thumbnailHeight
+                        : getMeasuredWidth() / thumbnailWidth;
+            }
+
+            if (isRotated) {
+                int rotationDir = 1;
+                mMatrix.setRotate(90 * rotationDir);
+                int newLeftInset = rotationDir == 1 ? thumbnailInsets.bottom : thumbnailInsets.top;
+                int newTopInset = rotationDir == 1 ? thumbnailInsets.left : thumbnailInsets.right;
+                mClippedInsets.offsetTo(newLeftInset * scale, newTopInset * scale);
+                if (rotationDir == -1) {
+                    // Crop the right/bottom side of the screenshot rather than left/top
+                    float excessHeight = thumbnailWidth * thumbnailScale - getMeasuredHeight();
+                    mClippedInsets.offset(0, excessHeight);
+                }
+                mMatrix.postTranslate(-mClippedInsets.left, -mClippedInsets.top);
+                // Move the screenshot to the thumbnail window (rotation moved it out).
+                if (rotationDir == 1) {
+                    mMatrix.postTranslate(mThumbnailData.thumbnail.getHeight(), 0);
+                } else {
+                    mMatrix.postTranslate(0, mThumbnailData.thumbnail.getWidth());
+                }
+            } else {
+                mClippedInsets.offsetTo(thumbnailInsets.left * scale, thumbnailInsets.top * scale);
+                mMatrix.setTranslate(-mClippedInsets.left, -mClippedInsets.top);
+            }
+
+            final float widthWithInsets;
+            final float heightWithInsets;
+            if (isRotated) {
+                widthWithInsets = mThumbnailData.thumbnail.getHeight() * thumbnailScale;
+                heightWithInsets = mThumbnailData.thumbnail.getWidth() * thumbnailScale;
+            } else {
+                widthWithInsets = mThumbnailData.thumbnail.getWidth() * thumbnailScale;
+                heightWithInsets = mThumbnailData.thumbnail.getHeight() * thumbnailScale;
+            }
+            mClippedInsets.left *= thumbnailScale;
+            mClippedInsets.top *= thumbnailScale;
+            mClippedInsets.right = widthWithInsets - mClippedInsets.left - getMeasuredWidth();
+            mClippedInsets.bottom = heightWithInsets - mClippedInsets.top - getMeasuredHeight();
+
+            mMatrix.postScale(thumbnailScale, thumbnailScale);
+            mBitmapShader.setLocalMatrix(mMatrix);
+
+            float bitmapHeight = Math.max((isRotated ? thumbnailWidth : thumbnailHeight)
+                    * thumbnailScale, 0);
+            if (Math.round(bitmapHeight) < getMeasuredHeight()) {
+                mClipBottom = bitmapHeight;
+            }
+            mPaint.setShader(mBitmapShader);
+        }
+
+        mRotated = isRotated;
+        invalidate();
+
+        // Update can be called from {@link #onSizeChanged} during layout, post handling of overlay
+        // as overlay could modify the views in the overlay as a side effect of its update.
+        post(this::updateOverlay);
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+        updateThumbnailMatrix();
+    }
+
+    /**
+     * @param intensity multiplier for color values. 0 - make black (white if shouldLighten), 255 -
+     *                  leave unchanged.
+     */
+    private static ColorFilter getColorFilter(int intensity, boolean shouldLighten,
+            float saturation) {
+        intensity = Utilities.boundToRange(intensity, 0, 255);
+
+        if (intensity == 255 && saturation == 1) {
+            return null;
+        }
+
+        final float intensityScale = intensity / 255f;
+        COLOR_MATRIX.setScale(intensityScale, intensityScale, intensityScale, 1);
+
+        if (saturation != 1) {
+            SATURATION_COLOR_MATRIX.setSaturation(saturation);
+            COLOR_MATRIX.postConcat(SATURATION_COLOR_MATRIX);
+        }
+
+        if (shouldLighten) {
+            final float[] colorArray = COLOR_MATRIX.getArray();
+            final int colorAdd = 255 - intensity;
+            colorArray[4] = colorAdd;
+            colorArray[9] = colorAdd;
+            colorArray[14] = colorAdd;
+        }
+
+        return new ColorMatrixColorFilter(COLOR_MATRIX);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/TaskView.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/TaskView.java
new file mode 100644
index 0000000000000000000000000000000000000000..87e6dd7299845f389e60223384706fd0662f1e9b
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/quickstep/views/TaskView.java
@@ -0,0 +1,780 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package foundation.e.blisslauncher.quickstep.views;
+
+import static android.widget.Toast.LENGTH_SHORT;
+import static foundation.e.blisslauncher.QuickstepAppTransitionManagerImpl.RECENTS_LAUNCH_DURATION;
+import static foundation.e.blisslauncher.core.Flags.ENABLE_QUICKSTEP_LIVE_TILE;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.FAST_OUT_SLOW_IN;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.animation.TimeInterpolator;
+import android.animation.ValueAnimator;
+import android.app.ActivityOptions;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Outline;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.drawable.Drawable;
+import android.os.Handler;
+import android.util.AttributeSet;
+import android.util.FloatProperty;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewOutlineProvider;
+import android.widget.FrameLayout;
+import android.widget.Toast;
+import com.android.systemui.shared.recents.model.Task;
+import com.android.systemui.shared.system.ActivityManagerWrapper;
+import com.android.systemui.shared.system.ActivityOptionsCompat;
+import com.android.systemui.shared.system.QuickStepContract;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+import foundation.e.blisslauncher.features.test.anim.Interpolators;
+import foundation.e.blisslauncher.features.test.anim.PendingAnimation;
+import foundation.e.blisslauncher.quickstep.RecentsModel;
+import foundation.e.blisslauncher.quickstep.TaskIconCache;
+import foundation.e.blisslauncher.quickstep.TaskThumbnailCache;
+import foundation.e.blisslauncher.quickstep.util.TaskCornerRadius;
+import foundation.e.blisslauncher.quickstep.util.ViewPool;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+
+/**
+ * A task in the Recents view.
+ */
+public class TaskView extends FrameLayout implements RecentsView.PageCallbacks, ViewPool.Reusable {
+
+    private static final String TAG = TaskView.class.getSimpleName();
+
+    /** A curve of x from 0 to 1, where 0 is the center of the screen and 1 is the edge. */
+    private static final TimeInterpolator CURVE_INTERPOLATOR
+            = x -> (float) -Math.cos(x * Math.PI) / 2f + .5f;
+
+    /**
+     * The alpha of a black scrim on a page in the carousel as it leaves the screen.
+     * In the resting position of the carousel, the adjacent pages have about half this scrim.
+     */
+    public static final float MAX_PAGE_SCRIM_ALPHA = 0.4f;
+
+    /**
+     * How much to scale down pages near the edge of the screen.
+     */
+    public static final float EDGE_SCALE_DOWN_FACTOR = 0.03f;
+
+    public static final long SCALE_ICON_DURATION = 120;
+    private static final long DIM_ANIM_DURATION = 700;
+
+    private static final List<Rect> SYSTEM_GESTURE_EXCLUSION_RECT =
+            Collections.singletonList(new Rect());
+
+    public static final FloatProperty<TaskView> FULLSCREEN_PROGRESS =
+            new FloatProperty<TaskView>("fullscreenProgress") {
+                @Override
+                public void setValue(TaskView taskView, float v) {
+                    taskView.setFullscreenProgress(v);
+                }
+
+                @Override
+                public Float get(TaskView taskView) {
+                    return taskView.mFullscreenProgress;
+                }
+            };
+
+    private static final FloatProperty<TaskView> FOCUS_TRANSITION =
+            new FloatProperty<TaskView>("focusTransition") {
+                @Override
+                public void setValue(TaskView taskView, float v) {
+                    taskView.setIconAndDimTransitionProgress(v, false /* invert */);
+                }
+
+                @Override
+                public Float get(TaskView taskView) {
+                    return taskView.mFocusTransitionProgress;
+                }
+            };
+
+    private final OnAttachStateChangeListener mTaskMenuStateListener =
+            new OnAttachStateChangeListener() {
+                @Override
+                public void onViewAttachedToWindow(View view) {
+                }
+
+                @Override
+                public void onViewDetachedFromWindow(View view) {
+                    if (mMenuView != null) {
+                        mMenuView.removeOnAttachStateChangeListener(this);
+                        mMenuView = null;
+                    }
+                }
+            };
+
+    private final TaskOutlineProvider mOutlineProvider;
+
+    private Task mTask;
+    private TaskThumbnailView mSnapshotView;
+    private TaskMenuView mMenuView;
+    private IconView mIconView;
+    private float mCurveScale;
+    private float mFullscreenProgress;
+    private final FullscreenDrawParams mCurrentFullscreenParams;
+    private final float mCornerRadius;
+    private final float mWindowCornerRadius;
+    private final BaseDraggingActivity mActivity;
+
+    private ObjectAnimator mIconAndDimAnimator;
+    private float mIconScaleAnimStartProgress = 0;
+    private float mFocusTransitionProgress = 1;
+    private float mStableAlpha = 1;
+
+    private boolean mShowScreenshot;
+
+    // The current background requests to load the task thumbnail and icon
+    private TaskThumbnailCache.ThumbnailLoadRequest mThumbnailLoadRequest;
+    private TaskIconCache.IconLoadRequest mIconLoadRequest;
+
+    // Order in which the footers appear. Lower order appear below higher order.
+    public static final int INDEX_DIGITAL_WELLBEING_TOAST = 0;
+    public static final int INDEX_PROACTIVE_SUGGEST = 1;
+    private final FooterWrapper[] mFooters = new FooterWrapper[2];
+    private float mFooterVerticalOffset = 0;
+    private float mFooterAlpha = 1;
+    private int mStackHeight;
+
+    public TaskView(Context context) {
+        this(context, null);
+    }
+
+    public TaskView(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public TaskView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        mActivity = BaseDraggingActivity.fromContext(context);
+        setOnClickListener((view) -> {
+            if (getTask() == null) {
+                return;
+            }
+            if (ENABLE_QUICKSTEP_LIVE_TILE) {
+                if (isRunningTask()) {
+                    createLaunchAnimationForRunningTask().start();
+                } else {
+                    launchTask(true /* animate */);
+                }
+            } else {
+                launchTask(true /* animate */);
+            }
+        });
+        mCornerRadius = TaskCornerRadius.get(context);
+        mWindowCornerRadius = QuickStepContract.getWindowCornerRadius(context.getResources());
+        mCurrentFullscreenParams = new FullscreenDrawParams(mCornerRadius);
+
+        mOutlineProvider = new TaskOutlineProvider(getResources(), mCurrentFullscreenParams);
+        setOutlineProvider(mOutlineProvider);
+    }
+
+    @Override
+    protected void onFinishInflate() {
+        super.onFinishInflate();
+        mSnapshotView = findViewById(R.id.snapshot);
+        mIconView = findViewById(R.id.icon);
+    }
+
+    public TaskMenuView getMenuView() {
+        return mMenuView;
+    }
+
+    /**
+     * Updates this task view to the given {@param task}.
+     */
+    public void bind(Task task) {
+        cancelPendingLoadTasks();
+        mTask = task;
+        mSnapshotView.bind(task);
+    }
+
+    public Task getTask() {
+        return mTask;
+    }
+
+    public TaskThumbnailView getThumbnail() {
+        return mSnapshotView;
+    }
+
+    public IconView getIconView() {
+        return mIconView;
+    }
+
+    public AnimatorPlaybackController createLaunchAnimationForRunningTask() {
+        final PendingAnimation pendingAnimation =
+                getRecentsView().createTaskLauncherAnimation(this, RECENTS_LAUNCH_DURATION);
+        pendingAnimation.anim.setInterpolator(Interpolators.TOUCH_RESPONSE_INTERPOLATOR);
+        AnimatorPlaybackController currentAnimation = AnimatorPlaybackController
+                .wrap(pendingAnimation.anim, RECENTS_LAUNCH_DURATION, null);
+        currentAnimation.setEndAction(() -> {
+            pendingAnimation.finish(true);
+            launchTask(false);
+        });
+        return currentAnimation;
+    }
+
+    public void launchTask(boolean animate) {
+        launchTask(animate, false /* freezeTaskList */);
+    }
+
+    public void launchTask(boolean animate, boolean freezeTaskList) {
+        launchTask(animate, freezeTaskList, (result) -> {
+            if (!result) {
+                notifyTaskLaunchFailed(TAG);
+            }
+        }, getHandler());
+    }
+
+    public void launchTask(boolean animate, Consumer<Boolean> resultCallback,
+            Handler resultCallbackHandler) {
+        launchTask(animate, false /* freezeTaskList */, resultCallback, resultCallbackHandler);
+    }
+
+    public void launchTask(boolean animate, boolean freezeTaskList, Consumer<Boolean> resultCallback,
+            Handler resultCallbackHandler) {
+        if (ENABLE_QUICKSTEP_LIVE_TILE) {
+            if (isRunningTask()) {
+                getRecentsView().finishRecentsAnimation(false /* toRecents */,
+                        () -> resultCallbackHandler.post(() -> resultCallback.accept(true)));
+            } else {
+                launchTaskInternal(animate, freezeTaskList, resultCallback, resultCallbackHandler);
+            }
+        } else {
+            launchTaskInternal(animate, freezeTaskList, resultCallback, resultCallbackHandler);
+        }
+    }
+
+    private void launchTaskInternal(boolean animate, boolean freezeTaskList,
+            Consumer<Boolean> resultCallback, Handler resultCallbackHandler) {
+        if (mTask != null) {
+            final ActivityOptions opts;
+            if (animate) {
+                opts = mActivity.getActivityLaunchOptions(this);
+                if (freezeTaskList) {
+                    ActivityOptionsCompat.setFreezeRecentTasksList(opts);
+                }
+                ActivityManagerWrapper.getInstance().startActivityFromRecentsAsync(mTask.key,
+                        opts, resultCallback, resultCallbackHandler);
+            } else {
+                opts = ActivityOptionsCompat.makeCustomAnimation(getContext(), 0, 0, () -> {
+                    if (resultCallback != null) {
+                        // Only post the animation start after the system has indicated that the
+                        // transition has started
+                        resultCallbackHandler.post(() -> resultCallback.accept(true));
+                    }
+                }, resultCallbackHandler);
+                if (freezeTaskList) {
+                    ActivityOptionsCompat.setFreezeRecentTasksList(opts);
+                }
+                ActivityManagerWrapper.getInstance().startActivityFromRecentsAsync(mTask.key,
+                        opts, (success) -> {
+                            if (resultCallback != null && !success) {
+                                // If the call to start activity failed, then post the result
+                                // immediately, otherwise, wait for the animation start callback
+                                // from the activity options above
+                                resultCallbackHandler.post(() -> resultCallback.accept(false));
+                            }
+                        }, resultCallbackHandler);
+            }
+        }
+    }
+
+    public void onTaskListVisibilityChanged(boolean visible) {
+        if (mTask == null) {
+            return;
+        }
+        cancelPendingLoadTasks();
+        if (visible) {
+            // These calls are no-ops if the data is already loaded, try and load the high
+            // resolution thumbnail if the state permits
+            RecentsModel model = RecentsModel.INSTANCE.get(getContext());
+            TaskThumbnailCache thumbnailCache = model.getThumbnailCache();
+            TaskIconCache iconCache = model.getIconCache();
+            mThumbnailLoadRequest = thumbnailCache.updateThumbnailInBackground(
+                    mTask, thumbnail -> mSnapshotView.setThumbnail(mTask, thumbnail));
+            mIconLoadRequest = iconCache.updateIconInBackground(mTask,
+                    (task) -> {
+                        setIcon(task.icon);
+                        if (ENABLE_QUICKSTEP_LIVE_TILE && isRunningTask()) {
+                            getRecentsView().updateLiveTileIcon(task.icon);
+                        }
+                    });
+        } else {
+            mSnapshotView.setThumbnail(null, null);
+            setIcon(null);
+            // Reset the task thumbnail reference as well (it will be fetched from the cache or
+            // reloaded next time we need it)
+            mTask.thumbnail = null;
+        }
+    }
+
+    private void cancelPendingLoadTasks() {
+        if (mThumbnailLoadRequest != null) {
+            mThumbnailLoadRequest.cancel();
+            mThumbnailLoadRequest = null;
+        }
+        if (mIconLoadRequest != null) {
+            mIconLoadRequest.cancel();
+            mIconLoadRequest = null;
+        }
+    }
+
+    private boolean showTaskMenu() {
+        getRecentsView().snapToPage(getRecentsView().indexOfChild(this));
+        mMenuView = TaskMenuView.showForTask(this);
+        if (mMenuView != null) {
+            mMenuView.addOnAttachStateChangeListener(mTaskMenuStateListener);
+        }
+        return mMenuView != null;
+    }
+
+    private void setIcon(Drawable icon) {
+        if (icon != null) {
+            mIconView.setDrawable(icon);
+            mIconView.setOnClickListener(v -> showTaskMenu());
+            mIconView.setOnLongClickListener(v -> {
+                requestDisallowInterceptTouchEvent(true);
+                return showTaskMenu();
+            });
+        } else {
+            mIconView.setDrawable(null);
+            mIconView.setOnClickListener(null);
+            mIconView.setOnLongClickListener(null);
+        }
+    }
+
+    private void setIconAndDimTransitionProgress(float progress, boolean invert) {
+        if (invert) {
+            progress = 1 - progress;
+        }
+        mFocusTransitionProgress = progress;
+        mSnapshotView.setDimAlphaMultipler(progress);
+        float iconScalePercentage = (float) SCALE_ICON_DURATION / DIM_ANIM_DURATION;
+        float lowerClamp = invert ? 1f - iconScalePercentage : 0;
+        float upperClamp = invert ? 1 : iconScalePercentage;
+        float scale = Interpolators.clampToProgress(FAST_OUT_SLOW_IN, lowerClamp, upperClamp)
+                .getInterpolation(progress);
+        mIconView.setScaleX(scale);
+        mIconView.setScaleY(scale);
+
+        mFooterVerticalOffset = 1.0f - scale;
+        for (FooterWrapper footer : mFooters) {
+            if (footer != null) {
+                footer.updateFooterOffset();
+            }
+        }
+    }
+
+    public void setIconScaleAnimStartProgress(float startProgress) {
+        mIconScaleAnimStartProgress = startProgress;
+    }
+
+    public void animateIconScaleAndDimIntoView() {
+        if (mIconAndDimAnimator != null) {
+            mIconAndDimAnimator.cancel();
+        }
+        mIconAndDimAnimator = ObjectAnimator.ofFloat(this, FOCUS_TRANSITION, 1);
+        mIconAndDimAnimator.setCurrentFraction(mIconScaleAnimStartProgress);
+        mIconAndDimAnimator.setDuration(DIM_ANIM_DURATION).setInterpolator(LINEAR);
+        mIconAndDimAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mIconAndDimAnimator = null;
+            }
+        });
+        mIconAndDimAnimator.start();
+    }
+
+    protected void setIconScaleAndDim(float iconScale) {
+        setIconScaleAndDim(iconScale, false);
+    }
+
+    private void setIconScaleAndDim(float iconScale, boolean invert) {
+        if (mIconAndDimAnimator != null) {
+            mIconAndDimAnimator.cancel();
+        }
+        setIconAndDimTransitionProgress(iconScale, invert);
+    }
+
+    private void resetViewTransforms() {
+        setCurveScale(1);
+        setTranslationX(0f);
+        setTranslationY(0f);
+        setTranslationZ(0);
+        setAlpha(mStableAlpha);
+        setIconScaleAndDim(1);
+    }
+
+    public void resetVisualProperties() {
+        resetViewTransforms();
+        setFullscreenProgress(0);
+    }
+
+    public void setStableAlpha(float parentAlpha) {
+        mStableAlpha = parentAlpha;
+        setAlpha(mStableAlpha);
+    }
+
+    @Override
+    public void onRecycle() {
+        resetViewTransforms();
+        // Clear any references to the thumbnail (it will be re-read either from the cache or the
+        // system on next bind)
+        mSnapshotView.setThumbnail(mTask, null);
+        setOverlayEnabled(false);
+        onTaskListVisibilityChanged(false);
+    }
+
+    @Override
+    public void onPageScroll(RecentsView.ScrollState scrollState) {
+        float curveInterpolation =
+                CURVE_INTERPOLATOR.getInterpolation(scrollState.linearInterpolation);
+
+        mSnapshotView.setDimAlpha(curveInterpolation * MAX_PAGE_SCRIM_ALPHA);
+        setCurveScale(getCurveScaleForCurveInterpolation(curveInterpolation));
+
+        mFooterAlpha = Utilities.boundToRange(1.0f - 2 * scrollState.linearInterpolation, 0f, 1f);
+        for (FooterWrapper footer : mFooters) {
+            if (footer != null) {
+                footer.mView.setAlpha(mFooterAlpha);
+            }
+        }
+
+        if (mMenuView != null) {
+            mMenuView.setPosition(getX() - getRecentsView().getScrollX(), getY());
+            mMenuView.setScaleX(getScaleX());
+            mMenuView.setScaleY(getScaleY());
+        }
+    }
+
+
+    /**
+     * Sets the footer at the specific index and returns the previously set footer.
+     */
+    public View setFooter(int index, View view) {
+        View oldFooter = null;
+
+        // If the footer are is already collapsed, do not animate entry
+        boolean shouldAnimateEntry = mFooterVerticalOffset <= 0;
+
+        if (mFooters[index] != null) {
+            oldFooter = mFooters[index].mView;
+            mFooters[index].release();
+            removeView(oldFooter);
+
+            // If we are replacing an existing footer, do not animate entry
+            shouldAnimateEntry = false;
+        }
+        if (view != null) {
+            int indexToAdd = getChildCount();
+            for (int i = index - 1; i >= 0; i--) {
+                if (mFooters[i] != null) {
+                    indexToAdd = indexOfChild(mFooters[i].mView);
+                    break;
+                }
+            }
+
+            addView(view, indexToAdd);
+            ((LayoutParams) view.getLayoutParams()).gravity =
+                    Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL;
+            view.setAlpha(mFooterAlpha);
+            mFooters[index] = new FooterWrapper(view);
+            if (shouldAnimateEntry) {
+                mFooters[index].animateEntry();
+            }
+        } else {
+            mFooters[index] = null;
+        }
+
+        mStackHeight = 0;
+        for (FooterWrapper footer : mFooters) {
+            if (footer != null) {
+                footer.setVerticalShift(mStackHeight);
+                mStackHeight += footer.mExpectedHeight;
+            }
+        }
+
+        return oldFooter;
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        super.onLayout(changed, left, top, right, bottom);
+        setPivotX((right - left) * 0.5f);
+        setPivotY(mSnapshotView.getTop() + mSnapshotView.getHeight() * 0.5f);
+        if (Utilities.ATLEAST_Q) {
+            SYSTEM_GESTURE_EXCLUSION_RECT.get(0).set(0, 0, getWidth(), getHeight());
+            setSystemGestureExclusionRects(SYSTEM_GESTURE_EXCLUSION_RECT);
+        }
+
+        mStackHeight = 0;
+        for (FooterWrapper footer : mFooters) {
+            if (footer != null) {
+                mStackHeight += footer.mView.getHeight();
+            }
+        }
+        for (FooterWrapper footer : mFooters) {
+            if (footer != null) {
+                footer.updateFooterOffset();
+            }
+        }
+    }
+
+    public static float getCurveScaleForInterpolation(float linearInterpolation) {
+        float curveInterpolation = CURVE_INTERPOLATOR.getInterpolation(linearInterpolation);
+        return getCurveScaleForCurveInterpolation(curveInterpolation);
+    }
+
+    private static float getCurveScaleForCurveInterpolation(float curveInterpolation) {
+        return 1 - curveInterpolation * EDGE_SCALE_DOWN_FACTOR;
+    }
+
+    public void setCurveScale(float curveScale) {
+        mCurveScale = curveScale;
+        onScaleChanged();
+    }
+
+    public float getCurveScale() {
+        return mCurveScale;
+    }
+
+    private void onScaleChanged() {
+        float scale = mCurveScale;
+        setScaleX(scale);
+        setScaleY(scale);
+    }
+
+    @Override
+    public boolean hasOverlappingRendering() {
+        // TODO: Clip-out the icon region from the thumbnail, since they are overlapping.
+        return false;
+    }
+
+    private static final class TaskOutlineProvider extends ViewOutlineProvider {
+
+        private final int mMarginTop;
+        private FullscreenDrawParams mFullscreenParams;
+
+        TaskOutlineProvider(Resources res, FullscreenDrawParams fullscreenParams) {
+            mMarginTop = res.getDimensionPixelSize(R.dimen.task_thumbnail_top_margin);
+            mFullscreenParams = fullscreenParams;
+        }
+
+        public void setFullscreenParams(FullscreenDrawParams params) {
+            mFullscreenParams = params;
+        }
+
+        @Override
+        public void getOutline(View view, Outline outline) {
+            RectF insets = mFullscreenParams.mCurrentDrawnInsets;
+            float scale = mFullscreenParams.mScale;
+            outline.setRoundRect(0,
+                    (int) (mMarginTop * scale),
+                    (int) ((insets.left + view.getWidth() + insets.right) * scale),
+                    (int) ((insets.top + view.getHeight() + insets.bottom) * scale),
+                    mFullscreenParams.mCurrentDrawnCornerRadius);
+        }
+    }
+
+    private class FooterWrapper extends ViewOutlineProvider {
+
+        final View mView;
+        final ViewOutlineProvider mOldOutlineProvider;
+        final ViewOutlineProvider mDelegate;
+
+        final int mExpectedHeight;
+        final int mOldPaddingBottom;
+
+        int mAnimationOffset = 0;
+        int mEntryAnimationOffset = 0;
+
+        public FooterWrapper(View view) {
+            mView = view;
+            mOldOutlineProvider = view.getOutlineProvider();
+            mDelegate = mOldOutlineProvider == null
+                    ? ViewOutlineProvider.BACKGROUND : mOldOutlineProvider;
+
+            int h = view.getLayoutParams().height;
+            if (h > 0) {
+                mExpectedHeight = h;
+            } else {
+                int m = MeasureSpec.makeMeasureSpec(MeasureSpec.EXACTLY - 1, MeasureSpec.AT_MOST);
+                view.measure(m, m);
+                mExpectedHeight = view.getMeasuredHeight();
+            }
+            mOldPaddingBottom = view.getPaddingBottom();
+
+            if (mOldOutlineProvider != null) {
+                view.setOutlineProvider(this);
+                view.setClipToOutline(true);
+            }
+        }
+
+        public void setVerticalShift(int shift) {
+            mView.setPadding(mView.getPaddingLeft(), mView.getPaddingTop(),
+                    mView.getPaddingRight(), mOldPaddingBottom + shift);
+        }
+
+        @Override
+        public void getOutline(View view, Outline outline) {
+            mDelegate.getOutline(view, outline);
+            outline.offset(0, -mAnimationOffset - mEntryAnimationOffset);
+        }
+
+        void updateFooterOffset() {
+            mAnimationOffset = Math.round(mStackHeight * mFooterVerticalOffset);
+            mView.setTranslationY(mAnimationOffset + mEntryAnimationOffset
+                    + mCurrentFullscreenParams.mCurrentDrawnInsets.bottom
+                    + mCurrentFullscreenParams.mCurrentDrawnInsets.top);
+            mView.invalidateOutline();
+        }
+
+        void release() {
+            mView.setOutlineProvider(mOldOutlineProvider);
+            setVerticalShift(0);
+        }
+
+        void animateEntry() {
+            ValueAnimator animator = ValueAnimator.ofFloat(0, 1);
+            animator.addUpdateListener(anim -> {
+               float factor = 1 - anim.getAnimatedFraction();
+               int totalShift = mExpectedHeight + mView.getPaddingBottom() - mOldPaddingBottom;
+                mEntryAnimationOffset = Math.round(factor * totalShift);
+                updateFooterOffset();
+            });
+            animator.setDuration(100);
+            animator.start();
+        }
+    }
+
+    public RecentsView getRecentsView() {
+        return (RecentsView) getParent();
+    }
+
+    public void notifyTaskLaunchFailed(String tag) {
+        String msg = "Failed to launch task";
+        if (mTask != null) {
+            msg += " (task=" + mTask.key.baseIntent + " userId=" + mTask.key.userId + ")";
+        }
+        Log.w(tag, msg);
+        Toast.makeText(getContext(), R.string.activity_not_available, LENGTH_SHORT).show();
+    }
+
+    /**
+     * Hides the icon and shows insets when this TaskView is about to be shown fullscreen.
+     * @param progress: 0 = show icon and no insets; 1 = don't show icon and show full insets.
+     */
+    public void setFullscreenProgress(float progress) {
+        progress = Utilities.boundToRange(progress, 0, 1);
+        if (progress == mFullscreenProgress) {
+            return;
+        }
+        mFullscreenProgress = progress;
+        boolean isFullscreen = mFullscreenProgress > 0;
+        mIconView.setVisibility(progress < 1 ? VISIBLE : INVISIBLE);
+        setClipChildren(!isFullscreen);
+        setClipToPadding(!isFullscreen);
+
+        TaskThumbnailView thumbnail = getThumbnail();
+        boolean isMultiWindowMode = mActivity.getDeviceProfile().isMultiWindowMode;
+        RectF insets = thumbnail.getInsetsToDrawInFullscreen(isMultiWindowMode);
+        float currentInsetsLeft = insets.left * mFullscreenProgress;
+        float currentInsetsRight = insets.right * mFullscreenProgress;
+        mCurrentFullscreenParams.setInsets(currentInsetsLeft,
+                insets.top * mFullscreenProgress,
+                currentInsetsRight,
+                insets.bottom * mFullscreenProgress);
+        float fullscreenCornerRadius = isMultiWindowMode ? 0 : mWindowCornerRadius;
+        mCurrentFullscreenParams.setCornerRadius(Utilities.mapRange(mFullscreenProgress,
+                mCornerRadius, fullscreenCornerRadius) / getRecentsView().getScaleX());
+        // We scaled the thumbnail to fit the content (excluding insets) within task view width.
+        // Now that we are drawing left/right insets again, we need to scale down to fit them.
+        if (getWidth() > 0) {
+            mCurrentFullscreenParams.setScale(getWidth()
+                    / (getWidth() + currentInsetsLeft + currentInsetsRight));
+        }
+
+        // Some of the items in here are dependent on the current fullscreen params
+        setIconScaleAndDim(progress, true /* invert */);
+
+        thumbnail.setFullscreenParams(mCurrentFullscreenParams);
+        mOutlineProvider.setFullscreenParams(mCurrentFullscreenParams);
+        invalidateOutline();
+    }
+
+    public boolean isRunningTask() {
+        if (getRecentsView() == null) {
+            return false;
+        }
+        return this == getRecentsView().getRunningTaskView();
+    }
+
+    public void setShowScreenshot(boolean showScreenshot) {
+        mShowScreenshot = showScreenshot;
+    }
+
+    public boolean showScreenshot() {
+        if (!isRunningTask()) {
+            return true;
+        }
+        return mShowScreenshot;
+    }
+
+    public void setOverlayEnabled(boolean overlayEnabled) {
+        mSnapshotView.setOverlayEnabled(overlayEnabled);
+    }
+
+    /**
+     * We update and subsequently draw these in {@link #setFullscreenProgress(float)}.
+     */
+    static class FullscreenDrawParams {
+        RectF mCurrentDrawnInsets = new RectF();
+        float mCurrentDrawnCornerRadius;
+        /** The current scale we apply to the thumbnail to adjust for new left/right insets. */
+        float mScale = 1;
+
+        public FullscreenDrawParams(float cornerRadius) {
+            setCornerRadius(cornerRadius);
+        }
+
+        public void setInsets(float left, float top, float right, float bottom) {
+            mCurrentDrawnInsets.set(left, top, right, bottom);
+        }
+
+        public void setCornerRadius(float cornerRadius) {
+            mCurrentDrawnCornerRadius = cornerRadius;
+        }
+
+        public void setScale(float scale) {
+            mScale = scale;
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/OverlayCallbackImpl.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/OverlayCallbackImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..200d1d37839a91a025b028d7071e4b4306329967
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/OverlayCallbackImpl.java
@@ -0,0 +1,50 @@
+package foundation.e.blisslauncher.uioverrides;
+
+import android.util.Log;
+
+import org.jetbrains.annotations.Nullable;
+
+import foundation.e.blisslauncher.features.test.TestActivity;
+
+public class OverlayCallbackImpl implements TestActivity.LauncherOverlay {
+
+    private final TestActivity mLauncher;
+    private static final String TAG = "OverlayCallbackImpl";
+    private float mProgress = 0;
+
+    private TestActivity.LauncherOverlayCallbacks mLauncherOverlayCallbacks;
+
+    public OverlayCallbackImpl(TestActivity launcher) {
+        this.mLauncher = launcher;
+    }
+
+    @Override
+    public void onScrollInteractionBegin() {
+        Log.d(TAG, "onScrollInteractionBegin() called");
+        mLauncherOverlayCallbacks.onScrollBegin();
+    }
+
+    @Override
+    public void onScrollInteractionEnd() {
+        Log.d(TAG, "onScrollInteractionEnd() called");
+        if(mProgress > 0.5f) mLauncherOverlayCallbacks.onScrollChanged(1f);
+        else mLauncherOverlayCallbacks.onScrollChanged(0f);
+    }
+
+    @Override
+    public void onScrollChange(float progress, boolean rtl) {
+        Log.d(
+            TAG,
+            "onScrollChange() called with: progress = [" + progress + "], rtl = [" + rtl + "]"
+        );
+        if(mLauncherOverlayCallbacks != null) {
+            mLauncherOverlayCallbacks.onScrollChanged(progress);
+            mProgress = progress;
+        }
+    }
+
+    @Override
+    public void setOverlayCallbacks(@Nullable TestActivity.LauncherOverlayCallbacks callbacks) {
+        mLauncherOverlayCallbacks = callbacks;
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/RecentsUiFactory.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/RecentsUiFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e10adf81553588d9c75aa94deee71fa44eda8f8
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/RecentsUiFactory.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.uioverrides;
+
+import static foundation.e.blisslauncher.features.test.LauncherState.NORMAL;
+import static foundation.e.blisslauncher.features.test.LauncherState.OVERVIEW;
+import static foundation.e.blisslauncher.quickstep.SysUINavigationMode.Mode.NO_BUTTON;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.view.Gravity;
+import com.android.systemui.shared.system.WindowManagerWrapper;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.LauncherStateManager;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.TouchController;
+import foundation.e.blisslauncher.features.test.UiThreadHelper;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+import foundation.e.blisslauncher.features.test.graphics.RotationMode;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode.Mode;
+import foundation.e.blisslauncher.quickstep.TouchInteractionService;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.uioverrides.touchcontrollers.FlingAndHoldTouchController;
+import foundation.e.blisslauncher.uioverrides.touchcontrollers.NavBarToHomeTouchController;
+import foundation.e.blisslauncher.uioverrides.touchcontrollers.PortraitStatesTouchController;
+import foundation.e.blisslauncher.uioverrides.touchcontrollers.QuickSwitchTouchController;
+import foundation.e.blisslauncher.uioverrides.touchcontrollers.TaskViewTouchController;
+import java.util.ArrayList;
+
+/**
+ * Provides recents-related {@link UiFactory} logic and classes.
+ */
+public abstract class RecentsUiFactory {
+
+    public static final boolean GO_LOW_RAM_RECENTS_ENABLED = false;
+    private static final UiThreadHelper.AsyncCommand SET_SHELF_HEIGHT_CMD = (visible, height) ->
+            WindowManagerWrapper.getInstance().setShelfHeight(visible != 0, height);
+
+    public static RotationMode ROTATION_LANDSCAPE = new RotationMode(-90) {
+        @Override
+        public void mapRect(int left, int top, int right, int bottom, Rect out) {
+            out.left = top;
+            out.top = right;
+            out.right = bottom;
+            out.bottom = left;
+        }
+
+        @Override
+        public void mapInsets(Context context, Rect insets, Rect out) {
+            // If there is a display cutout, the top insets in portrait would also include the
+            // cutout, which we will get as the left inset in landscape. Using the max of left and
+            // top allows us to cover both cases (with or without cutout).
+            if (SysUINavigationMode.getMode(context) == NO_BUTTON) {
+                out.top = Math.max(insets.top, insets.left);
+                out.bottom = Math.max(insets.right, insets.bottom);
+                out.left = out.right = 0;
+            } else {
+                out.top = Math.max(insets.top, insets.left);
+                out.bottom = insets.right;
+                out.left = insets.bottom;
+                out.right = 0;
+            }
+        }
+    };
+
+    public static RotationMode ROTATION_SEASCAPE = new RotationMode(90) {
+        @Override
+        public void mapRect(int left, int top, int right, int bottom, Rect out) {
+            out.left = bottom;
+            out.top = left;
+            out.right = top;
+            out.bottom = right;
+        }
+
+        @Override
+        public void mapInsets(Context context, Rect insets, Rect out) {
+            if (SysUINavigationMode.getMode(context) == NO_BUTTON) {
+                out.top = Math.max(insets.top, insets.right);
+                out.bottom = Math.max(insets.left, insets.bottom);
+                out.left = out.right = 0;
+            } else {
+                out.top = Math.max(insets.top, insets.right);
+                out.bottom = insets.left;
+                out.right = insets.bottom;
+                out.left = 0;
+            }
+        }
+
+        @Override
+        public int toNaturalGravity(int absoluteGravity) {
+            int horizontalGravity = absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK;
+            int verticalGravity = absoluteGravity & Gravity.VERTICAL_GRAVITY_MASK;
+
+            if (horizontalGravity == Gravity.RIGHT) {
+                horizontalGravity = Gravity.LEFT;
+            } else if (horizontalGravity == Gravity.LEFT) {
+                horizontalGravity = Gravity.RIGHT;
+            }
+
+            if (verticalGravity == Gravity.TOP) {
+                verticalGravity = Gravity.BOTTOM;
+            } else if (verticalGravity == Gravity.BOTTOM) {
+                verticalGravity = Gravity.TOP;
+            }
+
+            return ((absoluteGravity & ~Gravity.HORIZONTAL_GRAVITY_MASK)
+                    & ~Gravity.VERTICAL_GRAVITY_MASK)
+                    | horizontalGravity | verticalGravity;
+        }
+    };
+
+    public static RotationMode getRotationMode(VariantDeviceProfile dp) {
+        return RotationMode.NORMAL;
+    }
+
+    public static TouchController[] createTouchControllers(TestActivity launcher) {
+        Mode mode = SysUINavigationMode.getMode(launcher);
+
+        ArrayList<TouchController> list = new ArrayList<>();
+        list.add(launcher.getDragController());
+        if (mode == NO_BUTTON) {
+            list.add(new QuickSwitchTouchController(launcher));
+            list.add(new NavBarToHomeTouchController(launcher));
+            list.add(new FlingAndHoldTouchController(launcher));
+        } else {
+                list.add(new PortraitStatesTouchController(launcher,
+                        mode.hasGestures /* allowDragToOverview */));
+                if (mode.hasGestures) {
+                    list.add(new QuickSwitchTouchController(launcher));
+                }
+        }
+
+        list.add(new LauncherTaskViewController(launcher));
+        return list.toArray(new TouchController[list.size()]);
+    }
+
+    /**
+     * Creates and returns the controller responsible for recents view state transitions.
+     *
+     * @param launcher the launcher activity
+     * @return state handler for recents
+     */
+    public static LauncherStateManager.StateHandler createRecentsViewStateController(TestActivity launcher) {
+        return new RecentsViewStateController(launcher);
+    }
+
+    /**
+     * Clears the swipe shared state for the current swipe gesture.
+     */
+    public static void clearSwipeSharedState(boolean finishAnimation) {
+        TouchInteractionService.getSwipeSharedState().clearAllState(finishAnimation);
+    }
+
+    /**
+     * Recents logic that triggers when launcher state changes or launcher activity stops/resumes.
+     *
+     * @param launcher the launcher activity
+     */
+    public static void onLauncherStateOrResumeChanged(TestActivity launcher) {
+        LauncherState state = launcher.getStateManager().getState();
+        VariantDeviceProfile profile = launcher.getDeviceProfile();
+        boolean visible = (state == NORMAL || state == OVERVIEW) && launcher.isUserActive();
+        UiThreadHelper.runAsyncCommand(launcher, SET_SHELF_HEIGHT_CMD,
+                visible ? 1 : 0, profile.getHotseatBarSizePx());
+
+        if (state == NORMAL) {
+            launcher.<RecentsView>getOverviewPanel().setSwipeDownShouldLaunchApp(false);
+        }
+    }
+
+    private static final class LauncherTaskViewController extends
+        TaskViewTouchController<TestActivity> {
+
+        LauncherTaskViewController(TestActivity activity) {
+            super(activity);
+        }
+
+        @Override
+        protected boolean isRecentsInteractive() {
+            return mActivity.isInState(OVERVIEW);
+        }
+
+        @Override
+        protected void onUserControlledAnimationCreated(AnimatorPlaybackController animController) {
+            mActivity.getStateManager().setCurrentUserControlledAnimation(animController);
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/RecentsViewStateController.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/RecentsViewStateController.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8ec4ed2c421c4e4fb1e0d034a0594f8051c54d2
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/RecentsViewStateController.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.uioverrides;
+
+import static foundation.e.blisslauncher.features.test.LauncherState.RECENTS_CLEAR_ALL_BUTTON;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+
+import android.animation.ValueAnimator;
+import android.annotation.TargetApi;
+import android.os.Build;
+import android.util.FloatProperty;
+import androidx.annotation.NonNull;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.LauncherStateManager;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+import foundation.e.blisslauncher.features.test.anim.PropertySetter;
+import foundation.e.blisslauncher.quickstep.views.ClearAllButton;
+import foundation.e.blisslauncher.quickstep.views.LauncherRecentsView;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+
+/**
+ * State handler for handling UI changes for {@link LauncherRecentsView}. In addition to managing
+ * the basic view properties, this class also manages changes in the task visuals.
+ */
+@TargetApi(Build.VERSION_CODES.O)
+public final class RecentsViewStateController extends
+    BaseRecentsViewStateController<LauncherRecentsView> {
+
+    public RecentsViewStateController(TestActivity launcher) {
+        super(launcher);
+    }
+
+    @Override
+    public void setState(@NonNull LauncherState state) {
+        super.setState(state);
+        if (state.overviewUi) {
+            mRecentsView.updateEmptyMessage();
+            mRecentsView.resetTaskVisuals();
+        }
+        setAlphas(PropertySetter.NO_ANIM_PROPERTY_SETTER, state.getVisibleElements(mLauncher));
+        mRecentsView.setFullscreenProgress(state.getOverviewFullscreenProgress());
+    }
+
+    @Override
+    void setStateWithAnimationInternal(@NonNull final LauncherState toState,
+            @NonNull AnimatorSetBuilder builder, @NonNull LauncherStateManager.AnimationConfig config) {
+        super.setStateWithAnimationInternal(toState, builder, config);
+
+        if (!toState.overviewUi) {
+            builder.addOnFinishRunnable(mRecentsView::resetTaskVisuals);
+        }
+
+        if (toState.overviewUi) {
+            ValueAnimator updateAnim = ValueAnimator.ofFloat(0, 1);
+            updateAnim.addUpdateListener(valueAnimator -> {
+                // While animating into recents, update the visible task data as needed
+                mRecentsView.loadVisibleTaskData();
+            });
+            updateAnim.setDuration(config.duration);
+            builder.play(updateAnim);
+            mRecentsView.updateEmptyMessage();
+        }
+
+        PropertySetter propertySetter = config.getPropertySetter(builder);
+        setAlphas(propertySetter, toState.getVisibleElements(mLauncher));
+        float fullscreenProgress = toState.getOverviewFullscreenProgress();
+        propertySetter.setFloat(mRecentsView, RecentsView.FULLSCREEN_PROGRESS, fullscreenProgress, LINEAR);
+    }
+
+    private void setAlphas(PropertySetter propertySetter, int visibleElements) {
+        boolean hasClearAllButton = (visibleElements & RECENTS_CLEAR_ALL_BUTTON) != 0;
+        propertySetter.setFloat(mRecentsView.getClearAllButton(), ClearAllButton.VISIBILITY_ALPHA,
+                hasClearAllButton ? 1f : 0f, LINEAR);
+    }
+
+    @Override
+    FloatProperty<RecentsView> getContentAlphaProperty() {
+        return RecentsView.CONTENT_ALPHA;
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/states/BackgroundAppState.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/states/BackgroundAppState.java
new file mode 100644
index 0000000000000000000000000000000000000000..f1d58ead8222766b2d550763a4bfd1e819181020
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/states/BackgroundAppState.java
@@ -0,0 +1,90 @@
+/*
+ * 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 foundation.e.blisslauncher.uioverrides.states;
+
+import static foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils.OVERVIEW_TRANSITION_MS;
+
+import foundation.e.blisslauncher.core.customviews.AbstractFloatingView;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.quickstep.util.LayoutUtils;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+
+/**
+ * State indicating that the Launcher is behind an app
+ */
+public class BackgroundAppState extends OverviewState {
+
+    private static final int STATE_FLAGS =
+            FLAG_DISABLE_RESTORE | FLAG_OVERVIEW_UI | FLAG_DISABLE_ACCESSIBILITY
+                    | FLAG_DISABLE_INTERACTION;
+
+    public BackgroundAppState(int id) {
+        super(id, OVERVIEW_TRANSITION_MS, STATE_FLAGS);
+    }
+
+    @Override
+    public void onStateEnabled(TestActivity launcher) {
+        AbstractFloatingView.closeAllOpenViews(launcher, false);
+    }
+
+    @Override
+    public float getVerticalProgress(TestActivity launcher) {
+        /*int transitionLength = LayoutUtils.getShelfTrackingDistance(launcher,
+                launcher.getDeviceProfile());
+        float progressDelta = (transitionLength / scrollRange);
+        return super.getVerticalProgress(launcher) + progressDelta;*/
+        return 1f;
+    }
+
+    @Override
+    public LauncherState.ScaleAndTranslation getOverviewScaleAndTranslation(TestActivity launcher) {
+        // Initialize the recents view scale to what it would be when starting swipe up
+        RecentsView recentsView = launcher.getOverviewPanel();
+        int taskCount = recentsView.getTaskViewCount();
+        if (taskCount == 0) {
+            return super.getOverviewScaleAndTranslation(launcher);
+        }
+        TaskView dummyTask = recentsView.getTaskViewAt(Math.max(taskCount - 1,
+                recentsView.getCurrentPage()));
+        return recentsView.getTempClipAnimationHelper().updateForFullscreenOverview(dummyTask)
+                .getScaleAndTranslation();
+    }
+
+    @Override
+    public float getOverviewFullscreenProgress() {
+        return 1;
+    }
+
+    @Override
+    public int getVisibleElements(TestActivity launcher) {
+        return super.getVisibleElements(launcher)
+                & ~RECENTS_CLEAR_ALL_BUTTON;
+    }
+
+    @Override
+    public ScaleAndTranslation getHotseatScaleAndTranslation(TestActivity launcher) {
+        if ((getVisibleElements(launcher) & HOTSEAT_ICONS) != 0) {
+            // Translate hotseat offscreen if we show it in overview.
+            ScaleAndTranslation scaleAndTranslation = super.getHotseatScaleAndTranslation(launcher);
+            scaleAndTranslation.translationY = LayoutUtils.getShelfTrackingDistance(launcher,
+                    launcher.getDeviceProfile());
+            return scaleAndTranslation;
+        }
+        return super.getHotseatScaleAndTranslation(launcher);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/states/OverviewPeekState.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/states/OverviewPeekState.java
new file mode 100644
index 0000000000000000000000000000000000000000..61d848dfb8b8d7689d7562cdee128a6339cf9108
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/states/OverviewPeekState.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.uioverrides.states;
+
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_FADE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_TRANSLATE_X;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.INSTANT;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.OVERSHOOT_1_7;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+
+public class OverviewPeekState extends OverviewState {
+    public OverviewPeekState(int id) {
+        super(id);
+    }
+
+    @Override
+    public ScaleAndTranslation getOverviewScaleAndTranslation(TestActivity launcher) {
+        ScaleAndTranslation result = super.getOverviewScaleAndTranslation(launcher);
+        result.translationX = NORMAL.getOverviewScaleAndTranslation(launcher).translationX
+                - launcher.getResources().getDimension(R.dimen.overview_peek_distance);
+        return result;
+    }
+
+    @Override
+    public void prepareForAtomicAnimation(TestActivity launcher, LauncherState fromState,
+            AnimatorSetBuilder builder) {
+        if (this == OVERVIEW_PEEK && fromState == NORMAL) {
+            builder.setInterpolator(ANIM_OVERVIEW_FADE, INSTANT);
+            builder.setInterpolator(ANIM_OVERVIEW_TRANSLATE_X, OVERSHOOT_1_7);
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/states/OverviewState.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/states/OverviewState.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a9bd77fa2a739f60caee90a2db3911d590a4bf3
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/states/OverviewState.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.uioverrides.states;
+
+import static android.view.View.VISIBLE;
+import static foundation.e.blisslauncher.features.test.RotationHelper.REQUEST_ROTATE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_FADE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_SCALE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_TRANSLATE_X;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_WORKSPACE_FADE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_WORKSPACE_SCALE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_WORKSPACE_TRANSLATE;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.ACCEL;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.DEACCEL_2;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.OVERSHOOT_1_2;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.OVERSHOOT_1_7;
+import static foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils.OVERVIEW_TRANSITION_MS;
+import static foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils.SCALE_PROPERTY;
+
+import android.graphics.Rect;
+import android.view.View;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.customviews.AbstractFloatingView;
+import foundation.e.blisslauncher.core.customviews.LauncherPagedView;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+
+/**
+ * Definition for overview state
+ */
+public class OverviewState extends LauncherState {
+
+    // Scale recents takes before animating in
+    private static final float RECENTS_PREPARE_SCALE = 1.33f;
+
+    protected static final Rect sTempRect = new Rect();
+
+    private static final int STATE_FLAGS = FLAG_WORKSPACE_ICONS_CAN_BE_DRAGGED
+            | FLAG_DISABLE_RESTORE | FLAG_OVERVIEW_UI | FLAG_DISABLE_ACCESSIBILITY;
+
+    public OverviewState(int id) {
+        this(id, OVERVIEW_TRANSITION_MS, STATE_FLAGS);
+    }
+
+    protected OverviewState(int id, int transitionDuration, int stateFlags) {
+        super(id, transitionDuration, stateFlags);
+    }
+
+    @Override
+    public ScaleAndTranslation getWorkspaceScaleAndTranslation(TestActivity launcher) {
+        RecentsView recentsView = launcher.getOverviewPanel();
+        LauncherPagedView workspace = launcher.getLauncherPagedView();
+        View workspacePage = workspace.getPageAt(workspace.getCurrentPage());
+        float workspacePageWidth = workspacePage != null && workspacePage.getWidth() != 0
+                ? workspacePage.getWidth() : launcher.getDeviceProfile().getAvailableWidthPx();
+        recentsView.getTaskSize(sTempRect);
+        float scale = (float) sTempRect.width() / workspacePageWidth;
+        float parallaxFactor = 0.5f;
+        return new ScaleAndTranslation(scale, 0, -getDefaultSwipeHeight(launcher) * parallaxFactor);
+    }
+
+    @Override
+    public ScaleAndTranslation getHotseatScaleAndTranslation(TestActivity launcher) {
+        if ((getVisibleElements(launcher) & HOTSEAT_ICONS) != 0) {
+            // If the hotseat icons are visible in overview, keep them in their normal position.
+            return super.getWorkspaceScaleAndTranslation(launcher);
+        }
+        return getWorkspaceScaleAndTranslation(launcher);
+    }
+
+    @Override
+    public ScaleAndTranslation getOverviewScaleAndTranslation(TestActivity launcher) {
+        return new ScaleAndTranslation(1f, 0f, 0f);
+    }
+
+    @Override
+    public void onStateEnabled(TestActivity launcher) {
+        AbstractFloatingView.closeAllOpenViews(launcher);
+    }
+
+    @Override
+    public void onStateTransitionEnd(TestActivity launcher) {
+        launcher.getRotationHelper().setCurrentStateRequest(REQUEST_ROTATE);
+    }
+
+    @Override
+    public PageAlphaProvider getWorkspacePageAlphaProvider(TestActivity launcher) {
+        return new PageAlphaProvider(DEACCEL_2) {
+            @Override
+            public float getPageAlpha(int pageIndex) {
+                return 0;
+            }
+        };
+    }
+
+    @Override
+    public int getVisibleElements(TestActivity launcher) {
+            return HOTSEAT_ICONS;
+    }
+
+    @Override
+    public float getWorkspaceScrimAlpha(TestActivity launcher) {
+        return 0.5f;
+    }
+
+    @Override
+    public float getVerticalProgress(TestActivity launcher) {
+        return 1f;
+    }
+
+    public static float getDefaultVerticalProgress(TestActivity launcher) {
+        return 1f;
+    }
+
+    @Override
+    public String getDescription(TestActivity launcher) {
+        return launcher.getString(R.string.accessibility_desc_recent_apps);
+    }
+
+    public static float getDefaultSwipeHeight(TestActivity launcher) {
+        return getDefaultSwipeHeight(launcher.getDeviceProfile());
+    }
+
+    public static float getDefaultSwipeHeight(VariantDeviceProfile dp) {
+        return 0f;
+    }
+
+    @Override
+    public void onBackPressed(TestActivity launcher) {
+        TaskView taskView = launcher.<RecentsView>getOverviewPanel().getRunningTaskView();
+        if (taskView != null) {
+            taskView.launchTask(true);
+        } else {
+            super.onBackPressed(launcher);
+        }
+    }
+
+    @Override
+    public void prepareForAtomicAnimation(TestActivity launcher, LauncherState fromState,
+            AnimatorSetBuilder builder) {
+        if (fromState == NORMAL && this == OVERVIEW) {
+            if (SysUINavigationMode.getMode(launcher) == SysUINavigationMode.Mode.NO_BUTTON) {
+                builder.setInterpolator(ANIM_WORKSPACE_SCALE, ACCEL);
+                builder.setInterpolator(ANIM_WORKSPACE_TRANSLATE, ACCEL);
+            } else {
+                builder.setInterpolator(ANIM_WORKSPACE_SCALE, OVERSHOOT_1_2);
+
+                // Scale up the recents, if it is not coming from the side
+                RecentsView overview = launcher.getOverviewPanel();
+                if (overview.getVisibility() != VISIBLE || overview.getContentAlpha() == 0) {
+                    SCALE_PROPERTY.set(overview, RECENTS_PREPARE_SCALE);
+                }
+            }
+            builder.setInterpolator(ANIM_WORKSPACE_FADE, OVERSHOOT_1_2);
+            builder.setInterpolator(ANIM_OVERVIEW_SCALE, OVERSHOOT_1_2);
+            builder.setInterpolator(ANIM_OVERVIEW_TRANSLATE_X, OVERSHOOT_1_7);
+            builder.setInterpolator(ANIM_OVERVIEW_FADE, OVERSHOOT_1_2);
+        }
+    }
+
+    public static OverviewState newBackgroundState(int id) {
+        return new BackgroundAppState(id);
+    }
+
+    public static OverviewState newPeekState(int id) {
+        return new OverviewPeekState(id);
+    }
+
+    public static OverviewState newSwitchState(int id) {
+        return new QuickSwitchState(id);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/states/QuickSwitchState.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/states/QuickSwitchState.java
new file mode 100644
index 0000000000000000000000000000000000000000..b5bf3cbce5966b0ef57b01fce9e529606d3b8d5b
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/states/QuickSwitchState.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.uioverrides.states;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.quickstep.WindowTransformSwipeHandler;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+
+/**
+ * State to indicate we are about to launch a recent task. Note that this state is only used when
+ * quick switching from launcher; quick switching from an app uses WindowTransformSwipeHelper.
+ * @see WindowTransformSwipeHandler.GestureEndTarget#NEW_TASK
+ */
+public class QuickSwitchState extends BackgroundAppState {
+
+    private static final String TAG = "QuickSwitchState";
+
+    public QuickSwitchState(int id) {
+        super(id);
+    }
+
+    @Override
+    public ScaleAndTranslation getWorkspaceScaleAndTranslation(TestActivity launcher) {
+        // TODO: May need to fix it.
+        return new ScaleAndTranslation(1, 0, 0);
+    }
+
+    @Override
+    public int getVisibleElements(TestActivity launcher) {
+        return NONE;
+    }
+
+    @Override
+    public void onStateTransitionEnd(TestActivity launcher) {
+        TaskView tasktolaunch = launcher.<RecentsView>getOverviewPanel().getTaskViewAt(0);
+        if (tasktolaunch != null) {
+            tasktolaunch.launchTask(false, success -> {
+                if (!success) {
+                    launcher.getStateManager().goToState(OVERVIEW);
+                    tasktolaunch.notifyTaskLaunchFailed(TAG);
+                } else {
+                    launcher.getStateManager().moveToRestState();
+                }
+            }, new Handler(Looper.getMainLooper()));
+        } else {
+            launcher.getStateManager().goToState(NORMAL);
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/FlingAndHoldTouchController.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/FlingAndHoldTouchController.java
new file mode 100644
index 0000000000000000000000000000000000000000..025c546b5efb1d16b2eb2e6dc6e346b4c2c96581
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/FlingAndHoldTouchController.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.uioverrides.touchcontrollers;
+
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_OVERVIEW_DISABLED;
+import static foundation.e.blisslauncher.features.test.LauncherState.HOTSEAT_ICONS;
+import static foundation.e.blisslauncher.features.test.LauncherState.NORMAL;
+import static foundation.e.blisslauncher.features.test.LauncherState.OVERVIEW;
+import static foundation.e.blisslauncher.features.test.LauncherState.OVERVIEW_PEEK;
+import static foundation.e.blisslauncher.features.test.LauncherStateManager.ANIM_ALL;
+import static foundation.e.blisslauncher.features.test.LauncherStateManager.ATOMIC_OVERVIEW_PEEK_COMPONENT;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_HOTSEAT_SCALE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_HOTSEAT_TRANSLATE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_VERTICAL_PROGRESS;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.OVERSHOOT_1_2;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.view.HapticFeedbackConstants;
+import android.view.MotionEvent;
+import android.view.ViewConfiguration;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+import foundation.e.blisslauncher.quickstep.OverviewInteractionState;
+import foundation.e.blisslauncher.quickstep.util.MotionPauseDetector;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+
+/**
+ * Touch controller which handles swipe and hold to go to Overview
+ */
+public class FlingAndHoldTouchController extends PortraitStatesTouchController {
+
+    private static final long PEEK_IN_ANIM_DURATION = 240;
+    private static final long PEEK_OUT_ANIM_DURATION = 100;
+    private static final float MAX_DISPLACEMENT_PERCENT = 0.75f;
+
+    private final MotionPauseDetector mMotionPauseDetector;
+    private final float mMotionPauseMinDisplacement;
+    private final float mMotionPauseMaxDisplacement;
+
+    private AnimatorSet mPeekAnim;
+
+    public FlingAndHoldTouchController(TestActivity l) {
+        super(l, false /* allowDragToOverview */);
+        mMotionPauseDetector = new MotionPauseDetector(l);
+        mMotionPauseMinDisplacement = ViewConfiguration.get(l).getScaledTouchSlop();
+        mMotionPauseMaxDisplacement = getShiftRange() * MAX_DISPLACEMENT_PERCENT;
+    }
+
+    @Override
+    protected long getAtomicDuration() {
+        return 300;
+    }
+
+    @Override
+    public void onDragStart(boolean start) {
+        mMotionPauseDetector.clear();
+
+        super.onDragStart(start);
+
+        if (handlingOverviewAnim()) {
+            mMotionPauseDetector.setOnMotionPauseListener(isPaused -> {
+                RecentsView recentsView = mLauncher.getOverviewPanel();
+                recentsView.setOverviewStateEnabled(isPaused);
+                if (mPeekAnim != null) {
+                    mPeekAnim.cancel();
+                }
+                LauncherState fromState = isPaused ? NORMAL : OVERVIEW_PEEK;
+                LauncherState toState = isPaused ? OVERVIEW_PEEK : NORMAL;
+                long peekDuration = isPaused ? PEEK_IN_ANIM_DURATION : PEEK_OUT_ANIM_DURATION;
+                mPeekAnim = mLauncher.getStateManager().createAtomicAnimation(fromState, toState,
+                        new AnimatorSetBuilder(), ATOMIC_OVERVIEW_PEEK_COMPONENT, peekDuration);
+                mPeekAnim.addListener(new AnimatorListenerAdapter() {
+                    @Override
+                    public void onAnimationEnd(Animator animation) {
+                        mPeekAnim = null;
+                    }
+                });
+                mPeekAnim.start();
+                recentsView.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY,
+                        HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
+            });
+        }
+    }
+
+    /**
+     * @return Whether we are handling the overview animation, rather than
+     * having it as part of the existing animation to the target state.
+     */
+    private boolean handlingOverviewAnim() {
+        int stateFlags = OverviewInteractionState.INSTANCE.get(mLauncher).getSystemUiStateFlags();
+        return mStartState == NORMAL && (stateFlags & SYSUI_STATE_OVERVIEW_DISABLED) == 0;
+    }
+
+    @Override
+    protected AnimatorSetBuilder getAnimatorSetBuilderForStates(LauncherState fromState,
+            LauncherState toState) {
+        return super.getAnimatorSetBuilderForStates(fromState, toState);
+    }
+
+    @Override
+    public boolean onDrag(float displacement, MotionEvent event) {
+        float upDisplacement = -displacement;
+        mMotionPauseDetector.setDisallowPause(upDisplacement < mMotionPauseMinDisplacement
+                || upDisplacement > mMotionPauseMaxDisplacement);
+        mMotionPauseDetector.addPosition(displacement, event.getEventTime());
+        return super.onDrag(displacement, event);
+    }
+
+    @Override
+    public void onDragEnd(float velocity, boolean fling) {
+        if (mMotionPauseDetector.isPaused() && handlingOverviewAnim()) {
+            if (mPeekAnim != null) {
+                mPeekAnim.cancel();
+            }
+
+            AnimatorSetBuilder builder = new AnimatorSetBuilder();
+            builder.setInterpolator(ANIM_VERTICAL_PROGRESS, OVERSHOOT_1_2);
+            if ((OVERVIEW.getVisibleElements(mLauncher) & HOTSEAT_ICONS) != 0) {
+                builder.setInterpolator(ANIM_HOTSEAT_SCALE, OVERSHOOT_1_2);
+                builder.setInterpolator(ANIM_HOTSEAT_TRANSLATE, OVERSHOOT_1_2);
+            }
+            AnimatorSet overviewAnim = mLauncher.getStateManager().createAtomicAnimation(
+                    NORMAL, OVERVIEW, builder, ANIM_ALL, ATOMIC_DURATION);
+            overviewAnim.addListener(new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    onSwipeInteractionCompleted(OVERVIEW);
+                }
+            });
+            overviewAnim.start();
+        } else {
+            super.onDragEnd(velocity, fling);
+        }
+        mMotionPauseDetector.clear();
+    }
+
+    @Override
+    protected void updateAnimatorBuilderOnReinit(AnimatorSetBuilder builder) {
+        if (handlingOverviewAnim()) {
+            // We don't want the state transition to all apps to animate overview,
+            // as that will cause a jump after our atomic animation.
+            builder.addFlag(AnimatorSetBuilder.FLAG_DONT_ANIMATE_OVERVIEW);
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/NavBarToHomeTouchController.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/NavBarToHomeTouchController.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d21d6770ffdf5fcdbfa5cce3fac125b2bcbaf57
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/NavBarToHomeTouchController.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.uioverrides.touchcontrollers;
+
+import static android.view.View.TRANSLATION_X;
+import static foundation.e.blisslauncher.features.test.LauncherState.NORMAL;
+import static foundation.e.blisslauncher.features.test.LauncherState.OVERVIEW;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.DEACCEL_3;
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.animation.ValueAnimator;
+import android.view.MotionEvent;
+import android.view.animation.Interpolator;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.customviews.AbstractFloatingView;
+import foundation.e.blisslauncher.core.touch.AbstractStateChangeTouchController;
+import foundation.e.blisslauncher.core.touch.SwipeDetector;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.TouchController;
+import foundation.e.blisslauncher.features.test.anim.AnimationSuccessListener;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+
+/**
+ * Handles swiping up on the nav bar to go home from launcher, e.g. overview or all apps.
+ */
+public class NavBarToHomeTouchController implements TouchController, SwipeDetector.Listener {
+
+    private static final Interpolator PULLBACK_INTERPOLATOR = DEACCEL_3;
+
+    private final TestActivity mLauncher;
+    private final SwipeDetector mSwipeDetector;
+    private final float mPullbackDistance;
+
+    private boolean mNoIntercept;
+    private LauncherState mStartState;
+    private LauncherState mEndState = NORMAL;
+    private AnimatorPlaybackController mCurrentAnimation;
+
+    public NavBarToHomeTouchController(TestActivity launcher) {
+        mLauncher = launcher;
+        mSwipeDetector = new SwipeDetector(mLauncher, this, SwipeDetector.VERTICAL);
+        mPullbackDistance = mLauncher.getResources().getDimension(R.dimen.home_pullback_distance);
+    }
+
+    @Override
+    public final boolean onControllerInterceptTouchEvent(MotionEvent ev) {
+        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
+            mStartState = mLauncher.getStateManager().getState();
+            mNoIntercept = !canInterceptTouch(ev);
+            if (mNoIntercept) {
+                return false;
+            }
+            mSwipeDetector.setDetectableScrollConditions(SwipeDetector.DIRECTION_POSITIVE, false);
+        }
+
+        if (mNoIntercept) {
+            return false;
+        }
+
+        onControllerTouchEvent(ev);
+        return mSwipeDetector.isDraggingOrSettling();
+    }
+
+    private boolean canInterceptTouch(MotionEvent ev) {
+        boolean cameFromNavBar = (ev.getEdgeFlags() & Utilities.EDGE_NAV_BAR) != 0;
+        if (!cameFromNavBar) {
+            return false;
+        }
+        if (mStartState == OVERVIEW) {
+            return true;
+        }
+        if (AbstractFloatingView.getTopOpenView(mLauncher) != null) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public final boolean onControllerTouchEvent(MotionEvent ev) {
+        return mSwipeDetector.onTouchEvent(ev);
+    }
+
+    private float getShiftRange() {
+        return mLauncher.getDeviceProfile().getHeightPx();
+    }
+
+    @Override
+    public void onDragStart(boolean start) {
+        initCurrentAnimation();
+    }
+
+    private void initCurrentAnimation() {
+        long accuracy = (long) (getShiftRange() * 2);
+        final AnimatorSet anim = new AnimatorSet();
+        if (mStartState == OVERVIEW) {
+            RecentsView recentsView = mLauncher.getOverviewPanel();
+            float pullbackDist = mPullbackDistance;
+            if (!recentsView.isRtl()) {
+                pullbackDist = -pullbackDist;
+            }
+            Animator pullback = ObjectAnimator.ofFloat(recentsView, TRANSLATION_X, pullbackDist);
+            pullback.setInterpolator(PULLBACK_INTERPOLATOR);
+            anim.play(pullback);
+        }
+        AbstractFloatingView topView = AbstractFloatingView.getTopOpenView(mLauncher);
+        anim.setDuration(accuracy);
+        mCurrentAnimation = AnimatorPlaybackController.wrap(anim, accuracy, this::clearState);
+    }
+
+    private void clearState() {
+        mCurrentAnimation = null;
+        mSwipeDetector.finishedScrolling();
+        mSwipeDetector.setDetectableScrollConditions(0, false);
+    }
+
+    @Override
+    public boolean onDrag(float displacement) {
+        // Only allow swipe up.
+        displacement = Math.min(0, displacement);
+        float progress = Utilities.getProgress(displacement, 0, getShiftRange());
+        mCurrentAnimation.setPlayFraction(progress);
+        return true;
+    }
+
+    @Override
+    public void onDragEnd(float velocity, boolean fling) {
+        float progress = mCurrentAnimation.getProgressFraction();
+        float interpolatedProgress = PULLBACK_INTERPOLATOR.getInterpolation(progress);
+        boolean success = interpolatedProgress >= AbstractStateChangeTouchController.SUCCESS_TRANSITION_PROGRESS
+                || (velocity < 0 && fling);
+        if (success) {
+            mLauncher.getStateManager().goToState(mEndState, true,
+                    () -> onSwipeInteractionCompleted(mEndState));
+            AbstractFloatingView topOpenView = AbstractFloatingView.getTopOpenView(mLauncher);
+            if (topOpenView != null) {
+                AbstractFloatingView.closeAllOpenViews(mLauncher);
+            }
+        } else {
+            // Quickly return to the state we came from (we didn't move far).
+            ValueAnimator anim = mCurrentAnimation.getAnimationPlayer();
+            anim.setFloatValues(progress, 0);
+            anim.addListener(new AnimationSuccessListener() {
+                @Override
+                public void onAnimationSuccess(Animator animator) {
+                    onSwipeInteractionCompleted(mStartState);
+                }
+            });
+            anim.setDuration(80).start();
+        }
+    }
+
+    private void onSwipeInteractionCompleted(LauncherState targetState) {
+        clearState();
+        mLauncher.getStateManager().goToState(targetState, false /* animated */);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/PortraitOverviewStateTouchHelper.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/PortraitOverviewStateTouchHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c6c3b4b2d9514a83fe9c538e89134c1c6b003ea
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/PortraitOverviewStateTouchHelper.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.uioverrides.touchcontrollers;
+
+import static foundation.e.blisslauncher.uioverrides.touchcontrollers.PortraitStatesTouchController.isTouchOverHotseat;
+
+import android.view.MotionEvent;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.anim.PendingAnimation;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+
+/**
+ * Helper class for {@link PortraitStatesTouchController} that determines swipeable regions and
+ * animations on the overview state that depend on the recents implementation.
+ */
+public final class PortraitOverviewStateTouchHelper {
+
+    RecentsView mRecentsView;
+    TestActivity mLauncher;
+
+    public PortraitOverviewStateTouchHelper(TestActivity launcher) {
+        mLauncher = launcher;
+        mRecentsView = launcher.getOverviewPanel();
+    }
+
+    /**
+     * Whether or not {@link PortraitStatesTouchController} should intercept the touch when on the
+     * overview state.
+     *
+     * @param ev the motion event
+     * @return true if we should intercept the motion event
+     */
+    boolean canInterceptTouch(MotionEvent ev) {
+        if (mRecentsView.getChildCount() > 0) {
+            // Allow swiping up in the gap between the hotseat and overview.
+            return ev.getY() >= mRecentsView.getChildAt(0).getBottom();
+        } else {
+            // If there are no tasks, we only intercept if we're below the hotseat height.
+            return isTouchOverHotseat(mLauncher, ev);
+        }
+    }
+
+    /**
+     * Whether or not swiping down to leave overview state should return to the currently running
+     * task app.
+     *
+     * @return true if going back should take the user to the currently running task
+     */
+    boolean shouldSwipeDownReturnToApp() {
+        TaskView taskView = mRecentsView.getTaskViewAt(mRecentsView.getNextPage());
+        return taskView != null && mRecentsView.shouldSwipeDownLaunchApp();
+    }
+
+    /**
+     * Create the animation for going from overview to the task app via swiping. Should only be
+     * called when {@link #shouldSwipeDownReturnToApp()} returns true.
+     *
+     * @param duration how long the animation should be
+     * @return the animation
+     */
+    PendingAnimation createSwipeDownToTaskAppAnimation(long duration) {
+        mRecentsView.setCurrentPage(mRecentsView.getPageNearestToCenterOfScreen());
+        TaskView taskView = mRecentsView.getTaskViewAt(mRecentsView.getCurrentPage());
+        if (taskView == null) {
+            throw new IllegalStateException("There is no task view to animate to.");
+        }
+        return mRecentsView.createTaskLauncherAnimation(taskView, duration);
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/QuickSwitchTouchController.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/QuickSwitchTouchController.java
new file mode 100644
index 0000000000000000000000000000000000000000..f093523525ce8e5d4fd9cd869e8a0d020ad8e653
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/QuickSwitchTouchController.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.uioverrides.touchcontrollers;
+
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_OVERVIEW_DISABLED;
+import static foundation.e.blisslauncher.features.test.LauncherState.NORMAL;
+import static foundation.e.blisslauncher.features.test.LauncherState.QUICK_SWITCH;
+import static foundation.e.blisslauncher.features.test.SystemUiController.UI_STATE_OVERVIEW;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_FADE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_SCALE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_TRANSLATE_Y;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_VERTICAL_PROGRESS;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_WORKSPACE_FADE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_WORKSPACE_TRANSLATE;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.ACCEL_2;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.DEACCEL_2;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.INSTANT;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+
+import android.view.MotionEvent;
+import androidx.annotation.Nullable;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.touch.AbstractStateChangeTouchController;
+import foundation.e.blisslauncher.core.touch.SwipeDetector;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.LauncherStateManager;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+import foundation.e.blisslauncher.quickstep.OverviewInteractionState;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode.Mode;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+
+/**
+ * Handles quick switching to a recent task from the home screen.
+ */
+public class QuickSwitchTouchController extends AbstractStateChangeTouchController {
+
+    private @Nullable
+    TaskView mTaskToLaunch;
+
+    public QuickSwitchTouchController(TestActivity launcher) {
+        this(launcher, SwipeDetector.HORIZONTAL);
+    }
+
+    protected QuickSwitchTouchController(TestActivity l, SwipeDetector.Direction dir) {
+        super(l, dir);
+    }
+
+    @Override
+    protected boolean canInterceptTouch(MotionEvent ev) {
+        if (mCurrentAnimation != null) {
+            return true;
+        }
+        if (!mLauncher.isInState(NORMAL)) {
+            return false;
+        }
+        if ((ev.getEdgeFlags() & Utilities.EDGE_NAV_BAR) == 0) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    protected LauncherState getTargetState(LauncherState fromState, boolean isDragTowardPositive) {
+        int stateFlags = OverviewInteractionState.INSTANCE.get(mLauncher).getSystemUiStateFlags();
+        if ((stateFlags & SYSUI_STATE_OVERVIEW_DISABLED) != 0) {
+            return NORMAL;
+        }
+        return isDragTowardPositive ? QUICK_SWITCH : NORMAL;
+    }
+
+    @Override
+    public void onDragStart(boolean start) {
+        super.onDragStart(start);
+        mTaskToLaunch = mLauncher.<RecentsView>getOverviewPanel().getTaskViewAt(0);
+    }
+
+    @Override
+    protected void onSwipeInteractionCompleted(LauncherState targetState) {
+        super.onSwipeInteractionCompleted(targetState);
+        mTaskToLaunch = null;
+    }
+
+    @Override
+    protected float initCurrentAnimation(int animComponents) {
+        AnimatorSetBuilder animatorSetBuilder = new AnimatorSetBuilder();
+        setupInterpolators(animatorSetBuilder);
+        long accuracy = (long) (getShiftRange() * 2);
+        mCurrentAnimation = mLauncher.getStateManager().createAnimationToNewWorkspace(mToState,
+                animatorSetBuilder, accuracy, this::clearState, LauncherStateManager.ANIM_ALL);
+        mCurrentAnimation.getAnimationPlayer().addUpdateListener(valueAnimator -> {
+            updateFullscreenProgress((Float) valueAnimator.getAnimatedValue());
+        });
+        return 1 / getShiftRange();
+    }
+
+    private void setupInterpolators(AnimatorSetBuilder animatorSetBuilder) {
+        animatorSetBuilder.setInterpolator(ANIM_WORKSPACE_FADE, DEACCEL_2);
+        if (SysUINavigationMode.getMode(mLauncher) == Mode.NO_BUTTON) {
+            // Overview lives to the left of workspace, so translate down later than over
+            animatorSetBuilder.setInterpolator(ANIM_WORKSPACE_TRANSLATE, ACCEL_2);
+            animatorSetBuilder.setInterpolator(ANIM_VERTICAL_PROGRESS, ACCEL_2);
+            animatorSetBuilder.setInterpolator(ANIM_OVERVIEW_SCALE, ACCEL_2);
+            animatorSetBuilder.setInterpolator(ANIM_OVERVIEW_TRANSLATE_Y, ACCEL_2);
+            animatorSetBuilder.setInterpolator(ANIM_OVERVIEW_FADE, INSTANT);
+        } else {
+            animatorSetBuilder.setInterpolator(ANIM_WORKSPACE_TRANSLATE, LINEAR);
+            animatorSetBuilder.setInterpolator(ANIM_VERTICAL_PROGRESS, LINEAR);
+        }
+    }
+
+    @Override
+    protected void updateProgress(float progress) {
+        super.updateProgress(progress);
+        updateFullscreenProgress(Utilities.boundToRange(progress, 0, 1));
+    }
+
+    private void updateFullscreenProgress(float progress) {
+        if (mTaskToLaunch != null) {
+            mTaskToLaunch.setFullscreenProgress(progress);
+            int sysuiFlags = progress > RecentsView.UPDATE_SYSUI_FLAGS_THRESHOLD
+                    ? mTaskToLaunch.getThumbnail().getSysUiStatusNavFlags()
+                    : 0;
+            mLauncher.getSystemUiController().updateUiState(UI_STATE_OVERVIEW, sysuiFlags);
+        }
+    }
+
+    @Override
+    protected float getShiftRange() {
+        return mLauncher.getDeviceProfile().getWidthPx() / 2f;
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/TaskViewTouchController.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/TaskViewTouchController.java
new file mode 100644
index 0000000000000000000000000000000000000000..eafeb15e3c143788f3d35d552997e80b17f7877d
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/TaskViewTouchController.java
@@ -0,0 +1,305 @@
+/*
+ * 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 foundation.e.blisslauncher.uioverrides.touchcontrollers;
+
+import static foundation.e.blisslauncher.core.Flags.ENABLE_QUICKSTEP_LIVE_TILE;
+import static foundation.e.blisslauncher.core.Flags.QUICKSTEP_SPRINGS;
+import static foundation.e.blisslauncher.core.Utilities.SINGLE_FRAME_MS;
+import static foundation.e.blisslauncher.core.customviews.AbstractFloatingView.TYPE_ACCESSIBLE;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.scrollInterpolatorForVelocity;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.view.MotionEvent;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.customviews.AbstractFloatingView;
+import foundation.e.blisslauncher.core.touch.SwipeDetector;
+import foundation.e.blisslauncher.core.utils.FlingBlockCheck;
+import foundation.e.blisslauncher.features.test.BaseDragLayer;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.features.test.TouchController;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+import foundation.e.blisslauncher.features.test.anim.Interpolators;
+import foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils;
+import foundation.e.blisslauncher.features.test.anim.PendingAnimation;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode;
+import foundation.e.blisslauncher.quickstep.views.RecentsView;
+import foundation.e.blisslauncher.quickstep.views.TaskView;
+
+/**
+ * Touch controller for handling task view card swipes
+ */
+public abstract class TaskViewTouchController<T extends BaseDraggingActivity>
+        extends AnimatorListenerAdapter implements TouchController, SwipeDetector.Listener {
+
+    private static final String TAG = "OverviewSwipeController";
+
+    // Progress after which the transition is assumed to be a success in case user does not fling
+    public static final float SUCCESS_TRANSITION_PROGRESS = 0.5f;
+
+    protected final T mActivity;
+    private final SwipeDetector mDetector;
+    private final RecentsView mRecentsView;
+    private final int[] mTempCords = new int[2];
+
+    private PendingAnimation mPendingAnimation;
+    private AnimatorPlaybackController mCurrentAnimation;
+    private boolean mCurrentAnimationIsGoingUp;
+
+    private boolean mNoIntercept;
+
+    private float mDisplacementShift;
+    private float mProgressMultiplier;
+    private float mEndDisplacement;
+    private FlingBlockCheck mFlingBlockCheck = new FlingBlockCheck();
+
+    private TaskView mTaskBeingDragged;
+
+    public TaskViewTouchController(T activity) {
+        mActivity = activity;
+        mRecentsView = activity.getOverviewPanel();
+        mDetector = new SwipeDetector(activity, this, SwipeDetector.VERTICAL);
+    }
+
+    private boolean canInterceptTouch() {
+        if (mCurrentAnimation != null) {
+            // If we are already animating from a previous state, we can intercept.
+            return true;
+        }
+        if (AbstractFloatingView.getTopOpenViewWithType(mActivity, TYPE_ACCESSIBLE) != null) {
+            return false;
+        }
+        return isRecentsInteractive();
+    }
+
+    protected abstract boolean isRecentsInteractive();
+
+    protected void onUserControlledAnimationCreated(AnimatorPlaybackController animController) {
+    }
+
+    @Override
+    public void onAnimationCancel(Animator animation) {
+        if (mCurrentAnimation != null && animation == mCurrentAnimation.getTarget()) {
+            clearState();
+        }
+    }
+
+    @Override
+    public boolean onControllerInterceptTouchEvent(MotionEvent ev) {
+        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
+            mNoIntercept = !canInterceptTouch();
+            if (mNoIntercept) {
+                return false;
+            }
+
+            // Now figure out which direction scroll events the controller will start
+            // calling the callbacks.
+            int directionsToDetectScroll = 0;
+            boolean ignoreSlopWhenSettling = false;
+            if (mCurrentAnimation != null) {
+                directionsToDetectScroll = SwipeDetector.DIRECTION_BOTH;
+                ignoreSlopWhenSettling = true;
+            } else {
+                mTaskBeingDragged = null;
+
+                for (int i = 0; i < mRecentsView.getTaskViewCount(); i++) {
+                    TaskView view = mRecentsView.getTaskViewAt(i);
+                    if (mRecentsView.isTaskViewVisible(view) && mActivity.getDragLayer()
+                            .isEventOverView(view, ev)) {
+                        mTaskBeingDragged = view;
+                        if (!SysUINavigationMode.getMode(mActivity).hasGestures) {
+                            // Don't allow swipe down to open if we don't support swipe up
+                            // to enter overview.
+                            directionsToDetectScroll = SwipeDetector.DIRECTION_POSITIVE;
+                        } else {
+                            // The task can be dragged up to dismiss it,
+                            // and down to open if it's the current page.
+                            directionsToDetectScroll = i == mRecentsView.getCurrentPage()
+                                    ? SwipeDetector.DIRECTION_BOTH : SwipeDetector.DIRECTION_POSITIVE;
+                        }
+                        break;
+                    }
+                }
+                if (mTaskBeingDragged == null) {
+                    mNoIntercept = true;
+                    return false;
+                }
+            }
+
+            mDetector.setDetectableScrollConditions(
+                    directionsToDetectScroll, ignoreSlopWhenSettling);
+        }
+
+        if (mNoIntercept) {
+            return false;
+        }
+
+        onControllerTouchEvent(ev);
+        return mDetector.isDraggingOrSettling();
+    }
+
+    @Override
+    public boolean onControllerTouchEvent(MotionEvent ev) {
+        return mDetector.onTouchEvent(ev);
+    }
+
+    private void reInitAnimationController(boolean goingUp) {
+        if (mCurrentAnimation != null && mCurrentAnimationIsGoingUp == goingUp) {
+            // No need to init
+            return;
+        }
+        int scrollDirections = mDetector.getScrollDirections();
+        if (goingUp && ((scrollDirections & SwipeDetector.DIRECTION_POSITIVE) == 0)
+                || !goingUp && ((scrollDirections & SwipeDetector.DIRECTION_NEGATIVE) == 0)) {
+            // Trying to re-init in an unsupported direction.
+            return;
+        }
+        if (mCurrentAnimation != null) {
+            mCurrentAnimation.setPlayFraction(0);
+        }
+        if (mPendingAnimation != null) {
+            mPendingAnimation.finish(false);
+            mPendingAnimation = null;
+        }
+
+        mCurrentAnimationIsGoingUp = goingUp;
+        BaseDragLayer dl = mActivity.getDragLayer();
+        long maxDuration = (long) (2 * dl.getHeight());
+
+        if (goingUp) {
+            mPendingAnimation = mRecentsView.createTaskDismissAnimation(mTaskBeingDragged,
+                    true /* animateTaskView */, true /* removeTask */, maxDuration);
+
+            mEndDisplacement = -mTaskBeingDragged.getHeight();
+        } else {
+            mPendingAnimation = mRecentsView.createTaskLauncherAnimation(
+                    mTaskBeingDragged, maxDuration);
+            mPendingAnimation.anim.setInterpolator(Interpolators.ZOOM_IN);
+
+            mTempCords[1] = mTaskBeingDragged.getHeight();
+            dl.getDescendantCoordRelativeToSelf(mTaskBeingDragged, mTempCords);
+            mEndDisplacement = dl.getHeight() - mTempCords[1];
+        }
+
+        if (mCurrentAnimation != null) {
+            mCurrentAnimation.setOnCancelRunnable(null);
+        }
+        mCurrentAnimation = AnimatorPlaybackController
+                .wrap(mPendingAnimation.anim, maxDuration, this::clearState);
+        onUserControlledAnimationCreated(mCurrentAnimation);
+        mCurrentAnimation.getTarget().addListener(this);
+        mCurrentAnimation.dispatchOnStart();
+        mProgressMultiplier = 1 / mEndDisplacement;
+    }
+
+    @Override
+    public void onDragStart(boolean start) {
+        if (mCurrentAnimation == null) {
+            reInitAnimationController(mDetector.wasInitialTouchPositive());
+            mDisplacementShift = 0;
+        } else {
+            mDisplacementShift = mCurrentAnimation.getProgressFraction() / mProgressMultiplier;
+            mCurrentAnimation.pause();
+        }
+        mFlingBlockCheck.unblockFling();
+    }
+
+    @Override
+    public boolean onDrag(float displacement) {
+        float totalDisplacement = displacement + mDisplacementShift;
+        boolean isGoingUp =
+                totalDisplacement == 0 ? mCurrentAnimationIsGoingUp : totalDisplacement < 0;
+        if (isGoingUp != mCurrentAnimationIsGoingUp) {
+            reInitAnimationController(isGoingUp);
+            mFlingBlockCheck.blockFling();
+        } else {
+            mFlingBlockCheck.onEvent();
+        }
+        mCurrentAnimation.setPlayFraction(Utilities.boundToRange(
+                totalDisplacement * mProgressMultiplier, 0, 1));
+
+        if (ENABLE_QUICKSTEP_LIVE_TILE) {
+            if (mRecentsView.getCurrentPage() != 0 || isGoingUp) {
+                mRecentsView.redrawLiveTile(true);
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public void onDragEnd(float velocity, boolean fling) {
+        final boolean goingToEnd;
+        final int logAction;
+        boolean blockedFling = fling && mFlingBlockCheck.isBlocked();
+        if (blockedFling) {
+            fling = false;
+        }
+        float progress = mCurrentAnimation.getProgressFraction();
+        float interpolatedProgress = mCurrentAnimation.getInterpolatedProgress();
+        if (fling) {
+            boolean goingUp = velocity < 0;
+            goingToEnd = goingUp == mCurrentAnimationIsGoingUp;
+        } else {
+            goingToEnd = interpolatedProgress > SUCCESS_TRANSITION_PROGRESS;
+        }
+        long animationDuration = SwipeDetector.calculateDuration(
+                velocity, goingToEnd ? (1 - progress) : progress);
+        if (blockedFling && !goingToEnd) {
+            animationDuration *= LauncherAnimUtils.blockedFlingDurationFactor(velocity);
+        }
+
+        float nextFrameProgress = Utilities.boundToRange(
+                progress + velocity * SINGLE_FRAME_MS / Math.abs(mEndDisplacement), 0f, 1f);
+
+        mCurrentAnimation.setEndAction(() -> onCurrentAnimationEnd(goingToEnd));
+
+        ValueAnimator anim = mCurrentAnimation.getAnimationPlayer();
+        anim.setFloatValues(nextFrameProgress, goingToEnd ? 1f : 0f);
+        anim.setDuration(animationDuration);
+        anim.setInterpolator(scrollInterpolatorForVelocity(velocity));
+        if (ENABLE_QUICKSTEP_LIVE_TILE) {
+            anim.addUpdateListener(valueAnimator -> {
+                if (mRecentsView.getCurrentPage() != 0 || mCurrentAnimationIsGoingUp) {
+                    mRecentsView.redrawLiveTile(true);
+                }
+            });
+        }
+        if (QUICKSTEP_SPRINGS) {
+            mCurrentAnimation.dispatchOnStartWithVelocity(goingToEnd ? 1f : 0f, velocity);
+        }
+        anim.start();
+    }
+
+    private void onCurrentAnimationEnd(boolean wasSuccess) {
+        if (mPendingAnimation != null) {
+            mPendingAnimation.finish(wasSuccess);
+            mPendingAnimation = null;
+        }
+        clearState();
+    }
+
+    private void clearState() {
+        mDetector.finishedScrolling();
+        mDetector.setDetectableScrollConditions(0, false);
+        mTaskBeingDragged = null;
+        mCurrentAnimation = null;
+        if (mPendingAnimation != null) {
+            mPendingAnimation.finish(false);
+            mPendingAnimation = null;
+        }
+    }
+}
diff --git a/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/TransposedQuickSwitchTouchController.java b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/TransposedQuickSwitchTouchController.java
new file mode 100644
index 0000000000000000000000000000000000000000..5cbee14d485d70aa3e980275e2ff9d4744bbf209
--- /dev/null
+++ b/app/src/quickstep/recents_ui_overrides/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/TransposedQuickSwitchTouchController.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.uioverrides.touchcontrollers;
+
+import foundation.e.blisslauncher.core.touch.SwipeDetector;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.TestActivity;
+
+public class TransposedQuickSwitchTouchController extends QuickSwitchTouchController {
+
+    public TransposedQuickSwitchTouchController(TestActivity launcher) {
+        super(launcher, SwipeDetector.VERTICAL);
+    }
+
+    @Override
+    protected LauncherState getTargetState(LauncherState fromState, boolean isDragTowardPositive) {
+        return super.getTargetState(fromState,
+                isDragTowardPositive);
+    }
+
+    @Override
+    protected float initCurrentAnimation(int animComponents) {
+        float multiplier = super.initCurrentAnimation(animComponents);
+        return -multiplier;
+    }
+
+    @Override
+    protected float getShiftRange() {
+        return mLauncher.getDeviceProfile().getHeightPx() / 2f;
+    }
+}
diff --git a/app/src/quickstep/res/drawable/bg_wellbeing_toast.xml b/app/src/quickstep/res/drawable/bg_wellbeing_toast.xml
new file mode 100644
index 0000000000000000000000000000000000000000..65730f6cc7ac0207c58a690bc9f2fae280894fb5
--- /dev/null
+++ b/app/src/quickstep/res/drawable/bg_wellbeing_toast.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2019 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
+    <solid android:color="#E61A73E8" />
+    <corners android:radius="?android:attr/dialogCornerRadius" />
+</shape>
\ No newline at end of file
diff --git a/app/src/quickstep/res/drawable/bg_workspace_card_button.xml b/app/src/quickstep/res/drawable/bg_workspace_card_button.xml
new file mode 100644
index 0000000000000000000000000000000000000000..3ba47bb4d1551a7f85f73f0dfb39d01fece5c530
--- /dev/null
+++ b/app/src/quickstep/res/drawable/bg_workspace_card_button.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+**
+** Copyright 2017, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+-->
+
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="?android:attr/colorControlHighlight">
+    <item android:id="@android:id/mask">
+        <color android:color="#ffffffff" />
+    </item>
+
+    <item>
+        <color android:color="#77FFFFFF" />
+    </item>
+</ripple>
diff --git a/app/src/quickstep/res/drawable/ic_empty_recents.xml b/app/src/quickstep/res/drawable/ic_empty_recents.xml
new file mode 100644
index 0000000000000000000000000000000000000000..51837339756fc1770619c66e7ff6003c387e5650
--- /dev/null
+++ b/app/src/quickstep/res/drawable/ic_empty_recents.xml
@@ -0,0 +1,30 @@
+<!--
+Copyright (C) 2018 The Android Open Source Project
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="92dp"
+    android:height="80dp"
+    android:viewportWidth="92.0"
+    android:viewportHeight="80.0"
+    android:tint="?android:attr/textColorPrimary">
+    <path
+        android:fillColor="#AAFFFFFF"
+        android:pathData="M18,6H2C0.9,6,0,6.9,0,8v64c0,1.1,0.9,2,2,2h16c1.1,0,2-0.9,2-2V8C20,6.9,19.1,6,18,6z M16,69.25
+        c0,0.41-0.34,0.75-0.75,0.75H4.75C4.34,70,4,69.66,4,69.25v-58.5C4,10.34,4.34,10,4.75,10h10.5c0.41,0,0.75,0.34,0.75,0.75V69.25
+        z M90,6H74c-1.1,0-2,0.9-2,2v64c0,1.1,0.9,2,2,2h16c1.1,0,2-0.9,2-2V8C92,6.9,91.1,6,90,6z M88,69.25c0,0.41-0.34,0.75-0.75,0.75
+        h-10.5C76.34,70,76,69.66,76,69.25v-58.5c0-0.41,0.34-0.75,0.75-0.75h10.5c0.41,0,0.75,0.34,0.75,0.75V69.25z M64,0H28
+        c-2.21,0-4,1.79-4,4v72c0,2.21,1.79,4,4,4h36c2.21,0,4-1.79,4-4V4C68,1.79,66.21,0,64,0z M64,75c0,0.55-0.45,1-1,1H29
+        c-0.55,0-1-0.45-1-1V5c0-0.55,0.45-1,1-1h34c0.55,0,1,0.45,1,1V75z"/>
+</vector>
diff --git a/app/src/quickstep/res/drawable/ic_hourglass_top.xml b/app/src/quickstep/res/drawable/ic_hourglass_top.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2f8bec381e2e866c6f3e26018d544b8ac1b220d8
--- /dev/null
+++ b/app/src/quickstep/res/drawable/ic_hourglass_top.xml
@@ -0,0 +1,13 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24"
+        android:viewportHeight="24"
+        android:tint="?android:attr/textColorPrimary">
+    <group>
+        <clip-path android:pathData="M0,0H24V24H0Z M 0,0"/>
+        <path
+            android:fillColor="#FFFFFFFF"
+            android:pathData="M6,2V8H6l4,4L6,16H6v6H18V16h0l-4,-4,4,-4h0V2ZM16,16.5V20H8V16.5l4,-4Z"/>
+    </group>
+</vector>
diff --git a/app/src/quickstep/res/drawable/ic_pin.xml b/app/src/quickstep/res/drawable/ic_pin.xml
new file mode 100644
index 0000000000000000000000000000000000000000..f9eedbc4b467c486d71947737c68c8ba49169c30
--- /dev/null
+++ b/app/src/quickstep/res/drawable/ic_pin.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24.0dp"
+        android:height="24.0dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0"
+        android:tint="?android:attr/textColorPrimary">
+
+    <path
+        android:strokeColor="#FFFFFFFF"
+        android:strokeAlpha=".008"
+        android:pathData="M0 0h24v24H0z" />
+    <path
+        android:fillColor="#FFFFFFFF"
+        android:pathData="M17 4v7l2 3v2h-6v5l-1 1-1-1v-5H5v-2l2-3V4c0-1.1 0.9 -2 2-2h6c1.11 0 2 0.89 2
+2zM9 4v7.75L7.5 14h9L15 11.75V4H9z" />
+
+</vector>
\ No newline at end of file
diff --git a/app/src/quickstep/res/drawable/ic_split_screen.xml b/app/src/quickstep/res/drawable/ic_split_screen.xml
new file mode 100644
index 0000000000000000000000000000000000000000..108006929cc590202a475928a451aed0987faf5e
--- /dev/null
+++ b/app/src/quickstep/res/drawable/ic_split_screen.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24"
+        android:viewportHeight="24"
+        android:tint="?android:attr/textColorPrimary">
+
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M18,4v5H6V4H18 M18,2H6C4.9,2,4,2.9,4,4v5c0,1.1,0.9,2,2,2h12c1.1,0,2-0.9,2-2V4C20,2.9,19.1,2,18,2L18,2z" />
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M18,15v5H6v-5H18 M18,13H6c-1.1,0-2,0.9-2,2v5c0,1.1,0.9,2,2,2h12c1.1,0,2-0.9,2-2v-5C20,13.9,19.1,13,18,13L18,13z" />
+</vector>
diff --git a/app/src/quickstep/res/drawable/task_menu_bg.xml b/app/src/quickstep/res/drawable/task_menu_bg.xml
new file mode 100644
index 0000000000000000000000000000000000000000..49269030ee47829808d242fd54adcab6aea71d2f
--- /dev/null
+++ b/app/src/quickstep/res/drawable/task_menu_bg.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:gravity="bottom">
+        <!-- Shadow -->
+        <shape>
+            <gradient android:angle="270"
+                android:endColor="@android:color/transparent"
+                android:startColor="#26000000" />
+            <size android:height="@dimen/task_card_menu_shadow_height" />
+        </shape>
+    </item>
+    <item android:bottom="@dimen/task_card_menu_shadow_height">
+        <!-- Background -->
+        <shape>
+            <corners
+                android:topLeftRadius="?android:attr/dialogCornerRadius"
+                android:topRightRadius="?android:attr/dialogCornerRadius"
+                android:bottomLeftRadius="0dp"
+                android:bottomRightRadius="0dp" />
+            <solid android:color="#3C4043" />
+        </shape>
+    </item>
+</layer-list>
diff --git a/app/src/quickstep/res/layout/digital_wellbeing_toast.xml b/app/src/quickstep/res/layout/digital_wellbeing_toast.xml
new file mode 100644
index 0000000000000000000000000000000000000000..83594e4ff335cdfc48f392cffc24b0a2594db634
--- /dev/null
+++ b/app/src/quickstep/res/layout/digital_wellbeing_toast.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2019 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.
+-->
+<TextView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="48dp"
+    android:background="@drawable/bg_wellbeing_toast"
+    android:fontFamily="sans-serif"
+    android:forceHasOverlappingRendering="false"
+    android:gravity="center"
+    android:importantForAccessibility="noHideDescendants"
+    android:textColor="@android:color/white"
+    android:textSize="14sp"/>
\ No newline at end of file
diff --git a/app/src/quickstep/res/layout/overview_clear_all_button.xml b/app/src/quickstep/res/layout/overview_clear_all_button.xml
new file mode 100644
index 0000000000000000000000000000000000000000..03fae0800ccce04cb1faa910ef94a187fefd50ab
--- /dev/null
+++ b/app/src/quickstep/res/layout/overview_clear_all_button.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<foundation.e.blisslauncher.quickstep.views.ClearAllButton
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    style="@android:style/Widget.DeviceDefault.Button.Borderless"
+    android:id="@+id/clear_all"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="@string/recents_clear_all"
+    android:textColor="@android:color/white"
+    android:textSize="14sp"
+    android:translationY="@dimen/task_thumbnail_half_top_margin"
+    />
\ No newline at end of file
diff --git a/app/src/quickstep/res/layout/task.xml b/app/src/quickstep/res/layout/task.xml
new file mode 100644
index 0000000000000000000000000000000000000000..9c7bb811d6887e03c2206b2ad7f01fc145f2365a
--- /dev/null
+++ b/app/src/quickstep/res/layout/task.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+     Copyright (C) 2017 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<foundation.e.blisslauncher.quickstep.views.TaskView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:defaultFocusHighlightEnabled="false"
+    android:elevation="4dp"
+    android:focusable="true">
+
+    <foundation.e.blisslauncher.quickstep.views.TaskThumbnailView
+        android:id="@+id/snapshot"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:layout_marginTop="@dimen/task_thumbnail_top_margin"/>
+
+    <foundation.e.blisslauncher.quickstep.views.IconView
+        android:id="@+id/icon"
+        android:layout_width="@dimen/task_thumbnail_icon_size"
+        android:layout_height="@dimen/task_thumbnail_icon_size"
+        android:layout_gravity="top|center_horizontal"
+        android:focusable="false"
+        android:importantForAccessibility="no"/>
+</foundation.e.blisslauncher.quickstep.views.TaskView>
\ No newline at end of file
diff --git a/app/src/quickstep/res/layout/task_menu.xml b/app/src/quickstep/res/layout/task_menu.xml
new file mode 100644
index 0000000000000000000000000000000000000000..e356afdec1c577e2bb178b3057ad0166951ca71e
--- /dev/null
+++ b/app/src/quickstep/res/layout/task_menu.xml
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<foundation.e.blisslauncher.quickstep.views.TaskMenuView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:animateLayoutChanges="true"
+    android:background="@drawable/task_menu_bg"
+    android:paddingBottom="@dimen/task_card_menu_shadow_height"
+    android:orientation="vertical"
+    android:visibility="invisible">
+
+    <foundation.e.blisslauncher.quickstep.views.IconView
+      android:id="@+id/task_icon"
+      android:layout_width="@dimen/task_thumbnail_icon_size"
+      android:layout_height="@dimen/task_thumbnail_icon_size"
+      android:layout_gravity="top|center_horizontal"
+      android:layout_marginBottom="@dimen/deep_shortcut_drawable_padding"
+      android:focusable="false"
+      android:importantForAccessibility="no" />
+
+    <TextView
+        android:id="@+id/task_name"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:gravity="center_horizontal"
+        android:layout_marginBottom="16dp"
+        android:textSize="12sp"/>
+
+    <LinearLayout
+        android:id="@+id/menu_option_layout"
+        style="@style/TaskMenu"
+        android:divider="@drawable/all_apps_divider"
+        android:showDividers="beginning"
+        android:paddingStart="@dimen/task_card_menu_horizontal_padding"
+        android:paddingEnd="@dimen/task_card_menu_horizontal_padding"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"/>
+
+</foundation.e.blisslauncher.quickstep.views.TaskMenuView>
\ No newline at end of file
diff --git a/app/src/quickstep/res/layout/task_view_menu_option.xml b/app/src/quickstep/res/layout/task_view_menu_option.xml
new file mode 100644
index 0000000000000000000000000000000000000000..102ae9bc23374b19485874874e33ce7a4976b7cd
--- /dev/null
+++ b/app/src/quickstep/res/layout/task_view_menu_option.xml
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    style="@style/TaskMenu.Option"
+    android:layout_height="wrap_content"
+    android:layout_gravity="center"
+    android:orientation="vertical"
+    android:paddingTop="@dimen/task_card_menu_option_vertical_padding"
+    android:paddingBottom="@dimen/task_card_menu_option_vertical_padding"
+    android:background="?android:attr/selectableItemBackground"
+    android:theme="@style/PopupItem" >
+
+    <View
+      android:id="@+id/icon"
+      android:layout_width="@dimen/system_shortcut_icon_size"
+      android:layout_height="@dimen/system_shortcut_icon_size"
+      android:layout_marginTop="@dimen/system_shortcut_header_icon_padding"
+      android:layout_marginBottom="@dimen/deep_shortcut_drawable_padding"
+      android:layout_gravity="center_horizontal"
+      android:backgroundTint="?android:attr/textColorTertiary"/>
+
+    <TextView
+        style="@style/BaseIcon"
+        android:id="@+id/text"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:paddingBottom="@dimen/popup_padding_end"
+        android:textSize="12sp"
+        android:textColor="?android:attr/textColorPrimary"
+        android:fontFamily="sans-serif"
+        android:gravity="center_horizontal"
+        android:layout_gravity="center_horizontal"
+        android:focusable="false" />
+
+</LinearLayout>
diff --git a/app/src/quickstep/res/values-af/strings.xml b/app/src/quickstep/res/values-af/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..64b8e2c3b1b6cddb0eb2b0a4e5c9dbaa5f1a1a50
--- /dev/null
+++ b/app/src/quickstep/res/values-af/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Verdeelde skerm"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Speld vas"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Vormvry"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Oorsig"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Geen onlangse items nie"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Maak toe"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Programgebruikinstellings"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Vee alles uit"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Onlangse programme"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minuut"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> oor vandag"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Programvoorstelle"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Alle programme"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Jou voorspelde programme"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-am/strings.xml b/app/src/quickstep/res/values-am/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..3daa92226c7c189b9a06fffd7466b84914acbd31
--- /dev/null
+++ b/app/src/quickstep/res/values-am/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"የተከፈለ ማያ ገጽ"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"ሰካ"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"ነጻ ቅጽ"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"ማጠቃለያ"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"ምንም የቅርብ ጊዜ ንጥሎች የሉም"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"ዝጋ"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"የመተግበሪያ አጠቃቀም ቅንብሮች"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"ሁሉንም አጽዳ"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"የቅርብ ጊዜ መተግበሪያዎች"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>፣ <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 ደቂቃ"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"ዛሬ <xliff:g id="TIME">%1$s</xliff:g> ቀርቷል"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"የመተግበሪያ ጥቆማዎች"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"ሁሉም መተግበሪያዎች"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"የእርስዎ የሚገመቱ መተግበሪያዎች"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ar/strings.xml b/app/src/quickstep/res/values-ar/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..b036bc1ebd3004909ab09d81bcb3b5a065585773
--- /dev/null
+++ b/app/src/quickstep/res/values-ar/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"تقسيم الشاشة"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"تثبيت"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"شكل مجاني"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"نظرة عامة"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"ليست هناك عناصر تم استخدامها مؤخرًا"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"إغلاق"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"إعدادات استخدام التطبيق"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"محو الكل"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"التطبيقات المستخدمة مؤخرًا"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>، <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"أقل من دقيقة"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"يتبقى اليوم <xliff:g id="TIME">%1$s</xliff:g>."</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"اقتراحات التطبيقات"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"جميع التطبيقات"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"تطبيقاتك المتوقّعة"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-as/strings.xml b/app/src/quickstep/res/values-as/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..c188493e59e8b55189e589e596cbc9c57c9815b0
--- /dev/null
+++ b/app/src/quickstep/res/values-as/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"বিভাজিত স্ক্ৰীণ"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"পিন"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Freeform"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"অৱলোকন"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"কোনো শেহতীয়া বস্তু নাই"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"বন্ধ কৰক"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"এপে ব্যৱহাৰ কৰা ডেটাৰ ছেটিংসমূহ"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"সকলো মচক"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"শেহতীয়া এপসমূহ"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; ১ মিনিট"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"আজি <xliff:g id="TIME">%1$s</xliff:g> বাকী আছ"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"এপৰ পৰামৰ্শসমূহ"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"সকলো এপ্"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"আপোনাৰ অনুমানিক এপ্"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-az/strings.xml b/app/src/quickstep/res/values-az/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..aa8fa536ac8c420cd42a8e51aaf02d09ea6707f3
--- /dev/null
+++ b/app/src/quickstep/res/values-az/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Bölünmüş ekran"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Sancın"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Sərbəst rejim"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"İcmal"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Son elementlər yoxdur"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Bağlayın"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Tətbiq istifadə ayarları"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Hamısını silin"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Son tətbiqlər"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 dəq"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Bu gün <xliff:g id="TIME">%1$s</xliff:g> qaldı"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Tətbiq təklifləri"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Bütün tətbiqlər"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Təklif edilən tətbiqlər"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-b+sr+Latn/strings.xml b/app/src/quickstep/res/values-b+sr+Latn/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..fbbe9d2dc5c5beeaa2d998ea71696a5b4e76d982
--- /dev/null
+++ b/app/src/quickstep/res/values-b+sr+Latn/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Podeljeni ekran"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Zakači"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Slobodni oblik"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Pregled"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Nema nedavnih stavki"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Zatvori"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Podešavanja korišćenja aplikacije"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Obriši sve"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Nedavne aplikacije"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Još <xliff:g id="TIME">%1$s</xliff:g> danas"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Predlozi aplikacija"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Sve aplikacije"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Predviđene aplikacije"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-be/strings.xml b/app/src/quickstep/res/values-be/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..c4a277267ce6e48fec44ad2317f445ee6313cf7e
--- /dev/null
+++ b/app/src/quickstep/res/values-be/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Падзяліць экран"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Замацаваць"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Адвольная форма"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Агляд"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Няма новых элементаў"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Закрыць"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Налады выкарыстання праграмы"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Ачысціць усё"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Нядаўнія праграмы"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 хв"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Сёння засталося <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Прапановы праграм"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Усе праграмы"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Вашы праграмы з падказак"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-bg/strings.xml b/app/src/quickstep/res/values-bg/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..9e8c54a9c7bed885f6a4b070ef9c6c02a1e2ddcc
--- /dev/null
+++ b/app/src/quickstep/res/values-bg/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Разделен екран"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Фиксиране"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Свободна форма"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Общ преглед"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Няма скорошни елементи"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Затваряне"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Настройки за използването на приложенията"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Изчистване на всички"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Скорошни приложения"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 мин"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Оставащо време днес: <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Предложения за приложения"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Всички приложения"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Предвидени приложения"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-bn/strings.xml b/app/src/quickstep/res/values-bn/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..57f92e5a0c56a147d18706dda62f9ee3ac6d28c0
--- /dev/null
+++ b/app/src/quickstep/res/values-bn/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"স্ক্রিন স্প্লিট করুন"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"পিন করুন"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"ফ্রি-ফর্ম"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"এক নজরে"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"কোনো সাম্প্রতিক আইটেম নেই"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"বন্ধ করুন"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"অ্যাপ ব্যবহারের সেটিংস"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"সবকিছু খালি করুন"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"সম্প্রতি ব্যবহৃত অ্যাপ"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; ১ মি."</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"আজকে <xliff:g id="TIME">%1$s</xliff:g> বাকি আছে"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"অ্যাপের সাজেশন"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"সব অ্যাপ"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"আপনার প্রয়োজন হতে পারে এমন অ্যাপ"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-bs/strings.xml b/app/src/quickstep/res/values-bs/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..7968f7cc68a6271219d56a12c7fe35e470520927
--- /dev/null
+++ b/app/src/quickstep/res/values-bs/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Način rada podijeljenog ekrana"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Zakači"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Slobodan oblik"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Pregled"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Nema nedavnih stavki"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Zatvaranje"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Postavke korištenja aplikacije"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Obriši sve"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Nedavne aplikacije"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Preostalo vrijeme: <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Prijedlozi za aplikacije"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Sve aplikacije"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Predviđene aplikacije"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ca/strings.xml b/app/src/quickstep/res/values-ca/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6420aa8cb8982ccc84a892d1c77049f9020367cd
--- /dev/null
+++ b/app/src/quickstep/res/values-ca/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Pantalla dividida"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Fixa"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Format lliure"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Aplicacions recents"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"No hi ha cap element recent"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Tanca"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Configuració d\'ús d\'aplicacions"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Esborra-ho tot"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Aplicacions recents"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>; <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minut"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"temps restant avui: <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Suggeriments d\'aplicacions"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Totes les aplicacions"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Prediccions d\'aplicacions"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-cs/strings.xml b/app/src/quickstep/res/values-cs/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..194ff87dc59b5e20e43932619319365434621458
--- /dev/null
+++ b/app/src/quickstep/res/values-cs/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Rozdělená obrazovka"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"PIN"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Neomezený režim"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Přehled"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Žádné nedávné položky"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Zavřít"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Nastavení využití aplikací"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Vymazat vše"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Poslední aplikace"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minuta"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"dnes zbývá: <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Návrhy aplikací"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Všechny aplikace"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Vaše předpovídané aplikace"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-da/strings.xml b/app/src/quickstep/res/values-da/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..b43a76eb94fc30a890ff71d42b6c4ef9b2f607f1
--- /dev/null
+++ b/app/src/quickstep/res/values-da/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Opdel skærm"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Fastgør"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Frit format"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Oversigt"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Ingen nye elementer"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Luk"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Indstillinger for appforbrug"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Ryd alt"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Seneste apps"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> tilbage i dag"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Appforslag"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Alle apps"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Dine foreslåede apps"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-de/strings.xml b/app/src/quickstep/res/values-de/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..449cc8c11df99bd52d62d5f9984b22d684c142b5
--- /dev/null
+++ b/app/src/quickstep/res/values-de/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Splitscreen"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Anpinnen"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Freeform-Modus"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Übersicht"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Keine kürzlich verwendeten Elemente"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Schließen"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Einstellungen zur App-Nutzung"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Alle Apps schließen"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Zuletzt aktive Apps"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Heute noch <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"App-Vorschläge"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Alle Apps"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"App-Vorschläge für dich"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-el/strings.xml b/app/src/quickstep/res/values-el/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..87268df749a32c4a23a60971fc3398d4306396c4
--- /dev/null
+++ b/app/src/quickstep/res/values-el/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Διαχωρισμός οθόνης"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Καρφίτσωμα"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Ελεύθερη μορφή"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Επισκόπηση"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Δεν υπάρχουν πρόσφατα στοιχεία"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Κλείσιμο"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Ρυθμίσεις χρήσης εφαρμογής"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Διαγραφή όλων"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Πρόσφατες εφαρμογές"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 λ."</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Απομένουν <xliff:g id="TIME">%1$s</xliff:g> σήμερα"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Προτάσεις εφαρμογών"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Όλες οι εφαρμογές"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Προβλέψεις εφαρμογών"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-en-rAU/strings.xml b/app/src/quickstep/res/values-en-rAU/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2d1418e5f46ad728f833b7b489dcb16157c5082b
--- /dev/null
+++ b/app/src/quickstep/res/values-en-rAU/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Split screen"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Pin"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Freeform"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Overview"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"No recent items"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Close"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"App usage settings"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Clear all"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Recent apps"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minute"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> left today"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"App suggestions"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"All apps"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Your predicted apps"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-en-rGB/strings.xml b/app/src/quickstep/res/values-en-rGB/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2d1418e5f46ad728f833b7b489dcb16157c5082b
--- /dev/null
+++ b/app/src/quickstep/res/values-en-rGB/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Split screen"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Pin"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Freeform"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Overview"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"No recent items"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Close"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"App usage settings"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Clear all"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Recent apps"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minute"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> left today"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"App suggestions"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"All apps"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Your predicted apps"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-en-rIN/strings.xml b/app/src/quickstep/res/values-en-rIN/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2d1418e5f46ad728f833b7b489dcb16157c5082b
--- /dev/null
+++ b/app/src/quickstep/res/values-en-rIN/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Split screen"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Pin"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Freeform"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Overview"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"No recent items"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Close"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"App usage settings"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Clear all"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Recent apps"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minute"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> left today"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"App suggestions"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"All apps"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Your predicted apps"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-es-rUS/strings.xml b/app/src/quickstep/res/values-es-rUS/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..5f5d0bdfe9db91fe134abac2b7b227bddc764212
--- /dev/null
+++ b/app/src/quickstep/res/values-es-rUS/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Pantalla dividida"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Fijar"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Formato libre"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Recientes"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"No hay elementos recientes"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Cerrar"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Configuración de uso de la app"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Borrar todo"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Apps recientes"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g> (<xliff:g id="REMAINING_TIME">%2$s</xliff:g>)"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minuto"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Tiempo restante: <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Sugerencias de apps"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Todas las apps"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Predicción de tus apps"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-es/strings.xml b/app/src/quickstep/res/values-es/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..329286b3bf3345de7e8e161a5af29cc04dfde243
--- /dev/null
+++ b/app/src/quickstep/res/values-es/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Dividir pantalla"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Fijar"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Formato libre"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Aplicaciones recientes"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"No hay elementos recientes"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Cerrar"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Ajustes de uso de la aplicación"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Borrar todo"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Aplicaciones recientes"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g> (<xliff:g id="REMAINING_TIME">%2$s</xliff:g>)"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt;1 minuto"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"tiempo restante: <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Sugerencias de aplicaciones"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Todas las aplicaciones"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Predicción de aplicaciones"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-et/strings.xml b/app/src/quickstep/res/values-et/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..0577b0f562a602c538e6aa5fecf3512aa3816afc
--- /dev/null
+++ b/app/src/quickstep/res/values-et/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Jagatud ekraan"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Kinnita"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Vabavorm"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Ülevaade"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Hiljutisi üksusi pole"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Sule"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Rakenduse kasutuse seaded"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Sule kõik"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Hiljutised rakendused"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g> <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minut"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Tääna jäänud <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Rakenduste soovitused"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Kõik rakendused"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Teie ennustatud rakendused"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-eu/strings.xml b/app/src/quickstep/res/values-eu/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..c2d149e3627dd28fedf197203c335d06c0814c6a
--- /dev/null
+++ b/app/src/quickstep/res/values-eu/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Zatitu pantaila"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Ainguratu"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Modu librea"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Ikuspegi orokorra"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Ez dago azkenaldi honetako ezer"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Itxi"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Aplikazioen erabileraren ezarpenak"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Garbitu guztiak"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Azken aplikazioak"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g> (<xliff:g id="REMAINING_TIME">%2$s</xliff:g>)"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> gelditzen dira gaur"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Iradokitako aplikazioak"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Aplikazio guztiak"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Lagungarri izan dakizkizukeen aplikazioak"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-fa/strings.xml b/app/src/quickstep/res/values-fa/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..cc26695a607e4ed43023e8026349befb5b3d0439
--- /dev/null
+++ b/app/src/quickstep/res/values-fa/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"تقسیم صفحه"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"پین"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Freeform"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"نمای کلی"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"بدون موارد اخیر"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"بستن"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"تنظیمات استفاده از برنامه"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"پاک کردن همه"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"برنامه‌های اخیر"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>، <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; ۱ دقیقه"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> باقی‌مانده برای امروز"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"برنامه‌های پیشنهادی"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"همه برنامه‌ها"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"برنامه‌های پیش‌بینی‌شده"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-fi/strings.xml b/app/src/quickstep/res/values-fi/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..f43433e3a11be4a11a1f5bc5f556f375820b9834
--- /dev/null
+++ b/app/src/quickstep/res/values-fi/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Jaettu näyttö"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Kiinnitä"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Vapaamuotoinen"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Viimeisimmät"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Ei viimeaikaisia kohteita"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Sulje"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Sovelluksen käyttöasetukset"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Poista kaikki"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Viimeisimmät sovellukset"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> jäljellä tänään"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Sovellusehdotukset"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Kaikki sovellukset"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Sovellusennusteet"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-fr-rCA/strings.xml b/app/src/quickstep/res/values-fr-rCA/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..a9a1cffb6d90102a7562f19393324dec255554c8
--- /dev/null
+++ b/app/src/quickstep/res/values-fr-rCA/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Écran divisé"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Épingler"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Forme libre"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Aperçu"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Aucun élément récent"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Fermer"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Paramètres d\'utilisation de l\'application"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Tout effacer"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Applications récentes"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g> : <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Il reste <xliff:g id="TIME">%1$s</xliff:g> aujourd\'hui"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Suggestions d\'applications"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Toutes les applications"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Vos prédictions d\'applications"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-fr/strings.xml b/app/src/quickstep/res/values-fr/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..5394f495e943a4619fcb44bb47995435b43981a2
--- /dev/null
+++ b/app/src/quickstep/res/values-fr/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Écran partagé"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Épingler"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Format libre"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Aperçu"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Aucun élément récent"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Fermer"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Paramètres de consommation de l\'application"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Tout effacer"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Applications récentes"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Encore <xliff:g id="TIME">%1$s</xliff:g> aujourd\'hui"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Suggestions d\'applications"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Toutes les applications"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Vos applications prévues"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-gl/strings.xml b/app/src/quickstep/res/values-gl/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..356d10d5da00c7a6e77abb265a44aa176261f9ac
--- /dev/null
+++ b/app/src/quickstep/res/values-gl/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Pantalla dividida"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Fixar"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Forma libre"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Visión xeral"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Non hai elementos recentes"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Pecha a aplicación"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Configuración do uso de aplicacións"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Borrar todo"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Apps recentes"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g> (<xliff:g id="REMAINING_TIME">%2$s</xliff:g>)"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt;1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Tempo restante hoxe <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Suxestións de aplicacións"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Todas as aplicacións"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"As túas aplicacións preditas"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-gu/strings.xml b/app/src/quickstep/res/values-gu/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..660ad87acc0ae3a2a53d96fbc7b47244bec3cb89
--- /dev/null
+++ b/app/src/quickstep/res/values-gu/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"સ્ક્રીનને વિભાજિત કરો"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"પિન કરો"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"ફ્રિફોર્મ"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"ઝલક"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"તાજેતરની કોઈ આઇટમ નથી"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"બંધ કરો"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"ઍપ વપરાશનું સેટિંગ"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"બધું સાફ કરો"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"તાજેતરની ઍપ"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 મિનિટ"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> આજે બાકી"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"ઍપ સૂચનો"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"બધી ઍપ"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"તમારી પૂર્વાનુમાનિત ઍપ"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-hi/strings.xml b/app/src/quickstep/res/values-hi/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..0467af4b2dec124fc5bb3da7bff8e896ad00beb4
--- /dev/null
+++ b/app/src/quickstep/res/values-hi/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"स्क्रीन को दो हिस्सों में बाँटना (स्प्लिट स्क्रीन)"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"पिन करना"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"फ़्रीफ़ॉर्म"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"खास जानकारी"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"हाल ही में इस्तेमाल किया गया कोई ऐप्लिकेशन नहीं है"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"बंद करें"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"ऐप्लिकेशन इस्तेमाल की सेटिंग"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"सभी ऐप्लिकेशन बंद करें"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"हाल ही में इस्तेमाल किए गए एेप्लिकेशन"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt;1 मिनट"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"आज <xliff:g id="TIME">%1$s</xliff:g> और चलेगा"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"ऐप्लिकेशन के सुझाव"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"सभी ऐप्लिकेशन"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"आपके काम के ऐप्लिकेशन"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-hr/strings.xml b/app/src/quickstep/res/values-hr/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..ab56e57b50f51d7c7ff71ff42343f43f40464ff5
--- /dev/null
+++ b/app/src/quickstep/res/values-hr/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Podijeljeni zaslon"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Prikvači"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Slobodni oblik"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Pregled"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Nema nedavnih stavki"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Zatvori"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Postavke upotrebe aplikacija"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Izbriši sve"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Nedavne aplikacije"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Još <xliff:g id="TIME">%1$s</xliff:g> danas"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Predložene aplikacije"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Sve aplikacije"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Vaše predviđene aplikacije"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-hu/strings.xml b/app/src/quickstep/res/values-hu/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..dec6ea015848801e2302dd605d7956ac88986e48
--- /dev/null
+++ b/app/src/quickstep/res/values-hu/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Osztott képernyő"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Rögzítés"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Szabad forma"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Áttekintés"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Nincsenek mostanában használt elemek"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Bezárás"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Alkalmazáshasználati beállítások"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Összes törlése"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Legutóbbi alkalmazások"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 perc"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Ma még <xliff:g id="TIME">%1$s</xliff:g> van hátra"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Alkalmazásjavaslatok"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Az összes alkalmazás"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Várható alkalmazások"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-hy/strings.xml b/app/src/quickstep/res/values-hy/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..1656a1444d9d587156384cf8ded80a06044002d9
--- /dev/null
+++ b/app/src/quickstep/res/values-hy/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Տրոհել էկրանը"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Ամրացնել"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Կամայական ձև"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Ընդհանուր տեղեկություններ"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Վերջին տարրեր չկան"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Փակել"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Հավելվածի օգտագործման կարգավորումներ"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Փակել բոլորը"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Վերջին օգտագործած հավելվածները"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 ր"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Այսօր մնացել է՝ <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Առաջարկվող հավելվածներ"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Բոլոր հավելվածները"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Ձեր կանխատեսված հավելվածները"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-in/strings.xml b/app/src/quickstep/res/values-in/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6824d16b407e82559ab2a308589efb4a2e479921
--- /dev/null
+++ b/app/src/quickstep/res/values-in/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Layar terpisah"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Pasang pin"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Format bebas"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Ringkasan"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Tidak ada item yang baru dibuka"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Tutup"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Setelan penggunaan aplikasi"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Hapus semua"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Aplikasi baru-baru ini"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 menit"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> tersisa hari ini"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Saran aplikasi"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Semua aplikasi"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Aplikasi yang diprediksi"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-is/strings.xml b/app/src/quickstep/res/values-is/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..f60a2c68028c46f499aaecedfaa881e7b27adc52
--- /dev/null
+++ b/app/src/quickstep/res/values-is/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Skipta skjá"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Festa"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Frjálst snið"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Yfirlit"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Engin nýleg atriði"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Loka"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Notkunarstillingar forrits"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Hreinsa allt"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Nýleg forrit"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 mín."</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> eftir í dag"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Tillögur að forritum"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Öll forrit"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Spáð forrit"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-it/strings.xml b/app/src/quickstep/res/values-it/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..559fdb4b6e6583f2119c1f486e02ebb3ece048b2
--- /dev/null
+++ b/app/src/quickstep/res/values-it/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Schermo diviso"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Blocca"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Forma libera"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Panoramica"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Nessun elemento recente"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Chiudi"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Impostazioni di utilizzo delle app"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Cancella tutto"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"App recenti"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Rimanente oggi: <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"App suggerite"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Tutte le app"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Le app previste"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-iw/strings.xml b/app/src/quickstep/res/values-iw/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..58cab4e0a9b0f4cfdecf2ccfe5686000f8efb588
--- /dev/null
+++ b/app/src/quickstep/res/values-iw/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"מסך מפוצל"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"הצמדה"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"מצב חופשי"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"מסכים אחרונים"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"אין פריטים אחרונים"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"סגירה"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"הגדרות שימוש באפליקציה"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"ניקוי הכול"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"אפליקציות אחרונות"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"‏&lt; דקה"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"הזמן שנותר להיום: <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"הצעות לאפליקציות"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"כל האפליקציות"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"האפליקציות החזויות שלך"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ja/strings.xml b/app/src/quickstep/res/values-ja/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..d3fecde2081c6bac635604ad55a2f46316e8bc34
--- /dev/null
+++ b/app/src/quickstep/res/values-ja/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"分割画面"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"固定"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"フリーフォーム"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"概要"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"最近のアイテムはありません"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"閉じる"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"アプリの使用状況の設定"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"すべてクリア"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"最近使ったアプリ"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>、<xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"1 分未満"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"今日はあと <xliff:g id="TIME">%1$s</xliff:g>です"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"アプリの候補"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"すべてのアプリ"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"予測されたアプリ"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ka/strings.xml b/app/src/quickstep/res/values-ka/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..67b03a754f05cc353617473b6af70ebaab29cae9
--- /dev/null
+++ b/app/src/quickstep/res/values-ka/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"ეკრანის გაყოფა"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"ჩამაგრება"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"თავისუფალი ფორმა"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"მიმოხილვა"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"ბოლოს გამოყენებული ერთეულები არ არის"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"დახურვა"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"აპების გამოყენების პარამეტრები"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"ყველას გასუფთავება"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"ბოლოდროინდელი აპები"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 წუთი"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"დღეს დარჩენილია <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"აპების შემოთავაზებები"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"ყველა აპი"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"თქვენი პროგნოზირებული აპები"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-kk/strings.xml b/app/src/quickstep/res/values-kk/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..a9fcbedb2091c7788406485da2efc77d36885ada
--- /dev/null
+++ b/app/src/quickstep/res/values-kk/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Экранды бөлу"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Бекіту"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Еркін форма"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Шолу"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Соңғы элементтер жоқ"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Жабу"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Қолданбаны пайдалану параметрлері"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Барлығын өшіру"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Соңғы пайдаланылған қолданбалар"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 мин"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Бүгін <xliff:g id="TIME">%1$s</xliff:g> қалды"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Қолданба ұсыныстары"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Барлық қолданбалар"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Ұсынылатын қолданбалар"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-km/strings.xml b/app/src/quickstep/res/values-km/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..c422041e7aa4f519602ce450da5fa2ab652c00d5
--- /dev/null
+++ b/app/src/quickstep/res/values-km/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"មុខងារ​បំបែកអេក្រង់"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"ដៅ"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"មុខងារទម្រង់សេរី"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"ទិដ្ឋភាពរួម"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"មិនមានធាតុថ្មីៗទេ"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"បិទ"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"ការកំណត់​ការប្រើប្រាស់​កម្មវិធី"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"សម្អាត​ទាំងអស់"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"កម្មវិធី​ថ្មីៗ"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 នាទី"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"នៅសល់ <xliff:g id="TIME">%1$s</xliff:g> ទៀត​នៅថ្ងៃនេះ"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"ការណែនាំកម្មវិធី"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"កម្មវិធី​ទាំងអស់"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"កម្មវិធី​ដែលបាន​ព្យាករ​របស់អ្នក"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-kn/strings.xml b/app/src/quickstep/res/values-kn/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..52782610b950b3034acff66eb76fd2cf3a009b47
--- /dev/null
+++ b/app/src/quickstep/res/values-kn/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"ಪರದೆಯನ್ನು ಬೇರ್ಪಡಿಸಿ"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"ಪಿನ್ ಮಾಡಿ"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"ಮುಕ್ತಸ್ವರೂಪ"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"ಅವಲೋಕನ"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"ಯಾವುದೇ ಇತ್ತೀಚಿನ ಐಟಂಗಳಿಲ್ಲ"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"ಮುಚ್ಚಿ"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"ಆ್ಯಪ್‌ ಬಳಕೆಯ ಸೆಟ್ಟಿಂಗ್‌ಗಳು"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"ಎಲ್ಲವನ್ನೂ ತೆರವುಗೊಳಿಸಿ"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"ಇತ್ತೀಚಿನ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 ನಿ"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"ಇಂದು <xliff:g id="TIME">%1$s</xliff:g> ಸಮಯ ಉಳಿದಿದೆ"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"ಆ್ಯಪ್ ಸಲಹೆಗಳು"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"ಎಲ್ಲಾ ಆ್ಯಪ್‌ಗಳು"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"ನಿಮ್ಮ ಸಂಭವನೀಯ ಆ್ಯಪ್‌ಗಳು"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ko/strings.xml b/app/src/quickstep/res/values-ko/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..7a8e6a1f9a1e535fd1932927116cf3b0170bff23
--- /dev/null
+++ b/app/src/quickstep/res/values-ko/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"화면 분할"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"고정"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"자유 형식"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"최근 사용"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"최근 항목이 없습니다."</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"닫기"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"앱 사용 설정"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"모두 삭제"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"최근 앱"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1분"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"오늘 <xliff:g id="TIME">%1$s</xliff:g> 남음"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"앱 추천"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"모든 앱"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"추천 앱"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ky/strings.xml b/app/src/quickstep/res/values-ky/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..4018e57dccba853fc53ecbc9a0c854392c04abf3
--- /dev/null
+++ b/app/src/quickstep/res/values-ky/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Экранды бөлүү"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Кадап коюу"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Эркин форма режими"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Сереп салуу"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Акыркы колдонмолор жок"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Жабуу"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Колдонмону пайдалануу жөндөөлөрү"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Баарын тазалоо"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Акыркы колдонмолор"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 мүнөт"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Бүгүн <xliff:g id="TIME">%1$s</xliff:g> мүнөт калды"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Колдонмо сунуштары"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Бардык колдонмолор"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Божомолдонгон колдонмолоруңуз"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-land/dimens.xml b/app/src/quickstep/res/values-land/dimens.xml
new file mode 100644
index 0000000000000000000000000000000000000000..c03eaa2cf1de2982854d7d4071e3c2f9e1471d26
--- /dev/null
+++ b/app/src/quickstep/res/values-land/dimens.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<resources>
+    <dimen name="task_card_menu_horizontal_padding">24dp</dimen>
+</resources>
\ No newline at end of file
diff --git a/app/src/quickstep/res/values-land/styles.xml b/app/src/quickstep/res/values-land/styles.xml
new file mode 100644
index 0000000000000000000000000000000000000000..0824b4f555ce7cf02b1696b10488075db679bfc3
--- /dev/null
+++ b/app/src/quickstep/res/values-land/styles.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<resources>
+    <!-- Task Menu layout styles. -->
+    <style name="TaskMenu">
+        <item name="android:orientation">horizontal</item>
+    </style>
+
+    <!-- Task Menu Option layout styles. -->
+    <style name="TaskMenu.Option">
+        <item name="android:layout_width">0dp</item>
+        <item name="android:layout_weight">1</item>
+    </style>
+</resources>
\ No newline at end of file
diff --git a/app/src/quickstep/res/values-lo/strings.xml b/app/src/quickstep/res/values-lo/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..e406b7083d8d458a6fa9193a8ed6677de231c8c7
--- /dev/null
+++ b/app/src/quickstep/res/values-lo/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"ແບ່ງໜ້າຈໍ"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"ປັກໝຸດ"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"ຮູບແບບອິດສະຫລະ"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"ພາບຮວມ"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"ບໍ່ມີລາຍການຫຼ້າສຸດ"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"ປິດ"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"ການຕັ້ງຄ່າການນຳໃຊ້ແອັບ"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"ລຶບລ້າງທັງໝົດ"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"ແອັບຫຼ້າສຸດ"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 ນາທີ"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"ເຫຼືອ <xliff:g id="TIME">%1$s</xliff:g> ມື້ນີ້"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"ການແນະນຳແອັບ"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"ແອັບທັງໝົດ"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"ແອັບທີ່ຄາດເດົາໄວ້ແລ້ວຂອງທ່ານ"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-lt/strings.xml b/app/src/quickstep/res/values-lt/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..ed1fc373e28cc0def4bb3734381cf356fe955755
--- /dev/null
+++ b/app/src/quickstep/res/values-lt/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Skaidyti ekraną"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Prisegti"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Laisva forma"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Apžvalga"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Nėra jokių naujausių elementų"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Uždaryti"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Programos naudojimo nustatymai"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Išvalyti viską"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Naujausios programos"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min."</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Šiandien liko: <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Programų pasiūlymai"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Visos programos"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Numatomos programos"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-lv/strings.xml b/app/src/quickstep/res/values-lv/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..85ce0e017dd4a544554f75ae75b69fd7852a61b8
--- /dev/null
+++ b/app/src/quickstep/res/values-lv/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Sadalīt ekrānu"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Piespraust"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Brīva forma"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Pārskats"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Nav nesenu vienumu."</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Aizvērt"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Lietotņu izmantošanas iestatījumi"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Notīrīt visu"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Pēdējās izmantotās lietotnes"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt;1 minūte"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Šodien atlicis: <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Ieteicamās lietotnes"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Visas lietotnes"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Jūsu prognozētās lietotnes"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-mk/strings.xml b/app/src/quickstep/res/values-mk/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..9f11521df3cbb5f04e41d81541d7038a5003791f
--- /dev/null
+++ b/app/src/quickstep/res/values-mk/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Поделен екран"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Прикачување"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Freeform"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Преглед"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Нема неодамнешни ставки"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Затвори"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Поставки за користење на апликациите"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Исчисти ги сите"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Неодамнешни апликации"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 минута"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Уште <xliff:g id="TIME">%1$s</xliff:g> за денес"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Предлози за апликации"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Сите апликации"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Вашите предвидени апликации"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ml/strings.xml b/app/src/quickstep/res/values-ml/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2e02e80fa81f9201ceaa40b9597844e6f62cf0a3
--- /dev/null
+++ b/app/src/quickstep/res/values-ml/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"സ്‌ക്രീൻ വിഭജിക്കുക"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"പിൻ ചെയ്യുക"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"ഫ്രീഫോം"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"അവലോകനം"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"സമീപകാല ഇനങ്ങൾ ഒന്നുമില്ല"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"അവസാനിപ്പിക്കുക"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"ആപ്പ് ഉപയോഗ ക്രമീകരണം"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"എല്ലാം മായ്‌ക്കുക"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"സമീപകാല ആപ്പുകൾ"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 മിനിറ്റ്"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"ഇന്ന് <xliff:g id="TIME">%1$s</xliff:g> ശേഷിക്കുന്നു"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"ആപ്പ് നിർദ്ദേശങ്ങൾ"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"എല്ലാ ആപ്പുകളും"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"നിങ്ങളുടെ പ്രവചിക്കപ്പെട്ട ആപ്പുകൾ"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-mn/strings.xml b/app/src/quickstep/res/values-mn/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..5de8602022f1741ad881a066ccf1315d73beff51
--- /dev/null
+++ b/app/src/quickstep/res/values-mn/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Дэлгэцийг хуваах"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Тогтоох"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Чөлөөтэй хувьсах"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Тойм"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Сүүлийн үеийн зүйл алга"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Хаах"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Апп ашиглалтын тохиргоо"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Бүгдийг устгах"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Саяхны аппууд"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 минут"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Өнөөдөр <xliff:g id="TIME">%1$s</xliff:g> үлдсэн"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Аппын зөвлөмж"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Бүх апп"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Таны таамагласан аппууд"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-mr/strings.xml b/app/src/quickstep/res/values-mr/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..1ca558a240dc8d418ab6345168225867fe335374
--- /dev/null
+++ b/app/src/quickstep/res/values-mr/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"विभाजित स्क्रीन"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"पिन करा"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"फ्रीफॉर्म"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"अवलोकन"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"कोणतेही अलीकडील आयटम नाहीत"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"बंद"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"अ‍ॅप वापर सेटिंग्ज"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"सर्व साफ करा"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"अलीकडील अॅप्स"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"१मिहून कमी"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"आज <xliff:g id="TIME">%1$s</xliff:g>शिल्लक आहे"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"अ‍ॅप सूचना"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"सर्व अ‍ॅप्स"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"तुमची पूर्वानुमानीत अ‍ॅप्स"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ms/strings.xml b/app/src/quickstep/res/values-ms/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..254296376927b1ac6f07c3c027f5f51c5fc21c18
--- /dev/null
+++ b/app/src/quickstep/res/values-ms/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Skrin pisah"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Semat"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Bentuk bebas"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Ikhtisar"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Tiada item terbaharu"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Tutup"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Tetapan penggunaan apl"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Kosongkan semua"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Apl terbaharu"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minit"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> lagi hari ini"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Cadangan apl"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Semua apl"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Apl ramalan anda"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-my/strings.xml b/app/src/quickstep/res/values-my/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..7683e059903e4c16e7dcd0fe80083f83a32c0235
--- /dev/null
+++ b/app/src/quickstep/res/values-my/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"မျက်နှာပြင် ခွဲ၍ပြသခြင်း"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"ပင်ထိုးခြင်း"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"အလွတ်ပုံစံ"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"အနှစ်ချုပ်"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"မကြာမီကဖွင့်ထားသည်များ မရှိပါ"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"ပိတ်ရန်"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"အက်ပ်အသုံးပြုမှု ဆက်တင်များ"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"အားလုံးကို ရှင်းရန်"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"လတ်တလောသုံး အက်ပ်များ"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>၊ <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; ၁ မိနစ်"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"ယနေ့ <xliff:g id="TIME">%1$s</xliff:g> ခု ကျန်သည်"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"အက်ပ်အကြံပြုချက်များ"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"အက်ပ်အားလုံး"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"သင်၏ ခန့်မှန်းအက်ပ်များ"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-nb/strings.xml b/app/src/quickstep/res/values-nb/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..01bbb6a75d66365ece763ce569ae706db8f42def
--- /dev/null
+++ b/app/src/quickstep/res/values-nb/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Delt skjerm"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Fest"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Fritt format"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Oversikt"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Ingen nylige elementer"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Lukk"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Innstillinger for appbruk"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Fjern alt"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Nylige apper"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minutt"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> gjenstår i dag"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Appanbefalinger"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Alle apper"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Forslag til apper"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ne/strings.xml b/app/src/quickstep/res/values-ne/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..60e9bd5313f7e1a392cbfbf457c86dea410b10a0
--- /dev/null
+++ b/app/src/quickstep/res/values-ne/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"स्क्रिन विभाजन गर्नुहोस्"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"पिन गर्नुहोस्"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"फ्रिफर्म"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"परिदृश्य"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"हालसालैको कुनै पनि वस्तु छैन"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"बन्द गर्नुहोस्"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"अनुप्रयोगको उपयोगका सेटिङहरू"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"सबै खाली गर्नुहोस्"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"हालसालैका अनुप्रयोगहरू"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; १ मिनेट"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"आज: <xliff:g id="TIME">%1$s</xliff:g> बाँकी"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"अनुप्रयोगसम्बन्धी सुझावहरू"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"सबै अनुप्रयोगहरू"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"तपाईंका पूर्वानुमानित अनुप्रयोगहरू"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-nl/strings.xml b/app/src/quickstep/res/values-nl/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..8032567e1cd03be6a811a92f2284e14f513022da
--- /dev/null
+++ b/app/src/quickstep/res/values-nl/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Gesplitst scherm"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Vastzetten"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Vrije vorm"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Overzicht"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Geen recente items"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Sluiten"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Instellingen voor app-gebruik"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Alles wissen"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Recente apps"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minuut"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Nog <xliff:g id="TIME">%1$s</xliff:g> vandaag"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"App-suggesties"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Alle apps"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Je voorspelde apps"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-or/strings.xml b/app/src/quickstep/res/values-or/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2ebec4e7c74737d5bc12ca6dc56386e636393028
--- /dev/null
+++ b/app/src/quickstep/res/values-or/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"ସ୍କ୍ରୀନ୍‌କୁ ଭାଗ କରନ୍ତୁ"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"ପିନ୍‍"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"ଫ୍ରିଫର୍ମ"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"ସଂକ୍ଷିପ୍ତ ବିବରଣ"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"କୌଣସି ସାମ୍ପ୍ରତିକ ଆଇଟମ୍ ନାହିଁ"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"ବନ୍ଦ କରନ୍ତୁ"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"ଆପ୍‍ ବ୍ୟବହାର ସେଟିଂସ୍‍"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"ସବୁ ଖାଲି କରନ୍ତୁ"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"ବର୍ତ୍ତମାନର ଆପ୍‌"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g> <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 ମିନିଟ୍"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"ଆଜି <xliff:g id="TIME">%1$s</xliff:g> ବାକି ଅଛି"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"ଆପ୍ ପରାମର୍ଶଗୁଡ଼ିକ"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"ସମସ୍ତ ଆପ୍ସ"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"ଆପଣ ପୂର୍ବାନୁମାନ କରିଥିବା ଆପ୍ସ"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-pa/strings.xml b/app/src/quickstep/res/values-pa/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..58c0d2afa4550e65ed6c0c4ca4a2c566d5887a53
--- /dev/null
+++ b/app/src/quickstep/res/values-pa/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"ਸਪਲਿਟ ਸਕ੍ਰੀਨ"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"ਪਿੰਨ ਕਰੋ"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"ਫ੍ਰੀਫਾਰਮ"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"ਰੂਪ-ਰੇਖਾ"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"ਕੋਈ ਹਾਲੀਆ ਆਈਟਮਾਂ ਨਹੀਂ"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"ਬੰਦ ਕਰੋ"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"ਐਪ ਵਰਤੋਂ ਦੀਆਂ ਸੈਟਿੰਗਾਂ"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"ਸਭ ਕਲੀਅਰ ਕਰੋ"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"ਹਾਲੀਆ ਐਪਾਂ"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 ਮਿੰਟ"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"ਅੱਜ <xliff:g id="TIME">%1$s</xliff:g> ਬਾਕੀ"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"ਐਪ ਸੰਬੰਧੀ ਸੁਝਾਅ"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"ਸਾਰੀਆਂ ਐਪਾਂ"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"ਤੁਹਾਡੀਆਂ ਪੂਰਵ ਅਨੁਮਾਨਿਤ ਐਪਾਂ"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-pl/strings.xml b/app/src/quickstep/res/values-pl/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..d83160dffb21a2cbbc75905e6e2796c60d5ea159
--- /dev/null
+++ b/app/src/quickstep/res/values-pl/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Podziel ekran"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Przypnij"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Tryb dowolny"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Przegląd"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Brak ostatnich elementów"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Zamknij"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Ustawienia użycia aplikacji"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Wyczyść wszystko"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Ostatnie aplikacje"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&gt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Na dziś zostało <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Sugerowane aplikacje"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Wszystkie aplikacje"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Przewidywane aplikacje"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-pt-rPT/strings.xml b/app/src/quickstep/res/values-pt-rPT/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2fd34d636cd90b4be2a2ea2d425c81dfd33fa5e4
--- /dev/null
+++ b/app/src/quickstep/res/values-pt-rPT/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Ecrã dividido"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Fixar"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Forma livre"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Vista geral"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Nenhum item recente"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Fechar"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Definições de utilização de aplicações"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Limpar tudo"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Aplicações recentes"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minuto"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Resta(m) <xliff:g id="TIME">%1$s</xliff:g> hoje."</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Sugestões de aplicações"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Todas as aplicações"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"As suas aplicações previstas"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-pt/strings.xml b/app/src/quickstep/res/values-pt/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..673dfe2e733cbbb45095d760743d6e9608a386bc
--- /dev/null
+++ b/app/src/quickstep/res/values-pt/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Tela dividida"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Fixar"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Forma livre"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Visão geral"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Nenhum item recente"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Fechar"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Configurações de uso do app"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Limpar tudo"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Apps recentes"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> restante(s) hoje"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Sugestões de apps"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Todos os apps"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Suas predições de apps"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ro/strings.xml b/app/src/quickstep/res/values-ro/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2ac783eb0e0815f64e584cbd83d217ac73ba5645
--- /dev/null
+++ b/app/src/quickstep/res/values-ro/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Ecran împărțit"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Fixați"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Formă liberă"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Recente"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Niciun element recent"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Închideți"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Setări de utilizare a aplicației"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Ștergeți tot"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Aplicații recente"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minut"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Au mai rămas <xliff:g id="TIME">%1$s</xliff:g> astăzi"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Sugestii de aplicații"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Toate aplicațiile"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Aplicațiile estimate"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ru/strings.xml b/app/src/quickstep/res/values-ru/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..5dd89a644baf8a7c235eb616c458d3018a781365
--- /dev/null
+++ b/app/src/quickstep/res/values-ru/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Разделить экран"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Блокировать"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Произвольная форма"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Обзор"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Здесь пока ничего нет."</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Закрыть"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Настройки использования приложения"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Очистить все"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Недавние приложения"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>: <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 мин."</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Осталось сегодня: <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Рекомендуемые приложения"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Все приложения"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Ваши рекомендуемые приложения"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-si/strings.xml b/app/src/quickstep/res/values-si/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..f6584c4dcad0ce0a8881e7d75d41f6afe90a78d7
--- /dev/null
+++ b/app/src/quickstep/res/values-si/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"බෙදුම් තිරය"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"අමුණන්න"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Freeform"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"දළ විශ්ලේෂණය"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"මෑත අයිතම නැත"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"වසන්න"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"යෙදුම් භාවිත සැකසීම්"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"සියල්ල හිස් කරන්න"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"මෑත යෙදුම්"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 විනාඩියක්"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"අද <xliff:g id="TIME">%1$s</xliff:g>ක් ඉතුරුයි"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"යෙදුම් යෝජනා"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"සියලු යෙදුම්"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"ඔබේ පුරෝකථන කළ යෙදුම්"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-sk/strings.xml b/app/src/quickstep/res/values-sk/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..8a9c7365f269d73bcb3ed223193facf6adfed0eb
--- /dev/null
+++ b/app/src/quickstep/res/values-sk/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Rozdeliť obrazovku"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Pripnúť"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Voľný režim"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Prehľad"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Žiadne nedávne položky"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Zavrieť"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Nastavenia využívania aplikácie"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Vymazať všetko"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Nedávne aplikácie"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"Menej ako 1 minúta"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Dnes ešte zostáva: <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Návrhy aplikácií"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Všetky aplikácie"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Vaše predpovedané aplikácie"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-sl/strings.xml b/app/src/quickstep/res/values-sl/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..15f8f89cc77fb3e0fba6cadf264f24b320ef115d
--- /dev/null
+++ b/app/src/quickstep/res/values-sl/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Razdeljen zaslon"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Pripni"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Prosta oblika"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Pregled"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Ni nedavnih elementov"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Zapri"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Nastavitve uporabe aplikacij"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Počisti vse"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Nedavne aplikacije"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Danes je ostalo še <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Predlogi za aplikacije"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Vse aplikacije"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Predvidene aplikacije"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-sq/strings.xml b/app/src/quickstep/res/values-sq/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..d8f5f28b4206de05f46ce1f4e8324896e27d8306
--- /dev/null
+++ b/app/src/quickstep/res/values-sq/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Ekrani i ndarë"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Gozhdo"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Formë e lirë"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Përmbledhja"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Nuk ka asnjë artikull të fundit"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Mbyll"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Cilësimet e përdorimit të aplikacionit"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Pastroji të gjitha"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Aplikacionet e fundit"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 minutë"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> të mbetura sot"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Sugjerimet e aplikacioneve"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Të gjitha aplikacionet"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Aplikacionet e tua të parashikuara"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-sr/strings.xml b/app/src/quickstep/res/values-sr/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..b72164144692cbdffa0f500e468e3dce5c472fdb
--- /dev/null
+++ b/app/src/quickstep/res/values-sr/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Подељени екран"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Закачи"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Слободни облик"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Преглед"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Нема недавних ставки"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Затвори"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Подешавања коришћења апликације"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Обриши све"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Недавне апликације"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 мин"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Још <xliff:g id="TIME">%1$s</xliff:g> данас"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Предлози апликација"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Све апликације"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Предвиђене апликације"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-sv/strings.xml b/app/src/quickstep/res/values-sv/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..ba7ebcdec7d88f304558b507d0b6e22910358de4
--- /dev/null
+++ b/app/src/quickstep/res/values-sv/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Delad skärm"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Fäst"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Fritt format"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Översikt"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Listan med de senaste åtgärderna är tom"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Stäng"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Inställningar för appanvändning"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Rensa alla"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Senaste apparna"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> kvar i dag"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Appförslag"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Alla appar"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Föreslagna appar"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-sw/strings.xml b/app/src/quickstep/res/values-sw/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..24db4290934768617c7fef9c40c1ec91a5a3675a
--- /dev/null
+++ b/app/src/quickstep/res/values-sw/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Gawa skrini"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Bandika"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Muundo huru"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Muhtasari"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Hakuna vipengee vya hivi karibuni"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Funga"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Mipangilio ya matumizi ya programu"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Ondoa zote"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Programu za hivi karibuni"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; dak 1"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Umebakisha <xliff:g id="TIME">%1$s</xliff:g> leo"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Mapendekezo ya programu"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Programu zote"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Programu zako zinazopendekezwa"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ta/strings.xml b/app/src/quickstep/res/values-ta/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..97d51cd35f99e8bb96cbfe674898d46e3e9ab00d
--- /dev/null
+++ b/app/src/quickstep/res/values-ta/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"திரைப் பிரிப்பு"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"பின் செய்தல்"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"குறிப்பிட்ட வடிவமில்லாத பயன்முறை"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"மேலோட்டப் பார்வை"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"சமீபத்தியவை எதுவுமில்லை"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"மூடும்"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"ஆப்ஸ் உபயோக அமைப்புகள்"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"எல்லாம் அழி"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"சமீபத்திய ஆப்ஸ்"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 நி"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"இன்று <xliff:g id="TIME">%1$s</xliff:g> மீதமுள்ளது"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"ஆப்ஸ் பரிந்துரைகள்"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"அனைத்து ஆப்ஸும்"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"நீங்கள் கணித்த ஆப்ஸ்"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-te/strings.xml b/app/src/quickstep/res/values-te/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..24b37f75d42648c082837d43b8f01afbd87b9678
--- /dev/null
+++ b/app/src/quickstep/res/values-te/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"స్క్రీన్‌ని విభజించు"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"పిన్ చేయి"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"సంప్రదాయేతర"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"అవలోకనం"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"ఇటీవలి అంశాలు ఏవీ లేవు"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"మూసివేయండి"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"యాప్ వినియోగ సెట్టింగ్‌లు"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"అన్నీ తీసివేయండి"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"ఇటీవలి యాప్‌లు"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 నిమిషం"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"నేటికి <xliff:g id="TIME">%1$s</xliff:g> మిగిలి ఉంది"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"యాప్ సూచనలు"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"అన్ని యాప్‌లు"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"మీ సూచించబడిన యాప్‌లు"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-th/strings.xml b/app/src/quickstep/res/values-th/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..0f6821bf19baf5a5ab91a83d3c1b410fbc7abf69
--- /dev/null
+++ b/app/src/quickstep/res/values-th/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"แยกหน้าจอ"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"ตรึง"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"รูปแบบอิสระ"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"ภาพรวม"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"ไม่มีรายการล่าสุด"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"ปิด"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"การตั้งค่าการใช้แอป"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"ล้างทั้งหมด"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"แอปล่าสุด"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g> <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt;1 นาที"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"วันนี้เหลืออีก <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"คำแนะนำเกี่ยวกับแอป"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"แอปทั้งหมด"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"แอปที่คาดการณ์ไว้"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-tl/strings.xml b/app/src/quickstep/res/values-tl/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..491bac5bd988db5d9ebc5f777d6436c5d0434d12
--- /dev/null
+++ b/app/src/quickstep/res/values-tl/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Hatiin ang screen"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"I-pin"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Freeform"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Overview"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Walang kamakailang item"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Isara"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Mga setting ng paggamit ng app"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"I-clear lahat"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Mga kamakailang app"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 min"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> na lang ngayon"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Mga iminumungkahing app"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Lahat ng app"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Iyong mga nahulaang app"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-tr/strings.xml b/app/src/quickstep/res/values-tr/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..ec6d88405c768167b68a4579fe4490dc87561c13
--- /dev/null
+++ b/app/src/quickstep/res/values-tr/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Bölünmüş ekran"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Sabitle"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Serbest çalışma"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Genel bakış"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Yeni öğe yok"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Kapat"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Uygulama kullanım ayarları"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Tümünü temizle"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Son uygulamalar"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 dk."</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Bugün <xliff:g id="TIME">%1$s</xliff:g> kaldı"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Uygulama önerileri"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Tüm uygulamalar"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Tahmin edilen uygulamalarınız"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-uk/strings.xml b/app/src/quickstep/res/values-uk/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..77360625dba3efdccc0dc5508e9802a99d2459b8
--- /dev/null
+++ b/app/src/quickstep/res/values-uk/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Розділити екран"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Закріпити"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Довільна форма"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Огляд"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Немає нещодавніх додатків"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Закрити"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Налаштування використання додатка"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Очистити все"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Нещодавні додатки"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 хв"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Сьогодні залишилося <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Пропозиції додатків"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Усі додатки"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Передбачені додатки"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-ur/strings.xml b/app/src/quickstep/res/values-ur/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..87b303f2af0104939cea6184fb302cb0b51b5251
--- /dev/null
+++ b/app/src/quickstep/res/values-ur/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"اسپلٹ اسکرین وضع"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"پن کریں"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"فری فارم"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"مجموعی جائزہ"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"کوئی حالیہ آئٹم نہیں"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"بند کریں"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"ایپ کے استعمال کی ترتیبات"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"سبھی کو صاف کریں"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"حالیہ ایپس"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>،<xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"‏&lt; 1 منٹ"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"آج <xliff:g id="TIME">%1$s</xliff:g> بچا ہے"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"ایپ کی تجاویز"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"تمام ایپس"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"آپ کی پیشن گوئی کردہ ایپس"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-uz/strings.xml b/app/src/quickstep/res/values-uz/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..67c8e91c0013b6e08b782db71c26a2c9e986e901
--- /dev/null
+++ b/app/src/quickstep/res/values-uz/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Ekranni ikkiga ajratish"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Mahkamlash"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Erkin shakl"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Nazar"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Yaqinda ishlatilgan ilovalar yo‘q"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Yopish"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Ilovadan foydalanish sozlamalari"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Hammasini tozalash"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Yaqinda ishlatilgan ilovalar"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 daqiqa"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Bugun <xliff:g id="TIME">%1$s</xliff:g> qoldi"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Tavsiya etiladigan ilovalar"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Barcha ilovalar"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Taklif qilingan ilovalaringiz"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-vi/strings.xml b/app/src/quickstep/res/values-vi/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..34c89efcf11c348ef9777936163ea5e149bc4210
--- /dev/null
+++ b/app/src/quickstep/res/values-vi/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Chia đôi màn hình"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Ghim"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"Dạng tự do"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Tổng quan"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Không có mục gần đây nào"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Đóng"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Cài đặt mức sử dụng ứng dụng"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Xóa tất cả"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Ứng dụng gần đây"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 phút"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"Hôm nay còn <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Các ứng dụng đề xuất"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Tất cả ứng dụng"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Các ứng dụng gợi ý của bạn"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-zh-rCN/strings.xml b/app/src/quickstep/res/values-zh-rCN/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..0e83977fa3e4b2535e5635cffadad3a0436d212c
--- /dev/null
+++ b/app/src/quickstep/res/values-zh-rCN/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"分屏"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"固定"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"自由窗口"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"概览"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"近期没有任何内容"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"关闭"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"应用使用设置"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"全部清除"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"最近用过的应用"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>（<xliff:g id="REMAINING_TIME">%2$s</xliff:g>）"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"不到 1 分钟"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"今天还可使用 <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"应用推荐"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"所有应用"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"您的预测应用"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-zh-rHK/strings.xml b/app/src/quickstep/res/values-zh-rHK/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..ac7e8e9002e26c500e462e5762738b0473ad06bc
--- /dev/null
+++ b/app/src/quickstep/res/values-zh-rHK/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"分割畫面"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"固定"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"自由形式"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"概覽"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"最近沒有任何項目"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"關閉"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"應用程式使用情況設定"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"全部清除"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"最近使用的應用程式"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>，<xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"少於 1 分鐘"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"今天剩餘時間：<xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"應用程式建議"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"所有應用程式"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"您的預測應用程式"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-zh-rTW/strings.xml b/app/src/quickstep/res/values-zh-rTW/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..3323bfd57d257df3745d33397ac962907ed15294
--- /dev/null
+++ b/app/src/quickstep/res/values-zh-rTW/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"分割畫面"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"固定"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"自由形式"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"總覽"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"最近沒有任何項目"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"關閉"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"應用程式使用情況設定"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"全部清除"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"最近使用的應用程式"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g> (<xliff:g id="REMAINING_TIME">%2$s</xliff:g>)"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 分鐘"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"今天還能使用 <xliff:g id="TIME">%1$s</xliff:g>"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"應用程式建議"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"所有應用程式"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"系統預測你會使用的應用程式"</string>
+</resources>
diff --git a/app/src/quickstep/res/values-zu/strings.xml b/app/src/quickstep/res/values-zu/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..0f1d99d7b67cc75a3268a6cb12cef36dc4a3da0e
--- /dev/null
+++ b/app/src/quickstep/res/values-zu/strings.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="recent_task_option_split_screen" msgid="5353188922202653570">"Hlukanisa isikrini"</string>
+    <string name="recent_task_option_pin" msgid="7929860679018978258">"Phina"</string>
+    <string name="recent_task_option_freeform" msgid="48863056265284071">"I-Freeform"</string>
+    <string name="accessibility_desc_recent_apps" msgid="1444379410873162882">"Buka konke"</string>
+    <string name="recents_empty_message" msgid="7040467240571714191">"Azikho izinto zakamuva"</string>
+    <string name="accessibility_close_task" msgid="5354563209433803643">"Vala"</string>
+    <string name="accessibility_app_usage_settings" msgid="6312864233673544149">"Izilungiselelo zokusetshenziswa kohlelo lokusebenza"</string>
+    <string name="recents_clear_all" msgid="5328176793634888831">"Sula konke"</string>
+    <string name="accessibility_recent_apps" msgid="4058661986695117371">"Izinhlelo zokusebenza zakamuva"</string>
+    <string name="task_contents_description_with_remaining_time" msgid="4479688746574672685">"<xliff:g id="TASK_DESCRIPTION">%1$s</xliff:g>, <xliff:g id="REMAINING_TIME">%2$s</xliff:g>"</string>
+    <string name="shorter_duration_less_than_one_minute" msgid="4722015666335015336">"&lt; 1 iminithi"</string>
+    <string name="time_left_for_app" msgid="3111996412933644358">"<xliff:g id="TIME">%1$s</xliff:g> esele namhlanje"</string>
+    <string name="title_app_suggestions" msgid="4185902664111965088">"Iziphakamiso zohlelo lokusebenza"</string>
+    <string name="all_apps_label" msgid="8542784161730910663">"Zonke izinhlelo zokusebenza"</string>
+    <string name="all_apps_prediction_tip" msgid="2672336544844936186">"Izinhlelo zakho zokusebenza eziqagelwe"</string>
+</resources>
diff --git a/app/src/quickstep/res/values/config.xml b/app/src/quickstep/res/values/config.xml
new file mode 100644
index 0000000000000000000000000000000000000000..9c055ee559d1009e3cd1275d06c4fbd4e23c0bd0
--- /dev/null
+++ b/app/src/quickstep/res/values/config.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<resources>
+    <string name="task_overlay_factory_class" translatable="false"></string>
+
+    <string name="overview_callbacks_class" translatable="false"></string>
+
+    <!-- Activity which blocks home gesture -->
+    <string name="gesture_blocking_activity" translatable="false"></string>
+
+
+    <!-- The number of thumbnails and icons to keep in the cache. The thumbnail cache size also
+         determines how many thumbnails will be fetched in the background. -->
+    <integer name="recentsThumbnailCacheSize">3</integer>
+    <integer name="recentsIconCacheSize">12</integer>
+
+    <!-- Assistant Gesture -->
+    <integer name="assistant_gesture_min_time_threshold">200</integer>
+    <integer name="assistant_gesture_corner_deg_threshold">20</integer>
+</resources>
diff --git a/app/src/quickstep/res/values/dimens.xml b/app/src/quickstep/res/values/dimens.xml
new file mode 100644
index 0000000000000000000000000000000000000000..c44cd2a760b0043b3df5e13d601f4a0d4ddf9042
--- /dev/null
+++ b/app/src/quickstep/res/values/dimens.xml
@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2017 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<resources>
+
+    <dimen name="task_thumbnail_top_margin">24dp</dimen>
+    <dimen name="task_thumbnail_half_top_margin">12dp</dimen>
+    <dimen name="task_thumbnail_icon_size">48dp</dimen>
+    <!-- For screens without rounded corners -->
+    <dimen name="task_corner_radius_small">2dp</dimen>
+
+    <dimen name="recents_page_spacing">10dp</dimen>
+    <dimen name="recents_clear_all_deadzone_vertical_margin">70dp</dimen>
+    <dimen name="overview_peek_distance">96dp</dimen>
+
+    <!-- The speed in dp/s at which the user needs to be scrolling in recents such that we start
+             loading full resolution screenshots. -->
+    <dimen name="recents_fast_fling_velocity">600dp</dimen>
+
+    <!-- These velocities are in dp / s -->
+    <dimen name="quickstep_fling_threshold_velocity">500dp</dimen>
+    <dimen name="quickstep_fling_min_velocity">250dp</dimen>
+
+    <!-- These speeds are in dp / ms -->
+    <dimen name="motion_pause_detector_speed_very_slow">0.0285dp</dimen>
+    <dimen name="motion_pause_detector_speed_slow">0.15dp</dimen>
+    <dimen name="motion_pause_detector_speed_somewhat_fast">0.285dp</dimen>
+    <dimen name="motion_pause_detector_speed_fast">1.4dp</dimen>
+    <dimen name="motion_pause_detector_min_displacement_from_app">36dp</dimen>
+
+    <!-- Launcher app transition -->
+    <dimen name="content_trans_y">50dp</dimen>
+    <dimen name="workspace_trans_y">50dp</dimen>
+    <dimen name="closing_window_trans_y">115dp</dimen>
+
+    <dimen name="recents_empty_message_text_size">16sp</dimen>
+    <dimen name="recents_empty_message_text_padding">16dp</dimen>
+
+    <!-- Total space (start + end) between the task card and the edge of the screen
+         in various configurations -->
+    <dimen name="task_card_vert_space">40dp</dimen>
+    <dimen name="task_card_menu_option_vertical_padding">8dp</dimen>
+    <dimen name="task_card_menu_shadow_height">3dp</dimen>
+    <dimen name="task_card_menu_horizontal_padding">0dp</dimen>
+    <dimen name="portrait_task_card_horz_space">136dp</dimen>
+    <dimen name="landscape_task_card_horz_space">200dp</dimen>
+    <dimen name="multi_window_task_card_horz_space">100dp</dimen>
+    <!-- Copied from framework resource:
+       docked_stack_divider_thickness - 2 * docked_stack_divider_insets -->
+    <dimen name="multi_window_task_divider_size">10dp</dimen>
+
+    <!-- same as vertical_drag_handle_size -->
+    <dimen name="shelf_surface_offset">24dp</dimen>
+
+    <!-- Assistant Gestures -->
+    <!-- Distance from the vertical edges of the screen in which assist gestures are recognized -->
+    <dimen name="gestures_assistant_width">48dp</dimen>
+    <dimen name="gestures_assistant_drag_threshold">55dp</dimen>
+
+    <!-- Distance to move elements when swiping up to go home from launcher -->
+    <dimen name="home_pullback_distance">28dp</dimen>
+    <dimen name="deep_shortcut_drawable_padding">8dp</dimen>
+</resources>
diff --git a/app/src/quickstep/res/values/strings.xml b/app/src/quickstep/res/values/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..66a09fcf7431a7a766c521289a648220e2d94e7a
--- /dev/null
+++ b/app/src/quickstep/res/values/strings.xml
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+* Copyright (C) 2017 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+
+    <!-- Application name -->
+    <string name="derived_app_name" translatable="false">Quickstep</string>
+
+    <!-- Options for recent tasks -->
+    <!-- Title for an option to enter split screen mode for a given app -->
+    <string name="recent_task_option_split_screen">Split screen</string>
+    <!-- Title for an option to keep an app pinned to the screen until it is unpinned -->
+    <string name="recent_task_option_pin">Pin</string>
+    <!-- Title for an option to enter freeform mode for a given app -->
+    <string name="recent_task_option_freeform">Freeform</string>
+
+    <!-- Content description for the recent apps panel (not shown on the screen). [CHAR LIMIT=NONE] -->
+    <string name="accessibility_desc_recent_apps">Overview</string>
+
+    <!-- Recents: The empty recents string. [CHAR LIMIT=NONE] -->
+    <string name="recents_empty_message">No recent items</string>
+
+    <!-- Content description for the recent apps's accessibility option that closes it. [CHAR LIMIT=NONE] -->
+    <string name="accessibility_close_task">Close</string>
+
+    <!-- Content description for the recent apps's accessibility option that opens its usage settings. [CHAR LIMIT=NONE] -->
+    <string name="accessibility_app_usage_settings">App usage settings</string>
+
+    <!-- Recents: Title of a button that clears the task list, i.e. closes all tasks. [CHAR LIMIT=30] -->
+    <string name="recents_clear_all">Clear all</string>
+
+    <!-- Accessibility title for the list of recent apps [CHAR_LIMIT=none] -->
+    <string name="accessibility_recent_apps">Recent apps</string>
+
+    <!-- Accessibility title for an app card in Recents for apps that have time limit set
+     [CHAR_LIMIT=none] -->
+    <string name="task_contents_description_with_remaining_time"><xliff:g id="task_description" example="GMail">%1$s</xliff:g>, <xliff:g id="remaining_time" example="7 minutes left today">%2$s</xliff:g></string>
+
+    <!-- Text to show total app usage per day if it is less than 1 minute ("&lt;" is the
+     escaped form of '<'). [CHAR LIMIT=15] -->
+    <string name="shorter_duration_less_than_one_minute">&lt; 1 minute</string>
+
+    <!-- Annotation shown on an app card in Recents, telling that the app has a usage limit set by
+    the user, and a given time is left for it today [CHAR LIMIT=22] -->
+    <string name="time_left_for_app"><xliff:g id="time" example="7 minutes">%1$s</xliff:g> left today</string>
+
+</resources>
\ No newline at end of file
diff --git a/app/src/quickstep/res/values/styles.xml b/app/src/quickstep/res/values/styles.xml
new file mode 100644
index 0000000000000000000000000000000000000000..bb364ff6de74f5a501c176c21062bbce040728f9
--- /dev/null
+++ b/app/src/quickstep/res/values/styles.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2018 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<resources>
+    <!-- Task Menu layout styles. -->
+    <style name="TaskMenu">
+        <item name="android:orientation">vertical</item>
+    </style>
+
+    <!-- Task Menu Option layout styles. -->
+    <style name="TaskMenu.Option">
+        <item name="android:layout_width">match_parent</item>
+        <item name="android:layout_height">wrap_content</item>
+    </style>
+</resources>
\ No newline at end of file
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/LauncherAnimationRunner.java b/app/src/quickstep/src/foundation/e/blisslauncher/LauncherAnimationRunner.java
new file mode 100644
index 0000000000000000000000000000000000000000..780ca4ff953b358f2e180a2bc293ac9d896c5112
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/LauncherAnimationRunner.java
@@ -0,0 +1,138 @@
+/*
+ * 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 foundation.e.blisslauncher;
+
+import static com.android.systemui.shared.recents.utilities.Utilities.postAtFrontOfQueueAsynchronously;
+import static foundation.e.blisslauncher.core.Utilities.SINGLE_FRAME_MS;
+import static foundation.e.blisslauncher.core.Utilities.postAsyncCallback;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.annotation.TargetApi;
+import android.os.Build;
+import android.os.Handler;
+import androidx.annotation.BinderThread;
+import androidx.annotation.UiThread;
+import com.android.systemui.shared.system.RemoteAnimationRunnerCompat;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+
+@TargetApi(Build.VERSION_CODES.P)
+public abstract class LauncherAnimationRunner implements RemoteAnimationRunnerCompat {
+
+    private final Handler mHandler;
+    private final boolean mStartAtFrontOfQueue;
+    private AnimationResult mAnimationResult;
+
+    /**
+     * @param startAtFrontOfQueue If true, the animation start will be posted at the front of the
+     *                            queue to minimize latency.
+     */
+    public LauncherAnimationRunner(Handler handler, boolean startAtFrontOfQueue) {
+        mHandler = handler;
+        mStartAtFrontOfQueue = startAtFrontOfQueue;
+    }
+
+    @BinderThread
+    @Override
+    public void onAnimationStart(RemoteAnimationTargetCompat[] targetCompats, Runnable runnable) {
+        Runnable r = () -> {
+            finishExistingAnimation();
+            mAnimationResult = new AnimationResult(runnable);
+            onCreateAnimation(targetCompats, mAnimationResult);
+        };
+        if (mStartAtFrontOfQueue) {
+            postAtFrontOfQueueAsynchronously(mHandler, r);
+        } else {
+            postAsyncCallback(mHandler, r);
+        }
+    }
+
+    /**
+     * Called on the UI thread when the animation targets are received. The implementation must
+     * call {@link AnimationResult#setAnimation(AnimatorSet)} with the target animation to be run.
+     */
+    @UiThread
+    public abstract void onCreateAnimation(
+            RemoteAnimationTargetCompat[] targetCompats, AnimationResult result);
+
+    @UiThread
+    private void finishExistingAnimation() {
+        if (mAnimationResult != null) {
+            mAnimationResult.finish();
+            mAnimationResult = null;
+        }
+    }
+
+    /**
+     * Called by the system
+     */
+    @BinderThread
+    @Override
+    public void onAnimationCancelled() {
+        postAsyncCallback(mHandler, this::finishExistingAnimation);
+    }
+
+    public static final class AnimationResult {
+
+        private final Runnable mFinishRunnable;
+
+        private AnimatorSet mAnimator;
+        private boolean mFinished = false;
+        private boolean mInitialized = false;
+
+        private AnimationResult(Runnable finishRunnable) {
+            mFinishRunnable = finishRunnable;
+        }
+
+        @UiThread
+        private void finish() {
+            if (!mFinished) {
+                mFinishRunnable.run();
+                mFinished = true;
+            }
+        }
+
+        @UiThread
+        public void setAnimation(AnimatorSet animation) {
+            if (mInitialized) {
+                throw new IllegalStateException("Animation already initialized");
+            }
+            mInitialized = true;
+            mAnimator = animation;
+            if (mAnimator == null) {
+                finish();
+            } else if (mFinished) {
+                // Animation callback was already finished, skip the animation.
+                mAnimator.start();
+                mAnimator.end();
+            } else {
+                // Start the animation
+                mAnimator.addListener(new AnimatorListenerAdapter() {
+                    @Override
+                    public void onAnimationEnd(Animator animation) {
+                        finish();
+                    }
+                });
+                mAnimator.start();
+
+                // Because t=0 has the app icon in its original spot, we can skip the
+                // first frame and have the same movement one frame earlier.
+                mAnimator.setCurrentPlayTime(SINGLE_FRAME_MS);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/LauncherInitListener.java b/app/src/quickstep/src/foundation/e/blisslauncher/LauncherInitListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..02fd41e63b2c55b42570c4cb2003f1e9baf56c4e
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/LauncherInitListener.java
@@ -0,0 +1,94 @@
+/*
+ * 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 foundation.e.blisslauncher;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.os.Handler;
+
+import foundation.e.blisslauncher.quickstep.OverviewCallbacks;
+import foundation.e.blisslauncher.quickstep.util.RemoteAnimationProvider;
+import foundation.e.blisslauncher.quickstep.ActivityControlHelper;
+
+import java.util.function.BiPredicate;
+
+import foundation.e.blisslauncher.features.test.InternalStateHandler;
+import foundation.e.blisslauncher.features.test.TestActivity;
+
+@TargetApi(Build.VERSION_CODES.P)
+public class LauncherInitListener extends InternalStateHandler implements
+    ActivityControlHelper.ActivityInitListener {
+
+    private final BiPredicate<TestActivity, Boolean> mOnInitListener;
+
+    private RemoteAnimationProvider mRemoteAnimationProvider;
+
+    public LauncherInitListener(BiPredicate<TestActivity, Boolean> onInitListener) {
+        mOnInitListener = onInitListener;
+    }
+
+    @Override
+    protected boolean init(TestActivity launcher, boolean alreadyOnHome) {
+        if (mRemoteAnimationProvider != null) {
+            QuickstepAppTransitionManagerImpl appTransitionManager =
+                    (QuickstepAppTransitionManagerImpl) launcher.getAppTransitionManager();
+
+            // Set a one-time animation provider. After the first call, this will get cleared.
+            // TODO: Probably also check the intended target id.
+            CancellationSignal cancellationSignal = new CancellationSignal();
+            appTransitionManager.setRemoteAnimationProvider((targets) -> {
+
+                // On the first call clear the reference.
+                cancellationSignal.cancel();
+                RemoteAnimationProvider provider = mRemoteAnimationProvider;
+                mRemoteAnimationProvider = null;
+
+                if (provider != null && launcher.getStateManager().getState().overviewUi) {
+                    return provider.createWindowAnimation(targets);
+                }
+                return null;
+            }, cancellationSignal);
+        }
+        OverviewCallbacks.get(launcher).onInitOverviewTransition();
+        return mOnInitListener.test(launcher, alreadyOnHome);
+    }
+
+    @Override
+    public void register() {
+        initWhenReady();
+    }
+
+    @Override
+    public void unregister() {
+        mRemoteAnimationProvider = null;
+        clearReference();
+    }
+
+    @Override
+    public void registerAndStartActivity(Intent intent, RemoteAnimationProvider animProvider,
+            Context context, Handler handler, long duration) {
+        mRemoteAnimationProvider = animProvider;
+
+        register();
+
+        Bundle options = animProvider.toActivityOptions(handler, duration).toBundle();
+        context.startActivity(addToIntent(new Intent((intent))), options);
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/QuickstepAppTransitionManagerImpl.java b/app/src/quickstep/src/foundation/e/blisslauncher/QuickstepAppTransitionManagerImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf3a7566c8021585ec675cde1fc5ddc2672aee1d
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/QuickstepAppTransitionManagerImpl.java
@@ -0,0 +1,808 @@
+/*
+ * 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 foundation.e.blisslauncher;
+
+import static com.android.systemui.shared.system.QuickStepContract.getWindowCornerRadius;
+import static com.android.systemui.shared.system.QuickStepContract.supportsRoundedCornersOnWindows;
+import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_CLOSING;
+import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_OPENING;
+import static foundation.e.blisslauncher.core.Utilities.postAsyncCallback;
+import static foundation.e.blisslauncher.features.test.BaseActivity.INVISIBLE_ALL;
+import static foundation.e.blisslauncher.features.test.BaseActivity.INVISIBLE_BY_APP_TRANSITIONS;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.AGGRESSIVE_EASE;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.DEACCEL_1_7;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.EXAGGERATED_EASE;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+import static foundation.e.blisslauncher.features.test.dragndrop.DragLayer.ALPHA_INDEX_TRANSITIONS;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.animation.ValueAnimator;
+import android.annotation.TargetApi;
+import android.app.ActivityOptions;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.os.Build;
+import android.os.CancellationSignal;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Pair;
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.android.systemui.shared.system.ActivityCompat;
+import com.android.systemui.shared.system.ActivityOptionsCompat;
+import com.android.systemui.shared.system.QuickStepContract;
+import com.android.systemui.shared.system.RemoteAnimationAdapterCompat;
+import com.android.systemui.shared.system.RemoteAnimationDefinitionCompat;
+import com.android.systemui.shared.system.RemoteAnimationRunnerCompat;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat;
+import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat.SurfaceParams;
+import com.android.systemui.shared.system.WindowManagerWrapper;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.utils.MultiValueAlpha;
+import foundation.e.blisslauncher.features.test.IconTextView;
+import foundation.e.blisslauncher.features.test.LauncherAppTransitionManager;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.features.test.dragndrop.DragLayer;
+import foundation.e.blisslauncher.quickstep.TaskUtils;
+import foundation.e.blisslauncher.quickstep.util.MultiValueUpdateListener;
+import foundation.e.blisslauncher.quickstep.util.RemoteAnimationProvider;
+import foundation.e.blisslauncher.quickstep.util.RemoteAnimationTargetSet;
+
+/**
+ * {@link LauncherAppTransitionManager} with Quickstep-specific app transitions for launching from
+ * home and/or all-apps.
+ */
+@TargetApi(Build.VERSION_CODES.O)
+@SuppressWarnings("unused")
+public abstract class QuickstepAppTransitionManagerImpl extends LauncherAppTransitionManager
+    implements VariantDeviceProfile.OnDeviceProfileChangeListener {
+
+    private static final String TAG = "QuickstepTransition";
+
+    /**
+     * 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 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";
+
+    private static final long APP_LAUNCH_DURATION = 450;
+    // Use a shorter duration for x or y translation to create a curve effect
+    private static final long APP_LAUNCH_CURVED_DURATION = 250;
+    private static final long APP_LAUNCH_ALPHA_DURATION = 50;
+    private static final long APP_LAUNCH_ALPHA_START_DELAY = 25;
+
+    // We scale the durations for the downward app launch animations (minus the scale animation).
+    private static final float APP_LAUNCH_DOWN_DUR_SCALE_FACTOR = 0.8f;
+    private static final long APP_LAUNCH_DOWN_DURATION =
+        (long) (APP_LAUNCH_DURATION * APP_LAUNCH_DOWN_DUR_SCALE_FACTOR);
+    private static final long APP_LAUNCH_DOWN_CURVED_DURATION =
+        (long) (APP_LAUNCH_CURVED_DURATION * APP_LAUNCH_DOWN_DUR_SCALE_FACTOR);
+    private static final long APP_LAUNCH_ALPHA_DOWN_DURATION =
+        (long) (APP_LAUNCH_ALPHA_DURATION * APP_LAUNCH_DOWN_DUR_SCALE_FACTOR);
+
+    private static final long CROP_DURATION = 375;
+    private static final long RADIUS_DURATION = 375;
+
+    public static final int RECENTS_LAUNCH_DURATION = 336;
+    private static final int LAUNCHER_RESUME_START_DELAY = 100;
+    private static final int CLOSING_TRANSITION_DURATION_MS = 250;
+
+    protected static final int CONTENT_ALPHA_DURATION = 217;
+    protected static final int CONTENT_TRANSLATION_DURATION = 350;
+
+    // Progress = 0: All apps is fully pulled up, Progress = 1: All apps is fully pulled down.
+    public static final float ALL_APPS_PROGRESS_OFF_SCREEN = 1.3059858f;
+
+    protected final TestActivity mLauncher;
+
+    private final DragLayer mDragLayer;
+    private final MultiValueAlpha.AlphaProperty mDragLayerAlpha;
+
+    final Handler mHandler;
+    private final boolean mIsRtl;
+
+    private final float mContentTransY;
+    private final float mWorkspaceTransY;
+    private final float mClosingWindowTransY;
+
+    private VariantDeviceProfile mDeviceProfile;
+
+    private RemoteAnimationProvider mRemoteAnimationProvider;
+
+    private final AnimatorListenerAdapter mForceInvisibleListener = new AnimatorListenerAdapter() {
+        @Override
+        public void onAnimationStart(Animator animation) {
+            mLauncher.addForceInvisibleFlag(INVISIBLE_BY_APP_TRANSITIONS);
+        }
+
+        @Override
+        public void onAnimationEnd(Animator animation) {
+            mLauncher.clearForceInvisibleFlag(INVISIBLE_BY_APP_TRANSITIONS);
+        }
+    };
+
+    public QuickstepAppTransitionManagerImpl(Context context) {
+        mLauncher = TestActivity.Companion.getLauncher(context);
+        mDragLayer = mLauncher.getDragLayer();
+        mDragLayerAlpha = mDragLayer.getAlphaProperty(ALPHA_INDEX_TRANSITIONS);
+        mHandler = new Handler(Looper.getMainLooper());
+        mIsRtl = Utilities.isRtl(mLauncher.getResources());
+        mDeviceProfile = mLauncher.getDeviceProfile();
+
+        Resources res = mLauncher.getResources();
+        mContentTransY = res.getDimensionPixelSize(R.dimen.content_trans_y);
+        mWorkspaceTransY = res.getDimensionPixelSize(R.dimen.workspace_trans_y);
+        mClosingWindowTransY = res.getDimensionPixelSize(R.dimen.closing_window_trans_y);
+
+        mLauncher.addOnDeviceProfileChangeListener(this);
+        registerRemoteAnimations();
+    }
+
+    @Override
+    public void onDeviceProfileChanged(VariantDeviceProfile dp) {
+        mDeviceProfile = dp;
+    }
+
+    /**
+     * @return ActivityOptions with remote animations that controls how the window of the opening
+     * targets are displayed.
+     */
+    @Override
+    public ActivityOptions getActivityLaunchOptions(TestActivity launcher, View v) {
+        if (hasControlRemoteAppTransitionPermission()) {
+            boolean fromRecents = isLaunchingFromRecents(v, null /* targets */);
+            RemoteAnimationRunnerCompat runner = new LauncherAnimationRunner(
+                mHandler,
+                true /* startAtFrontOfQueue */
+            ) {
+
+                @Override
+                public void onCreateAnimation(
+                    RemoteAnimationTargetCompat[] targetCompats,
+                    AnimationResult result
+                ) {
+                    AnimatorSet anim = new AnimatorSet();
+
+                    boolean launcherClosing =
+                        launcherIsATargetWithMode(targetCompats, MODE_CLOSING);
+
+                    if (isLaunchingFromRecents(v, targetCompats)) {
+                        composeRecentsLaunchAnimator(anim, v, targetCompats, launcherClosing);
+                    } else {
+                        composeIconLaunchAnimator(anim, v, targetCompats, launcherClosing);
+                    }
+
+                    if (launcherClosing) {
+                        anim.addListener(mForceInvisibleListener);
+                    }
+
+                    result.setAnimation(anim);
+                }
+            };
+
+            // 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
+                : APP_LAUNCH_DURATION;
+
+            long statusBarTransitionDelay = duration - STATUS_BAR_TRANSITION_DURATION
+                - STATUS_BAR_TRANSITION_PRE_DELAY;
+            return ActivityOptionsCompat.makeRemoteAnimation(new RemoteAnimationAdapterCompat(
+                runner, duration, statusBarTransitionDelay));
+        }
+        return super.getActivityLaunchOptions(launcher, v);
+    }
+
+    /**
+     * 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
+     */
+    protected abstract boolean isLaunchingFromRecents(
+        @NonNull View v,
+        @Nullable RemoteAnimationTargetCompat[] targets
+    );
+
+    /**
+     * Composes the animations for a launch from the recents list.
+     *
+     * @param anim            the animator set to add to
+     * @param v               the launching view
+     * @param targets         the apps that are opening/closing
+     * @param launcherClosing true if the launcher app is closing
+     */
+    protected abstract void composeRecentsLaunchAnimator(
+        @NonNull AnimatorSet anim, @NonNull View v,
+        @NonNull RemoteAnimationTargetCompat[] targets, boolean launcherClosing
+    );
+
+    /**
+     * Compose the animations for a launch from the app icon.
+     *
+     * @param anim            the animation to add to
+     * @param v               the launching view with the icon
+     * @param targets         the list of opening/closing apps
+     * @param launcherClosing true if launcher is closing
+     */
+    private void composeIconLaunchAnimator(
+        @NonNull AnimatorSet anim, @NonNull View v,
+        @NonNull RemoteAnimationTargetCompat[] targets, boolean launcherClosing
+    ) {
+        // Set the state animation first so that any state listeners are called
+        // before our internal listeners.
+        mLauncher.getStateManager().setCurrentAnimation(anim);
+
+        Rect windowTargetBounds = getWindowTargetBounds(targets);
+        boolean isAllOpeningTargetTrs = true;
+        for (int i = 0; i < targets.length; i++) {
+            RemoteAnimationTargetCompat target = targets[i];
+            if (target.mode == MODE_OPENING) {
+                isAllOpeningTargetTrs &= target.isTranslucent;
+            }
+            if (!isAllOpeningTargetTrs) break;
+        }
+        anim.play(getOpeningWindowAnimators(v, targets, windowTargetBounds,
+            !isAllOpeningTargetTrs
+        ));
+        if (launcherClosing) {
+            Pair<AnimatorSet, Runnable> launcherContentAnimator =
+                getLauncherContentAnimator(true /* isAppOpening */,
+                    new float[]{0, -mContentTransY});
+            anim.play(launcherContentAnimator.first);
+            anim.addListener(new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    launcherContentAnimator.second.run();
+                }
+            });
+        }
+    }
+
+    /**
+     * 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
+     * figure out where the floating view should animate to.
+     */
+    private Rect getWindowTargetBounds(RemoteAnimationTargetCompat[] targets) {
+        Rect bounds = new Rect(0, 0, mDeviceProfile.getWidthPx(), mDeviceProfile.getHeightPx());
+        if (mLauncher.isInMultiWindowMode()) {
+            for (RemoteAnimationTargetCompat target : targets) {
+                if (target.mode == MODE_OPENING) {
+                    bounds.set(target.sourceContainerBounds);
+                    bounds.offsetTo(target.position.x, target.position.y);
+                    return bounds;
+                }
+            }
+        }
+        return bounds;
+    }
+
+    public void setRemoteAnimationProvider(
+        final RemoteAnimationProvider animationProvider,
+        CancellationSignal cancellationSignal
+    ) {
+        mRemoteAnimationProvider = animationProvider;
+        cancellationSignal.setOnCancelListener(() -> {
+            if (animationProvider == mRemoteAnimationProvider) {
+                mRemoteAnimationProvider = null;
+            }
+        });
+    }
+
+    /**
+     * 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.
+     * @param trans        Array that contains the start and end translation values for the content.
+     */
+    private Pair<AnimatorSet, Runnable> getLauncherContentAnimator(
+        boolean isAppOpening,
+        float[] trans
+    ) {
+        AnimatorSet launcherAnimator = new AnimatorSet();
+        Runnable endListener;
+
+        float[] alphas = isAppOpening
+            ? new float[]{1, 0}
+            : new float[]{0, 1};
+
+
+            mDragLayerAlpha.setValue(alphas[0]);
+            ObjectAnimator alpha =
+                ObjectAnimator.ofFloat(mDragLayerAlpha, MultiValueAlpha.VALUE, alphas);
+            alpha.setDuration(CONTENT_ALPHA_DURATION);
+            alpha.setInterpolator(LINEAR);
+            launcherAnimator.play(alpha);
+
+            mDragLayer.setTranslationY(trans[0]);
+            ObjectAnimator transY = ObjectAnimator.ofFloat(mDragLayer, View.TRANSLATION_Y, trans);
+            transY.setInterpolator(AGGRESSIVE_EASE);
+            transY.setDuration(CONTENT_TRANSLATION_DURATION);
+            launcherAnimator.play(transY);
+
+            // Pause page indicator animations as they lead to layer trashing.
+
+            //TODO: DO it later.
+            //mLauncher.getLauncherPagedView().getPageIndicator().pauseAnimations();
+            mDragLayer.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+
+            endListener = this::resetContentView;
+        return new Pair<>(launcherAnimator, endListener);
+    }
+
+    /**
+     * 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
+     * @param trans  the translation Y values to animator to over time
+     * @return listener to run when the animation ends
+     */
+    protected abstract Runnable composeViewContentAnimator(
+        @NonNull AnimatorSet anim,
+        float[] alphas, float[] trans
+    );
+
+    /**
+     * @return Animator that controls the window of the opening targets.
+     */
+    private ValueAnimator getOpeningWindowAnimators(
+        View v, RemoteAnimationTargetCompat[] targets,
+        Rect windowTargetBounds, boolean toggleVisibility
+    ) {
+        Rect bounds = new Rect();
+        if (v instanceof IconTextView) {
+            bounds.set(((IconTextView) v).getIconBounds());
+        } else {
+            mDragLayer.getDescendantRectRelativeToSelf(v, bounds);
+        }
+        int[] floatingViewBounds = new int[2];
+
+        Rect crop = new Rect();
+        Matrix matrix = new Matrix();
+
+        RemoteAnimationTargetSet openingTargets = new RemoteAnimationTargetSet(
+            targets,
+            MODE_OPENING
+        );
+        SyncRtSurfaceTransactionApplierCompat surfaceApplier =
+            new SyncRtSurfaceTransactionApplierCompat(v);
+        openingTargets.addDependentTransactionApplier(surfaceApplier);
+
+        // Scale the app icon to take up the entire screen. This simplifies the math when
+        // animating the app window position / scale.
+        float smallestSize = Math.min(windowTargetBounds.height(), windowTargetBounds.width());
+        float maxScaleX = smallestSize / bounds.width();
+        float maxScaleY = smallestSize / bounds.height();
+        float scale = Math.max(maxScaleX, maxScaleY);
+        float startScale = 1f;
+        /*if (v instanceof IconTextView && !(v.getParent() instanceof DeepShortcutView)) {
+            Drawable dr = ((IconTextView) v).getIcon();
+            if (dr instanceof FastBitmapDrawable) {
+                startScale = ((FastBitmapDrawable) dr).getAnimatedScale();
+            }
+        }*/
+        final float initialStartScale = startScale;
+
+        int[] dragLayerBounds = new int[2];
+        mDragLayer.getLocationOnScreen(dragLayerBounds);
+
+        // Animate the app icon to the center of the window bounds in screen coordinates.
+        float centerX = windowTargetBounds.centerX() - dragLayerBounds[0];
+        float centerY = windowTargetBounds.centerY() - dragLayerBounds[1];
+
+        float dX = centerX - bounds.centerX();
+        float dY = centerY - bounds.centerY();
+
+        boolean useUpwardAnimation = bounds.top > centerY
+            || Math.abs(dY) < mLauncher.getDeviceProfile().getCellHeightPx();
+        final long xDuration = useUpwardAnimation ? APP_LAUNCH_CURVED_DURATION
+            : APP_LAUNCH_DOWN_DURATION;
+        final long yDuration = useUpwardAnimation ? APP_LAUNCH_DURATION
+            : APP_LAUNCH_DOWN_CURVED_DURATION;
+        final long alphaDuration = useUpwardAnimation ? APP_LAUNCH_ALPHA_DURATION
+            : APP_LAUNCH_ALPHA_DOWN_DURATION;
+
+        RectF targetBounds = new RectF(windowTargetBounds);
+        RectF currentBounds = new RectF();
+        RectF temp = new RectF();
+
+        ValueAnimator appAnimator = ValueAnimator.ofFloat(0, 1);
+        appAnimator.setDuration(APP_LAUNCH_DURATION);
+        appAnimator.setInterpolator(LINEAR);
+        appAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                if (v instanceof IconTextView) {
+                    ((IconTextView) v).setStayPressed(false);
+                }
+                openingTargets.release();
+            }
+        });
+
+        float shapeRevealDuration = APP_LAUNCH_DURATION;
+
+        final float startCrop;
+        final float endCrop;
+        // TODO: May enable when supporting landscape
+        /*if (mDeviceProfile.isVerticalBarLayout()) {
+            startCrop = windowTargetBounds.height();
+            endCrop = windowTargetBounds.width();
+        } else {
+            startCrop = windowTargetBounds.width();
+            endCrop = windowTargetBounds.height();
+        }*/
+
+        startCrop = windowTargetBounds.width();
+        endCrop = windowTargetBounds.height();
+
+        final float initialWindowRadius = supportsRoundedCornersOnWindows(mLauncher.getResources())
+            ? startCrop / 2f : 0f;
+        final float windowRadius = mDeviceProfile.isMultiWindowMode
+            ? 0 : getWindowCornerRadius(mLauncher.getResources());
+        appAnimator.addUpdateListener(new MultiValueUpdateListener() {
+            FloatProp mDx = new FloatProp(0, dX, 0, xDuration, AGGRESSIVE_EASE);
+            FloatProp mDy = new FloatProp(0, dY, 0, yDuration, AGGRESSIVE_EASE);
+            FloatProp mIconScale = new FloatProp(initialStartScale, scale, 0, APP_LAUNCH_DURATION,
+                EXAGGERATED_EASE
+            );
+            FloatProp mIconAlpha = new FloatProp(1f, 0f, APP_LAUNCH_ALPHA_START_DELAY,
+                alphaDuration, LINEAR
+            );
+            FloatProp mCroppedSize = new FloatProp(startCrop, endCrop, 0, CROP_DURATION,
+                EXAGGERATED_EASE
+            );
+            FloatProp mWindowRadius = new FloatProp(initialWindowRadius, windowRadius, 0,
+                RADIUS_DURATION, EXAGGERATED_EASE
+            );
+
+            @Override
+            public void onUpdate(float percent) {
+                // Calculate app icon size.
+                float iconWidth = bounds.width() * mIconScale.value;
+                float iconHeight = bounds.height() * mIconScale.value;
+
+                // Animate the window crop so that it starts off as a square.
+                final int windowWidth;
+                final int windowHeight;
+
+                // TODO: later
+                /*if (mDeviceProfile.isVerticalBarLayout()) {
+                    windowWidth = (int) mCroppedSize.value;
+                    windowHeight = windowTargetBounds.height();
+                } else {
+                    windowWidth = windowTargetBounds.width();
+                    windowHeight = (int) mCroppedSize.value;
+                }*/
+                windowWidth = windowTargetBounds.width();
+                windowHeight = (int) mCroppedSize.value;
+                crop.set(0, 0, windowWidth, windowHeight);
+
+                // Scale the app window to match the icon size.
+                float scaleX = iconWidth / windowWidth;
+                float scaleY = iconHeight / windowHeight;
+                float scale = Math.min(1f, Math.max(scaleX, scaleY));
+
+                float scaledWindowWidth = windowWidth * scale;
+                float scaledWindowHeight = windowHeight * scale;
+
+                float offsetX = (scaledWindowWidth - iconWidth) / 2;
+                float offsetY = (scaledWindowHeight - iconHeight) / 2;
+
+                // Calculate the window position
+                temp.set(bounds);
+                temp.offset(dragLayerBounds[0], dragLayerBounds[1]);
+                temp.offset(mDx.value, mDy.value);
+                Utilities.scaleRectFAboutCenter(temp, mIconScale.value);
+                float transX0 = temp.left - offsetX;
+                float transY0 = temp.top - offsetY;
+
+                float croppedHeight = (windowTargetBounds.height() - crop.height()) * scale;
+                float croppedWidth = (windowTargetBounds.width() - crop.width()) * scale;
+                SurfaceParams[] params = new SurfaceParams[targets.length];
+                for (int i = targets.length - 1; i >= 0; i--) {
+                    RemoteAnimationTargetCompat target = targets[i];
+                    Rect targetCrop;
+                    final float alpha;
+                    final float cornerRadius;
+                    if (target.mode == MODE_OPENING) {
+                        matrix.setScale(scale, scale);
+                        matrix.postTranslate(transX0, transY0);
+                        targetCrop = crop;
+                        alpha = 1f - mIconAlpha.value;
+                        cornerRadius = mWindowRadius.value;
+                        matrix.mapRect(currentBounds, targetBounds);
+                        // TODO: Later
+                        /*if (mDeviceProfile.isVerticalBarLayout()) {
+                            currentBounds.right -= croppedWidth;
+                        } else {
+                            currentBounds.bottom -= croppedHeight;
+                        }*/
+                        currentBounds.bottom -= croppedHeight;
+                        v.setAlpha(alpha);
+                    } else {
+                        matrix.setTranslate(target.position.x, target.position.y);
+                        targetCrop = target.sourceContainerBounds;
+                        alpha = 1f;
+                        cornerRadius = 0;
+                    }
+
+                    params[i] = new SurfaceParams(target.leash, alpha, matrix, targetCrop,
+                        RemoteAnimationProvider.getLayer(target, MODE_OPENING),
+                        cornerRadius
+                    );
+                }
+                surfaceApplier.scheduleApply(params);
+            }
+        });
+        return appAnimator;
+    }
+
+    /**
+     * Registers remote animations used when closing apps to home screen.
+     */
+    private void registerRemoteAnimations() {
+        // Unregister this
+        if (hasControlRemoteAppTransitionPermission()) {
+            RemoteAnimationDefinitionCompat definition = new RemoteAnimationDefinitionCompat();
+            definition.addRemoteAnimation(
+                WindowManagerWrapper.TRANSIT_WALLPAPER_OPEN,
+                WindowManagerWrapper.ACTIVITY_TYPE_STANDARD,
+                new RemoteAnimationAdapterCompat(getWallpaperOpenRunner(false /* fromUnlock */),
+                    CLOSING_TRANSITION_DURATION_MS, 0 /* statusBarTransitionDelay */
+                )
+            );
+            new ActivityCompat(mLauncher).registerRemoteAnimations(definition);
+        }
+    }
+
+    private boolean launcherIsATargetWithMode(RemoteAnimationTargetCompat[] targets, int mode) {
+        return TaskUtils.taskIsATargetWithMode(targets, mLauncher.getTaskId(), mode);
+    }
+
+    /**
+     * @return Runner that plays when user goes to Launcher
+     * ie. pressing home, swiping up from nav bar.
+     */
+    RemoteAnimationRunnerCompat getWallpaperOpenRunner(boolean fromUnlock) {
+        return new WallpaperOpenLauncherAnimationRunner(mHandler, false /* startAtFrontOfQueue */,
+            fromUnlock);
+    }
+
+    /**
+     * Animator that controls the transformations of the windows when unlocking the device.
+     */
+    private Animator getUnlockWindowAnimator(RemoteAnimationTargetCompat[] targets) {
+        SyncRtSurfaceTransactionApplierCompat surfaceApplier =
+            new SyncRtSurfaceTransactionApplierCompat(mDragLayer);
+        ValueAnimator unlockAnimator = ValueAnimator.ofFloat(0, 1);
+        unlockAnimator.setDuration(CLOSING_TRANSITION_DURATION_MS);
+        float cornerRadius = mDeviceProfile.isMultiWindowMode ? 0 :
+            QuickStepContract.getWindowCornerRadius(mLauncher.getResources());
+        unlockAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationStart(Animator animation) {
+                SurfaceParams[] params = new SurfaceParams[targets.length];
+                for (int i = targets.length - 1; i >= 0; i--) {
+                    RemoteAnimationTargetCompat target = targets[i];
+                    params[i] = new SurfaceParams(target.leash, 1f, null,
+                        target.sourceContainerBounds,
+                        RemoteAnimationProvider.getLayer(target, MODE_OPENING), cornerRadius
+                    );
+                }
+                surfaceApplier.scheduleApply(params);
+            }
+        });
+        return unlockAnimator;
+    }
+
+    /**
+     * Animator that controls the transformations of the windows the targets that are closing.
+     */
+    private Animator getClosingWindowAnimators(RemoteAnimationTargetCompat[] targets) {
+        SyncRtSurfaceTransactionApplierCompat surfaceApplier =
+            new SyncRtSurfaceTransactionApplierCompat(mDragLayer);
+        Matrix matrix = new Matrix();
+        ValueAnimator closingAnimator = ValueAnimator.ofFloat(0, 1);
+        int duration = CLOSING_TRANSITION_DURATION_MS;
+        float windowCornerRadius = mDeviceProfile.isMultiWindowMode
+            ? 0 : getWindowCornerRadius(mLauncher.getResources());
+        closingAnimator.setDuration(duration);
+        closingAnimator.addUpdateListener(new MultiValueUpdateListener() {
+            FloatProp mDy = new FloatProp(0, mClosingWindowTransY, 0, duration, DEACCEL_1_7);
+            FloatProp mScale = new FloatProp(1f, 1f, 0, duration, DEACCEL_1_7);
+            FloatProp mAlpha = new FloatProp(1f, 0f, 25, 125, LINEAR);
+
+            @Override
+            public void onUpdate(float percent) {
+                SurfaceParams[] params = new SurfaceParams[targets.length];
+                for (int i = targets.length - 1; i >= 0; i--) {
+                    RemoteAnimationTargetCompat target = targets[i];
+                    final float alpha;
+                    final float cornerRadius;
+                    if (target.mode == MODE_CLOSING) {
+                        matrix.setScale(mScale.value, mScale.value,
+                            target.sourceContainerBounds.centerX(),
+                            target.sourceContainerBounds.centerY()
+                        );
+                        matrix.postTranslate(0, mDy.value);
+                        matrix.postTranslate(target.position.x, target.position.y);
+                        alpha = mAlpha.value;
+                        cornerRadius = windowCornerRadius;
+                    } else {
+                        matrix.setTranslate(target.position.x, target.position.y);
+                        alpha = 1f;
+                        cornerRadius = 0f;
+                    }
+                    params[i] = new SurfaceParams(target.leash, alpha, matrix,
+                        target.sourceContainerBounds,
+                        RemoteAnimationProvider.getLayer(target, MODE_CLOSING),
+                        cornerRadius
+                    );
+                }
+                surfaceApplier.scheduleApply(params);
+            }
+        });
+
+        return closingAnimator;
+    }
+
+    /**
+     * Creates an animator that modifies Launcher as a result from {@link #getWallpaperOpenRunner}.
+     */
+    private void createLauncherResumeAnimation(AnimatorSet anim) {
+
+        AnimatorSet workspaceAnimator = new AnimatorSet();
+
+        mDragLayer.setTranslationY(-mWorkspaceTransY);
+        ;
+        workspaceAnimator.play(ObjectAnimator.ofFloat(mDragLayer, View.TRANSLATION_Y,
+            -mWorkspaceTransY, 0
+        ));
+
+        mDragLayerAlpha.setValue(0);
+        workspaceAnimator.play(ObjectAnimator.ofFloat(
+            mDragLayerAlpha, MultiValueAlpha.VALUE, 0, 1f));
+
+        workspaceAnimator.setStartDelay(LAUNCHER_RESUME_START_DELAY);
+        workspaceAnimator.setDuration(333);
+        workspaceAnimator.setInterpolator(DEACCEL_1_7);
+
+        // Pause page indicator animations as they lead to layer trashing.
+        //mLauncher.getLauncherPagedView().getPageIndicator().pauseAnimations();
+        mDragLayer.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+
+        workspaceAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                resetContentView();
+            }
+        });
+        anim.play(workspaceAnimator);
+    }
+
+    private void resetContentView() {
+        //mLauncher.getLauncherPagedView().getPageIndicator().skipAnimationsToEnd();
+        mDragLayerAlpha.setValue(1f);
+        mDragLayer.setLayerType(View.LAYER_TYPE_NONE, null);
+        mDragLayer.setTranslationY(0f);
+    }
+
+    private boolean hasControlRemoteAppTransitionPermission() {
+        return mLauncher.checkSelfPermission(CONTROL_REMOTE_APP_TRANSITION_PERMISSION)
+            == PackageManager.PERMISSION_GRANTED;
+    }
+
+    /**
+     * Remote animation runner for animation from the app to Launcher, including recents.
+     */
+    class WallpaperOpenLauncherAnimationRunner extends LauncherAnimationRunner {
+        private final boolean mFromUnlock;
+
+        public WallpaperOpenLauncherAnimationRunner(
+            Handler handler, boolean startAtFrontOfQueue,
+            boolean fromUnlock
+        ) {
+            super(handler, startAtFrontOfQueue);
+            mFromUnlock = fromUnlock;
+        }
+
+        @Override
+        public void onCreateAnimation(
+            RemoteAnimationTargetCompat[] targetCompats,
+            AnimationResult result
+        ) {
+            if (!mLauncher.hasBeenResumed()) {
+                // If launcher is not resumed, wait until new async-frame after resume
+                mLauncher.addOnResumeCallback(() ->
+                    postAsyncCallback(mHandler, () ->
+                        onCreateAnimation(targetCompats, result)));
+                return;
+            }
+
+            AnimatorSet anim = null;
+            RemoteAnimationProvider provider = mRemoteAnimationProvider;
+            if (provider != null) {
+                anim = provider.createWindowAnimation(targetCompats);
+            }
+
+            if (anim == null) {
+                anim = new AnimatorSet();
+                anim.play(mFromUnlock
+                    ? getUnlockWindowAnimator(targetCompats)
+                    : getClosingWindowAnimators(targetCompats));
+
+                // Normally, we run the launcher content animation when we are transitioning
+                // home, but if home is already visible, then we don't want to animate the
+                // contents of launcher unless we know that we are animating home as a result
+                // of the home button press with quickstep, which will result in launcher being
+                // started on touch down, prior to the animation home (and won't be in the
+                // 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 (launcherIsATargetWithMode(targetCompats, MODE_OPENING)
+                    || mLauncher.isForceInvisible()) {
+                    // Only register the content animation for cancellation when state changes
+                    mLauncher.getStateManager().setCurrentAnimation(anim);
+                    if (mFromUnlock) {
+                        Pair<AnimatorSet, Runnable> contentAnimator =
+                            getLauncherContentAnimator(false /* isAppOpening */,
+                                new float[]{mContentTransY, 0});
+                        contentAnimator.first.setStartDelay(0);
+                        anim.play(contentAnimator.first);
+                        anim.addListener(new AnimatorListenerAdapter() {
+                            @Override
+                            public void onAnimationEnd(Animator animation) {
+                                contentAnimator.second.run();
+                            }
+                        });
+                    } else {
+                        createLauncherResumeAnimation(anim);
+                    }
+                }
+            }
+
+            mLauncher.clearForceInvisibleFlag(INVISIBLE_ALL);
+            result.setAnimation(anim);
+        }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/proxy/ProxyActivityStarter.java b/app/src/quickstep/src/foundation/e/blisslauncher/proxy/ProxyActivityStarter.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d8155567531f124b7d4b3cea52fdebf28caeffe
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/proxy/ProxyActivityStarter.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.proxy;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentSender.SendIntentException;
+import android.os.Bundle;
+import android.util.Log;
+
+public class ProxyActivityStarter extends Activity {
+
+    private static final String TAG = "ProxyActivityStarter";
+
+    public static final String EXTRA_PARAMS = "start-activity-params";
+
+    private StartActivityParams mParams;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setVisible(false);
+
+        mParams = getIntent().getParcelableExtra(EXTRA_PARAMS);
+        if (mParams == null) {
+            Log.d(TAG, "Proxy activity started without params");
+            finishAndRemoveTask();
+            return;
+        }
+
+        if (savedInstanceState != null) {
+            // Already started the activity. Just wait for the result.
+            return;
+        }
+
+        if (mParams.intent != null) {
+            startActivityForResult(mParams.intent, mParams.requestCode, mParams.options);
+            return;
+        } else if (mParams.intentSender != null) {
+            try {
+                startIntentSenderForResult(mParams.intentSender, mParams.requestCode,
+                        mParams.fillInIntent, mParams.flagsMask, mParams.flagsValues,
+                        mParams.extraFlags,
+                        mParams.options);
+                return;
+            } catch (SendIntentException e) {
+                mParams.deliverResult(this, RESULT_CANCELED, null);
+            }
+        }
+        finishAndRemoveTask();
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (requestCode == mParams.requestCode) {
+            mParams.deliverResult(this, resultCode, data);
+        }
+        finishAndRemoveTask();
+    }
+
+    public static Intent getLaunchIntent(Context context, StartActivityParams params) {
+        return new Intent(context, ProxyActivityStarter.class)
+                .putExtra(EXTRA_PARAMS, params)
+                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED
+                        | Intent.FLAG_ACTIVITY_CLEAR_TASK);
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/proxy/StartActivityParams.java b/app/src/quickstep/src/foundation/e/blisslauncher/proxy/StartActivityParams.java
new file mode 100644
index 0000000000000000000000000000000000000000..008ed148a8c6650608db9d1b1ae4879dce994587
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/proxy/StartActivityParams.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.proxy;
+
+import android.app.Activity;
+import android.app.PendingIntent;
+import android.app.PendingIntent.CanceledException;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.Log;
+
+public class StartActivityParams implements Parcelable {
+
+    private static final String TAG = "StartActivityParams";
+
+    private final PendingIntent mPICallback;
+    public final int requestCode;
+
+    public Intent intent;
+
+    public IntentSender intentSender;
+    public Intent fillInIntent;
+    public int flagsMask;
+    public int flagsValues;
+    public int extraFlags;
+    public Bundle options;
+
+    public StartActivityParams(Activity activity, int requestCode) {
+        this(activity.createPendingResult(requestCode, new Intent(),
+                PendingIntent.FLAG_ONE_SHOT | PendingIntent.FLAG_UPDATE_CURRENT), requestCode);
+    }
+
+    public StartActivityParams(PendingIntent pendingIntent, int requestCode) {
+        this.mPICallback = pendingIntent;
+        this.requestCode = requestCode;
+    }
+
+    private StartActivityParams(Parcel parcel) {
+        mPICallback = parcel.readTypedObject(PendingIntent.CREATOR);
+        requestCode = parcel.readInt();
+        intent = parcel.readTypedObject(Intent.CREATOR);
+
+        intentSender = parcel.readTypedObject(IntentSender.CREATOR);
+        fillInIntent = parcel.readTypedObject(Intent.CREATOR);
+        flagsMask = parcel.readInt();
+        flagsValues = parcel.readInt();
+        extraFlags = parcel.readInt();
+        options = parcel.readBundle();
+    }
+
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel parcel, int flags) {
+        parcel.writeTypedObject(mPICallback, flags);
+        parcel.writeInt(requestCode);
+        parcel.writeTypedObject(intent, flags);
+
+        parcel.writeTypedObject(intentSender, flags);
+        parcel.writeTypedObject(fillInIntent, flags);
+        parcel.writeInt(flagsMask);
+        parcel.writeInt(flagsValues);
+        parcel.writeInt(extraFlags);
+        parcel.writeBundle(options);
+    }
+
+    public void deliverResult(Context context, int resultCode, Intent data) {
+        try {
+            if (mPICallback != null) {
+                mPICallback.send(context, resultCode, data);
+            }
+        } catch (CanceledException e) {
+            Log.e(TAG, "Unable to send back result", e);
+        }
+    }
+
+    public static final Creator<StartActivityParams> CREATOR =
+            new Creator<StartActivityParams>() {
+                public StartActivityParams createFromParcel(Parcel source) {
+                    return new StartActivityParams(source);
+                }
+
+                public StartActivityParams[] newArray(int size) {
+                    return new StartActivityParams[size];
+                }
+            };
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/ActivityControlHelper.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/ActivityControlHelper.java
new file mode 100644
index 0000000000000000000000000000000000000000..fdcf784731f7769c247d9dff3ce892e7e01d1e08
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/ActivityControlHelper.java
@@ -0,0 +1,152 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.Region;
+import android.os.Build;
+import android.os.Handler;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.animation.Interpolator;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.UiThread;
+
+import foundation.e.blisslauncher.quickstep.util.RemoteAnimationProvider;
+import foundation.e.blisslauncher.quickstep.util.RemoteAnimationTargetSet;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+
+import java.util.function.BiPredicate;
+import java.util.function.Consumer;
+
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+
+/**
+ * Utility class which abstracts out the logical differences between Launcher and RecentsActivity.
+ */
+@TargetApi(Build.VERSION_CODES.P)
+public interface ActivityControlHelper<T extends BaseDraggingActivity> {
+
+    void onTransitionCancelled(T activity, boolean activityVisible);
+
+    int getSwipeUpDestinationAndLength(VariantDeviceProfile dp, Context context, Rect outRect);
+
+    void onSwipeUpToRecentsComplete(T activity);
+
+    default void onSwipeUpToHomeComplete(T activity) { }
+    void onAssistantVisibilityChanged(float visibility);
+
+    @NonNull HomeAnimationFactory prepareHomeUI(T activity);
+
+    AnimationFactory prepareRecentsUI(T activity, boolean activityVisible,
+            boolean animateActivity, Consumer<AnimatorPlaybackController> callback);
+
+    ActivityInitListener createActivityInitListener(BiPredicate<T, Boolean> onInitListener);
+
+    @Nullable
+    T getCreatedActivity();
+
+    default boolean isResumed() {
+        BaseDraggingActivity activity = getCreatedActivity();
+        return activity != null && activity.hasBeenResumed();
+    }
+
+    @UiThread
+    @Nullable
+    <T extends View> T getVisibleRecentsView();
+
+    @UiThread
+    boolean switchToRecentsIfVisible(Runnable onCompleteCallback);
+
+    Rect getOverviewWindowBounds(Rect homeBounds, RemoteAnimationTargetCompat target);
+
+    boolean shouldMinimizeSplitScreen();
+
+    default boolean deferStartingActivity(Region activeNavBarRegion, MotionEvent ev) {
+        return true;
+    }
+
+    boolean isInLiveTileMode();
+
+    void onLaunchTaskFailed(T activity);
+
+    void onLaunchTaskSuccess(T activity);
+
+    interface ActivityInitListener {
+
+        void register();
+
+        void unregister();
+
+        void registerAndStartActivity(Intent intent, RemoteAnimationProvider animProvider,
+                Context context, Handler handler, long duration);
+    }
+
+    interface AnimationFactory {
+
+        enum ShelfAnimState {
+            HIDE(true), PEEK(true), OVERVIEW(false), CANCEL(false);
+
+            ShelfAnimState(boolean shouldPreformHaptic) {
+                this.shouldPreformHaptic = shouldPreformHaptic;
+            }
+
+            public final boolean shouldPreformHaptic;
+        }
+
+        default void onRemoteAnimationReceived(RemoteAnimationTargetSet targets) { }
+
+        void createActivityController(long transitionLength);
+
+        default void adjustActivityControllerInterpolators() { }
+
+        default void onTransitionCancelled() { }
+
+        default void setShelfState(ShelfAnimState animState, Interpolator interpolator,
+                long duration) { }
+
+        /**
+         * @param attached Whether to show RecentsView alongside the app window. If false, recents
+         *                 will be hidden by some property we can animate, e.g. alpha.
+         * @param animate Whether to animate recents to/from its new attached state.
+         */
+        default void setRecentsAttachedToAppWindow(boolean attached, boolean animate) { }
+    }
+
+    interface HomeAnimationFactory {
+
+        /** Return the floating view that will animate in sync with the closing window. */
+        default @Nullable View getFloatingView() {
+            return null;
+        }
+
+        @NonNull RectF getWindowTargetRect();
+
+        @NonNull AnimatorPlaybackController createActivityAnimationToHome();
+
+        default void playAtomicAnimation(float velocity) {
+            // No-op
+        }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/AnimatedFloat.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/AnimatedFloat.java
new file mode 100644
index 0000000000000000000000000000000000000000..6604dabd1246a66f594e704cb9a96c4dd62ab80f
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/AnimatedFloat.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foundation.e.blisslauncher.quickstep;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.util.FloatProperty;
+
+/**
+ * A mutable float which allows animating the value
+ */
+public class AnimatedFloat {
+
+    public static FloatProperty<AnimatedFloat> VALUE = new FloatProperty<AnimatedFloat>("value") {
+        @Override
+        public void setValue(AnimatedFloat obj, float v) {
+            obj.updateValue(v);
+        }
+
+        @Override
+        public Float get(AnimatedFloat obj) {
+            return obj.value;
+        }
+    };
+
+    private final Runnable mUpdateCallback;
+    private ObjectAnimator mValueAnimator;
+
+    public float value;
+
+    public AnimatedFloat(Runnable updateCallback) {
+        mUpdateCallback = updateCallback;
+    }
+
+    public ObjectAnimator animateToValue(float start, float end) {
+        cancelAnimation();
+        mValueAnimator = ObjectAnimator.ofFloat(this, VALUE, start, end);
+        mValueAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animator) {
+                if (mValueAnimator == animator) {
+                    mValueAnimator = null;
+                }
+            }
+        });
+        return mValueAnimator;
+    }
+
+    /**
+     * Changes the value and calls the callback.
+     * Note that the value can be directly accessed as well to avoid notifying the callback.
+     */
+    public void updateValue(float v) {
+        if (Float.compare(v, value) != 0) {
+            value = v;
+            mUpdateCallback.run();
+        }
+    }
+
+    public void cancelAnimation() {
+        if (mValueAnimator != null) {
+            mValueAnimator.cancel();
+        }
+    }
+
+    public void finishAnimation() {
+        if (mValueAnimator != null && mValueAnimator.isRunning()) {
+            mValueAnimator.end();
+        }
+    }
+
+    public ObjectAnimator getCurrentAnimation() {
+        return mValueAnimator;
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/BaseRecentsActivity.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/BaseRecentsActivity.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ce9471a417b95418cdfad93dede6f9735c46f99
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/BaseRecentsActivity.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep;
+
+import static android.content.pm.ActivityInfo.CONFIG_ORIENTATION;
+import static android.content.pm.ActivityInfo.CONFIG_SCREEN_SIZE;
+
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import foundation.e.blisslauncher.BlissLauncher;
+import foundation.e.blisslauncher.core.customviews.AbstractFloatingView;
+import foundation.e.blisslauncher.features.test.BaseDraggingActivity;
+import foundation.e.blisslauncher.features.test.SystemUiController;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.uioverrides.UiFactory;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+
+/**
+ * A base fallback recents activity that provides support for device profile changes, activity
+ * lifecycle tracking, and basic input handling from recents.
+ *
+ * This class is only used as a fallback in case the default launcher does not have a recents
+ * implementation.
+ */
+public abstract class BaseRecentsActivity extends BaseDraggingActivity {
+
+    private Configuration mOldConfig;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        mOldConfig = new Configuration(getResources().getConfiguration());
+        initDeviceProfile();
+        initViews();
+
+        getSystemUiController().updateUiState(
+            SystemUiController.UI_STATE_BASE_WINDOW,
+                false);
+        RecentsActivityTracker.onRecentsActivityCreate(this);
+    }
+
+    /**
+     * Init drag layer and overview panel views.
+     */
+    abstract protected void initViews();
+
+    @Override
+    public void onConfigurationChanged(Configuration newConfig) {
+        int diff = newConfig.diff(mOldConfig);
+        if ((diff & (CONFIG_ORIENTATION | CONFIG_SCREEN_SIZE)) != 0) {
+            onHandleConfigChanged();
+        }
+        mOldConfig.setTo(newConfig);
+        super.onConfigurationChanged(newConfig);
+    }
+
+    /**
+     * Logic for when device configuration changes (rotation, screen size change, multi-window,
+     * etc.)
+     */
+    protected void onHandleConfigChanged() {
+        initDeviceProfile();
+
+        AbstractFloatingView.closeOpenViews(this, true,
+                AbstractFloatingView.TYPE_ALL);
+        dispatchDeviceProfileChanged();
+
+        reapplyUi();
+    }
+
+    /**
+     * Initialize/update the device profile.
+     */
+    private void initDeviceProfile() {
+        mDeviceProfile = createDeviceProfile();
+        onDeviceProfileInitiated();
+    }
+
+    /**
+     * Generate the device profile to use in this activity.
+     * @return device profile
+     */
+    protected VariantDeviceProfile createDeviceProfile() {
+        VariantDeviceProfile dp = BlissLauncher.getApplication(this).getInvariantDeviceProfile().getDeviceProfile(this);
+
+        // In case we are reusing IDP, create a copy so that we don't conflict with Launcher
+        // activity.
+        return dp.copy(this);
+    }
+
+
+    @Override
+    protected void onStop() {
+        super.onStop();
+
+        // Workaround for b/78520668, explicitly trim memory once UI is hidden
+        onTrimMemory(TRIM_MEMORY_UI_HIDDEN);
+    }
+
+    @Override
+    public void onEnterAnimationComplete() {
+        super.onEnterAnimationComplete();
+        UiFactory.onEnterAnimationComplete(this);
+    }
+
+    @Override
+    public void onTrimMemory(int level) {
+        super.onTrimMemory(level);
+        UiFactory.onTrimMemory(this, level);
+    }
+
+    @Override
+    protected void onNewIntent(Intent intent) {
+        super.onNewIntent(intent);
+        RecentsActivityTracker.onRecentsActivityNewIntent(this);
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        RecentsActivityTracker.onRecentsActivityDestroy(this);
+    }
+
+    @Override
+    public void onBackPressed() {
+        // TODO: Launch the task we came from
+        startHome();
+    }
+
+    public void startHome() {
+        startActivity(new Intent(Intent.ACTION_MAIN)
+                .addCategory(Intent.CATEGORY_HOME)
+                .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
+    }
+
+    @Override
+    public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) {
+        super.dump(prefix, fd, writer, args);
+        writer.println(prefix + "Misc:");
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/HandlerRunnable.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/HandlerRunnable.java
new file mode 100644
index 0000000000000000000000000000000000000000..3305bd477404b31737c180988a0b233c97beb108
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/HandlerRunnable.java
@@ -0,0 +1,67 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.os.Handler;
+
+/**
+ * A runnable that can be posted to a {@link Handler} which can be canceled.
+ */
+public abstract class HandlerRunnable implements Runnable {
+
+    private final Handler mHandler;
+    private final Runnable mEndRunnable;
+
+    private boolean mEnded = false;
+    private boolean mCanceled = false;
+
+    public HandlerRunnable(Handler handler, Runnable endRunnable) {
+        mHandler = handler;
+        mEndRunnable = endRunnable;
+    }
+
+    /**
+     * Cancels this runnable from being run, only if it has not already run.
+     */
+    public void cancel() {
+        mHandler.removeCallbacks(this);
+        // TODO: This can actually cause onEnd to be called twice if the handler is already running
+        //       this runnable
+        // NOTE: This is currently run on whichever thread the caller is run on.
+        mCanceled = true;
+        onEnd();
+    }
+
+    /**
+     * @return whether this runnable was canceled.
+     */
+    protected boolean isCanceled() {
+        return mCanceled;
+    }
+
+    /**
+     * To be called by the implemention of this runnable. The end callback is done on whichever
+     * thread the caller is calling from.
+     */
+    public void onEnd() {
+        if (!mEnded) {
+            mEnded = true;
+            if (mEndRunnable != null) {
+                mEndRunnable.run();
+            }
+        }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/MainThreadInitializedObject.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/MainThreadInitializedObject.java
new file mode 100644
index 0000000000000000000000000000000000000000..729c7f37825c98182366f03f4cc2e0e47a92d06f
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/MainThreadInitializedObject.java
@@ -0,0 +1,67 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.content.Context;
+import android.os.Looper;
+
+import androidx.annotation.VisibleForTesting;
+
+import java.util.concurrent.ExecutionException;
+
+import foundation.e.blisslauncher.core.executors.MainThreadExecutor;
+
+/**
+ * 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 (mValue == null) {
+            if (Looper.myLooper() == Looper.getMainLooper()) {
+                mValue = mProvider.get(context.getApplicationContext());
+            } else {
+                try {
+                    return new MainThreadExecutor().submit(() -> get(context)).get();
+                } catch (InterruptedException|ExecutionException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+        return mValue;
+    }
+
+    public T getNoCreate() {
+        return mValue;
+    }
+
+    @VisibleForTesting
+    public void initializeForTesting(T value) {
+        mValue = value;
+    }
+
+    public interface ObjectProvider<T> {
+
+        T get(Context context);
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/NormalizedIconLoader.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/NormalizedIconLoader.java
new file mode 100644
index 0000000000000000000000000000000000000000..3752712c09588bde337cdf6d78713d4648d11481
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/NormalizedIconLoader.java
@@ -0,0 +1,81 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.annotation.TargetApi;
+import android.app.ActivityManager.TaskDescription;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.ActivityInfo;
+import android.content.res.Resources;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.os.UserHandle;
+import android.util.LruCache;
+import android.util.SparseArray;
+
+import com.android.systemui.shared.recents.model.IconLoader;
+import com.android.systemui.shared.recents.model.TaskKeyLruCache;
+
+import foundation.e.blisslauncher.BlissLauncher;
+import foundation.e.blisslauncher.core.IconsHandler;
+
+/**
+ * Extension of {@link IconLoader} with icon normalization support
+ */
+@TargetApi(Build.VERSION_CODES.O)
+public class NormalizedIconLoader extends IconLoader {
+
+    private final SparseArray<Drawable> mDefaultIcons = new SparseArray<>();
+
+    public NormalizedIconLoader(Context context, TaskKeyLruCache<Drawable> iconCache,
+            LruCache<ComponentName, ActivityInfo> activityInfoCache,
+            boolean disableColorExtraction) {
+        super(context, iconCache, activityInfoCache);
+    }
+
+    @Override
+    public Drawable getDefaultIcon(int userId) {
+        synchronized (mDefaultIcons) {
+            Drawable info = mDefaultIcons.get(userId);
+            if (info == null) {
+                info = getBitmapInfo(Resources.getSystem()
+                    .getDrawable(android.R.drawable.sym_def_app_icon), userId);
+                mDefaultIcons.put(userId, info);
+            }
+
+            return info;
+        }
+    }
+
+    @Override
+    protected Drawable createBadgedDrawable(Drawable drawable, int userId, TaskDescription desc) {
+        return getBitmapInfo(drawable, userId);
+    }
+
+    private synchronized Drawable getBitmapInfo(Drawable drawable, int userId) {
+        IconsHandler iconsHandler = BlissLauncher.getApplication(mContext).getIconsHandler();
+        return iconsHandler.getBadgedIcon(drawable, UserHandle.of(userId));
+    }
+
+    @Override
+    protected Drawable getBadgedActivityIcon(ActivityInfo activityInfo, int userId,
+            TaskDescription desc) {
+        return getBitmapInfo(
+            activityInfo.loadUnbadgedIcon(mContext.getPackageManager()),
+            userId);
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/OverviewCallbacks.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/OverviewCallbacks.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff9e275f3c704ea1337fa4dded4d381c8e51e30b
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/OverviewCallbacks.java
@@ -0,0 +1,44 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.content.Context;
+
+import foundation.e.blisslauncher.quickstep.util.ResourceBasedOverride;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.utils.Preconditions;
+
+/**
+ * Callbacks related to overview/quicksteps.
+ */
+public class OverviewCallbacks implements ResourceBasedOverride {
+
+    private static OverviewCallbacks sInstance;
+
+    public static OverviewCallbacks get(Context context) {
+        Preconditions.assertUIThread();
+        if (sInstance == null) {
+            sInstance = Overrides.getObject(OverviewCallbacks.class,
+                    context.getApplicationContext(), R.string.overview_callbacks_class);
+        }
+        return sInstance;
+    }
+
+    public void onInitOverviewTransition() { }
+
+    public void closeAllWindows() { }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/OverviewComponentObserver.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/OverviewComponentObserver.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f40b4b653c347dc3bc374067c00554237c8a0ff
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/OverviewComponentObserver.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep;
+
+import static android.content.Intent.ACTION_PACKAGE_ADDED;
+import static android.content.Intent.ACTION_PACKAGE_CHANGED;
+import static android.content.Intent.ACTION_PACKAGE_REMOVED;
+import static com.android.systemui.shared.system.PackageManagerWrapper.ACTION_PREFERRED_ACTIVITY_CHANGED;
+import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_HOME_DISABLED;
+import static foundation.e.blisslauncher.core.utils.PackageManagerHelper.getPackageFilter;
+
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.ResolveInfo;
+import com.android.systemui.shared.system.PackageManagerWrapper;
+import java.util.ArrayList;
+
+/**
+ * Class to keep track of the current overview component based off user preferences and app updates
+ * and provide callers the relevant classes.
+ */
+public final class OverviewComponentObserver {
+    private final BroadcastReceiver mUserPreferenceChangeReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            updateOverviewTargets();
+        }
+    };
+    private final BroadcastReceiver mOtherHomeAppUpdateReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            updateOverviewTargets();
+        }
+    };
+    private final Context mContext;
+    private final ComponentName mMyHomeComponent;
+    private String mUpdateRegisteredPackage;
+    private ActivityControlHelper mActivityControlHelper;
+    private Intent mOverviewIntent;
+    private Intent mHomeIntent;
+    private int mSystemUiStateFlags;
+    private boolean mIsHomeAndOverviewSame;
+
+    public OverviewComponentObserver(Context context) {
+        mContext = context;
+
+        Intent myHomeIntent = new Intent(Intent.ACTION_MAIN)
+                .addCategory(Intent.CATEGORY_HOME)
+                .setPackage(mContext.getPackageName());
+        ResolveInfo info = context.getPackageManager().resolveActivity(myHomeIntent, 0);
+        mMyHomeComponent = new ComponentName(context.getPackageName(), info.activityInfo.name);
+
+        mContext.registerReceiver(mUserPreferenceChangeReceiver,
+                new IntentFilter(ACTION_PREFERRED_ACTIVITY_CHANGED));
+        updateOverviewTargets();
+    }
+
+    public void onSystemUiStateChanged(int stateFlags) {
+        boolean homeDisabledChanged = (mSystemUiStateFlags & SYSUI_STATE_HOME_DISABLED)
+                != (stateFlags & SYSUI_STATE_HOME_DISABLED);
+        mSystemUiStateFlags = stateFlags;
+        if (homeDisabledChanged) {
+            updateOverviewTargets();
+        }
+    }
+
+    /**
+     * Update overview intent and {@link ActivityControlHelper} based off the current launcher home
+     * component.
+     */
+    private void updateOverviewTargets() {
+        ComponentName defaultHome = PackageManagerWrapper.getInstance()
+                .getHomeActivities(new ArrayList<>());
+
+        final String overviewIntentCategory;
+        ComponentName overviewComponent;
+        mHomeIntent = null;
+
+        if ((mSystemUiStateFlags & SYSUI_STATE_HOME_DISABLED) == 0 &&
+                (defaultHome == null || mMyHomeComponent.equals(defaultHome))) {
+            // User default home is same as out home app. Use Overview integrated in Launcher.
+            overviewComponent = mMyHomeComponent;
+            mActivityControlHelper = new LauncherActivityControllerHelper();
+            mIsHomeAndOverviewSame = true;
+            overviewIntentCategory = Intent.CATEGORY_HOME;
+
+            if (mUpdateRegisteredPackage != null) {
+                // Remove any update listener as we don't care about other packages.
+                mContext.unregisterReceiver(mOtherHomeAppUpdateReceiver);
+                mUpdateRegisteredPackage = null;
+            }
+        } else {
+            // The default home app is a different launcher. Use the fallback Overview instead.
+            overviewComponent = new ComponentName(mContext, RecentsActivity.class);
+            mActivityControlHelper = new FallbackActivityControllerHelper();
+            mIsHomeAndOverviewSame = false;
+            overviewIntentCategory = Intent.CATEGORY_DEFAULT;
+
+            mHomeIntent = new Intent(Intent.ACTION_MAIN)
+                    .addCategory(Intent.CATEGORY_HOME)
+                    .setComponent(defaultHome);
+            // User's default home app can change as a result of package updates of this app (such
+            // as uninstalling the app or removing the "Launcher" feature in an update).
+            // Listen for package updates of this app (and remove any previously attached
+            // package listener).
+            if (defaultHome == null) {
+                if (mUpdateRegisteredPackage != null) {
+                    mContext.unregisterReceiver(mOtherHomeAppUpdateReceiver);
+                }
+            } else if (!defaultHome.getPackageName().equals(mUpdateRegisteredPackage)) {
+                if (mUpdateRegisteredPackage != null) {
+                    mContext.unregisterReceiver(mOtherHomeAppUpdateReceiver);
+                }
+
+                mUpdateRegisteredPackage = defaultHome.getPackageName();
+                mContext.registerReceiver(mOtherHomeAppUpdateReceiver, getPackageFilter(
+                        mUpdateRegisteredPackage, ACTION_PACKAGE_ADDED, ACTION_PACKAGE_CHANGED,
+                        ACTION_PACKAGE_REMOVED));
+            }
+        }
+
+        mOverviewIntent = new Intent(Intent.ACTION_MAIN)
+                .addCategory(overviewIntentCategory)
+                .setComponent(overviewComponent)
+                .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        if (mHomeIntent == null) {
+            mHomeIntent = mOverviewIntent;
+        }
+    }
+
+    /**
+     * Clean up any registered receivers.
+     */
+    public void onDestroy() {
+        mContext.unregisterReceiver(mUserPreferenceChangeReceiver);
+
+        if (mUpdateRegisteredPackage != null) {
+            mContext.unregisterReceiver(mOtherHomeAppUpdateReceiver);
+            mUpdateRegisteredPackage = null;
+        }
+    }
+
+    /**
+     * Get the current intent for going to the overview activity.
+     *
+     * @return the overview intent
+     */
+    public Intent getOverviewIntent() {
+        return mOverviewIntent;
+    }
+
+    /**
+     * Get the current intent for going to the home activity.
+     */
+    public Intent getHomeIntent() {
+        return mHomeIntent;
+    }
+
+    /**
+     * Returns true if home and overview are same activity.
+     */
+    public boolean isHomeAndOverviewSame() {
+        return mIsHomeAndOverviewSame;
+    }
+
+    /**
+     * Get the current activity control helper for managing interactions to the overview activity.
+     *
+     * @return the current activity control helper
+     */
+    public ActivityControlHelper getActivityControlHelper() {
+        return mActivityControlHelper;
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/OverviewInteractionState.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/OverviewInteractionState.java
new file mode 100644
index 0000000000000000000000000000000000000000..52b2f1b47855606614f7361a7267945495d63ed8
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/OverviewInteractionState.java
@@ -0,0 +1,133 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Message;
+import android.os.RemoteException;
+import android.util.Log;
+
+import com.android.systemui.shared.recents.ISystemUiProxy;
+
+import androidx.annotation.WorkerThread;
+
+import foundation.e.blisslauncher.features.test.UiThreadHelper;
+
+/**
+ * Sets alpha for the back button
+ */
+public class OverviewInteractionState {
+
+    private static final String TAG = "OverviewFlags";
+
+    private static final String HAS_ENABLED_QUICKSTEP_ONCE = "launcher.has_enabled_quickstep_once";
+
+    // We do not need any synchronization for this variable as its only written on UI thread.
+    public static final MainThreadInitializedObject<OverviewInteractionState> INSTANCE =
+            new MainThreadInitializedObject<>(OverviewInteractionState::new);
+
+    private static final int MSG_SET_PROXY = 200;
+    private static final int MSG_SET_BACK_BUTTON_ALPHA = 201;
+
+    private final Context mContext;
+    private final Handler mUiHandler;
+    private final Handler mBgHandler;
+
+    // These are updated on the background thread
+    private ISystemUiProxy mISystemUiProxy;
+    private float mBackButtonAlpha = 1;
+
+    private int mSystemUiStateFlags;
+
+    private OverviewInteractionState(Context context) {
+        mContext = context;
+
+        // Data posted to the uihandler will be sent to the bghandler. Data is sent to uihandler
+        // because of its high send frequency and data may be very different than the previous value
+        // For example, send back alpha on uihandler to avoid flickering when setting its visibility
+        mUiHandler = new Handler(this::handleUiMessage);
+        mBgHandler = new Handler(UiThreadHelper.getBackgroundLooper(), this::handleBgMessage);
+
+        onNavigationModeChanged(SysUINavigationMode.INSTANCE.get(context)
+                .addModeChangeListener(this::onNavigationModeChanged));
+    }
+
+    public float getBackButtonAlpha() {
+        return mBackButtonAlpha;
+    }
+
+    public void setBackButtonAlpha(float alpha, boolean animate) {
+        if (!modeSupportsGestures()) {
+            alpha = 1;
+        }
+        mUiHandler.removeMessages(MSG_SET_BACK_BUTTON_ALPHA);
+        mUiHandler.obtainMessage(MSG_SET_BACK_BUTTON_ALPHA, animate ? 1 : 0, 0, alpha)
+                .sendToTarget();
+    }
+
+    public void setSystemUiProxy(ISystemUiProxy proxy) {
+        mBgHandler.obtainMessage(MSG_SET_PROXY, proxy).sendToTarget();
+    }
+
+    public void setSystemUiStateFlags(int stateFlags) {
+        mSystemUiStateFlags = stateFlags;
+    }
+
+    public int getSystemUiStateFlags() {
+        return mSystemUiStateFlags;
+    }
+
+    private boolean handleUiMessage(Message msg) {
+        if (msg.what == MSG_SET_BACK_BUTTON_ALPHA) {
+            mBackButtonAlpha = (float) msg.obj;
+        }
+        mBgHandler.obtainMessage(msg.what, msg.arg1, msg.arg2, msg.obj).sendToTarget();
+        return true;
+    }
+
+    private boolean handleBgMessage(Message msg) {
+        switch (msg.what) {
+            case MSG_SET_PROXY:
+                mISystemUiProxy = (ISystemUiProxy) msg.obj;
+                break;
+            case MSG_SET_BACK_BUTTON_ALPHA:
+                applyBackButtonAlpha((float) msg.obj, msg.arg1 == 1);
+                return true;
+        }
+        return true;
+    }
+
+    @WorkerThread
+    private void applyBackButtonAlpha(float alpha, boolean animate) {
+        if (mISystemUiProxy == null) {
+            return;
+        }
+        try {
+            mISystemUiProxy.setBackButtonAlpha(alpha, animate);
+        } catch (RemoteException e) {
+            Log.w(TAG, "Unable to update overview back button alpha", e);
+        }
+    }
+
+    private void onNavigationModeChanged(SysUINavigationMode.Mode mode) {
+        // TODO: may be update preference here.
+    }
+
+    private boolean modeSupportsGestures() {
+        return SysUINavigationMode.getMode(mContext).hasGestures;
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/QuickstepProcessInitializer.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/QuickstepProcessInitializer.java
new file mode 100644
index 0000000000000000000000000000000000000000..d269f6747c799caf735bf7ea8453c9e5017136dd
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/QuickstepProcessInitializer.java
@@ -0,0 +1,63 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.app.ActivityManager;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.UserManager;
+import android.util.Log;
+
+import com.android.systemui.shared.system.ThreadedRendererCompat;
+
+import foundation.e.blisslauncher.BuildConfig;
+
+@SuppressWarnings("unused")
+public class QuickstepProcessInitializer {
+
+    private static final String TAG = "QuickstepProcessInitializer";
+    private static final int HEAP_LIMIT_MB = 250;
+    private static final boolean IS_DEBUG_DEVICE = true;
+
+    public QuickstepProcessInitializer(Context context) { }
+
+    protected void init(Context context) {
+        if (IS_DEBUG_DEVICE) {
+            try {
+                // Trigger a heap dump if the PSS reaches beyond the target heap limit
+                final ActivityManager am = context.getSystemService(ActivityManager.class);
+                am.setWatchHeapLimit(HEAP_LIMIT_MB * 1024 * 1024);
+            } catch (SecurityException e) {
+                // Do nothing
+            }
+        }
+
+        // Workaround for b/120550382, an external app can cause the launcher process to start for
+        // a work profile user which we do not support. Disable the application immediately when we
+        // detect this to be the case.
+        UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE);
+        if (um.isManagedProfile()) {
+            PackageManager pm = context.getPackageManager();
+            pm.setApplicationEnabledSetting(context.getPackageName(),
+                    PackageManager.COMPONENT_ENABLED_STATE_DISABLED, 0 /* flags */);
+            Log.w(TAG, "Disabling " + BuildConfig.APPLICATION_ID
+                    + ", unable to run in a managed profile");
+            return;
+        }
+        // Elevate GPU priority for Quickstep and Remote animations.
+        ThreadedRendererCompat.setContextPriority(ThreadedRendererCompat.EGL_CONTEXT_PRIORITY_HIGH_IMG);
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/RecentTasksList.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/RecentTasksList.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f07ffe2b57e053c49323e287075f71dab6e8db2
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/RecentTasksList.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package foundation.e.blisslauncher.quickstep;
+
+import android.annotation.TargetApi;
+import android.app.ActivityManager;
+import android.content.Context;
+import android.os.Build;
+import android.os.Process;
+import android.util.SparseBooleanArray;
+import com.android.systemui.shared.recents.model.Task;
+import com.android.systemui.shared.system.ActivityManagerWrapper;
+import com.android.systemui.shared.system.BackgroundExecutor;
+import com.android.systemui.shared.system.KeyguardManagerCompat;
+import com.android.systemui.shared.system.TaskStackChangeListener;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+
+import foundation.e.blisslauncher.core.executors.MainThreadExecutor;
+
+/**
+ * Manages the recent task list from the system, caching it as necessary.
+ */
+@TargetApi(Build.VERSION_CODES.P)
+public class RecentTasksList extends TaskStackChangeListener {
+
+    private final KeyguardManagerCompat mKeyguardManager;
+    private final MainThreadExecutor mMainThreadExecutor;
+    private final BackgroundExecutor mBgThreadExecutor;
+
+    // The list change id, increments as the task list changes in the system
+    private int mChangeId;
+    // The last change id when the list was last loaded completely, must be <= the list change id
+    private int mLastLoadedId;
+    // The last change id was loaded with keysOnly  = true
+    private boolean mLastLoadHadKeysOnly;
+
+    ArrayList<Task> mTasks = new ArrayList<>();
+
+    public RecentTasksList(Context context) {
+        mMainThreadExecutor = new MainThreadExecutor();
+        mBgThreadExecutor = BackgroundExecutor.get();
+        mKeyguardManager = new KeyguardManagerCompat(context);
+        mChangeId = 1;
+        ActivityManagerWrapper.getInstance().registerTaskStackListener(this);
+    }
+
+    /**
+     * Fetches the task keys skipping any local cache.
+     */
+    public void getTaskKeys(int numTasks, Consumer<ArrayList<Task>> callback) {
+        // Kick off task loading in the background
+        mBgThreadExecutor.submit(() -> {
+            ArrayList<Task> tasks = loadTasksInBackground(numTasks, true /* loadKeysOnly */);
+            mMainThreadExecutor.execute(() -> callback.accept(tasks));
+        });
+    }
+
+    /**
+     * Asynchronously fetches the list of recent tasks, reusing cached list if available.
+     *
+     * @param loadKeysOnly Whether to load other associated task data, or just the key
+     * @param callback The callback to receive the list of recent tasks
+     * @return The change id of the current task list
+     */
+    public synchronized int getTasks(boolean loadKeysOnly, Consumer<ArrayList<Task>> callback) {
+        final int requestLoadId = mChangeId;
+        Runnable resultCallback = callback == null
+                ? () -> { }
+                : () -> callback.accept(copyOf(mTasks));
+
+        if (mLastLoadedId == mChangeId && (!mLastLoadHadKeysOnly || loadKeysOnly)) {
+            // The list is up to date, callback with the same list
+            mMainThreadExecutor.execute(resultCallback);
+            return requestLoadId;
+        }
+
+        // Kick off task loading in the background
+        mBgThreadExecutor.submit(() -> {
+            ArrayList<Task> tasks = loadTasksInBackground(Integer.MAX_VALUE, loadKeysOnly);
+
+            mMainThreadExecutor.execute(() -> {
+                mTasks = tasks;
+                mLastLoadedId = requestLoadId;
+                mLastLoadHadKeysOnly = loadKeysOnly;
+                resultCallback.run();
+            });
+        });
+
+        return requestLoadId;
+    }
+
+    /**
+     * @return Whether the provided {@param changeId} is the latest recent tasks list id.
+     */
+    public synchronized boolean isTaskListValid(int changeId) {
+        return mChangeId == changeId;
+    }
+
+    @Override
+    public synchronized void onTaskStackChanged() {
+        mChangeId++;
+    }
+
+    @Override
+    public void onTaskRemoved(int taskId) {
+        for (int i = mTasks.size() - 1; i >= 0; i--) {
+            if (mTasks.get(i).key.id == taskId) {
+                mTasks.remove(i);
+                return;
+            }
+        }
+    }
+
+    @Override
+    public synchronized void onActivityPinned(String packageName, int userId, int taskId,
+            int stackId) {
+        mChangeId++;
+    }
+
+    @Override
+    public synchronized void onActivityUnpinned() {
+        mChangeId++;
+    }
+
+    /**
+     * Loads and creates a list of all the recent tasks.
+     */
+    private ArrayList<Task> loadTasksInBackground(int numTasks,
+            boolean loadKeysOnly) {
+        int currentUserId = Process.myUserHandle().getIdentifier();
+        ArrayList<Task> allTasks = new ArrayList<>();
+        List<ActivityManager.RecentTaskInfo> rawTasks =
+                ActivityManagerWrapper.getInstance().getRecentTasks(numTasks, currentUserId);
+        // The raw tasks are given in most-recent to least-recent order, we need to reverse it
+        Collections.reverse(rawTasks);
+
+        SparseBooleanArray tmpLockedUsers = new SparseBooleanArray() {
+            @Override
+            public boolean get(int key) {
+                if (indexOfKey(key) < 0) {
+                    // Fill the cached locked state as we fetch
+                    put(key, mKeyguardManager.isDeviceLocked(key));
+                }
+                return super.get(key);
+            }
+        };
+
+        int taskCount = rawTasks.size();
+        for (int i = 0; i < taskCount; i++) {
+            ActivityManager.RecentTaskInfo rawTask = rawTasks.get(i);
+            Task.TaskKey taskKey = new Task.TaskKey(rawTask);
+            Task task;
+            if (!loadKeysOnly) {
+                boolean isLocked = tmpLockedUsers.get(taskKey.userId);
+                task = Task.from(taskKey, rawTask, isLocked);
+            } else {
+                task = new Task(taskKey);
+            }
+            allTasks.add(task);
+        }
+
+        return allTasks;
+    }
+
+    private ArrayList<Task> copyOf(ArrayList<Task> tasks) {
+        ArrayList<Task> newTasks = new ArrayList<>();
+        for (int i = 0; i < tasks.size(); i++) {
+            Task t = tasks.get(i);
+            newTasks.add(new Task(t.key, t.colorPrimary, t.colorBackground, t.isDockable,
+                    t.isLocked, t.taskDescription, t.topActivity));
+        }
+        return newTasks;
+    }
+}
\ No newline at end of file
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/RecentsActivityTracker.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/RecentsActivityTracker.java
new file mode 100644
index 0000000000000000000000000000000000000000..08fe73cda3b975ff3221e84a5df8fa77f52e80bf
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/RecentsActivityTracker.java
@@ -0,0 +1,134 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+
+import foundation.e.blisslauncher.quickstep.util.RemoteAnimationProvider;
+
+import java.lang.ref.WeakReference;
+import java.util.function.BiPredicate;
+
+import foundation.e.blisslauncher.core.executors.MainThreadExecutor;
+
+/**
+ * Utility class to track create/destroy for some {@link BaseRecentsActivity}.
+ */
+@TargetApi(Build.VERSION_CODES.P)
+public class RecentsActivityTracker<T extends BaseRecentsActivity> implements
+    ActivityControlHelper.ActivityInitListener {
+
+    private static WeakReference<BaseRecentsActivity> sCurrentActivity =
+            new WeakReference<>(null);
+    private static final Scheduler sScheduler = new Scheduler();
+
+    private final BiPredicate<T, Boolean> mOnInitListener;
+
+    public RecentsActivityTracker(BiPredicate<T, Boolean> onInitListener) {
+        mOnInitListener = onInitListener;
+    }
+
+    @Override
+    public void register() {
+        sScheduler.schedule(this);
+    }
+
+    @Override
+    public void unregister() {
+        sScheduler.clearReference(this);
+    }
+
+    private boolean init(T activity, boolean visible) {
+        return mOnInitListener.test(activity, visible);
+    }
+
+    public static <T extends BaseRecentsActivity> T getCurrentActivity() {
+        return (T) sCurrentActivity.get();
+    }
+
+    @Override
+    public void registerAndStartActivity(Intent intent, RemoteAnimationProvider animProvider,
+            Context context, Handler handler, long duration) {
+        register();
+
+        Bundle options = animProvider.toActivityOptions(handler, duration).toBundle();
+        context.startActivity(intent, options);
+    }
+
+    public static void onRecentsActivityCreate(BaseRecentsActivity activity) {
+        sCurrentActivity = new WeakReference<>(activity);
+        sScheduler.initIfPending(activity, false);
+    }
+
+
+    public static void onRecentsActivityNewIntent(BaseRecentsActivity activity) {
+        sScheduler.initIfPending(activity, activity.isStarted());
+    }
+
+    public static void onRecentsActivityDestroy(BaseRecentsActivity activity) {
+        if (sCurrentActivity.get() == activity) {
+            sCurrentActivity.clear();
+        }
+    }
+
+
+    private static class Scheduler implements Runnable {
+
+        private WeakReference<RecentsActivityTracker> mPendingTracker = new WeakReference<>(null);
+        private MainThreadExecutor mMainThreadExecutor;
+
+        public synchronized void schedule(RecentsActivityTracker tracker) {
+            mPendingTracker = new WeakReference<>(tracker);
+            if (mMainThreadExecutor == null) {
+                mMainThreadExecutor = new MainThreadExecutor();
+            }
+            mMainThreadExecutor.execute(this);
+        }
+
+        @Override
+        public void run() {
+            BaseRecentsActivity activity = sCurrentActivity.get();
+            if (activity != null) {
+                initIfPending(activity, activity.isStarted());
+            }
+        }
+
+        public synchronized boolean initIfPending(BaseRecentsActivity activity,
+                boolean alreadyOnHome) {
+            RecentsActivityTracker tracker = mPendingTracker.get();
+            if (tracker != null) {
+                if (!tracker.init(activity, alreadyOnHome)) {
+                    mPendingTracker.clear();
+                }
+                return true;
+            }
+            return false;
+        }
+
+        public synchronized boolean clearReference(RecentsActivityTracker tracker) {
+            if (mPendingTracker.get() == tracker) {
+                mPendingTracker.clear();
+                return true;
+            }
+            return false;
+        }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/RecentsModel.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/RecentsModel.java
new file mode 100644
index 0000000000000000000000000000000000000000..050e37186fc4dadfc08fd371e726492b40909ec0
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/RecentsModel.java
@@ -0,0 +1,212 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.annotation.TargetApi;
+import android.app.ActivityManager;
+import android.content.ComponentCallbacks2;
+import android.content.Context;
+import android.os.Build;
+import android.os.HandlerThread;
+import android.os.Process;
+import android.os.RemoteException;
+import android.util.Log;
+
+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.TaskStackChangeListener;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+/**
+ * Singleton class to load and manage recents model.
+ */
+@TargetApi(Build.VERSION_CODES.O)
+public class RecentsModel extends TaskStackChangeListener {
+
+    private static final String TAG = "RecentsModel";
+
+    // We do not need any synchronization for this variable as its only written on UI thread.
+    public static final MainThreadInitializedObject<RecentsModel> INSTANCE =
+            new MainThreadInitializedObject<>(c -> new RecentsModel(c));
+
+    private final List<TaskThumbnailChangeListener> mThumbnailChangeListeners = new ArrayList<>();
+    private final Context mContext;
+
+    private ISystemUiProxy mSystemUiProxy;
+
+    private final RecentTasksList mTaskList;
+    private final TaskIconCache mIconCache;
+    private final TaskThumbnailCache mThumbnailCache;
+
+    private RecentsModel(Context context) {
+        mContext = context;
+        HandlerThread loaderThread = new HandlerThread("TaskThumbnailIconCache",
+                Process.THREAD_PRIORITY_BACKGROUND);
+        loaderThread.start();
+        mTaskList = new RecentTasksList(context);
+        mIconCache = new TaskIconCache(context, loaderThread.getLooper());
+        mThumbnailCache = new TaskThumbnailCache(context, loaderThread.getLooper());
+        ActivityManagerWrapper.getInstance().registerTaskStackListener(this);
+    }
+
+    public TaskIconCache getIconCache() {
+        return mIconCache;
+    }
+
+    public TaskThumbnailCache getThumbnailCache() {
+        return mThumbnailCache;
+    }
+
+    /**
+     * Fetches the list of recent tasks.
+     *
+     * @param callback The callback to receive the task plan once its complete or null. This is
+     *                always called on the UI thread.
+     * @return the request id associated with this call.
+     */
+    public int getTasks(Consumer<ArrayList<Task>> callback) {
+        return mTaskList.getTasks(false /* loadKeysOnly */, callback);
+    }
+
+    /**
+     * @return The task id of the running task, or -1 if there is no current running task.
+     */
+    public static int getRunningTaskId() {
+        ActivityManager.RunningTaskInfo runningTask =
+                ActivityManagerWrapper.getInstance().getRunningTask();
+        return runningTask != null ? runningTask.id : -1;
+    }
+
+    /**
+     * @return Whether the provided {@param changeId} is the latest recent tasks list id.
+     */
+    public boolean isTaskListValid(int changeId) {
+        return mTaskList.isTaskListValid(changeId);
+    }
+
+    /**
+     * Finds and returns the task key associated with the given task id.
+     *
+     * @param callback The callback to receive the task key if it is found or null. This is always
+     *                 called on the UI thread.
+     */
+    public void findTaskWithId(int taskId, Consumer<Task.TaskKey> callback) {
+        mTaskList.getTasks(true /* loadKeysOnly */, (tasks) -> {
+            for (Task task : tasks) {
+                if (task.key.id == taskId) {
+                    callback.accept(task.key);
+                    return;
+                }
+            }
+            callback.accept(null);
+        });
+    }
+
+    @Override
+    public void onTaskStackChangedBackground() {
+        if (!mThumbnailCache.isPreloadingEnabled()) {
+            // Skip if we aren't preloading
+            return;
+        }
+
+        int currentUserId = Process.myUserHandle().getIdentifier();
+        if (!TaskUtils.checkCurrentOrManagedUserId(currentUserId, mContext)) {
+            // Skip if we are not the current user
+            return;
+        }
+
+        // Keep the cache up to date with the latest thumbnails
+        int runningTaskId = RecentsModel.getRunningTaskId();
+        mTaskList.getTaskKeys(mThumbnailCache.getCacheSize(), tasks -> {
+            for (Task task : tasks) {
+                if (task.key.id == runningTaskId) {
+                    // Skip the running task, it's not going to have an up-to-date snapshot by the
+                    // time the user next enters overview
+                    continue;
+                }
+                mThumbnailCache.updateThumbnailInCache(task);
+            }
+        });
+    }
+
+    @Override
+    public void onTaskSnapshotChanged(int taskId, ThumbnailData snapshot) {
+        mThumbnailCache.updateTaskSnapShot(taskId, snapshot);
+
+        for (int i = mThumbnailChangeListeners.size() - 1; i >= 0; i--) {
+            Task task = mThumbnailChangeListeners.get(i).onTaskThumbnailChanged(taskId, snapshot);
+            if (task != null) {
+                task.thumbnail = snapshot;
+            }
+        }
+    }
+
+    @Override
+    public void onTaskRemoved(int taskId) {
+        Task.TaskKey dummyKey = new Task.TaskKey(taskId, 0, null, null, 0, 0);
+        mThumbnailCache.remove(dummyKey);
+    }
+
+    public void setSystemUiProxy(ISystemUiProxy systemUiProxy) {
+        mSystemUiProxy = systemUiProxy;
+    }
+
+    public ISystemUiProxy getSystemUiProxy() {
+        return mSystemUiProxy;
+    }
+
+    public void onTrimMemory(int level) {
+        if (level == ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN) {
+            mThumbnailCache.getHighResLoadingState().setVisible(false);
+        }
+        if (level == ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL) {
+            // Clear everything once we reach a low-mem situation
+            mThumbnailCache.clear();
+            mIconCache.clear();
+        }
+    }
+
+    public void onOverviewShown(boolean fromHome, String tag) {
+        if (mSystemUiProxy == null) {
+            return;
+        }
+        try {
+            mSystemUiProxy.onOverviewShown(fromHome);
+        } catch (RemoteException e) {
+            Log.w(tag,
+                    "Failed to notify SysUI of overview shown from " + (fromHome ? "home" : "app")
+                            + ": ", e);
+        }
+    }
+
+    public void addThumbnailChangeListener(TaskThumbnailChangeListener listener) {
+        mThumbnailChangeListeners.add(listener);
+    }
+
+    public void removeThumbnailChangeListener(TaskThumbnailChangeListener listener) {
+        mThumbnailChangeListeners.remove(listener);
+    }
+
+    public interface TaskThumbnailChangeListener {
+
+        Task onTaskThumbnailChanged(int taskId, ThumbnailData thumbnailData);
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/RemoteRunnable.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/RemoteRunnable.java
new file mode 100644
index 0000000000000000000000000000000000000000..1385f927f36ea378230a1fabdccff350a9a612b2
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/RemoteRunnable.java
@@ -0,0 +1,33 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.os.RemoteException;
+import android.util.Log;
+
+@FunctionalInterface
+public interface RemoteRunnable {
+
+    void run() throws RemoteException;
+
+    static void executeSafely(RemoteRunnable r) {
+        try {
+            r.run();
+        } catch (final RemoteException e) {
+            Log.e("RemoteRunnable", "Error calling remote method", e);
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/SysUINavigationMode.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/SysUINavigationMode.java
new file mode 100644
index 0000000000000000000000000000000000000000..c63d3d5e92d8e88b387416894b07ee49bdca7ace
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/SysUINavigationMode.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep;
+
+import static foundation.e.blisslauncher.core.utils.PackageManagerHelper.getPackageFilter;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.util.Log;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Observer for the resource config that specifies the navigation bar mode.
+ */
+public class SysUINavigationMode {
+
+    public enum Mode {
+        THREE_BUTTONS(false, 0),
+        TWO_BUTTONS(true, 1),
+        NO_BUTTON(true, 2);
+
+        public final boolean hasGestures;
+        public final int resValue;
+
+        Mode(boolean hasGestures, int resValue) {
+            this.hasGestures = hasGestures;
+            this.resValue = resValue;
+        }
+    }
+
+    public static Mode getMode(Context context) {
+        return INSTANCE.get(context).getMode();
+    }
+
+    public static MainThreadInitializedObject<SysUINavigationMode> INSTANCE =
+            new MainThreadInitializedObject<>(SysUINavigationMode::new);
+
+    private static final String TAG = "SysUINavigationMode";
+
+    private final String ACTION_OVERLAY_CHANGED = "android.intent.action.OVERLAY_CHANGED";
+    private static final String NAV_BAR_INTERACTION_MODE_RES_NAME =
+            "config_navBarInteractionMode";
+
+    private final Context mContext;
+    private Mode mMode;
+
+    private final List<NavigationModeChangeListener> mChangeListeners = new ArrayList<>();
+
+    public SysUINavigationMode(Context context) {
+        mContext = context;
+        initializeMode();
+
+        mContext.registerReceiver(new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                Mode oldMode = mMode;
+                initializeMode();
+                if (mMode != oldMode) {
+                    dispatchModeChange();
+                }
+            }
+        }, getPackageFilter("android", ACTION_OVERLAY_CHANGED));
+    }
+
+    private void initializeMode() {
+        int modeInt = getSystemIntegerRes(mContext, NAV_BAR_INTERACTION_MODE_RES_NAME);
+        for(Mode m : Mode.values()) {
+            if (m.resValue == modeInt) {
+                mMode = m;
+            }
+        }
+    }
+
+    private void dispatchModeChange() {
+        for (NavigationModeChangeListener listener : mChangeListeners) {
+            listener.onNavigationModeChanged(mMode);
+        }
+    }
+
+    public Mode addModeChangeListener(NavigationModeChangeListener listener) {
+        mChangeListeners.add(listener);
+        return mMode;
+    }
+
+    public void removeModeChangeListener(NavigationModeChangeListener listener) {
+        mChangeListeners.remove(listener);
+    }
+
+    public Mode getMode() {
+        return mMode;
+    }
+
+    private static int getSystemIntegerRes(Context context, String resName) {
+        Resources res = context.getResources();
+        int resId = res.getIdentifier(resName, "integer", "android");
+
+        if (resId != 0) {
+            return res.getInteger(resId);
+        } else {
+            Log.e(TAG, "Failed to get system resource ID. Incompatible framework version?");
+            return -1;
+        }
+    }
+
+    public interface NavigationModeChangeListener {
+
+        void onNavigationModeChanged(Mode newMode);
+    }
+}
\ No newline at end of file
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/TaskIconCache.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/TaskIconCache.java
new file mode 100644
index 0000000000000000000000000000000000000000..b84be22b6207087a905277d3b1d8c7fa20ca9d63
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/TaskIconCache.java
@@ -0,0 +1,153 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import static foundation.e.blisslauncher.uioverrides.RecentsUiFactory.GO_LOW_RAM_RECENTS_ENABLED;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.ActivityInfo;
+import android.content.res.Resources;
+import android.graphics.drawable.Drawable;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.LruCache;
+import android.view.accessibility.AccessibilityManager;
+import com.android.systemui.shared.recents.model.Task;
+import com.android.systemui.shared.recents.model.TaskKeyLruCache;
+import com.android.systemui.shared.system.ActivityManagerWrapper;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.executors.MainThreadExecutor;
+import foundation.e.blisslauncher.core.utils.Preconditions;
+import java.util.function.Consumer;
+
+/**
+ * Manages the caching of task icons and related data.
+ * TODO: This class should later be merged into IconCache.
+ */
+public class TaskIconCache {
+
+    private final Handler mBackgroundHandler;
+    private final MainThreadExecutor mMainThreadExecutor;
+    private final AccessibilityManager mAccessibilityManager;
+
+    private final NormalizedIconLoader mIconLoader;
+
+    private final TaskKeyLruCache<Drawable> mIconCache;
+    private final TaskKeyLruCache<String> mContentDescriptionCache;
+    private final LruCache<ComponentName, ActivityInfo> mActivityInfoCache;
+
+    private TaskKeyLruCache.EvictionCallback mClearActivityInfoOnEviction =
+            new TaskKeyLruCache.EvictionCallback() {
+        @Override
+        public void onEntryEvicted(Task.TaskKey key) {
+            if (key != null) {
+                mActivityInfoCache.remove(key.getComponent());
+            }
+        }
+    };
+
+    public TaskIconCache(Context context, Looper backgroundLooper) {
+        mBackgroundHandler = new Handler(backgroundLooper);
+        mMainThreadExecutor = new MainThreadExecutor();
+        mAccessibilityManager = context.getSystemService(AccessibilityManager.class);
+
+        Resources res = context.getResources();
+        int cacheSize = res.getInteger(R.integer.recentsIconCacheSize);
+        mIconCache = new TaskKeyLruCache<>(cacheSize, mClearActivityInfoOnEviction);
+        mContentDescriptionCache = new TaskKeyLruCache<>(cacheSize, mClearActivityInfoOnEviction);
+        mActivityInfoCache = new LruCache<>(cacheSize);
+        mIconLoader = new NormalizedIconLoader(context, mIconCache, mActivityInfoCache,
+                true /* disableColorExtraction */);
+    }
+
+    /**
+     * 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.
+     * @return A cancelable handle to the request
+     */
+    public IconLoadRequest updateIconInBackground(Task task, Consumer<Task> callback) {
+        Preconditions.assertUIThread();
+        if (task.icon != null) {
+            // Nothing to load, the icon is already loaded
+            callback.accept(task);
+            return null;
+        }
+
+        IconLoadRequest request = new IconLoadRequest(mBackgroundHandler) {
+            @Override
+            public void run() {
+                Drawable icon = mIconLoader.getIcon(task);
+                String contentDescription = loadContentDescriptionInBackground(task);
+                if (isCanceled()) {
+                    // We don't call back to the provided callback in this case
+                    return;
+                }
+                mMainThreadExecutor.execute(() -> {
+                    task.icon = icon;
+                    task.titleDescription = contentDescription;
+                    callback.accept(task);
+                    onEnd();
+                });
+            }
+        };
+        Utilities.postAsyncCallback(mBackgroundHandler, request);
+        return request;
+    }
+
+    public void clear() {
+        mIconCache.evictAll();
+        mContentDescriptionCache.evictAll();
+    }
+
+    /**
+     * Loads the content description for the given {@param task}.
+     */
+    private String loadContentDescriptionInBackground(Task task) {
+        // Return the cached content description if it exists
+        String label = mContentDescriptionCache.getAndInvalidateIfModified(task.key);
+        if (label != null) {
+            return label;
+        }
+
+        // Skip loading content descriptions if accessibility is disabled unless low RAM recents
+        // is enabled.
+        if (!GO_LOW_RAM_RECENTS_ENABLED && !mAccessibilityManager.isEnabled()) {
+            return "";
+        }
+
+        // Skip loading the content description if the activity no longer exists
+        ActivityInfo activityInfo = mIconLoader.getAndUpdateActivityInfo(task.key);
+        if (activityInfo == null) {
+            return "";
+        }
+
+        // Load the label otherwise
+        label = ActivityManagerWrapper.getInstance().getBadgedContentDescription(activityInfo,
+                task.key.userId, task.taskDescription);
+        mContentDescriptionCache.put(task.key, label);
+        return label;
+    }
+
+    public static abstract class IconLoadRequest extends HandlerRunnable {
+        IconLoadRequest(Handler handler) {
+            super(handler, null);
+        }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/TaskThumbnailCache.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/TaskThumbnailCache.java
new file mode 100644
index 0000000000000000000000000000000000000000..fd330e05de74a42798003a37fb32f25e68ceb68a
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/TaskThumbnailCache.java
@@ -0,0 +1,242 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.app.ActivityManager;
+import android.content.Context;
+import android.content.res.Resources;
+import android.os.Handler;
+import android.os.Looper;
+import com.android.systemui.shared.recents.model.Task;
+import com.android.systemui.shared.recents.model.Task.TaskKey;
+import com.android.systemui.shared.recents.model.TaskKeyLruCache;
+import com.android.systemui.shared.recents.model.ThumbnailData;
+import com.android.systemui.shared.system.ActivityManagerWrapper;
+import java.util.ArrayList;
+import java.util.function.Consumer;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.core.Utilities;
+import foundation.e.blisslauncher.core.executors.MainThreadExecutor;
+import foundation.e.blisslauncher.core.utils.Preconditions;
+
+public class TaskThumbnailCache {
+
+    private final Handler mBackgroundHandler;
+    private final MainThreadExecutor mMainThreadExecutor;
+
+    private final int mCacheSize;
+    private final ThumbnailCache mCache;
+    private final HighResLoadingState mHighResLoadingState;
+
+    public static class HighResLoadingState {
+        private boolean mIsLowRamDevice;
+        private boolean mVisible;
+        private boolean mFlingingFast;
+        private boolean mHighResLoadingEnabled;
+        private ArrayList<HighResLoadingStateChangedCallback> mCallbacks = new ArrayList<>();
+
+        public interface HighResLoadingStateChangedCallback {
+            void onHighResLoadingStateChanged(boolean enabled);
+        }
+
+        private HighResLoadingState(Context context) {
+            ActivityManager activityManager =
+                    (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+            mIsLowRamDevice = activityManager.isLowRamDevice();
+        }
+
+        public void addCallback(HighResLoadingStateChangedCallback callback) {
+            mCallbacks.add(callback);
+        }
+
+        public void removeCallback(HighResLoadingStateChangedCallback callback) {
+            mCallbacks.remove(callback);
+        }
+
+        public void setVisible(boolean visible) {
+            mVisible = visible;
+            updateState();
+        }
+
+        public void setFlingingFast(boolean flingingFast) {
+            mFlingingFast = flingingFast;
+            updateState();
+        }
+
+        public boolean isEnabled() {
+            return mHighResLoadingEnabled;
+        }
+
+        private void updateState() {
+            boolean prevState = mHighResLoadingEnabled;
+            mHighResLoadingEnabled = !mIsLowRamDevice && mVisible && !mFlingingFast;
+            if (prevState != mHighResLoadingEnabled) {
+                for (int i = mCallbacks.size() - 1; i >= 0; i--) {
+                    mCallbacks.get(i).onHighResLoadingStateChanged(mHighResLoadingEnabled);
+                }
+            }
+        }
+    }
+
+    public TaskThumbnailCache(Context context, Looper backgroundLooper) {
+        mBackgroundHandler = new Handler(backgroundLooper);
+        mMainThreadExecutor = new MainThreadExecutor();
+        mHighResLoadingState = new HighResLoadingState(context);
+
+        Resources res = context.getResources();
+        mCacheSize = res.getInteger(R.integer.recentsThumbnailCacheSize);
+        mCache = new ThumbnailCache(mCacheSize);
+    }
+
+    /**
+     * Synchronously fetches the thumbnail for the given {@param task} and puts it in the cache.
+     */
+    public void updateThumbnailInCache(Task task) {
+        Preconditions.assertUIThread();
+        // Fetch the thumbnail for this task and put it in the cache
+        if (task.thumbnail == null) {
+            updateThumbnailInBackground(task.key, true /* reducedResolution */,
+                    t -> task.thumbnail = t);
+        }
+    }
+
+    /**
+     * Synchronously updates the thumbnail in the cache if it is already there.
+     */
+    public void updateTaskSnapShot(int taskId, ThumbnailData thumbnail) {
+        Preconditions.assertUIThread();
+        mCache.updateIfAlreadyInCache(taskId, thumbnail);
+    }
+
+    /**
+     * Asynchronously fetches the icon and other task data for the given {@param task}.
+     *
+     * @param callback The callback to receive the task after its data has been populated.
+     * @return A cancelable handle to the request
+     */
+    public ThumbnailLoadRequest updateThumbnailInBackground(
+            Task task, Consumer<ThumbnailData> callback) {
+        Preconditions.assertUIThread();
+
+        boolean reducedResolution = !mHighResLoadingState.isEnabled();
+        if (task.thumbnail != null && (!task.thumbnail.reducedResolution || reducedResolution)) {
+            // Nothing to load, the thumbnail is already high-resolution or matches what the
+            // request, so just callback
+            callback.accept(task.thumbnail);
+            return null;
+        }
+
+
+        return updateThumbnailInBackground(task.key, !mHighResLoadingState.isEnabled(), t -> {
+            task.thumbnail = t;
+            callback.accept(t);
+        });
+    }
+
+    private ThumbnailLoadRequest updateThumbnailInBackground(TaskKey key, boolean reducedResolution,
+            Consumer<ThumbnailData> callback) {
+        Preconditions.assertUIThread();
+
+        ThumbnailData cachedThumbnail = mCache.getAndInvalidateIfModified(key);
+        if (cachedThumbnail != null && (!cachedThumbnail.reducedResolution || reducedResolution)) {
+            // Already cached, lets use that thumbnail
+            callback.accept(cachedThumbnail);
+            return null;
+        }
+
+        ThumbnailLoadRequest request = new ThumbnailLoadRequest(mBackgroundHandler,
+                reducedResolution) {
+            @Override
+            public void run() {
+                ThumbnailData thumbnail = ActivityManagerWrapper.getInstance().getTaskThumbnail(
+                        key.id, reducedResolution);
+                if (isCanceled()) {
+                    // We don't call back to the provided callback in this case
+                    return;
+                }
+                mMainThreadExecutor.execute(() -> {
+                    mCache.put(key, thumbnail);
+                    callback.accept(thumbnail);
+                    onEnd();
+                });
+            }
+        };
+        Utilities.postAsyncCallback(mBackgroundHandler, request);
+        return request;
+    }
+
+    /**
+     * Clears the cache.
+     */
+    public void clear() {
+        mCache.evictAll();
+    }
+
+    /**
+     * Removes the cached thumbnail for the given task.
+     */
+    public void remove(Task.TaskKey key) {
+        mCache.remove(key);
+    }
+
+    /**
+     * @return The cache size.
+     */
+    public int getCacheSize() {
+        return mCacheSize;
+    }
+
+    /**
+     * @return The mutable high-res loading state.
+     */
+    public HighResLoadingState getHighResLoadingState() {
+        return mHighResLoadingState;
+    }
+
+    /**
+     * @return Whether to enable background preloading of task thumbnails.
+     */
+    public boolean isPreloadingEnabled() {
+        return !mHighResLoadingState.mIsLowRamDevice && mHighResLoadingState.mVisible;
+    }
+
+    public static abstract class ThumbnailLoadRequest extends HandlerRunnable {
+        public final boolean reducedResolution;
+
+        ThumbnailLoadRequest(Handler handler, boolean reducedResolution) {
+            super(handler, null);
+            this.reducedResolution = reducedResolution;
+        }
+    }
+
+    private static class ThumbnailCache extends TaskKeyLruCache<ThumbnailData> {
+
+        public ThumbnailCache(int cacheSize) {
+            super(cacheSize);
+        }
+
+        /**
+         * Updates the cache entry if it is already present in the cache
+         */
+        public void updateIfAlreadyInCache(int taskId, ThumbnailData thumbnailData) {
+            ThumbnailData oldData = getCacheEntry(taskId);
+            if (oldData != null) {
+                putCacheEntry(taskId, thumbnailData);
+            }
+        }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/TaskUtils.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/TaskUtils.java
new file mode 100644
index 0000000000000000000000000000000000000000..47503df911702c6f027eeead99f928e7685edbc7
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/TaskUtils.java
@@ -0,0 +1,97 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.LauncherApps;
+import android.content.pm.PackageManager;
+import android.os.UserHandle;
+import android.util.Log;
+
+import com.android.systemui.shared.recents.model.Task;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+
+import java.util.List;
+
+import foundation.e.blisslauncher.core.UserManagerCompat;
+import foundation.e.blisslauncher.core.utils.ComponentKey;
+
+/**
+ * Contains helpful methods for retrieving data from {@link Task}s.
+ */
+public final class TaskUtils {
+
+    private static final String TAG = "TaskUtils";
+
+    private TaskUtils() {}
+
+    /**
+     * TODO: remove this once we switch to getting the icon and label from IconCache.
+     */
+    public static CharSequence getTitle(Context context, Task task) {
+        LauncherApps launcherApps =
+            (LauncherApps) context.getSystemService(Context.LAUNCHER_APPS_SERVICE);
+        PackageManager packageManager = context.getPackageManager();
+        UserHandle user = UserHandle.of(task.key.userId);
+        ApplicationInfo applicationInfo = null;
+        try {
+            applicationInfo = launcherApps.getApplicationInfo(
+                task.getTopComponent().getPackageName(), 0, user);
+        } catch (PackageManager.NameNotFoundException e) {
+            e.printStackTrace();
+        }
+        if (applicationInfo == null) {
+            Log.e(TAG, "Failed to get title for task " + task);
+            return "";
+        }
+        return packageManager.getUserBadgedLabel(
+            applicationInfo.loadLabel(packageManager), user);
+    }
+
+    public static ComponentKey getLaunchComponentKeyForTask(Task.TaskKey taskKey) {
+        final ComponentName cn = taskKey.sourceComponent != null
+                ? taskKey.sourceComponent
+                : taskKey.getComponent();
+        return new ComponentKey(cn, UserHandle.of(taskKey.userId));
+    }
+
+
+    public static boolean taskIsATargetWithMode(RemoteAnimationTargetCompat[] targets,
+            int taskId, int mode) {
+        for (RemoteAnimationTargetCompat target : targets) {
+            if (target.mode == mode && target.taskId == taskId) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean checkCurrentOrManagedUserId(int currentUserId, Context context) {
+        if (currentUserId == UserHandle.myUserId()) {
+            return true;
+        }
+        List<UserHandle> allUsers = UserManagerCompat.getInstance(context).getUserProfiles();
+        for (int i = allUsers.size() - 1; i >= 0; i--) {
+            if (currentUserId == allUsers.get(i).getIdentifier()) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/BinderTracker.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/BinderTracker.java
new file mode 100644
index 0000000000000000000000000000000000000000..24d4248eec9d4bd9a5c777055fdf63a46e281885
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/BinderTracker.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.util;
+
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.Looper;
+import android.util.Log;
+
+/**
+ * Utility class to test and check binder calls during development.
+ */
+public class BinderTracker {
+
+    private static final String TAG = "BinderTracker";
+    private static final boolean IS_DOGFOOD_BUILD = true;
+
+    public static void start() {
+        if (IS_DOGFOOD_BUILD) {
+            Log.wtf(TAG, "Accessing tracker in released code.", new Exception());
+            return;
+        }
+
+        Binder.setProxyTransactListener(new Tracker());
+    }
+
+    public static void stop() {
+        if (IS_DOGFOOD_BUILD) {
+            Log.wtf(TAG, "Accessing tracker in released code.", new Exception());
+            return;
+        }
+        Binder.setProxyTransactListener(null);
+    }
+
+    private static class Tracker implements Binder.ProxyTransactListener {
+
+        @Override
+        public Object onTransactStarted(IBinder iBinder, int code) {
+            if (Looper.myLooper() == Looper.getMainLooper()) {
+                Log.e(TAG, "Binder call on ui thread", new Exception());
+            }
+            return null;
+        }
+
+        @Override
+        public void onTransactEnded(Object session) { }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/CachedEventDispatcher.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/CachedEventDispatcher.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3e76b9b4d5f50fa17ceb815d69d7c744a9309a0
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/CachedEventDispatcher.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.util;
+
+import static com.android.systemui.shared.system.InputChannelCompat.mergeMotionEvent;
+
+import android.view.MotionEvent;
+import java.util.ArrayList;
+import java.util.function.Consumer;
+
+/**
+ * Utility class to dispatch touch events to a different class. It stores the events locally
+ * until a valid dispatcher is available.
+ */
+public class CachedEventDispatcher {
+
+    private Consumer<MotionEvent> mConsumer;
+
+    private ArrayList<MotionEvent> mCache;
+    private MotionEvent mLastEvent;
+
+    public void dispatchEvent(MotionEvent event) {
+        if (mConsumer != null) {
+            mConsumer.accept(event);
+        } else {
+            if (mLastEvent == null || !mergeMotionEvent(event, mLastEvent)) {
+                // Queue event.
+                if (mCache == null) {
+                    mCache = new ArrayList<>();
+                }
+                mLastEvent = MotionEvent.obtain(event);
+                mCache.add(mLastEvent);
+            }
+        }
+    }
+
+    public void setConsumer(Consumer<MotionEvent> consumer) {
+        if (consumer == null) {
+            return;
+        }
+        mConsumer = consumer;
+        int cacheCount = mCache == null ? 0 : mCache.size();
+        for (int i = 0; i < cacheCount; i++) {
+            MotionEvent ev = mCache.get(i);
+            mConsumer.accept(ev);
+            ev.recycle();
+        }
+        mCache = null;
+        mLastEvent = null;
+    }
+
+    public boolean hasConsumer() {
+        return mConsumer != null;
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/LayoutUtils.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/LayoutUtils.java
new file mode 100644
index 0000000000000000000000000000000000000000..5db578c6f834a27e001e8c8d4f2d320c14972fdc
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/LayoutUtils.java
@@ -0,0 +1,119 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.util;
+
+import static java.lang.annotation.RetentionPolicy.SOURCE;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Rect;
+import androidx.annotation.AnyThread;
+import androidx.annotation.IntDef;
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import java.lang.annotation.Retention;
+
+public class LayoutUtils {
+
+    private static final int MULTI_WINDOW_STRATEGY_HALF_SCREEN = 1;
+    private static final int MULTI_WINDOW_STRATEGY_DEVICE_PROFILE = 2;
+
+    @Retention(SOURCE)
+    @IntDef({MULTI_WINDOW_STRATEGY_HALF_SCREEN, MULTI_WINDOW_STRATEGY_DEVICE_PROFILE})
+    private @interface MultiWindowStrategy {}
+
+    public static void calculateLauncherTaskSize(Context context, VariantDeviceProfile dp, Rect outRect) {
+        float extraSpace;
+        extraSpace = dp.getHotseatBarSizePx() + dp.getVerticalDragHandleSizePx();
+        calculateTaskSize(context, dp, extraSpace, MULTI_WINDOW_STRATEGY_HALF_SCREEN, outRect);
+    }
+
+    public static void calculateFallbackTaskSize(Context context, VariantDeviceProfile dp, Rect outRect) {
+        calculateTaskSize(context, dp, 0, MULTI_WINDOW_STRATEGY_DEVICE_PROFILE, outRect);
+    }
+
+    @AnyThread
+    public static void calculateTaskSize(Context context, VariantDeviceProfile dp,
+            float extraVerticalSpace, @MultiWindowStrategy int multiWindowStrategy, Rect outRect) {
+        float taskWidth, taskHeight, paddingHorz;
+        Resources res = context.getResources();
+        Rect insets = dp.getInsets();
+
+        if (dp.isMultiWindowMode) {
+            if (multiWindowStrategy == MULTI_WINDOW_STRATEGY_HALF_SCREEN) {
+                VariantDeviceProfile fullDp = dp.getFullScreenProfile();
+                // Use availableWidthPx and availableHeightPx instead of widthPx and heightPx to
+                // account for system insets
+                taskWidth = fullDp.getAvailableWidthPx();
+                taskHeight = fullDp.getAvailableHeightPx();
+                float halfDividerSize = res.getDimension(R.dimen.multi_window_task_divider_size)
+                        / 2;
+
+                // TODO: Fix this when supporting landscape mode.
+                /*if (fullDp.isLandscape) {
+                    taskWidth = taskWidth / 2 - halfDividerSize;
+                } else {
+                    taskHeight = taskHeight / 2 - halfDividerSize;
+                }*/
+                taskHeight = taskHeight / 2 - halfDividerSize;
+            } else {
+                // multiWindowStrategy == MULTI_WINDOW_STRATEGY_DEVICE_PROFILE
+                taskWidth = dp.getWidthPx();
+                taskHeight = dp.getHeightPx();
+            }
+            paddingHorz = res.getDimension(R.dimen.multi_window_task_card_horz_space);
+        } else {
+            taskWidth = dp.getAvailableWidthPx();
+            taskHeight = dp.getHeightPx();
+            // TODO: Fix this when supporting landscape mode.
+            /*paddingHorz = res.getDimension(dp.isVerticalBarLayout()
+                    ? R.dimen.landscape_task_card_horz_space
+                    : R.dimen.portrait_task_card_horz_space);*/
+            paddingHorz = res.getDimension(R.dimen.portrait_task_card_horz_space);
+        }
+
+        float topIconMargin = res.getDimension(R.dimen.task_thumbnail_top_margin);
+        float paddingVert = res.getDimension(R.dimen.task_card_vert_space);
+
+        // Note this should be same as dp.availableWidthPx and dp.availableHeightPx unless
+        // we override the insets ourselves.
+        int launcherVisibleWidth = dp.getWidthPx() - insets.left - insets.right;
+        int launcherVisibleHeight = dp.getHeightPx() - insets.top - insets.bottom;
+
+        float availableHeight = launcherVisibleHeight
+                - topIconMargin - extraVerticalSpace - paddingVert;
+        float availableWidth = launcherVisibleWidth - paddingHorz;
+
+        float scale = Math.min(availableWidth / taskWidth, availableHeight / taskHeight);
+        float outWidth = scale * taskWidth;
+        float outHeight = scale * taskHeight;
+
+        // Center in the visible space
+        float x = insets.left + (launcherVisibleWidth - outWidth) / 2;
+        float y = insets.top + Math.max(topIconMargin,
+                (launcherVisibleHeight - extraVerticalSpace - outHeight) / 2);
+        outRect.set(Math.round(x), Math.round(y),
+                Math.round(x) + Math.round(outWidth), Math.round(y) + Math.round(outHeight));
+    }
+
+    public static int getShelfTrackingDistance(Context context, VariantDeviceProfile dp) {
+        // Track the bottom of the window.
+        int shelfHeight = dp.getHotseatBarSizePx() + dp.getInsets().bottom;
+        int spaceBetweenShelfAndRecents = (int) context.getResources().getDimension(
+            R.dimen.task_card_vert_space);
+        return shelfHeight + spaceBetweenShelfAndRecents;
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/MotionPauseDetector.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/MotionPauseDetector.java
new file mode 100644
index 0000000000000000000000000000000000000000..f11e05b7f90d8f3f22fbb3621a68df7d7777a61e
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/MotionPauseDetector.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.quickstep.util;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.view.MotionEvent;
+
+import foundation.e.blisslauncher.R;
+import foundation.e.blisslauncher.features.test.Alarm;
+
+/**
+ * Given positions along x- or y-axis, tracks velocity and acceleration and determines when there is
+ * a pause in motion.
+ */
+public class MotionPauseDetector {
+
+    // The percentage of the previous speed that determines whether this is a rapid deceleration.
+    // The bigger this number, the easier it is to trigger the first pause.
+    private static final float RAPID_DECELERATION_FACTOR = 0.6f;
+
+    /** If no motion is added for this amount of time, assume the motion has paused. */
+    private static final long FORCE_PAUSE_TIMEOUT = 300;
+
+    private static final long HARDER_TRIGGER_TIMEOUT = 400;
+
+    private final float mSpeedVerySlow;
+    private final float mSpeedSlow;
+    private final float mSpeedSomewhatFast;
+    private final float mSpeedFast;
+    private final Alarm mForcePauseTimeout;
+    private final boolean mMakePauseHarderToTrigger;
+    private final Context mContext;
+
+    private Long mPreviousTime = null;
+    private Float mPreviousPosition = null;
+    private Float mPreviousVelocity = null;
+
+    private Float mFirstPosition = null;
+
+    private OnMotionPauseListener mOnMotionPauseListener;
+    private boolean mIsPaused;
+    // Bias more for the first pause to make it feel extra responsive.
+    private boolean mHasEverBeenPaused;
+    /** @see #setDisallowPause(boolean) */
+    private boolean mDisallowPause;
+    // Time at which speed became < mSpeedSlow (only used if mMakePauseHarderToTrigger == true).
+    private long mSlowStartTime;
+
+    public MotionPauseDetector(Context context) {
+        this(context, false);
+    }
+
+    /**
+     * @param makePauseHarderToTrigger Used for gestures that require a more explicit pause.
+     */
+    public MotionPauseDetector(Context context, boolean makePauseHarderToTrigger) {
+        mContext = context;
+        Resources res = context.getResources();
+        mSpeedVerySlow = res.getDimension(R.dimen.motion_pause_detector_speed_very_slow);
+        mSpeedSlow = res.getDimension(R.dimen.motion_pause_detector_speed_slow);
+        mSpeedSomewhatFast = res.getDimension(R.dimen.motion_pause_detector_speed_somewhat_fast);
+        mSpeedFast = res.getDimension(R.dimen.motion_pause_detector_speed_fast);
+        mForcePauseTimeout = new Alarm();
+        mForcePauseTimeout.setOnAlarmListener(alarm -> updatePaused(true /* isPaused */));
+        mMakePauseHarderToTrigger = makePauseHarderToTrigger;
+    }
+
+    /**
+     * Get callbacks for when motion pauses and resumes.
+     */
+    public void setOnMotionPauseListener(OnMotionPauseListener listener) {
+        mOnMotionPauseListener = listener;
+    }
+
+    /**
+     * @param disallowPause If true, we will not detect any pauses until this is set to false again.
+     */
+    public void setDisallowPause(boolean disallowPause) {
+        mDisallowPause = disallowPause;
+        updatePaused(mIsPaused);
+    }
+
+    /**
+     * Computes velocity and acceleration to determine whether the motion is paused.
+     * @param position The x or y component of the motion being tracked.
+     *
+     * TODO: Use historical positions as well, e.g. {@link MotionEvent#getHistoricalY(int, int)}.
+     */
+    public void addPosition(float position, long time) {
+        if (mFirstPosition == null) {
+            mFirstPosition = position;
+        }
+        mForcePauseTimeout.setAlarm(mMakePauseHarderToTrigger
+                ? HARDER_TRIGGER_TIMEOUT
+                : FORCE_PAUSE_TIMEOUT);
+        if (mPreviousTime != null && mPreviousPosition != null) {
+            long changeInTime = Math.max(1, time - mPreviousTime);
+            float changeInPosition = position - mPreviousPosition;
+            float velocity = changeInPosition / changeInTime;
+            if (mPreviousVelocity != null) {
+                checkMotionPaused(velocity, mPreviousVelocity, time);
+            }
+            mPreviousVelocity = velocity;
+        }
+        mPreviousTime = time;
+        mPreviousPosition = position;
+    }
+
+    private void checkMotionPaused(float velocity, float prevVelocity, long time) {
+        float speed = Math.abs(velocity);
+        float previousSpeed = Math.abs(prevVelocity);
+        boolean isPaused;
+        if (mIsPaused) {
+            // Continue to be paused until moving at a fast speed.
+            isPaused = speed < mSpeedFast || previousSpeed < mSpeedFast;
+        } else {
+            if (velocity < 0 != prevVelocity < 0) {
+                // We're just changing directions, not necessarily stopping.
+                isPaused = false;
+            } else {
+                isPaused = speed < mSpeedVerySlow && previousSpeed < mSpeedVerySlow;
+                if (!isPaused && !mHasEverBeenPaused) {
+                    // We want to be more aggressive about detecting the first pause to ensure it
+                    // feels as responsive as possible; getting two very slow speeds back to back
+                    // takes too long, so also check for a rapid deceleration.
+                    boolean isRapidDeceleration = speed < previousSpeed * RAPID_DECELERATION_FACTOR;
+                    isPaused = isRapidDeceleration && speed < mSpeedSomewhatFast;
+                }
+                if (mMakePauseHarderToTrigger) {
+                    if (speed < mSpeedSlow) {
+                        if (mSlowStartTime == 0) {
+                            mSlowStartTime = time;
+                        }
+                        isPaused = time - mSlowStartTime >= HARDER_TRIGGER_TIMEOUT;
+                    } else {
+                        mSlowStartTime = 0;
+                        isPaused = false;
+                    }
+                }
+            }
+        }
+        updatePaused(isPaused);
+    }
+
+    private void updatePaused(boolean isPaused) {
+        if (mDisallowPause) {
+            isPaused = false;
+        }
+        if (mIsPaused != isPaused) {
+            mIsPaused = isPaused;
+            if (mIsPaused) {
+                mHasEverBeenPaused = true;
+            }
+            if (mOnMotionPauseListener != null) {
+                mOnMotionPauseListener.onMotionPauseChanged(mIsPaused);
+            }
+        }
+    }
+
+    public void clear() {
+        mPreviousTime = null;
+        mPreviousPosition = null;
+        mPreviousVelocity = null;
+        mFirstPosition = null;
+        setOnMotionPauseListener(null);
+        mIsPaused = mHasEverBeenPaused = false;
+        mSlowStartTime = 0;
+        mForcePauseTimeout.cancelAlarm();
+    }
+
+    public boolean isPaused() {
+        return mIsPaused;
+    }
+
+    public interface OnMotionPauseListener {
+        void onMotionPauseChanged(boolean isPaused);
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/MultiValueUpdateListener.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/MultiValueUpdateListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..f35f1552dd38479f0a9e83a8c05c0047469e0374
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/MultiValueUpdateListener.java
@@ -0,0 +1,68 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.util;
+
+import android.animation.ValueAnimator;
+import android.view.animation.Interpolator;
+
+import java.util.ArrayList;
+
+/**
+ * Utility class to update multiple values with different interpolators and durations during
+ * the same animation.
+ */
+public abstract class MultiValueUpdateListener implements ValueAnimator.AnimatorUpdateListener {
+
+    private final ArrayList<FloatProp> mAllProperties = new ArrayList<>();
+
+    @Override
+    public final void onAnimationUpdate(ValueAnimator animator) {
+        final float percent = animator.getAnimatedFraction();
+        final float currentPlayTime = percent * animator.getDuration();
+
+        for (int i = mAllProperties.size() - 1; i >= 0; i--) {
+            FloatProp prop = mAllProperties.get(i);
+            float time = Math.max(0, currentPlayTime - prop.mDelay);
+            float newPercent = Math.min(1f, time / prop.mDuration);
+            newPercent = prop.mInterpolator.getInterpolation(newPercent);
+            prop.value = prop.mEnd * newPercent + prop.mStart * (1 - newPercent);
+        }
+        onUpdate(percent);
+    }
+
+    public abstract void onUpdate(float percent);
+
+    public final class FloatProp {
+
+        public float value;
+
+        private final float mStart;
+        private final float mEnd;
+        private final float mDelay;
+        private final float mDuration;
+        private final Interpolator mInterpolator;
+
+        public FloatProp(float start, float end, float delay, float duration, Interpolator i) {
+            value = mStart = start;
+            mEnd = end;
+            mDelay = delay;
+            mDuration = duration;
+            mInterpolator = i;
+
+            mAllProperties.add(this);
+        }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/RemoteAnimationProvider.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/RemoteAnimationProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..53ac06536b8266f2c87dd56d829e65900a7dc314
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/RemoteAnimationProvider.java
@@ -0,0 +1,69 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.util;
+
+import android.animation.AnimatorSet;
+import android.app.ActivityOptions;
+import android.os.Handler;
+
+import foundation.e.blisslauncher.LauncherAnimationRunner;
+import com.android.systemui.shared.system.ActivityOptionsCompat;
+import com.android.systemui.shared.system.RemoteAnimationAdapterCompat;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import com.android.systemui.shared.system.TransactionCompat;
+
+@FunctionalInterface
+public interface RemoteAnimationProvider {
+
+    static final int Z_BOOST_BASE = 800570000;
+
+    AnimatorSet createWindowAnimation(RemoteAnimationTargetCompat[] targets);
+
+    default ActivityOptions toActivityOptions(Handler handler, long duration) {
+        LauncherAnimationRunner runner = new LauncherAnimationRunner(handler,
+                false /* startAtFrontOfQueue */) {
+
+            @Override
+            public void onCreateAnimation(RemoteAnimationTargetCompat[] targetCompats,
+                    AnimationResult result) {
+                result.setAnimation(createWindowAnimation(targetCompats));
+            }
+        };
+        return ActivityOptionsCompat.makeRemoteAnimation(
+                new RemoteAnimationAdapterCompat(runner, duration, 0));
+    }
+
+    /**
+     * Prepares the given {@param targets} for a remote animation, and should be called with the
+     * transaction from the first frame of animation.
+     *
+     * @param boostModeTargets The mode indicating which targets to boost in z-order above other
+     *                         targets.
+     */
+    static void prepareTargetsForFirstFrame(RemoteAnimationTargetCompat[] targets,
+            TransactionCompat t, int boostModeTargets) {
+        for (RemoteAnimationTargetCompat target : targets) {
+            t.setLayer(target.leash, getLayer(target, boostModeTargets));
+            t.show(target.leash);
+        }
+    }
+
+    static int getLayer(RemoteAnimationTargetCompat target, int boostModeTarget) {
+        return target.mode == boostModeTarget
+                ? Z_BOOST_BASE + target.prefixOrderIndex
+                : target.prefixOrderIndex;
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/RemoteAnimationTargetSet.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/RemoteAnimationTargetSet.java
new file mode 100644
index 0000000000000000000000000000000000000000..887dc0ed71f466a04c598f6410445c96930e81d7
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/RemoteAnimationTargetSet.java
@@ -0,0 +1,90 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.util;
+
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import com.android.systemui.shared.system.SyncRtSurfaceTransactionApplierCompat;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Queue;
+
+/**
+ * Holds a collection of RemoteAnimationTargets, filtered by different properties.
+ */
+public class RemoteAnimationTargetSet {
+
+    private final Queue<SyncRtSurfaceTransactionApplierCompat> mDependentTransactionAppliers =
+            new ArrayDeque<>(1);
+
+    public final RemoteAnimationTargetCompat[] unfilteredApps;
+    public final RemoteAnimationTargetCompat[] apps;
+    public final int targetMode;
+    public final boolean hasRecents;
+
+    public RemoteAnimationTargetSet(RemoteAnimationTargetCompat[] apps, int targetMode) {
+        ArrayList<RemoteAnimationTargetCompat> filteredApps = new ArrayList<>();
+        boolean hasRecents = false;
+        if (apps != null) {
+            for (RemoteAnimationTargetCompat target : apps) {
+                if (target.mode == targetMode) {
+                    filteredApps.add(target);
+                }
+
+                hasRecents |= target.activityType ==
+                        RemoteAnimationTargetCompat.ACTIVITY_TYPE_RECENTS;
+            }
+        }
+
+        this.unfilteredApps = apps;
+        this.apps = filteredApps.toArray(new RemoteAnimationTargetCompat[filteredApps.size()]);
+        this.targetMode = targetMode;
+        this.hasRecents = hasRecents;
+    }
+
+    public RemoteAnimationTargetCompat findTask(int taskId) {
+        for (RemoteAnimationTargetCompat target : apps) {
+            if (target.taskId == taskId) {
+                return target;
+            }
+        }
+        return null;
+    }
+
+    public boolean isAnimatingHome() {
+        for (RemoteAnimationTargetCompat target : apps) {
+            if (target.activityType == RemoteAnimationTargetCompat.ACTIVITY_TYPE_HOME) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void addDependentTransactionApplier(SyncRtSurfaceTransactionApplierCompat delay) {
+        mDependentTransactionAppliers.add(delay);
+    }
+
+    public void release() {
+        SyncRtSurfaceTransactionApplierCompat applier = mDependentTransactionAppliers.poll();
+        if (applier == null) {
+            for (RemoteAnimationTargetCompat target : unfilteredApps) {
+                target.release();
+            }
+        } else {
+            applier.addAfterApplyCallback(this::release);
+        }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/RemoteFadeOutAnimationListener.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/RemoteFadeOutAnimationListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b3998a866e258386c7b85da9b230c8ea1531a38
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/RemoteFadeOutAnimationListener.java
@@ -0,0 +1,52 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.util;
+
+import static com.android.systemui.shared.system.RemoteAnimationTargetCompat.MODE_CLOSING;
+
+import android.animation.ValueAnimator;
+import android.animation.ValueAnimator.AnimatorUpdateListener;
+import com.android.systemui.shared.system.RemoteAnimationTargetCompat;
+import com.android.systemui.shared.system.TransactionCompat;
+
+/**
+ * Animation listener which fades out the closing targets
+ */
+public class RemoteFadeOutAnimationListener implements AnimatorUpdateListener {
+
+    private final RemoteAnimationTargetSet mTarget;
+    private boolean mFirstFrame = true;
+
+    public RemoteFadeOutAnimationListener(RemoteAnimationTargetCompat[] targets) {
+        mTarget = new RemoteAnimationTargetSet(targets, MODE_CLOSING);
+    }
+
+    @Override
+    public void onAnimationUpdate(ValueAnimator valueAnimator) {
+        TransactionCompat t = new TransactionCompat();
+        if (mFirstFrame) {
+            RemoteAnimationProvider
+                .prepareTargetsForFirstFrame(mTarget.unfilteredApps, t, MODE_CLOSING);
+            mFirstFrame = false;
+        }
+
+        float alpha = 1 - valueAnimator.getAnimatedFraction();
+        for (RemoteAnimationTargetCompat app : mTarget.apps) {
+            t.setAlpha(app.leash, alpha);
+        }
+        t.apply();
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/ResourceBasedOverride.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/ResourceBasedOverride.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1bd63b394223dd4cef13bc33260e0ebf524c45e
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/ResourceBasedOverride.java
@@ -0,0 +1,54 @@
+/*
+ * 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 foundation.e.blisslauncher.quickstep.util;
+
+import android.content.Context;
+import android.text.TextUtils;
+import android.util.Log;
+
+import java.lang.reflect.InvocationTargetException;
+
+/**
+ * An interface to indicate that a class is dynamically loaded using resource overlay, hence its
+ * class name and constructor should be preserved by proguard
+ */
+public interface ResourceBasedOverride {
+
+    class Overrides {
+
+        private static final String TAG = "Overrides";
+
+        public static <T extends ResourceBasedOverride> T getObject(
+                Class<T> clazz, Context context, int resId) {
+            String className = context.getString(resId);
+            if (!TextUtils.isEmpty(className)) {
+                try {
+                    Class<?> cls = Class.forName(className);
+                    return (T) cls.getDeclaredConstructor(Context.class).newInstance(context);
+                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException
+                        | ClassCastException | NoSuchMethodException | InvocationTargetException e) {
+                    Log.e(TAG, "Bad overriden class", e);
+                }
+            }
+
+            try {
+                return clazz.newInstance();
+            } catch (InstantiationException|IllegalAccessException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/Themes.java b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/Themes.java
new file mode 100644
index 0000000000000000000000000000000000000000..583915efefaad6ebe03048e577e9cae3de6aa4bc
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/quickstep/util/Themes.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package foundation.e.blisslauncher.quickstep.util;
+
+import android.content.Context;
+import android.content.res.Configuration;
+import android.content.res.TypedArray;
+import android.graphics.Color;
+import android.graphics.ColorMatrix;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.util.IntArray;
+import android.util.SparseArray;
+import android.util.TypedValue;
+
+import foundation.e.blisslauncher.R;
+
+/**
+ * Various utility methods associated with theming.
+ */
+public class Themes {
+
+    public static String getDefaultBodyFont(Context context) {
+        TypedArray ta = context.obtainStyledAttributes(android.R.style.TextAppearance_DeviceDefault,
+                new int[]{android.R.attr.fontFamily});
+        String value = ta.getString(0);
+        ta.recycle();
+        return value;
+    }
+
+    public static float getDialogCornerRadius(Context context) {
+        return getDimension(context, android.R.attr.dialogCornerRadius,
+                context.getResources().getDimension(R.dimen.default_dialog_corner_radius));
+    }
+
+    public static float getDimension(Context context, int attr, float defaultValue) {
+        TypedArray ta = context.obtainStyledAttributes(new int[]{attr});
+        float value = ta.getDimension(0, defaultValue);
+        ta.recycle();
+        return value;
+    }
+
+    public static int getColorAccent(Context context) {
+        return getAttrColor(context, android.R.attr.colorAccent);
+    }
+
+    public static int getAttrColor(Context context, int attr) {
+        TypedArray ta = context.obtainStyledAttributes(new int[]{attr});
+        int colorAccent = ta.getColor(0, 0);
+        ta.recycle();
+        return colorAccent;
+    }
+
+    public static boolean getAttrBoolean(Context context, int attr) {
+        TypedArray ta = context.obtainStyledAttributes(new int[]{attr});
+        boolean value = ta.getBoolean(0, false);
+        ta.recycle();
+        return value;
+    }
+
+    public static Drawable getAttrDrawable(Context context, int attr) {
+        TypedArray ta = context.obtainStyledAttributes(new int[]{attr});
+        Drawable value = ta.getDrawable(0);
+        ta.recycle();
+        return value;
+    }
+
+    public static int getAttrInteger(Context context, int attr) {
+        TypedArray ta = context.obtainStyledAttributes(new int[]{attr});
+        int value = ta.getInteger(0, 0);
+        ta.recycle();
+        return value;
+    }
+
+    /**
+     * Returns the alpha corresponding to the theme attribute {@param attr}, in the range [0, 255].
+     */
+    public static int getAlpha(Context context, int attr) {
+        TypedArray ta = context.obtainStyledAttributes(new int[]{attr});
+        float alpha = ta.getFloat(0, 0);
+        ta.recycle();
+        return (int) (255 * alpha + 0.5f);
+    }
+
+    /**
+     * Scales a color matrix such that, when applied to color R G B A, it produces R' G' B' A' where
+     * R' = r * R
+     * G' = g * G
+     * B' = b * B
+     * A' = a * A
+     *
+     * The matrix will, for instance, turn white into r g b a, and black will remain black.
+     *
+     * @param color The color r g b a
+     * @param target The ColorMatrix to scale
+     */
+    public static void setColorScaleOnMatrix(int color, ColorMatrix target) {
+        target.setScale(Color.red(color) / 255f, Color.green(color) / 255f,
+                Color.blue(color) / 255f, Color.alpha(color) / 255f);
+    }
+
+    /**
+     * Changes a color matrix such that, when applied to srcColor, it produces dstColor.
+     *
+     * Note that values on the last column of target ColorMatrix can be negative, and may result in
+     * negative values when applied on a color. Such negative values will be automatically shifted
+     * up to 0 by the framework.
+     *
+     * @param srcColor The color to start from
+     * @param dstColor The color to create by applying target on srcColor
+     * @param target The ColorMatrix to transform the color
+     */
+    public static void setColorChangeOnMatrix(int srcColor, int dstColor, ColorMatrix target) {
+        target.reset();
+        target.getArray()[4] = Color.red(dstColor) - Color.red(srcColor);
+        target.getArray()[9] = Color.green(dstColor) - Color.green(srcColor);
+        target.getArray()[14] = Color.blue(dstColor) - Color.blue(srcColor);
+        target.getArray()[19] = Color.alpha(dstColor) - Color.alpha(srcColor);
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/BackButtonAlphaHandler.java b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/BackButtonAlphaHandler.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d7df4fbda1678154358282d3e67150b4a78f980
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/BackButtonAlphaHandler.java
@@ -0,0 +1,72 @@
+/*
+ * 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 foundation.e.blisslauncher.uioverrides;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+
+import foundation.e.blisslauncher.quickstep.OverviewInteractionState;
+
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.LauncherStateManager;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+
+public class BackButtonAlphaHandler implements LauncherStateManager.StateHandler {
+
+    private static final String TAG = "BackButtonAlphaHandler";
+
+    private final TestActivity mLauncher;
+    private final OverviewInteractionState mOverviewInteractionState;
+
+    public BackButtonAlphaHandler(TestActivity launcher) {
+        mLauncher = launcher;
+        mOverviewInteractionState = OverviewInteractionState.INSTANCE.get(mLauncher);
+    }
+
+    @Override
+    public void setState(LauncherState state) {
+        UiFactory.onLauncherStateOrFocusChanged(mLauncher);
+    }
+
+    @Override
+    public void setStateWithAnimation(LauncherState toState,
+            AnimatorSetBuilder builder, LauncherStateManager.AnimationConfig config) {
+        if (!config.playNonAtomicComponent()) {
+            return;
+        }
+        float fromAlpha = mOverviewInteractionState.getBackButtonAlpha();
+        float toAlpha = toState.hideBackButton ? 0 : 1;
+        if (Float.compare(fromAlpha, toAlpha) != 0) {
+            ValueAnimator anim = ValueAnimator.ofFloat(fromAlpha, toAlpha);
+            anim.setDuration(config.duration);
+            anim.addUpdateListener(valueAnimator -> {
+                final float alpha = (float) valueAnimator.getAnimatedValue();
+                mOverviewInteractionState.setBackButtonAlpha(alpha, false);
+            });
+            anim.addListener(new AnimatorListenerAdapter() {
+                @Override
+                public void onAnimationEnd(Animator animation) {
+                    // Reapply the final alpha in case some state (e.g. window focus) changed.
+                    UiFactory.onLauncherStateOrFocusChanged(mLauncher);
+                }
+            });
+            builder.play(anim);
+        }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/BaseRecentsViewStateController.java b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/BaseRecentsViewStateController.java
new file mode 100644
index 0000000000000000000000000000000000000000..8df651d057a1382c575cb25427e6e4f05a4fda42
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/BaseRecentsViewStateController.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2019 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 foundation.e.blisslauncher.uioverrides;
+
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_FADE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_SCALE;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_TRANSLATE_X;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_OVERVIEW_TRANSLATE_Y;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.AGGRESSIVE_EASE_IN_OUT;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+import static foundation.e.blisslauncher.features.test.anim.LauncherAnimUtils.SCALE_PROPERTY;
+
+import android.util.FloatProperty;
+import android.view.View;
+import android.view.animation.Interpolator;
+import androidx.annotation.NonNull;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.LauncherStateManager;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+import foundation.e.blisslauncher.features.test.anim.PropertySetter;
+
+/**
+ * State handler for recents view. Manages UI changes and animations for recents view based off the
+ * current {@link LauncherState}.
+ *
+ * @param <T> the recents view
+ */
+public abstract class BaseRecentsViewStateController<T extends View>
+        implements LauncherStateManager.StateHandler {
+    protected final T mRecentsView;
+    protected final TestActivity mLauncher;
+
+    public BaseRecentsViewStateController(@NonNull TestActivity launcher) {
+        mLauncher = launcher;
+        mRecentsView = launcher.getOverviewPanel();
+    }
+
+    @Override
+    public void setState(@NonNull LauncherState state) {
+        LauncherState.ScaleAndTranslation scaleAndTranslation = state
+                .getOverviewScaleAndTranslation(mLauncher);
+        SCALE_PROPERTY.set(mRecentsView, scaleAndTranslation.scale);
+        float translationX = scaleAndTranslation.translationX;
+        if (mRecentsView.getLayoutDirection() == View.LAYOUT_DIRECTION_RTL) {
+            translationX = -translationX;
+        }
+        mRecentsView.setTranslationX(translationX);
+        mRecentsView.setTranslationY(scaleAndTranslation.translationY);
+        getContentAlphaProperty().set(mRecentsView, state.overviewUi ? 1f : 0);
+    }
+
+    @Override
+    public final void setStateWithAnimation(@NonNull final LauncherState toState,
+            @NonNull AnimatorSetBuilder builder, @NonNull LauncherStateManager.AnimationConfig config) {
+        boolean playAtomicOverviewComponent = config.playAtomicOverviewScaleComponent()
+                || config.playAtomicOverviewPeekComponent();
+        if (!playAtomicOverviewComponent) {
+            // The entire recents animation is played atomically.
+            return;
+        }
+        setStateWithAnimationInternal(toState, builder, config);
+    }
+
+    /**
+     * Core logic for animating the recents view UI.
+     *
+     * @param toState state to animate to
+     * @param builder animator set builder
+     * @param config current animation config
+     */
+    void setStateWithAnimationInternal(@NonNull final LauncherState toState,
+            @NonNull AnimatorSetBuilder builder, @NonNull LauncherStateManager.AnimationConfig config) {
+        PropertySetter setter = config.getPropertySetter(builder);
+        LauncherState.ScaleAndTranslation scaleAndTranslation = toState.getOverviewScaleAndTranslation(mLauncher);
+        Interpolator scaleInterpolator = builder.getInterpolator(ANIM_OVERVIEW_SCALE, LINEAR);
+        setter.setFloat(mRecentsView, SCALE_PROPERTY, scaleAndTranslation.scale, scaleInterpolator);
+        Interpolator translateXInterpolator = builder.getInterpolator(
+                ANIM_OVERVIEW_TRANSLATE_X, LINEAR);
+        Interpolator translateYInterpolator = builder.getInterpolator(
+                ANIM_OVERVIEW_TRANSLATE_Y, LINEAR);
+        float translationX = scaleAndTranslation.translationX;
+        if (mRecentsView.getLayoutDirection() == View.LAYOUT_DIRECTION_RTL) {
+            translationX = -translationX;
+        }
+        setter.setFloat(mRecentsView, View.TRANSLATION_X, translationX, translateXInterpolator);
+        setter.setFloat(mRecentsView, View.TRANSLATION_Y, scaleAndTranslation.translationY,
+                translateYInterpolator);
+        setter.setFloat(mRecentsView, getContentAlphaProperty(), toState.overviewUi ? 1 : 0,
+                builder.getInterpolator(ANIM_OVERVIEW_FADE, AGGRESSIVE_EASE_IN_OUT));
+    }
+
+    /**
+     * Get property for content alpha for the recents view.
+     *
+     * @return the float property for the view's content alpha
+     */
+    abstract FloatProperty getContentAlphaProperty();
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/DisplayRotationListener.java b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/DisplayRotationListener.java
new file mode 100644
index 0000000000000000000000000000000000000000..c51fb8f8b2f45d0a46b15fb1196a9e7cb34848e3
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/DisplayRotationListener.java
@@ -0,0 +1,48 @@
+/*
+ * 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 foundation.e.blisslauncher.uioverrides;
+
+import android.content.Context;
+import android.os.Handler;
+
+import com.android.systemui.shared.system.RotationWatcher;
+
+/**
+ * Utility class for listening for rotation changes
+ */
+public class DisplayRotationListener extends RotationWatcher {
+
+    private final Runnable mCallback;
+    private Handler mHandler;
+
+    public DisplayRotationListener(Context context, Runnable callback) {
+        super(context);
+        mCallback = callback;
+    }
+
+    @Override
+    public void enable() {
+        if (mHandler == null) {
+            mHandler = new Handler();
+        }
+        super.enable();
+    }
+
+    @Override
+    protected void onRotationChanged(int i) {
+        mHandler.post(mCallback);
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/UiFactory.java b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/UiFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3653f52bc38a85c9acb371d7fcccd8bdf6098b4
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/UiFactory.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package foundation.e.blisslauncher.uioverrides;
+
+import static android.app.Activity.RESULT_CANCELED;
+
+import android.animation.AnimatorSet;
+import android.animation.ValueAnimator;
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.util.Base64;
+import com.android.systemui.shared.system.ActivityCompat;
+import foundation.e.blisslauncher.QuickstepAppTransitionManagerImpl;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.LauncherStateManager;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.proxy.ProxyActivityStarter;
+import foundation.e.blisslauncher.proxy.StartActivityParams;
+import foundation.e.blisslauncher.quickstep.OverviewInteractionState;
+import foundation.e.blisslauncher.quickstep.RecentsModel;
+import foundation.e.blisslauncher.quickstep.SysUINavigationMode;
+import foundation.e.blisslauncher.quickstep.util.RemoteFadeOutAnimationListener;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintWriter;
+import java.util.zip.Deflater;
+
+public class UiFactory extends RecentsUiFactory {
+
+    public static Runnable enableLiveUIChanges(TestActivity launcher) {
+        SysUINavigationMode.NavigationModeChangeListener listener = m -> {
+            launcher.getDragLayer().recreateControllers();
+            launcher.getRotationHelper().setRotationHadDifferentUI(m != SysUINavigationMode.Mode.NO_BUTTON);
+        };
+        SysUINavigationMode mode = SysUINavigationMode.INSTANCE.get(launcher);
+        SysUINavigationMode.Mode m = mode.addModeChangeListener(listener);
+        launcher.getRotationHelper().setRotationHadDifferentUI(m != SysUINavigationMode.Mode.NO_BUTTON);
+        return () -> mode.removeModeChangeListener(listener);
+    }
+
+    public static LauncherStateManager.StateHandler[] getStateHandler(TestActivity launcher) {
+        return new LauncherStateManager.StateHandler[] {
+                launcher.getLauncherPagedView(),
+                createRecentsViewStateController(launcher),
+                new BackButtonAlphaHandler(launcher)};
+    }
+
+    /**
+     * Sets the back button visibility based on the current state/window focus.
+     */
+    public static void onLauncherStateOrFocusChanged(TestActivity launcher) {
+        boolean shouldBackButtonBeHidden = launcher != null
+                && launcher.getStateManager().getState().hideBackButton
+                && launcher.hasWindowFocus();
+        if (shouldBackButtonBeHidden) {
+            // Show the back button if there is a floating view visible.
+            shouldBackButtonBeHidden = true;
+        }
+        OverviewInteractionState.INSTANCE.get(launcher)
+                .setBackButtonAlpha(shouldBackButtonBeHidden ? 0 : 1, true /* animate */);
+        if (launcher != null && launcher.getDragLayer() != null) {
+            launcher.getRootView().setDisallowBackGesture(shouldBackButtonBeHidden);
+        }
+    }
+
+    public static void onCreate(TestActivity launcher) {
+
+        /*if (!launcher.getSharedPrefs().getBoolean(SHELF_BOUNCE_SEEN, false)) {
+            launcher.getStateManager().addStateListener(new LauncherStateManager.StateListener() {
+                @Override
+                public void onStateTransitionStart(LauncherState toState) {
+                }
+
+                @Override
+                public void onStateTransitionComplete(LauncherState finalState) {
+                    LauncherState prevState = launcher.getStateManager().getLastState();
+
+                    if ((finalState == ALL_APPS && prevState == OVERVIEW) || BOUNCE_MAX_COUNT <=
+                            launcher.getSharedPrefs().getInt(SHELF_BOUNCE_COUNT, 0)) {
+                        launcher.getSharedPrefs().edit().putBoolean(SHELF_BOUNCE_SEEN, true).apply();
+                        launcher.getStateManager().removeStateListener(this);
+                    }
+                }
+            });
+        }*/
+    }
+
+    public static void onEnterAnimationComplete(Context context) {
+        // After the transition to home, enable the high-res thumbnail loader if it wasn't enabled
+        // as a part of quickstep, so that high-res thumbnails can load the next time we enter
+        // overview
+        RecentsModel.INSTANCE.get(context).getThumbnailCache()
+                .getHighResLoadingState().setVisible(true);
+    }
+
+    public static void onTrimMemory(Context context, int level) {
+        RecentsModel model = RecentsModel.INSTANCE.get(context);
+        if (model != null) {
+            model.onTrimMemory(level);
+        }
+    }
+
+    public static void useFadeOutAnimationForLauncherStart(TestActivity launcher,
+            CancellationSignal cancellationSignal) {
+        QuickstepAppTransitionManagerImpl appTransitionManager =
+                (QuickstepAppTransitionManagerImpl) launcher.getAppTransitionManager();
+        appTransitionManager.setRemoteAnimationProvider((targets) -> {
+
+            // On the first call clear the reference.
+            cancellationSignal.cancel();
+
+            ValueAnimator fadeAnimation = ValueAnimator.ofFloat(1, 0);
+            fadeAnimation.addUpdateListener(new RemoteFadeOutAnimationListener(targets));
+            AnimatorSet anim = new AnimatorSet();
+            anim.play(fadeAnimation);
+            return anim;
+        }, cancellationSignal);
+    }
+
+    public static boolean dumpActivity(Activity activity, PrintWriter writer) {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        if (!(new ActivityCompat(activity).encodeViewHierarchy(out))) {
+            return false;
+        }
+
+        Deflater deflater = new Deflater();
+        deflater.setInput(out.toByteArray());
+        deflater.finish();
+
+        out.reset();
+        byte[] buffer = new byte[1024];
+        while (!deflater.finished()) {
+            int count = deflater.deflate(buffer); // returns the generated code... index
+            out.write(buffer, 0, count);
+        }
+
+        writer.println("--encoded-view-dump-v0--");
+        writer.println(Base64.encodeToString(
+                out.toByteArray(), Base64.NO_WRAP | Base64.NO_PADDING));
+        return true;
+    }
+
+    public static boolean startIntentSenderForResult(Activity activity, IntentSender intent,
+            int requestCode, Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags,
+            Bundle options) {
+        StartActivityParams params = new StartActivityParams(activity, requestCode);
+        params.intentSender = intent;
+        params.fillInIntent = fillInIntent;
+        params.flagsMask = flagsMask;
+        params.flagsValues = flagsValues;
+        params.extraFlags = extraFlags;
+        params.options = options;
+        ((Context) activity).startActivity(ProxyActivityStarter.getLaunchIntent(activity, params));
+        return true;
+    }
+
+    public static boolean startActivityForResult(Activity activity, Intent intent, int requestCode,
+            Bundle options) {
+        StartActivityParams params = new StartActivityParams(activity, requestCode);
+        params.intent = intent;
+        params.options = options;
+        activity.startActivity(ProxyActivityStarter.getLaunchIntent(activity, params));
+        return true;
+    }
+
+    /**
+     * Removes any active ProxyActivityStarter task and sends RESULT_CANCELED to Launcher.
+     *
+     * ProxyActivityStarter is started with clear task to reset the task after which it removes the
+     * task itself.
+     */
+    public static void resetPendingActivityResults(TestActivity launcher, int requestCode) {
+        launcher.onActivityResult(requestCode, RESULT_CANCELED, null);
+        launcher.startActivity(ProxyActivityStarter.getLaunchIntent(launcher, null));
+    }
+
+    public static LauncherState.ScaleAndTranslation getOverviewScaleAndTranslationForNormalState(TestActivity l) {
+        if (SysUINavigationMode.getMode(l) == SysUINavigationMode.Mode.NO_BUTTON) {
+            float offscreenTranslationX = l.getDeviceProfile().getWidthPx()
+                    - l.getOverviewPanel().getPaddingStart();
+            return new LauncherState.ScaleAndTranslation(1f, offscreenTranslationX, 0f);
+        }
+        return new LauncherState.ScaleAndTranslation(1.1f, 0f, 0f);
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/LandscapeEdgeSwipeController.java b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/LandscapeEdgeSwipeController.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa5f2e8eb7689055be9bdb15500e73912623adcf
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/LandscapeEdgeSwipeController.java
@@ -0,0 +1,65 @@
+package foundation.e.blisslauncher.uioverrides.touchcontrollers;
+
+import static foundation.e.blisslauncher.core.Utilities.EDGE_NAV_BAR;
+import static foundation.e.blisslauncher.features.test.LauncherState.NORMAL;
+import static foundation.e.blisslauncher.features.test.LauncherState.OVERVIEW;
+
+import android.view.MotionEvent;
+import foundation.e.blisslauncher.core.customviews.AbstractFloatingView;
+import foundation.e.blisslauncher.core.touch.AbstractStateChangeTouchController;
+import foundation.e.blisslauncher.core.touch.SwipeDetector;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.LauncherStateManager;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.quickstep.RecentsModel;
+
+/**
+ * Touch controller for handling edge swipes in landscape/seascape UI
+ */
+public class LandscapeEdgeSwipeController extends AbstractStateChangeTouchController {
+
+    private static final String TAG = "LandscapeEdgeSwipeCtrl";
+
+    public LandscapeEdgeSwipeController(TestActivity l) {
+        super(l, SwipeDetector.HORIZONTAL);
+    }
+
+    @Override
+    protected boolean canInterceptTouch(MotionEvent ev) {
+        if (mCurrentAnimation != null) {
+            // If we are already animating from a previous state, we can intercept.
+            return true;
+        }
+        if (AbstractFloatingView.getTopOpenView(mLauncher) != null) {
+            return false;
+        }
+        return mLauncher.isInState(NORMAL) && (ev.getEdgeFlags() & EDGE_NAV_BAR) != 0;
+    }
+
+    @Override
+    protected LauncherState getTargetState(LauncherState fromState, boolean isDragTowardPositive) {
+        boolean draggingFromNav = !isDragTowardPositive;
+        return draggingFromNav ? OVERVIEW : NORMAL;
+    }
+
+    protected float getShiftRange() {
+        return mLauncher.getDragLayer().getWidth();
+    }
+
+    @Override
+    protected float initCurrentAnimation(@LauncherStateManager.AnimationComponents int animComponent) {
+        float range = getShiftRange();
+        long maxAccuracy = (long) (2 * range);
+        mCurrentAnimation = mLauncher.getStateManager().createAnimationToNewWorkspace(mToState,
+                maxAccuracy, animComponent);
+        return -2 / range;
+    }
+
+    @Override
+    protected void onSwipeInteractionCompleted(LauncherState targetState) {
+        super.onSwipeInteractionCompleted(targetState);
+        if (mStartState == NORMAL && targetState == OVERVIEW) {
+            RecentsModel.INSTANCE.get(mLauncher).onOverviewShown(true, TAG);
+        }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/PortraitStatesTouchController.java b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/PortraitStatesTouchController.java
new file mode 100644
index 0000000000000000000000000000000000000000..65fabd5d963d172fab3a83d93aed9ba97efcea64
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/PortraitStatesTouchController.java
@@ -0,0 +1,247 @@
+/*
+ * 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 foundation.e.blisslauncher.uioverrides.touchcontrollers;
+
+import static foundation.e.blisslauncher.features.test.LauncherState.NORMAL;
+import static foundation.e.blisslauncher.features.test.LauncherState.OVERVIEW;
+import static foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder.ANIM_VERTICAL_PROGRESS;
+import static foundation.e.blisslauncher.features.test.anim.Interpolators.LINEAR;
+
+import android.animation.TimeInterpolator;
+import android.animation.ValueAnimator;
+import android.view.MotionEvent;
+import android.view.animation.Interpolator;
+import foundation.e.blisslauncher.core.touch.AbstractStateChangeTouchController;
+import foundation.e.blisslauncher.core.touch.SwipeDetector;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.LauncherStateManager;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.features.test.anim.AnimatorPlaybackController;
+import foundation.e.blisslauncher.features.test.anim.AnimatorSetBuilder;
+import foundation.e.blisslauncher.features.test.anim.Interpolators;
+import foundation.e.blisslauncher.quickstep.OverviewInteractionState;
+import foundation.e.blisslauncher.quickstep.RecentsModel;
+import foundation.e.blisslauncher.quickstep.util.LayoutUtils;
+import foundation.e.blisslauncher.uioverrides.states.OverviewState;
+
+/**
+ * Touch controller for handling various state transitions in portrait UI.
+ */
+public class PortraitStatesTouchController extends AbstractStateChangeTouchController {
+
+    private static final String TAG = "PortraitStatesTouchCtrl";
+
+    /**
+     * The progress at which all apps content will be fully visible when swiping up from overview.
+     */
+    private static final float ALL_APPS_CONTENT_FADE_THRESHOLD = 0.08f;
+
+    /**
+     * The progress at which recents will begin fading out when swiping up from overview.
+     */
+    private static final float RECENTS_FADE_THRESHOLD = 0.88f;
+
+    private final PortraitOverviewStateTouchHelper mOverviewPortraitStateTouchHelper;
+
+    private final InterpolatorWrapper mAllAppsInterpolatorWrapper = new InterpolatorWrapper();
+
+    private final boolean mAllowDragToOverview;
+
+    // If true, we will finish the current animation instantly on second touch.
+    private boolean mFinishFastOnSecondTouch;
+
+    public PortraitStatesTouchController(TestActivity l, boolean allowDragToOverview) {
+        super(l, SwipeDetector.VERTICAL);
+        mOverviewPortraitStateTouchHelper = new PortraitOverviewStateTouchHelper(l);
+        mAllowDragToOverview = allowDragToOverview;
+    }
+
+    @Override
+    protected boolean canInterceptTouch(MotionEvent ev) {
+        if (mCurrentAnimation != null) {
+            if (mFinishFastOnSecondTouch) {
+                // TODO: Animate to finish instead.
+                mCurrentAnimation.skipToEnd();
+            }
+            // Otherwise, make sure everything is settled and don't intercept so they can scroll
+            // recents, dismiss a task, etc.
+            if (mAtomicAnim != null) {
+                mAtomicAnim.end();
+            }
+            return false;
+        }
+       if (mLauncher.isInState(OVERVIEW)) {
+            if (!mOverviewPortraitStateTouchHelper.canInterceptTouch(ev)) {
+                return false;
+            }
+        } else {
+            // If we are swiping to all apps instead of overview, allow it from anywhere.
+            boolean interceptAnywhere = mLauncher.isInState(NORMAL) && !mAllowDragToOverview;
+            // For all other states, only listen if the event originated below the hotseat height
+            if (!interceptAnywhere && !isTouchOverHotseat(mLauncher, ev)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    protected LauncherState getTargetState(LauncherState fromState, boolean isDragTowardPositive) {
+        if (fromState == OVERVIEW) {
+            return  NORMAL;
+        } else if (fromState == NORMAL && isDragTowardPositive) {
+            int stateFlags = OverviewInteractionState.INSTANCE.get(mLauncher)
+                    .getSystemUiStateFlags();
+            return OVERVIEW;
+        }
+        return fromState;
+    }
+
+    private AnimatorSetBuilder getNormalToOverviewAnimation() {
+        mAllAppsInterpolatorWrapper.baseInterpolator = LINEAR;
+
+        AnimatorSetBuilder builder = new AnimatorSetBuilder();
+        builder.setInterpolator(ANIM_VERTICAL_PROGRESS, mAllAppsInterpolatorWrapper);
+        return builder;
+    }
+
+    @Override
+    protected AnimatorSetBuilder getAnimatorSetBuilderForStates(LauncherState fromState,
+            LauncherState toState) {
+        AnimatorSetBuilder builder = new AnimatorSetBuilder();
+        if (fromState == NORMAL && toState == OVERVIEW) {
+            builder = getNormalToOverviewAnimation();
+        }
+        return builder;
+    }
+
+    @Override
+    protected float initCurrentAnimation(@LauncherStateManager.AnimationComponents int animComponents) {
+        float range = getShiftRange();
+        long maxAccuracy = (long) (2 * range);
+
+        float startVerticalShift = mFromState.getVerticalProgress(mLauncher) * range;
+        float endVerticalShift = mToState.getVerticalProgress(mLauncher) * range;
+
+        float totalShift = endVerticalShift - startVerticalShift;
+
+        final AnimatorSetBuilder builder = totalShift == 0 ? new AnimatorSetBuilder()
+                : getAnimatorSetBuilderForStates(mFromState, mToState);
+        updateAnimatorBuilderOnReinit(builder);
+
+        cancelPendingAnim();
+
+        if (mFromState == OVERVIEW && mToState == NORMAL
+                && mOverviewPortraitStateTouchHelper.shouldSwipeDownReturnToApp()) {
+            // Reset the state manager, when changing the interaction mode
+            mLauncher.getStateManager().goToState(OVERVIEW, false /* animate */);
+            mPendingAnimation = mOverviewPortraitStateTouchHelper
+                    .createSwipeDownToTaskAppAnimation(maxAccuracy);
+            mPendingAnimation.anim.setInterpolator(Interpolators.LINEAR);
+
+            Runnable onCancelRunnable = () -> {
+                cancelPendingAnim();
+                clearState();
+            };
+            mCurrentAnimation = AnimatorPlaybackController.wrap(mPendingAnimation.anim, maxAccuracy,
+                    onCancelRunnable);
+            mLauncher.getStateManager().setCurrentUserControlledAnimation(mCurrentAnimation);
+            totalShift = LayoutUtils.getShelfTrackingDistance(mLauncher,
+                    mLauncher.getDeviceProfile());
+        } else {
+            mCurrentAnimation = mLauncher.getStateManager()
+                    .createAnimationToNewWorkspace(mToState, builder, maxAccuracy, this::clearState,
+                            animComponents);
+        }
+
+        if (totalShift == 0) {
+            totalShift = Math.signum(mFromState.ordinal - mToState.ordinal)
+                    * OverviewState.getDefaultSwipeHeight(mLauncher);
+        }
+        return 1 / totalShift;
+    }
+
+    /**
+     * Give subclasses the chance to update the animation when we re-initialize towards a new state.
+     */
+    protected void updateAnimatorBuilderOnReinit(AnimatorSetBuilder builder) {
+    }
+
+    private void cancelPendingAnim() {
+        if (mPendingAnimation != null) {
+            mPendingAnimation.finish(false);
+            mPendingAnimation = null;
+        }
+    }
+
+    @Override
+    protected void updateSwipeCompleteAnimation(ValueAnimator animator, long expectedDuration,
+            LauncherState targetState, float velocity, boolean isFling) {
+        super.updateSwipeCompleteAnimation(animator, expectedDuration, targetState,
+                velocity, isFling);
+        handleFirstSwipeToOverview(animator, expectedDuration, targetState, velocity, isFling);
+    }
+
+    private void handleFirstSwipeToOverview(final ValueAnimator animator,
+            final long expectedDuration, final LauncherState targetState, final float velocity,
+            final boolean isFling) {
+        if (mFromState == NORMAL && mToState == OVERVIEW && targetState == OVERVIEW) {
+            mFinishFastOnSecondTouch = true;
+            if (isFling && expectedDuration != 0) {
+                // Update all apps interpolator to add a bit of overshoot starting from currFraction
+                final float currFraction = mCurrentAnimation.getProgressFraction();
+                mAllAppsInterpolatorWrapper.baseInterpolator = Interpolators.clampToProgress(
+                        Interpolators.overshootInterpolatorForVelocity(velocity), currFraction, 1);
+                animator.setDuration(Math.min(expectedDuration, ATOMIC_DURATION))
+                        .setInterpolator(LINEAR);
+            }
+        } else {
+            mFinishFastOnSecondTouch = false;
+        }
+    }
+
+    @Override
+    protected void onSwipeInteractionCompleted(LauncherState targetState) {
+        super.onSwipeInteractionCompleted(targetState);
+        if (mStartState == NORMAL && targetState == OVERVIEW) {
+            RecentsModel.INSTANCE.get(mLauncher).onOverviewShown(true, TAG);
+        }
+    }
+
+    /**
+     * Whether the motion event is over the hotseat.
+     *
+     * @param launcher the launcher activity
+     * @param ev the event to check
+     * @return true if the event is over the hotseat
+     */
+    static boolean isTouchOverHotseat(TestActivity launcher, MotionEvent ev) {
+        VariantDeviceProfile dp = launcher.getDeviceProfile();
+        int hotseatHeight = dp.getHotseatBarSizePx() + dp.getInsets().bottom;
+        return (ev.getY() >= (launcher.getDragLayer().getHeight() - hotseatHeight));
+    }
+
+    private static class InterpolatorWrapper implements Interpolator {
+
+        public TimeInterpolator baseInterpolator = LINEAR;
+
+        @Override
+        public float getInterpolation(float v) {
+            return baseInterpolator.getInterpolation(v);
+        }
+    }
+}
diff --git a/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/StatusBarTouchController.java b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/StatusBarTouchController.java
new file mode 100644
index 0000000000000000000000000000000000000000..6365a2ca20eb971148235dc29e5e68e10554ce0d
--- /dev/null
+++ b/app/src/quickstep/src/foundation/e/blisslauncher/uioverrides/touchcontrollers/StatusBarTouchController.java
@@ -0,0 +1,124 @@
+/*
+ * 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 foundation.e.blisslauncher.uioverrides.touchcontrollers;
+
+import static android.view.MotionEvent.ACTION_DOWN;
+import static android.view.MotionEvent.ACTION_MOVE;
+
+import android.os.RemoteException;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.ViewConfiguration;
+import com.android.systemui.shared.recents.ISystemUiProxy;
+import foundation.e.blisslauncher.core.customviews.AbstractFloatingView;
+import foundation.e.blisslauncher.core.touch.TouchEventTranslator;
+import foundation.e.blisslauncher.features.test.LauncherState;
+import foundation.e.blisslauncher.features.test.TestActivity;
+import foundation.e.blisslauncher.features.test.TouchController;
+import foundation.e.blisslauncher.features.test.VariantDeviceProfile;
+import foundation.e.blisslauncher.quickstep.RecentsModel;
+
+/**
+ * TouchController for handling touch events that get sent to the StatusBar. Once the
+ * Once the event delta y passes the touch slop, the events start getting forwarded.
+ * All events are offset by initial Y value of the pointer.
+ */
+public class StatusBarTouchController implements TouchController {
+
+    private static final String TAG = "StatusBarController";
+
+    protected final TestActivity mLauncher;
+    protected final TouchEventTranslator mTranslator;
+    private final float mTouchSlop;
+    private ISystemUiProxy mSysUiProxy;
+    private int mLastAction;
+
+    /* If {@code false}, this controller should not handle the input {@link MotionEvent}.*/
+    private boolean mCanIntercept;
+
+    public StatusBarTouchController(TestActivity l) {
+        mLauncher = l;
+        // Guard against TAPs by increasing the touch slop.
+        mTouchSlop = 2 * ViewConfiguration.get(l).getScaledTouchSlop();
+        mTranslator = new TouchEventTranslator((MotionEvent ev)-> dispatchTouchEvent(ev));
+    }
+
+    private void dispatchTouchEvent(MotionEvent ev) {
+        try {
+            if (mSysUiProxy != null) {
+                mLastAction = ev.getActionMasked();
+                mSysUiProxy.onStatusBarMotionEvent(ev);
+            }
+        } catch (RemoteException e) {
+            Log.e(TAG, "Remote exception on sysUiProxy.", e);
+        }
+    }
+
+    @Override
+    public final boolean onControllerInterceptTouchEvent(MotionEvent ev) {
+        int action = ev.getActionMasked();
+        if (action == ACTION_DOWN) {
+            mCanIntercept = canInterceptTouch(ev);
+            if (!mCanIntercept) {
+                return false;
+            }
+            mTranslator.reset();
+            mTranslator.setDownParameters(0, ev);
+        } else if (ev.getActionMasked() == MotionEvent.ACTION_POINTER_DOWN) {
+            // Check!! should only set it only when threshold is not entered.
+            mTranslator.setDownParameters(ev.getActionIndex(), ev);
+        }
+        if (!mCanIntercept) {
+            return false;
+        }
+        if (action == ACTION_MOVE) {
+            float dy = ev.getY() - mTranslator.getDownY();
+            float dx = ev.getX() - mTranslator.getDownX();
+            if (dy > mTouchSlop && dy > Math.abs(dx)) {
+                mTranslator.dispatchDownEvents(ev);
+                mTranslator.processMotionEvent(ev);
+                return true;
+            }
+            if (Math.abs(dx) > mTouchSlop) {
+                mCanIntercept = false;
+            }
+        }
+        return false;
+    }
+
+
+    @Override
+    public final boolean onControllerTouchEvent(MotionEvent ev) {
+        mTranslator.processMotionEvent(ev);
+        return true;
+    }
+
+    private boolean canInterceptTouch(MotionEvent ev) {
+        if (!mLauncher.isInState(LauncherState.NORMAL) ||
+                AbstractFloatingView.getTopOpenViewWithType(mLauncher,
+                        AbstractFloatingView.TYPE_STATUS_BAR_SWIPE_DOWN_DISALLOW) != null) {
+            return false;
+        } else {
+            // For NORMAL state, only listen if the event originated above the navbar height
+            VariantDeviceProfile dp = mLauncher.getDeviceProfile();
+            if (ev.getY() > (mLauncher.getDragLayer().getHeight() - dp.getInsets().bottom)) {
+                return false;
+            }
+        }
+        mSysUiProxy = RecentsModel.INSTANCE.get(mLauncher).getSystemUiProxy();
+        return mSysUiProxy != null;
+    }
+}
diff --git a/app/src/test/java/foundation/e/blisslauncher/core/events/EventRelayTest.java b/app/src/test/java/foundation/e/blisslauncher/core/events/EventRelayTest.java
index 100b138b7373c1d9360343bcc68c1a6139f2363f..6ad3b8b44b928cee31f22682eaf38acb32be0e81 100644
--- a/app/src/test/java/foundation/e/blisslauncher/core/events/EventRelayTest.java
+++ b/app/src/test/java/foundation/e/blisslauncher/core/events/EventRelayTest.java
@@ -1,5 +1,11 @@
 package foundation.e.blisslauncher.core.events;
 
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -7,13 +13,6 @@ import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.junit.MockitoJUnitRunner;
 
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
 @RunWith(MockitoJUnitRunner.class)
 @SuppressWarnings("unchecked")
 public class EventRelayTest {
diff --git a/build.gradle b/build.gradle
index b16585da3cd92cc633a807572210d032cffcbd41..37b6651f09df915e2917d8704e3b007434766a56 100755
--- a/build.gradle
+++ b/build.gradle
@@ -15,16 +15,12 @@ buildscript {
 
         classpath Libs.Kotlin.gradlePlugin
         classpath Libs.Kotlin.extensions
-
-        classpath Libs.Google.fabricPlugin
-        classpath Libs.Google.gmsGoogleServices
-
         classpath Libs.dexcountGradlePlugin
     }
 }
 
 plugins {
-    id "com.diffplug.gradle.spotless" version "3.14.0"
+    id "com.diffplug.spotless" version "5.12.4"
     id 'com.github.ben-manes.versions' version "0.25.0"
 }
 
@@ -35,23 +31,16 @@ allprojects {
         maven { url 'https://jitpack.io' }
         mavenCentral()
     }
-}
 
-subprojects {
-    apply plugin: 'com.diffplug.gradle.spotless'
-    spotless {
-        java {
-            target '**/*.java'
-            removeUnusedImports() // removes any unused imports
-        }
-        kotlin {
-            target "**/*.kt"
-            ktlint()
+    ext.addFrameworkJar = { String path ->
+        def frameworkJar = new File(rootProject.projectDir, 'app/libs/' + path)
+        if (!frameworkJar.exists()) {
+            throw new IllegalArgumentException("Framework jar path doesn't exist")
         }
-        kotlinGradle {
-            // same as kotlin, but for .gradle.kts files (defaults to '*.gradle.kts')
-            target '*.gradle.kts', 'additionalScripts/*.gradle.kts'
-            ktlint()
+        gradle.projectsEvaluated {
+            tasks.withType(JavaCompile) {
+                options.bootstrapClasspath = files([frameworkJar] + (options.bootstrapClasspath.files as Iterable<File>))
+            }
         }
     }
 }
diff --git a/buildSrc/src/main/java/foundation/e/blisslauncher/buildsrc/Dependencies.kt b/buildSrc/src/main/java/foundation/e/blisslauncher/buildsrc/Dependencies.kt
index 5575c7e471e16c9e1ac049d904f9c215534eba9d..65ee7d1dc0100eb38bbb64f96db182bc2e8ea283 100644
--- a/buildSrc/src/main/java/foundation/e/blisslauncher/buildsrc/Dependencies.kt
+++ b/buildSrc/src/main/java/foundation/e/blisslauncher/buildsrc/Dependencies.kt
@@ -2,11 +2,11 @@ package foundation.e.blisslauncher.buildsrc
 
 object Versions {
     const val compile_sdk = 29
-    const val min_sdk = 24
+    const val min_sdk = 25
     const val target_sdk = 29
-    const val android_gradle_plugin = "3.5.0"
-    const val dexcount_gradle_plugin = "0.8.6"
-    const val kotlin = "1.3.41"
+    const val android_gradle_plugin = "4.2.2"
+    const val dexcount_gradle_plugin = "2.0.0"
+    const val kotlin = "1.5.10"
     const val timber = "4.7.1"
     const val junit = "4.12"
     const val robolectric = "4.3"
diff --git a/data/build.gradle b/data/build.gradle
index 2e3d8bef1a129ba62261e72536de0005069fd18a..644f1409a108c36eecbfc204d98179d86d7cd3f4 100644
--- a/data/build.gradle
+++ b/data/build.gradle
@@ -4,6 +4,7 @@ import foundation.e.blisslauncher.buildsrc.Versions
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 apply plugin: 'kotlin-kapt'
+apply from: '../spotless/spotless.gradle'
 
 android {
     compileSdkVersion Versions.compile_sdk
diff --git a/data/src/test/java/foundation/e/blisslauncher/data/ExampleUnitTest.kt b/data/src/test/java/foundation/e/blisslauncher/data/ExampleUnitTest.kt
index 1ed56b7767ccab8a8a712e68cf1a5c82dbdb4bde..eb7c58612d315b9b04063db8811d2035a1879ce2 100644
--- a/data/src/test/java/foundation/e/blisslauncher/data/ExampleUnitTest.kt
+++ b/data/src/test/java/foundation/e/blisslauncher/data/ExampleUnitTest.kt
@@ -1,8 +1,7 @@
 package foundation.e.blisslauncher.data
 
-import org.junit.Test
-
 import org.junit.Assert
+import org.junit.Test
 
 /**
  * Example local unit test, which will execute on the development machine (host).
diff --git a/domain/build.gradle b/domain/build.gradle
index dcca293e86e96225fcd3f89989e9c55b37b87f1c..a893d1019d8e5adf5f880649de46659e8962861f 100644
--- a/domain/build.gradle
+++ b/domain/build.gradle
@@ -4,6 +4,7 @@ import foundation.e.blisslauncher.buildsrc.Versions
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 apply plugin: 'kotlin-kapt'
+apply from: '../spotless/spotless.gradle'
 
 android {
     compileSdkVersion Versions.compile_sdk
diff --git a/domain/src/main/java/foundation/e/blisslauncher/domain/executors/PostExecutionThread.kt b/domain/src/main/java/foundation/e/blisslauncher/domain/executors/PostExecutionThread.kt
index ba8ed2ca00f0cd30c86908b522b3adf42eedacdd..3a80de7b12ccf3c908da3ed340b7937b2924116a 100644
--- a/domain/src/main/java/foundation/e/blisslauncher/domain/executors/PostExecutionThread.kt
+++ b/domain/src/main/java/foundation/e/blisslauncher/domain/executors/PostExecutionThread.kt
@@ -4,4 +4,4 @@ import io.reactivex.Scheduler
 
 interface PostExecutionThread {
     val scheduler: Scheduler
-}
\ No newline at end of file
+}
diff --git a/domain/src/main/java/foundation/e/blisslauncher/domain/executors/ThreadExecutor.kt b/domain/src/main/java/foundation/e/blisslauncher/domain/executors/ThreadExecutor.kt
index f2b27ad31beacca6d30360477de737e9baa5f98a..8c42d0692381c2e0695a7fae8b9b8e20ad28fcf3 100644
--- a/domain/src/main/java/foundation/e/blisslauncher/domain/executors/ThreadExecutor.kt
+++ b/domain/src/main/java/foundation/e/blisslauncher/domain/executors/ThreadExecutor.kt
@@ -2,4 +2,4 @@ package foundation.e.blisslauncher.domain.executors
 
 import java.util.concurrent.Executor
 
-interface ThreadExecutor : Executor
\ No newline at end of file
+interface ThreadExecutor : Executor
diff --git a/domain/src/main/java/foundation/e/blisslauncher/domain/interactors/Interactor.kt b/domain/src/main/java/foundation/e/blisslauncher/domain/interactors/Interactor.kt
index 144ad143f1e9ea9003559ac72ca3be03011eae04..f6cd34da1b0511b5a5cb672b73dff68513e492bb 100644
--- a/domain/src/main/java/foundation/e/blisslauncher/domain/interactors/Interactor.kt
+++ b/domain/src/main/java/foundation/e/blisslauncher/domain/interactors/Interactor.kt
@@ -49,4 +49,4 @@ abstract class CompletableInteractor<in P> : Interactor<P>, Disposable {
     override fun dispose() = disposables.dispose()
 
     override fun isDisposed(): Boolean = disposables.isDisposed
-}
\ No newline at end of file
+}
diff --git a/domain/src/test/java/foundation/e/blisslauncher/domain/ExampleUnitTest.kt b/domain/src/test/java/foundation/e/blisslauncher/domain/ExampleUnitTest.kt
index 7c5a7b55e68f9443f2d8e80a4d187df12feeb94d..16b020231987a7d0dc64e208efd2838bd06a38d7 100644
--- a/domain/src/test/java/foundation/e/blisslauncher/domain/ExampleUnitTest.kt
+++ b/domain/src/test/java/foundation/e/blisslauncher/domain/ExampleUnitTest.kt
@@ -1,8 +1,7 @@
 package foundation.e.blisslauncher.domain
 
-import org.junit.Test
-
 import org.junit.Assert.assertEquals
+import org.junit.Test
 
 /**
  * Example local unit test, which will execute on the development machine (host).
diff --git a/gradle.properties b/gradle.properties
index 4b862715dc7d100816ac4837adabc43b5687ee0f..9482d318a64ac820e61c1ac5092e6ba357f08524 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -24,4 +24,4 @@ android.useAndroidX=true
 android.enableJetifier=true
 
 # The default memory is 512m
-org.gradle.jvmargs=-Xmx1g
+org.gradle.jvmargs=-Xmx4g
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index fd7090066b6d91bcf4344445eacb2453dd111696..f52e14384f0a91eaf2983c670f2bf171aa6ff04b 100755
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Tue Nov 12 21:21:51 IST 2019
+#Fri Jul 09 22:53:52 IST 2021
 distributionBase=GRADLE_USER_HOME
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
 distributionPath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip
+zipStoreBase=GRADLE_USER_HOME
diff --git a/keystore/platform.keystore b/keystore/platform.keystore
new file mode 100644
index 0000000000000000000000000000000000000000..574b2203d6dc78b3853cf899c3c7a1f60c773507
Binary files /dev/null and b/keystore/platform.keystore differ
diff --git a/settings.gradle b/settings.gradle
index e70334ca2e10a41e1aa63b764f3f9d4b645171e5..a22df8a494b74fbf3216fcde191ceda2fbd68e9c 100755
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,3 +1,4 @@
 include ':app'
 include ':data'
-include ':domain'
\ No newline at end of file
+include ':domain'
+include ':SystemUISharedLib', ':QuickstepCompat', ':QuickstepCompatVQ'
diff --git a/spotless/spotless.gradle b/spotless/spotless.gradle
new file mode 100644
index 0000000000000000000000000000000000000000..c82509da652bb0cc56e95ba6d68a062d01c4f1d0
--- /dev/null
+++ b/spotless/spotless.gradle
@@ -0,0 +1,17 @@
+apply plugin: 'com.diffplug.spotless'
+spotless {
+    java {
+        target '**/*.java'
+        importOrder() // standard import order
+        removeUnusedImports() // removes any unused imports
+    }
+    kotlin {
+        target "**/*.kt"
+        ktlint().userData([disabled_rules:"no-wildcard-imports"])
+    }
+    kotlinGradle {
+        // same as kotlin, but for .gradle.kts files (defaults to '*.gradle.kts')
+        target '*.gradle.kts', 'additionalScripts/*.gradle.kts'
+        ktlint()
+    }
+}
\ No newline at end of file