diff --git a/lawnchair/res/layout/floating_surface_view.xml b/lawnchair/res/layout/floating_surface_view.xml
new file mode 100644
index 00000000000..c43e100f322
--- /dev/null
+++ b/lawnchair/res/layout/floating_surface_view.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<app.lawnchair.views.LawnchairFloatingSurfaceView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content" />
\ No newline at end of file
diff --git a/lawnchair/res/values/config.xml b/lawnchair/res/values/config.xml
index ac0261ce4b8..b712c206df6 100644
--- a/lawnchair/res/values/config.xml
+++ b/lawnchair/res/values/config.xml
@@ -96,6 +96,9 @@
     <!-- which web search provider to use by default -->
     <string name="config_default_web_suggestion_provider" translatable="false">google</string>
 
+    <!-- which overlay to use by default -->
+    <string name="config_default_overlay" translatable="false">suck_in</string>
+
     <bool name="config_default_show_hotseat">true</bool>
     <bool name="config_default_always_reload_icons">true</bool>
     <bool name="config_default_dark_status_bar">false</bool>
@@ -127,7 +130,7 @@
     <bool name="config_default_show_icon_labels_in_drawer">true</bool>
     <bool name="config_default_enable_fuzzy_search">false</bool>
     <bool name="config_default_enable_smartspace">true</bool>
-    <bool name="config_default_enable_feed">true</bool>
+    <bool name="config_default_enable_feed">false</bool>
     <bool name="config_default_enable_icon_selection">false</bool>
     <bool name="config_default_show_component_names">false</bool>
     <bool name="config_default_smartspace_show_date">true</bool>
diff --git a/lawnchair/res/values/strings.xml b/lawnchair/res/values/strings.xml
index c874d6797dc..dcbce02b499 100644
--- a/lawnchair/res/values/strings.xml
+++ b/lawnchair/res/values/strings.xml
@@ -170,6 +170,12 @@
     <string name="recents_lock_unlock">Lock/unlock</string>
     <string name="recents_lock_unlock_description">Prevent selected app from closing when pressing \"Clear all\"</string>
 
+    <!--Overlay-->
+    <string name="overlay_fade_in">Fade In</string>
+    <string name="overlay_suck_in">Suck In</string>
+    <string name="app_closing_animation">App closing animation</string>
+    <string name="overlay_label">Overlay</string>
+
     <!--
 
     Notifications
diff --git a/lawnchair/src/app/lawnchair/LawnchairLauncher.kt b/lawnchair/src/app/lawnchair/LawnchairLauncher.kt
index 9f60aa5c26e..5b9123c20c5 100644
--- a/lawnchair/src/app/lawnchair/LawnchairLauncher.kt
+++ b/lawnchair/src/app/lawnchair/LawnchairLauncher.kt
@@ -28,6 +28,7 @@ import android.util.Pair
 import android.view.Display
 import android.view.View
 import android.view.ViewTreeObserver
+import android.window.SplashScreen
 import androidx.activity.SystemBarStyle
 import androidx.activity.enableEdgeToEdge
 import androidx.core.view.WindowInsetsCompat
@@ -51,6 +52,7 @@ import app.lawnchair.ui.popup.LauncherOptionsPopup
 import app.lawnchair.ui.popup.LawnchairShortcut
 import app.lawnchair.util.getThemedIconPacksInstalled
 import app.lawnchair.util.unsafeLazy
+import app.lawnchair.views.LawnchairFloatingSurfaceView
 import com.android.launcher3.AbstractFloatingView
 import com.android.launcher3.BaseActivity
 import com.android.launcher3.BubbleTextView
@@ -75,7 +77,6 @@ import com.android.launcher3.util.SystemUiController.UI_STATE_BASE_WINDOW
 import com.android.launcher3.util.Themes
 import com.android.launcher3.util.TouchController
 import com.android.launcher3.views.ActivityContext
-import com.android.launcher3.views.FloatingSurfaceView
 import com.android.launcher3.views.OptionsPopupView
 import com.android.launcher3.views.OptionsPopupView.OptionItem
 import com.android.launcher3.widget.LauncherWidgetHolder
@@ -300,7 +301,7 @@ class LawnchairLauncher : QuickstepLauncher() {
                     false,
                     AbstractFloatingView.TYPE_ICON_SURFACE,
                 )
-                FloatingSurfaceView.show(this, gnc)
+                LawnchairFloatingSurfaceView.show(this, gnc)
             }
         }
     }
