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的流程和原理。

结语

每当自己总结这些原理性的东西的时候，表达总是不够太好，感觉也有可能是自己理解还不是那么深刻的原因，学无止境，越往下学就越感觉到自己得无知，所以我也只是希望能通过这些细微得沉淀，慢慢让自己形成一个大的知识体系吧。