Kotlin Coroutines'ta SharedFlow ve StateFlow Yapıları

Kotlin Coroutines'ta SharedFlow ve StateFlow Yapıları

Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
Flow yapısı genellikle soğuktur (cold), yani içerisindeki veriler yalnızca ihtiyaç duyulduğunda hesaplanır ve
yayımlanır. Ancak bazı durumlarda, birden fazla alıcının aynı değişim kaynağına eşzamanlı olarak abone olması gerekir.
Bu gibi durumlarda SharedFlow kullanılır. SharedFlow, yapısal olarak birden fazla kişiye aynı anda mesaj gönderilen
bir e-posta listesine benzetilebilir. Ayrıca, sistemdeki belirli bir değeri sürekli gözlemlemek istediğimizde
kullanabileceğimiz StateFlow adında başka bir yapı daha vardır. Bu yapı, bir değerin güncel hâlini temsil eder ve
değişiklikleri gerçek zamanlı olarak takip etmemize olanak tanır. Her iki yapıyı da adım adım açıklayalım.

SharedFlow

Öncelikle MutableSharedFlow ile başlayalım. Bu yapı, herkesin mesaj gönderebildiği (emit) ve bu mesajların o anda
dinlemekte olan (collect eden) tüm coroutine’ler tarafından alındığı bir yayın kanalı (broadcast channel) gibi
çalışır. Yani veri bir kez yayımlandığında, o sırada aboneliği aktif olan tüm alıcılar bu veriyi aynı anda alır.
import kotlinx.coroutines.* import kotlinx.coroutines.flow.MutableSharedFlow // Ana işlev askıya alınabilir (suspend) olarak tanımlanmıştır. // coroutineScope içinde coroutine'ler başlatılarak yapı yönetilir. suspend fun main(): Unit = coroutineScope { // Sıcak (hot) bir veri yayım kanalı oluşturulur: MutableSharedFlow // `replay = 0` olduğunda geçmişte yayımlanan hiçbir değer yeni abonelere iletilmez. val mutableSharedFlow = MutableSharedFlow<String>(replay = 0) // Akışı ilk dinleyen coroutine başlatılır. // Bu dinleyici, yayımlanan tüm değerleri anlık olarak toplar ve terminale yazdırır. launch { mutableSharedFlow.collect { println("#1 received $it") } } // Akışı ikinci dinleyen coroutine başlatılır. // Aynı şekilde, eş zamanlı olarak yayımlanan mesajları toplar. launch { mutableSharedFlow.collect { println("#2 received $it") } } // Dinleyicilerin başlatılması için kısa bir gecikme verilir. // Bu gecikme olmazsa bazı emit'ler dinleyiciler hazır olmadan gerçekleşebilir. delay(1000) // İlk mesaj yayımlanır; aktif olan her iki dinleyici tarafından alınır. mutableSharedFlow.emit("Message1") // İkinci mesaj da aynı şekilde her iki dinleyiciye gönderilir. mutableSharedFlow.emit("Message2") } // (1 saniye sonra) // #1 received Message1 // #2 received Message1 // #1 received Message2 // #2 received Message2 // (program sonsuza dek çalışır çünkü koleksiyonlar asla tamamlanmaz)
Yukarıdaki program asla sona ermez çünkü coroutineScope, launch ile başlatılmış ve MutableSharedFlow üzerinden
dinlemeye devam eden coroutine’lerin tamamlanmasını bekler. Görüldüğü üzere, MutableSharedFlow yapısı
kapatılabilir (
closable) değildir. Bu nedenle, bu durumu sonlandırmanın tek yolu, tüm scope'u iptal etmektir (cancel).
Ayrıca, MutableSharedFlow yeni mesajlar göndermeye devam edebilir. Eğer replay parametresi ayarlanırsa (varsayılan
olarak 0’dır), belirtilen sayıda son değer bellekte tutulur. Bu durumda, bir coroutine gözlemlemeye (observe etmeye)
başladığında önce bu önbellekteki değerleri alır. Bu önbellek, resetReplayCache fonksiyonu ile sıfırlanabilir.
import kotlinx.coroutines.* import kotlinx.coroutines.flow.MutableSharedFlow // Ana işlev askıya alınabilir (suspend) olarak tanımlanır. // Coroutine bağlamında çalıştırılır. suspend fun main(): Unit = coroutineScope { // Sıcak veri yayımı için kullanılan `MutableSharedFlow` tanımlanır. // `replay = 2` ile son 2 mesaj bellekte tutulur ve yeni abonelere otomatik olarak iletilir. val mutableSharedFlow = MutableSharedFlow<String>( replay = 2 ) // Üç adet mesaj yayımlanır. // `replay = 2` olduğundan, yalnızca en son iki mesaj (2. ve 3.) bellekte tutulur. mutableSharedFlow.emit("Message1") mutableSharedFlow.emit("Message2") mutableSharedFlow.emit("Message3") // `replayCache`, bellekte saklanan son mesajlara doğrudan erişim sağlar. // Bu durumda: ["Message2", "Message3"] println(mutableSharedFlow.replayCache) // Yeni bir dinleyici başlatılır (collector). // İlk olarak bellekteki mesajları (replay) alır, ardından yeni gelenleri dinlemeye devam eder. launch { mutableSharedFlow.collect { println("#1 received $it") } // Başlangıçta şu çıktı alınır: // #1 received Message2 // #1 received Message3 } // Collector'ın başlaması için kısa bir gecikme tanımlanır. delay(100) // `resetReplayCache()` çağrıldığında bellekteki tüm replay mesajları silinir. // Bundan sonra yeni abonelere geçmiş mesaj verilmez. mutableSharedFlow.resetReplayCache() // `replayCache` artık boştur: [] println(mutableSharedFlow.replayCache) }
MutableSharedFlow, kavramsal olarak RxJava'daki Subject türlerine benzer. replay parametresi 0 olarak
ayarlandığında, PublishSubject davranışına benzer şekilde çalışır. replay 1 olarak ayarlanırsa, bu yapı
BehaviorSubject ile benzerlik gösterir. replay değeri Int.MAX_VALUE olarak ayarlanırsa, bu kez ReplaySubject
gibi çalışır.
Kotlin'de, yalnızca dinleme (observe) işlemi için kullanılan arabirimler (interface) ile veri değiştirme (emit etme)
işlemi için kullanılan arabirimler arasında açık bir ayrım yapılmasını tercih ederiz. Örneğin, daha önce SendChannel,
ReceiveChannel ve Channel arasındaki ayrımı görmüştük. Aynı kural burada da geçerlidir. MutableSharedFlow, hem
SharedFlow hem de FlowCollector arayüzlerinden türetilmiştir. SharedFlow, Flow arayüzünü miras alır ve veri
akışını gözlemlemek için kullanılırken; FlowCollector, veri göndermek (emit etmek) amacıyla kullanılır.
// `MutableSharedFlow` arayüzü, veri yayımı ve gözlemi için iki ana rolü birleştirir: // 1. Yayımcı (FlowCollector): veri gönderme // 2. Gözlemci (SharedFlow): veri alma interface MutableSharedFlow<T> : SharedFlow<T>, FlowCollector<T> { // Veriyi askıya alınmadan (suspend olmadan) yayınlamaya çalışır. // Eğer yeterli kapasite varsa yayımlar, aksi takdirde false döner. // Performans kritik durumlarda tercih edilir (örneğin UI event yayımı). fun tryEmit(value: T): Boolean // Anlık olarak bu akışı dinleyen (collect eden) abone sayısını temsil eder. // Bu bilgi, paylaşım stratejilerini optimize etmek için kullanılabilir. val subscriptionCount: StateFlow<Int> // Replay belleğini manuel olarak temizlemeye yarar. // Replay özelliği etkinse (replay > 0), bu fonksiyon bellekteki geçmiş değerleri siler. fun resetReplayCache() } // `SharedFlow` arayüzü, yalnızca veri gözlemlemek için kullanılır. // Akışı temsil eder, emit etme işlevi içermez (salt okunur). interface SharedFlow<out T> : Flow<T> { // Replay belleğinde tutulmakta olan geçmiş öğelere doğrudan erişim sağlar. // Bu liste her zaman son yayımlanan replay kapasitesi kadar veri içerir. val replayCache: List<T> } // `FlowCollector` arayüzü, Flow üzerine veri yayımlamak için kullanılır. // `emit` fonksiyonu suspend'dir: yayım işlemi bloklamaz ancak bekleyebilir. interface FlowCollector<in T> { // Akışa bir öğe yayımlar. // Tüketici yavaşsa askıya alınabilir (backpressure uyumlu) davranır. suspend fun emit(value: T) }
Bu arayüzler (interface) genellikle yalnızca belirli işlevleri dışa açmak amacıyla kullanılır: yalnızca veri
yayımlamak (emit etmek) ya da yalnızca veri toplamak (collect etmek) için.
import kotlinx.coroutines.* import kotlinx.coroutines.flow.* // Askıya alınabilir (suspend) ana fonksiyon tanımlanır. // CoroutineScope içerisinde yürütülür, böylece coroutine yaşam döngüsü kontrol altına alınır. suspend fun main(): Unit = coroutineScope { // MutableSharedFlow, Kotlin Coroutines'un çoklu aboneye destek veren, sıcak (hot) ve yeniden oynatılabilir (replay) özellikli veri yayım kanalıdır. // Burada varsayılan replay=0 ile oluşturulmuş, yani önceden yayımlanmış değerleri saklamaz. val mutableSharedFlow = MutableSharedFlow<String>() // SharedFlow, yalnızca veri gözlemleme (subscription) yetkisi olan salt okunur arayüzdür. // MutableSharedFlow örneği, SharedFlow türüne atanarak dışarıya sadece tüketici rolüyle açılır. val sharedFlow: SharedFlow<String> = mutableSharedFlow // FlowCollector, veri yayma (emit) işlevini taşıyan yazma odaklı arayüzdür. // MutableSharedFlow örneği, FlowCollector türüne atanarak sadece üretici rolüyle kullanılabilir. val collector: FlowCollector<String> = mutableSharedFlow // Coroutine başlatılır; bu coroutine, mutableSharedFlow'dan yayımlanan tüm değerleri toplar. // Abone (collector) olarak tüm değerler alınır ve işlenir. launch { mutableSharedFlow.collect { println("#1 received $it") } } // İkinci bir coroutine başlatılır; sharedFlow referansı üzerinden aynı akış izlenir. // Böylece çoklu abonelik durumu sağlanır. launch { sharedFlow.collect { println("#2 received $it") } } // Coroutine'lerin başlatılması ve koleksiyonun aktif hale gelmesi için kısa gecikme verilir. delay(1000) // Veri yayımı başlatılır. // `mutableSharedFlow.emit` çağrısı ile "Message1" yayımlanır; tüm aktif aboneler tarafından alınır. mutableSharedFlow.emit("Message1") // Alternatif olarak, sadece FlowCollector arayüzü kullanılarak "Message2" yayımlanır. // Bu çağrı da aynı şekilde tüm abonelere ulaşır. collector.emit("Message2") } // (1 saniye sonra) // #1 received Message1 // #2 received Message1 // #1 received Message2 // #2 received Message2
Aşağıda Android'de SharedFlow kullanımına dair tipik bir örnek yer almaktadır:
// Kullanıcı profil değişikliklerini yönetmek üzere tasarlanmış ViewModel sınıfı. class UserProfileViewModel { // İçsel olarak kullanıcı değişikliklerini yayımlamak için MutableSharedFlow kullanılır. // Bu yapı, çoklu aboneye sıcak (hot) veri yayımı sağlar ve replay parametresi varsayılandır (0). private val _userChanges = MutableSharedFlow<UserChange>() // Dış dünyaya yalnızca veri gözlemleme (collect) yetkisi verilen SharedFlow. // Böylece dışarıdan yayımlama engellenir, encapsulation sağlanır. val userChanges: SharedFlow<UserChange> = _userChanges // ViewModel oluşturulurken çağrılır. // Coroutine başlatılarak kullanıcı değişiklikleri gözlemlenir ve işlenir. fun onCreate() { viewModelScope.launch { // Kullanıcı değişikliklerini sırayla alır ve applyUserChange fonksiyonuna iletir. userChanges.collect(::applyUserChange) } } // Kullanıcı adı değiştiğinde çağrılır. // Gerekirse validasyon veya ön işlemler yapılabilir. // Değişiklik MutableSharedFlow üzerinden yayımlanır. fun onNameChanged(newName: String) { _userChanges.emit(NameChange(newName)) } // Kullanıcının genel anahtarı değiştiğinde çağrılır. // Gerekirse geçerlilik kontrolü yapılabilir. // Değişiklik yayımlanır. fun onPublicKeyChanged(newPublicKey: String) { _userChanges.emit(PublicKeyChange(newPublicKey)) } }

