// ViewModel 中定義狀態(tài)
class UserViewModel : ViewModel() {
    private val _userState = MutableStateFlow<User?>(null) // 初始值為 null
    val userState: StateFlow<User?> = _userState.asStateFlow()
    fun login(username: String, password: String) {
        viewModelScope.launch {
            _userState.value = User.Loading
            val result = repository.login(username, password)
            _userState.value = result.fold(
                onSuccess = { User.LoggedIn(it) },
                onFailure = { User.Error(it.message) }
            )
        }
    }
}
// Activity/Fragment 中監(jiān)聽狀態(tài)
lifecycleScope.launch {
    viewModel.userState.collect { state ->
        when (state) {
            is User.Loading -> showProgressBar()
            is User.LoggedIn -> updateUI(state.data)
            is User.Error -> showError(state.message)
            null -> Unit // 初始狀態(tài)處理
        }
    }
}

// ViewModel 中定義事件流
class EventViewModel : ViewModel() {
    private val _toastEvents = MutableSharedFlow<String>()
    val toastEvents: SharedFlow<String> = _toastEvents.asSharedFlow()
    fun showToast(message: String) {
        viewModelScope.launch {
            _toastEvents.emit(message) // 發(fā)送事件
        }
    }
}
// Activity/Fragment 中收集事件
lifecycleScope.launch {
    viewModel.toastEvents.collect { message ->
        Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
    }
}

// 配置 replay=1 表示新訂閱者收到最近一次事件
private val _events = MutableSharedFlow<Event>(
    replay = 1, 
    extraBufferCapacity = 10, // 緩沖區(qū)總?cè)萘?= replay + extraBufferCapacity
    onBufferOverflow = BufferOverflow.DROP_OLDEST // 緩沖區(qū)滿時丟棄舊事件
)
// 發(fā)送事件
fun sendEvent(event: Event) {
    viewModelScope.launch {
        _events.emit(event)
    }
}

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.userState.collect { updateUI(it) }
    }
}

val searchQuery = MutableSharedFlow<String>()
searchQuery
    .debounce(300) // 300ms 防抖
    .distinctUntilChanged()
    .collect { query -> search(query) }

@Test
fun testUserState() = runTest {
    viewModel.userState.test {
        assertThat(awaitItem()).isNull() // 初始值
        viewModel.login("user", "pass")
        assertThat(awaitItem()).isInstanceOf<User.Loading>()
        val result = awaitItem()
        assertThat(result).isInstanceOf<User.LoggedIn>()
    }
}

// 最多緩存 5 個事件，溢出時丟棄舊事件
MutableSharedFlow<Event>(replay = 0, extraBufferCapacity = 5)

val dataFlow = repository.fetchData()
    .shareIn(viewModelScope, SharingStarted.WhileSubscribed(5000))

if (!_events.tryEmit(event)) {
    // 處理緩沖區(qū)滿的情況
}

class MyViewModel : ViewModel() {
    // 狀態(tài)
    val uiState: StateFlow<State> = ...
    // 事件
    val events: SharedFlow<Event> = ...
}

需要管理狀態(tài)嗎？
├─ 是 → 需要初始值嗎？
│   ├─ 是 → 使用 StateFlow
│   └─ 否 → 考慮使用可空類型的 StateFlow 或 SharedFlow
└─ 否 → 處理的是事件嗎？
    ├─ 是 → 需要?dú)v史事件嗎？
    │   ├─ 是 → 使用 SharedFlow 配置適當(dāng) replay
    │   └─ 否 → 使用 SharedFlow (replay=0)
    └─ 否 → 可能需要重新評估需求

fun main() = runBlocking {
    val sharedFlow = MutableSharedFlow<String>(replay = 1)
        //事件觸發(fā)
        launch {
            sharedFlow.emit("Event Triggered")
        }
        // 事件訂閱
        sharedFlow.collect { value ->
            println("Received: $value")
        }
}

fun main() = runBlocking {
    val stateFlow = MutableStateFlow("Initial State")
    // 模擬狀態(tài)更新
    launch {
        stateFlow.value = "Updated State"
    }
    // 模擬訂閱
    stateFlow.collect { value ->
        println("Current state: $value")
    }
}