{"id":6,"date":"2026-09-05T01:06:53","date_gmt":"2026-09-04T23:06:53","guid":{"rendered":"https:\/\/grindloop.io\/blog\/?p=6"},"modified":"2026-09-27T00:06:34","modified_gmt":"2026-09-26T22:06:34","slug":"why-your-combined-stateflow-shows-stale-data-sharingstarted-lazily-vs-eagerly","status":"publish","type":"post","link":"https:\/\/grindloop.ai\/blog\/why-your-combined-stateflow-shows-stale-data-sharingstarted-lazily-vs-eagerly\/","title":{"rendered":"Why Your Combined StateFlow Shows Stale Data: SharingStarted.Lazily vs Eagerly"},"content":{"rendered":"

This ViewModel combines a user flow and a settings flow into one UI state. A unit test reads uiState.value<\/code> right after creating the ViewModel. It gets the empty placeholder, not the combined state. In another test, the ViewModel won’t even run without extra setup. What’s wrong?<\/p><\/blockquote>\n\n\n

val uiState: StateFlow<UiState> = combine(userFlow, settingsFlow) { user, settings ->\n    UiState(user.name, settings.darkMode)\n}.stateIn(\n    scope = CoroutineScope(Dispatchers.Main),\n    started = SharingStarted.Lazily,\n    initialValue = UiState(\"\", false)\n)<\/pre>\n\n\n
This StateFlow stale data bug has two causes. Neither is in the combine<\/code> lambda. First, SharingStarted.Lazily<\/code> doesn’t start the upstream until something subscribes. Code that reads .value<\/code> before any subscriber gets the initialValue<\/code>. Here that’s an empty placeholder. Second, the scope is created inside the class with Dispatchers.Main<\/code> hardcoded. Local unit tests don’t have a Main dispatcher unless the test replaces it. The scope also isn’t tied to the ViewModel’s lifecycle. The fix is to inject the scope, or use viewModelScope<\/code> with a test rule for Main. Then pick the sharing strategy based on how the state is read. Use Eagerly<\/code> when code reads .value<\/code> directly and needs it current. Use WhileSubscribed<\/code> when only the UI collects it.<\/p>\n\n
Bug 1: Lazily waits for a subscriber, so StateFlow stale data appears<\/h2>\n\n
The kotlinx.coroutines docs for SharingStarted.Lazily<\/code><\/a> are short. Sharing starts when the first subscriber appears and never stops. Until then, combine<\/code> hasn’t collected anything. A read of uiState.value<\/code> in that window returns UiState(\"\", false)<\/code>.<\/p>\n\n
In an app, the UI usually subscribes quickly, so this can go unnoticed. It shows up in tests that assert on .value<\/code> without collecting. It also shows up in any code that reads .value<\/code> before the screen starts collecting. A click handler is a common example.<\/p>\n\n
Bug 2: the scope is hardcoded to Dispatchers.Main<\/h2>\n\n
CoroutineScope(Dispatchers.Main)<\/code> is built inside the class. Android’s guide to testing coroutines<\/a> covers this. In local unit tests, the Main dispatcher should be replaced with a TestDispatcher<\/code>. It recommends Dispatchers.setMain<\/code>, usually through a reusable JUnit rule. A class that builds its own Main scope forces every test to do that. Nothing cancels that scope when the ViewModel is cleared, so the sharing coroutine outlives the screen.<\/p>\n\n
The fix<\/h2>\n\n\n
class ProfileViewModel(\n    userFlow: Flow<User>,\n    settingsFlow: Flow<Settings>,\n    scope: CoroutineScope   \/\/ injected\n) {\n    val uiState: StateFlow<UiState> = combine(userFlow, settingsFlow) { user, settings ->\n        UiState(user.name, settings.darkMode)\n    }.stateIn(scope, SharingStarted.Eagerly, UiState(\"\", false))\n}<\/pre>\n\n\n
Injecting the scope lets a test pass its own dispatcher and control time. In a real ViewModel<\/code>, viewModelScope<\/code> does the same job, as long as tests replace Main with a rule. Eagerly<\/code> starts collecting right away, so .value<\/code> reflects the latest combined state. Even so, a test using a StandardTestDispatcher<\/code> must still advance the scheduler before asserting.<\/p>\n\n
Choosing a sharing strategy<\/h2>\n\n