JetPack：Lifecycle
前言
因为最近没有什么项目，所以有时间研究了一下Andorid得JetPack，打开Android开发这平台，找到JetPack专栏，可以看到这样得介绍：
Jetpack 是一套库、工具和指南，可帮助开发者更轻松地编写优质应用。这些组件可帮助您遵循最佳做法、让您摆脱编写样板代码的工作并简化复杂任务，以便您将精力集中放在所需的代码上。
Jetpack 包含与平台 API 解除捆绑的 androidx.* 软件包库。这意味着，它可以提供向后兼容性，且比 Android 平台的更新频率更高，以此确保您始终可以获取最新且最好的 Jetpack 组件版本。
附上链接：https://developer.android.google.cn/jetpack
简而言之，JetPack就是Google为了规范Android开发，解决之前Android开发各种库使用碎片化得问题，提出来的一套数据库，生命周期管理等等一整套完整得库，可以这样说，当时真正走进JetPack得时候，只有两个字 ’真香’
本文是JetPack得一个系列，首先介绍一下最常用得库Lifecycle
Lifecycle篇
一 什么是Lifecycle
学习Lifecycle之前，首先我们应该明白什么是Lifecycle，学习一个东西最好的办法就是去看官方文档，打开Lifecycle专栏，可以看到如下几个大字来介绍Lifecycle：
使用生命周期感知型组件处理生命周期
其实就是运用观察者模式，来观察Acitivity，Fragment等具有生命周期得控件，好处就是优化我们代码，避免内存泄漏等一系列得问题。
二 如何使用Lifecycle
Lifecycle得使用其实很简单，LifecycleObserver观察者，LifecycleOwner被观察者，只需要观察者去订阅被观察者就行。
1，观察者实现LifecycleObserver, 创建需要感知得生命周期方法，并加上@OnLifecycleEvent注解
public class BasePresenter<T extends IBaseView> implements LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
void onCreateX(LifecycleOwner owner) {
}
}
2, 被观察者实现LifecycleOwner接口，因为Activity最终父类ComponentActivity实现了LifecycleOwner接口，所以任意Activity在Lifecycle框架中都是一个被观察者。
3，建立订阅关系：
protected void init() {
activity.getLifecycle().addObserver(BasePresenter);
}
只需要以上3步，观察者就可以感知到被观察者得生命周期，是不是非常简单实用。
三 Lifecycle得原理
在通常开发中，一般我们掌握如何使用就可以开始开发了，但是作为一个努力进步得程序员，知其然也要知其所以然是我们拔高得必走之路，源码虽然枯燥，但是了解源码得思想也是非常重要得一步。让我们一起看看Lifecyle是如何关联生命周期得：
1，首先我们来看ComponentActivity，因为ComponentActivity实现LifecycleOwner接口，所以让应用运行时，肯定会先走ComponentActivity得onCreate，查看onCreate获取可以找到答案(以下代码只贴上关键代码)：
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ReportFragment.injectIfNeededIn(this);
}
public static void injectIfNeededIn(Activity activity) {
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();
}
}
让我们点开injectIfNeededIn方法，该方法创建了一个没有界面得ReportFragment，查看ReportFragment可以发现，该Fragment关联者Activity得生命周期，切在每个生命周期方法中都会调用dispatch()方法，所以我们可以继续往下跟：
private void dispatch(Lifecycle.Event event) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
}
看到目前为止，我们应该知道一件事情，那就是在ComponentActivity中创建了一个没有界面得Fragment关联这activity生命周期，且每个生命周期方法都调用了 dispatch方法。
所以我们继续查看dispatch：
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
private void moveToState(State next) {
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) {
backwardPass(lifecycleOwner);
}
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
}
}
看到这里可以看到两个方法backwardPass(),forwardPass(),其实这两个方法做了同一个事情，同步状态。
在Lifecycle中维护了一组枚举类型，Event和State
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;
}
}
而我们在上面看到得disPatch就是为了让二者状态统一
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;
}
明白这个状态以后我们继续玩下看：forwardPass();
private void forwardPass(LifecycleOwner lifecycleOwner) {
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();
}
}
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
@Override
public void onStateChanged(LifecycleOwner source, Event event) {
mInfo.invokeCallbacks(source, event, mWrapped);
}
看到invokeCallbacks，我们就可以猜测是通过反射来获取生命周期得方法，然后调用方法，往下跟：
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;
}
}
看到这里被观察者所做的逻辑基本清楚了，利用放射原理，然后判断方法对应的参数有几个，调用对应的方法，是的观察者中的回到被调用！
而我们的反射得到的参数和方法是哪里来的呢，接下来带着这个疑问，让我们看一下getLifecycle().addObserver(presenter);订阅事件到底做了什么：
public void addObserver(@NonNull LifecycleObserver observer) {
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
调用addObserver方法，首先记录当前的状态，然后嗲这状态信息和被观察者包装到ObserverWithState中，
然后我们看看ObserverWithState类：
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = getStateAfter(event);
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
是不是很熟悉，在上面的forwardPass方法中最终的回调也是到这里。
在订阅的时候，我们把被观察者信息，和状态存到ObserverWithState中并调用了lifecycleEventObserver
lifecycleEventObserver中，最终会调用到createInfo方法：
for (Method method : methods) {
OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
Class<?>[] params = method.getParameterTypes();
int callType = CALL_TYPE_NO_ARG;
if (params.length > 0) {
callType = CALL_TYPE_PROVIDER;
}
Lifecycle.Event event = annotation.value();
if (params.length > 1) {
callType = CALL_TYPE_PROVIDER_WITH_EVENT;
}
}
在这个方法中，会通过method.getAnnotation(OnLifecycleEvent.class); 判断是不是Lifecycle订阅的注解，然后获取每个方法的参数并赋值给callType = CALL_TYPE_PROVIDER; 然后在invokeCallbacks中调用。
以上就是整个Lifecycle的流程和原理。
结语
每当自己总结这些原理性的东西的时候，表达总是不够太好，感觉也有可能是自己理解还不是那么深刻的原因，学无止境，越往下学就越感觉到自己得无知，所以我也只是希望能通过这些细微得沉淀，慢慢让自己形成一个大的知识体系吧。
