StateFlow与SharedFlow ⭐⭐

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
fun main() = runBlocking {
 
    // ============ 冷流示例 ============
    // flow{} 构建器创建的是冷流
    val coldFlow = flow {
        println("冷流：开始发射数据...")   // 每次 collect 都会打印
        emit(1)                            // 发射第一个值
        emit(2)                            // 发射第二个值
    }
 
    // 第一次收集 —— 触发上游从头执行
    println("--- 第一次 collect 冷流 ---")
    coldFlow.collect { value ->
        println("冷流收集到: $value")
    }
 
    // 第二次收集 —— 再次触发上游从头执行（完全独立的执行）
    println("--- 第二次 collect 冷流 ---")
    coldFlow.collect { value ->
        println("冷流收集到: $value")
    }
 
    // ============ 热流示例 ============
    // MutableStateFlow 是热流，创建时必须提供初始值
    val hotFlow = MutableStateFlow(0)      // 初始状态为 0
 
    // 启动一个协程持续收集热流
    val job = launch {
        hotFlow.collect { value ->         // 订阅者开始监听
            println("热流收集到: $value")  // 立即收到当前值 0
        }
    }
 
    delay(100)                             // 给收集者一点启动时间
    hotFlow.value = 1                      // 更新状态为 1（所有收集者立即收到）
    delay(100)
    hotFlow.value = 2                      // 更新状态为 2
    delay(100)
    job.cancel()                           // 取消收集
}

// 定义 UI 状态的密封接口，穷举所有可能的状态
sealed interface UiState {
    // 加载中状态 —— 无额外数据
    data object Loading : UiState
 
    // 成功状态 —— 携带数据列表
    data class Success(val items: List<String>) : UiState
 
    // 错误状态 —— 携带错误信息
    data class Error(val message: String) : UiState
}
 
class MyViewModel : ViewModel() {
 
    // 私有的 MutableStateFlow，外部无法直接修改
    // 初始状态为 Loading
    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
 
    // 公开的只读 StateFlow，供 UI 层订阅
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()
 
    fun loadData() {
        viewModelScope.launch {
            _uiState.value = UiState.Loading         // 切换到加载状态
            try {
                val data = repository.fetchItems()    // 从仓库获取数据
                _uiState.value = UiState.Success(data) // 成功：更新状态
            } catch (e: Exception) {
                _uiState.value = UiState.Error(e.message ?: "Unknown error") // 失败：更新状态
            }
        }
    }
}

import kotlinx.coroutines.flow.MutableStateFlow
 
fun main() {
    // 创建时必须传入初始值（此处为 "Hello"）
    val stateFlow = MutableStateFlow("Hello")
 
    // 随时可以同步读取当前值，无需挂起、无需协程
    println(stateFlow.value)  // 输出: Hello
 
    // 更新值
    stateFlow.value = "World"
 
    // 再次读取，拿到的是最新值
    println(stateFlow.value)  // 输出: World
}

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
fun main() = runBlocking {
    val stateFlow = MutableStateFlow(0)    // 初始值为 0
 
    // 启动一个收集者，但人为加入延迟模拟"慢消费"
    val job = launch {
        stateFlow.collect { value ->
            println("收集到: $value")
            delay(200)                     // 模拟 UI 渲染耗时 200ms
        }
    }
 
    delay(50)                              // 确保收集者启动
 
    // 快速连续更新 1 → 2 → 3 → 4 → 5
    for (i in 1..5) {
        stateFlow.value = i                // 每次更新都覆盖前一个值
        println("发射: $i")
        delay(30)                          // 每 30ms 更新一次（远快于收集者的 200ms）
    }
 
    delay(1000)                            // 等待收集者处理完
    job.cancel()
}

// StateFlow 内部状态槽位的变化时间线
 
// 时间轴 ──────────────────────────────────────────►
// 
// 槽位状态:  [0]  →  [1]  →  [2]  →  [3]  →  [4]  →  [5]
//             ▲                                         ▲
//             │                                         │
//         收集者读取 0                              收集者读取 5
//         (开始处理, 耗时 200ms)                    (处理完毕回来读取)
//
//             ◄──── 1,2,3,4 被合并（丢弃）────────►

val counter = MutableStateFlow(0)  // 创建可变状态流，初始值 0
 
counter.value = 1                  // 直接赋值，简单直接
counter.value = 2                  // 再次赋值，覆盖旧值

val counter = MutableStateFlow(0)
 
