看下使用好不好,没想到真是简洁的离谱啊,好了,我们从这里开始观察
val getTopTabLiveData by lazy { MutableLiveData<Boolean>() }
...
viewModel.getTopTabLiveData.observe(this){
// do some thing
}
observer()做了什么
将指定事件跟生命周期绑定
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
// 判断生命周期为销毁,则忽略
if (owner.getLifecycle().getCurrentState() == DESTROYED) return;
// 实例一个新的生命周期绑定观察者
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
// 判断是否之前已经赋值,来防止有煞笔重复调用,专治代码水土不服
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
// 注意看LifecycleBoundObserver.isAttachedTo()
// 如果之前已经赋值但又有煞笔在不同LifecycleOwner(生命周期管理者)中调用,话不多说,直接给crash,google就是牛逼
if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
// 如果已经赋值且上面煞笔处理没问题,就不再做处理了
if (existing != null) {
return;
}
// 看到了没有,核心啊,精髓啊,给当前LifecycleOwner加入Observer(观察者),在生命周期各个阶段响应事件
owner.getLifecycle().addObserver(wrapper);
}
看看mObservers.putIfAbsent:
public V putIfAbsent(@NonNull K key, @NonNull V v) {
Entry<K, V> entry = get(key);
// 如果给定的值已经存在,则返回值
if (entry != null) return entry.mValue;
// 否则存进去,真似厉害啊
put(key, v);
// 返回代表之前不存在的null值,这就是理解有木有
return null;
}
看看LifecycleBoundObserver :
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@NonNull
// 生命周期管理者
final LifecycleOwner mOwner;
// 看到这里没,直接赋值了,有什么好说的
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
super(observer);
mOwner = owner;
}
// 有点意思,这里判断是否处在活跃状态,就可以他妈的做正确的生命周期回调响应
@Override
boolean shouldBeActive() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
// 若生命周期已为销毁状态, 则移除 observer, 避免内存泄露
if (currentState == DESTROYED) {
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
// 判断两个生命周期管理者是否为同一个
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
好了到这LiveData.observe()已经观察完毕了,到看看LiveData.postValue()了, 别说,google还是有点讲究的,看看这个官方提示:
liveData.postValue("a");// 异步传值
liveData.setValue("b"); //同步传值
// 结果: 值“b”将首先设置,然后主线程将用值“a”覆盖它。
// 如果在此主线程执行postValue()之前多次调用postValue(),则只会调度最后一个值
postValue()做了什么
他妈的,还能做什么,就是传值啊,这还用说的文章到此结束了,不会吧,不会吧,异步传值得注意处理多线程下的共享变量问题呢
...
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
// 判断之前是否已经赋值过了
postTask = mPendingData == NOT_SET;
// 给mPendingData赋值
mPendingData = value;
}
// 看到没有,他妈的,之前已经赋值就return了,好气哦,干嘛这样呢
// 嘿,看下mPostValueRunnable没有,他就是防止煞笔多线程下多次赋相同值做的
if (!postTask) return;
// 把传值线程放到主线程执行
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
...
// 未赋值状态
static final Object NOT_SET = new Object()
// 默认就是未赋值状态
volatile Object mPendingData = NOT_SET
// 传值线程
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings("unchecked")
@Override
public void run() {
// 看到没有,真正传值都是通过newValue来传的好不好
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
// 嘿嘿,这里回归默认未赋值状态了
mPendingData = NOT_SET;
}
// 最终还是调到setValue啊,果然啊,条条道路通setValue啊
setValue((T) newValue);
}
};
setValue()
有什么好说的,其他的一枪秒了,我才是传输数据的核心代码好不好,屁,dispatchingValue才是
// 设置传输数据。 如果有活跃的ObserverWrapper(观察者),值将被分发给他们。
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
@SuppressWarnings("WeakerAccess") /* synthetic access */
void dispatchingValue(@Nullable ObserverWrapper initiator) {
// 判断事件分发是否已经在执行,是则打断
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
// 事件分发开始
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
if (initiator != null) {
considerNotify(initiator);
initiator = null;
} else {
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) break;
}
}
} while (mDispatchInvalidated);
// 事件分发结束
mDispatchingValue = false;
}
...
private void considerNotify(ObserverWrapper observer) {
// 如果生命周期管理者已经销毁,则忽略
if (!observer.mActive) {
return;
}
// 在分发之前检查下最先状态,如果不在活跃阶段,则不改变状态
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
// 判断version , 因为从上面来看,每次赋值version都会变得
// 他妈的的,这样就不会陷入多次分发,保证只取最先的传值
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
// 执行每个生命周期管理者的观察者的事件分发
observer.mObserver.onChanged((T) mData);
}
get到没有?