SharedFlow: τι είναι, SharedFlow vs StateFlow σε Android

Τι είναι το SharedFlow στο Kotlin;

SharedFlow — είναι μια θερμή ροή (hot flow) από τη βιβλιοθήκη kotlinx.coroutines.flow που, σε αντίθεση με το StateFlow, δεν είναι δεσμευμένη σε μία κατάσταση και μπορεί να εκπέμψει οποιονδήποτε αριθμό γεγονότων σε οποιουσδήποτε συνδρομητές. Το SharedFlow είναι ο βασικός τύπος για το StateFlow — το StateFlow υλοποιείται μέσω του SharedFlow με replay = 1.

Το βασικό χαρακτηριστικό του SharedFlow — δεν είναι υποχρεωμένο να αποθηκεύει την τελευταία τιμή. Από προεπιλογή (replay = 0) ένας νέος συνδρομητής δεν λαμβάνει τίποτα μέχρι να σταλεί ένα νέο γεγονός. Αυτό καθιστά το SharedFlow ιδανικό για σενάρια όπου το γεγονός πρέπει να υποβληθεί σε επεξεργασία ακριβώς μία φορά: πλοήγηση, Snackbar, ειδοποιήσεις συστήματος, αποτελέσματα σάρωσης κωδικού QR.

Το SharedFlow σταθεροποιήθηκε στο kotlinx.coroutines 1.4.0 (Νοέμβριος 2020) μαζί με το StateFlow. Σύμφωνα με την τεκμηρίωση του Kotlin Coroutines (2025), το SharedFlow χρησιμοποιεί κλείδωμα λεπτής κοκκομετρίας για συγχρονισμό συνδρομητών και παρέχει γραμμική επεκτασιμότητα έως 1000+ ταυτόχρονους συνδρομητές χωρίς υποβάθμιση απόδοσης, όπως επιβεβαιώνεται από δοκιμές της JetBrains.

SharedFlow vs StateFlow: πότε να χρησιμοποιήσετε τι

Η επιλογή μεταξύ SharedFlow και StateFlow εξαρτάται από τη σημασιολογία των μεταδιδόμενων δεδομένων: κατάσταση (StateFlow) ή γεγονός (SharedFlow). Παρακάτω υπάρχουν σαφή κριτήρια με παραδείγματα.

Ο απλούστερος κανόνας: εάν τα δεδομένα πρέπει να εμφανίζονται κατά την περιστροφή της οθόνης — είναι κατάσταση (StateFlow). Εάν κατά την περιστροφή της οθόνης το γεγονός δεν πρέπει να επαναληφθεί — είναι εφάπαξ γεγονός (SharedFlow). Για παράδειγμα, „toast με μήνυμα σφάλματος“ — SharedFlow: κατά την περιστροφή το toast δεν πρέπει να εμφανιστεί ξανά. „Λίστα προϊόντων“ — StateFlow: κατά την περιστροφή η λίστα πρέπει να παραμείνει στην οθόνη.

Στην IT Sectr χρησιμοποιούμε το SharedFlow για: εντολές πλοήγησης (μετάβαση σε οθόνη, άνοιγμα deep link), γεγονότα UI (Snackbar, AlertDialog), ειδοποιήσεις συστήματος (ενημέρωση δεδομένων στο παρασκήνιο, αποτέλεσμα πληρωμής), αναλυτικά γεγονότα (καταγραφή, παρακολούθηση).

MutableSharedFlow: emit, tryEmit και προσωρινή αποθήκευση

MutableSharedFlow — τροποποιήσιμη έκδοση του SharedFlow με μεθόδους emit() (suspend) και tryEmit() (non-suspend) για αποστολή γεγονότων. Η emit() αναστέλλεται εάν η προσωρινή μνήμη είναι γεμάτη και onBufferOverflow = SUSPEND. Η tryEmit() επιστρέφει Boolean — εάν το γεγονός προστέθηκε επιτυχώς στην προσωρινή μνήμη.

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
}

Οι παράμετροι του κατασκευαστή είναι κρίσιμες: replay = 0 εγγυάται ότι το γεγονός δεν θα επαναληφθεί για νέο συνδρομητή; extraBufferCapacity = 10 — προσωρινή μνήμη για γρήγορη αποστολή γεγονότων πριν εγγραφεί το UI; DROP_OLDEST — στρατηγική υπερχείλισης: παλιά γεγονότα απορρίπτονται, νέα διατηρούνται. Σύμφωνα με το Kotlin Coroutines Performance (JetBrains, 2024), το SharedFlow με extraBufferCapacity = 64 επεξεργάζεται πάνω από 100.000 γεγονότα ανά δευτερόλεπτο χωρίς απώλειες.

