SKILL.md
$27
Common fixes:
- ANR / Main thread blocking: Move heavy work to
withContext(Dispatchers.IO)orDispatchers.Default; ensure suspend functions are main-safe.
- Memory leaks / zombie coroutines: Replace
GlobalScopewith a lifecycle-bound scope (viewModelScope,lifecycleScope, or injectedapplicationScope).
- Lifecycle collection issues: Replace deprecated
launchWhenStartedwithrepeatOnLifecycle(Lifecycle.State.STARTED).
- State exposure: Encapsulate
MutableStateFlow/MutableSharedFlow; expose read-onlyStateFloworFlow.
- CancellationException swallowing: Ensure generic
catch (e: Exception)blocks rethrowCancellationException.
- Non-cooperative cancellation: Add
ensureActive()oryield()in tight loops for cooperative cancellation.
- Callback APIs: Convert listeners to
callbackFlowwith properawaitClosecleanup.
- Hardcoded Dispatchers: Inject
CoroutineDispatchervia constructor for testability.
Critical Rules
Dispatcher Injection (Testability)
// CORRECT: Inject dispatcher
class UserRepository(
private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO
) {
suspend fun fetchUser() = withContext(ioDispatcher) { ... }
}
// INCORRECT: Hardcoded dispatcher
class UserRepository {
suspend fun fetchUser() = withContext(Dispatchers.IO) { ... }
}Lifecycle-Aware Collection
// CORRECT: Use repeatOnLifecycle
viewLifecycleOwner.lifecycleScope.launch {
viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
viewModel.uiState.collect { state -> updateUI(state) }
}
}
// INCORRECT: Direct collection (unsafe, deprecated)
lifecycleScope.launchWhenStarted {
viewModel.uiState.collect { state -> updateUI(state) }
}State Encapsulation
// CORRECT: Expose read-only StateFlow
class MyViewModel : ViewModel() {
private val _uiState = MutableStateFlow(UiState())
val uiState: StateFlow<UiState> = _uiState.asStateFlow()
}
// INCORRECT: Exposed mutable state
class MyViewModel : ViewModel() {
val uiState = MutableStateFlow(UiState()) // Leaks mutability
}Exception Handling
// CORRECT: Rethrow CancellationException
try {
doSuspendWork()
} catch (e: CancellationException) {
throw e // Must rethrow!
} catch (e: Exception) {
handleError(e)
}
// INCORRECT: Swallows cancellation
try {
doSuspendWork()
} catch (e: Exception) {
handleError(e) // CancellationException swallowed!
}Cooperative Cancellation
// CORRECT: Check for cancellation in tight loops
suspend fun processLargeList(items: List<Item>) {
items.forEach { item ->
ensureActive() // Check cancellation
processItem(item)
}
}
// INCORRECT: Non-cooperative (ignores cancellation)
suspend fun processLargeList(items: List<Item>) {
items.forEach { item ->
processItem(item) // Never checks cancellation
}
}Callback Conversion
// CORRECT: callbackFlow with awaitClose
fun locationUpdates(): Flow<Location> = callbackFlow {
val listener = LocationListener { location ->
trySend(location)
}
locationManager.requestLocationUpdates(listener)
awaitClose { locationManager.removeUpdates(listener) }
}Scope Guidelines
Scope
Use When
Lifecycle
viewModelScope
ViewModel operations
Cleared with ViewModel
lifecycleScope
UI operations in Activity/Fragment
Destroyed with lifecycle owner
repeatOnLifecycle
Flow collection in UI
Started/Stopped with lifecycle state
applicationScope (injected)
App-wide background work
Application lifetime
GlobalScope
NEVER USE
Breaks structured concurrency
Testing Pattern
@Test
fun `loading data updates state`() = runTest {
val testDispatcher = StandardTestDispatcher(testScheduler)
val repository = FakeRepository()
val viewModel = MyViewModel(repository, testDispatcher)
viewModel.loadData()
advanceUntilIdle()
assertEquals(UiState.Success(data), viewModel.uiState.value)
}