@@ -349,7 +350,7 @@ class LawnchairLauncher : QuickstepLauncher() {
             view.iconView.setBackgroundDrawable(item.icon)
             view.bubbleText.text = item.label
             view.setOnClickListener(popup)
-//            view.onLongClickListener = popup
+            view.onLongClickListener = popup
             popup.mItemMap[view] = item
         }
 
@@ -424,6 +425,9 @@ class LawnchairLauncher : QuickstepLauncher() {
                 height,
             ),
         )
+        if (Utilities.ATLEAST_T) {
+            options.splashScreenStyle = SplashScreen.SPLASH_SCREEN_STYLE_ICON
+        }
         options.launchDisplayId = if (v.display != null) v.display.displayId else Display.DEFAULT_DISPLAY
         val callback = RunnableList()
         return ActivityOptionsWrapper(options, callback)
diff --git a/lawnchair/src/app/lawnchair/preferences2/PreferenceManager2.kt b/lawnchair/src/app/lawnchair/preferences2/PreferenceManager2.kt
index 6aa2f66598f..5901bd57c3f 100644
--- a/lawnchair/src/app/lawnchair/preferences2/PreferenceManager2.kt
+++ b/lawnchair/src/app/lawnchair/preferences2/PreferenceManager2.kt
@@ -45,6 +45,7 @@ import app.lawnchair.theme.color.ColorStyle
 import app.lawnchair.ui.popup.LauncherOptionsPopup
 import app.lawnchair.ui.preferences.components.HiddenAppsInSearch
 import app.lawnchair.util.kotlinxJson
+import app.lawnchair.views.overlay.FullScreenOverlayMode
 import com.android.launcher3.InvariantDeviceProfile
 import com.android.launcher3.InvariantDeviceProfile.INDEX_DEFAULT
 import com.android.launcher3.LauncherAppState
@@ -460,6 +461,14 @@ class PreferenceManager2 private constructor(private val context: Context) :
         defaultValue = context.resources.getBoolean(R.bool.config_default_enable_fuzzy_search),
     )
 
+    val closingAppOverlay = preference(
+        key = stringPreferencesKey(name = "closing_app_overlay"),
+        defaultValue = FullScreenOverlayMode.fromValue(context.resources.getString(R.string.config_default_overlay)),
+        parse = { FullScreenOverlayMode.fromValue(it) },
+        save = { it.value },
+        onSet = { reloadHelper.reloadGrid() },
+    )
+
     val matchHotseatQsbStyle = preference(
         key = booleanPreferencesKey(name = "use_drawer_search_icon"),
         defaultValue = false,
diff --git a/lawnchair/src/app/lawnchair/ui/preferences/components/OverlayHandlerPreference.kt b/lawnchair/src/app/lawnchair/ui/preferences/components/OverlayHandlerPreference.kt
new file mode 100644
index 00000000000..a6b211ab7a0
--- /dev/null
+++ b/lawnchair/src/app/lawnchair/ui/preferences/components/OverlayHandlerPreference.kt
@@ -0,0 +1,83 @@
+package app.lawnchair.ui.preferences.components
+
+import android.R as AndroidR
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import app.lawnchair.preferences.PreferenceAdapter
+import app.lawnchair.ui.ModalBottomSheetContent
+import app.lawnchair.ui.preferences.components.layout.PreferenceDivider
+import app.lawnchair.ui.preferences.components.layout.PreferenceTemplate
+import app.lawnchair.ui.util.LocalBottomSheetHandler
+import app.lawnchair.views.overlay.FullScreenOverlayMode
+import kotlinx.coroutines.launch
+
+val overlayOptions = listOf(
+    FullScreenOverlayMode.SUCK_IN,
+    FullScreenOverlayMode.FADE_IN,
+)
+
+@Composable
+fun OverlayHandlerPreference(
+    adapter: PreferenceAdapter<FullScreenOverlayMode>,
+    label: String,
+    modifier: Modifier = Modifier,
+) {
+    val scope = rememberCoroutineScope()
+    val bottomSheetHandler = LocalBottomSheetHandler.current
+
+    val currentConfig = adapter.state.value
+
+    fun onSelect(option: FullScreenOverlayMode) {
+        scope.launch {
+            adapter.onChange(option)
+        }
+    }
+
+    PreferenceTemplate(
+        title = { Text(text = label) },
+        description = { Text(text = stringResource(currentConfig.labelRes)) },
+        modifier = modifier.clickable {
+            bottomSheetHandler.show {
+                ModalBottomSheetContent(
+                    title = { Text(label) },
+                    buttons = {
+                        OutlinedButton(onClick = { bottomSheetHandler.hide() }) {
+                            Text(text = stringResource(id = AndroidR.string.cancel))
+                        }
+                    },
+                ) {
+                    LazyColumn {
+                        itemsIndexed(overlayOptions) { index, option ->
+                            if (index > 0) {
+                                PreferenceDivider(startIndent = 40.dp)
+                            }
+                            val selected = currentConfig == option
+                            PreferenceTemplate(
+                                title = { Text(text = stringResource(option.labelRes)) },
+                                modifier = Modifier.clickable {
+                                    bottomSheetHandler.hide()
+                                    onSelect(option)
+                                },
+                                startWidget = {
+                                    RadioButton(
+                                        selected = selected,
+                                        onClick = null,
+                                    )
+                                },
+                            )
+                        }
+                    }
+                }
+            }
+        },
+    )
+}
diff --git a/lawnchair/src/app/lawnchair/ui/preferences/destinations/HomeScreenPreferences.kt b/lawnchair/src/app/lawnchair/ui/preferences/destinations/HomeScreenPreferences.kt
index fd65e99bf08..b1c4d1c7c78 100644
--- a/lawnchair/src/app/lawnchair/ui/preferences/destinations/HomeScreenPreferences.kt
+++ b/lawnchair/src/app/lawnchair/ui/preferences/destinations/HomeScreenPreferences.kt
@@ -34,6 +34,7 @@ import app.lawnchair.ui.preferences.LocalIsExpandedScreen
 import app.lawnchair.ui.preferences.components.FeedPreference
 import app.lawnchair.ui.preferences.components.GestureHandlerPreference
 import app.lawnchair.ui.preferences.components.NavigationActionPreference
+import app.lawnchair.ui.preferences.components.OverlayHandlerPreference
 import app.lawnchair.ui.preferences.components.controls.ClickablePreference
 import app.lawnchair.ui.preferences.components.controls.ListPreference
 import app.lawnchair.ui.preferences.components.controls.SliderPreference
@@ -93,6 +94,13 @@ fun HomeScreenPreferences(
                 FeedPreference()
             }
         }
