Android Jetpack 组件之 Lifecycle源码

1、前言

最近简单看了下google推出的框架Jetpack，感觉此框架的内容可以对平时的开发有很大的帮助，也可以解决很多开发中的问题，对代码的逻辑和UI界面实现深层解耦，打造数据驱动型UI界面。

Android Architecture组件是Android Jetpack的一部分，它们是一组库，旨在帮助开发者设计健壮、可测试和可维护的应用程序，包含一下组件：

Android Jetpack组件总览
Android Jetpack 组件之 Lifecycle使用
Android Jetpack 组件之 Lifecycle源码
Android Jetpack组件之ViewModel使用
Android Jetpack组件之 LiveData使用-源码
Android Jetpack组件之 Paging使用-源码
Android Jetpack组件之 Room使用-源码
Android Jetpack组件之Navigation使用-源码
Android Jetpack组件之WorkManger使用介绍
Android Jetpack组件App Startup简析
Android Jetpack组件之Hilt使用

本系列文章是各处copy过来的，个人感觉所有的开发者都应该尽早的熟悉Jetpack组件，相信一定会被它的魅力所吸引，最近也在完成一个使用以上所有组件实现的项目，作为对Jetpack组件的项目实践，下面来分析一下每个组件对项目开发的帮助。

二、源码分析

关于Lifecycle的使用考上一篇文章Android Jetpack框架之 Lifecycles使用，从使用的方法中我们知道Lifecycle的实现主要依赖：LifecycleObserver、LifecycleOwner；通过像Owner注册Observer实现感知Owner的生命周期，下面一起看看源码是如何巧妙设计的；

2.1、生命周期观察者：LifecycleObserver

// 实现LifecycleObserver
class MyObserver(var lifecycle: Lifecycle, var callback: CallBack) : LifecycleObserver {@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)public fun connectOnCreate() {p("connectOnCreate")}@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)public fun connectOnResume() {p("connectOnResume")}
}// LifecycleObserver 是一个空接口
public interface LifecycleObserver {}

上面过程做了三件事情：

实现LifecycleObserver的接口
编写要执行的方法
为每个方法添加注解，表示其执行的时机

@OnLifecycleEvent：运行注解

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

2.2、生命周期：Lifecycle.Event & State

 // 生命周期Event
public enum Event {/*** Constant for onCreate event of the {@link LifecycleOwner}.*/ON_CREATE,/*** Constant for onStart event of the {@link LifecycleOwner}.*/ON_START,/*** Constant for onResume event of the {@link LifecycleOwner}.*/ON_RESUME,/*** Constant for onPause event of the {@link LifecycleOwner}.*/ON_PAUSE,/*** Constant for onStop event of the {@link LifecycleOwner}.*/ON_STOP,/*** Constant for onDestroy event of the {@link LifecycleOwner}.*/ON_DESTROY,/*** An {@link Event Event} constant that can be used to match all events.*/ON_ANY}//5个对应的生命周期状态public enum State {DESTROYED,INITIALIZED,CREATED,STARTED,RESUMED;public boolean isAtLeast(@NonNull State state) {return compareTo(state) >= 0;}}

通过Lifecycle.Event和State的查看，系统提供了Activity每个生命周期对应的Event，而Event有会有对应的State，此时以大致猜想到上面的执行过程：

使用LifeEvent标记每个执行方法的Event
当活动状态改变时，系统会判断即将要改变成的状态
根据状态获取要执行的Event
从注册的Observer中获取标注为对应的Event，执行逻辑

2.3、生命周期的感知

LifecycleOwner

