什么是LifeCycle

在官网的介绍中是这么说的

生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护

重点:响应生命周期状态的变化

为什么还需要LifeCycle

举个实际项目中的示例，比如写了一个 Manager,需要在

onCreate() 的时候 init 初始化
onStart() 的时候 start() 标记开始
onStop() 的时候 stop() 标记结束
onDestory() 的时候 relase() 回收资源

当这个manager 需要在 ActivityA ；ActivityB ActivityC 中都要使用，以前的做法，就需要在他们各自的生命周期中处理;例如下面的伪代码实现

public class ActivityA() : AppCompatActivity() {
    
    override fun onCreate(savedInstanceState: Bundle) {
        TestManager().getInstance().init()
    }

    override fun onStart() {
        TestManager().getInstance().start()
    }

    override fun onStop() {
        TestManager().getInstance().stop()
    }

    override fun onDestroy() {
        TestManager().getInstance().release()
    }
}

有多少个Activity 就需要做这样的示例代码多少次，先不说Lifeycle 的好处，光这样看，第一 代码冗余，第二 不利于拓展，第三，极大的加大了代码风险。

而使用 LifeCycle 就可以通过其 感知生命周期状态的变化 的能力，在 Manager 内部就做到

init()
release()
start()
stop()

public class Manager() : LifecycleObserver() {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    onCreate() {
        init()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    onStart() {
        start()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    onStop() {
        stop()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    onDestroy() {
        release()
    }
}

lifecycle的优点，这里我比较认可重学安卓：为你还原一个真实的 Jetpack Lifecycle 作者的观点

1.实现生命周期管理的一致性，做到 “一处修改、处处生效”。
2.让第三方组件能够随时在自己内部拿到生命周期状态，以便执行及时叫停错过时机的异步业务等操作。
3.让第三方组件在调试时能够更方便和安全地追踪到事故所在的生命周期源。

如何使用

在官方的使用生命周期感知型组件处理生命周期中也有详细的介绍

更佳推荐的方式

添加依赖

def lifecycle_version = "2.2.0"
// Annotation processor
kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
// alternately - if using Java8, use the following instead of lifecycle-compiler
implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

在 build.gralde 中添加kapt插件 'kotlin-kapt'

plugins {
    id 'com.android.library'
    id 'kotlin-android'
    id 'kotlin-android-extensions'
    id 'kotlin-kapt'
}

实现 DefaultLifecycleObserver 接口

class TestLifecycle : DefaultLifecycleObserver{
}

//添加即可
lifecycle.addObserver(TestLifecycle())

在 DefaultLifecycleObserver 中已经帮我们实现好了对应的生命周期

LifeCycle 是如何工作的

看到上面的使用方式，应该能够猜测到这就是就是设计模式中的观察者模式。带着这个设计模式的概念，我们想象一下，LifeCycle 的工作原理

需要有一个东西去保存所有的观察者
当观察者生命周期发生变化的时候需要去通知已经注册的观察者

如何添加观察者

带着我们想象的LifeCycle 去看一下他的源码，而lifeCycle 的入口就在 addObserver 这个方法

点击进入看一下，会发现这其实是一个抽象接口

public abstract class Lifecycle {
    //省略代码
    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    //省略代码
}

继续跟着这个方法去看他的具体实现，只有一个地方

public class LifecycleRegistry extends Lifecycle {
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        //省略代码
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
        //省略代码
    }
}

还记得我们的初心么，需要有一个东西去保存所有的观察者 看到上面的代码我们把观察者添加到了一个map 中

//LifecycleRegistry
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();

OK 看到这里我们的猜测完成了第一步

LifeCycle 通过 addObserver 将观察者保存在 LifecycleRegistry 中的 mObserverMap 中

LifecycleRegistry 在哪里创建的

继续看一下 LifecycleRegistry 这个类，既然是一个普通的java 类那么一定有一个地方去创建他，查找以后，会发现，他在 ComponentActivity 和 Fragment 中都有创建，

public class ComponentActivity extends Activity implements
        LifecycleOwner,
        KeyEventDispatcher.Component {

    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

}

public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
        ViewModelStoreOwner, SavedStateRegistryOwner {

    LifecycleRegistry mLifecycleRegistry;
    public Fragment() {
        initLifecycle();
    }

    private void initLifecycle() {
        mLifecycleRegistry = new LifecycleRegistry(this);
    }
}

看一下最上面写的示例

我们通过 lifecycle 调用 addObserver 方法添加观察者对象

lifecycle.addObserver(TestLifecycle())

获取到的 lifecycle 其实就是我们创建的 LifecycleRegistry 对象

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

到此我们得到第二个信息

LifeCycle 在 Fragment 或者 Activity 初始化的时候创建了LifecycleRegistry

LifeCycle 如何将生命周期变化通知观察者

既然 LifecycleRegistry 是纽带将 LifeCycle 和 Fragmet/Activity 联系在了一起，那Fragmet/Activity 生命周期变化时候，LifecycleRegistry 又做了什么呢

查看源码得知，在变化的时候 LifecycleRegistry 执行了 handleLifecycleEvent 方法。将 Fragmet 的生命周期通知到了 LifecycleRegistry，

Activity 则是在 FragmentActivity 中使用handleLifecycleEvent FragmentActivity 继承了 ComponentActivity

public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
        ViewModelStoreOwner, SavedStateRegistryOwner {
    LifecycleRegistry mLifecycleRegistry;

    void performCreate(Bundle savedInstanceState) {
        onCreate(savedInstanceState);
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }

    void performStart() {
        onStart();
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }

    void performResume() {
        onResume();
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    }    


    //上面都是先走生命周期，再走分发

    //下面都是先走分发，再走生命周期

    void performPause() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
        onPause();
    }    

