kotlin-concurrency-expert

Structured concurrency in Android ensures coroutine operations are tied to specific lifecycles, preventing leaks and UI freezes. It requires replacing GlobalScope with viewModelScope or lifecycleScope, and using repeatOnLifecycle instead of launchWhenStarted for safe cancellation.

The best way to review coroutine scope usage is to scan for GlobalScope launches and improper dispatcher injection. Refactoring these into viewModelScope or lifecycleScope with withContext(Dispatchers.IO) enforces structured concurrency and resolves lifecycle safety issues.

To replace launchWhenStarted with repeatOnLifecycle, wrap your coroutine collection logic inside a repeatOnLifecycle(Lifecycle.State.STARTED) block. This ensures the coroutine automatically suspends and cancels when the lifecycle drops below the target state, preventing UI leaks.

Refactoring coroutines for lifecycle safety directly improves Android testability. By advocating injectable dispatchers and test-friendly scoping strategies, you can easily swap Dispatchers.Main or Dispatchers.IO during unit tests to verify cancellation and threading behavior.

You should avoid GlobalScope because it creates unstructured concurrency, keeping coroutines alive independently of the Android lifecycle. This leads to memory leaks and potential crashes; using viewModelScope or lifecycleScope ensures coroutines are safely cancelled when the UI is destroyed.