class LifeCyclerActivity : AppCompatActivity() {...var myObserver = MyObserver(lifecycle, object : CallBack { // 创建LifecyclerObserveroverride fun update() {...}})lifecycle.addObserver(myObserver) // 添加观察者}
}

从上面的使用情况看出，使用的活动需要调用getLifecycle（）方法，返回LifecycleRegistry，这里的getLifecycle（）方法其实是接口LifecycleOwner接口中的方法，

@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {/*** Returns the Lifecycle of the provider.** @return The lifecycle of the provider.*/@NonNullLifecycle getLifecycle();
}

此时LifecycleActivity虽然没有实现接口，因为他继承的AppCompatActivity继承了SupportActivity，而SupportActivity实现了接口

@RestrictTo(LIBRARY_GROUP)
public class SupportActivity extends Activity implements LifecycleOwner {private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this); //创建@Overridepublic Lifecycle getLifecycle() { // 重写方法返回LifecycleRegistry return mLifecycleRegistry;}}

SupportActivity除了执行上述操作外，在onCrate的方法中还有一句重要的代码，初始化了一个ReportFragment

protected void onCreate(@Nullable Bundle savedInstanceState) {super.onCreate(savedInstanceState);ReportFragment.injectIfNeededIn(this);}

ReportFragment

public class ReportFragment extends Fragment {private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"+ ".LifecycleDispatcher.report_fragment_tag";public static void injectIfNeededIn(Activity activity) { //初始化Fragmentandroid.app.FragmentManager manager = activity.getFragmentManager();if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();manager.executePendingTransactions();}}@Overridepublic void onActivityCreated(Bundle savedInstanceState) {super.onActivityCreated(savedInstanceState);dispatchCreate(mProcessListener);dispatch(Lifecycle.Event.ON_CREATE);}@Overridepublic void onStart() {super.onStart();dispatchStart(mProcessListener);dispatch(Lifecycle.Event.ON_START);}@Overridepublic void onResume() {super.onResume();dispatchResume(mProcessListener);dispatch(Lifecycle.Event.ON_RESUME);}@Overridepublic void onPause() {super.onPause();dispatch(Lifecycle.Event.ON_PAUSE);}@Overridepublic void onStop() {super.onStop();dispatch(Lifecycle.Event.ON_STOP);}@Overridepublic void onDestroy() {super.onDestroy();dispatch(Lifecycle.Event.ON_DESTROY);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);}}}
}

上面代码中做了两件事：

添加一个ReportFragment的实例
根据Fragment的每个生命周期的回调，调用dispatch（）处理回调事件

在dispatch（）方法中根据LifecyclerOwner和LifecyclerRegistryOwner实例分别处理，因为LifecyclerRegistryOwner也是继承LifecyclerOwner，而在我们SupportActivity中的getLifecycler（）中返回的是LifecycleRegistry，所以此处回调的都是LifecycleRegistry的handleLifecycleEvent；

2.4、生命周期处理

LifecycleRegistry

创建LifecycleRegistry实例

 // 对LifecycleOwner使用了弱引用
private final WeakReference<LifecycleOwner> mLifecycleOwner;public LifecycleRegistry(@NonNull LifecycleOwner provider) {mLifecycleOwner = new WeakReference<>(provider);// 状态为初始化状态mState = INITIALIZED;}

接着上面的执行，我们找到handleLifecycleEvent（）

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {State next = getStateAfter(event);moveToState(next);}

还记的上面的猜想吗？和此处执行的逻辑完全一致，对于getStateAfter（）和moveToState（），从名字中可以看出他们是执行响应生命周期的地方

 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);}private void moveToState(State next) {if (mState == next) {return;}mState = next;// 当正在sync中处理改变状态时 mHandlingEvent = true// 当我们调用addObserver时 mAddingObserverCounter ！= 0// 这两种状态都是正在执行任务的状态，所以此时直接returnif (mHandlingEvent || mAddingObserverCounter != 0) {mNewEventOccurred = true;// we will figure out what to do on upper level.return;}mHandlingEvent = true;sync();mHandlingEvent = false;}

在getStateAfter中首先根据执行的Lifecycle.Event，判断执行事件后下一个到达的状态，然后使用moveToState（）中的sync（）修改活动的生命周期：

private void sync() {LifecycleOwner lifecycleOwner = mLifecycleOwner.get();if (lifecycleOwner == null) {Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "+ "new events from it.");return;}while (!isSynced()) {mNewEventOccurred = false;// 比较的是出现的顺序 如果下一个周期小于当前的周期 即向前backif (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {backwardPass(lifecycleOwner); // 修改集合}//获取新的Map的EntryEntry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();if (!mNewEventOccurred && newest != null&& mState.compareTo(newest.getValue().mState) > 0) {forwardPass(lifecycleOwner);}}mNewEventOccurred = false;}

在sync()方法中除了必要的条件和判断外，主要的逻辑还是生命周期的比较和处理，由前面我们知道Lifecycle.Event和Lifecycle.State的声明顺序是和活动的声明周期执行顺序一致的，所以对Lifecycle.State的前后顺序的比较也就反应了声明周期状态的变换，比如活动此时的生命周期为Resumed（此时mObserverMap中保存的状态为Resumed），而下一个变换的状态为Started(此时的mState为Started)，从声明周期中可以知道此时执行的时onPause（），对应的LIfecycle.Event为ON_PAUSE，那么上述逻辑中此时执行的是：

if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {backwardPass(lifecycleOwner); // 修改集合}

backwardPass

 private void backwardPass(LifecycleOwner lifecycleOwner) {Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =mObserverMap.descendingIterator();while (descendingIterator.hasNext() && !mNewEventOccurred) {Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();// 获取当前保存的 ObserverWithState  从中提取状态ObserverWithState observer = entry.getValue(); while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred&& mObserverMap.contains(entry.getKey()))) {// 如果保存的状态大于 要变化的状态 向前修改Event event = downEvent(observer.mState); //查找对应周期变化的事件pushParentState(getStateAfter(event)); observer.dispatchEvent(lifecycleOwner, event); // 发送事件popParentState();}}}

在backwardPass（）方法中会将mObserverMap中保存的状态与mState比较，然后调用downEvent（）根据保存的状态找出要执行的Event，并调用Observer的dispatEvent（）方法发送事件，对于downEvent（）还有个与之对应的方法upEvent（）：

private static Event downEvent(State state) {switch (state) {case INITIALIZED:throw new IllegalArgumentException();case CREATED:return ON_DESTROY;case STARTED:return ON_STOP;case RESUMED:return ON_PAUSE;case DESTROYED:throw new IllegalArgumentException();}throw new IllegalArgumentException("Unexpected state value " + state);}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);}

上面的判断逻辑就是根据下一个目标生命周期的变化，与要执行的Event之间的转换，逻辑如下图：

按照我们上面的举例，从Resumed变为Started，从上图可以看出执行的Event是ON_PAUSE，与我们的猜想一致，总结一下Lifecycle对状态的处理流程：

实现LifecycleOwner获取LifecycleRegistry实例
绑定并存储HolderFragment
当HolderFragment生命周期改变时，调用handleLifecycleEvent处理事件
LifecycleRegistry根据要执行的Event获取要改变的状态和当前储存的状态
比较两个状态，获取真正要执行的Lifecycle.Event
调用储存的ObserverWithState的dispatchEvent（）发送事件

事件的处理流程已经清楚了，那么mState和ObserverWithState实例是什么时候存储的？又执行了哪些操作呢？那现在就从第一步添加开始看

2.5、添加Observer

addObserver：添加观察者Observer

 @Overridepublic void addObserver(@NonNull LifecycleObserver observer) {State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);...}

ObserverWithState

上述过程中获取了要执行的Event后，调用了Observer的dispatchEvent（）发送事件，我么知道此时调用的就是ObserverWithState .dispatchEvent（）方法，ObserverWithState封装了State和GenericLifecycleObserver 实例，在dispatchEvent（）又调用了mLifecycleObserver.onStateChanged(owner, event)，所以事件真正的执行是从onStateChanged（）开始的。

 static class ObserverWithState {State mState;GenericLifecycleObserver mLifecycleObserver;ObserverWithState(LifecycleObserver observer, State initialState) {mLifecycleObserver = Lifecycling.getCallback(observer);mState = initialState;}void dispatchEvent(LifecycleOwner owner, Event event) {State newState = getStateAfter(event);mState = min(mState, newState);mLifecycleObserver.onStateChanged(owner, event);mState = newState;}}

在ObserverWithState 的初始化过程中，同时调用了Lifecycling.getCallback(observer)创建了GenericLifecycleObserver实例

GenericLifecycleObserver

GenericLifecycleObserver的通过Lifecycling.getCallback(observer) 创建实例

 @NonNullstatic GenericLifecycleObserver getCallback(Object object) {if (object instanceof FullLifecycleObserver) {return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);}if (object instanceof GenericLifecycleObserver) {return (GenericLifecycleObserver) 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);}

创建不同的GenericLifecycleObserver并传入GeneratedAdapter实例，以SingleGeneratedAdapterObserver为例，实现GenericLifecycleObserver的接口重写onStateChange（）方法，在方法内部调用GeneratedAdapter的callMethod（）执行设定Observer的相关方法。

public class SingleGeneratedAdapterObserver implements GenericLifecycleObserver {private final GeneratedAdapter mGeneratedAdapter;SingleGeneratedAdapterObserver(GeneratedAdapter generatedAdapter) {mGeneratedAdapter = generatedAdapter;}@Overridepublic void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {mGeneratedAdapter.callMethods(source, event, false, null);mGeneratedAdapter.callMethods(source, event, true, null);}
}

在使用Debug追踪方法执行，在Lifecycling.getCallback(observer)中返回的是ReflectiveGenericLifecycleObserver，查看源码

class ReflectiveGenericLifecycleObserver implements GenericLifecycleObserver {private final Object mWrapped;private final CallbackInfo mInfo;ReflectiveGenericLifecycleObserver(Object wrapped) {mWrapped = wrapped;mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());}@Overridepublic void onStateChanged(LifecycleOwner source, Event event) {mInfo.invokeCallbacks(source, event, mWrapped);}
}

在构造函数中，初始化CallbackInfo实例，储存了Observer中定义的方法注解，在CallbackInfo的类中有一段代码比较明显：

//获取Observer的所有方法Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);boolean hasLifecycleMethods = false;for (Method method : methods) {// 获取方法的注解OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);if (annotation == null) {continue;}hasLifecycleMethods = true;//方法的参数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 Lifecycle.Event event = annotation.value();if (params.length > 1) {callType = CALL_TYPE_PROVIDER_WITH_EVENT;...}//创建MethodReference 封装了参数和方法MethodReference methodReference = new MethodReference(callType, method);verifyAndPutHandler(handlerToEvent, methodReference, event, klass);}// 创建并保存CallbackInfo实例CallbackInfo info = new CallbackInfo(handlerToEvent);mCallbackMap.put(klass, info);mHasLifecycleMethods.put(klass, hasLifecycleMethods);return info;

上述执行的逻辑很清楚，里面的几个属性需要简单说明：

MethodReference：封装了Method的参数类型和方法
handlerToEvent：是一个Map<MethodReference, Lifecycle.Event>，保存MethodReference和对应的Lifecycle.Event事件，上述调用的verifyAndPutHandler（）就是MethodReference和Lifecycle.Event放进Map
mCallbackMap：Map<Class, CallbackInfo>，储存Observer的类对应的CallbackInfo
mHasLifecycleMethods：用于标注Observer类是否有注解的方法

所以在ReflectiveGenericLifecycleObserver中的CallbackInfo是储存了Observer中方法信息的实例，我们只需要在使用的时候获取并调用其中的方法，所以ReflectiveGenericLifecycleObserver的onStateChange（）中调用mInfo.invokeCallbacks(source, event, mWrapped)执行相应的方法，对于添加执行的逻辑总结：

初始化State为INITIALIZED或Destroy状态
调用ClassesInfoCache.sInstance.getInfo（），遍历获取Observer中的所有注解、参数和方法，并对应储存
创建ObserverWithState保存状态和CallbackInfo

到此结束，执行的时候只是按照上面的执行逻辑取出存储的ObserverWithState中的信息，即可在生命周期改变时，提取储存的方法和注解，找到目标方法，执行我们注解的Observer中的逻辑了。