// update 接收一个 lambda，参数是当前值，返回值是新值
// 内部使用 CAS（Compare-And-Swap）循环保证原子性
counter.update { currentValue ->   // currentValue 是此刻的最新值
    currentValue + 1               // 返回值将成为新的状态
}

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
fun main() = runBlocking {
    val counter = MutableStateFlow(0)
 
    // 启动 100 个协程，每个协程递增 1000 次
    val jobs = List(100) {
        launch(Dispatchers.Default) {      // 在多线程调度器上执行
            repeat(1000) {
                // ❌ 错误方式：可能丢失更新
                // counter.value = counter.value + 1
 
                // ✅ 正确方式：原子更新
                counter.update { it + 1 }  // CAS 保证不丢失
            }
        }
    }
 
    jobs.forEach { it.join() }             // 等待所有协程完成
 
    // 使用 update：结果精确为 100000
    // 使用直接赋值：结果可能小于 100000（丢失更新）
    println("最终计数: ${counter.value}")   // 输出: 最终计数: 100000
}

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
fun main() = runBlocking {
    // 1. 创建：必须提供初始值
    val mutableSF = MutableStateFlow("initial")
 
    // 2. 读取当前值（同步，非挂起）
    val current: String = mutableSF.value
    println("当前值: $current")                // 输出: 当前值: initial
 
    // 3. 直接赋值更新
    mutableSF.value = "updated"
    println("更新后: ${mutableSF.value}")      // 输出: 更新后: updated
 
    // 4. 原子更新
    mutableSF.update { old ->
        "$old + appended"                      // 基于旧值计算新值
    }
    println("原子更新后: ${mutableSF.value}")  // 输出: 原子更新后: updated + appended
 
    // 5. emit（等价于赋值，在 StateFlow 中永不挂起）
    mutableSF.emit("via emit")
    println("emit 后: ${mutableSF.value}")     // 输出: emit 后: via emit
 
    // 6. 转为只读 StateFlow（封装暴露）
    val readOnly: StateFlow<String> = mutableSF.asStateFlow()
    // readOnly.value = "xxx"  // ❌ 编译错误！只读，无法赋值
    println("只读访问: ${readOnly.value}")      // ✅ 可以读取
}

// ==================== LiveData 版本（旧） ====================
 
class SearchViewModel_Old : ViewModel() {
    // 搜索关键词
    private val _query = MutableLiveData<String>("")
    val query: LiveData<String> = _query
 
    // 搜索结果 —— 需要 switchMap 来响应 query 变化
    val results: LiveData<List<String>> = _query.switchMap { keyword ->
        // switchMap 内部需要返回 LiveData
        // 无法直接使用 suspend 函数，需要 liveData{} 构建器
        liveData {
            emit(repository.search(keyword))   // 发起搜索
        }
    }
 
    fun onQueryChanged(text: String) {
        _query.value = text                    // 更新关键词
    }
}
 
// UI 层（Activity/Fragment）
// viewModel.results.observe(viewLifecycleOwner) { list ->
//     adapter.submitList(list)
// }

// ==================== StateFlow 版本（新） ====================
 
class SearchViewModel_New : ViewModel() {
    // 搜索关键词 —— StateFlow 替代 LiveData
    private val _query = MutableStateFlow("")
    val query: StateFlow<String> = _query.asStateFlow()
 
    // 搜索结果 —— 使用 Flow 操作符链式处理
    val results: StateFlow<List<String>> = _query
        .debounce(300)                         // 防抖 300ms，避免频繁请求
        .distinctUntilChanged()                // 相同关键词不重复搜索
        .flatMapLatest { keyword ->            // 新关键词取消旧搜索
            flow {
                emit(repository.search(keyword)) // 发起搜索
            }
        }
        .stateIn(                              // 将 Flow 转为 StateFlow
            scope = viewModelScope,            // 绑定 ViewModel 生命周期
            started = SharingStarted.WhileSubscribed(5000), // 有订阅者时激活，无订阅者 5s 后停止
            initialValue = emptyList()         // 初始值为空列表
        )
 
    fun onQueryChanged(text: String) {
        _query.value = text                    // 更新关键词
    }
}
 
// UI 层（Compose）
// val results by viewModel.results.collectAsStateWithLifecycle()
// LazyColumn { items(results) { ... } }

fun <T> Flow<T>.stateIn(
    scope: CoroutineScope,         // 协程作用域（控制生命周期）
    started: SharingStarted,       // 启动策略
    initialValue: T                // 初始值
): StateFlow<T>

// ========== 方式一：Jetpack Compose（最推荐）==========
@Composable
fun SearchScreen(viewModel: SearchViewModel) {
    // collectAsStateWithLifecycle() 自动跟随组合的生命周期
    // 当 Composable 离开屏幕时自动停止收集
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
 
    when (uiState) {                           // 根据状态渲染 UI
        is UiState.Loading -> LoadingSpinner()
        is UiState.Success -> ItemList((uiState as UiState.Success).items)
        is UiState.Error -> ErrorMessage((uiState as UiState.Error).message)
    }
}
 
// ========== 方式二：传统 View 体系 ==========
class SearchFragment : Fragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
 
        // repeatOnLifecycle 确保只在 STARTED 及以上状态收集
        // 当 Fragment 进入 STOPPED 状态时自动取消收集协程
        viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.uiState.collect { state ->
                    // 更新 UI
                    updateUi(state)
                }
            }
        }
    }
}

