0Pricing
Kotlin Academy · Ders

SharedFlow: Olay Veri Yolları ve Tek Seferlik Olaylar

Olayları yayınlamak için SharedFlow replay ve extraBufferCapacity ayarlarını yapılandırın.

SharedFlow: Olay Veri Yolları ve Tek Seferlik Olaylar, CoddyKit'te ücretsiz bir Kotlin Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Kotlin Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Kotlin Academy kursu toplamda 4 dersten oluşur.

SharedFlow Nedir?

SharedFlow, tüm etkin toplayıcılara yayın yapan sıcak bir akıştır. StateFlow'dan farklı olarak mevcut değer kavramı yoktur — tamamen olay odaklıdır.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val events = MutableSharedFlow<String>()
    launch { events.collect { println("Collector 1: $it") } }
    launch { events.collect { println("Collector 2: $it") } }
    delay(50)
    events.emit("UserLoggedIn")
    events.emit("DataRefreshed")
    delay(50)
    coroutineContext.cancelChildren()
}

replay Parametresi

replay, son N yayımı arabelleğe alır. Yeni toplayıcılar geçmişteki en fazla N olayı hemen alır. Varsayılan değer 0'dır (yeniden oynatma yoktur).

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow = MutableSharedFlow<Int>(replay = 2)
    flow.emit(1); flow.emit(2); flow.emit(3)
    // Late subscriber gets last 2:
    flow.collect { print("$it ") }  // prints 2 3
}

extraBufferCapacity

extraBufferCapacity, replay kapasitesinin ötesinde arabellek alanı ekler. Göndericiler, arabellek dolana kadar askıya alınmadan yayım yapabilir.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow = MutableSharedFlow<Int>(
        replay = 0,
        extraBufferCapacity = 10
    )
    // Can emit up to 10 times without a collector ready:
    repeat(10) { flow.tryEmit(it) }
    launch { flow.collect { print("$it ") } }
    delay(50)
    coroutineContext.cancelChildren()
}

Askıya Almayan Yayım İçin tryEmit

tryEmit(value), askıya almadan yayım yapar ve arabellek doluysa false döndürür. Askıya almayan bağlamlarda (geri çağrılar, tıklama işleyicileri) kullanın.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow = MutableSharedFlow<String>(extraBufferCapacity = 5)
    val ok = flow.tryEmit("click")  // non-suspending
    println("Emitted: $ok")
    launch { flow.collect { println(it) } }
    delay(50)
    coroutineContext.cancelChildren()
}

Tek Seferlik Olaylar (Kullanıcı Arayüzü Gezinmesi)

Gezinme veya kısa bildirim çubuğu gösterme gibi tek seferlik kullanıcı arayüzü olayları için replay=0 içeren SharedFlow kullanın — olaylar yeniden oluşturmada tekrar oynatılmaz.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
class NavViewModel {
    private val _events = MutableSharedFlow<String>()
    val events = _events.asSharedFlow()
    fun navigateTo(route: String) {
        // viewModelScope.launch:
        kotlinx.coroutines.GlobalScope.launch { _events.emit(route) }
    }
}
// Collect in UI:
// viewModel.events.collect { route -> navController.navigate(route) }

SharedFlow ve StateFlow Karşılaştırması

StateFlow: mevcut değere sahip durum (kullanıcı arayüzü durumu). SharedFlow: kalıcılığı olmayan olaylar (gezinme, kısa bildirim çubuğu, analiz). Tüketicilerin en güncel değere ihtiyaç duyup duymamasına göre seçim yapın.

import kotlinx.coroutines.flow.*
// StateFlow: always has a value; new subscribers get current value
val uiState = MutableStateFlow("idle")

// SharedFlow: no stored value; events fire and are gone (unless replay>0)
val singleEvents = MutableSharedFlow<String>(replay = 0)

fun main() { println("State = what it is; Event = what happened") }

SharedFlow ile Olay Veri Yolu

RxJava PublishSubject kalıplarının yerini alacak şekilde, tekil bir SharedFlow kullanarak uygulama genelinde basit bir olay veri yolu uygulayın.

