(StateFlow & ShareFlow) VS (Flow & LiveData)

2.lifecycleScope: The coroutine started in this scope will be canceled when Lifecycle is destroyed; you can also specify when to start through the when life cycle. If Lifecycle is not at least in the minimum required state, any coroutine running within these blocks will be suspended, note that it is suspend rather than cancellation on destruction, which means resources will still be wasted.

Be sure to pay attention to the difference between the word cancel and suspend. In fact, suspension still has a subscription relationship. When the flow is launched, it will still receive the message and go to the upstream of collect and it will not be cancelled. However, cancellation is the cancellation of the coroutine scope and the collect function will not be executed. .

But we can use repeatOnLifecycle, which cancels when leaving a certain life cycle, and starts a new coroutine when it meets the requirement (that is, the collect function will be re-executed as a new subscriber).

Android official warning: Prefer to use the repeatOnLifecycle API to collect data streams instead of collecting within the launchWhenX API. Because the latter API will suspend the coroutine instead of canceling it when Lifecycle is in the STOPPED state. The upstream stream remains active in the background and may emit new items and consume resources.

• An initial value needs to be given.

Build StateFlow & amp;ShareFlow

Official example:

To convert ordinary flow to ShareFlow (a type of StateFlow) through the shareIn operator, the following three parameters need to be passed in: (these three parameters)

class NewsRemoteDataSource(...,
    private val externalScope: CoroutineScope,
) {
    val latestNews: Flow<List<ArticleHeadline>> = flow {
        ...
    }.shareIn(
        externalScope,
        replay = 1,
        started = SharingStarted.WhileSubscribed()
    )
}

• externalScope: CoroutineScope for shared data streams. This scoped function should outlive any consumer to keep the shared data stream active long enough. (When the scope is exceeded, the flow downstream logic is cancelled)

repeatOnLifecycle collects the (upstream) collect function for the life cycle unsubscription flow (in line with opening a new coroutine to re-subscribe). The WhileSubscribed policy configures the subscriber timeout to cancel the flow function (downstream). Match these two, one is a subscriber and the other is Handle the business logic of the subscriber relationship

• replay: The number of data items to replay (replay) to each new collector. (The value will also be stored when the value is emitted, which can be understood as configuring the buffer size for later “playback”)
• started: “Start” the behavior policy. 1.WhileSubscribed() When there are active subscribers (the coroutine domain of the observed flow has not been canceled), the flow function will also be active (execute the flow function), and the timeout for the last subscriber’s unsubscription can be configured. The time tocancel the flow function can also be configured to expire (data will be removed from the buffer after a period of time)