fun main() = runBlocking {
    val stateFlow = MutableStateFlow(1)
 
    stateFlow.value = 2
    stateFlow.value = 2
    stateFlow.value = 3
 
    val job = launch {
        stateFlow.collect {
            println(it)
        }
    }
 
    delay(100)
    stateFlow.value = 3
    stateFlow.value = 4
    delay(100)
    job.cancel()
}

// MutableSharedFlow 的工厂函数签名
public fun <T> MutableSharedFlow(
    replay: Int = 0,                          // 重放缓冲区大小：新订阅者能收到多少个历史值
    extraBufferCapacity: Int = 0,             // 额外缓冲区容量：在 replay 基础上再加多少缓冲
    onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND  // 缓冲区溢出策略
): MutableSharedFlow<T>

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
fun main() = runBlocking {
 
    // 创建一个 SharedFlow：
    //   replay = 1        → 新订阅者能收到最近 1 个历史值
    //   extraBufferCapacity = 2  → 额外缓冲 2 个值
    //   总缓冲区 = 1 + 2 = 3
    //   溢出策略 = DROP_OLDEST → 缓冲区满时丢弃最旧的值
    val sharedFlow = MutableSharedFlow<Int>(
        replay = 1,                                    // 重放缓冲区大小
        extraBufferCapacity = 2,                       // 额外缓冲区容量
        onBufferOverflow = BufferOverflow.DROP_OLDEST  // 溢出时丢弃最旧的值
    )
 
    // 在没有任何订阅者的情况下快速发射 5 个值
    // 由于总缓冲区只有 3，且策略是 DROP_OLDEST
    // 最终缓冲区中只保留最新的 3 个值：3, 4, 5
    sharedFlow.emit(1)  // 进入缓冲区 → [1]
    sharedFlow.emit(2)  // 进入缓冲区 → [1, 2]
    sharedFlow.emit(3)  // 进入缓冲区 → [1, 2, 3]  ← 缓冲区已满
    sharedFlow.emit(4)  // DROP_OLDEST → 丢弃 1 → [2, 3, 4]
    sharedFlow.emit(5)  // DROP_OLDEST → 丢弃 2 → [3, 4, 5]
 
    // 此时才启动一个 collector
    // 由于 replay = 1，新订阅者只会收到缓冲区中最新的 1 个值
    val job = launch {
        sharedFlow.collect { value ->                  // 新订阅者开始收集
            println("Collector received: $value")      // 首先收到 replay 的值 5
        }
    }
 
    delay(100)  // 给 collector 一点时间处理 replay 值
 
    // 继续发射新值
    sharedFlow.emit(6)  // collector 实时收到 6
    sharedFlow.emit(7)  // collector 实时收到 7
 
    delay(100)  // 等待 collector 处理
    job.cancel() // 取消收集
}
 
// 输出：
// Collector received: 5   ← replay 重放的值（最近 1 个）
// Collector received: 6   ← 实时接收
// Collector received: 7   ← 实时接收

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
fun main() = runBlocking {
 
    // ========== replay = 0（默认值）==========
    // 新订阅者不会收到任何历史值
    val flow0 = MutableSharedFlow<String>(replay = 0)  // 不重放
    flow0.emit("历史消息A")                              // 没有订阅者，直接丢失
    flow0.emit("历史消息B")                              // 没有订阅者，直接丢失
 
    val job0 = launch {
        flow0.collect { println("[replay=0] $it") }     // 启动收集，但什么也收不到
    }
    delay(50)
    flow0.emit("新消息C")                                // 订阅后发射，能收到
    delay(50)
    job0.cancel()
    // 输出: [replay=0] 新消息C
 
    println("---")
 
    // ========== replay = 1 ==========
    // 新订阅者收到最近 1 个历史值
    val flow1 = MutableSharedFlow<String>(replay = 1)  // 重放 1 个
    flow1.emit("历史消息A")                              // 进入 replay buffer
    flow1.emit("历史消息B")                              // 覆盖 A，replay buffer = [B]
 
    val job1 = launch {
        flow1.collect { println("[replay=1] $it") }     // 立即收到 "历史消息B"
    }
    delay(50)
    flow1.emit("新消息C")                                // 实时收到
    delay(50)
    job1.cancel()
    // 输出:
    // [replay=1] 历史消息B
    // [replay=1] 新消息C
 
    println("---")
 
    // ========== replay = 3 ==========
    // 新订阅者收到最近 3 个历史值
    val flow3 = MutableSharedFlow<String>(replay = 3)  // 重放 3 个
    flow3.emit("消息1")                                  // replay buffer = [1]
    flow3.emit("消息2")                                  // replay buffer = [1, 2]
    flow3.emit("消息3")                                  // replay buffer = [1, 2, 3]
    flow3.emit("消息4")                                  // 溢出最旧 → buffer = [2, 3, 4]
 
    val job3 = launch {
        flow3.collect { println("[replay=3] $it") }     // 依次收到 2, 3, 4
    }
    delay(50)
    job3.cancel()
    // 输出:
    // [replay=3] 消息2
    // [replay=3] 消息3
    // [replay=3] 消息4
}

