MyMutableLiveData 继承 MutableLiveData
class MyMutableLiveData : MutableLiveData<Any>() {
open inner class WrapperObserver(private val stick : Boolean = false, //是否是粘性观察,是的话会收到订阅之前的消息
private val observer : Observer<Any>) : Observer<Any> {
/**
* 是否是新加入的观察者
*/
private val isFirstObserver : AtomicBoolean = AtomicBoolean(true)
override fun onChanged(t : Any) {
if(mLock.get() && !stick) {
//当前是锁定状态非粘性观察者,且是新的观察者,设置成不是新观察者。如果不是新观察者,则通知
if(isFirstObserver.compareAndSet(false, false)) {
observer.onChanged(t)
}
} else {
//非锁定状态或粘性观察者,修改为不是新观察者,接收通知
isFirstObserver.set(false)
observer.onChanged(t)
}
}
}
//消息通知锁
private val mLock : AtomicBoolean = AtomicBoolean(true)
override fun observe(owner : LifecycleOwner, observer : Observer<Any>) {
observe(owner, false, observer)
}
fun observe(owner : LifecycleOwner, stick : Boolean = false, observer : Observer<Any>) {
//新来的观察者锁住消息通知
mLock.set(true)
super.observe(owner, WrapperObserver(stick, observer))
}
override fun observeForever(observer : Observer<Any>) {
observeForever(false, observer)
}
fun observeForever(stick : Boolean = false, observer : Observer<Any>) {
//新来的观察者锁住消息通知
mLock.set(true)
super.observeForever(WrapperObserver(stick, observer))
}
@MainThread
override fun setValue(t : Any?) {
mLock.set(false)
super.setValue(t)
}
override fun postValue(value : Any?) {
mLock.set(false)
super.postValue(value)
}
/**
* Used for cases where T is Void, to make calls cleaner.
*/
@MainThread
fun call() {
value = null
}
}
LiveDataBus
object LiveDataBus {
private val liveDataMap by lazy {
hashMapOf<String, MutableLiveData<Any>>()
}
fun register(key:String): MyMutableLiveData {
if (!liveDataMap.containsKey(key)){
liveDataMap[key] = MyMutableLiveData()
}
return liveDataMap[key] as MyMutableLiveData
}
}
使用
LiveDataBus.register(TAG).postValue(position)
LiveDataBus.register(TAG).observe(owner){
}