shareIn

Flow yapısı genellikle kullanıcı eylemleri, veritabanı değişiklikleri veya yeni mesajlar gibi değişiklikleri gözlemlemek
için kullanılır. Bu tür olayların nasıl işlendiğini ve birleştirildiğini (merge) daha önce öğrendik. Ancak ya birden
fazla sınıf bu değişikliklerle ilgileniyorsa ve tek bir flow'u birden fazla flow gibi kullanmak istiyorsak? Bu durumda
çözüm SharedFlow kullanmaktır. Bir Flow'u SharedFlow'a dönüştürmenin en kolay yolu ise shareIn fonksiyonudur.
import kotlinx.coroutines.* import kotlinx.coroutines.flow.* // Askıya alınabilir ana fonksiyon tanımlanır ve coroutineScope içinde yürütülür. suspend fun main(): Unit = coroutineScope { // "A", "B", "C" öğelerini yayımlayan bir flow oluşturulur. // Her öğe arasında 1 saniyelik gecikme vardır. val flow = flowOf("A", "B", "C") .onEach { delay(1000) } // Akışı sıcak (hot) ve paylaşımlı bir akışa dönüştürmek için `shareIn` kullanılır. // Böylece aynı kaynak, birden fazla abonede paylaşılır ve tekrar oluşturulmaz. val sharedFlow: SharedFlow<String> = flow.shareIn( scope = this, // Coroutine kapsamı: mevcut coroutineScope started = SharingStarted.Eagerly, // Akış hemen başlatılır, abonelik beklenmez // replay = 0 varsayılanı: geçmiş veri tutulmaz, yeni aboneler yalnızca yeni öğeleri alır ) // Birinci abonelikten önce 500 ms gecikme; böylece abonelik biraz erken başlar. delay(500) // İlk abonelik başlatılır; baştan itibaren tüm öğeleri alır. launch { sharedFlow.collect { println("#1 $it") } } // 1 saniye gecikmeden sonra ikinci abonelik başlar. // Bu abone, "B" öğesinden itibaren veri almaya başlar. delay(1000) launch { sharedFlow.collect { println("#2 $it") } } // 1 saniye daha gecikmeden sonra üçüncü abonelik başlar. // Bu abone yalnızca en son öğe "C" yi alır. delay(1000) launch { sharedFlow.collect { println("#3 $it") } } } // (1 saniye sonra) // #1 A // (1 saniye sonra) // #1 B // #2 B // (1 saniye sonra) // #1 C // #2 C // #3 C
shareIn fonksiyonu bir SharedFlow oluşturur ve bir Flow içerisinden öğeleri bu yapıya gönderir. Çünkü bir flow'dan
veri toplayabilmek için bir coroutine başlatmak gerekir; bu yüzden shareIn fonksiyonu ilk parametre olarak bir
coroutine scope ister. Üçüncü parametre olan replay, varsayılan olarak 0’dır. İkinci parametre olan started ise ilgi
çekicidir; çünkü dinlemenin ne zaman başlayacağını, yani verilerin ne zaman toplanmaya başlanacağını, dinleyici sayısına
göre belirler. Aşağıdaki seçenekler desteklenir:
  • SharingStarted.Eagerly – Flow dinlenmeye hemen başlanır ve elde edilen veriler akışa gönderilir. Ancak dikkat
    edilmelidir ki, eğer replay değeri sınırlıysa ve dinlemeye başlamadan önce veriler gelirse, bu veriler kaybolabilir.
    Özellikle replay = 0 ise, dinlemeye başlamadan önceki tüm veriler kaybedilir.