val sharedFlow = MutableSharedFlow<String>(replay = 2)  // 重放 2 个
 
sharedFlow.emit("事件A")                                  // replay cache = [A]
sharedFlow.emit("事件B")                                  // replay cache = [A, B]
 
println(sharedFlow.replayCache)                           // 输出: [事件A, 事件B]
 
// 清空 replay 缓冲区
sharedFlow.resetReplayCache()                             // replay cache 清空
 
println(sharedFlow.replayCache)                           // 输出: []
// 此时新订阅者不会收到任何历史值

val sharedFlow = MutableSharedFlow<Int>()
 
// emit 是 suspend 函数，必须在协程中调用
// 当缓冲区满且策略为 SUSPEND 时，emit 会挂起等待
launch {
    sharedFlow.emit(42)  // 挂起发射
}

val sharedFlow = MutableSharedFlow<Int>(
    replay = 0,
    extraBufferCapacity = 1  // 总缓冲区 = 1
)
 
// tryEmit 是普通函数，不会挂起
// 如果缓冲区有空间，发射成功返回 true
// 如果缓冲区满，发射失败返回 false（不会挂起等待）
val success = sharedFlow.tryEmit(42)  // true（缓冲区有空间）
println("第一次 tryEmit: $success")   // true
 
val failed = sharedFlow.tryEmit(43)   // false（缓冲区已满，没有订阅者消费）
println("第二次 tryEmit: $failed")    // false

val sharedFlow = MutableSharedFlow<String>()
 
// subscriptionCount 本身是一个 StateFlow<Int>
// 可以用来实现"至少有一个订阅者时才开始生产数据"的逻辑
launch {
    sharedFlow.subscriptionCount
        .map { count -> count > 0 }                // 映射为"是否有订阅者"的 Boolean
        .distinctUntilChanged()                     // 去重，只在变化时通知
        .collect { hasSubscribers ->
            if (hasSubscribers) {
                println("有订阅者了，开始生产数据")  // 可以在这里启动数据源
            } else {
                println("无订阅者，停止生产")        // 可以在这里释放资源
            }
        }
}

class EventBusViewModel : ViewModel() {
 
    // 私有可变 SharedFlow — 仅内部可以发射
    private val _events = MutableSharedFlow<UiEvent>(
        replay = 0,                                    // 不重放（事件只消费一次）
        extraBufferCapacity = 1,                       // 额外缓冲 1 个，防止短暂无订阅者时丢失
        onBufferOverflow = BufferOverflow.DROP_OLDEST  // 溢出时丢最旧的
    )
 
    // 公开只读 SharedFlow — 外部只能 collect，不能 emit
    val events: SharedFlow<UiEvent> = _events.asSharedFlow()
 
    // 发送事件的方法
    fun showSnackbar(message: String) {
        viewModelScope.launch {
            _events.emit(UiEvent.ShowSnackbar(message))  // 内部发射事件
        }
    }
}
 
// 密封类定义 UI 事件
sealed class UiEvent {
    data class ShowSnackbar(val message: String) : UiEvent()  // Snackbar 事件
    data class Navigate(val route: String) : UiEvent()        // 导航事件
    object GoBack : UiEvent()                                 // 返回事件
}

// ❌ 错误示范：用 StateFlow 发送一次性事件
class BadViewModel : ViewModel() {
    private val _snackbar = MutableStateFlow<String?>(null) // 初始值 null
    val snackbar: StateFlow<String?> = _snackbar
 
    fun showError() {
        _snackbar.value = "网络错误"  // 设置事件
    }
}
 
// Activity 中观察
lifecycleScope.launch {
    viewModel.snackbar.collect { message ->
        // 问题 1: 屏幕旋转后，StateFlow 会重放最新值
        //         → Snackbar 会再次弹出（重复消费事件！）
        // 问题 2: StateFlow 的 distinctUntilChanged 特性
        //         → 连续两次发送相同的错误消息，第二次会被去重吞掉
        message?.let { showSnackbar(it) }
    }
}

// ✅ 正确方式：用 SharedFlow 发送一次性事件
class GoodViewModel : ViewModel() {
 
    // replay = 0 → 不重放，事件只消费一次
    // extraBufferCapacity = 1 → 防止短暂的订阅间隙丢失事件
    private val _uiEvents = MutableSharedFlow<UiEvent>(
        extraBufferCapacity = 1  // 关键：提供最小缓冲防丢失
    )
    val uiEvents: SharedFlow<UiEvent> = _uiEvents.asSharedFlow()
 
    fun triggerNetworkError() {
        viewModelScope.launch {
            _uiEvents.emit(UiEvent.ShowSnackbar("网络错误"))  // 第 1 次
            _uiEvents.emit(UiEvent.ShowSnackbar("网络错误"))  // 第 2 次 — 不会被去重！
        }
    }
 
    fun navigateToDetail(id: String) {
        viewModelScope.launch {
            _uiEvents.emit(UiEvent.Navigate("detail/$id"))   // 导航事件
        }
    }
}

