第 05 章 MVVM 架构与组件交互¶

// 基本ViewModel
class UserViewModel : ViewModel() {
    private val _userName = MutableStateFlow("")
    val userName: StateFlow<String> = _userName.asStateFlow()

    fun updateUserName(name: String) {
        _userName.value = name
    }

    override fun onCleared() {
        super.onCleared()
        // 清理资源
    }
}

// 带SavedState的ViewModel
// SavedStateHandle 可在进程被系统回收后恢复状态（如旋转屏幕、后台被杀）
class TaskViewModel(savedStateHandle: SavedStateHandle) : ViewModel() {
    private val taskId: String = checkNotNull(savedStateHandle["taskId"]) // 从导航参数中提取

    // 使用SavedStateHandle保存状态，进程重建后自动恢复
    var searchQuery by savedStateHandle.saveable { mutableStateOf("") }
        private set
}

// 在Compose中使用
@Composable
fun UserScreen(viewModel: UserViewModel = viewModel()) {
    val userName by viewModel.userName.collectAsState()

    TextField(
        value = userName,
        onValueChange = viewModel::updateUserName
    )
}

// 定义UI状态
data class NewsUiState(
    val isLoading: Boolean = false,
    val news: List<NewsItem> = emptyList(),
    val error: String? = null,
    val selectedCategory: NewsCategory = NewsCategory.ALL
)

// 定义UI事件
sealed class NewsEvent {
    data class SelectCategory(val category: NewsCategory) : NewsEvent()
    data class Refresh(val force: Boolean = false) : NewsEvent()
    data object LoadMore : NewsEvent()
}

// ViewModel实现
@HiltViewModel
class NewsViewModel @Inject constructor(
    private val getNewsUseCase: GetNewsUseCase
) : ViewModel() {

    private val _uiState = MutableStateFlow(NewsUiState())
    val uiState: StateFlow<NewsUiState> = _uiState.asStateFlow()

    init {
        loadNews()
    }

    // 统一事件入口：将 UI 事件分发到对应处理函数
    fun onEvent(event: NewsEvent) {
        when (event) {
            is NewsEvent.SelectCategory -> selectCategory(event.category)
            is NewsEvent.Refresh -> refresh(event.force)
            is NewsEvent.LoadMore -> loadMore()
        }
    }

    private fun selectCategory(category: NewsCategory) {
        _uiState.update { it.copy(selectedCategory = category) }
        loadNews()
    }

    private fun loadNews() {
        viewModelScope.launch {
            _uiState.update { it.copy(isLoading = true, error = null) }

            getNewsUseCase(_uiState.value.selectedCategory)
                .onSuccess { news ->
                    _uiState.update {
                        it.copy(news = news, isLoading = false)
                    }
                }
                .onFailure { error ->
                    // 加载失败时保留已有数据，只更新错误信息
                    _uiState.update {
                        it.copy(error = error.message, isLoading = false)
                    }
                }
        }
    }
}

// Repository接口
interface UserRepository {  // interface定义类型契约
    suspend fun getUser(userId: String): Result<User>
    suspend fun updateUser(user: User): Result<Unit>
    fun getUsersFlow(): Flow<List<User>>
}

// Repository实现
class UserRepositoryImpl @Inject constructor(
    private val userApi: UserApi,
    private val userDao: UserDao,
    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
) : UserRepository {

    // 离线优先策略：网络成功则缓存到本地，网络失败则回退到本地缓存
    override suspend fun getUser(userId: String): Result<User> =
        withContext(ioDispatcher) {
            try {  // try/catch捕获异常
                // 先尝试从网络获取
                val remoteUser = userApi.getUser(userId)
                userDao.insertUser(remoteUser.toEntity()) // 同步到本地数据库
                Result.success(remoteUser.toDomain())
            } catch (e: Exception) {
                // 网络失败则从本地获取
                userDao.getUserById(userId)?.let {
                    Result.success(it.toDomain())
                } ?: Result.failure(e) // 本地也无数据时返回失败
            }
        }

    override fun getUsersFlow(): Flow<List<User>> {
        return userDao.getUsersFlow()
            .map { entities -> entities.map { it.toDomain() } } // Entity → Domain 模型转换
            .flowOn(ioDispatcher) // 在 IO 线程执行数据库操作
    }
}

// UseCase基类
// 通过 operator fun invoke 实现类的函数式调用：useCase(params)
abstract class UseCase<in P, R> {
    operator fun invoke(parameters: P): Flow<Result<R>> = execute(parameters)
        .catch { e -> emit(Result.failure(e)) } // 统一捕获异常，转为 Result.failure
        .flowOn(Dispatchers.IO)                  // 确保在 IO 线程执行

    protected abstract fun execute(parameters: P): Flow<Result<R>>
}

// 具体UseCase
class GetNewsUseCase @Inject constructor(
    private val newsRepository: NewsRepository
) : UseCase<NewsCategory, List<NewsItem>>() {

    override fun execute(parameters: NewsCategory): Flow<Result<List<NewsItem>>> = flow {
        emit(Result.success(newsRepository.getNews(parameters)))
    }
}

// 无参数UseCase
class GetCurrentUserUseCase @Inject constructor(
    private val userRepository: UserRepository
) {
    suspend operator fun invoke(): Result<User> {
        return userRepository.getCurrentUser()
    }
}

// Application类
@HiltAndroidApp
class MyApplication : Application()

// 模块定义
@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {

    @Provides
    @Singleton
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl(BuildConfig.BASE_URL)
            .addConverterFactory(Json.asConverterFactory())
            .build()
    }

    @Provides
    @Singleton
    fun provideUserApi(retrofit: Retrofit): UserApi {
        return retrofit.create(UserApi::class.java)
    }
}

@Module
@InstallIn(SingletonComponent::class)
abstract class RepositoryModule {

    @Binds
    abstract fun bindUserRepository(
        impl: UserRepositoryImpl
    ): UserRepository
}

// 限定符
@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class IoDispatcher

@Module
@InstallIn(SingletonComponent::class)
object DispatcherModule {

    @Provides
    @IoDispatcher
    fun providesIoDispatcher(): CoroutineDispatcher = Dispatchers.IO
}

// 注入使用
@HiltViewModel
class MyViewModel @Inject constructor(
    private val repository: UserRepository,
    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
) : ViewModel()

// 事件定义
sealed class AppEvent {
    data class ShowToast(val message: String) : AppEvent()
    data class Navigate(val route: String) : AppEvent()
    object Logout : AppEvent()
}

// EventBus — 基于 SharedFlow 的全局事件总线
// SharedFlow 不会重放历史事件，适合一次性事件（Toast、导航等）
@Singleton
class AppEventBus @Inject constructor() {
    private val _events = MutableSharedFlow<AppEvent>() // 无 replay，新订阅者不会收到旧事件
    val events = _events.asSharedFlow()

    suspend fun emit(event: AppEvent) {
        _events.emit(event)
    }
}

// 收集事件
@Composable
fun EventHandler(eventBus: AppEventBus = hiltViewModel()) {
    val context = LocalContext.current

    LaunchedEffect(Unit) {
        eventBus.events.collect { event ->
            when (event) {
                is AppEvent.ShowToast -> {
                    Toast.makeText(context, event.message, Toast.LENGTH_SHORT).show()
                }
                // 处理其他事件
            }
        }
    }
}