使用篇
引入库：
implementation "androidx.lifecycle:lifecycle-runtime:2.0.0"implementation "androidx.lifecycle:lifecycle-extensions:2.0.0"implementation "androidx.lifecycle:lifecycle-common-java8:2.0.0"annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.0.0"
创建一个观察者对象，注意一定要实现LifecycleObserver接口：
package com.example.myapplicationimport android.util.Logimport androidx.lifecycle.Lifecycleimport androidx.lifecycle.LifecycleObserverimport androidx.lifecycle.OnLifecycleEventclass MyObserver : LifecycleObserver {@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)fun onCreate() {Log.w(TAG, "onCreate: ")}@OnLifecycleEvent(Lifecycle.Event.ON_START)fun onStart() {Log.w(TAG, "onStart: ")}@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)fun onResume() {Log.w(TAG, "onResume: ")}@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)fun onPause() {Log.w(TAG, "onPause: ")}@OnLifecycleEvent(Lifecycle.Event.ON_STOP)fun onStop() {Log.w(TAG, "onStop: ")}@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)fun onDestroy() {Log.w(TAG, "onDestroy: ")}companion object {private const val TAG = "MyObserver"}}
使用：
class MainActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_main)val observer = MyObserver()lifecycle.addObserver(observer)}}
这样运行以后就可以实时观察activity的生命周期了：
-08-13 19:06:03.025 8263-8263/com.example.lifecycletest W/MyObserver: onCreate: -08-13 19:06:03.028 8263-8263/com.example.lifecycletest W/MyObserver: onStart: -08-13 19:06:03.030 8263-8263/com.example.lifecycletest W/MyObserver: onResume: -08-13 19:06:38.333 8263-8263/com.example.lifecycletest W/MyObserver: onPause: -08-13 19:06:38.363 8263-8263/com.example.lifecycletest W/MyObserver: onStop: -08-13 19:06:44.911 8263-8263/com.example.lifecycletest W/MyObserver: onDestroy:
使用比较简单，下面来重点分析一下原理吧。
原理篇
整个使用过程非常简单，但是这个Jetpack给我们提供的生命周期监听框架的实现原理又是什么呢？今天就来一探究竟。
我们先来看使用代码：
class MainActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_main)val observer = MyObserver()//1lifecycle.addObserver(observer)//2}}
我们先关注注释2，lifecycle点进去看看：
@NonNull@Overridepublic Lifecycle getLifecycle() {return mLifecycleRegistry;}
这个方法在ComponentActivity里面，而：
MainActivity的父类是AppCompatActivityAppCompatActivity的父类是FragmentActivityFragmentActivity的父类是ComponentActivity
返回了一个mLifecycleRegistry，我们先来看下这个东西是啥？
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
继续看构造方法：
public LifecycleRegistry(@NonNull LifecycleOwner provider) {this(provider, true);}private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {mLifecycleOwner = new WeakReference<>(provider);//2mState = INITIALIZED;//1mEnforceMainThread = enforceMainThread;}
这里面注意一下注释1处，对后面分析代码有用。注释2处的mLifecycleOwner就是MainActivity本身的弱引用，也是通过构造传过来的。我们接着来分析LifecycleRegistry（翻译：生命周期登记处）的addObserver方法：
@Overridepublic void addObserver(@NonNull LifecycleObserver observer) {enforceMainThreadIfNeeded("addObserver");State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);//1ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);//2if (previous != null) {return;}LifecycleOwner lifecycleOwner = mLifecycleOwner.get();//3if (lifecycleOwner == null) {// it is null we should be destroyed. Fallback quicklyreturn;}boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;State targetState = calculateTargetState(observer);mAddingObserverCounter++;while ((pareTo(targetState) < 0&& mObserverMap.contains(observer))) {pushParentState(statefulObserver.mState);final Event event = Event.upFrom(statefulObserver.mState);if (event == null) {throw new IllegalStateException("no event up from " + statefulObserver.mState);}statefulObserver.dispatchEvent(lifecycleOwner, event);popParentState();// mState / subling may have been changed recalculatetargetState = calculateTargetState(observer);}if (!isReentrance) {// we do sync only on the top level.sync();}mAddingObserverCounter--;}
先来看注释1处：先把observer和mState封装成一个ObserverWithState对象：
static class ObserverWithState {State mState;LifecycleEventObserver mLifecycleObserver;ObserverWithState(LifecycleObserver observer, State initialState) {mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);//1mState = initialState;}void dispatchEvent(LifecycleOwner owner, Event event) {State newState = event.getTargetState();mState = min(mState, newState);mLifecycleObserver.onStateChanged(owner, event);mState = newState;}}
再进lifecycleEventobserver方法看下：
@NonNullstatic 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);//走这里，看下面分析}
我们来看：
public interface LifecycleEventObserver extends LifecycleObserver {void onStateChanged(@NonNull LifecycleOwner source,@NonNull Lifecycle.Event event);}interface FullLifecycleObserver extends LifecycleObserver {void onCreate(LifecycleOwner owner);void onStart(LifecycleOwner owner);void onResume(LifecycleOwner owner);void onPause(LifecycleOwner owner);void onStop(LifecycleOwner owner);void onDestroy(LifecycleOwner owner);}
我们知道MyObserver类实现了LifecycleObserver接口，而LifecycleEventObserver和FullLifecycleObserver是LifecycleObserver的子接口，所以MyObserver不属于这两个接口的任何一种。我们再来关注一下这行代码：
int type = getObserverConstructorType(klass);
再看下调用链：
private static int getObserverConstructorType(Class<?> klass) {Integer callbackCache = sCallbackCache.get(klass);if (callbackCache != null) {return callbackCache;}int type = resolveObserverCallbackType(klass);//一开始没有缓存，走这里sCallbackCache.put(klass, type);return type;}private static int resolveObserverCallbackType(Class<?> klass) {// anonymous class bug:35073837if (klass.getCanonicalName() == null) {return REFLECTIVE_CALLBACK;//走了这个}Constructor<? extends GeneratedAdapter> constructor = generatedConstructor(klass);if (constructor != null) {sClassToAdapters.put(klass, Collections.<Constructor<? extends GeneratedAdapter>>singletonList(constructor));return GENERATED_CALLBACK;}boolean hasLifecycleMethods = ClassesInfoCache.sInstance.hasLifecycleMethods(klass);if (hasLifecycleMethods) {return REFLECTIVE_CALLBACK;}Class<?> superclass = klass.getSuperclass();List<Constructor<? extends GeneratedAdapter>> adapterConstructors = null;if (isLifecycleParent(superclass)) {if (getObserverConstructorType(superclass) == REFLECTIVE_CALLBACK) {return REFLECTIVE_CALLBACK;}adapterConstructors = new ArrayList<>(sClassToAdapters.get(superclass));}for (Class<?> intrface : klass.getInterfaces()) {if (!isLifecycleParent(intrface)) {continue;}if (getObserverConstructorType(intrface) == REFLECTIVE_CALLBACK) {return REFLECTIVE_CALLBACK;}if (adapterConstructors == null) {adapterConstructors = new ArrayList<>();}adapterConstructors.addAll(sClassToAdapters.get(intrface));}if (adapterConstructors != null) {sClassToAdapters.put(klass, adapterConstructors);return GENERATED_CALLBACK;}return REFLECTIVE_CALLBACK;}public String getCanonicalName() {if (isArray()) {//是数组？String canonicalName = getComponentType().getCanonicalName();if (canonicalName != null)return canonicalName + "[]";elsereturn null;}if (isLocalOrAnonymousClass())//MyObserver是本地类return null;Class<?> enclosingClass = getEnclosingClass();if (enclosingClass == null) { // top level classreturn getName();} else {String enclosingName = enclosingClass.getCanonicalName();if (enclosingName == null)return null;return enclosingName + "." + getSimpleName();}}
一开始没有缓存，走resolveObserverCallbackType，如果是本地方法，返回
REFLECTIVE_CALLBACK
所以Lifecycling.lifecycleEventObserver(observer)最终会走到
return new ReflectiveGenericLifecycleObserver(object);
下面重点分析一下这个类（generic：通用的意思）：
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {private final Object mWrapped;private final CallbackInfo mInfo;ReflectiveGenericLifecycleObserver(Object wrapped) {mWrapped = wrapped;mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());}@Overridepublic void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {mInfo.invokeCallbacks(source, event, mWrapped);}}
这个类实现了LifecycleEventObserver，重写了onStateChanged方法。
先来关注一下getInfo方法：
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);}}//获取所有MyObserver里面的方法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;}hasLifecycleMethods = true;Class<?>[] params = method.getParameterTypes();int callType = CALL_TYPE_NO_ARG;//参数类型集合数量 目前demo是0if (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);//注解value（event）和方法引用类型放到map里面verifyAndPutHandler(handlerToEvent, methodReference, event, klass);}//放到callBackInfo里面CallbackInfo info = new CallbackInfo(handlerToEvent);mCallbackMap.put(klass, info);//缓存 前面有取的操作mHasLifecycleMethods.put(klass, hasLifecycleMethods);return info;}
verifyAndPutHandler方法：
private void verifyAndPutHandler(Map<MethodReference, Lifecycle.Event> handlers,MethodReference newHandler, Lifecycle.Event newEvent, Class<?> klass) {Lifecycle.Event event = handlers.get(newHandler);if (event != null && newEvent != event) {Method method = newHandler.mMethod;throw new IllegalArgumentException("Method " + method.getName() + " in " + klass.getName()+ " already declared with different @OnLifecycleEvent value: previous"+ " value " + event + ", new value " + newEvent);}if (event == null) {handlers.put(newHandler, newEvent);}}
一开始获取event为null，放到map里面。
这样，lifecycle.addObserver就将MyObserver里面所有带@OnLifecycleEvent注解的方法封装到CallbackInfo里面了。但是到目前为止好像并没有看到为什么观察者MyObserver可以监听activity的生命周期。
我们接着回到ComponentActivity的onCreate方法：
@Overrideprotected void onCreate(@Nullable Bundle savedInstanceState) {// Restore the Saved State first so that it is available to// OnContextAvailableListener instancesmSavedStateRegistryController.performRestore(savedInstanceState);mContextAwareHelper.dispatchOnContextAvailable(this);super.onCreate(savedInstanceState);mActivityResultRegistry.onRestoreInstanceState(savedInstanceState);ReportFragment.injectIfNeededIn(this);//重点关注if (mContentLayoutId != 0) {setContentView(mContentLayoutId);}}
进重点关注那个注释里面看看：
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)public class ReportFragment extends android.app.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) {// On API 29+, we can register for the correct Lifecycle callbacks directlyLifecycleCallbacks.registerIn(activity);}// Prior to API 29 and to maintain compatibility with older versions of// ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and// need to support activities that don't extend from FragmentActivity from support lib),// use a framework fragment to get the correct timing of Lifecycle eventsandroid.app.FragmentManager manager = activity.getFragmentManager();if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();// Hopefully, we are the first to make a transaction.manager.executePendingTransactions();}}@SuppressWarnings("deprecation")static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {if (activity instanceof LifecycleRegistryOwner) {((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);return;}if (activity instanceof LifecycleOwner) {//7Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();if (lifecycle instanceof LifecycleRegistry) {((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);}}}static ReportFragment get(Activity activity) {return (ReportFragment) activity.getFragmentManager().findFragmentByTag(REPORT_FRAGMENT_TAG);}private ActivityInitializationListener mProcessListener;private void dispatchCreate(ActivityInitializationListener listener) {if (listener != null) {listener.onCreate();}}private void dispatchStart(ActivityInitializationListener listener) {if (listener != null) {listener.onStart();}}private void dispatchResume(ActivityInitializationListener listener) {if (listener != null) {listener.onResume();}}@Overridepublic void onActivityCreated(Bundle savedInstanceState) {super.onActivityCreated(savedInstanceState);dispatchCreate(mProcessListener);dispatch(Lifecycle.Event.ON_CREATE);//1}@Overridepublic void onStart() {super.onStart();dispatchStart(mProcessListener);dispatch(Lifecycle.Event.ON_START);//2}@Overridepublic void onResume() {super.onResume();dispatchResume(mProcessListener);dispatch(Lifecycle.Event.ON_RESUME);//3}@Overridepublic void onPause() {super.onPause();dispatch(Lifecycle.Event.ON_PAUSE);//4}@Overridepublic void onStop() {super.onStop();dispatch(Lifecycle.Event.ON_STOP);//5}@Overridepublic void onDestroy() {super.onDestroy();dispatch(Lifecycle.Event.ON_DESTROY);//6// just want to be sure that we won't leak reference to an activitymProcessListener = null;}private void dispatch(@NonNull Lifecycle.Event event) {if (Build.VERSION.SDK_INT < 29) {// Only dispatch events from ReportFragment on API levels prior// to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks// added in ReportFragment.injectIfNeededIndispatch(getActivity(), event);}}void setProcessListener(ActivityInitializationListener processListener) {mProcessListener = processListener;}interface ActivityInitializationListener {void onCreate();void onStart();void onResume();}// this class isn't inlined only because we need to add a proguard rule for it (b/142778206)// In addition to that registerIn method allows to avoid class verification failure,// because registerActivityLifecycleCallbacks is available only since api 29.@RequiresApi(29)static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {static void registerIn(Activity activity) {activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());}@Overridepublic void onActivityCreated(@NonNull Activity activity,@Nullable Bundle bundle) {}@Overridepublic void onActivityPostCreated(@NonNull Activity activity,@Nullable Bundle savedInstanceState) {dispatch(activity, Lifecycle.Event.ON_CREATE);}@Overridepublic void onActivityStarted(@NonNull Activity activity) {}@Overridepublic void onActivityPostStarted(@NonNull Activity activity) {dispatch(activity, Lifecycle.Event.ON_START);}@Overridepublic void onActivityResumed(@NonNull Activity activity) {}@Overridepublic void onActivityPostResumed(@NonNull Activity activity) {dispatch(activity, Lifecycle.Event.ON_RESUME);}@Overridepublic void onActivityPrePaused(@NonNull Activity activity) {dispatch(activity, Lifecycle.Event.ON_PAUSE);}@Overridepublic void onActivityPaused(@NonNull Activity activity) {}@Overridepublic void onActivityPreStopped(@NonNull Activity activity) {dispatch(activity, Lifecycle.Event.ON_STOP);}@Overridepublic void onActivityStopped(@NonNull Activity activity) {}@Overridepublic void onActivitySaveInstanceState(@NonNull Activity activity,@NonNull Bundle bundle) {}@Overridepublic void onActivityPreDestroyed(@NonNull Activity activity) {dispatch(activity, Lifecycle.Event.ON_DESTROY);}@Overridepublic void onActivityDestroyed(@NonNull Activity activity) {}}}
在MainActivity里面加了一个无UI的fragment，我们这里先不分析api大于等于29的情况，以简化我们的思考。我们知道，每当activity生命周期变化时，fragment生命周期也会发生变化。然后通过注释1，2，3，4，5，6处分发事件。又因为：
public class ComponentActivity extends androidx.ponentActivity implementsContextAware,LifecycleOwner//1
所以走注释7处：
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {if (activity instanceof LifecycleRegistryOwner) {((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);return;}if (activity instanceof LifecycleOwner) {//7Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();if (lifecycle instanceof LifecycleRegistry) {((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);}}}
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {enforceMainThreadIfNeeded("handleLifecycleEvent");moveToState(event.getTargetState());}
接着看：
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");}
getTargetState这个意思很明确：根据event值进行判断，返回对应状态。直接这么说可能不是很好理解，我们来看一张图（个人认为这张图在解释Lifecycle原理这块不可或缺）：
从左向右，代表activity的正向生命周期，从右往左代表activity的反向生命周期。
下面再来分析moveToState方法：
private void moveToState(State next) {if (mState == next) {//mState初始值为INITIALIZED，不相等，往下走return;}mState = next;if (mHandlingEvent || mAddingObserverCounter != 0) {mNewEventOccurred = true;// we will figure out what to do on upper level.return;}mHandlingEvent = true;sync();//1mHandlingEvent = 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()) {mNewEventOccurred = false;// no need to check eldest for nullability, because isSynced does it for us.if (pareTo(mObserverMap.eldest().getValue().mState) < 0) {backwardPass(lifecycleOwner);}Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();if (!mNewEventOccurred && newest != null&& pareTo(newest.getValue().mState) > 0) {forwardPass(lifecycleOwner);}}mNewEventOccurred = false;}
我们先来看看mObserverMap是啥？
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =new FastSafeIterableMap<>();
这个Map是以LifecycleObserver为键，以ObserverWithState为值。我们又联系到addObserver方法：
@Overridepublic void addObserver(@NonNull LifecycleObserver observer) {enforceMainThreadIfNeeded("addObserver");State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);//1···}
我们进注释1处看看：
@Overridepublic V putIfAbsent(@NonNull K key, @NonNull V v) {Entry<K, V> current = get(key);if (current != null) {return current.mValue;}mHashMap.put(key, put(key, v));return null;}
这个Map里面又封装了一个HashMap：
private HashMap<K, Entry<K, V>> mHashMap = new HashMap<>();
我们再来分析一下：
private boolean isSynced() {if (mObserverMap.size() == 0) {return true;}State eldestObserverState = mObserverMap.eldest().getValue().mState;State newestObserverState = mObserverMap.newest().getValue().mState;return eldestObserverState == newestObserverState && mState == newestObserverState;}
这个方法是什么意思呢？看代码很明显：mObserverMap里面是有数据的，而且State存的是INITIALIZED，当无UI的fragment分发事件时，mState改变。isSynced返回false。
所以，while(true)，我们先来看正向流程：
private void forwardPass(LifecycleOwner lifecycleOwner) {Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =mObserverMap.iteratorWithAdditions();//遍历所有观察者，demo里我们只写了一个while (ascendingIterator.hasNext() && !mNewEventOccurred) {Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();//取ObserverWithState对象ObserverWithState observer = entry.getValue();while ((pareTo(mState) < 0 && !mNewEventOccurred&& mObserverMap.contains(entry.getKey()))) {pushParentState(observer.mState);final Event event = Event.upFrom(observer.mState);//1if (event == null) {throw new IllegalStateException("no event up from " + observer.mState);}observer.dispatchEvent(lifecycleOwner, event);//2popParentState();}}}
因为是正向流程，所以是图中从左往右，看注释1处：
@Nullablepublic static Event upFrom(@NonNull State state) {switch (state) {case INITIALIZED:return ON_CREATE;case CREATED:return ON_START;case STARTED:return ON_RESUME;default:return null;}}
最开始observer.mState是INITIALIZED，正向流程所以event为ON_CREATE，再来看注释2:
void dispatchEvent(LifecycleOwner owner, Event event) {State newState = event.getTargetState();mState = min(mState, newState);mLifecycleObserver.onStateChanged(owner, event);//1mState = newState;}
获取新的state，把新的状态赋给mState。我们注意注释1，通过前面的分析我们知道：
mLifecycleobserver其实是一个ReflectiveGenericLifecycleObserver，所以：
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {private final Object mWrapped;private final CallbackInfo mInfo;ReflectiveGenericLifecycleObserver(Object wrapped) {mWrapped = wrapped;mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());}@Overridepublic void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {mInfo.invokeCallbacks(source, event, mWrapped);//1}}
会走到这个注释1。接着看：
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);}
我们先来看看mEventToHandlers又是个啥？
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<>();for (Map.Entry<MethodReference, Lifecycle.Event> entry : handlerToEvent.entrySet()) {Lifecycle.Event event = entry.getValue();List<MethodReference> methodReferences = mEventToHandlers.get(event);if (methodReferences == null) {//为nullmethodReferences = new ArrayList<>();mEventToHandlers.put(event, methodReferences);}methodReferences.add(entry.getKey());}}···}
```MethodReference methodReference = new MethodReference(callType, method);verifyAndPutHandler(handlerToEvent, methodReference, event, klass);}CallbackInfo info = new CallbackInfo(handlerToEvent);```
首先我们将参数类型和方法封装到MethodReference，然后将MethodReference作为键，Event作为值存到handlerToEvent这个Map里面，然后在CallbackInfo这个类构造里面遍历这个Map，然后这里面进行了一个非常骚气的操作，将event作为键，所有event对应methodReference的集合作为值存到一个新Map里面。这样做是保证了fragment分发一个event，所有观察者对应方法都会响应！
在往下看：
//List<MethodReference> handlers 一个event事件对应的所有观察者的方法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);}}}
继续：
void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {//noinspection TryWithIdenticalCatchestry {switch (mCallType) {case CALL_TYPE_NO_ARG:mMethod.invoke(target);//1break;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);}}
我们在MyObserver里面定义的方法是无参数的，走注释1。target->mWrapped->object->observer->MyObserver。也就是调用了MyObserver对应注释的方法。到这里，Lifecycle的流程就分析完了。用起来非常简单的Jetpack框架，其原理确实相当的复杂，但是给我们带来的思考确实非常的宝贵。