    void performStop() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
        onStop();
    }    

    void performDestroy() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
        onDestroy();
    }    
}

看一下 handleLifecycleEvent 方法

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

//LifecycleRegistry
private void moveToState(State next) {
    //省略代码
    sync();
    //省略代码
}

//LifecycleRegistry
private void sync() {
    //省略代码
    //当前的观察者对象数量大于0 
    while (!isSynced()) {
        //省略代码
        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);
        }
    }
    //省略代码
}

//LifecycleRegistry
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();
        }
    }
}

//LifecycleRegistry

private void backwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
    //map 中多有的 LifecycleObserver 遍历
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
        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();
        }
    }
}

继续查看会发现在 ObserverWithState 这个类中所有的状态都在 LifecycleEventObserver 的 onStateChanged 接口中触发了

static class ObserverWithState {
    LifecycleEventObserver mLifecycleObserver;
    void dispatchEvent(LifecycleOwner owner, Event event) {
        //这里的接口
        mLifecycleObserver.onStateChanged(owner, event);
    }
}

示例中使用的 DefaultLifecycleObserver 继承自 FullLifecycleObserver,在onStateChanged 的时候，通过接口就将状态记录下来了

class FullLifecycleObserverAdapter implements LifecycleEventObserver {

    private final FullLifecycleObserver mFullLifecycleObserver;
    private final LifecycleEventObserver mLifecycleEventObserver;

    FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
            LifecycleEventObserver lifecycleEventObserver) {
        mFullLifecycleObserver = fullLifecycleObserver;
        mLifecycleEventObserver = lifecycleEventObserver;
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        switch (event) {
            case ON_CREATE:
                mFullLifecycleObserver.onCreate(source);
                break;
            case ON_START:
                mFullLifecycleObserver.onStart(source);
                break;
            case ON_RESUME:
                mFullLifecycleObserver.onResume(source);
                break;
            case ON_PAUSE:
                mFullLifecycleObserver.onPause(source);
                break;
            case ON_STOP:
                mFullLifecycleObserver.onStop(source);
                break;
            case ON_DESTROY:
                mFullLifecycleObserver.onDestroy(source);
                break;
            case ON_ANY:
                throw new IllegalArgumentException("ON_ANY must not been send by anybody");
        }
        if (mLifecycleEventObserver != null) {
            mLifecycleEventObserver.onStateChanged(source, event);
        }
    }
}

到这里我们又得到一个有用的信息

LifeCycle 通过 LifecycleRegistry handleLifecycleEvent 方法完成了生命周期变化的通知

放上一个时序图，能更加直观的看到每个生命周期做了生命

图片来自 Android 架构组件（一）——Lifecycle

分析LifeCycle 整体架构

全家福照片

图片来自 Android 架构组件（一）——Lifecycle

简要分析每个类的作用

方法	说明
Lifecycle	抽象类添加删除观察者，获取状态
LifecycleRegistry	继承Lifecycle 真正处理状态变化
ObserverWithState	静态类，保存了当前观察者的状态
Status	枚举类观察者的状态
Event	枚举类记录当前的生命周期状态

LifecyleObserver 全家福

Android LifeCycle 浅析