开源 | 如何写一个好用的 JetPack Compose 状态页组件

   val state = mutableStateOf (Loading)
   when(state){
     Loading -> {}
      Error -> {}
      Content -> {
       //加载错误了, 更改状态即可
       state = Error
     }
      xxx
 }

@Composable
fun Test() {
    var state = remember {
        mutableStateOf(StateEnum.LOADING)
    }
    when (state.value) {
        StateEnum.LOADING -> {
        }
        StateEnum.CONTENT -> {
            // 展示成功
        }
        StateEnum.ERROR -> {
            // 展示错误
        }
    }
    // 获取结果
    val data = getData()
    if (data is Success) {
        state.value = StateEnum.CONTENT
    } else if (data is Error) {
        state.value = StateEnum.ERROR
    }
}

enum class StateEnum {
    LOADING,
    EMPTY,
    ERROR,
    CONTENT
}

interface IState {
    val state: StateEnum
    var enableNullRetry: Boolean
    var enableErrorRetry: Boolean
    /** 显示加载成功
     * @param [tag] 可以传递任意数据,会在回调处收到
     * */
    fun showContent(tag: Any? = null)
    ...
}

object StateX {
    /** 默认点击防抖时间 */
    var defaultClickTime = 600L
    /** 空数据重试开关 */
    var enableNullRetry = true
    /** 异常重试开关 */
    var enableErrorRetry = true
}

class StateComposeConfig {
    ...
    internal var emptyComponent: stateComponentBlock = {}
    ...
    internal var onContent: stateBlock? = null
    ...
    fun onContent(block: stateBlock) {
        this.onContent = block
    }
    ...
    fun emptyComponent(component: stateComponentBlock) {
        this.emptyComponent = component
    }
}
/** 内部使用的StateCompose配置 */
internal val composeConfig by lazy(LazyThreadSafetyMode.PUBLICATION) {
    StateComposeConfig()
}
/** 配置state-compose的配置 */
fun StateX.composeConfig(config: StateComposeConfig.() -> Unit) {
    composeConfig.apply(config)
}

interface IStateCompose : IState {
    /** 当前state附带的value */
    val tag: Any?
    /** 错误时的回调 */
    fun onError(block: stateBlock)
    ...
}

class StateComposeImpl constructor(stateEnum: StateEnum = StateEnum.CONTENT) : IStateCompose {
    // 这里是一个类型别名,只是为了省去方法参数中多余的写法，
    // 坏处就是可能会降低可读性，具体根据自身而定
    // internal typealias stateBlock = (tag: Any?) -> Unit
    // 刷新时的回调，可以在这里回调里做数据加载，加载完成后调用showContent即可。
    private var onRefresh: stateBlock? = null
    // 异常回调,默认使用的全局错误回调
    private var onError: stateBlock? = composeConfig.onError
    ...
    /** 当前内部可变状态 */
    private var _internalState by mutableStateOf(StateEnum.CONTENT)
    /** 当前状态内部缓存的tag */
    private var _internalTag: Any?
    override val state: StateEnum
        get() = _internalState
    override val tag: Any?
        get() = _internalTag
    override fun onError(block: stateBlock) {
        this.onError = block
    }
    ...
    override fun showError(tag: Any?) {
        onError?.invoke(tag)
        newState(StateEnum.ERROR, tag)
    }
    ...
    private fun newState(newState: StateEnum, tag: Any?) {
        _internalState = newState
        _internalTag = tag
    }
}

@Composable
fun StateCompose(
    stateControl: IStateCompose,
    loadingComponentBlock: stateComponentBlock 
      = composeConfig.loadingComponent,
    ...
    contentComponentBlock: stateComponentBlock,
) {
    when (stateControl.state) {
        StateEnum.LOADING ->
            loadingComponentBlock(stateControl, stateControl.tag)
        StateEnum.CONTENT ->
            contentComponentBlock(stateControl, stateControl.tag)
        StateEnum.ERROR ->
            if (stateControl.enableErrorRetry) {
            StateBoxComposeClick(block = {
                stateControl.showLoading(null)
            }) {
                errorComponentBlock(stateControl, stateControl.tag)
            }
        } else errorComponentBlock(stateControl, stateControl.tag)
        ...
    }
}

/** 在ViewModel中生成一个 IStateCompose
 * @param stateEnum 默认的状态
 * */
inline fun ViewModel.lazyState(
    stateEnum: StateEnum = StateEnum.CONTENT,
    crossinline obj: StateComposeImpl.() -> Unit = {}
): Lazy<IStateCompose> = lazy(LazyThreadSafetyMode.PUBLICATION) {
    StateComposeImpl(stateEnum).apply(obj)
}
/**
 * 当state在ViewModel中缓存时,可以使用这个方法便于对state做初始化相关
 * 这样的好处就是可以将唯一初始化的东西放在这个 [block] 回调中,而不用担心重复初始化
 * @param composeState 要记住的状态State
 * */
@Composable
inline fun rememberState(
    composeState: IStateCompose,
    crossinline block: IStateCompose.() -> Unit = {}
): IStateCompose = currentComposer.cache(false) {
    composeState.apply(block)
}
/**
 * 记录state的状态,直接生成一个新的IStateCompose
 * @param stateEnum 默认的状态
 * @param block 对于IStateCompose的回调使用
 * */
@Composable
inline fun rememberState(
    stateEnum: StateEnum = StateEnum.CONTENT,
    crossinline block: IStateCompose.() -> Unit = {}
): IStateCompose = currentComposer.cache(false) {
    StateComposeImpl(stateEnum).apply(block)
}