Android MVI 模式的封装实现(基于kotlin FLow 和 ViewModel)

Posted 2023-02-21 匆忙拥挤repeat

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Android MVI 模式的封装实现(基于kotlin FLow 和 ViewModel)相关的知识，希望对你有一定的参考价值。

文章目录

MVI 的简单理解
定义 Intent 和 State
定义BaseViewModel
ViewModel实现类
- 与View强相关的 VM实现
- 一个通用的VM实现
View 层实现
BaseMviActivity、BaseMviFragment、BaseMviUi 实现
一些注意点
参考：
后记

MVI 的简单理解

MVI 是 Model-View-Intent 的缩写，它也是一种响应式 + 流式处理思想的架构。

MVI 的 Model 代表一种可订阅的状态模型的概念，添加了 Intent 概念来代表用户行为，采用单向数据流来控制数据流动和各层依赖关系。

MVI 中的单项数据流工作流程如下：

用户操作、数据初始化操作等，以 Intent 的形式通知 Model
Model 基于 Intent 更新 State
View 接收到 State 变化刷新 UI

在ViewModel中，持有并公开 Intent、State。数据Model被State依赖，进行流转。因此，VM负责的是，Intent、State的状态存储，数据层的中继。
具体表现为：

View层 (Activity/Fragment) ，通过 VM(ViewModel) 发送 I(Intent)；
VM 内，根据收到的 Intent，经过一定的处理变换，然后发送 UI-State；
View 层观察到这个 UI-State，展现相应的VIew 或其它 UI 操作。
View 层，发送 Intent，观察 UI-State，持有 VM的引用。
VM 应该属于 M 层(个人认为，有些人认为，这就是一个中间层，怎么理解都行)。M层就包括了数据源(数据模型)、业务数据处理、UI-State和Intent的模型定义。

本文参考了一些文章，在实践中，抽象封装了 IUiIntent 和 IUiState 基类；抽象了BaseMviViewModel和BaseMviUi基类等

定义 Intent 和 State

定义基类接口，和通用的实现的类
Intent：

/**
 * desc:    UI 事件意图，或 数据获取的意图
 * author:  stone
 * email:   aa86799@163.com
 * time:    2022/11/24 12:19
 */
interface IUiIntent

class InitDataIntent: IUiIntent

State：

interface IUiState

/**
 * 正在加载
 */
class LoadingState(val isShow: Boolean) : IUiState

/**
 * 加载失败
 */
class LoadErrorState(val error: String) : IUiState
// 加载成功
class LoadSuccessState<T>(val subState: IUiState, val data: T?) : IUiState
// 分页加载成功
class LoadSuccessMultiDataState<T>(val subState: IUiState, val data: List<T>?, val page: Int) : IUiState

说明：

LoadSuccessState(subState, …)，用subState来区分具体的 UI-State

定义BaseViewModel

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch

/**
 * desc:
 * author:  stone
 * email:   aa86799@163.com
 * time:    2022/11/24 13:41
 */
abstract class BaseMviViewModel : ViewModel() 

    /**
     * UI 状态
     */
    private val _uiStateFlow by lazy  MutableStateFlow(initUiState()) 
    val uiStateFlow: StateFlow<IUiState> = _uiStateFlow.asStateFlow()

    /**
     * 事件意图, 点击事件、刷新等都是Intent。表示用户的主动操作
     */
    private val _userIntent = MutableSharedFlow<IUiIntent>()
    protected val userIntent = _userIntent.asSharedFlow()
	
	init 
        viewModelScope.launch 
            userIntent.distinctUntilChanged().collect 
                handleUserIntent(it)
            
        
    

    abstract fun handleUserIntent(intent: IUiIntent)

    protected open fun initUiState(): IUiState 
        return LoadingState(true)
    

    protected fun sendUiState(block: IUiState.() -> IUiState) 
        _uiStateFlow.update  block(it)  // 更新值