import kotlinx.coroutines.* import kotlinx.coroutines.flow.* // Askıya alınabilir ana fonksiyon tanımlanır ve coroutineScope içinde yürütülür. suspend fun main(): Unit = coroutineScope { // "A", "B", "C" öğelerini hızlıca yayımlayan bir soğuk (cold) Flow oluşturulur. val flow = flowOf("A", "B", "C") // Soğuk Flow'u sıcak (hot), paylaşımlı bir SharedFlow'a dönüştürür. // `SharingStarted.Eagerly` ile akış hemen başlatılır, abonelik beklenmez. val sharedFlow: SharedFlow<String> = flow.shareIn( scope = this, started = SharingStarted.Eagerly, // replay varsayılan olarak 0'dır, geçmiş değerler saklanmaz. ) // Aboneler 100 ms sonra eklenir. // Bu süre içinde tüm değerler zaten yayımlanmış ve kaybolmuştur. delay(100) // Birinci abone başlatılır; ancak `replay = 0` olduğu için önceki değerler verilmez. launch { sharedFlow.collect { println("#1 $it") } } // Program hemen "Done" yazdırır ve sona erer. print("Done") }
  • SharingStarted.Lazily – Dinleme (collect etme) işlemi, ilk abone (subscriber) ortaya çıktığında başlar. Bu sayede,
    ilk abone tüm yayımlanan değerleri almış olur. Daha sonra abone olanlar ise yalnızca belirlenmiş olan replay miktarı
    kadar en güncel değerleri alma garantisine sahiptir. Üst akıştaki (upstream) flow, tüm aboneler kaybolsa bile aktif
    kalmaya devam eder; ancak abone yokken yalnızca son replay değerleri önbellekte tutulur.
