ReadThat 10: Kotlin Flows in Practice

Part 10 of the ReadThat case study.

📲 Try it live: Download the ReadThat APK (8.3 MB, Android 8+). Open the file on your phone and allow “install unknown apps” if prompted.

Flow is the wiring of the production KMP client: Room emits, repositories transform, the shared ViewModel/controllers derive immutable state, and Compose collects. The former standalone teaching-only :flows module has been removed; the patterns below are the live implementations that ship on Android and iOS, with their tests beside the owning modules.

Example 1: One immutable auth state with combine(...).stateIn(...)

Authentication has three independently changing inputs—secure-session state, form state, and a recovery message—but the UI receives one coherent snapshot:

1
val state: StateFlow<SharedAuthState> = combine(
2
    source.session,
3
    mutableForm,
4
    mutableMessage,
5
) { session, form, message ->
6
    SharedAuthState(session, form, source.enabled, message)
7
}.stateIn(
8
    coroutineScope,
9
    SharingStarted.Eagerly,
10
    SharedAuthState(source.session.value, backendEnabled = source.enabled),
11
)

SharedAuthController.kt#L71-L85

Why each piece is there:

• One state object, not a bundle of flows: an emission cannot pair a new session with stale form enablement or an obsolete message.
• The initial value is meaningful: Compose can render immediately, before the first combined emission.
• Eagerly is intentional here: auth is application-scoped, so its combined projection stays synchronized before and between auth-screen collectors. Screen-derived work uses a different policy; the detail render flow below uses WhileSubscribed(5_000).

The controller also serializes restore/auth jobs, but those commands only mutate the inputs above. There is still one public state stream and one source of UI truth.

Example 2: Observing Room

Room queries returning Flow/PagingSource are the mechanism that makes “Room is the source of truth” reactive rather than aspirational. The feed path:

1
@Transaction
2
@Query(
3
    """SELECT * FROM feed_groups
4
       WHERE accountId = :accountId AND feedId = :feedId
5
       ORDER BY sortIndex ASC"""
6
)
7
fun pagingSource(accountId: String, feedId: String): PagingSource<Int, GroupWithState>

FeedDao.kt#L17-L47 (condensed)

Room invalidates this PagingSource on any write to either joined table. That single fact powers the app’s best trick, the optimistic vote:

1
toggleLike(itemId)
2
  └─ one Room transaction: update item_state + insert vote_outbox
3
       └─ Room invalidates the PagingSource
4
            └─ Paging re-emits the affected page
5
                 └─ Compose recomposes the one changed row

No manual list surgery, no second page list to keep consistent, and the same optimistic state row is visible in feed, MediaFeed, and detail. The shared ReadThatViewModel retains the grouped Room pages once, then maps them into independently keyed SDUI cells:

1
private val cachedPagedFeed = feedController.cards.cachedIn(viewModelScope)
2

3
val pagedFeedCells: Flow<PagingData<CellUi>> = cachedPagedFeed.map { paging ->
4
    paging.flatMap { card -> card.cells }
5
}

ReadThatViewModel.kt#L212-L221

cachedIn matters: a new collector reuses the same loaded pages rather than building a new Pager generation. Non-paging Room observation follows the same shape elsewhere: the community drawer combines account-scoped membership, visit, and sync-state DAO flows, then publishes a retained snapshot (OfflineFirstRepository.kt#L321-L343).

Example 3: Expensive derivation only when structure changes

Comments demonstrate why not every property belongs in one giant combine. Loading flags can change frequently; flattening a deep tree is expensive. The shared projection first removes every field that cannot affect rows:

1
internal fun Flow<DetailState>.commentRenderLists(
2
    dispatcher: CoroutineDispatcher = Dispatchers.Default,
3
): Flow<CommentRenderList> = map { state ->
4
    DetailStructure(
5
        tree = state.comments,
6
        collapsed = state.collapsedCommentIds + state.autoCollapsedCommentIds,
7
    )
8
}.distinctUntilChanged().map { structure ->
9
    structure.tree?.let { CommentFlattener.flatten(it, structure.collapsed) }
10
        ?: CommentRenderList(emptyList(), 0, 0)
11
}.flowOn(dispatcher)

SharedDetailPresentation.kt

The ordering is the point:

• Project first, so errors, spinners, and drafts cannot invalidate comment rows. Vote/score changes remain inside the tree and correctly do produce new rows.
• Apply distinctUntilChanged to the small structural key.
• Flatten only after distinctness, and move that work off the UI thread with flowOn.
• Retain the result in the shared ViewModel with SharingStarted.WhileSubscribed(5_000), avoiding background work while spanning short collector gaps (ReadThatViewModel.kt#L258-L263).

Example 4: Switch destination-owned streams with flatMapLatest

MediaFeed, search, and community pages have destination-scoped controllers. The application ViewModel exposes only the active controller’s stream:

1
val pagedMediaFeed: Flow<PagingData<MediaFeedItem>> = activeMediaFeedController
2
    .flatMapLatest { controller ->
3
        controller?.feed ?: flowOf(PagingData.empty())
4
    }
5

6
val sharedSearchState: StateFlow<SharedSearchUiState> = activeSearchController
7
    .flatMapLatest { controller ->
8
        controller?.state ?: flowOf(SharedSearchUiState())
9
    }
10
    .stateIn(viewModelScope, SharingStarted.Eagerly, SharedSearchUiState())

ReadThatViewModel.kt#L223-L246

flatMapLatest cancels collection from the old destination as soon as a new controller becomes active, so a late search or media emission cannot repaint a different screen. Search applies the same pattern one layer down: (query, type, sort, time, safe) maps to a request, distinctUntilChanged suppresses equivalent requests, and flatMapLatest switches the Room-backed Pager (SharedSearchController.kt#L107-L114).

These patterns are tested where they ship: auth state, feed Paging integration, and search policy.

← Part 9: Networking deep dive · Next: Part 11: Kotlin Multiplatform →