使用:
public class LiveDataActivity extends AppCompatActivity {
MutableLiveData liveData= new MutableLiveData<String>();
void liveDataTest(){
// 任何线程都可以发送数据
liveData.postValue("postValue");
// 只有主线程可以发送数据
// liveData.setValue("setValue")
}
void observeTest(){
//订阅
liveData.observe(this, new Observer<String>() {
@Override
public void onChanged(String data) {
//收到数据data
}
});
//可以有多个订阅
liveData.observe(this, new Observer<String>() {
@Override
public void onChanged(String data) {
//收到数据data
}
});
}
}
阶段一:
postValue:
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
- 将用户发送的数据给到一个 mPendingData 的变量;
- 切换到主线程
- 执行了一个mPostValueRunnable;
mPostValueRunnable:
volatile Object mPendingData = NOT_SET;
private int mVersion;
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings("unchecked")
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;
}
setValue((T) newValue);
}
};
- 在mPostValueRunnable中将mPendingData给到了新的临时变量newValue;
- mPendingData的值置为空;
- 调用setValue(newValue);
setValue:
private volatile Object mData;
private int mVersion;
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
- 将数据版本mVersion +1;
- 将发送的数据给到了mData;
- 调用分发数据dispatchingValue;
看到这里发现,数据其实最后存到了mData中;若想发送订阅消息,肯定得添加订阅者;
阶段二:
添加订阅者,observe():
//用户使用:
//liveData.observe(this@LiveDataActivity,{
//
//})
private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
new SafeIterableMap<>();
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
//如果被观察者的生命周期是DESTROYED,就不添加订阅者
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
...
owner.getLifecycle().addObserver(wrapper);
}
- 将有生命周期的Activity和订阅者Observer传了进来;
- 判断Activity的生命周期;
- 将Activity和Observer封装为一个LifecycleBoundObserver对象;
- 将LifecycleBoundObserver放到了mObservers这个Map集合中;
- map的key为观察者,value为封装了activity和观察者Observer的对象LifecycleBoundObserver;
LifecycleBoundObserver及它的父类ObserverWrapper:
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@NonNull
final LifecycleOwner mOwner;
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
super(observer);
mOwner = owner;
}
...
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
if (currentState == DESTROYED) {
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
...
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
//ObserverWrapper
private abstract class ObserverWrapper {
//传进来的观察者放这里了
final Observer<? super T> mObserver;
boolean mActive;
int mLastVersion = START_VERSION;
ObserverWrapper(Observer<? super T> observer) {
mObserver = observer;
}
...
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;
}
mActive = newActive;
changeActiveCounter(mActive ? 1 : -1);
if (mActive) {
dispatchingValue(this);
}
}
}
- 将有生命周期的Activity给到了LifecycleBoundObserver的mOwner;
- 将观察者给到了LifecycleBoundObserver的父类ObserverWrapper的mObserver;
- 其实LifecycleBoundObserver就可以获取到Activity和mObserver;
- 上一步,看到将封装后的LifecycleBoundObserver放到了mObservers这个map中;
- map的key为观察者,value为封装了activity和观察者Observer的对象LifecycleBoundObserver;
阶段三:
分发:
在阶段一setValue()时,调用了dispatchingValue(null);
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.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
observer.mObserver.onChanged((T) mData);
}
- 当为null时,走到了for循环
- 循环取出map中的value,而value就是LifecycleBoundObserver;
- LifecycleBoundObserver中有mObserver,mObserver就是用户传的观察者;
- mObserver.onChanged((T) mData);
- 完成了“主动”分发;
未完--------下篇有时间将分析生命周期改变时分发、粘性事件、LiveDataBus原理;