SharedFlow Nedir? Android'de SharedFlow vs StateFlow

Kotlin'de SharedFlow Nedir?

SharedFlow, kotlinx.coroutines.flow kütüphanesinden, StateFlow'un aksine tek bir duruma bağlı olmayan ve isteğe bağlı sayıda olayı isteğe bağlı abonelere gönderebilen sıcak bir akıştır (hot flow). SharedFlow, StateFlow için temel türdür — StateFlow aslında replay = 1 ile SharedFlow üzerinden uygulanır.

SharedFlow'un temel özelliği, son değeri saklama zorunluluğunun olmamasıdır. Varsayılan olarak (replay = 0), yeni bir abone yeni bir olay gönderilene kadar hiçbir şey almaz. Bu, SharedFlow'u olayın tam olarak bir kez işlenmesi gereken senaryolar için ideal hale getirir: gezinme, Snackbar, sistem bildirimleri, QR kod tarama sonuçları.

SharedFlow, StateFlow ile birlikte kotlinx.coroutines 1.4.0'da (Kasım 2020) kararlı hale getirildi. Kotlin Coroutines belgelerine göre (2025), SharedFlow, aboneleri senkronize etmek için ince taneli kilit kullanır ve JetBrains testleriyle onaylandığı üzere performans düşüşü olmadan 1000+ eşzamanlı aboneye kadar doğrusal ölçeklenebilirlik sağlar.

SharedFlow vs StateFlow: Ne Zaman Hangisi Kullanılır

SharedFlow ve StateFlow arasındaki seçim, iletilen verilerin anlambilimine bağlıdır: durum (StateFlow) veya olay (SharedFlow). Aşağıda — örneklerle net kriterler.

Basit kural: veriler ekran döndürüldüğünde gösterilmeliyse — bu durumdur (StateFlow). Ekran döndürüldüğünde olay tekrarlanmamalıysa — bu tek seferlik olaydır (SharedFlow). Örneğin, «hata mesajı bildirimi» — SharedFlow: ekran döndürüldüğünde bildirim tekrar gösterilmemelidir. «Ürün listesi» — StateFlow: ekran döndürüldüğünde liste ekranda kalmalıdır.

IT Sectr'de SharedFlow'u şunlar için kullanıyoruz: gezinme komutları (ekrana geçiş, derin bağlantı açma), UI olayları (Snackbar, AlertDialog), sistem bildirimleri (arka planda veri güncelleme, ödeme sonucu), analitik olaylar (günlükleme, izleme).

MutableSharedFlow: emit, tryEmit ve Arabelleğe Alma

MutableSharedFlow, olayları göndermek için emit() (suspend) ve tryEmit() (suspend olmayan) yöntemleriyle SharedFlow'un değiştirilebilir sürümüdür. Arabellek doluysa ve onBufferOverflow = SUSPEND ise emit() askıya alınır. tryEmit() Boolean döndürür — olayın arabelleğe başarıyla eklenip eklenmediğini belirtir.

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
}

Yapıcı parametreleri kritiktir: replay = 0, olayın yeni bir abone için tekrarlanmamasını garanti eder; extraBufferCapacity = 10, UI abone olmadan önce hızlı olay gönderimi durumunda arabellek sağlar; DROP_OLDEST, taşma stratejisidir: eski olaylar atılır, yenileri korunur. Kotlin Coroutines Performansına göre (JetBrains, 2024), extraBufferCapacity = 64 ile SharedFlow, kayıp olmadan saniyede 100.000'den fazla olayı işler.

SharedFlow ile Tek Seferlik Olaylar: Event Deseni

Event Deseni (veya UiEvent), Google tarafından ViewModel'den View'e tek seferlik olayları iletmek için önerilen yöntemdir. Durumdan (StateFlow) farklı olarak, olay tam olarak bir kez işlenmeli ve ekran döndürüldüğünde tekrarlanmamalıdır. replay = 0 ile SharedFlow bu görev için idealdir.

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 ?: "Sipariş hatası"))
            }
        }
    }
}

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

View'de (Activity/Fragment): olaya abonelik, lifecycleScope içinde repeatOnLifecycle(STATE.STARTED) ile yapılmalıdır. STARTED durumuna her girişte abonelik yeniden oluşturulur, ancak olay tekrarlanmaz çünkü replay=0 ile SharedFlow onu zaten serbest bırakmıştır. Bu, sipariş takip ekranına gezinmenin her ekran döndürmede değil, yalnızca bir kez gerçekleşmesini garanti eder.

SharedFlow Parametreleri: replay, extraBufferCapacity, onBufferOverflow

MutableSharedFlow yapıcısı, arabellek davranışını belirleyen üç parametre alır. Yanlış yapılandırma, olay kaybına veya emit()'in bloke olmasına neden olabilir.

// Farklı senaryolar için yapılandırmalar:

// 1. Tek seferlik UI olayları (gezinme, bildirimler)
val uiEvents = MutableSharedFlow<UiEvent>(
    replay = 0,
    extraBufferCapacity = 5,
    onBufferOverflow = BufferOverflow.DROP_OLDEST
)

// 2. Durum senkronizasyonu için Replay akışı (StateFlow gibi)
val stateLike = MutableSharedFlow<AppState>(
    replay = 1,
    extraBufferCapacity = 0
)

// 3. Yüksek frekanslı olay gönderimi (analitik, günlükler)
val analytics = MutableSharedFlow<AnalyticsEvent>(
    replay = 0,
    extraBufferCapacity = 100,
    onBufferOverflow = BufferOverflow.DROP_OLDEST
)

Önemli: extraBufferCapacity + replay = toplam arabellek boyutu. emit(), abonenin olayı işlemesinden daha hızlı çağrılırsa arabellek dolar ve onBufferOverflow devreye girer. UI olayları için DROP_OLDEST güvenli bir stratejidir: eski olaylar (artık güncel olmayan gezinmeler) yenileri lehine atılır. Finansal işlemler için SUSPEND kullanın — bu, göndereni bloke etme pahasına hiçbir olayın kaybolmamasını garanti eder.

Kotlin'de SharedFlow Kod Örnekleri

Örnek 1: Jetpack Navigation ile SharedFlow Kullanımı

Gezinme komutları, SharedFlow için klasik bir kullanım durumudur. Fragment olaylara abone olur ve gezinmeyi gerçekleştirir. Ekran döndürüldüğünde komut tekrarlanmaz.

// 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'te:
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()
            }
        }
    }
}

Örnek 2: Room ve Flow Operatörleriyle SharedFlow

Karmaşık senaryo: UI için StateFlow ile birleştirerek arka plan olay bildirimleri için SharedFlow.

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("Yeni bildirim: ${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("Tüm bildirimler okundu olarak işaretlendi")
        }
    }
}

Bu örnekte: StateFlow bildirim listesini saklar (durum — ekran döndürüldüğünde korunur), SharedFlow bildirim mesajlarını gönderir (tek seferlik olaylar — ekran döndürüldüğünde tekrarlanmaz). İki Flow türünün kombinasyonu, Google tarafından 2022'den itibaren ViewModel için önerilen desendir.