import kotlinx.coroutines.flow.*
object EventBus {
    private val _events = MutableSharedFlow<Any>(extraBufferCapacity = 100)
    val events = _events.asSharedFlow()
    fun post(event: Any) { _events.tryEmit(event) }
}
sealed class AppEvent {
    object UserLoggedOut : AppEvent()
    data class ShowError(val msg: String) : AppEvent()
}
// Usage: EventBus.post(AppEvent.UserLoggedOut)

subscriptionCount

sharedFlow.subscriptionCount, etkin toplayıcıların sayısını izleyen bir StateFlow değeridir — üst akış üreticilerini başlatmak veya durdurmak için kullanışlıdır.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow = MutableSharedFlow<Int>()
    println("Subscribers: ${flow.subscriptionCount.value}")  // 0
    val job = launch { flow.collect { } }
    delay(50)
    println("Subscribers: ${flow.subscriptionCount.value}")  // 1
    job.cancel()
    delay(50)
    println("Subscribers: ${flow.subscriptionCount.value}")  // 0
}

resetReplayCache

resetReplayCache(), arabelleğe alınmış yeniden oynatma önbelleğini temizler; yeniden oynatılan olaylar güncelliğini yitirdiğinde ve yeni abonelerin bunları görmemesi gerektiğinde kullanışlıdır.

import kotlinx.coroutines.flow.*
fun main() {
    val flow = MutableSharedFlow<Int>(replay = 3)
    flow.tryEmit(1); flow.tryEmit(2); flow.tryEmit(3)
    println("Replay cache: ${flow.replayCache}")  // [1, 2, 3]
    flow.resetReplayCache()
    println("Replay cache: ${flow.replayCache}")  // []
}

SharedFlow'da Geri Basıncın Yönetilmesi

Toplayıcılar yavaş olduğunda seçim yapmak için onBufferOverflow kullanın: SUSPEND (varsayılan), DROP_OLDEST veya DROP_LATEST.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.channels.BufferOverflow
fun main() = runBlocking {
    val flow = MutableSharedFlow<Int>(
        replay = 0,
        extraBufferCapacity = 3,
        onBufferOverflow = BufferOverflow.DROP_OLDEST
    )
    repeat(10) { flow.tryEmit(it) }
    launch {
        flow.collect { println(it) }  // only sees most recent 3
    }
    delay(50)
    coroutineContext.cancelChildren()
}

Zaman Aşımıyla Toplama

Sınırlı sayıda olayı işleyip sonra durmak için bir SharedFlow akışını zaman aşımıyla toplayın; bu, sınama veya sınırlandırılmış işleme için kullanışlıdır.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val events = MutableSharedFlow<String>()
    launch { repeat(5) { delay(50); events.emit("Event $it") } }
    withTimeoutOrNull(200) {
        events.collect { println(it) }
    }
    println("Done collecting")
}

Hızlı Kontrol

Gezinme gibi tek seferlik kullanıcı arayüzü olayları için hangi yeniden oynatma değerini kullanmalısınız?

Özet

SharedFlow, sıcak bir olay yayıncısıdır. Tek seferlik olaylar için replay=0, geç abone olanlar için replay>0 kullanın. Askıya alma özelliği olmayan bağlamlarda tryEmit kullanın. Olaylar için SharedFlow'u, durum için StateFlow'u seçin.

Sıkça Sorulan Sorular

“SharedFlow: Olay Veri Yolları ve Tek Seferlik Olaylar” dersi ücretsiz mi?

Evet — “SharedFlow: Olay Veri Yolları ve Tek Seferlik Olaylar” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Kotlin Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Kotlin Academy kursu toplamda 4 dersten oluşur.

“SharedFlow: Olay Veri Yolları ve Tek Seferlik Olaylar” dersinde ne öğreneceğim?

Olayları yayınlamak için SharedFlow replay ve extraBufferCapacity ayarlarını yapılandırın. Kotlin Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Kotlin Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Kotlin Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“SharedFlow: Olay Veri Yolları ve Tek Seferlik Olaylar” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Kotlin Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Kotlin Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. StateFlow: Kullanıcı Arayüzü için Sıcak Durum Tutucusu
  2. SharedFlow: Olay Veri Yolları ve Tek Seferlik Olaylar
  3. shareIn ve stateIn ile Soğuk Flow'u Sıcağa Dönüştürme
  4. Turbine ile StateFlow ve SharedFlow Sınaması
← Kotlin Academy Sayfasına Dön