SharedFlow: mi ez, SharedFlow vs StateFlow Android rendszeren

Mi az a SharedFlow Kotlinban?

SharedFlow — egy forró adatfolyam (hot flow) a kotlinx.coroutines.flow könyvtárból, amely a StateFlow-val ellentétben nem kötődik egyetlen állapothoz, és tetszőleges számú eseményt képes küldeni tetszőleges előfizetőknek. A SharedFlow az alap típus a StateFlow számára — a StateFlow a SharedFlow-on keresztül van megvalósítva replay = 1 értékkel.

A SharedFlow kulcsjellemzője — nem kötelező tárolnia az utolsó értéket. Alapértelmezés szerint (replay = 0) az új előfizető semmit sem kap, amíg új eseményt nem küldenek. Ez teszi a SharedFlow-t ideálissá olyan forgatókönyvekhez, ahol az eseményt pontosan egyszer kell feldolgozni: navigáció, Snackbar, rendszerértesítések, QR-kód beolvasásának eredményei.

A SharedFlow a kotlinx.coroutines 1.4.0-ban (2020. november) stabilizálódott a StateFlow-val együtt. A Kotlin Coroutines dokumentáció (2025) szerint a SharedFlow finomszemcsés zárolást használ az előfizetők szinkronizálásához, és lineáris skálázhatóságot biztosít akár 1000+ egyidejű előfizetőig teljesítményromlás nélkül, amit a JetBrains tesztek is megerősítenek.

SharedFlow vs StateFlow: mikor mit használjunk

A SharedFlow és StateFlow közötti választás a továbbított adatok szemantikájától függ: állapot (StateFlow) vagy esemény (SharedFlow). Az alábbiakban egyértelmű kritériumokat talál példákkal.

A legegyszerűbb szabály: ha az adatoknak láthatónak kell lenniük a képernyő elforgatásakor — az állapot (StateFlow). Ha a képernyő elforgatásakor az esemény nem ismétlődhet meg — az egyszeri esemény (SharedFlow). Például „toast hibaüzenettel” — SharedFlow: elforgatáskor a toast nem jelenhet meg újra. „Terméklista” — StateFlow: elforgatáskor a listának a képernyőn kell maradnia.

Az IT Sectr-nél a SharedFlow-t használjuk: navigációs parancsokhoz (képernyőre váltás, deep link megnyitása), UI eseményekhez (Snackbar, AlertDialog), rendszerértesítésekhez (háttéradatok frissítése, fizetési eredmény), analitikai eseményekhez (naplózás, követés).

MutableSharedFlow: emit, tryEmit és pufferelés

MutableSharedFlow — a SharedFlow módosítható verziója az emit() (suspend) és tryEmit() (non-suspend) metódusokkal események küldéséhez. Az emit() felfüggeszti magát, ha a puffer tele van és onBufferOverflow = SUSPEND. A tryEmit() Boolean értéket ad vissza — hogy az esemény sikeresen hozzáadódott-e a pufferhez.

class EventBus {
    private val _events = MutableSharedFlow<UiEvent>(
        replay = 0,
        extraBufferCapacity = 10,
        onBufferOverflow = BufferOverflow.DROP_OLDEST
    )
    val events: SharedFlow<UiEvent> get() = _events

    suspend fun sendEvent(event: UiEvent) {
        _events.emit(event)
    }

    fun trySendEvent(event: UiEvent): Boolean {
        return _events.tryEmit(event)
    }
}

sealed interface UiEvent {
    data class ShowSnackbar(val message: String) : UiEvent
    data class NavigateTo(val route: String) : UiEvent
    data class ShowDialog(val title: String, val message: String) : UiEvent
}

A konstruktor paraméterei kritikusak: a replay = 0 garantálja, hogy az esemény nem ismétlődik meg egy új előfizető számára; extraBufferCapacity = 10 — puffer a gyors eseményküldéshez, mielőtt a UI feliratkozna; DROP_OLDEST — túlcsordulási stratégia: a régi események eldobásra kerülnek, az újak megmaradnak. A Kotlin Coroutines Performance (JetBrains, 2024) szerint a SharedFlow extraBufferCapacity = 64 értékkel több mint 100 000 eseményt dolgoz fel másodpercenként veszteség nélkül.

SharedFlow egyszeri eseményekhez: az Event minta

Az Event (vagy UiEvent) minta — a Google által ajánlott módszer egyszeri események ViewModel-ből View-ba történő továbbítására. Az állapottal (StateFlow) ellentétben az eseményt pontosan egyszer kell feldolgozni, és a képernyő elforgatásakor nem szabad megismétlődnie. A replay = 0 értékű SharedFlow ideális ehhez a feladathoz.

class CheckoutViewModel : ViewModel() {
    private val _uiState = MutableStateFlow<CheckoutState>(CheckoutState.Idle)
    val uiState: StateFlow<CheckoutState> get() = _uiState

    private val _event = MutableSharedFlow<CheckoutEvent>()
    val event: SharedFlow<CheckoutEvent> get() = _event

    fun placeOrder() {
        viewModelScope.launch {
            _uiState.value = CheckoutState.Loading
            try {
                val orderId = orderRepository.createOrder(cart)
                _uiState.value = CheckoutState.Success(orderId)
                _event.emit(CheckoutEvent.NavigateToOrderTracking(orderId))
            } catch (e: Exception) {
                _uiState.value = CheckoutState.Error(e.message)
                _event.emit(CheckoutEvent.ShowErrorSnackbar(e.message ?: "Formázási hiba"))
            }
        }
    }
}

