Android Jetpack Lifecycle 源码解析

dependencies { def lifecycle_version = "2.2.0" // Lifecycles only (without ViewModel or LiveData) implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version" }

dependencies { def lifecycle_version = "1.1.1" implementation "android.arch.lifecycle:runtime:$lifecycle_version" }

class MyActivity extends AppCompatActivity { private MyLocationListener myLocationListener; public void onCreate(...) { // manage other component myLocationListener = new MyLocationListener(this, location -> { // update UI }); } @Override public void onStart() { super.onStart(); // manage other component Util.checkUserStatus(result -> { // what if this callback is invoked AFTER activity is stopped? if (result) { myLocationListener.start(); } }); } @Override public void onStop() { super.onStop(); // manage other component myLocationListener.stop(); } }

public class MyObserver implements LifecycleObserver { @OnLifecycleEvent(Lifecycle.Event.ON_RESUME) public void connectListener() { ... } @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE) public void disconnectListener() { ... } } // 注释1使用LifecycleOwner只有的Lifecycle添加一个观察者 myLifecycleOwner.getLifecycle().addObserver(new MyObserver());

package android.arch.lifecycle @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface OnLifecycleEvent { Lifecycle.Event value(); }

package android.arch.lifecycle @SuppressWarnings({"WeakerAccess", "unused"}) public interface LifecycleOwner { @NonNull Lifecycle getLifecycle(); }

package android.arch.lifecycle; 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(); @SuppressWarnings("WeakerAccess") public enum Event { ON_CREATE, ON_START, ON_RESUME, ON_PAUSE, ON_STOP, ON_DESTROY, /** * An {@link Event Event} constant that can be used to match all events. */ ON_ANY } @SuppressWarnings("WeakerAccess") public enum State { DESTROYED, INITIALIZED, CREATED, STARTED, RESUMED; public boolean isAtLeast(@NonNull State state) { return compareTo(state) >= 0; } } }

package android.support.v4.app; @RestrictTo({Scope.LIBRARY_GROUP}) public class SupportActivity extends Activity implements LifecycleOwner, Component { private SimpleArrayMap<Class<? extends SupportActivity.ExtraData>, SupportActivity.ExtraData> mExtraDataMap = new SimpleArrayMap(); // 注释0 Lifecycle的实现类，LifecycleRegistry private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this); ... protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); // 注释1: Fragment 监听事件变化 ReportFragment.injectIfNeededIn(this); } // 注释2:onSaveInstanceState回调，切换状态到State.CREATED。 @CallSuper //子类override 时必须call super.onSaveInstanceState(outState); 防止状态丢失。 protected void onSaveInstanceState(Bundle outState) { this.mLifecycleRegistry.markState(State.CREATED); super.onSaveInstanceState(outState); } // 注释3 实现getLifecycle().LifecycleOwner接口 public Lifecycle getLifecycle() { return this.mLifecycleRegistry; } ... }

public static void injectIfNeededIn(Activity activity) { // ProcessLifecycleOwner should always correctly work and some activities may not extend // FragmentActivity from support lib, so we use framework fragments for activities android.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(); } }

... @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); } @Override public void onResume() { super.onResume(); dispatchResume(mProcessListener); dispatch(Lifecycle.Event.ON_RESUME); } @Override public void onPause() { super.onPause(); dispatch(Lifecycle.Event.ON_PAUSE); } @Override public void onStop() { super.onStop(); dispatch(Lifecycle.Event.ON_STOP); } @Override public void onDestroy() { super.onDestroy(); dispatch(Lifecycle.Event.ON_DESTROY); // just want to be sure that we won't leak reference to an activity mProcessListener = null; } private void dispatch(Lifecycle.Event event) { Activity activity = getActivity(); if (activity instanceof LifecycleRegistryOwner) { ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event); return; } if (activity instanceof LifecycleOwner) { Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle(); if (lifecycle instanceof LifecycleRegistry) { ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event); } } }

package android.arch.lifecycle; public LifecycleRegistry(@NonNull LifecycleOwner provider) { mLifecycleOwner = new WeakReference<>(provider); mState = INITIALIZED; } // 注释0 将Lifecycle的状态，移到给出的状态，并且向观察者分发所需的事件：假如Lifecycle处于RESUMED状态，正好有一个刚注册的ObserverA。 // ObserverA 会连续收到 ON_CREATE，ON_START，ON_RESUME 三个事件。 @SuppressWarnings("WeakerAccess") @MainThread public void markState(@NonNull State state) { moveToState(state); } // 注释1:根据发来的event，设置当前的状态，并且通知观察者当前的event。 public void handleLifecycleEvent(@NonNull Lifecycle.Event event) { State next = getStateAfter(event); moveToState(next); } // 注释2:完成状态转换。 private void moveToState(State next) { if (mState == next) { return; } mState = next; // 注释3：防止状态快速切换 if (mHandlingEvent || mAddingObserverCounter != 0) { // 注释4: 防止漏掉新事件 mNewEventOccurred = true; // we will figure out what to do on upper level. return; } mHandlingEvent = true; sync(); mHandlingEvent = false; } // 注释5: 根据event 获取下一个状态 static State getStateAfter(Event event) { switch (event) { case ON_CREATE: case ON_STOP: return CREATED; case ON_START: case ON_PAUSE: return STARTED; case ON_RESUME: return RESUMED; case ON_DESTROY: return DESTROYED; case ON_ANY: break; } throw new IllegalArgumentException("Unexpected event value " event); }

// happens only on the top of stack (never in reentrance), // so it doesn't have to take in account parents private void sync() { 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) { // 注释0 backwardPass(); } // 注释2 Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest(); if (!mNewEventOccurred && newest != null && mState.compareTo(newest.getValue().mState) > 0) { // 注释1 forwardPass(); } } mNewEventOccurred = false; }

private void forwardPass() { Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator = mObserverMap.iteratorWithAdditions(); while (ascendingIterator.hasNext() && !mNewEventOccurred) { // 注释1 重要的ObserverWithState Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next(); ObserverWithState observer = entry.getValue(); while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred && mObserverMap.contains(entry.getKey()))) { pushParentState(observer.mState); // 注释0 最重要的一环，派发新事件，给观察者 observer.dispatchEvent(mLifecycleOwner, upEvent(observer.mState)); popParentState(); } } }

private static Event upEvent(State state) { switch (state) { case INITIALIZED: case DESTROYED: return ON_CREATE; case CREATED: return ON_START; case STARTED: return ON_RESUME; case RESUMED: throw new IllegalArgumentException(); } throw new IllegalArgumentException("Unexpected state value " state); }

static State min(@NonNull State state1, @Nullable State state2) { return state2 != null && state2.compareTo(state1) < 0 ? state2 : state1; } static class ObserverWithState { State mState; GenericLifecycleObserver mLifecycleObserver; ObserverWithState(LifecycleObserver observer, State initialState) { // 注释1 mLifecycleObserver = Lifecycling.getCallback(observer); mState = initialState; } void dispatchEvent(LifecycleOwner owner, Event event) { State newState = getStateAfter(event); mState = min(mState, newState); // 注释2 mLifecycleObserver.onStateChanged(owner, event); mState = newState; } } }

@NonNull static GenericLifecycleObserver getCallback(Object object) { // step 0: 如果是GenericLifecycleObserver，直接返回。 if (object instanceof GenericLifecycleObserver) { return (GenericLifecycleObserver) object; } //noinspection TryWithIdenticalCatches try { // step2，获取缓存的class构造器，（一个class注册过，就把它放入缓存） final Class<?> klass = object.getClass(); Constructor<? extends GenericLifecycleObserver> cachedConstructor = sCallbackCache.get( klass); // if (cachedConstructor != null) { return cachedConstructor.newInstance(object); } // 根据LifecycleObserver类或子类，获得GenericLifecycleObserver类或子类的构造器 cachedConstructor = getGeneratedAdapterConstructor(klass); if (cachedConstructor != null) { if (!cachedConstructor.isAccessible()) { cachedConstructor.setAccessible(true); } } else { cachedConstructor = sREFLECTIVE; } sCallbackCache.put(klass, cachedConstructor); return cachedConstructor.newInstance(object); } catch (IllegalAccessException e) { throw new RuntimeException(e); } catch (InstantiationException e) { throw new RuntimeException(e); } catch (InvocationTargetException e) { throw new RuntimeException(e); } }

class ReflectiveGenericLifecycleObserver implements GenericLifecycleObserver { private final Object mWrapped; // LifecycleObserver，为什么是它，看后边。 private final CallbackInfo mInfo; @SuppressWarnings("WeakerAccess") static final Map<Class, CallbackInfo> sInfoCache = new HashMap<>(); ReflectiveGenericLifecycleObserver(Object wrapped) { mWrapped = wrapped; // 注释0 mInfo = getInfo(mWrapped.getClass()); } @Override public void onStateChanged(LifecycleOwner source, Event event) { // 注释1 invokeCallbacks(mInfo, source, event); }

private static CallbackInfo getInfo(Class klass) { CallbackInfo existing = sInfoCache.get(klass); // step0： 取缓存 if (existing != null) { return existing; } // step1， 无缓存就创建 existing = createInfo(klass); return existing; } private static CallbackInfo createInfo(Class klass) { // step 2 获得当前类的父类 Class superclass = klass.getSuperclass(); Map<MethodReference, Event> handlerToEvent = new HashMap<>(); // step 3 如果父类不为null，为其创建CallbackInfo（是个递归的过程，最终将此类继承结构中，所有层级注册过的方法都添加至handlerToEvent中） if (superclass != null) { CallbackInfo superInfo = getInfo(superclass); if (superInfo != null) { handlerToEvent.putAll(superInfo.mHandlerToEvent); } } // step 4 获取当前类，声明的所有方法（public，private，等所有方法） Method[] methods = klass.getDeclaredMethods(); // step 5，获取当前类实现的所有监听event方法，添加到当前handlerToEvent里。 Class[] interfaces = klass.getInterfaces(); for (Class intrfc : interfaces) { for (Entry<MethodReference, Event> entry : getInfo(intrfc).mHandlerToEvent.entrySet()) { verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass); } } // step6 遍历所有的方法，获取包含OnLifecycleEvent注解的方法, 分析每个注册方法的调用类型，并且创建MethodReference，添加到handlerToEvent中 for (Method method : methods) { OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class); if (annotation == null) { continue; } Class<?>[] params = method.getParameterTypes(); // 注意对监听event事件参数的要求，要么没参数，要么参数0是LifecycleOwner的子类，要么参数1也还是Event类型的，这时还要求监听的Event得是onAny。 // 而且参数最长，3个，不能再多了。 // 为啥会有这等要求呢？1）反射invoke方法要传参，lifecyle作为一个通用框架，获取到的真正的参数的对象，也是有限的。2）给监听onAny的方法，一个知道当前event的入口。 3） 也给监听者一个获取到生命周期对象（Activity，Fragment）的机会。 int callType = CALL_TYPE_NO_A 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"); } } Event event = annotation.value(); if (params.length > 1) { callType = CALL_TYPE_PROVIDER_WITH_EVENT; if (!params[1].isAssignableFrom(Event.class)) { throw new IllegalArgumentException( "invalid parameter type. second arg must be an event"); } if (event != 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"); } // step 7创建MethodReference，添加到handlerToEvent。 MethodReference methodReference = new MethodReference(callType, method); verifyAndPutHandler(handlerToEvent, methodReference, event, klass); } // step8，通过handlerToEvent，创建CallbackInfo，并添加到sInfoCache中 CallbackInfo info = new CallbackInfo(handlerToEvent); sInfoCache.put(klass, info); return info; }

@SuppressWarnings("WeakerAccess") static class CallbackInfo { // 注释0:监听同一个event的方法列表 final Map<Event, List<MethodReference>> mEventToHandlers; // 注释1: 包含方法引用，与event的Map，在createInfo阶段被创建。 final Map<MethodReference, Event> mHandlerToEvent; // 注释2: 将mHandlerToEvent，转换为mEventToHandlers CallbackInfo(Map<MethodReference, Event> handlerToEvent) { mHandlerToEvent = handlerToEvent; mEventToHandlers = new HashMap<>(); for (Entry<MethodReference, Event> entry : handlerToEvent.entrySet()) { Event event = entry.getValue(); List<MethodReference> methodReferences = mEventToHandlers.get(event); if (methodReferences == null) { methodReferences = new ArrayList<>(); mEventToHandlers.put(event, methodReferences); } methodReferences.add(entry.getKey()); } } }

@Override public void onStateChanged(LifecycleOwner source, Event event) { // step0:拿着mInfo，和真正的对象类型，去反射该调用的方法。 invokeCallbacks(mInfo, source, event); } // step2，根据info里缓存的信息，遍历所有监听方法，挨个反射调用一下。 private void invokeMethodsForEvent(List<MethodReference> handlers, LifecycleOwner source, Event event) { if (handlers != null) { for (int i = handlers.size() - 1; i >= 0; i--) { MethodReference reference = handlers.get(i); invokeCallback(reference, source, event); } } } // step1，通知监听该event的方法；同时通知监听所有event的方法。 @SuppressWarnings("ConstantConditions") private void invokeCallbacks(CallbackInfo info, LifecycleOwner source, Event event) { invokeMethodsForEvent(info.mEventToHandlers.get(event), source, event); invokeMethodsForEvent(info.mEventToHandlers.get(Event.ON_ANY), source, event); } // step3，按照缓存的方法参数类型，反射方法。 private void invokeCallback(MethodReference reference, LifecycleOwner source, Event event) { //noinspection TryWithIdenticalCatches try { switch (reference.mCallType) { case CALL_TYPE_NO_ARG: reference.mMethod.invoke(mWrapped); break; case CALL_TYPE_PROVIDER: reference.mMethod.invoke(mWrapped, source); break; case CALL_TYPE_PROVIDER_WITH_EVENT: reference.mMethod.invoke(mWrapped, source, event); break; } } catch (InvocationTargetException e) { throw new RuntimeException("Failed to call observer method", e.getCause()); } catch (IllegalAccessException e) { throw new RuntimeException(e); } }