SharedFlow για εφάπαξ γεγονότα: το μοτίβο Event

Το μοτίβο Event (ή UiEvent) — η προτεινόμενη από την Google μέθοδος μεταφοράς εφάπαξ γεγονότων από το ViewModel στο View. Σε αντίθεση με την κατάσταση (StateFlow), το γεγονός πρέπει να υποβληθεί σε επεξεργασία ακριβώς μία φορά και κατά την περιστροφή της οθόνης δεν πρέπει να επαναληφθεί. Το SharedFlow με replay = 0 είναι ιδανικό για αυτήν την εργασία.

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 ?: "Σφάλμα μορφοποίησης"))
            }
        }
    }
}

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

Στο View (Activity/Fragment): η εγγραφή στο γεγονός πρέπει να εκτελείται στο lifecycleScope με repeatOnLifecycle(STATE.STARTED). Σε κάθε είσοδο στο STARTED η εγγραφή δημιουργείται ξανά, αλλά το γεγονός δεν επαναλαμβάνεται επειδή το SharedFlow με replay=0 το έχει ήδη απελευθερώσει. Αυτό εγγυάται ότι η πλοήγηση στην οθόνη παρακολούθησης παραγγελίας θα συμβεί μόνο μία φορά, όχι σε κάθε περιστροφή.

Παράμετροι SharedFlow: replay, extraBufferCapacity, onBufferOverflow

Ο κατασκευαστής MutableSharedFlow δέχεται τρεις παραμέτρους που καθορίζουν τη συμπεριφορά της προσωρινής μνήμης. Η λανθασμένη διαμόρφωση μπορεί να οδηγήσει σε απώλεια γεγονότων ή μπλοκάρισμα του emit().

// Διαμορφώσεις για διαφορετικά σενάρια:

// 1. Εφάπαξ γεγονότα UI (πλοήγηση, toast)
val uiEvents = MutableSharedFlow<UiEvent>(
    replay = 0,
    extraBufferCapacity = 5,
    onBufferOverflow = BufferOverflow.DROP_OLDEST
)

// 2. Ροή replay για συγχρονισμό κατάστασης (σαν StateFlow)
val stateLike = MutableSharedFlow<AppState>(
    replay = 1,
    extraBufferCapacity = 0
)

// 3. Αποστολή γεγονότων υψηλής συχνότητας (αναλυτικά, αρχεία καταγραφής)
val analytics = MutableSharedFlow<AnalyticsEvent>(
    replay = 0,
    extraBufferCapacity = 100,
    onBufferOverflow = BufferOverflow.DROP_OLDEST
)

Σημαντικό: extraBufferCapacity + replay = συνολικό μέγεθος προσωρινής μνήμης. Εάν η emit() καλείται ταχύτερα από όσο ο συνδρομητής επεξεργάζεται το γεγονός, η προσωρινή μνήμη γεμίζει και ενεργοποιείται το onBufferOverflow. Για γεγονότα UI, το DROP_OLDEST είναι ασφαλής στρατηγική: παλιά γεγονότα (μη πλέον σχετικές πλοηγήσεις) απορρίπτονται υπέρ των νέων. Για οικονομικές συναλλαγές χρησιμοποιήστε SUSPEND — αυτό εγγυάται ότι κανένα γεγονός δεν θα χαθεί με κόστος το μπλοκάρισμα του αποστολέα.

Παραδείγματα κώδικα: SharedFlow σε Kotlin

Παράδειγμα 1: SharedFlow για πλοήγηση με Jetpack Navigation

Εντολές πλοήγησης — κλασική περίπτωση χρήσης για SharedFlow. Το Fragment εγγράφεται στα γεγονότα και εκτελεί πλοήγηση. Κατά την περιστροφή της οθόνης η εντολή δεν επαναλαμβάνεται.

// 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:
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: SharedFlow με Room και τελεστές Flow

Σύνθετο σενάριο: SharedFlow για ειδοποιήσεις σχετικά με γεγονότα παρασκηνίου με συνδυασμό με StateFlow για UI.

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("Νέα ειδοποίηση: ${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("Όλες οι ειδοποιήσεις επισημάνθηκαν ως αναγνωσμένες")
        }
    }
}

Σε αυτό το παράδειγμα: το StateFlow αποθηκεύει τη λίστα ειδοποιήσεων (κατάσταση — διατηρείται κατά την περιστροφή), το SharedFlow εκπέμπει μηνύματα toast (εφάπαξ γεγονότα — δεν επαναλαμβάνονται κατά την περιστροφή). Ο συνδυασμός δύο τύπων Flow — το προτεινόμενο μοτίβο της Google για ViewModel από το 2022.