import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.delay import kotlinx.coroutines.flow.* import kotlinx.coroutines.launch // Askıya alınabilir (suspend) ana fonksiyon tanımlanır ve coroutineScope içinde yürütülür. // CoroutineScope, coroutine yaşam döngüsünü yönetir ve yapılandırır. suspend fun main(): Unit = coroutineScope { // İlk veri akışı (flow1), içinde "A", "B", "C" öğelerini tutan sabit bir akıştır. // Bu akış öğeleri hızlıca, yani hemen yayar. val flow1 = flowOf("A", "B", "C") // İkinci veri akışı (flow2), "D" öğesini içerir ancak her öğe yayımlanmadan önce 1 saniye gecikme uygular. // Bu gecikme, akışın zamana bağlı davranışını simüle etmek için önemlidir. val flow2 = flowOf("D") .onEach { delay(1000) } // İki farklı akış, merge operatörü ile birleştirilir. // Merge, her iki akıştan yayımlanan öğeleri aldığı gibi tek bir ortak akışta toplar. // Burada elde edilen birleşik akış, shareIn ile paylaşılabilir, sıcak (hot) ve çoklu aboneli hâle getirilir. val sharedFlow = merge(flow1, flow2).shareIn( scope = this, // Akışın yaşam döngüsü bu coroutineScope'a bağlıdır. started = SharingStarted.Lazily, // Akış, ilk abone geldiğinde başlar; abonelik beklemez. // replay varsayılan olarak 0'dır, yani geçmiş değerler yeni abonelere iletilmez. ) // İlk abonelik başlamadan önce 100 milisaniye gecikme vardır. // Bu süre zarfında flow1 akışındaki "A", "B", "C" öğeleri yayımlanır ancak henüz hiç abone yoktur. delay(100) // İlk abone başlatılır; bu abone shareIn ile paylaşılmış akışın tüm yeni yayımlanan değerlerini alır. launch { sharedFlow.collect { println("#1 $it") } } // 1 saniye sonra ikinci abonelik başlatılır. // Bu abone shareIn akışında yeni yayımlanan değerleri alır ancak geçmişte yayımlananları alamaz (replay=0). delay(1000) launch { sharedFlow.collect { println("#2 $it") } } }
  • WhileSubscribed() – Flow'u dinlemeye (collect etmeye), ilk abone (subscriber) ortaya çıktığında başlar; son abone
    abonelikten çıktığında ise dinleme durur. Eğer SharedFlow durdurulmuşken yeni bir abone gelirse, dinleme yeniden
    başlatılır.
WhileSubscribed, isteğe bağlı olarak yapılandırılabilen iki ek parametreye sahiptir:
  • stopTimeoutMillis: Son abone ayrıldıktan sonra ne kadar süreyle dinlemeye devam edileceğini belirler (varsayılan
    değeri 0’dır).
  • replayExpirationMillis: Dinleme durduktan sonra, replay verilerinin ne kadar süreyle saklanacağını belirler (
    varsayılan değeri Long.MAX_VALUE’dur).
