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
        }
    }
}