//        _uiStateFlow.update  _uiStateFlow.value.block()  // 作用和上一句一样的
    

    /**
     * 分发意图
     *
     * 仅此一个 公开函数。供 V 调用
     */
    fun dispatch(intent: IUiIntent) 
        viewModelScope.launch 
            _userIntent.emit(intent)
        
    

    /**
     * @param showLoading 是否展示Loading
     * @param request 请求数据
     * @param successCallback 请求成功
     * @param failCallback 请求失败，处理异常逻辑
     */
    protected fun <T : Any> requestDataWithFlow(
        showLoading: Boolean = true,
        request: Flow<BaseResult<T?>>,
        successCallback: (T?) -> Unit,
        failCallback: suspend (String) -> Unit =  errMsg ->  //默认异常处理，子类可以进行覆写
            sendUiState  LoadErrorState(errMsg) 
        
    ) 
        viewModelScope.launch 
            request
            	.onStart 
	                if (showLoading) 
	                    sendUiState  LoadingState(true) 
	                
            	
                .flowOn(Dispatchers.Default)
                .catch  // 代码运行异常
                    failCallback(it.message ?: "发生了错误")
                    sendUiState  LoadingState(false) 
                
                .onCompletion 
                    sendUiState  LoadingState(false) 
                
                .flowOn(Dispatchers.Main)
                .collect 
                    if (it.status == NET_STATUS_SUCCESS) 
                        successCallback(it.data)
                     else 
                        failCallback(it.statusText ?: "服务响应发生了错误")

对 BaseVM 的一些说明：

定义了通用的 UI状态，_uiStateFlow 供VM内部私有使用。uiStateFlow是不可变类型，供外部V层使用。
_userIntent 也是VM内部私有使用，userIntent仅由BaseVM的子类使用。
MutableStateFlow 初始时，必须有一个初始值。提供一个可用子类重写的 initUiState()来设置初始State。
提供一个由子类必须重写的处理 Intent 的抽象函数 handleUserIntent()
提供一个由子类调用的 sendUiState(state) 来发送 UIState
提供一个公开的 dispatch(intent) 来分发 Intent
提供一个由子类调用的 requestDataWithFlow()。其中参数 request，是一个Flow<BaseResult<T?>>类型。BaseResult<T?>就是个通用响应类型 + 实际响应类型的组合。然后在 github 找到一个 FlowCallAdapter，将 retrofit 的网络请求响应转为 Flow。

ViewModel实现类

与View强相关的 VM实现

/**
 * desc:
 * author:  stone
 * email:   aa86799@163.com
 * time:    2022/11/23 14:31
 */
class TableViewModel(
    private val datasource: TableDatasource = TableDatasource()
) : BaseMviViewModel() 

	override fun handleUserIntent(intent: IUiIntent) 
        when (intent) 
            is InitDataIntent -> initLoad()
            is TableIntent.SaveIntent -> saveData(intent.data)
        
    

    private fun initLoad() 
        viewModelScope.launch 
            // 检查类型
            requestDataWithFlow(request = datasource.queryCheckType(), successCallback = 
                sendUiState  LoadSuccessState(TableUiState.CheckTypeState, it) 
            )

            // 单位类别
            requestDataWithFlow(request = datasource.queryUnitType(), successCallback = 
                sendUiState  LoadSuccessState(TableUiState.UnitTypeState(), it) 
            )

            // 处理措施
            requestDataWithFlow(request = datasource.queryHandle(), successCallback = 
                sendUiState  LoadSuccessState(TableUiState.HandleState(), it) 
            )
        
    

    private fun saveData(body: PostBody) 
        viewModelScope.launch 
            // 添加检查信息
            requestDataWithFlow(request = datasource.addCheckInfo(body), successCallback = 
                sendUiState  LoadSuccessState(TableUiState.AddSuccessState(), it?.messeage) 
            )
        
    



sealed class TableUiState 

    object CheckTypeState : IUiState // 检查表类型 需要请求网络，并在UI 上展示

    class UnitTypeState : IUiState // 单位类型 需要请求网络，并在UI 上展示

    class HandleState : IUiState // 处理措施 需要请求网络，并在UI 上展示

    class AddSuccessState : IUiState // 保存成功 需要在UI 上展示



sealed class TableIntent 

    class SaveIntent(val data: PostBody) : IUiIntent // 用户点击保存

一个通用的VM实现

/**
 * desc:    提供 区域查询。 这是一个可供其它 V 层，所使用的 VM。
 * author:  stone
 * email:   aa86799@163.com
 * time:    2022/11/23 14:31
 */
