一、前言

Lifecycle 生命周期感知控件属于谷歌在2018推出Android jetpack(外网)其中的软件架构组件中的一个。在谷歌开发者网站有介绍Lifecycle(外网)。本文指在介绍Lifecycle的使用。让你快速理解并上手Lifecycle库。虽然Lifecycle很简单，但我们还是应该仔细品一品。因为jetpack中太多库依赖这种声明周期管理了。

二、Lifecycle

谷歌爸爸是这么说的：生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。
简单理解下：把声明周期用观察者模式来监听。把以前跟声明周期相关操作代码提出来写。
在介绍Lifecycle的两种用法前，我们需要先导入。其它用法请参看Lifecycle 版本说明(外网)

// Lifecycles only (without ViewModel or LiveData)
implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

基本使用

三个步骤就可以使用起来了，就是普通观察者模式的三个步骤。
1、创建一个被观察者Lifecycle对象
2、创建一个或多个观察者LifecycleObserver对象
3、Lifecycle.addObserver把一个或多个LifecycleObserver观察者添加
第一步：创建Lifecycle

public class MyActivity extends Activity implements LifecycleOwner {

    private LifecycleRegistry mLifecycleRegistry;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mLifecycleRegistry = new LifecycleRegistry(this);
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    protected void onStart() {
        super.onStart();
        mLifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mLifecycleRegistry.markState(Lifecycle.State.DESTROYED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

• Lifecycle是一个抽象类，LifecycleRegistry就是它的一个具体实现
• LifecycleOwner接口，就定义了一个getLifecycle，方便获取被观察者。它存在的意义表示你的Activity或者Fragement具有Lifecycle特性。很多依赖Lifecycle的组件就是通过这里来判断的。
• mLifecycleRegistry.markState为了绑定状态，绑定了才好通知观察者
  第二步：创建LifecycleObserver观察者

public class MyObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void start() {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void destroy() {

    }
}

• LifecycleObserver是一个空接口，目的是为了方便注解使用
  第三步：添加观察者

mLifecycleRegistry.addObserver(new MyObserver());
if (mLifecycleRegistry.getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
    // do...
}

• addObserver添加就能监听了
• getCurrentState().isAtLeast提供了状态的查询
  State和Event对应关系
  三个步骤就完了，比较简单。细心的同学发现了，我们mark的时候状态是Lifecycle.State。而在观察者状态是Lifecycle.Event那么他们的对应关系如下图：
  
  关系图

常规情况
上面讲的用法是我们使用的普通的Activity，而实际开发的时候，我们经常使用的是MainActivity extends AppCompatActivity而AppCompatActivity已经默认为我们实现了Lifecycle。所以我们可以少些上面的第一步直接在MainActivity中使用getLifecycle()获取被观察者Lifecycle对象
再者如果你引用的是androidx中的Activity和Fragment他们也实现了Lifcycle的代码。

三、原理

对原理没兴趣的同学可以直接跳过这一节。
Lifecycle的运行机制也比较简单，无非就是观察者模式的惯用套路。我们也按步骤来解析
先看LifecycleRegistry.java

@Deprecated
    @MainThread
    public void markState(@NonNull State state) {
        setCurrentState(state);
    }

@MainThread
    public void setCurrentState(@NonNull State state) {
        moveToState(state);
    }

private void moveToState(State next) {
        ...
        sync();
       ...
    }

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);
            }
        }
        mNewEventOccurred = false;
    }

 private void forwardPass(LifecycleOwner lifecycleOwner) {
        Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
                mObserverMap.iteratorWithAdditions();
        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
            Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
            ObserverWithState observer = entry.getValue();
            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                    && mObserverMap.contains(entry.getKey()))) {
                pushParentState(observer.mState);
                observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
                popParentState();
            }
        }
    }

• 1.我们再Activity里调用martState的时候就是响应的时候
• 2.根据martState的调用顺序，最后走到了backwardPass和forwardPass他们类似
• 3.在forwardPass里，它遍历了观察者，调用了观察者的dispatchEvent方法。

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;
        }
    }

• 这里主要两点Lifecycling.lifecycleEventObserver和onStateChanged，而lifecycleEventObserver主要生成注解解析相关类

@NonNull
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        ...
        return new ReflectiveGenericLifecycleObserver(object);
    }

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    private final Object mWrapped;
    private final CallbackInfo mInfo;

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

    @Override
    public void onStateChanged(LifecycleOwner source, Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}

通过反射调用就响应到了我们的方法上。

四、写在最后

简单的来看，Lifecycle通过观察者模式独立了生命周期的感知功能。一者方便了我们独立的使用。二者也给一些需要生命周期感知的其它的组件提供了基础。还是挺有意思的一个组件。