kotlin-concurrency-expert

Fix Kotlin coroutine lifecycle leaks by enforcing structured concurrency within viewModelScope or lifecycleScope. This ensures coroutines are automatically cancelled when the Android lifecycle owner is destroyed, preventing memory leaks and UI freezing.

Structured concurrency in Android ViewModels requires scoping background work to lifecycle-aware boundaries like viewModelScope. It guarantees that launched coroutines are properly tracked and cancelled when the ViewModel clears, avoiding unmanaged background threads and race conditions.

Refactor improper dispatchers in Kotlin coroutines by applying dispatcher injection to switch execution contexts correctly. Move IO operations to appropriate scopes with explicit dispatcher management, ensuring safe cancellation and testability without blocking the UI thread.

Testing Android coroutines with hard-coded dispatchers is difficult. You must apply dispatcher injection to replace real dispatchers with test controllers. This enables lifecycle-aware collection and safe cancellation testing without relying on actual IO or UI threads.

Your Android UI freezes during background coroutine work because improper dispatchers or mis-scoped operations are blocking the UI thread. Identify coroutine misuse and apply structured concurrency to shift heavy tasks to viewModelScope with correct dispatcher injection.

The limitation of using GlobalScope for Android coroutines is the lack of lifecycle safety, causing operations to outlive their owners and trigger memory leaks. Replace GlobalScope with lifecycleScope or viewModelScope to enforce structured concurrency and safe cancellation.