class MainActivity : AppCompatActivity() {
 
    private val viewModel: GoodViewModel by viewModels()
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
 
        // 使用 repeatOnLifecycle 安全收集（API: lifecycle-runtime-ktx）
        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                // 只在 STARTED 及以上状态收集
                // 进入 STOPPED 时自动取消，重新进入 STARTED 时重新订阅
                viewModel.uiEvents.collect { event ->
                    when (event) {
                        is UiEvent.ShowSnackbar -> {
                            // 显示 Snackbar — 不会因旋转而重复
                            Snackbar.make(binding.root, event.message, Snackbar.LENGTH_SHORT).show()
                        }
                        is UiEvent.Navigate -> {
                            // 执行导航 — 不会因旋转而重复
                            findNavController().navigate(event.route)
                        }
                        is UiEvent.GoBack -> {
                            finish()
                        }
                    }
                }
            }
        }
    }
}

/**
 * 轻量级事件总线 — 基于 SharedFlow 实现
 * 替代 EventBus、RxBus 等第三方库
 */
object FlowEventBus {
 
    // 按事件类型存储对应的 SharedFlow
    // key: 事件的 Class 对象
    // value: 对应的 MutableSharedFlow 实例
    private val flows = ConcurrentHashMap<Class<*>, MutableSharedFlow<*>>()
 
    // 获取或创建指定类型的 SharedFlow
    // reified + inline 实现类型安全
    private inline fun <reified T : Any> getOrCreateFlow(): MutableSharedFlow<T> {
        return flows.getOrPut(T::class.java) {       // 如果不存在则创建
            MutableSharedFlow<T>(
                replay = 0,                           // 不重放 — 事件只消费一次
                extraBufferCapacity = 64,             // 较大的缓冲区防止丢失
                onBufferOverflow = BufferOverflow.DROP_OLDEST  // 溢出丢最旧
            )
        } as MutableSharedFlow<T>                     // 安全的类型转换
    }
 
    /**
     * 发送事件 — suspend 版本
     * 适合在协程中调用
     */
    suspend inline fun <reified T : Any> emit(event: T) {
        getOrCreateFlow<T>().emit(event)              // 发射事件到对应的 Flow
    }
 
    /**
     * 发送事件 — 非 suspend 版本
     * 适合在非协程环境中调用（如 Java 回调）
     */
    inline fun <reified T : Any> tryEmit(event: T): Boolean {
        return getOrCreateFlow<T>().tryEmit(event)    // 尝试发射，返回是否成功
    }
 
    /**
     * 订阅指定类型的事件流
     * 返回只读 SharedFlow 供外部 collect
     */
    inline fun <reified T : Any> on(): SharedFlow<T> {
        return getOrCreateFlow<T>().asSharedFlow()    // 返回只读视图
    }
}
 
// ========== 使用示例 ==========
 
// 定义事件
data class LoginSuccessEvent(val userId: String)   // 登录成功事件
data class LogoutEvent(val reason: String)         // 登出事件
 
// 发送端（在 ViewModel 或 Repository 中）
viewModelScope.launch {
    FlowEventBus.emit(LoginSuccessEvent("user_123"))  // 发送登录成功事件
}
 
// 接收端（在 Activity / Fragment 中）
lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        FlowEventBus.on<LoginSuccessEvent>().collect { event ->
            // 收到登录成功事件
            println("用户 ${event.userId} 登录成功")
            updateUI()
        }
    }
}

fun main() = runBlocking {
    val shared = MutableSharedFlow<Int>(
        replay = 2,
        extraBufferCapacity = 1,
        onBufferOverflow = BufferOverflow.DROP_OLDEST
    )
 
    shared.emit(10)
    shared.emit(20)
    shared.emit(30)
    shared.emit(40)
 
    val result = mutableListOf<Int>()
    val job = launch {
        shared.take(2).collect { result.add(it) }
    }
    job.join()
    println(result)
}

import kotlinx.coroutines.flow.*
 
fun main() {
    // ============ StateFlow：必须提供初始值 ============
    // 创建时传入初始值 0，value 属性立即可用
    val stateFlow = MutableStateFlow(0)
 
    // 无需任何 emit，直接就能读取当前值
    println("StateFlow 当前值: ${stateFlow.value}")  // 输出: 0
 
    // ============ SharedFlow：无需初始值 ============
    // 创建时不传入任何值，此刻"没有数据"
    val sharedFlow = MutableSharedFlow<Int>()
 
    // SharedFlow 没有 .value 属性！
    // 下面这行如果取消注释会编译错误：
    // println(sharedFlow.value)  // ❌ Unresolved reference: value
}

// StateFlow 接口 —— 注意 value 属性
public interface StateFlow<out T> : SharedFlow<T> {
    // 始终持有当前值，任何时刻都可同步读取
    public val value: T
}
 
// SharedFlow 接口 —— 没有 value 属性
public interface SharedFlow<out T> : Flow<T> {
    // 只暴露了 replayCache，即已重放的历史值列表
    public val replayCache: List<T>
}

