Android aac 组件是我们工程中最常见也是使用最多, 至于使用大家都应该都很熟练，并且也能很好理解单独个组件的作用和使用场景! 下面我主要分析对应的源码和流程，为什么能跟我们Activity和Fragment融和在一起。从源码的角度真正理解每个步骤,方便开发效率和遇到的坑快速排查~`
Lifecycle源码分析
Lifecycle基本使用很简单，接下来就是对Lifecycle原理和源码的解析了。Lifecycle 是具有生命周期感知能力的组件，我们能在 Activity 或者 Fragment 的生命周期发生变化的时候得到通知.
1.Lifecycle的生命周期状态事件和状态
- Lifecycle使用两个枚举来跟踪其关联组件的生命周期状态，这两个枚举分别是Event和State。 State指的是Lifecycle的生命周期所处的状态。 Event代表Lifecycle生命周期对应的事件，这些事件会映射到Activity和Fragment中的回调事件中。
- Lifecycle是一个抽象类，其内部不仅包括了添加和移除观察者的方法，还包括了此前说到的Event和State枚举。可以看到Event中的事件和Activity的生命周期几乎是对应的，除了ON_ANY，它可用于匹配所有事件。
public abstract class Lifecycle {
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
@MainThread
@NonNull
public abstract State getCurrentState();
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY;
}
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
2.Lifecycle如何观察Activity和Fragment的生命周期?
Activity和Fragment已经默认实现了LifecycleOwner接口，LifecycleOwner可以理解为被观察者，那么Lifecycle是如何观察Activity和Fragment的生命周期的呢？
我们知道AppCompatActivity继承->FragmentActivity继承->ComponentActivity,所以我们这边看下ComponentActivity.java
@RestrictTo(LIBRARY_GROUP)
public class ComponentActivity extends Activity implements LifecycleOwner {
private SimpleArrayMap<Class<? extends ExtraData>, ExtraData> mExtraDataMap =
new SimpleArrayMap<>();
//1
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@RestrictTo(LIBRARY_GROUP)
public void putExtraData(ExtraData extraData) {
mExtraDataMap.put(extraData.getClass(), extraData);
}
@Override
@SuppressWarnings("RestrictedApi")
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);//2
}
@CallSuper
@Override
protected void onSaveInstanceState(Bundle outState) {
mLifecycleRegistry.markState(Lifecycle.State.CREATED);//3
super.onSaveInstanceState(outState);
}
@RestrictTo(LIBRARY_GROUP)
public <T extends ExtraData> T getExtraData(Class<T> extraDataClass) {
return (T) mExtraDataMap.get(extraDataClass);
}
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;//4
}
@RestrictTo(LIBRARY_GROUP)
public static class ExtraData {
}
}
注释1处创建了LifecycleRegistry，它是Lifecycle的实现类。注释4处实现了LifecycleOwner接口定义的getLifecycle方法，返回了LifecycleRegistry。在注释3处，将Lifecycle的State设置为CREATED。正常来说应该在ComponentActivity的各个生命周期方法中改变Lifecycle的State，显然在ComponentActivity中没有做这些，而是将这个任务交给了ReportFragment，注释2处的将ComponentActivity注入到ReportFragment中。
ReportFragment.java
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public class ReportFragment extends Fragment {
private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
+ ".LifecycleDispatcher.report_fragment_tag";
public static void injectIfNeededIn(Activity activity) {
if (Build.VERSION.SDK_INT >= 29) { //1
LifecycleCallbacks.registerIn(activity);
}
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
manager.executePendingTransactions();
}
}
static ReportFragment get(Activity activity) {
return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
REPORT_FRAGMENT_TAG);
}
...
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatchCreate(mProcessListener);
dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
super.onStart();
dispatchStart(mProcessListener);
dispatch(Lifecycle.Event.ON_START);//2
}
@Override
public void onResume() {
super.onResume();
dispatchResume(mProcessListener);
dispatch(Lifecycle.Event.ON_RESUME);
}
...
private void dispatch(Lifecycle.Event event) {
Activity activity = getActivity();
if (activity instanceof LifecycleRegistryOwner) {//3
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
if (activity instanceof LifecycleOwner) {//4
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
...
}
注释1处会判断会做个版本号的区分，首先进行了版本区分：在API 29及以上 直接使用activity的registerActivityLifecycleCallbacks 直接注册了生命周期回调.然后给当前activity添加了ReportFragment，注意这个fragment是没有布局的.无论LifecycleCallbacks、还是fragment的生命周期方法 最后都走到了 dispatch(Activity activity, Lifecycle.Event event)方法
ReportFragment的onStart方法中会调用注释2处的dispatch方法。在dispatch方法的注释3处，判断Activity是否实现了LifecycleRegistryOwner接口，LifecycleRegistryOwner继承了LifecycleOwner接口，这两个接口不同的是，LifecycleRegistryOwner定义的getLifecycle方法返回的是LifecycleRegistry类型，而LifecycleOwner定义的getLifecycle方法返回的是Lifecycle类型。注释4处如果Activity实现了LifecycleOwner接口，会调用LifecycleRegistry的handleLifecycleEvent方法。
LifecycleRegistry.java
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
enforceMainThreadIfNeeded("handleLifecycleEvent");
moveToState(event.getTargetState());
}
看下event.getTaargetState()方法
public State getTargetState() {
switch (this) {
case ON_CREATE:
case ON_STOP:
return State.CREATED;
case ON_START:
case ON_PAUSE:
return State.STARTED;
case ON_RESUME:
return State.RESUMED;
case ON_DESTROY:
return State.DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException(this + " has no target state");
}
这个和文章开头给出的State与Event关系的时序图对照看会比较好理解，比如当前执行了ON_CREATE事件或者ON_STOP事件，那么状态就会处于CREATED。回到handleLifecycleEvent方法，其内部还会调用moveToState方法。
private void moveToState(State next) {
if (mState == next) {
return;
}
mState = next;
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
return;
}
mHandlingEvent = true;
sync();
mHandlingEvent = false;
}
如果当前所处的状态和即将要处于的状态一样就不做任何操作，再看看sync()方法
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
+ "garbage collected. It is too late to change lifecycle state.");
}
while (!isSynced()) { //1 意思是所有观察者都同步完了
mNewEventOccurred = false;
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner); // 2 向前
}
Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner); //3 向后
}
}
mNewEventOccurred = false;
}
private boolean isSynced() {
if (mObserverMap.size() == 0) {
return true;
}
//最老的和最新的观察者的状态一致，都是ower的当前状态，说明已经同步完了
State eldestObserverState = mObserverMap.eldest().getValue().mState;
State newestObserverState = mObserverMap.newest().getValue().mState;
return eldestObserverState == newestObserverState && mState == newestObserverState;
}
private void forwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
final Event event = Event.upFrom(observer.mState); //1
if (event == null) {
throw new IllegalStateException("no event up from " + observer.mState);
}
observer.dispatchEvent(lifecycleOwner, event); //2
popParentState();
}
}
}
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
Event event = Event.downFrom(observer.mState); //1
if (event == null) {
throw new IllegalStateException("no event down from " + observer.mState);
}
pushParentState(event.getTargetState());
observer.dispatchEvent(lifecycleOwner, event);//2
popParentState();
}
}
}
循环条件是!isSynced()，若最老的和最新的观察者的状态一致，且都是ower的当前状态，说明已经同步完了。
没有同步完就进入循环体：
mState比最老观察者状态小，走backwardPass(lifecycleOwner)：从新到老分发，循环使用downEvent()和observer.dispatchEvent()，连续分发事件；
mState比最新观察者状态大，走forwardPass(lifecycleOwner)：从老到新分发，循环使用upEvent()和observer.dispatchEvent()，连续分发事件。
接着ObserverWithState类型的observer就获取到了事件，即observer.dispatchEvent(lifecycleOwner, event)，下面来看看它是如何让加了对应注解的方法执行的。
3.Lifecycle观察到生命周期后,事件回调方法执行
LifecycleRegistry.java-> ObserverWithState
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
//1
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = event.getTargetState();
mState = min(mState, newState);
//2
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
Lifecycling.java
static LifecycleEventObserver lifecycleEventObserver(Object object) {
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
if (isLifecycleEventObserver && isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
(LifecycleEventObserver) object);
}
if (isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}
if (isLifecycleEventObserver) {
return (LifecycleEventObserver) object;
}
final Class<?> klass = object.getClass();
int type = getObserverConstructorType(klass);
if (type == GENERATED_CALLBACK) {
List<Constructor<? extends GeneratedAdapter>> constructors =
sClassToAdapters.get(klass);
if (constructors.size() == 1) {
GeneratedAdapter generatedAdapter = createGeneratedAdapter(
constructors.get(0), object);
return new SingleGeneratedAdapterObserver(generatedAdapter);
}
GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
for (int i = 0; i < constructors.size(); i++) {
adapters[i] = createGeneratedAdapter(constructors.get(i), object);
}
return new CompositeGeneratedAdaptersObserver(adapters);
}
return new ReflectiveGenericLifecycleObserver(object);
}
mLifecycleObserver是使用Lifecycling. lifecycleEventObserver(observer)获取的LifecycleEventObserver是接口，继承自LifecycleObserver
ReflectiveGenericLifecycleObserver和CompositeGeneratedAdaptersObserver是LifecycleEventObserver的实现类，这里主要查看ReflectiveGenericLifecycleObserver的onStateChanged方法是如何实现的。
ReflectiveGenericLifecycleObserver.java
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
private final Object mWrapped;
private final CallbackInfo mInfo;
ReflectiveGenericLifecycleObserver(Object wrapped) {
mWrapped = wrapped;
//1存放了event与加了注解方法的信息
mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
//2执行对应event的观察者的方法
mInfo.invokeCallbacks(source, event, mWrapped);
}
}
注释2处会调用CallbackInfo的invokeCallbacks方法，在讲这个方法前，需要先了解CallbackInfo是怎么创建的，我们关注注释1处
ClassesInfoCache.java
CallbackInfo getInfo(Class<?> klass) {
CallbackInfo existing = mCallbackMap.get(klass);
if (existing != null) {
return existing;
}
existing = createInfo(klass, null);
return existing;
}
private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
Class<?> superclass = klass.getSuperclass();
Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
if (superclass != null) {
CallbackInfo superInfo = getInfo(superclass);
if (superInfo != null) {
handlerToEvent.putAll(superInfo.mHandlerToEvent);
}
}
Class<?>[] interfaces = klass.getInterfaces();
for (Class<?> intrfc : interfaces) {
for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo(
intrfc).mHandlerToEvent.entrySet()) {
verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
}
}
Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
boolean hasLifecycleMethods = false;
for (Method method : methods) {
//遍历方法 找到注解OnLifecycleEvent
OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
if (annotation == null) {
continue; //没有注解OnLifecycleEvent 就return
}
hasLifecycleMethods = true;//有注解OnLifecycleEvent
Class<?>[] params = method.getParameterTypes();
int callType = CALL_TYPE_NO_ARG;
if (params.length > 0) {//有参数
callType = CALL_TYPE_PROVIDER;
if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
throw new IllegalArgumentException(
"invalid parameter type. Must be one and instanceof LifecycleOwner");
}
}
Lifecycle.Event event = annotation.value();
if (params.length > 1) {
callType = CALL_TYPE_PROVIDER_WITH_EVENT;
if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
throw new IllegalArgumentException(
"invalid parameter type. second arg must be an event");
}
if (event != Lifecycle.Event.ON_ANY) {
throw new IllegalArgumentException(
"Second arg is supported only for ON_ANY value");
}
}
if (params.length > 2) { //参数不能超过两个
throw new IllegalArgumentException("cannot have more than 2 params");
}
MethodReference methodReference = new MethodReference(callType, method);
//校验方法并加入到map handlerToEvent 中
verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
}
//获取的 所有注解生命周期的方法handlerToEvent，构造回调信息实例
CallbackInfo info = new CallbackInfo(handlerToEvent);
//把当前观察者的回调信息存到ClassesInfoCache中
mCallbackMap.put(klass, info);
//记录 观察者是否有注解了生命周期的方法
mHasLifecycleMethods.put(klass, hasLifecycleMethods);
return info;
}
- 如果不存在当前观察者回调信息，就使用createInfo()方法收集创建
- 先反射获取观察者的方法，遍历方法 找到注解了OnLifecycleEvent的方法，先对方法的参数进行了校验。
- 第一个参数必须是LifecycleOwner；第二个参数必须是Event；有两个参数 注解值只能是ON_ANY；参数不能超过两个
- 校验方法并加入到map，key是方法，value是Event。map handlerToEvent是所有的注解了生命周期的方法。
- 遍历完，然后用 handlerToEvent来构造 当前观察者回调信息CallbackInfo，存到ClassesInfoCache的mCallbackMap中，并记录 观察者是否有注解了生命周期的方法。
最后看CallBackInfo里面的invokeCallBacks
CallbackInfo.java
static class CallbackInfo {
final Map<Lifecycle.Event, List<MethodReference>> mEventToHandlers;
final Map<MethodReference, Lifecycle.Event> mHandlerToEvent;
CallbackInfo(Map<MethodReference, Lifecycle.Event> handlerToEvent) {
mHandlerToEvent = handlerToEvent;
mEventToHandlers = new HashMap<>();
//1
for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {
Lifecycle.Event event = entry.getValue();
List<MethodReference> methodReferences = mEventToHandlers.get(event);
if (methodReferences == null) {
methodReferences = new ArrayList<>();
mEventToHandlers.put(event, methodReferences);
}
methodReferences.add(entry.getKey());
}
}
@SuppressWarnings("ConstantConditions")
void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
target);
}
private static void invokeMethodsForEvent(List<MethodReference> handlers,
LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
if (handlers != null) {
for (int i = handlers.size() - 1; i >= 0; i--) {
handlers.get(i).invokeCallback(source, event, mWrapped);
}
}
}
}
MethodReference(int callType, Method method) {
mCallType = callType;
mMethod = method;
mMethod.setAccessible(true);
}
void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
//noinspection TryWithIdenticalCatches
try {
switch (mCallType) {
case CALL_TYPE_NO_ARG:
mMethod.invoke(target);
break;
case CALL_TYPE_PROVIDER:
mMethod.invoke(target, source);
break;
case CALL_TYPE_PROVIDER_WITH_EVENT:
mMethod.invoke(target, source, event);
break;
}
} catch (InvocationTargetException e) {
throw new RuntimeException("Failed to call observer method", e.getCause());
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
注释1处的循环的意义在于将handlerToEvent进行数据类型转换，转化为一个HashMap，key的值为事件，value的值为MethodReference。注释2处的invokeMethodsForEvent方法会传入mEventToHandlers.get(event)，也就是事件对应的MethodReference的集合。invokeMethodsForEvent方法中会遍历MethodReference的集合，调用MethodReference的invokeCallback方法。
LiveData 源码分析
LiveData原理是观察者模式，下面就先从LiveData.observe()方法看起
1.LiveData 添加观察者
LiveData.java
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// ignore
// LifecycleOwner是DESTROYED状态，直接忽略
return;
}
//1 使用LifecycleOwner、observer 组装成LifecycleBoundObserver，添加到mObservers中
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
//2
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;
}
//3
owner.getLifecycle().addObserver(wrapper);
}
下面就先从LiveData.observe()方法看起：
(1)首先是判断LifecycleOwner是DESTROYED状态，就直接忽略，不能添加。接着使用LifecycleOwner、observer 组装成LifecycleBoundObserver包装实例wrapper，使用putIfAbsent方法observer-wrapper作为key-value添加到观察者列表mObservers中。（putIfAbsent方法和put方法有区别，如果传入key对应的value已经存在，就返回存在的value，不进行替换。如果不存在，就添加key和value，返回null）
(2)然后对添加的结果进行判断，如果mObservers中已经存在此observer key，但value中的owner不是传进来的owner，就会报错“不能添加同一个observer却是不同LifecycleOwner”。如果是相同的owner，就直接returne。
(3)最后如果等于null，在注释3处会将LifecycleBoundObserver添加到Lifecycle中完成注册，这样当我们调用LiveData的observe方法时，实际上是LiveData内部完成了Lifecycle的观察者的添加，这样LiveData自然也就有了观察组件生命周期变化的能力。
2.LiveData的observe方法回调
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();
if (currentState == DESTROYED) { //1
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
activeStateChanged(shouldBeActive()); //2
currentState = mOwner.getLifecycle().getCurrentState();
}
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
}
LifecycleBoundObserver是LiveData的内部类，是对原始Observer的包装，把LifecycleOwner和Observer绑定在一起。当LifecycleOwner处于活跃状态，就称 LifecycleBoundObserver是活跃的观察者。它实现自接口LifecycleEventObserver，实现了onStateChanged方法。onStateChanged是生命周期状态变化的回调。
在LifecycleOwner生命周期状态变化时,注释1处判断如果是DESTROYED状态，则移除观察者。LiveData自动移除观察者特点就来源于此。 如果不是DESTROYED状态，注释2处将调用父类ObserverWrapper的activeStateChanged()方法处理 这个生命周期状态变化，shouldBeActive()的值作为参数，至少是STARTED状态为true，即活跃状态为true。
private abstract class ObserverWrapper {
final Observer<? super T> mObserver;
boolean mActive;
int mLastVersion = START_VERSION;
ObserverWrapper(Observer<? super T> observer) {
mObserver = observer;
}
abstract boolean shouldBeActive();
boolean isAttachedTo(LifecycleOwner owner) {
return false;
}
void detachObserver() {
}
void activeStateChanged(boolean newActive) {
if (newActive == mActive) {
return;//活跃状态 未发生变化时，不会处理。
}
mActive = newActive;
changeActiveCounter(mActive ? 1 : -1);
if (mActive) {//1
dispatchingValue(this);//观察者变为活跃，就进行数据分发
}
}
}
注释1处，如果是Active状态，会调用dispatchingValue方法，并将自身传进去
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
//1
mDispatchInvalidated = true;//如果当前正在分发，则分发无效，return
return;
}
mDispatchingValue = true;//标记正在分发
do {
mDispatchInvalidated = false;
if (initiator != null) {
//observerWrapper不为空，使用considerNotify()通知真正的观察者
considerNotify(initiator);
initiator = null;
} else {//observerWrapper为空，遍历通知所有的观察者
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
mDispatchingValue用于标记当前是否处于分发状态中，如果处于该状态，则在注释1处标记当前分发无效，直接return。一路调用过来，ObserverWrapper是不为null的，ObserverWrapper为null的情况在setValue和postValue会讲到，无论是那种情况，都会调用considerNotify方法，代码如下所示。
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) { //1
return;
}
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false); //2
return;
}
if (observer.mLastVersion >= mVersion) {
return;
}
observer.mLastVersion = mVersion;
//回调真正的mObserver的onChanged方法
observer.mObserver.onChanged((T) mData);//3
}
considerNotify方法中做了多次的判断，注释1处，如果ObserverWrapper的mActive值不为true，就直接return。注释2处，如果当前observer对应组件的状态不是Active，就会再次调用activeStateChanged方法，并传入false，其方法内部会再次判断是否执行onActive方法和onInactive方法回调。如果判断条件都满足会调用Observer的onChanged方法，这个方法正是使用LiveData的observe方法的回调。
3.LiveData的postValue/setValue方法分析(数据更新)
当调用MutableLiveData的observe方法后，还需要通过postValue/setValue方法来更新数据。
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable); //1
}
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings("unchecked")
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;
}
setValue((T) newValue); //2
}
};
@MainThread //3
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
postValue/setValue方法都定义在LiveData中，根据注释1和注释2处，可以发现postValue方法实际上就是将setValue方法切换到主线程调用。注释3处说明setValue方法是运行在主线程中的，其内部调用了dispatchingValue方法,此时传了null进去。也就是dispatchingValue方法的参数ObserverWrapper为null的情况第二节上面说过此方法.
从这里我们可以知道，无论是LiveData的observe方法还是LiveData的postValue/setValue方法都会调用dispatchingValue方法。
4.LiveData的Transformations原理
最后来看下Transformations的map原理，如何实现数据修改的。switchMap类似的。
Transformations.java
@MainThread
@NonNull
public static <X, Y> LiveData<Y> map(
@NonNull LiveData<X> source,
@NonNull final Function<X, Y> mapFunction) {
final MediatorLiveData<Y> result = new MediatorLiveData<>();
result.addSource(source, new Observer<X>() {
@Override
public void onChanged(@Nullable X x) {
result.setValue(mapFunction.apply(x));
}
});
return result;
}
new了一个MediatorLiveData实例，然后将 传入的livaData、new的Observer实例作为参数 调用addSource方法
@MainThread
public <S> void addSource(@NonNull LiveData<S> source, @NonNull Observer<? super S> onChanged) {
Source<S> e = new Source<>(source, onChanged);
Source<?> existing = mSources.putIfAbsent(source, e); //1
if (existing != null && existing.mObserver != onChanged) {
throw new IllegalArgumentException(
"This source was already added with the different observer");
}
if (existing != null) {
return;
}
if (hasActiveObservers()) {
//MediatorLiveData有活跃观察者，就plug
e.plug(); //2
}
}
注释1处将传进来的LiveData和onChanged封装到Source类中，注释2处调用了Source的plug方法：
private static class Source<V> implements Observer<V> {
final LiveData<V> mLiveData;
final Observer<? super V> mObserver;
int mVersion = START_VERSION;
Source(LiveData<V> liveData, final Observer<? super V> observer) {
mLiveData = liveData;
mObserver = observer;
}
void plug() {
mLiveData.observeForever(this); //1
}
void unplug() {
mLiveData.removeObserver(this);
}
@Override
public void onChanged(@Nullable V v) {
if (mVersion != mLiveData.getVersion()) {
mVersion = mLiveData.getVersion();
mObserver.onChanged(v); //2
}
}
}
注释2处可以看到，Transformations.map方法传入的Observer的回调在这里进行处理。注释1处，Source的plug方法会调用LiveData的observeForever方法，observeForever和observe又有啥区分呢?
@MainThread
public void observeForever(@NonNull Observer<? super T> observer) {
assertMainThread("observeForever");
AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer); //1
ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
if (existing instanceof LiveData.LifecycleBoundObserver) {
throw new IllegalArgumentException("Cannot add the same observer"
+ " with different lifecycles");
}
if (existing != null) {
return;
}
wrapper.activeStateChanged(true);
}
注释1处用AlwaysActiveObserver来对Observer进行包装，紧接着调用AlwaysActiveObserver的activeStateChanged方法，其内部实际调用的是ObserverWrapper的activeStateChanged方法这个上面已经说过。来看AlwaysActiveObserver类是如何定义的。
private class AlwaysActiveObserver extends ObserverWrapper {
AlwaysActiveObserver(Observer<? super T> observer) {
super(observer);
}
@Override
boolean shouldBeActive() { //1
return true;
}
}
AlwaysActiveObserver是LiveData的内部类，它继承自ObserverWrapper，AlwaysActiveObserver是LiveData的内部类和ObserverWrapper的区别就是，它是永远处于Active状态的。
这里为啥使用observeForever方法呢，这是因为源LiveData在外部使用时不会调用observer方法添加观察者，这里永久观察是为了在源LiveData数据变化时及时回调到 mObserver.onChanged(v)方法，也就是Transformations map方法中的onChanged方法。 而在e.plug()前是有判断 MediatorLiveData 确认有活跃观察者的。
最后map方法中的onChanged方法中有调用MediatorLiveData实例的setValue(mapFunction.apply(x)); 并返回实例。而mapFunction.apply()就是map方法传入的修改逻辑Function实例。
ViewModel 源码分析
首先ViewModel有2个特点:
(1)生命周期比Activity长
(2)不持有UI层引用
看到在因屏幕旋转而重新创建Activity后，ViewModel对象依然会保留。 只有Activity真正Finish的时ViewModel才会被清除。
也就是说，因系统配置变更Activity销毁重建，ViewModel对象会保留并关联到新的Activity。而Activity的正常销毁（系统不会重建Activity）时，ViewModel对象是会清除的。
1.ViewModel的创建
先来看下ViewModel类
public abstract class ViewModel {
// Can't use ConcurrentHashMap, because it can lose values on old apis (see b/37042460)
@Nullable
private final Map<String, Object> mBagOfTags = new HashMap<>();
private volatile boolean mCleared = false;
@SuppressWarnings("WeakerAccess")
protected void onCleared() {
}
@MainThread
final void clear() {
mCleared = true;
if (mBagOfTags != null) {
synchronized (mBagOfTags) {
for (Object value : mBagOfTags.values()) {
// see comment for the similar call in setTagIfAbsent
closeWithRuntimeException(value);
}
}
}
onCleared();
}
@SuppressWarnings("unchecked")
<T> T setTagIfAbsent(String key, T newValue) {
T previous;
synchronized (mBagOfTags) {
previous = (T) mBagOfTags.get(key);
if (previous == null) {
mBagOfTags.put(key, newValue);
}
}
T result = previous == null ? newValue : previous;
if (mCleared) {
closeWithRuntimeException(result);
}
return result;
}
@SuppressWarnings({"TypeParameterUnusedInFormals", "unchecked"})
<T> T getTag(String key) {
if (mBagOfTags == null) {
return null;
}
synchronized (mBagOfTags) {
return (T) mBagOfTags.get(key);
}
}
private static void closeWithRuntimeException(Object obj) {
if (obj instanceof Closeable) {
try {
((Closeable) obj).close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
ViewModel类 是抽象类，内部没有啥逻辑，有个clear()方法会在ViewModel将被清除时调用。
然后ViewModel实例的获取是通过ViewModelProvider类，见名知意，即ViewModel提供者，来看下它的构造方法
public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
: NewInstanceFactory.getInstance());
}
public ViewModelProvider(@NonNull ViewModelStoreOwner owner, @NonNull Factory factory) {
this(owner.getViewModelStore(), factory);//1
}
//1
public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
mFactory = factory;
mViewModelStore = store;
}
ViewModelProivder 有很多构造方法，不过最终都调到同一个地方,这个方法中,ViewModelStoreOwner——ViewModel存储器拥有者；ViewModelStore——ViewModel存储器，用来存ViewModel的地方；Factory——就是我们预期的工厂类创建ViewModel实例的工厂。
注释1处可以看到ViewModelStoreOwner获取ViewModelStore的代码
public interface ViewModelStoreOwner {
//获取ViewModelStore，即获取ViewModel存储器
ViewModelStore getViewModelStore();
}
ViewModelStoreOwner是一个接口,那么哪些类是这个接口的实现类呢？如你所料，我们熟悉的ComponentActivity 和 Fragment 都实现了这个接口
我们再来看看ViewModelStore这个类如何存储ViewModel、以及ViewModel实例如何获取的
ViewModelStore.java
public class ViewModelStore {
private final HashMap<String, ViewModel> mMap = new HashMap<>();
final void put(String key, ViewModel viewModel) {
ViewModel oldViewModel = mMap.put(key, viewModel);
if (oldViewModel != null) {
oldViewModel.onCleared();
}
}
final ViewModel get(String key) {
return mMap.get(key);
}
Set<String> keys() {
return new HashSet<>(mMap.keySet());
}
public final void clear() {
for (ViewModel vm : mMap.values()) {
vm.clear();
}
mMap.clear();
}
}
ViewModelStore代码很简单，比如同一个 Activity 的onCreate() 方法可能会多次回调，我们在 onCreate()方法初始化ViewModel，但是不可能每次 onCreate() 回调都会创建新的 ViewModel 对象，所以需要有一个东西用来存储的我们之前创建过的 ViewModel，这个就是ViewModelStore 的作用
我们再来看一下 get 方法，因为真正获取 ViewModel 对象就是通过这个方法的。
public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
String canonicalName = modelClass.getCanonicalName();
if (canonicalName == null) {
throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
}
return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
}
@MainThread
public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
ViewModel viewModel = mViewModelStore.get(key);
if (modelClass.isInstance(viewModel)) {
if (mFactory instanceof OnRequeryFactory) {
((OnRequeryFactory) mFactory).onRequery(viewModel);
}
return (T) viewModel;
} else {
//noinspection StatementWithEmptyBody
if (viewModel != null) {
// TODO: log a warning.
}
}
if (mFactory instanceof KeyedFactory) {
viewModel = ((KeyedFactory) mFactory).create(key, modelClass);
} else {
viewModel = mFactory.create(modelClass);
}
mViewModelStore.put(key, viewModel);
return (T) viewModel;
}
这个get方法总的来说逻辑清晰,主要分2步:
- 先通过 key 从 ViewModelStore (缓存)获取 ViewModel 对象，如果缓存中存在，直接返回。Activity 经过横屏重建之后，返回 ViewMode 的对象就是这里返回。
- 如果缓存不存在，那么通过 Factory 创建一个对象，然后放在缓存中，最后返回。
2.ViewModel 如何保证生命周期长
我们都知道 ViewModel 是从一个 ViewModelStore 缓存里面的获取，我们看了 ViewModelStore 的源码，发现它的内部并没有通过静态缓存实现。那么它是怎么实现Activity 在 onDestroy 之后(重建)，还继续保留已有的对象呢？这个我们可以从 ComponentActivity 的 getViewModelStore 方法去寻找答案
ComponentActivity.java
@NonNull
@Override
public ViewModelStore getViewModelStore() {
if (getApplication() == null) {
throw new IllegalStateException("Your activity is not yet attached to the "
+ "Application instance. You can't request ViewModel before onCreate call.");
}
ensureViewModelStore();
return mViewModelStore;
}
@SuppressWarnings("WeakerAccess") /* synthetic access */
void ensureViewModelStore() {
if (mViewModelStore == null) {
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null) {//1
// Restore the ViewModelStore from NonConfigurationInstances
mViewModelStore = nc.viewModelStore;
}
if (mViewModelStore == null) {//2
mViewModelStore = new ViewModelStore();
}
}
}
public final Object onRetainNonConfigurationInstance() {
// Maintain backward compatibility.
Object custom = onRetainCustomNonConfigurationInstance();
ViewModelStore viewModelStore = mViewModelStore;
if (viewModelStore == null) {
//3
NonConfigurationInstances nc =
(NonConfigurationInstances) getLastNonConfigurationInstance();
if (nc != null) {
viewModelStore = nc.viewModelStore;
}
}
if (viewModelStore == null && custom == null) {
return null;
}
NonConfigurationInstances nci = new NonConfigurationInstances();
nci.custom = custom;
nci.viewModelStore = viewModelStore; //4
return nci;
}
static final class NonConfigurationInstances {
Object custom;
ViewModelStore viewModelStore;
}
注释1处先尝试 从NonConfigurationInstance从获取 ViewModelStore实例，如果NonConfigurationInstance不存在，就new一个mViewModelStore。 并且还注意到，在onRetainNonConfigurationInstance()方法中 会把mViewModelStore赋值给NonConfigurationInstances
如果不存在就会new个NonConfigurationInstances,然后赋值
NonConfigurationInstances 其实就是一个 Wrapper，用来包装一下因为不受配置更改影响的数据，包括我们非常熟悉的 Fragment，比如说，一个 Activity 上面有一个 Fragment，旋转了屏幕导致 Activity 重新创建，此时Activity 跟之前的不是同一个对象，但是 Fragment 却是同一个,这就是通过 NonConfigurationInstances 实现的。也就是说在 getViewModelStore 方法里面，从 NonConfigurationInstances 获取的 ViewModelStore 对象其实就是上一个 Activity的
接着我们来看 NonConfigurationInstances 为啥能保证 Activity 重建前后，ViewModeStore 是同一个对象呢？我们直接从ActivityThread的performDestroyActivity方法去寻找答案。我们知道，performDestroyActivity 方法最后会回调到 Activity 的 onDestroy 方法，我们可以通过这个方法可以找到ActivtyThread 在 Activity onDestroy 之前做了保存操作。
ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing,
int configChanges, boolean getNonConfigInstance, String reason) {
// ······
performPauseActivityIfNeeded(r, "destroy");
// Activity的onStop方法回调
if (!r.stopped) {
callActivityOnStop(r, false /* saveState */, "destroy");
}
if (getNonConfigInstance) {
// ······
// retainNonConfigurationInstances方法的作用就是创建一个对象
r.lastNonConfigurationInstances= r.activity.retainNonConfigurationInstances();
// ······
}
// ······
// Activity的onDestroy方法回调
mInstrumentation.callActivityOnDestroy(r.activity);
// ······
return r;
}
从上面的代码中看出，在 Activity 的 onStop 和 onDestroy之间，会回调 retainNonConfigurationInstances方法，同时记录到ActivityClientRecord中去。这里retainNonConfigurationInstances 方法返回的对象就是我们之前看到的 NonConfigurationInstances 对象。那么又在哪里恢复已保存的 NonConfigurationInstances 对象呢？这个可以从 performLaunchActivity 方法找到答案。performLaunchActivity 方法的作用就是启动一个 Activity，Activity 重建肯定会调用这个方法。在performLaunchActivity方法里面，调用了Activity的attach方法，在这个方法，Google将已有的NonConfigurationInstances 赋值给了新的 Activity 对象。
Activity.java
final void attach(Context context, ActivityThread aThread,
Instrumentation instr, IBinder token, int ident,
Application application, Intent intent, ActivityInfo info,
CharSequence title, Activity parent, String id,
NonConfigurationInstances lastNonConfigurationInstances,
Configuration config, String referrer, IVoiceInteractor voiceInteractor,
Window window, ActivityConfigCallback activityConfigCallback, IBinder assistToken) {
//....
mLastNonConfigurationInstances = lastNonConfigurationInstances;
//....
}
我们回过头来看ComponentActivity里面的onRetainNonConfigurationInstance的getLastNonConfigurationInstance其实调用的是父类Activity的getLastNonConfigurationInstance()
Activity.java
public Object getLastNonConfigurationInstance() {
return mLastNonConfigurationInstances != null
? mLastNonConfigurationInstances.activity : null;//1
}
static final class NonConfigurationInstances {
Object activity;
HashMap<String, Object> children;
FragmentManagerNonConfig fragments;
ArrayMap<String, LoaderManager> loaders;
VoiceInteractor voiceInteractor;
}
这里的lastNonConfigurationInstances是存在 ActivityClientRecord中的一个组件信息,ActivityThread 中的 ActivityClientRecord 是不受 activity 重建的影响，那么ActivityClientRecord中lastNonConfigurationInstances也不受影响，那么其中的Object activity也不受影响，那么ComponentActivity中的NonConfigurationInstances的viewModelStore不受影响，那么viewModel也就不受影响了。
到这里，我们就知道为啥 NonConfigurationInstances 能保证 ViewModelStore 在 Activity 重建前后是同一个对象，同时也知道为啥 ViewModel 的生命周期比 Activity 的生命周期要长一点。
3.ViewModel Activity被销毁后恢复数据
我们知道ViewModel 的 Saved State ,SaveStateHandle 目前在一个独立的模块中，我们都要额外添加依赖对应的类我们看看
我们来看看ComponentActivity
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
ContextAware,
LifecycleOwner,
ViewModelStoreOwner,
HasDefaultViewModelProviderFactory,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner,
ActivityResultRegistryOwner,
ActivityResultCaller {
//....
}
final SavedStateRegistryController mSavedStateRegistryController =
SavedStateRegistryController.create(this);
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
mSavedStateRegistryController.performRestore(savedInstanceState);
//...
}
@CallSuper
@Override
protected void onSaveInstanceState(@NonNull Bundle outState) {
Lifecycle lifecycle = getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);
}
super.onSaveInstanceState(outState);
mSavedStateRegistryController.performSave(outState);
//...
}
SavedStateRegistryController 主要分为两个过程：
在 onCreate 方法调用了 performRestore 方法，主要的作用是恢复已保存的数据。
在 onDestroy 方法调用了 performSave 方法，主要的作用保存数据。
因此，我们也分为两个过程来分析，分别从保存数据和恢复和数据来分析。
1.数据保存
mSavedStateRegistryController.performSave(outState)的方法会调到performSave
SavedStateRegistry.java
@MainThread
void performSave(@NonNull Bundle outBundle) {
Bundle components = new Bundle();
if (mRestoredState != null) {
components.putAll(mRestoredState);//1
}
for (Iterator<Map.Entry<String, SavedStateProvider>> it =
mComponents.iteratorWithAdditions(); it.hasNext(); ) {
Map.Entry<String, SavedStateProvider> entry1 = it.next();
//2
components.putBundle(entry1.getKey(), entry1.getValue().saveState());
}
//3
outBundle.putBundle(SAVED_COMPONENTS_KEY, components);
}
performSave 主要做了三件事:
- 如果 mRestoredState 不为空，表示之前恢复的数据还没有被消费完，需要将没有消费的数据再一次保存。
- 遍历所有注册的 SavedStateProvider，将所有的 SavedStateProvider 提供的数据保存起来。
- 最后保存Activity 的bundle里面, 注意：outBundle是Activity 需要保存的数据Bundle。
2.恢复数据
void performRestore(@NonNull Lifecycle lifecycle, @Nullable Bundle savedState) {
if (mRestored) {
throw new IllegalStateException("SavedStateRegistry was already restored.");
}
if (savedState != null) {
mRestoredState = savedState.getBundle(SAVED_COMPONENTS_KEY);
}
lifecycle.addObserver(new GenericLifecycleObserver() {
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_START) {
mAllowingSavingState = true;
} else if (event == Lifecycle.Event.ON_STOP) {
mAllowingSavingState = false;
}
}
});
mRestored = true;
}
SavedStateRegistry 的 performRestore 方法做的操作从 savedState 获取之前保存的数据，然后赋值给mRestoredState. 现在是不是还没看见mRestoredState做取数据的操作，搜索mRestoredState这个变量还在那用到了，其实在consumeRestoredStateForKey这个方法
public Bundle consumeRestoredStateForKey(@NonNull String key) {
if (!mRestored) {
throw new IllegalStateException("You can consumeRestoredStateForKey "
+ "only after super.onCreate of corresponding component");
}
if (mRestoredState != null) {
//1
Bundle result = mRestoredState.getBundle(key);
mRestoredState.remove(key);
if (mRestoredState.isEmpty()) {
mRestoredState = null;
}
return result;
}
return null;
}
注释1处consumeRestoredStateForKey 方法的作用就是通过 key 从 mRestoredState 获取保存的数据。
然后此方法被外部类调用获取对应的数据~
