StateFlow e SharedFlow

StateFlow e SharedFlow sono API Flow che consentono ai flussi di emettere in modo ottimale aggiornamenti di stato ed emettere valori per più consumer.

StateFlow

StateFlow è un flusso osservabile che contiene lo stato e che emette gli aggiornamenti dello stato attuale e nuovo ai suoi raccoglitori. Il valore dello stato attuale può essere letto anche tramite la proprietà value. Per aggiornare lo stato e inviarlo al flusso, assegna un nuovo valore alla proprietà value della classe MutableStateFlow.

In Android, StateFlow è ideale per le classi che devono mantenere uno stato mutabile osservabile.

Seguendo gli esempi dei flussi Kotlin, un StateFlow può essere esposto da LatestNewsViewModel in modo che View possa ascoltare gli aggiornamenti dello stato della UI e fare in modo che lo stato dello schermo sopravviva alle modifiche alla configurazione.

class LatestNewsViewModel(
    private val newsRepository: NewsRepository
) : ViewModel() {

    // Backing property to avoid state updates from other classes
    private val _uiState = MutableStateFlow(LatestNewsUiState.Success(emptyList()))
    // The UI collects from this StateFlow to get its state updates
    val uiState: StateFlow<LatestNewsUiState> = _uiState

    init {
        viewModelScope.launch {
            newsRepository.favoriteLatestNews
                // Update UI with the latest favorite news
                // Writes to the value property of MutableStateFlow,
                // adding a new element to the flow and updating all
                // of its collectors
                .collect { favoriteNews ->
                    _uiState.value = LatestNewsUiState.Success(favoriteNews)
                }
        }
    }
}

// Represents different states for the LatestNews screen
sealed class LatestNewsUiState {
    data class Success(val news: List<ArticleHeadline>) : LatestNewsUiState()
    data class Error(val exception: Throwable) : LatestNewsUiState()
}

La classe responsabile dell'aggiornamento di un MutableStateFlow è il produttore, e tutte le classi che raccolgono dati dal StateFlow sono i consumatori. A differenza di un flusso freddo creato utilizzando lo strumento di creazione flow, un StateFlow è caldo: la raccolta dal flusso non attiva alcun codice produttore. Un StateFlow è sempre attivo e in memoria e diventa idoneo per la garbage collection solo quando non ci sono altri riferimenti a esso da una radice della garbage collection.

Quando un nuovo consumer inizia a raccogliere dati dal flusso, riceve l'ultimo stato nel flusso e tutti gli stati successivi. Puoi trovare questo comportamento in altre classi osservabili come LiveData.

View ascolta StateFlow come in qualsiasi altro flusso:

class LatestNewsActivity : ComponentActivity() {
    private val latestNewsViewModel: LatestNewsViewModel = TODO() // getViewModel()

    override fun onCreate(savedInstanceState: Bundle?) {
        // ...
        // Start a coroutine in the lifecycle scope
        lifecycleScope.launch {
            // repeatOnLifecycle launches the block in a new coroutine every time the
            // lifecycle is in the STARTED state (or above) and cancels it when it's STOPPED.
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                // Trigger the flow and start listening for values.
                // Note that this happens when lifecycle is STARTED and stops
                // collecting when the lifecycle is STOPPED
                latestNewsViewModel.uiState.collect { uiState ->
                    // New value received
                    when (uiState) {
                        is LatestNewsUiState.Success -> showFavoriteNews(uiState.news)
                        is LatestNewsUiState.Error -> showError(uiState.exception)
                    }
                }
            }
        }
    }
}

Per convertire un flusso in un StateFlow, utilizza l'operatore intermedio stateIn.

StateFlow, Flow e LiveData

StateFlow e LiveData hanno somiglianze. Entrambe sono classi di contenitori di dati osservabili ed entrambe seguono un pattern simile quando vengono utilizzate nell'architettura dell'app.

Tieni presente, tuttavia, che StateFlow e LiveData si comportano in modo diverso:

  • StateFlow richiede che venga passato uno stato iniziale al costruttore, mentre LiveData no.
  • LiveData.observe() annulla automaticamente la registrazione del consumatore quando la visualizzazione passa allo stato STOPPED, mentre la raccolta da un StateFlow o da qualsiasi altro flusso non si interrompe automaticamente. Per ottenere lo stesso comportamento, devi raccogliere il flusso da un blocco Lifecycle.repeatOnLifecycle.