class AreaViewModel(private val areaDatasource: AreaDatasource = AreaDatasource()) : BaseMviViewModel() 

    private val _areaIntent = MutableSharedFlow<IUiIntent>()
    protected val areaIntent = _areaIntent.asSharedFlow()

    override fun handleUserIntent(intent: IUiIntent) 
        when (intent) 
            is LoadAddressIntent -> loadArea()
        
    

    private fun loadArea() 
        viewModelScope.launch 
            // 区域查询
            requestDataWithFlow(request = areaDatasource.queryArea(), successCallback = 
                sendUiState  LoadSuccessState(AreaState(), it) 
            )
        
    


class LoadAddressIntent : IUiIntent

class AreaState : IUiState // 区域 需要请求网络，并在UI 上展示

说明：

关于 datasource 数据源，内部就提供一些返回 Flow<BaseResult<T?>> 类型的函数

View 层实现


class MyActivity : BaseMviActivity() 
	private val mViewModel by viewModels<TableViewModel>()
    private val mAreaViewModel by viewModels<AreaViewModel>()
	
	fun oncreate() 
		...
		initObserver()
		initBiz()
		initListener()
	

	private fun initObserver() 
        stateFlowHandle(mViewModel.uiStateFlow) 
        	if (it !is LoadSuccessState<*>) return@stateFlowHandle
            when (it.subState) 
                is TableUiState.CheckTypeState -> showCheckTypeState(it.data as? CheckTypeBean)
                is TableUiState.UnitTypeState -> showUnitTypeState(it.data as UnitTypeBean?)
                is TableUiState.HandleState -> showHandleState(it.data as HandleBean?)
                is TableUiState.AddSuccessState -> showToast(it.data?.toString() ?: "操作成功")
            
        
        stateFlowHandle(mAreaViewModel.uiStateFlow) 
        	if (it !is LoadSuccessState<*>) return@stateFlowHandle
            when (it.subState) 
                is AreaState -> showAreaState(it.data as ArrayList<AreaBean>?)
            
        
     
	
	private fun initBiz() 
        mViewModel.dispatch(InitDataIntent())
        mAreaViewModel.dispatch(LoadAddressIntent())
    
	
	private initListener() 
		btn_save.setOnClickListener 
			val body = PostBody()
			mViewModel.dispatch(TableIntent.SaveIntent(body))
		
	
    
	private fun showCheckTypeState(data: CheckTypeBean?)  // 检查表类型 
	private fun showUnitTypeState(data: UnitTypeBean?)  // 单位类型 
	private fun showHandleState(data: HandleBean?)  // 处理措施 
	private fun showAreaState(data: ArrayList<AreaBean>?)  // 区域信息 
	private fun showToast(msg: String)

说明

观察UIState，处理相应数据，展现相应的view
初始通过不同的VM，发送相应的Intent，去获取数据；VM中正常处理数据后，会发送相应的UIState。不同的 VM 分别观察各自关联的 UIState。
按钮点击事件中，发送一个 SaveIntent，由 TableVM 内部调用保存数据的 save()，调用正常，再发送 AddSuccessState

BaseMviActivity、BaseMviFragment、BaseMviUi 实现

I. BaseMviActivity

abstract class BaseMviActivity: AppCompatActivity() 
	...
	private val mBaseMviUi by lazy  BaseMviUi(this, this) 
	
	 /**
     * 显示用户等待框
     * @param msg 提示信息
     */
    protected fun showLoadingDialog(msg: String = "请等待...") 
        mBaseMviUi.showLoadingDialog(msg)
    

    /**
     * 隐藏等待框
     */
    protected fun dismissLoadingDialog() 
        mBaseMviUi.dismissLoadingDialog()
    

    protected fun showToast(msg: String) 
        mBaseMviUi.showToast(msg)
    

    protected fun showToastLong(msg: String) 
        mBaseMviUi.showToastLong(msg)
    

    protected fun stateFlowHandle(flow: Flow<IUiState>, block: (state: IUiState) -> Unit) 
        mBaseMviUi.stateFlowHandle(flow, block)

II. BaseMviFragment

/**
 * desc:
 * author:  stone
 * email:   aa86799@163.com
 * time:    2022/12/4 11:46
 */
