refactor: consolidate frame polling and cleanup across all platforms

Author: kdroidFilter

mediaplayer/src/jvmMain/kotlin/io/github/kdroidfilter/composemediaplayer/linux/LinuxVideoPlayerState.kt

@@ -718,26 +718,32 @@ class LinuxVideoPlayerState : VideoPlayerState {
         uiUpdateJob?.cancel()
         playerScope.cancel()
 
-        // Dispose the native player synchronously to guarantee cleanup before
-        // ioScope is cancelled — otherwise GStreamer keeps running (audio leak).
+        // Clear the pointer atomically so no background task can use it
         val ptrToDispose = playerPtrAtomic.getAndSet(0L)
 
-        skiaBitmapA?.close()
-        skiaBitmapB?.close()
-        skiaBitmapA = null
-        skiaBitmapB = null
-        skiaBitmapWidth = 0
-        skiaBitmapHeight = 0
-        nextSkiaBitmapA = true
-
-        if (ptrToDispose != 0L) {
+        // Native cleanup on a background thread to avoid blocking the UI.
+        Thread {
             try {
-                LinuxNativeBridge.nDisposePlayer(ptrToDispose)
+                skiaBitmapA?.close()
+                skiaBitmapB?.close()
+                skiaBitmapA = null
+                skiaBitmapB = null
+                skiaBitmapWidth = 0
+                skiaBitmapHeight = 0
+                nextSkiaBitmapA = true
             } catch (e: Exception) {
-                if (e is CancellationException) throw e
-                linuxLogger.e { "Error disposing player: ${e.message}" }
+                linuxLogger.e { "Error releasing bitmaps: ${e.message}" }
             }
-        }
+
+            if (ptrToDispose != 0L) {
+                try {
+                    LinuxNativeBridge.nDisposePlayer(ptrToDispose)
+                } catch (e: Exception) {
+                    if (e is CancellationException) throw e
+                    linuxLogger.e { "Error disposing player: ${e.message}" }
+                }
+            }
+        }.start()
 
         ioScope.cancel()
     }

mediaplayer/src/jvmMain/kotlin/io/github/kdroidfilter/composemediaplayer/mac/MacVideoPlayerState.kt

@@ -861,32 +861,37 @@ class MacVideoPlayerState : VideoPlayerState {
         uiUpdateJob?.cancel()
         playerScope.cancel()
 
-        // Dispose synchronously to guarantee cleanup before ioScope is cancelled —
-        // otherwise AVPlayer keeps running (audio leak).
-        // Use frameDispatcher to safely close bitmaps (rendering accesses them there).
-        val ptrToDispose = runBlocking(frameDispatcher) {
-            val ptr = playerPtrAtomic.getAndSet(0L)
-
-            skiaBitmapA?.close()
-            skiaBitmapB?.close()
-            skiaBitmapA = null
-            skiaBitmapB = null
-            skiaBitmapWidth = 0
-            skiaBitmapHeight = 0
-            nextSkiaBitmapA = true
-
-            ptr
-        }
+        // Clear the pointer atomically so no background task can use it
+        val ptrToDispose = playerPtrAtomic.getAndSet(0L)
 
-        if (ptrToDispose != 0L) {
-            macLogger.d { "dispose() - Disposing native player" }
+        // Release bitmaps on the frame dispatcher (rendering accesses them there)
+        // then dispose the native player — all on a background thread to avoid
+        // blocking the main/UI thread.
+        Thread {
             try {
-                MacNativeBridge.nDisposePlayer(ptrToDispose)
+                // Close bitmaps (not thread-safe with rendering, but frame updates
+                // are already cancelled above and playerPtr is zeroed)
+                skiaBitmapA?.close()
+                skiaBitmapB?.close()
+                skiaBitmapA = null
+                skiaBitmapB = null
+                skiaBitmapWidth = 0
+                skiaBitmapHeight = 0
+                nextSkiaBitmapA = true
             } catch (e: Exception) {
-                if (e is CancellationException) throw e
-                macLogger.e { "Error disposing player: ${e.message}" }
+                macLogger.e { "Error releasing bitmaps: ${e.message}" }
             }
-        }
+
+            if (ptrToDispose != 0L) {
+                macLogger.d { "dispose() - Disposing native player" }
+                try {
+                    MacNativeBridge.nDisposePlayer(ptrToDispose)
+                } catch (e: Exception) {
+                    if (e is CancellationException) throw e
+                    macLogger.e { "Error disposing player: ${e.message}" }
+                }
+            }
+        }.start()
 
         ioScope.cancel()
     }

