Prevent abandoned overlay windows (#2578)

- Capture overlay window state before service cleanup so stale resources remain releasable
- Release WindowManager and SurfaceControl overlays from cleanup snapshots outside the generation gate
- Cover cleanup behavior for handles, root removal, and already-removed windows

🤖 Auto-generated

Author: enaboapps

app/src/main/java/com/enaboapps/switchify/service/window/SwitchifyAccessibilityWindow.kt

@@ -47,15 +47,24 @@ class SwitchifyAccessibilityWindow private constructor() : LifecycleOwner, Saved
     private var isVisible = false
     private var windowGeneration = 0
     private var acceptingOverlayOperations = false
+    private val windowStateCleaner = WindowStateCleaner()
 
     companion object {
         private const val TAG = "SwitchifyAccessibilityWindow"
-        private const val SHUTDOWN_CLEANUP_TIMEOUT_MS = 500L
+        private const val SHUTDOWN_CLEANUP_TIMEOUT_MS = 2_000L
         val instance: SwitchifyAccessibilityWindow by lazy {
             SwitchifyAccessibilityWindow()
         }
     }
 
+    private data class WindowState(
+        val generation: Int,
+        val windowManager: WindowManager?,
+        val baseLayout: RelativeLayout?,
+        val surfaceHandles: MutableMap<ViewGroup, OverlayHandle>,
+        val wasVisible: Boolean
+    )
+
     private val defaultDisplayTarget = OverlayTargets.defaultDisplay().copy(forceSurface = true)
 
     override val lifecycle: Lifecycle
@@ -72,7 +81,9 @@ class SwitchifyAccessibilityWindow private constructor() : LifecycleOwner, Saved
         try {
             acceptingOverlayOperations = false
             windowGeneration += 1
-            cleanupOnMainBlocking()
+            if (!cleanupOnMainBlocking()) {
+                Log.w(TAG, "Timed out while cleaning up previous window state before setup")
+            }
 
             this.context = context
             windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
@@ -215,22 +226,25 @@ class SwitchifyAccessibilityWindow private constructor() : LifecycleOwner, Saved
      */
     fun cleanup() {
         if (Looper.myLooper() == Looper.getMainLooper()) {
-            if (acceptingOverlayOperations) cleanupNow()
+            cleanupCurrentStateNow()
             return
         }
-        postIfCurrentGeneration { cleanupNow() }
+        mainHandler.post { cleanupCurrentStateNow() }
     }
 
     /**
      * Cleans up the window and its resources when the service is destroyed.
      */
     fun onServiceDestroy() {
         acceptingOverlayOperations = false
+        windowGeneration += 1
         ServiceMessageHUD.instance.dispose()
         MenuHighlightHud.instance.dispose()
         ServiceStartupSplash.instance.dispose()
         MediaPipeBackend.close()
-        cleanupForServiceShutdown()
+        if (!cleanupOnMainBlocking()) {
+            Log.w(TAG, "Timed out waiting for service window cleanup")
+        }
         getContext()?.let { ctx ->
             screenWatcher?.unregister(ctx)
         }
@@ -239,6 +253,8 @@ class SwitchifyAccessibilityWindow private constructor() : LifecycleOwner, Saved
         windowManager = null
         surfaceControlBackend = null
         baseLayout = null
+        surfaceOverlayHandles.clear()
+        isVisible = false
     }
 
     /**
@@ -527,62 +543,86 @@ class SwitchifyAccessibilityWindow private constructor() : LifecycleOwner, Saved
         }
     }
 
-    private fun cleanupForServiceShutdown() {
-        acceptingOverlayOperations = false
-        cleanupOnMainBlocking()
-    }
-
-    private fun cleanupOnMainBlocking() {
+    private fun cleanupOnMainBlocking(): Boolean {
         if (Looper.myLooper() == Looper.getMainLooper()) {
-            cleanupNow()
-            return
+            cleanupCurrentStateNow()
+            return true
         }
+        val state = captureCurrentWindowState()
         val latch = CountDownLatch(1)
         mainHandler.postAtFrontOfQueue {
             try {
-                cleanupNow()
+                cleanupSnapshotNow(state)
             } finally {
                 latch.countDown()
             }
         }
-        if (!latch.await(SHUTDOWN_CLEANUP_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
-            Log.w(TAG, "Timed out waiting for window cleanup")
+        return latch.await(SHUTDOWN_CLEANUP_TIMEOUT_MS, TimeUnit.MILLISECONDS).also { completed ->
+            if (!completed) {
+                Log.w(TAG, "Timed out waiting for window cleanup")
+            }
         }
     }
 
-    private fun cleanupNow() {
-        try {
-            releaseSurfaceOverlays()
-            for (i in 0 until (baseLayout?.childCount ?: 0)) {
-                val child = baseLayout?.getChildAt(i)
+    private fun cleanupCurrentStateNow() {
+        cleanupSnapshotNow(captureCurrentWindowState())
+    }
+
+    private fun captureCurrentWindowState(): WindowState {
+        val state = WindowState(
+            generation = windowGeneration,
+            windowManager = windowManager,
+            baseLayout = baseLayout,
+            surfaceHandles = surfaceOverlayHandles.toMutableMap(),
+            wasVisible = isVisible
+        )
+        surfaceOverlayHandles.clear()
+        isVisible = false
+        return state
+    }
+
+    private fun cleanupSnapshotNow(state: WindowState) {
+        windowStateCleaner.cleanup(
+            WindowCleanupState(
+                surfaceHandles = state.surfaceHandles.mapKeys { it.key as Any }
+                    .mapValues { OverlayHandleCleanupHandle(it.value) }
+                    .toMutableMap(),
+                root = state.baseLayout?.let { layout ->
+                    AndroidWindowCleanupRoot(state.windowManager, layout)
+                },
+                wasVisible = state.wasVisible
+            )
+        )
+    }
+
+    private class OverlayHandleCleanupHandle(
+        private val handle: OverlayHandle
+    ) : WindowCleanupHandle {
+        override fun release() {
+            handle.release()
+        }
+    }
+
+    private class AndroidWindowCleanupRoot(
+        private val windowManager: WindowManager?,
+        private val layout: RelativeLayout
+    ) : WindowCleanupRoot {
+        override val isAttachedToWindow: Boolean
+            get() = layout.parent != null
+
+        override fun removeDescendantViews() {
+            for (i in 0 until layout.childCount) {
+                val child = layout.getChildAt(i)
                 if (child is ViewGroup) {
                     child.removeAllViews()
                 }
             }
-            baseLayout?.removeAllViews()
-            baseLayout?.let { layout ->
-                if (isVisible || layout.parent != null) {
-                    windowManager?.removeViewImmediate(layout)
-                }
-            }
-            isVisible = false
-        } catch (e: IllegalArgumentException) {
-            isVisible = false
-            Log.w(TAG, "Window was already removed during cleanup", e)
-        } catch (e: Exception) {
-            Log.e(TAG, "Error in cleanup: ${e.message}", e)
+            layout.removeAllViews()
         }
-    }
 
-    private fun releaseSurfaceOverlays() {
-        surfaceOverlayHandles.values.forEach { handle ->
-            try {
-                handle.release()
-            } catch (e: Exception) {
-                Log.e(TAG, "Error releasing surface overlay", e)
-            }
+        override fun removeImmediately() {
+            windowManager?.removeViewImmediate(layout)
         }
-        surfaceOverlayHandles.clear()
     }
 
     private fun layoutParamsForPlacement(placement: OverlayPlacement): RelativeLayout.LayoutParams {

app/src/main/java/com/enaboapps/switchify/service/window/WindowStateCleaner.kt

@@ -0,0 +1,56 @@
+package com.enaboapps.switchify.service.window
+
+import android.util.Log
+
+internal data class WindowCleanupState(
+    val surfaceHandles: MutableMap<Any, WindowCleanupHandle>,
+    val root: WindowCleanupRoot?,
+    val wasVisible: Boolean
+)
+
+internal interface WindowCleanupHandle {
+    fun release()
+}
+
+internal interface WindowCleanupRoot {
+    val isAttachedToWindow: Boolean
+
+    fun removeDescendantViews()
+    fun removeImmediately()
+}
+
+internal class WindowStateCleaner(
+    private val logError: (String, Throwable) -> Unit = { message, throwable ->
+        Log.e(TAG, message, throwable)
+    },
+    private val logWarning: (String, Throwable) -> Unit = { message, throwable ->
+        Log.w(TAG, message, throwable)
+    }
+) {
+    fun cleanup(state: WindowCleanupState) {
+        state.surfaceHandles.values.forEach { handle ->
+            try {
+                handle.release()
+            } catch (e: Exception) {
+                logError("Error releasing surface overlay", e)
+            }
+        }
+        state.surfaceHandles.clear()
+
+        val root = state.root ?: return
+        try {
+            root.removeDescendantViews()
+            if (state.wasVisible || root.isAttachedToWindow) {
+                root.removeImmediately()
+            }
+        } catch (e: IllegalArgumentException) {
+            logWarning("Window was already removed during cleanup", e)
+        } catch (e: Exception) {
+            logError("Error in cleanup", e)
+        }
+    }
+
+    private companion object {
+        private const val TAG = "WindowStateCleaner"
+    }
+}