// MutableStateFlow 工厂函数 —— 强制传入初始值
public fun <T> MutableStateFlow(value: T): MutableStateFlow<T>
 
// MutableSharedFlow 工厂函数 —— 无需初始值，参数全部有默认值
public fun <T> MutableSharedFlow(
    replay: Int = 0,           // 默认不重放
    extraBufferCapacity: Int = 0,
    onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND
): MutableSharedFlow<T>

class MyViewModel : ViewModel() {
 
    // ========== 用 StateFlow 管理 UI 状态 ==========
    // 屏幕状态必须有初始值：用户一打开页面就得看到"加载中"
    // 这里 UiState.Loading 就是那个"第零时刻"的状态
    data class UiState(
        val isLoading: Boolean = false,   // 是否正在加载
        val items: List<String> = emptyList(), // 数据列表
        val error: String? = null         // 错误信息
    )
 
    // 创建 MutableStateFlow，初始值为"加载中"状态
    private val _uiState = MutableStateFlow(UiState(isLoading = true))
    // 对外暴露不可变的 StateFlow
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()
 
    // ========== 用 SharedFlow 管理一次性事件 ==========
    // 事件在发生之前不存在，所以不需要初始值
    // 比如"显示一个 Toast"——App 启动时没有 Toast 要显示
    sealed class UiEvent {
        data class ShowToast(val message: String) : UiEvent()
        data class Navigate(val route: String) : UiEvent()
    }
 
    // 创建 MutableSharedFlow，不传初始值
    private val _events = MutableSharedFlow<UiEvent>()
    // 对外暴露不可变的 SharedFlow
    val events: SharedFlow<UiEvent> = _events.asSharedFlow()
 
    fun loadData() {
        viewModelScope.launch {
            // 更新状态：开始加载
            _uiState.value = UiState(isLoading = true)
            try {
                val data = repository.fetchData()  // 网络请求
                // 更新状态：加载成功
                _uiState.value = UiState(items = data)
                // 发射事件：显示成功提示（一次性消费）
                _events.emit(UiEvent.ShowToast("加载成功！"))
            } catch (e: Exception) {
                // 更新状态：加载失败
                _uiState.value = UiState(error = e.message)
            }
        }
    }
}

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
fun main() = runBlocking {
    // ============ StateFlow：自动去重 ============
    val stateFlow = MutableStateFlow(1)  // 初始值为 1
 
    // 启动一个收集者，打印每次收到的值
    val stateJob = launch {
        stateFlow.collect { value ->
            println("[StateFlow] 收到: $value")
        }
    }
 
    delay(100)  // 等收集者就绪
 
    stateFlow.value = 1  // 与当前值相同 → 静默丢弃，不通知
    delay(100)
    stateFlow.value = 2  // 不同 → 更新并通知
    delay(100)
    stateFlow.value = 2  // 又相同 → 再次丢弃
    delay(100)
    stateFlow.value = 3  // 不同 → 更新并通知
    delay(100)
 
    stateJob.cancel()
 
    // 输出：
    // [StateFlow] 收到: 1   ← 初始值
    // [StateFlow] 收到: 2   ← 值变了
    // [StateFlow] 收到: 3   ← 值又变了
    // 注意：两次重复的赋值 (1→1, 2→2) 完全没有触发通知！
 
    println("---分割线---")
 
    // ============ SharedFlow：默认不去重 ============
    val sharedFlow = MutableSharedFlow<Int>(replay = 0)
 
    val sharedJob = launch {
        sharedFlow.collect { value ->
            println("[SharedFlow] 收到: $value")
        }
    }
 
    delay(100)
 
    sharedFlow.emit(1)  // 通知
    delay(100)
    sharedFlow.emit(1)  // 再次通知！SharedFlow 不去重
    delay(100)
    sharedFlow.emit(2)  // 通知
    delay(100)
    sharedFlow.emit(2)  // 再次通知！
    delay(100)
 
    sharedJob.cancel()
 
    // 输出：
    // [SharedFlow] 收到: 1
    // [SharedFlow] 收到: 1   ← 重复值也会收到！
    // [SharedFlow] 收到: 2
    // [SharedFlow] 收到: 2   ← 重复值也会收到！
}

// data class 自动生成 equals()，基于所有属性比较
data class User(val name: String, val age: Int)
 
val flow = MutableStateFlow(User("Alice", 25))
 
// 创建一个全新的 User 对象，但属性值完全相同
val newUser = User("Alice", 25)
 
// 虽然 flow.value !== newUser（不同对象引用）
// 但 flow.value == newUser 为 true（structural equality）
// 所以这次赋值会被去重！collector 不会收到通知
flow.value = newUser

class SearchViewModel : ViewModel() {
    // 搜索结果状态
    private val _results = MutableStateFlow<List<String>>(emptyList())
    val results: StateFlow<List<String>> = _results.asStateFlow()
 
