0Pricing
Kotlin Academy · Ders

StateFlow: Kullanıcı Arayüzü için Sıcak Durum Tutucusu

StateFlow'u reaktif durum kapsayıcısı olarak kullanın ve onu ViewModels içinde gözlemleyin.

StateFlow: Kullanıcı Arayüzü için Sıcak Durum Tutucusu, CoddyKit'te ücretsiz bir Kotlin Academy dersidir. Bu, 4 dersinin 1. 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.

StateFlow Nedir?

StateFlow, her zaman bir değere sahip olan ve güncellemeleri tüm toplayıcılara yayan sıcak, durum tutan bir akıştır. Modern Kotlin mimarilerinde LiveData'nın yerini alır.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val stateFlow = MutableStateFlow(0)  // initial value
    println("Current: ${stateFlow.value}")
    stateFlow.value = 42
    println("Updated: ${stateFlow.value}")
}

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

MutableStateFlow, dahili olarak kullanılan değiştirilebilir uygulamadır. Tür dönüştürerek veya .asStateFlow() kullanarak dış gözlemcilere salt okunur StateFlow sunun.

import kotlinx.coroutines.flow.*
class CounterViewModel {
    private val _count = MutableStateFlow(0)  // mutable internally
    val count: StateFlow<Int> = _count.asStateFlow()  // read-only externally
    fun increment() { _count.value++ }
    fun decrement() { _count.value-- }
}

StateFlow Toplama

StateFlow öğesini diğer herhangi bir Flow gibi toplayın. En güncel değer, toplama başladığında hemen yayılır.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val state = MutableStateFlow("loading")
    launch {
        state.collect { println("State: $it") }
    }
    delay(50); state.value = "success"
    delay(50); state.value = "idle"
    delay(50)
    coroutineContext.cancelChildren()
}

StateFlow Yinelenen Değerleri Birleştirir

StateFlow yalnızca değer değiştiğinde yayım yapar. Aynı değeri iki kez ayarlarsanız yalnızca bir yayım gerçekleşir — art arda gelen yinelenen değerleri tekilleştirir.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow = MutableStateFlow("A")
    launch {
        flow.collect { println("Received: $it") }
    }
    delay(50)
    flow.value = "A"  // no emission — same value
    flow.value = "B"  // emits
    flow.value = "B"  // no emission — same value
    flow.value = "C"  // emits
    delay(50)
    coroutineContext.cancelChildren()
}

ViewModel İçinde StateFlow

Yerleşik ViewModel kalıbı: iş mantığı tarafından değiştirilen özel MutableStateFlow ve kullanıcı arayüzü tarafından gözlemlenen genel StateFlow.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
sealed class UiState { object Loading : UiState(); data class Success(val data: String) : UiState(); data class Error(val msg: String) : UiState() }
class MyViewModel(scope: CoroutineScope) {
    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()
    init {
        scope.launch {
            delay(100)  // simulate load
            _uiState.value = UiState.Success("Hello!")
        }
    }
}

Atomik Değişiklik İçin update()

Durumu mevcut değere göre atomik olarak güncellemek için update { } kullanın — eşzamanlı güncellemeler için önemlidir.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val counter = MutableStateFlow(0)
    List(100) {
        launch(Dispatchers.Default) {
            counter.update { it + 1 }  // thread-safe atomic update
        }
    }.forEach { it.join() }
    println("Counter: ${counter.value}")  // 100
}

İyimser Güncellemeler İçin compareAndSet

compareAndSet(expect, update), yalnızca mevcut değer expect ile eşleşiyorsa yeni değeri ayarlar. İyimser eşzamanlılık için kullanışlıdır.

import kotlinx.coroutines.flow.*
fun main() {
    val state = MutableStateFlow("idle")
    val changed = state.compareAndSet("idle", "loading")
    println("Changed: $changed, Value: ${state.value}")  // true, loading
    val changed2 = state.compareAndSet("idle", "error")  // won't change
    println("Changed: $changed2, Value: ${state.value}") // false, loading
}

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

StateFlow, Android yaşam döngüsü olmadan çalışır. LiveData yaşam döngüsünü dikkate alır ancak yalnızca Android'e özgüdür. Paylaşılan KMP ViewModels için StateFlow'u tercih edin.

import kotlinx.coroutines.flow.*
// StateFlow: pure Kotlin, works in commonMain
// val state = MutableStateFlow("value")

// LiveData: Android-only, lifecycle-aware
// val liveData = MutableLiveData("value")

// In Compose, collect StateFlow with:
// val state by viewModel.uiState.collectAsState()
fun main() { println("StateFlow: multiplatform; LiveData: Android-only") }

stateIn: Soğuk Flow'u StateFlow'a Dönüştürme

flow.stateIn(scope, started, initialValue), soğuk bir Flow'u sıcak bir StateFlow'a dönüştürür ve tüm toplayıcılar arasında tek bir aboneliği paylaşır.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val cold = flow {
        println("Fetching...")
        delay(100)
        emit("data")
    }
    val hot: StateFlow<String> = cold.stateIn(
        scope = this,
        started = SharingStarted.Lazily,
        initialValue = "loading"
    )
    launch { hot.collect { println("A: $it") } }
    launch { hot.collect { println("B: $it") } }
    delay(200)
    coroutineContext.cancelChildren()
}

SharingStarted Stratejileri

Hemen: hemen başlar. Tembel: ilk toplayıcıda başlar. WhileSubscribed(stopTimeout): toplayıcı kalmadığında durur, biri abone olduğunda yeniden başlar.

import kotlinx.coroutines.flow.*
// Eagerly: upstream starts right away
// SharingStarted.Eagerly

// Lazily: waits for first subscriber
// SharingStarted.Lazily

// WhileSubscribed: stops 5s after last subscriber
// SharingStarted.WhileSubscribed(5000)

// Typical ViewModel usage:
// val uiState = repo.dataFlow.stateIn(viewModelScope, WhileSubscribed(5000), Loading)

Türetilmiş Durumu Gözlemleme

map + stateIn kullanarak mevcut bir StateFlow'dan yeni bir StateFlow türetin. Türetilen akış, kaynak değiştiğinde güncellenir.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val count = MutableStateFlow(5)
    val doubled = count.map { it * 2 }.stateIn(this, SharingStarted.Eagerly, 10)
    println(doubled.value)  // 10
    count.value = 7
    delay(50)
    println(doubled.value)  // 14
    coroutineContext.cancelChildren()
}

Kısa Kontrol

Aynı değeri iki kez ayarladığınızda StateFlow ne yapar?

Özet

StateFlow, sıcak, her zaman değer taşıyan ve yinelenen değerleri birleştiren bir Flow'dur. Dahili olarak MutableStateFlow kullanın ve dışarıya StateFlow sunun. Eşzamanlı değişiklikler için update(), soğuk akışları dönüştürmek için stateIn() kullanın.

Sıkça Sorulan Sorular

“StateFlow: Kullanıcı Arayüzü için Sıcak Durum Tutucusu” dersi ücretsiz mi?

Evet — “StateFlow: Kullanıcı Arayüzü için Sıcak Durum Tutucusu” 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.

“StateFlow: Kullanıcı Arayüzü için Sıcak Durum Tutucusu” dersinde ne öğreneceğim?

StateFlow'u reaktif durum kapsayıcısı olarak kullanın ve onu ViewModels içinde gözlemleyin. 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 1. dersidir.

“StateFlow: Kullanıcı Arayüzü için Sıcak Durum Tutucusu” 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