import kotlinx.coroutines.* import kotlinx.coroutines.flow.* // Askıya alınabilir (suspend) ana fonksiyon, coroutineScope içinde yürütülür. // CoroutineScope, coroutine yaşam döngüsünü yönetir. suspend fun main(): Unit = coroutineScope { // Sabit öğelerden oluşan bir akış tanımlanır: "A", "B", "C", "D" // Akış başlatıldığında "Started" yazdırılır. // Akış tamamlandığında "Finished" yazdırılır. // Her öğe yayımlanmadan önce 1 saniye gecikme uygulanır. val flow = flowOf("A", "B", "C", "D") .onStart { println("Started") } .onCompletion { println("Finished") } .onEach { delay(1000) } // Akış, shareIn ile sıcak (hot) ve paylaşımlı bir akışa dönüştürülür. // SharingStarted.WhileSubscribed kullanılarak, yalnızca aboneler varsa çalışır. val sharedFlow = flow.shareIn( scope = this, started = SharingStarted.WhileSubscribed() ) // Başlangıçta abone yoktur, dolayısıyla flow başlamaz. delay(3000) // İlk abonelik başlatılır. // Bu abone, akışın ilk öğesi olan "A" yı alır. launch { println("#1 ${sharedFlow.first()}") } // İkinci abonelik başlatılır. // Bu abone, akışın ilk iki öğesini alır: "A" ve "B". launch { println("#2 ${sharedFlow.take(2).toList()}") } // İlk iki abonelik tamamlanana kadar 3 saniye beklenir. // Akış, bu noktada abone olmadığı için durur. delay(3000) // Üçüncü abonelik başlatılır. // Bu abonelik, akış yeniden başladığı için tekrar "A" öğesini alır. launch { println("#3 ${sharedFlow.first()}") } } // (3 saniye sonra) // Started // (1 saniye sonra) // #1 A // (1 saniye sonra) // #2 [A, B] // Finished // (1 saniye sonra) // Started // (1 saniye sonra) // #3 A // Finished
  • Ayrıca, SharingStarted arayüzünü implemente ederek özel bir paylaşım stratejisi de tanımlanabilir.
shareIn fonksiyonunu kullanmak, aynı değişikliklerle ilgilenen birden fazla servis olduğunda oldukça kullanışlıdır.
Örneğin, zaman içinde depolanan konumların (stored locations) nasıl değiştiğini gözlemlemeniz gerektiğini düşünelim.
Aşağıda, Android’de Room kütüphanesi kullanılarak bir DTO'nun (Data Transfer Object) nasıl implemente edilebileceğine
dair bir örnek yer almaktadır:
// Room kütüphanesinde veri erişim nesnesi (DAO) olarak tanımlanır. // Bu arayüz, Location nesneleri üzerinde temel CRUD işlemlerini sağlar. @Dao interface LocationDao { // Yeni bir konum eklemek için kullanılan fonksiyon. // Eğer aynı anahtarla (primary key) zaten bir kayıt varsa, bu işlem görmezden gelinir (IGNORE). @Insert(onConflict = OnConflictStrategy.IGNORE) suspend fun insertLocation(location: Location) // Tüm konum kayıtlarını silmek için kullanılan sorgu. // location_table tablosundaki tüm veriler temizlenir. @Query("DELETE FROM location_table") suspend fun deleteLocations() // Konum listesini zaman sırasına göre gözlemlemek için sorgu. // Sonuç bir Flow<List<Location>> olarak döner ve veritabanı değişikliklerini gerçek zamanlı olarak yansıtır. @Query("SELECT * FROM location_table ORDER BY time") fun observeLocations(): Flow<List<Location>> }
Sorun şudur: Eğer birden fazla servis aynı konumlara (locations) bağlı olmak zorundaysa, her birinin veritabanını ayrı
ayrı gözlemlemesi (observe etmesi) verimli olmayacaktır. Bunun yerine, bu değişiklikleri dinleyen merkezi bir servis
oluşturup bunları bir SharedFlow aracılığıyla paylaşabiliriz. İşte burada shareIn fonksiyonunu kullanmamız gerekir.
Peki ama nasıl yapılandırmalıyız?
Bu noktada bazı kararları sizin vermeniz gerekir:
Abonelerinizin (subscribers) en son konum listesini hemen almasını ister misiniz? Eğer öyleyse, replay değerini
1 olarak ayarlamalısınız.
Yalnızca değişikliklere tepki vermek istiyorsanız, replay = 0 yeterlidir.
Peki ya started parametresi? Bu kullanım senaryosu için WhileSubscribed() en uygun seçenek gibi görünüyor.
// LocationService sınıfı, konum verilerini yönetmek için tasarlanmıştır. // Bu sınıf, LocationDao'dan gelen veri akışını uygun şekilde paylaşır ve yönetir. class LocationService( locationDao: LocationDao, // Veri erişimi için DAO nesnesi alınır. scope: CoroutineScope // Akışların yaşam döngüsünü kontrol edecek coroutine kapsamı. ) { // locationDao.observeLocations() fonksiyonu tarafından dönen Flow alınır. // Bu Flow, shareIn operatörü ile paylaşımlı ve sıcak (hot) hale getirilir. // SharingStarted.WhileSubscribed() parametresi ile, yalnızca bir veya daha fazla abone varsa akış çalışır. private val locations = locationDao.observeLocations() .shareIn( scope = scope, started = SharingStarted.WhileSubscribed(), ) // Dışarıya locations Flow'u SharedFlow olarak açılır. // Böylece dış bileşenler veriyi gözlemleyebilir. fun observeLocations(): Flow<List<Location>> = locations }
Dikkat! Her çağrıda (fonksiyon çağrısı vb.) yeni bir SharedFlow oluşturmayın. Yalnızca bir tane oluşturun ve bunu bir
özellik (property) olarak saklayın.