    fun search(query: String) {
        viewModelScope.launch {
            val newResults = repository.search(query)
            // 如果搜索结果和上次完全相同（比如用户重复点击搜索）
            // StateFlow 自动去重，UI 不会触发无意义的重新渲染
            _results.value = newResults
        }
    }
}

// 场景：用户连续点击"刷新"按钮
// 你想每次点击都触发刷新，即使上一次结果相同
 
// ❌ 错误做法：用 StateFlow
val _refreshTrigger = MutableStateFlow(Unit)
fun refresh() {
    // Unit == Unit 永远为 true！
    // 第二次点击时 StateFlow 会去重，下游完全无反应！
    _refreshTrigger.value = Unit
}
 
// ✅ 正确做法 1：用 SharedFlow
val _refreshTrigger = MutableSharedFlow<Unit>()
suspend fun refresh() {
    _refreshTrigger.emit(Unit)  // 每次都会通知，不去重
}
 
// ✅ 正确做法 2：如果必须用 StateFlow，用自增计数器打破相等性
val _refreshTrigger = MutableStateFlow(0)
fun refresh() {
    _refreshTrigger.value++  // 每次值都不同，绕过去重
}

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
// 数据类，自动生成 equals() / hashCode()
data class FormState(
    val username: String = "",     // 用户名
    val email: String = "",        // 邮箱
    val isValid: Boolean = false   // 表单是否合法
)
 
fun main() = runBlocking {
    val formFlow = MutableStateFlow(FormState())  // 默认空表单
 
    var notificationCount = 0  // 记录收到通知的次数
 
    val job = launch {
        formFlow.collect {
            notificationCount++
            println("#$notificationCount 表单状态: $it")
        }
    }
 
    delay(100)
 
    // 第 1 次更新：修改用户名 → 新旧不同 → 通知 ✅
    formFlow.value = FormState(username = "Alice")
    delay(100)
 
    // 第 2 次更新：设置完全相同的值 → equals() 返回 true → 去重 ❌
    formFlow.value = FormState(username = "Alice")
    delay(100)
 
    // 第 3 次更新：增加 email → 新旧不同 → 通知 ✅
    formFlow.value = FormState(username = "Alice", email = "a@b.com")
    delay(100)
 
    // 第 4 次更新：又设置完全相同的组合 → 去重 ❌
    formFlow.value = FormState(username = "Alice", email = "a@b.com")
    delay(100)
 
    job.cancel()
 
    // 最终输出：
    // #1 表单状态: FormState(username=, email=, isValid=false)      ← 初始值
    // #2 表单状态: FormState(username=Alice, email=, isValid=false)  ← 第1次更新
    // #3 表单状态: FormState(username=Alice, email=a@b.com, isValid=false) ← 第3次更新
    // 总共只收到 3 次通知，而不是 5 次！
    println("总通知次数: $notificationCount")  // 输出: 3
}

// StateFlow 在概念上等价于以下 SharedFlow 配置：
val pseudoStateFlow = MutableSharedFlow<T>(
    replay = 1,                              // 始终重放最新 1 个值（新订阅者立刻收到）
    extraBufferCapacity = 0,                 // 没有额外缓存
    onBufferOverflow = BufferOverflow.DROP_OLDEST  // 新值直接覆盖旧值，永不挂起
)
// 外加：
// 1. 强制提供初始值
// 2. 内置 distinctUntilChanged() 去重
// 3. 提供 .value 属性进行同步读写

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
fun main() = runBlocking {
    // 创建一个 replay = 3 的 SharedFlow
    // 新订阅者可以收到订阅前最近的 3 个值
    val chatHistory = MutableSharedFlow<String>(replay = 3)
 
    // 先发射 5 条消息（此时还没有任何收集者）
    chatHistory.emit("消息1: 大家好")
    chatHistory.emit("消息2: 今天天气不错")
    chatHistory.emit("消息3: 准备开会")
    chatHistory.emit("消息4: 会议开始")
    chatHistory.emit("消息5: 讨论第一个议题")
 
    // 现在才开始收集（模拟"迟到"的订阅者）
    val job = launch {
        chatHistory.collect { msg ->
            println("[新加入者收到] $msg")
        }
    }
 
    delay(200)
    job.cancel()
 
    // 输出（只收到最近 3 条，因为 replay = 3）：
    // [新加入者收到] 消息3: 准备开会
    // [新加入者收到] 消息4: 会议开始
    // [新加入者收到] 消息5: 讨论第一个议题
 
    // 对比：StateFlow 只能 replay = 1（永远只有最新的那一个值）
}

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
fun main() = runBlocking {
 
    // ========== 策略 A：DROP_OLDEST（丢弃最旧的）==========
    val dropOldest = MutableSharedFlow<Int>(
        replay = 0,                // 不重放
        extraBufferCapacity = 2,   // 缓存 2 个值
        onBufferOverflow = BufferOverflow.DROP_OLDEST  // 溢出时丢弃最旧
    )
 
    // 慢速收集者
    val jobA = launch {
        dropOldest.collect {
            delay(500)  // 模拟处理很慢
            println("[DROP_OLDEST] 处理: $it")
        }
    }
 
    // 快速发射
    repeat(5) { i ->
        dropOldest.emit(i)       // 缓冲区满时会丢弃最旧的值
        println("[DROP_OLDEST] 发射: $i")
        delay(50)
    }
 
    delay(3000)
    jobA.cancel()
 
    println("---分割线---")
 
    // ========== 策略 B：DROP_LATEST（丢弃最新的）==========
    val dropLatest = MutableSharedFlow<Int>(
        replay = 0,
        extraBufferCapacity = 2,
        onBufferOverflow = BufferOverflow.DROP_LATEST  // 溢出时丢弃正在尝试发射的新值
    )
 
    val jobB = launch {
        dropLatest.collect {
            delay(500)
            println("[DROP_LATEST] 处理: $it")
        }
    }
 
    repeat(5) { i ->
        dropLatest.emit(i)
        println("[DROP_LATEST] 发射: $i")
        delay(50)
    }
 
    delay(3000)
    jobB.cancel()
 
    // 核心区别：
    // DROP_OLDEST：保证发射者不阻塞，牺牲旧数据
    // DROP_LATEST：保证发射者不阻塞，牺牲新数据
    // SUSPEND（默认）：发射者在缓冲区满时挂起等待，不丢失任何数据
}

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
// 模拟按钮点击事件
sealed class ClickEvent {
    object SingleClick : ClickEvent()   // 单击
    object DoubleClick : ClickEvent()   // 双击
}
 
