kotlin-concurrency-expert

To fix ANRs and main thread blocking in Kotlin Coroutines, identify problematic coroutines and refactor them using `Dispatchers.IO` with `withContext`. Ensure operations are properly scoped to the ViewModel's lifecycle to prevent main thread freezing and application unresponsiveness.

Structured concurrency in Kotlin prevents memory leaks by enforcing proper scoping and cooperative cancellation. Coroutines are tied to a specific lifecycle scope, ensuring they are automatically cancelled when their parent scope is destroyed, avoiding orphaned background tasks.

To safely collect Kotlin Flows without causing lifecycle crashes, apply lifecycle-aware collection methods. This ensures flow collection only occurs when the Android lifecycle component is active, suspending collection during stopped states to prevent crashes and save resources.

Yes, you can convert existing callback APIs to Kotlin Coroutines and Flows. This process involves wrapping callback-based asynchronous operations into suspend functions or Flow producers, applying best practices to ensure thread safety and cooperative cancellation during the conversion.

Kotlin Coroutines cause race conditions and incorrect state exposure when multiple threads access shared mutable state without synchronization. Remediating this requires applying thread safety best practices, using proper dispatcher injection, and ensuring state updates are confined to a single thread.

Testable dispatcher injection in Kotlin Coroutines is the practice of passing dispatchers via parameters rather than hardcoding them. You should use it to write deterministic unit tests, allowing you to easily swap `Dispatchers.IO` for a test dispatcher to control execution.