ViewModel:
负责为关联UI(activity/fragment)进行数据管理,业务逻辑处理。不直接持有view引用,不对UI进行访问调用操作
对外通过暴露Livedata方式响应处理结果
LiveData:
可感知组件生命周期、被观察的数据源,在数据发生改变时进行通知提醒
ViewModel处理数据后使用LiveData通知到observer数据已变更,
Lifecycle:
对象or组件生命周期状态定义接口,实现子类LifecycleRegistry。包含LifeCycleOwer和LifecycleObserver,分别是生命周期所有者和生命周期感知者
ViewModel创建存储流程:
组件与Livedata,Observer,Lifecycle关联流程:
Livedata observe()
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {//已销毁组件不作处理
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
return;
}
//包装observer包含组件生命状态监控的LifecycleBoundObserver
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing != null && !existing.isAttachedTo(owner)) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
//添加到Lifecyvle内保存
owner.getLifecycle().addObserver(wrapper);
}
LiveData 添加LifecycleBoundObserver到LifecycleRegister内处理:
public class LifecycleRegistry extends Lifecycle {
@Override
public void addObserver(LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//通过ObserverWithState包装LifecycleObserver内部进行操作管理
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
......
}
......
ObserverWithState负责分发组件状态变化,与关联的LifecycleBoundObserver状态关联
static class ObserverWithState {
State mState;
GenericLifecycleObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.getCallback(observer);
mState = initialState;
}
//分发组件状态到所关联Observer
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
看一下 LifecycleBoundObserver内部代码
class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
@NonNull final LifecycleOwner mOwner;
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) {
super(observer);
mOwner = owner;
}
......
//当组件周期状态变化时,处理关联的Observer
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
removeObserver(mObserver);
return;
}
activeStateChanged(shouldBeActive());
}
......
}
private abstract class ObserverWrapper {
final Observer<T> mObserver;
boolean mActive;
int mLastVersion = START_VERSION;
ObserverWrapper(Observer<T> observer) {
mObserver = observer;
}
......
void activeStateChanged(boolean newActive) {//组件周期变化时判断是否需要重新分发value data
if (newActive == mActive) {//observe与组件状态一致时不处理,
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
mActive = newActive;
boolean wasInactive = LiveData.this.mActiveCount == 0;
LiveData.this.mActiveCount += mActive ? 1 : -1;
if (wasInactive && mActive) {//LiveData从非活跃到激活状态
onActive();
}
if (LiveData.this.mActiveCount == 0 && !mActive) {//LiveData从激活到非活跃状态
onInactive();
}
if (mActive) {//组件激活状态时重新分发上一次存留数据
dispatchingValue(this);
}
}
}
LifeData分发数据处理:
setValue修改数据
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");//主线程调用
mVersion++;//每次修改,版本号+1
mData = value;
dispatchingValue(null);//数据分发处理
}
private void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
if (initiator != null) {//分发给指定observer
considerNotify(initiator);
initiator = null;
} else {//分发Observer列表内所有注册对象
for (Iterator<Map.Entry<Observer<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;
}
// 是否为active状态
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}//observer dataVersion大于等于LiveData dataVersion不予处理
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
//通知Observer change数据
observer.mObserver.onChanged((T) mData);
}
整体大致流程: