Lifecycle 一篇文章就够了

使用篇

引入库：

    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.Log
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import 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的生命周期了：

2022-08-13 19:06:03.025 8263-8263/com.example.lifecycletest W/MyObserver: onCreate:
2022-08-13 19:06:03.028 8263-8263/com.example.lifecycletest W/MyObserver: onStart:
2022-08-13 19:06:03.030 8263-8263/com.example.lifecycletest W/MyObserver: onResume:
2022-08-13 19:06:38.333 8263-8263/com.example.lifecycletest W/MyObserver: onPause:
2022-08-13 19:06:38.363 8263-8263/com.example.lifecycletest W/MyObserver: onStop:
2022-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的父类是AppCompatActivity
AppCompatActivity的父类是FragmentActivity
FragmentActivity的父类是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 ((statefulObserver.mState.compareTo(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.core.app.ComponentActivity 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 (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {backwardPass(lifecycleOwner);}Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();if (!mNewEventOccurred && newest != null&& mState.compareTo(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 ((observer.mState.compareTo(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框架，其原理确实相当的复杂，但是给我们带来的思考确实非常的宝贵。

Lifecycle 一篇文章就够了相关推荐

Android：学习AIDL，这一篇文章就够了(下)
前言上一篇博文介绍了关于AIDL是什么,为什么我们需要AIDL,AIDL的语法以及如何使用AIDL等方面的知识,这一篇博文将顺着上一篇的思路往下走,接着介绍关于AIDL的一些更加深入的知识.强烈建议 ...
架构师必须搞懂DNS，一篇文章就够了。
转载自架构师必须搞懂DNS,一篇文章就够了. 概念 DNS,全称Domain Name System,即域名系统,搞清楚,它不是DNF地下城与勇士. DNS是怎么来的,我们知道要访问一个服务器的资源 ...
集成Android免费语音合成功能（在线、离线、离在线融合），有这一篇文章就够了（离线）
原址集成Android免费语音合成功能(在线.离线.离在线融合),有这一篇文章就够了(在线) 集成Android免费语音合成功能(在线.离线.离在线融合),有这一篇文章就够了(离在线融合) ...
全面认识MOS管，一篇文章就够了
基础知识中 MOS 部分迟迟未整理,实际分享的电路中大部分常用电路都用到了MOS管, 今天势必要来一篇文章,彻底掌握mos管! ...更新:为什么常在MOS管GS并联电阻? ...更新:为什么要在MO ...
全面认识二极管，一篇文章就够了
电子设计基础元器件二极管,小小二极管,大大用途. ... 矜辰所致目录前言一.二极管基础知识 1.1 什么是二极管 1.2 二极管的组成 1.3 二极管的原理二.二极管特性 2.1 伏安特性 ...
js层级选择框样式_IOS和JS的交互，看这一篇文章就够了
IOS和JS的交互,看这一篇文章就够了创作不易,请珍惜,之后会持续更新,不断完善 Demo地址目录 WKWebView使用.JS的交互 WKWebView使用.JS的交互演示(本来想贴张GIF作 ...
关于VR产品的前世今生，看这一篇文章就够了
关于VR产品的前世今生,看这一篇文章就够了(转) 文/胡勇即使最富质疑精神最冷静的人也无法漠视现在的 VR/AR 掀起的狂潮,这个从科技圈蔓延到实业界最后席卷大众的想象力的狂欢正以前所未有的态势改变 ...
五年程序员是如何玩转闲鱼无货源的，只看这一篇文章就够了
今天的内容方向主要是基础篇-进阶篇 ,优化了一下操作方法,尽量细化,让你看完这篇内容之后从入门到大神. 基础篇: 注册这些基础的之前说过,这次就不说了,这次说下如何养号. 完善个人资料(头像.昵称.简 ...
MySQL优化-一篇文章就够了（转发加收藏吧）
关注我,一个仍存梦想的屌丝程序员,每天为你分享高质量编程博客. 回复 "代金券" 免费获取腾讯云和阿里云代金券前言说起MySQL的查询优化,相信大家收藏了一堆:不能使用SEL ...

Lifecycle 一篇文章就够了

使用篇

原理篇

Lifecycle 一篇文章就够了相关推荐

最新文章

热门文章