+        PreferenceGroup(heading = stringResource(R.string.overlay_label)) {
+            val overlayAdapter = prefs2.closingAppOverlay.getAdapter()
+            OverlayHandlerPreference(
+                adapter = overlayAdapter,
+                label = stringResource(id = R.string.app_closing_animation),
+            )
+        }
         PreferenceGroup(heading = stringResource(id = R.string.wallpaper)) {
             SwitchPreference(
                 prefs.wallpaperScrolling.getAdapter(),
diff --git a/lawnchair/src/app/lawnchair/views/FullScreenOverlayView.kt b/lawnchair/src/app/lawnchair/views/FullScreenOverlayView.kt
new file mode 100644
index 00000000000..1c07a366e37
--- /dev/null
+++ b/lawnchair/src/app/lawnchair/views/FullScreenOverlayView.kt
@@ -0,0 +1,218 @@
+package app.lawnchair.views
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.AnimatorSet
+import android.animation.ArgbEvaluator
+import android.animation.ObjectAnimator
+import android.animation.ValueAnimator
+import android.app.Activity
+import android.content.Context
+import android.graphics.Color
+import android.graphics.Outline
+import android.util.AttributeSet
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewOutlineProvider
+import android.view.animation.AccelerateInterpolator
+import android.view.animation.DecelerateInterpolator
+import android.view.animation.PathInterpolator
+import android.widget.FrameLayout
+import app.lawnchair.preferences2.PreferenceManager2
+import app.lawnchair.theme.color.tokens.ColorTokens
+import app.lawnchair.views.overlay.FullScreenOverlayMode
+import com.patrykmichalik.opto.core.firstBlocking
+
+class FullScreenOverlayView @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0,
+) : FrameLayout(context, attrs, defStyleAttr) {
+
+    private var endX = 0f
+    private var endY = 0f
+    private val startColor = ColorTokens.ColorBackground.resolveColor(context)
+    private val endColor = Color.TRANSPARENT
+
+    private var cornerRadius = 0f
+
+    init {
+        layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+        setLayerType(LAYER_TYPE_SOFTWARE, null)
+        setBackgroundColor(startColor)
+        clipToOutline = true
+    }
+
+    fun pointyEndView(view: View) {
+        val location = IntArray(2)
+        view.getLocationOnScreen(location)
+        endX = location[0] + view.width / 2f
+        endY = location[1] + view.height / 2f
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        outlineProvider = object : ViewOutlineProvider() {
+            override fun getOutline(view: View, outline: Outline) {
+                outline.setRoundRect(0, 0, view.width, view.height, cornerRadius)
+            }
+        }
+    }
+
+    fun suckAnimation(duration: Long = 600, onEnd: (() -> Unit)? = null) {
+        post {
+            if (!isAttachedToWindow) return@post
+
+            if (endX == 0f || endY == 0f) {
+                endX = width / 2f
+                endY = height / 2f
+            }
+
+            val moveX = ObjectAnimator.ofFloat(this, TRANSLATION_X, 0f, endX - width / 2)
+            val moveY = ObjectAnimator.ofFloat(this, TRANSLATION_Y, 0f, endY - height / 2)
+
+            val scaleAnimator = ValueAnimator.ofFloat(1f, 0.85f, 0.6f, 0.3f, 0.0f).apply {
+                this.duration = duration
+                addUpdateListener { animator ->
+                    val progress = animator.animatedFraction
+                    val scaleFactor = animator.animatedValue as Float
+                    scaleX = scaleFactor
+                    scaleY = scaleFactor
+
+                    val changeScale = progress < 0.8f
+
+                    val minSize = width.coerceAtMost(height) * scaleFactor
+                    cornerRadius = (width / 2f) * progress
+                    outlineProvider = object : ViewOutlineProvider() {
+                        override fun getOutline(view: View, outline: Outline) {
+                            outline.setRoundRect(0, 0, if (!changeScale) minSize.toInt() * 6 else view.width, if (!changeScale) minSize.toInt() * 6 else view.height, cornerRadius)
+                        }
+                    }
+                    invalidate()
+                }
+            }
+
+            val fadeAnimator = ObjectAnimator.ofFloat(this, ALPHA, 1f, 0.0f)
+
+            val fadeTriggerAnimator = ValueAnimator.ofFloat(0f, 1f).apply {
+                this.duration = duration
+                addUpdateListener { animator ->
+                    val progress = animator.animatedFraction
+                    if (progress > 0.5f) {
+                        if (!fadeAnimator.isRunning) fadeAnimator.start()
+                    }
+                }
+            }
+
+            AnimatorSet().apply {
+                playTogether(
+                    scaleAnimator,
+                    moveX,
+                    moveY,
+                    fadeTriggerAnimator,
+                )
+                play(fadeAnimator).after(fadeTriggerAnimator)
+                this.duration = duration
+                interpolator = PathInterpolator(0.22f, 1f, 0.36f, 1f)
+                addListener(object : AnimatorListenerAdapter() {
+                    override fun onAnimationEnd(animation: Animator) {
+                        (parent as? ViewGroup)?.removeView(this@FullScreenOverlayView)
+                        onEnd?.invoke()
+                    }
+                })
+                start()
+            }
+        }
+    }
+
+    fun animateIn(duration: Long = 400, onEnd: (() -> Unit)? = null) {
+        post {
+            if (!isAttachedToWindow) return@post
+
+            val colorAnimator =
+                ValueAnimator.ofObject(ArgbEvaluator(), startColor, startColor).apply {
+                    this.duration = duration
+                    interpolator = DecelerateInterpolator()
+                    addUpdateListener { animation ->
+                        setBackgroundColor(animation.animatedValue as Int)
+                    }
+                }
+
+            val fadeAnimator = ObjectAnimator.ofFloat(this, ALPHA, 0f, 1f).apply {
+                this.duration = duration
+                interpolator = DecelerateInterpolator()
+            }
+
+            AnimatorSet().apply {
+                playTogether(colorAnimator, fadeAnimator)
+                addListener(object : AnimatorListenerAdapter() {
+                    override fun onAnimationEnd(animation: Animator) {
+                        onEnd?.invoke()
+                    }
+                })
+                start()
+            }
+        }
+    }
+
+    fun animateOut(duration: Long = 1200, onEnd: (() -> Unit)? = null) {
+        post {
+            if (!isAttachedToWindow) return@post
+
+            val colorAnimator =
+                ValueAnimator.ofObject(ArgbEvaluator(), startColor, endColor).apply {
+                    this.duration = duration
+                    interpolator = AccelerateInterpolator()
+                    addUpdateListener { animation ->
+                        setBackgroundColor(animation.animatedValue as Int)
+                    }
+                }
+
+            val fadeAnimator = ObjectAnimator.ofFloat(this, ALPHA, 1f, 0f).apply {
+                this.duration = duration
+                interpolator = AccelerateInterpolator()
+            }
+
+            AnimatorSet().apply {
+                playTogether(colorAnimator, fadeAnimator)
+                addListener(object : AnimatorListenerAdapter() {
+                    override fun onAnimationEnd(animation: Animator) {
+                        visibility = INVISIBLE
+                        (parent as? ViewGroup)?.removeView(this@FullScreenOverlayView)
+                        onEnd?.invoke()
+                    }
+                })
+                start()
+            }
+        }
+    }
+}
+
+fun Activity.showFullScreenOverlay(
+    durationIn: Long = 200,
+    durationOut: Long = 500,
+    rootView: ViewGroup? = null,
+    endView: View,
+    onOverlayReady: () -> Unit,
+) {
+    val pref2 = PreferenceManager2.getInstance(this)
+    val animationMode = pref2.closingAppOverlay.firstBlocking()
+    val overlayView = FullScreenOverlayView(this)
+    val targetRootView = rootView ?: window.decorView.findViewById<ViewGroup>(android.R.id.content)
+
+    overlayView.pointyEndView(endView)
+    targetRootView?.addView(overlayView)
+
+    when (animationMode) {
+        FullScreenOverlayMode.FADE_IN -> {
+            overlayView.animateIn(durationIn) {
+                overlayView.animateOut(durationOut, onOverlayReady)
+            }
+        }
+        FullScreenOverlayMode.SUCK_IN -> {
+            overlayView.suckAnimation(durationOut) {
+                onOverlayReady()
+            }
+        }
+    }
+}
diff --git a/lawnchair/src/app/lawnchair/views/LawnchairFloatingSurfaceView.kt b/lawnchair/src/app/lawnchair/views/LawnchairFloatingSurfaceView.kt
new file mode 100644
index 00000000000..5128d710a87
--- /dev/null
+++ b/lawnchair/src/app/lawnchair/views/LawnchairFloatingSurfaceView.kt
@@ -0,0 +1,428 @@
+package app.lawnchair.views
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.AnimatorSet
+import android.animation.ObjectAnimator
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.PixelFormat
+import android.graphics.PorterDuff
+import android.graphics.Rect
+import android.graphics.RectF
+import android.util.AttributeSet
+import android.util.Log
+import android.util.Pair
+import android.view.MotionEvent
+import android.view.SurfaceControl
+import android.view.SurfaceHolder
+import android.view.SurfaceView
+import android.view.View
+import android.view.ViewTreeObserver.OnGlobalLayoutListener
+import androidx.core.graphics.createBitmap
+import androidx.dynamicanimation.animation.DynamicAnimation
+import androidx.dynamicanimation.animation.SpringAnimation
+import androidx.dynamicanimation.animation.SpringForce
+import app.lawnchair.LawnchairLauncher
+import app.lawnchair.launcher
+import com.android.app.animation.Interpolators
+import com.android.launcher3.AbstractFloatingView
+import com.android.launcher3.CellLayout
+import com.android.launcher3.GestureNavContract
+import com.android.launcher3.Insettable
+import com.android.launcher3.LauncherAnimUtils
+import com.android.launcher3.QuickstepTransitionManager.CONTENT_SCALE_DURATION
+import com.android.launcher3.QuickstepTransitionManager.LaunchDepthController
+import com.android.launcher3.R
+import com.android.launcher3.Utilities
+import com.android.launcher3.util.Executors
+import com.android.launcher3.util.MultiPropertyFactory
+import com.android.launcher3.util.window.RefreshRateTracker
+import com.android.launcher3.views.FloatingIconView.getLocationBoundsForView
+import com.android.launcher3.views.FloatingIconViewCompanion.setPropertiesVisible
+import java.util.function.Consumer
+import kotlin.math.roundToInt
+
+class LawnchairFloatingSurfaceView @JvmOverloads constructor(
+    context: Context?,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0,
+) : AbstractFloatingView(context, attrs, defStyleAttr),
+    OnGlobalLayoutListener,
+    Insettable,
+    SurfaceHolder.Callback2 {
+    private val mTmpPosition = RectF()
+
+    private val mLauncher: LawnchairLauncher = context!!.launcher
+    private val mIconPosition = RectF()
+    private val mDeviceProfile = mLauncher.deviceProfile
+
+    private val mIconBounds: Rect = Rect()
+    private val mRemoveViewRunnable = Runnable { this.removeViewFromParent() }
+
+    private val mSurfaceView: SurfaceView = SurfaceView(context)
+
+    private var mIcon: View? = null
+    private var mIconBitmap: Bitmap? = null
+    private var mContract: GestureNavContract? = null
+
+    init {
+        mSurfaceView.setLayerType(LAYER_TYPE_HARDWARE, null)
+        mSurfaceView.setZOrderOnTop(false)
+
+        mSurfaceView.holder.setFormat(PixelFormat.TRANSLUCENT)
+        mSurfaceView.holder.addCallback(this)
+
+        mIsOpen = true
+        addView(mSurfaceView)
+    }
+
+    override fun handleClose(animate: Boolean) {
+        setCurrentIconVisible(true)
+        mLauncher.viewCache.recycleView(R.layout.floating_surface_view, this)
+        mContract = null
+        mIcon = null
+        mIsOpen = false
+
+        // Remove after some time, to avoid flickering
+        Executors.MAIN_EXECUTOR.handler.postDelayed(
+            mRemoveViewRunnable,
+            RefreshRateTracker.getSingleFrameMs(mLauncher).toLong(),
+        )
+    }
+
+    private fun removeViewFromParent() {
+        if (mIconBitmap != null) {
+            mIconBitmap!!.recycle()
+            mIconBitmap = null
+        }
+        mLauncher.dragLayer.removeViewInLayout(this)
+    }
+
+    private fun removeViewImmediate() {
+        // Cancel any pending remove
+        Executors.MAIN_EXECUTOR.handler.removeCallbacks(mRemoveViewRunnable)
+        if (isAttachedToWindow) {
+            removeViewFromParent()
+        }
+    }
+
+    override fun isOfType(type: Int): Boolean {
+        return (type and TYPE_ICON_SURFACE) != 0
+    }
+
+    override fun onControllerInterceptTouchEvent(ev: MotionEvent?): Boolean {
+        close(false)
+        removeViewImmediate()
+        return false
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        getViewTreeObserver().addOnGlobalLayoutListener(this)
+        updateIconLocation()
+    }
+
+    fun getLauncherContentAnimator(
+        startDelay: Int,
+    ): Pair<AnimatorSet?, Runnable?> {
+        val launcherAnimator = AnimatorSet()
+        val endListener: Runnable?
+
+        val scales = floatArrayOf(mDeviceProfile.workspaceContentScale, 1f)
+
+        mLauncher.pauseExpensiveViewUpdates()
+
+        val viewsToAnimate: MutableList<View?> = ArrayList<View?>()
+        val workspace = mLauncher.workspace
+        workspace.forEachVisiblePage(
+            Consumer { view: View? -> viewsToAnimate.add((view as CellLayout).shortcutsAndWidgets) },
+        )
+        viewsToAnimate.add(mLauncher.hotseat)
+
+        viewsToAnimate.forEach(
+            Consumer { view: View? ->
+                val scaleAnim =
+                    ObjectAnimator.ofFloat<View?>(view, LauncherAnimUtils.SCALE_PROPERTY, *scales)
+                        .setDuration(CONTENT_SCALE_DURATION.toLong() * 3)
+                scaleAnim.interpolator = Interpolators.DECELERATE_1_5
+                launcherAnimator.play(scaleAnim)
+            },
+        )
+
+        endListener = Runnable {
+            viewsToAnimate.forEach(
+                Consumer { view: View? ->
+                    LauncherAnimUtils.SCALE_PROPERTY.set(view, 1f)
+                    view!!.setLayerType(LAYER_TYPE_NONE, null)
+                },
+            )
+            mLauncher.resumeExpensiveViewUpdates()
+        }
+
+        launcherAnimator.setStartDelay(startDelay.toLong())
+        return Pair<AnimatorSet?, Runnable?>(launcherAnimator, endListener)
+    }
+
+    private fun getBackgroundAnimator(): ObjectAnimator {
+        val depthController = LaunchDepthController(mLauncher)
+        val targetDepth = mLauncher.stateManager.state.getDepth<LawnchairLauncher?>(mLauncher)
+
+        val backgroundRadiusAnim = createDepthAnimator(
+            depthController,
+            targetDepth,
+            onEnd = {
+                if (Utilities.ATLEAST_R) {
+                    val viewRootImpl = mLauncher.dragLayer.getViewRootImpl()
+                    val parent = viewRootImpl?.surfaceControl
+                    val dimLayer: SurfaceControl = SurfaceControl.Builder()
+                        .setName("Blur layer")
+                        .setParent(parent)
+                        .setOpaque(false)
+                        .setEffectLayer()
+                        .build()
+
+                    createDepthAnimator(
+                        depthController,
+                        mLauncher.depthController.stateDepth.value,
+                    ) {
+                        depthController.dispose()
+                        SurfaceControl.Transaction().remove(dimLayer).apply()
+                    }.start()
+                } else {
+                    createDepthAnimator(
+                        depthController,
+                        mLauncher.depthController.stateDepth.value,
+                    ) {
+                        depthController.dispose()
+                    }.start()
+                }
+            },
+        )
+
+        return backgroundRadiusAnim
+    }
+
+    private fun createDepthAnimator(
+        depthController: LaunchDepthController,
+        targetDepth: Float,
+        onEnd: (() -> Unit)? = null,
+    ): ObjectAnimator {
+        return ObjectAnimator.ofFloat(
+            depthController.stateDepth,
+            MultiPropertyFactory.MULTI_PROPERTY_VALUE,
+            targetDepth,
+        ).apply {
+            duration = CONTENT_SCALE_DURATION.toLong() * 2
+            interpolator = Interpolators.DECELERATE_2
+            onEnd?.let {
+                addListener(object : AnimatorListenerAdapter() {
+                    override fun onAnimationEnd(animation: Animator) {
+                        it()
+                    }
+                })
+            }
+        }
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        getViewTreeObserver().removeOnGlobalLayoutListener(this)
+        setCurrentIconVisible(true)
+    }
+
+    override fun onGlobalLayout() {
+        updateIconLocation()
+    }
+
+    fun getIcon(): View? {
+        return mLauncher.getFirstMatchForAppClose(
+            null, /* StableViewInfo */
+            mContract!!.componentName.packageName,
+            mContract!!.user,
+            false, /* supportsAllAppsState */
+        )
+    }
+
+    override fun setInsets(insets: Rect?) {}
+
+    private fun updateIconLocation() {
+        if (mContract == null) {
+            return
+        }
+
+        synchronized(this) {
+            val icon = getIcon()
+
+            val iconChanged = mIcon !== icon
+            if (iconChanged) {
+                setCurrentIconVisible(true)
+                mIcon = icon
+                setCurrentIconVisible(false)
+            }
+
+            if (icon != null) {
+                getLocationBoundsForView(mLauncher, icon, false, mTmpPosition, mIconBounds)
+                if (mTmpPosition != mIconPosition) {
+                    mIconPosition.set(mTmpPosition)
+                    updateSurfaceViewLayout()
+                }
+            }
+
+            sendIconInfo()
+
+            if (mIcon != null && iconChanged && !mIconBounds.isEmpty) {
+                if (mIconBitmap == null || mIconBitmap!!.getWidth() != mIconBounds.width() || mIconBitmap!!.getHeight() != mIconBounds.height()) {
+                    if (mIconBitmap != null) mIconBitmap!!.recycle()
+                    mIconBitmap = createBitmap(
+                        mIconBounds.width(),
+                        mIconBounds.height(),
+                        Bitmap.Config.ARGB_8888,
+                    )
+                }
+                postInvalidateIconDrawing()
+            }
+        }
+    }
+
+    private fun postInvalidateIconDrawing() {
+        synchronized(this) {
+            post {
+                if (mIcon == null) return@post
+                drawIconOnBitmap()
+                drawOnSurface()
+                bouncyIcon()
+            }
+        }
+    }
+
+    private fun updateSurfaceViewLayout() {
+        post {
+            val lp = mSurfaceView.layoutParams as LayoutParams
+            lp.width = mIconPosition.width().roundToInt()
+            lp.height = mIconPosition.height().roundToInt()
+            lp.leftMargin = mIconPosition.left.roundToInt()
+            lp.topMargin = mIconPosition.top.roundToInt()
+        }
+    }
+
+    private fun drawIconOnBitmap() {
+        if (mIcon != null && !mIconBounds.isEmpty) {
+            setCurrentIconVisible(true)
+            try {
+                val c = Canvas(mIconBitmap!!)
+                c.translate(-mIconBounds.left.toFloat(), -mIconBounds.top.toFloat())
+                mIcon!!.draw(c)
+            } catch (t: Throwable) {
+                Log.e(this.javaClass.name, "drawIconOnBitmap: ", t)
+            }
+            setCurrentIconVisible(false)
+        }
+    }
+
+    private fun bouncyIcon() {
+        mIcon ?: return
+
+        val (startX, startY) = mIconPosition.left to mIconPosition.top - ((height * 0.2f) / 3)
+
+        listOf(
+            SpringAnimation(mIcon, DynamicAnimation.TRANSLATION_X, 1f).apply {
+                spring = SpringForce(1f).setStiffness(SpringForce.STIFFNESS_LOW)
+                    .setDampingRatio(SpringForce.DAMPING_RATIO_HIGH_BOUNCY)
+                setStartVelocity((mIconPosition.left - startX) * 2)
+            },
+            SpringAnimation(mIcon, DynamicAnimation.TRANSLATION_Y, 1f).apply {
+                spring = SpringForce(1f).setStiffness(SpringForce.STIFFNESS_LOW)
+                    .setDampingRatio(SpringForce.DAMPING_RATIO_HIGH_BOUNCY)
+                setStartVelocity((mIconPosition.top - startY) * 3)
+            },
+        ).forEach { it.start() }
+    }
+
+    private fun sendIconInfo() {
+        if (mContract != null && Utilities.ATLEAST_Q) {
+            mContract!!.sendEndPosition(mIconPosition, mLauncher, mSurfaceView.surfaceControl)
+        }
+    }
+
+    override fun surfaceCreated(surfaceHolder: SurfaceHolder) {
+        drawOnSurface()
+        sendIconInfo()
+    }
+
+    override fun surfaceChanged(
+        surfaceHolder: SurfaceHolder,
+        format: Int,
+        width: Int,
+        height: Int,
+    ) {
+        updateIconLocation()
+    }
+
+    override fun surfaceDestroyed(surfaceHolder: SurfaceHolder) {}
+
+    override fun surfaceRedrawNeeded(surfaceHolder: SurfaceHolder) {
+        drawOnSurface()
+    }
+
+    private fun drawOnSurface() {
+        val surfaceHolder = mSurfaceView.holder
+        if (!surfaceHolder.surface.isValid || mIconBitmap == null) return
+
+        synchronized(this) {
+            val c = surfaceHolder.lockHardwareCanvas()
+            if (c != null) {
+                try {
+                    c.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)
+                    c.drawBitmap(mIconBitmap!!, 0f, 0f, null)
+                } finally {
+                    surfaceHolder.unlockCanvasAndPost(c)
+                }
+            }
+        }
+    }
+
+    private fun setCurrentIconVisible(isVisible: Boolean) {
+        if (mIcon != null) {
+            setPropertiesVisible(mIcon, isVisible)
+        }
+    }
+
+    companion object {
+        /**
+         * Shows the surfaceView for the provided contract
+         */
+        fun show(launcher: LawnchairLauncher, contract: GestureNavContract?) {
+            val view: LawnchairFloatingSurfaceView =
+                launcher.viewCache.getView<LawnchairFloatingSurfaceView?>(
+                    R.layout.floating_surface_view,
+                    launcher,
+                    launcher.dragLayer,
+                )
+            view.mContract = contract
+            view.mIsOpen = true
+
+            val anim = AnimatorSet()
+            val startDelay = RefreshRateTracker.getSingleFrameMs(launcher)
+            val launcherContentAnimator: Pair<AnimatorSet?, Runnable?> =
+                view.getLauncherContentAnimator(startDelay)
+            anim.playTogether(launcherContentAnimator.first, view.getBackgroundAnimator())
+            anim.addListener(object : AnimatorListenerAdapter() {
+                override fun onAnimationEnd(animation: Animator) {
+                    launcherContentAnimator.second!!.run()
+                }
+            })
+
+            view.removeViewImmediate()
+            launcher.dragLayer.addView(view)
+            anim.start()
+            view.getIcon()?.let {
+                launcher.showFullScreenOverlay(endView = it) {
+                    view.mSurfaceView.setZOrderOnTop(true)
+                }
+            }
+        }
+    }
+}
diff --git a/lawnchair/src/app/lawnchair/views/overlay/FullScreenOverlayMode.kt b/lawnchair/src/app/lawnchair/views/overlay/FullScreenOverlayMode.kt
new file mode 100644
index 00000000000..cec5115a8e0
--- /dev/null
+++ b/lawnchair/src/app/lawnchair/views/overlay/FullScreenOverlayMode.kt
@@ -0,0 +1,16 @@
+package app.lawnchair.views.overlay
+
+import android.annotation.StringRes
+import com.android.launcher3.R
+
+enum class FullScreenOverlayMode(val value: String, @StringRes val labelRes: Int) {
+    FADE_IN("fade_in", R.string.overlay_fade_in),
+    SUCK_IN("suck_in", R.string.overlay_suck_in),
+    ;
+
+    companion object {
+        fun fromValue(value: String): FullScreenOverlayMode {
+            return entries.find { it.value == value } ?: FADE_IN
+        }
+    }
+}