StateFlow

StateFlow, SharedFlow kavramının bir uzantısıdır. Davranış olarak, replay parametresi 1 olarak ayarlanmış bir
SharedFlow ile benzer şekilde çalışır. Her zaman bir tane değer saklar ve bu değere value özelliği (property)
aracılığıyla erişilebilir.
// StateFlow, SharedFlow arayüzünden türetilmiş olup, her zaman güncel bir değer tutan özel bir veri akışıdır. // Bu özellik, abonelerin anlık ve kesin durumu her zaman alabilmesini sağlar. interface StateFlow<out T> : SharedFlow<T> { // Güncel değere erişim sağlayan salt okunur property. // Aboneler bu değeri doğrudan okuyabilir. val value: T } // MutableStateFlow, hem StateFlow hem de MutableSharedFlow arayüzlerini birleştiren genişletilmiş bir arayüzdür. // Böylece hem veri gözlemi hem de güncelleme yapılabilir. interface MutableStateFlow<T> : StateFlow<T>, MutableSharedFlow<T> { // Güncel değere hem erişim hem de atama yapılabilir. override var value: T // Atomik karşılaştır ve güncelle işlemi yapar. // Eğer mevcut değer 'expect' ile eşleşirse 'update' değeri atanır ve true döner. // Aksi halde işlem yapılmaz ve false döner. fun compareAndSet(expect: T, update: T): Boolean }
MutableStateFlow içerisinde value özelliğinin nasıl override edildiğine dikkat edin. Kotlin'de, open val
şeklinde tanımlanmış bir özellik, var ile geçersiz kılınabilir (override edilebilir). val yalnızca değeri
okumaya (
getter) izin verirken, var hem okumaya (getter) hem de yeni bir değer atamaya (setter) izin verir.
Başlangıç değeri, MutableStateFlow oluşturulurken yapıcıya (constructor) parametre olarak verilmelidir. Saklanan
değere erişmek ve onu güncellemek için doğrudan value özelliği kullanılır. Gördüğünüz gibi, MutableStateFlow, bir
değeri gözlemlenebilir şekilde tutan bir yapıdır (observable holder).
import kotlinx.coroutines.* import kotlinx.coroutines.flow.* // Askıya alınabilir ana fonksiyon tanımlanır; coroutineScope içinde çalıştırılır. suspend fun main(): Unit = coroutineScope { // MutableStateFlow başlatılır ve başlangıç değeri "A" olarak atanır. // StateFlow, her zaman güncel bir değer tutar ve gözlemcilere (abonelere) anında iletir. val state = MutableStateFlow("A") // Başlangıçtaki güncel değer doğrudan erişilerek konsola yazdırılır. println(state.value) // Çıktı: A // İlk coroutine başlatılır ve StateFlow üzerindeki tüm değerler toplanır. // Abone başlar başlamaz, ilk olarak mevcut değer ("A") yayımlanır. launch { state.collect { println("Güncel değer: $it") } } // 1 saniye sonra StateFlow'un değeri "B" olarak güncellenir. // Bu güncelleme tüm abonelere otomatik olarak iletilir. delay(1000) state.value = "B" // 1 saniye daha sonra yeni bir coroutine başlatılır ve yine StateFlow toplanır. // Yeni abone başlar başlamaz mevcut değer ("B") hemen alınır ve yayımlanır. delay(1000) launch { state.collect { println("Yeni abonede değer: $it") } } // 1 saniye sonra StateFlow'un değeri "C" olarak güncellenir. // Hem eski hem yeni aboneler "C" değerini otomatik olarak alır. delay(1000) state.value = "C" }
Android platformunda, StateFlow, LiveData için modern bir alternatif olarak kullanılır. Bunun iki temel nedeni
vardır:
Birincisi, StateFlow coroutine yapısıyla tam uyumludur.
İkincisi, bir başlangıç değerine sahiptir; bu nedenle nullable (null olabilir) olması gerekmez.
Bu özellikleri sayesinde StateFlow, ViewModel katmanında genellikle bileşenin durumunu (state) temsil etmek için
kullanılır. Bu durum (state) gözlemlenir ve kullanıcı arayüzü (view), bu gözlemlenen duruma göre gösterilir ve
güncellenir.
// Haber ekranının durumunu yöneten ViewModel sınıfı. // Android MVVM mimarisinde, arayüz durumunu yönetmek için kullanılır. class LatestNewsViewModel( private val newsRepository: NewsRepository // Haber verisini sağlayan bağımlılık (dependency) ) : ViewModel() { // Ekranda gösterilecek durumu saklayan içsel, değiştirilebilir (mutable) StateFlow. // Başlangıçta "LoadingNews" durumu atanır (tipik olarak yükleniyor ekranı için). private val _uiState = MutableStateFlow<NewsState>(LoadingNews) // Durum dış dünyaya sadece okunabilir (immutable) StateFlow olarak sunulur. // Bu, ViewModel'den veri kapsüllemeyi (encapsulation) ve tek yönlü veri akışını garanti eder. val uiState: StateFlow<NewsState> = _uiState // ViewModel yaşam döngüsünün başlangıcında çağrılır. // Haberler asenkron olarak yüklenir ve durum güncellenir. fun onCreate() { scope.launch { // Haber verisi alındığında StateFlow'un güncel değeri NewsLoaded ile değiştirilir. // Böylece UI aboneleri otomatik olarak bilgilendirilir. _uiState.value = NewsLoaded(newsRepository.getNews()) } } }
StateFlow yalnızca değer değiştiğinde yeni değerler yayınlar (emit eder).
import kotlinx.coroutines.* import kotlinx.coroutines.flow.* // Askıya alınabilir ana fonksiyon tanımlanır; coroutineScope ile coroutine yaşam döngüsü yönetilir. suspend fun main(): Unit = coroutineScope { // MutableStateFlow başlatılır ve başlangıç değeri "A" olarak atanır. // StateFlow her zaman bir güncel değer tutar ve yalnızca yeni, farklı bir değer yayımlandığında değişim olur. val state = MutableStateFlow("A") // Akış üzerinde her yeni değer yayımlandığında bir işlem (side-effect) yapılır. // onEach ile, yayımlanan her farklı değerde println çalışır. // stateIn ile akış sıcak (hot) ve paylaşılabilir hale gelir; başlatıldığı anda mevcut değer hemen yayımlanır. state.onEach { println("Updated to $it") } .stateIn(this) // StateFlow'un değeri "B" olarak güncellenir. // Önceki değer "A" olduğundan, değişiklik olur ve "Updated to B" yazdırılır. state.value = "B" // StateFlow'un değeri tekrar "B" olarak ayarlanır. // Mevcut değer zaten "B" olduğu için herhangi bir değişiklik olmaz, hiçbir şey yazdırılmaz. state.value = "B" // Yine "B" değeri emit edilir (asenkron yayımlanır). // Önceki değer "B" ile aynı olduğu için hiçbir değişiklik veya bildirim olmaz. state.emit("B") }
StateFlow aynı zamanda birleştirilmiş (conflated) yapıdadır; bu nedenle, daha yavaş gözlemciler bazı ara durum
değişikliklerini alamayabilir. Tüm olayları (event) almak için SharedFlow kullanın.
import kotlinx.coroutines.* import kotlinx.coroutines.flow.* import kotlinx.coroutines.test.* // Askıya alınabilir ana fonksiyon tanımlanır; coroutineScope ile coroutine yaşam döngüsü yönetilir. suspend fun main(): Unit = coroutineScope { // MutableStateFlow başlatılır ve başlangıç değeri 'X' olarak atanır. // StateFlow, her zaman bir güncel değer tutar ve değişiklikleri abonelere iletir. val state = MutableStateFlow('X') // Yeni bir coroutine başlatılır. // Bu coroutine, 300 ms aralıklarla A'dan E'ye kadar olan karakterleri sırayla yayımlar (emit veya value). launch { for (c in 'A'..'E') { delay(300) state.value = c // Alternatif olarak: state.emit(c) } } // StateFlow üzerindeki değerler toplanır (collect). // Her toplama (işleme) işlemi 1000 ms gecikmeli olarak yapılır. // Bu nedenle, bazı ara değerler toplanmadan güncel değerle üzerine yazılır ve atlanır. state.collect { delay(1000) println(it) } }
Bu davranış, bilinçli bir tasarım tercihidir. StateFlow, yalnızca mevcut durumu temsil eden bir yapıdır ve bu bağlamda,
tekrar eden ya da artık geçerliliğini yitirmiş olan durumların, gözlemleyen taraflar açısından ilgiye değer olmadığı
varsayılmaktadır.

