Flow & Channels

A cold Flow does nothing until it is collected and re-runs its producer separately for every collector, so each collector gets its own private sequence. A SharedFlow is hot: it emits whether or not anyone is listening, and all its collectors share one stream of emissions from a single producer.

Never at declaration time. An intermediate operator such as map, filter or onEach only returns a new Flow that wraps the previous one, so building the chain does no work at all. The whole chain runs when a terminal operator — collect, first, toList — starts it, once per collection.

A suspend function runs once and hands back a single value. A Flow emits many values over time, and the collector handles each one as it arrives. A Flow is cold: the producer block runs only when a terminal operator such as collect is called, and it starts over for every collector.

A Channel is a hot queue with suspension: send suspends while the buffer is full and receive suspends while it is empty. Every element goes to exactly ONE receiver — two receivers fan the work out between them rather than each getting a copy. That is what makes it the tool for producer/consumer handoff.

flowOn changes the context only for operators UPSTREAM of it — the producer and everything declared before the call. The collector always runs in the context of the coroutine that called collect, because Flow preserves context. So parseHeavy inside collect stays on the main thread; move it upstream, above flowOn.

StateFlow always holds exactly one current value, conflates fast emissions and drops a value equal to the previous one, so it models state and a new collector immediately receives the latest value. SharedFlow holds no value and is configurable (replay, buffer, overflow), which makes it the right tool for one-shot events.

By default collection is sequential: a slow collector back-pressures the producer, so emit suspends. buffer runs the producer and the collector in separate coroutines with a queue between them. conflate keeps only the newest value and drops the ones in between. collectLatest cancels the collector's body on each new value and restarts it.

StateFlow conflates and behaves as if distinctUntilChanged were applied, so assigning a value equal to the current one emits nothing — the second identical Toast is dropped before any collector sees it. StateFlow models state, not events: publish them through a MutableSharedFlow and emit each one.

Expose a Flow whenever every collector should see the whole stream and the producer should start on demand: it is cold, declarative and re-runs per collector, so nothing leaks if nobody collects. Reach for a Channel only for a hot handoff where each element must reach exactly one consumer — a work queue between coroutines.

Make the database the single source of truth: return its query Flow, so every write re-emits the list and the UI never lags behind storage. Trigger the refresh from the stream itself and write the network result INTO the database instead of emitting it. Failures go to a separate error stream, so a failed refresh leaves the cached list untouched. Share it with stateIn(WhileSubscribed).

catch is upstream-only: it sees exceptions from the producer and from the operators declared BEFORE it, and nothing else. An exception thrown inside collect is downstream, so catch never sees it and it propagates to the caller — that is exception transparency. Use retry/retryWhen for transient upstream failures and a plain try/catch around collect.