Android 中 StateFlow 的使用全面解析

// 核心协程依赖
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
// 可选：viewmodel + stateflow 扩展
implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.2"
implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.6.2"

import androidx.lifecycle.viewmodel
import androidx.lifecycle.viewmodelscope
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.mutablestateflow
import kotlinx.coroutines.flow.stateflow
import kotlinx.coroutines.flow.asstateflow
import kotlinx.coroutines.launch
class counterviewmodel : viewmodel() {
    // 1. 私有可变 stateflow（生产者），初始化默认值 0
    private val _counterstate = mutablestateflow(0)
    // 2. 对外暴露只读 stateflow（消费者）
    val counterstate: stateflow<int> = _counterstate.asstateflow()
    // 3. 同步更新状态（主线程/协程均可）
    fun incrementcounter() {
        _counterstate.value += 1
    }
    // 4. 异步更新状态（模拟网络/耗时操作）
    fun incrementcounterasync() {
        viewmodelscope.launch {
            delay(1000) // 模拟耗时操作
            _counterstate.value += 1
        }
    }
    // 5. 重置状态
    fun resetcounter() {
        _counterstate.value = 0
    }
}

import android.os.bundle
import androidx.activity.viewmodels
import androidx.appcompat.app.appcompatactivity
import androidx.lifecycle.lifecyclescope
import androidx.lifecycle.repeatonlifecycle
import kotlinx.coroutines.launch
import com.example.stateflow.databinding.activitycounterbinding
class counteractivity : appcompatactivity() {
    // 视图绑定
    private lateinit var binding: activitycounterbinding
    // viewmodel 实例
    private val viewmodel: counterviewmodel by viewmodels()
    override fun oncreate(savedinstancestate: bundle?) {
        super.oncreate(savedinstancestate)
        binding = activitycounterbinding.inflate(layoutinflater)
        setcontentview(binding.root)
        // 绑定点击事件
        binding.btnincrement.setonclicklistener {
            viewmodel.incrementcounter()
        }
        binding.btnincrementasync.setonclicklistener {
            viewmodel.incrementcounterasync()
        }
        binding.btnreset.setonclicklistener {
            viewmodel.resetcounter()
        }
        // 收集 stateflow 状态（生命周期感知）
        collectcounterstate()
    }
    private fun collectcounterstate() {
        // repeatonlifecycle：仅在 resumed 状态收集，paused 时暂停，destroyed 时取消
        lifecyclescope.launch {
            repeatonlifecycle(androidx.lifecycle.lifecycle.state.resumed) {
                // 收集状态更新
                viewmodel.counterstate.collect { count ->
                    // 更新 ui
                    binding.tvcounter.text = "当前计数：$count"
                }
            }
        }
    }
}

// 在 viewmodel 中扩展状态
val countertextstate: stateflow<string> = _counterstate
    .map { count -> "转换后的计数：$count" } // 状态转换
    .filter { it.isnotempty() } // 过滤空值
    .statein(
        scope = viewmodelscope,
        started = androidx.lifecycle.whilesubscribed(5000), // 5 秒无订阅则停止
        initialvalue = "转换后的计数：0"
    )

// 定义第二个状态
private val _isloading = mutablestateflow(false)
val isloading: stateflow<boolean> = _isloading.asstateflow()
// 合并计数和加载状态
val combinedstate: stateflow<pair<int, boolean>> = combine(
    _counterstate,
    _isloading
) { count, loading ->
    count to loading
}.statein(
    scope = viewmodelscope,
    started = whilesubscribed(5000),
    initialvalue = 0 to false
)
// 异步操作中更新加载状态
fun incrementcounterwithloading() {
    viewmodelscope.launch {
        _isloading.value = true
        delay(1000)
        _counterstate.value += 1
        _isloading.value = false
    }
}

// 搜索框输入状态
private val _searchtext = mutablestateflow("")
val searchtext: stateflow<string> = _searchtext.asstateflow()
// 防抖后的搜索状态（500ms 无输入才发射）
val debouncedsearchtext: stateflow<string> = _searchtext
    .debounce(500)
    .statein(
        scope = viewmodelscope,
        started = whilesubscribed(5000),
        initialvalue = ""
    )

// 初始化 datastore
private val context.datastore by preferencesdatastore(name = "counter_prefs")
private val counter_key = intpreferenceskey("counter")
// 从 datastore 加载初始状态
private suspend fun loadcounterfromdatastore(): int {
    return datastore.data.map { prefs ->
        prefs[counter_key] ?: 0
    }.first()
}
// 更新状态时持久化
fun incrementcounter() {
    viewmodelscope.launch {
        _counterstate.value += 1
        datastore.edit { prefs ->
            prefs[counter_key] = _counterstate.value
        }
    }
}