stateIn

stateIn, Flow<T> türündeki bir yapıyı StateFlow<T> türüne dönüştüren bir işleve (function) sahiptir. Yalnızca bir
scope (kapsam) ile birlikte çağrılabilir, ancak aynı zamanda askıya alınabilen (suspending) bir fonksiyondur. StateFlow
yapısının her zaman bir değere sahip olması gerektiğini unutmayın; bu nedenle, ilk değeri açıkça belirtmezseniz, ilk
değerin hesaplanmasını beklemeniz gerekir.
import kotlinx.coroutines.* import kotlinx.coroutines.flow.* // Askıya alınabilir ana fonksiyon tanımlanır; coroutineScope ile coroutine yaşam döngüsü kontrol edilir. suspend fun main(): Unit = coroutineScope { // "A", "B", "C" öğelerini yayımlayan bir flow oluşturulur. // Her öğe arasında 1 saniyelik gecikme uygulanır. // Ayrıca üretilen her değer konsola yazdırılır. val flow = flowOf("A", "B", "C") .onEach { delay(1000) } .onEach { println("Produced $it") } // Akış, stateIn operatörüyle StateFlow'a dönüştürülür. // StateFlow, daima güncel bir değer tutar ve tüm abonelere anında iletir. val stateFlow: StateFlow<String> = flow.stateIn(this) // Dinlemeye başlandığını belirten çıktı. println("Listening") // StateFlow'un güncel değeri anında okunur. // Akış başlatıldığında henüz ilk değer ("A") üretilmemiş olabilir; bu durumda initial değeri verir. println(stateFlow.value) // StateFlow üzerinde yayımlanan tüm değerler toplanır ve konsola yazdırılır. stateFlow.collect { println("Received $it") } } // (1 saniye) // Produced A // Listening // A // Received A // (1 saniye) // Produced B // Received B // (1 saniye) // Produced C // Received C
stateIn işlevinin ikinci varyantı askıya alınabilir (suspending) değildir; ancak bir başlangıç değeri (initial value)
ve bir started modu belirtmeniz gerekir. Bu mod, daha önce açıklandığı gibi, shareIn ile aynı seçeneklere sahiptir.
import kotlinx.coroutines.* import kotlinx.coroutines.flow.* // Askıya alınabilir ana fonksiyon tanımlanır; coroutineScope ile coroutine yaşam döngüsü kontrol edilir. suspend fun main(): Unit = coroutineScope { // "A" ve "B" öğelerini yayımlayan bir Flow oluşturulur. // Her öğe arasında 1 saniye gecikme uygulanır. // Her yayımlanan öğe, üretim anında konsola yazdırılır. val flow = flowOf("A", "B") .onEach { delay(1000) } .onEach { println("Produced $it") } // Akış, stateIn operatörüyle StateFlow'a dönüştürülür. // StateFlow: Sıcak (hot), paylaşılabilir ve her zaman bir güncel değer tutan bir veri akışıdır. // started = SharingStarted.Lazily: Akış, ilk abone geldiğinde başlar. // initialValue = "Empty": Akış henüz başlamadan önce erişilebilen başlangıç değeri atanır. val stateFlow: StateFlow<String> = flow.stateIn( scope = this, started = SharingStarted.Lazily, initialValue = "Empty" ) // StateFlow'un güncel değeri okunur. // Henüz akışa abone olunmadığı ve hiçbir değer yayımlanmadığı için başlangıç değeri ("Empty") elde edilir. println(stateFlow.value) // Akış başlatılmadan önce 2 saniye gecikme uygulanır. // Bu sırada "A" ve "B" değerleri üretilmez ve yayılmaz çünkü started = Lazily seçilmiştir. delay(2000) // Akışa abone olunur; bu noktadan sonra veri üretimi başlar. // Yayımlanan tüm değerler toplanır ve konsola yazdırılır. stateFlow.collect { println("Received $it") } } // Empty // (2 saniye) // Received Empty // (1 saniye) // Produced A // Received A // (1 saniye) // Produced B // Received B
Genellikle, tek bir değişim kaynağından gelen bir değeri gözlemlemek istediğimizde stateIn kullanırız. Bu süreçte,
değişiklikler işlenebilir ve nihayetinde bu değişiklikler kullanıcı arayüzü (view) tarafından gözlemlenebilir hâle
gelir.
// LocationsViewModel sınıfı, uygulamanın konum durumunu yönetmek için tasarlanır. // MVVM mimarisinde, ViewModel katmanı UI ile veri kaynakları arasındaki köprüdür. class LocationsViewModel( locationService: LocationService // Servis katmanı: konum verisini sağlayan bağımlılık (dependency). ) : ViewModel() { // Reaktif programlama paradigmasına uygun olarak, // servis katmanından sürekli izlenebilir bir veri akışı (Flow) alınır. private val rawLocationsFlow = locationService.observeLocations() // Veri katmanından gelen konum listesi, sunum (presentation) katmanında // doğrudan kullanılacak bir modele dönüştürülür. // Bu işlem, iş mantığı ile UI mantığının ayrılmasını sağlar (separation of concerns). private val locationsDisplayFlow = rawLocationsFlow .map { it.toLocationsDisplay() } // Elde edilen akış (locationsDisplayFlow), StateFlow'a dönüştürülür. // StateFlow, her zaman güncel bir değer tutar ve çoklu aboneliğe (subscriber) izin verir. // Sıcak (hot) ve paylaşımlı bir veri akışıdır. // Bu durum, UI'nın anlık olarak tüm değişikliklerden haberdar olmasını garanti eder. private val location = locationsDisplayFlow .stateIn( // StateFlow'un yaşam döngüsü ViewModel ile sınırlandırılır. // viewModelScope kullanımı, coroutine'lerin ve akışların ViewModel // ile birlikte otomatik olarak yönetilmesini sağlar. scope = viewModelScope, // SharingStarted.Lazily stratejisi, akışın ancak bir abone geldiğinde başlatılmasına olanak tanır. // Bu sayede, sistem kaynaklarının gereksiz yere tüketilmesi önlenir. started = SharingStarted.Lazily, // initialValue parametresi, akış başlamadan önce StateFlow'un hangi değeri sunacağını belirler. // Burada, UI'nın yükleniyor (loading) durumunda olması sağlanır. initialValue = LocationsDisplay.Loading ) // StateFlow üzerinden UI katmanı, konum durumu değişikliklerini her an izleyebilir. // Bu yapı, deterministik ve reaktif bir UI güncelleme mekanizması sağlar. // ... }

Özet

Bu bölümde, Android geliştiricileri için özellikle önemli olan SharedFlow ve StateFlow kavramlarını öğrendik. Bu
yapılar, MVVM (Model-View-ViewModel) deseninin bir parçası olarak yaygın biçimde kullanılmaktadır. Android geliştirme
sürecinde viewmodel'lar kullanıyorsanız, bu yapıların işlevlerini hatırlayın ve onları kullanmayı göz önünde
bulundurun.