Rendere caldi i flussi freddi utilizzando shareIn

StateFlow è un flusso hot: rimane in memoria finché il flusso viene raccolto o finché esistono altri riferimenti a esso da una radice di Garbage Collection. Puoi trasformare i flussi freddi in flussi caldi utilizzando l'operatore shareIn.

Utilizzando callbackFlow creato nei flussi Kotlin come esempio, anziché fare in modo che ogni raccoglitore crei un nuovo flusso, puoi condividere i dati recuperati da Firestore tra i raccoglitori utilizzando shareIn. Devi trasmettere quanto segue:

  • Un CoroutineScope utilizzato per condividere il flusso. Questo ambito deve durare più a lungo di qualsiasi consumatore per mantenere attivo il flusso condiviso per tutto il tempo necessario.
  • Il numero di elementi da riprodurre per ogni nuovo raccoglitore.
  • La policy sul comportamento iniziale.

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

In questo esempio, il flusso latestNews riproduce l'ultimo elemento emesso in un nuovo raccoglitore e rimane attivo finché externalScope è attivo e sono presenti raccoglitori attivi. Il criterio di avvio SharingStarted.WhileSubscribed() mantiene attivo il produttore upstream finché sono presenti abbonati attivi. Sono disponibili altre policy di avvio, ad esempio SharingStarted.Eagerly per avviare immediatamente il producer o SharingStarted.Lazily per iniziare la condivisione dopo la comparsa del primo abbonato e mantenere attivo il flusso per sempre.

SharedFlow

La funzione shareIn restituisce un SharedFlow, un flusso caldo che emette valori per tutti i consumer che li raccolgono. Un SharedFlow è una generalizzazione altamente configurabile di StateFlow.

Puoi creare un SharedFlow senza utilizzare shareIn. Ad esempio, puoi utilizzare un SharedFlow per inviare tick al resto dell'app in modo che tutti i contenuti vengano aggiornati periodicamente nello stesso momento. Oltre a recuperare le ultime notizie, potresti anche voler aggiornare la sezione con la raccolta degli argomenti preferiti dell'utente. Nel seguente snippet di codice, un TickHandler espone un SharedFlow in modo che le altre classi sappiano quando aggiornare i suoi contenuti. Come per StateFlow, utilizza una proprietà di supporto di tipo MutableSharedFlow in una classe per inviare elementi al flusso:

// Class that centralizes when the content of the app needs to be refreshed
class TickHandler(
    private val externalScope: CoroutineScope,
    private val tickIntervalMs: Long = 5000
) {
    // Backing property to avoid flow emissions from other classes
    private val _tickFlow = MutableSharedFlow<Unit>(replay = 0)
    val tickFlow: SharedFlow<Unit> = _tickFlow

    init {
        externalScope.launch {
            while (true) {
                _tickFlow.emit(Unit)
                delay(tickIntervalMs)
            }
        }
    }
}

class NewsRepository(
    // ...
    private val tickHandler: TickHandler,
    private val externalScope: CoroutineScope
) {
    init {
        externalScope.launch {
            // Listen for tick updates
            tickHandler.tickFlow.collect {
                refreshLatestNews()
            }
        }
    }

    suspend fun refreshLatestNews() { /* ... */ }
    // ...
}

Puoi personalizzare il comportamento di SharedFlow nei seguenti modi:

  • replay ti consente di inviare nuovamente un numero di valori emessi in precedenza per i nuovi iscritti.
  • onBufferOverflow consente di specificare un criterio per quando il buffer è pieno di elementi da inviare. Il valore predefinito è BufferOverflow.SUSPEND, che fa sospendere il chiamante. Altre opzioni sono DROP_LATEST o DROP_OLDEST.

MutableSharedFlow ha anche una proprietà subscriptionCount che contiene il numero di raccoglitori attivi, in modo da poter ottimizzare la logica della tua attività di conseguenza. MutableSharedFlow contiene anche una funzione resetReplayCache se non vuoi riprodurre le ultime informazioni inviate al flusso.

Risorse aggiuntive per il flusso