abstract class BaseMviFragment: Fragment() 

	private val mBaseMviUi by lazy  BaseMviUi(requireContext(), this) 
	
	/**
	 * 显示用户等待框
	 * @param msg 提示信息
	 */
    protected fun showLoadingDialog(msg: String = "请等待...") 
        mBaseMviUi.showLoadingDialog(msg)
    

    /**
     * 隐藏等待框
     */
    protected fun dismissLoadingDialog() 
        mBaseMviUi.dismissLoadingDialog()
    

    protected fun showToast(msg: String) 
        mBaseMviUi.showToast(msg)
    

    protected fun showToastLong(msg: String) 
        mBaseMviUi.showToastLong(msg)
    

    protected fun stateFlowHandle(flow: Flow<IUiState>, block: (state: IUiState) -> Unit) 
        mBaseMviUi.stateFlowHandle(flow, block)

III. BaseMviUi

/**
 * desc:
 * author:  stone
 * email:   aa86799@163.com
 * time:    2022/12/4 11:24
 */
class BaseMviUi(private val context: Context, private val lifecycleOwner: LifecycleOwner) 

    private var mLoading by Weak<LoadingDialog>()

    fun stateFlowHandle(flow: Flow<IUiState>, block: (state: IUiState) -> Unit) 
        lifecycleOwner.lifecycleScope.launchWhenCreated  // 开启新的协程
        	// repeatOnLifecycle 是一个挂起函数；低于目标生命周期状态会取消协程，内部由suspendCancellableCoroutine实现
            // STATE.CREATED 低于 STARTED 状态；若因某种原因，界面重建，重走 Activity#onCreate 生命周期，就会取消该协程，直到 STARTED 状态之后，被调用者重新触发
            lifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) 
                flow.collect 
                    when (it) 
                        is LoadingState ->  if (it.isShow) showLoadingDialog() else dismissLoadingDialog() 
                        is LoadErrorState -> showToast(it.error)
                        else -> block(it)
                    
                
            
        
    

    /**
     * 显示用户等待框
     * @param msg 提示信息
     */
    fun showLoadingDialog(msg: String = "请等待...") 
        if (mLoading?.isShowing == true) 
            mLoading?.setLoadingMsg(msg)
         else 
            mLoading = LoadingDialog(context)
            mLoading?.setLoadingMsg(msg)
            mLoading?.show()
        
    

    /**
     * 隐藏等待框
     */
    fun dismissLoadingDialog() 
        if (mLoading?.isShowing == true) 
            mLoading?.dismiss()
        
    

    fun showToast(msg: String) 
        ToastUtil.showToast(msg)
    

    fun showToastLong(msg: String) 
        ToastUtil.showToastLong(msg)

一些注意点

非通用的 UiState和 UiIntent，并且有多个时，可以定义在一个 sealed class 中。
对于 _userIntent: MutableSharedFlow<IUiIntent>() 这个类型，使用了 distinctUntilChanged()，防止重复数据。若一个State定义成object XxState ，那若连续发送多个 XxState，则只会观察处理第一个。后续的受distinctUntilChanged()影响，不会重复处理。比如，一个数据刷新的动作，就最好不要定义成 object 单例。

参考：

Android Jetpack系列之MVI架构

后记

2022-12-25 更新：
实际场景中，有时候可能要单独处理错误，而不是简单的统一 toast 错误信息。
为此，改写了 BaseMviUi#stateFlowHandle()，增加一个参数 handleError: Boolean

 fun stateFlowHandle(flow: Flow<IUiState>, handleError: Boolean, block: (state: IUiState) -> Unit) 
     lifecycleOwner.lifecycleScope.launchWhenCreated  // 开启新的协程
         // repeatOnLifecycle 是一个挂起函数；低于目标生命周期状态会取消协程，内部由suspendCancellableCoroutine实现
         // STATE.CREATED 低于 STARTED 状态；若因某种原因，界面重建，重走 Activity#onCreate 生命周期，就会取消该协程，直到 STARTED 状态之以上是关于Android MVI 模式的封装实现(基于kotlin FLow 和 ViewModel)的主要内容，如果未能解决你的问题，请参考以下文章 
 Android MVI 模式的简单实现(基于kotlin FLow 和 ViewModel)
 MVI 架构封装：快速优雅地实现网络请求
 MVI 架构封装：快速优雅地实现网络请求
 Android真的推荐用MVI模式？MVI和MVVM有啥区别？
 Android真的推荐用MVI模式？MVI和MVVM有什么区别？
 关于Android架构：MVI + LiveData + ViewModel | ProAndroidDev