mediaplayer/src/jvmMain/kotlin/io/github/kdroidfilter/composemediaplayer/windows/WindowsVideoPlayerState.kt

@@ -297,65 +297,43 @@ class WindowsVideoPlayerState : VideoPlayerState {
             return // Already disposing
         }
 
-        // Cancel the scope immediately to stop all coroutines
-        scope.cancel()
-
-        // Use runBlocking to ensure resources are cleaned up synchronously
-        runBlocking {
-            try {
-                // Cancel all jobs with immediate effect
-                videoJob?.cancel()
-                resizeJob?.cancel()
-
-                // Wait a bit for coroutines to cancel
-                delay(50)
-
-                mediaOperationMutex.withLock {
-                    // Stop playing if active
-                    _isPlaying = false
-                    val instance = videoPlayerInstance
-                    if (instance != 0L) {
-                        try {
-                            // Stop playback before releasing resources
-                            val hr = player.SetPlaybackState(instance, false, true)
-                            if (hr < 0) {
-                                windowsLogger.e { "Error stopping playback (hr=0x${hr.toString(16)})" }
-                            }
-                        } catch (e: Exception) {
-                            windowsLogger.e { "Exception stopping playback: ${e.message}" }
-                        }
-
-                        // Close the media
-                        try {
-                            player.CloseMedia(instance)
-                        } catch (e: Exception) {
-                            windowsLogger.e { "Exception closing media: ${e.message}" }
-                        }
-
-                        // Remove volume setting for this instance
-                        instanceVolumes.remove(instance)
+        // Stop coroutines first — non-blocking
+        videoJob?.cancel()
+        resizeJob?.cancel()
+        _isPlaying = false
+        _hasMedia = false
 
-                        // Destroy the player instance
-                        try {
-                            WindowsNativeBridge.destroyInstance(instance)
-                        } catch (e: Exception) {
-                            windowsLogger.e { "Exception destroying instance: ${e.message}" }
-                        }
+        // Release Kotlin-side resources immediately (bitmaps, channel)
+        releaseAllResources()
 
-                        videoPlayerInstance = 0L
-                    }
+        // Native cleanup on a background thread so dispose() never blocks the UI.
+        // scope is about to be cancelled, so use a detached thread.
+        val instance = videoPlayerInstance
+        videoPlayerInstance = 0L
+        lastUri = null
 
-                    // Clear all resources
-                    clearAllResourcesSync()
+        if (instance != 0L) {
+            Thread {
+                try {
+                    player.SetPlaybackState(instance, false, true)
+                } catch (e: Exception) {
+                    windowsLogger.e { "Exception stopping playback: ${e.message}" }
                 }
-            } catch (e: Exception) {
-                windowsLogger.e { "Error during dispose: ${e.message}" }
-            } finally {
-                // Mark player as uninitialized
-                _hasMedia = false
-                lastUri = null
-            }
+                try {
+                    player.CloseMedia(instance)
+                } catch (e: Exception) {
+                    windowsLogger.e { "Exception closing media: ${e.message}" }
+                }
+                instanceVolumes.remove(instance)
+                try {
+                    WindowsNativeBridge.destroyInstance(instance)
+                } catch (e: Exception) {
+                    windowsLogger.e { "Exception destroying instance: ${e.message}" }
+                }
+            }.start()
         }
+
+        scope.cancel()
     }
 
     private fun clearAllResourcesSync() {