sealed interface CheckoutEvent {
    data class NavigateToOrderTracking(val orderId: String) : CheckoutEvent
    data class ShowErrorSnackbar(val message: String) : CheckoutEvent
}

A View-ban (Activity/Fragment): az eseményre való feliratkozást a lifecycleScope-ban kell végrehajtani a repeatOnLifecycle(STATE.STARTED) segítségével. Minden STARTED-be történő belépéskor a feliratkozás újra létrejön, de az esemény nem ismétlődik, mert a SharedFlow replay=0-val már felszabadította azt. Ez garantálja, hogy a rendeléskövető képernyőre történő navigáció csak egyszer történik meg, nem minden elforgatáskor.

SharedFlow paraméterek: replay, extraBufferCapacity, onBufferOverflow

A MutableSharedFlow konstruktora három paramétert fogad, amelyek meghatározzák a puffer viselkedését. A helytelen konfiguráció események elvesztéséhez vagy az emit() blokkolásához vezethet.

// Konfigurációk különböző forgatókönyvekhez:

// 1. Egyszeri UI események (navigáció, toastok)
val uiEvents = MutableSharedFlow<UiEvent>(
    replay = 0,
    extraBufferCapacity = 5,
    onBufferOverflow = BufferOverflow.DROP_OLDEST
)

// 2. Replay adatfolyam állapot szinkronizálásához (mint a StateFlow)
val stateLike = MutableSharedFlow<AppState>(
    replay = 1,
    extraBufferCapacity = 0
)

// 3. Nagy frekvenciájú eseményküldés (analitika, naplók)
val analytics = MutableSharedFlow<AnalyticsEvent>(
    replay = 0,
    extraBufferCapacity = 100,
    onBufferOverflow = BufferOverflow.DROP_OLDEST
)

Fontos: extraBufferCapacity + replay = a puffer teljes mérete. Ha az emit() gyorsabban kerül meghívásra, mint ahogy az előfizető feldolgozza az eseményt, a puffer megtelik és az onBufferOverflow aktiválódik. UI eseményekhez a DROP_OLDEST biztonságos stratégia: a régi események (már nem aktuális navigációk) eldobásra kerülnek az újak javára. Pénzügyi tranzakciókhoz használja a SUSPEND-et — ez garantálja, hogy egyetlen esemény sem vész el a feladó blokkolása árán.

Kódpéldák: SharedFlow Kotlinban

1. példa: SharedFlow navigációhoz Jetpack Navigation-nel

Navigációs parancsok — klasszikus use case a SharedFlow számára. A Fragment feliratkozik az eseményekre és végrehajtja a navigációt. A képernyő elforgatásakor a parancs nem ismétlődik.

// ViewModel
class AuthViewModel : ViewModel() {
    private val _navEvent = MutableSharedFlow<NavEvent>()
    val navEvent: SharedFlow<NavEvent> get() = _navEvent

    fun onLoginSuccess() {
        viewModelScope.launch {
            _navEvent.emit(NavEvent.NavigateTo(NavRoutes.HOME))
        }
    }

    fun onLogout() {
        viewModelScope.launch {
            _navEvent.emit(NavEvent.NavigateTo(NavRoutes.LOGIN))
        }
    }
}

sealed interface NavEvent {
    data class NavigateTo(val route: String) : NavEvent
    data class NavigateBack(val popUpTo: String? = null) : NavEvent
}

// Fragment-ben:
viewLifecycleOwner.lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.navEvent.collect { navEvent ->
            when (navEvent) {
                is NavEvent.NavigateTo -> findNavController().navigate(navEvent.route)
                is NavEvent.NavigateBack -> findNavController().popBackStack()
            }
        }
    }
}

2. példa: SharedFlow Room-mal és Flow operátorokkal

Összetett forgatókönyv: SharedFlow a háttéreseményekről szóló értesítésekhez, kombinálva StateFlow-val az UI számára.

class NotificationViewModel : ViewModel() {
    private val _toastMessage = MutableSharedFlow<String>()
    val toastMessage: SharedFlow<String> get() = _toastMessage

    private val _notifications = MutableStateFlow<List<Notification>>(emptyList())
    val notifications: StateFlow<List<Notification>> get() = _notifications

    init {
        viewModelScope.launch {
            notificationChannel
                .consumeAsFlow()
                .collect { notification ->
                    _notifications.value = _notifications.value + notification
                    _toastMessage.emit("Új értesítés: ${notification.title}")
                }
        }
    }

    fun dismissNotification(id: String) {
        _notifications.value = _notifications.value.filter { it.id != id }
    }

    fun markAllRead() {
        viewModelScope.launch {
            _notifications.value = _notifications.value.map { it.copy(isRead = true) }
            _toastMessage.emit("Minden értesítés olvasottként jelölve")
        }
    }
}

Ebben a példában: a StateFlow tárolja az értesítések listáját (állapot — megmarad elforgatáskor), a SharedFlow toast üzeneteket küld (egyszeri események — nem ismétlődnek elforgatáskor). Két Flow típus kombinációja — a Google által ajánlott minta a ViewModel számára 2022 óta.