两种给给LiveData添加请求状态回调的方法

最近开发中一直在使用ViewModel +LiveData 配合来实现MVVM,LiveData 这个东西确实挺好用的.但是存在一个问题,看代码:

//表示一个从后台拿到的User类型来显示到UI
val  user  = MultableLiveData<User>()

user 从后台来,就可能出错,单单用一个user 是无法通知到UI层出错的,这时候需要一个变量来标记出错的内容,同时如果UI层想要在开始请求时显示加载动画,就又需要一个 变量来标记开始,这时候代码就变成了这样

val  user  = MultableLiveData<User>()
var startState = MultableLiveData<Any>()
var errorState = MultableLiveData<Throwable>()

然后在请求网络的回调中,开始请求数据就这样(为了容易理解,网络请求返回采用rxjava 的subscribe 的回调格式,所以就不要好奇为什么不直接在view 层订阅 网络请求返回的Observable 了,因为没有使用rxjava):

requetUser().subscribe{
      onStart = {startState.value = Any()},
      onNext = {user.postValue(it)},
      onError = {user.postValue(it)}
}

然后在 view层分别观察这三个状态:

user.observe(this,Observer{ 回显...})
startState.observe(this,Observer{开始加载动画....})
errorState.observe(this,Observer{提示出错....})

这样清晰是挺清晰的.如果一个页面对应一个接口还好.但是如果是很复杂的页面对应多个接口,而且每个接口的开始动画和出错提示是分开的,那么我们就需要给每一个接口创建三个liveData,这样就会有非常多的livedata字段..为了少写几个字段,我就想能不能制造一个天生的有开始状态,出错状态,正常状态且具有livedata特性的东东呢,这样一个接口对应一个livedata 字段就好了,于是我就做了如下的封装

import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.Observer

class StateLiveData<T>(value: T?) {
    private val liveData = MutableLiveData<T>(value)
    private var onStart = MutableLiveData<Any>()
    private var onError = MutableLiveData<Throwable>()

    var value: T?
        get() {
            return liveData.value
        }
        set(value) {
            liveData.value = value
        }

    fun postValue(value: T?) {
        liveData.postValue(value)
    }


    fun onStart() {
        onStart.value = Any()
    }

    fun postOnStart() {
        onStart.postValue(Any())
    }

    fun onError(throwable: Throwable) {
        onError.postValue(throwable)
    }


    fun observe(
        lifecycleOwner: LifecycleOwner,
        onNext: OnNext<T>? = null,
        onStart: OnStart? = null,
        onError: OnError? = null
    ) {
        liveData.observe(lifecycleOwner, Observer {
            onNext?.invoke(it)

        })
        this.onError.observe(lifecycleOwner, Observer {
            onError?.invoke(it)
        })

        this.onStart.observe(lifecycleOwner, Observer {
            onStart?.invoke()
        })

    }

}

typealias  OnError = (Throwable) -> Unit

typealias OnStart = () -> Unit

typealias OnNext<T> = (T) -> Unit

每一个 StateLiveData都具有 开始状态,出错状态,正常状态 这时候我们就可以这样写了

val user = StateLiveData<User>()

然后这样处理网络请求回调:

requestUser().subscribe(
onStart = { user.onStart() },
onNext = {user.value = it},
onError = {user.onError(it) }
)

然后在view层这样观测user

user.observe(this,
onNext = {回显结果...},
onStart = {加载动画..},
onError = {错误提示...}
)

这样就用构造了一个具备状态的livedata了..能够少写很多字段了哈哈哈...
这个是简单的封装,如果有需要ObserverForever 方法,对着这些方法进行一一封装就好了

另外想少写字段的方法还有一种就是构建一个带数据状态的UiState

sealed class UiState() {
    class Start : UiState()
    class Error(val throwable: Throwable) : UiState()
    class Next<T>(val t: T) : UiState()
}

然后User字段这样声明

val user = MultableLiveData<UiState<User>>

然后这样观测请求结果

requestUser().subscribe(
onStart = {user.postValue(UiState.Start()) },
onNext = { user.postValue(UiState.Next(it))},
onError = {user.postValue(UiState.Error(it) }
)

在view层这样观察

 user.observe(this, Observer{ 
            when(it){
                is UiState.Start -> {加载动画...}
                is UiState.Error ->{错误提示...}
                is UiState.Next<*> -> {
                    it.t as User {回显结果...}
                }
            }
        })