fun main() = runBlocking {
    val clickEvents = MutableSharedFlow<ClickEvent>()
 
    val job = launch {
        clickEvents.collect { event ->
            when (event) {
                is ClickEvent.SingleClick -> println("处理单击事件")
                is ClickEvent.DoubleClick -> println("处理双击事件")
            }
        }
    }
 
    delay(100)
 
    // 用户连续点击 3 次——每次都是 SingleClick
    clickEvents.emit(ClickEvent.SingleClick)  // ✅ 通知
    clickEvents.emit(ClickEvent.SingleClick)  // ✅ 通知（SharedFlow 不去重！）
    clickEvents.emit(ClickEvent.SingleClick)  // ✅ 通知
    // 如果用 StateFlow：第 2、3 次会被去重，只触发 1 次！这在按钮点击场景下是 Bug！
 
    delay(200)
    job.cancel()
 
    // 输出：
    // 处理单击事件
    // 处理单击事件
    // 处理单击事件
}

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
fun main() = runBlocking {
    val eventBus = MutableSharedFlow<String>(
        replay = 0,              // 不重放历史
        extraBufferCapacity = 64 // 给足缓冲，避免 emit 挂起
    )
 
    // 订阅者 A：处理日志
    val jobA = launch {
        eventBus.collect { println("[Logger] $it") }
    }
 
    // 订阅者 B：处理统计
    val jobB = launch {
        eventBus.collect { println("[Analytics] $it") }
    }
 
    // 订阅者 C：处理 UI 更新
    val jobC = launch {
        eventBus.collect { println("[UI] $it") }
    }
 
    delay(100)
 
    // 查看当前有多少活跃订阅者
    // SharedFlow 提供 subscriptionCount 属性（StateFlow 也有）
    println("当前订阅者数量: ${eventBus.subscriptionCount.value}")  // 输出: 3
 
    // 发射一个事件，三个订阅者都会收到
    eventBus.emit("用户登录成功")
 
    delay(200)
 
    // 取消其中一个订阅者
    jobC.cancel()
    delay(100)
    println("取消一个后订阅者数量: ${eventBus.subscriptionCount.value}")  // 输出: 2
 
    listOf(jobA, jobB).forEach { it.cancel() }
}

fun main() = runBlocking {
    val state = MutableStateFlow("A")
    val shared = MutableSharedFlow<String>(replay = 1)
    shared.emit("A")
 
    val results = mutableListOf<String>()
 
    val job1 = launch {
        state.collect { results.add("S:$it") }
    }
    val job2 = launch {
        shared.collect { results.add("H:$it") }
    }
 
    delay(100)
 
    state.value = "A"
    shared.emit("A")
 
    delay(100)
 
    state.value = "B"
    shared.emit("B")
 
    delay(100)
 
    job1.cancel()
    job2.cancel()
 
    println(results)
}

// ✅ 正确做法：内部可变，外部只读
class MyViewModel : ViewModel() {
    // 内部使用 MutableStateFlow，可以通过 value 属性写入
    private val _uiState = MutableStateFlow(UiState.Loading)
    // 对外暴露只读的 StateFlow 接口
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()
 
    // 内部使用 MutableSharedFlow，可以通过 emit() 发送事件
    private val _events = MutableSharedFlow<UiEvent>()
    // 对外暴露只读的 SharedFlow 接口
    val events: SharedFlow<UiEvent> = _events.asSharedFlow()
}