对于 LifeCycle 组件还不了解的同学，可以先阅读这篇文章：

学习问题

LifeCycle 是如何监听到 Activity/Fragment 生命周期变化的？
LifeCycle 如何将生命周期变化的事件分发给观察者的？

本文目录

一、四个重要的类

（一）Lifecycle

Lifecycle 是一个抽象类。它内部定义了两个枚举：Event 需要分发的事件的类型，State 宿主的状态。

1.Event

public enum Event {
   
   
    //对应于宿主（实现了LifecycleOwner的类）的 onCreate 方法
    ON_CREATE,

    //对应于宿主（实现了LifecycleOwner的类）的 onStart 方法
    ON_START,

    //对应于宿主（实现了LifecycleOwner的类）的 onResume 方法
    ON_RESUME,

    //对应于宿主（实现了LifecycleOwner的类）的 onPause 方法
    ON_PAUSE,

    //对应于宿主（实现了LifecycleOwner的类）的 onStop 方法
    ON_STOP,

    //对应于宿主（实现了LifecycleOwner的类）的 onDestroy 方法
    ON_DESTROY,

    //可以匹配宿主的所有生命周期事件
    ON_ANY
}

各个生命周期事件分发的时机：

ON_CREATE、ON_START 和 ON_RESUME：这三个生命周期事件是在宿主相应的生命周期方法 执行完成之后 被分发。

ON_PAUSE、ON_STOP 和 ON_DESTROY：这三个生命周期事件是在宿主相应的生命周期方法 被调用之前 分发。

2.State

public enum State {
   
   

    //已销毁状态。以 Activity 为例，在回调 Activity 的 onDestroy 方法之前，宿主会达到此状态。
    DESTROYED,

    //已初始化状态。在回调 onCreate 方法之前的一种状态。
    INITIALIZED,

    //已创建状态。两种情况下回处于这种状态：
    //1.宿主的 onCreate 方法执行之后
    //2.宿主的 onStop 方法调用之前
    CREATED,

    //可见状态。两种情况下回处于这种状态：
    //1.宿主的 onStart 方法执行之后
    //2.宿主的 onPause 方法调用之前
    STARTED,

    //聚焦（可交互状态）。宿主执行了 onResume 方法后处于该状态。
    RESUMED;

    public boolean isAtLeast(@NonNull State state) {
   
   
        return compareTo(state) >= 0;
    }
}

3.Event 和 State 的对应关系

（二）LifecycleRegistry

它是 Lifecycle 的唯一实现类。主要用来注册观察者（LifecycleObserver），以及分发宿主状态给它们（可以处理多个观察者）。

（三）LifecycleOwner

用来声明它是一个能够提供生命周期事件的宿主，Activity/Fragment 都实现了该接口。内部只有一个 getLifecycle 方法。

public interface LifecycleOwner {
   
   
    @NonNull
    Lifecycle getLifecycle();
}

（四）LifecycleObserver

用来定义观察者。

二、四个类之间的关系

LifeCycle 类关系图

说明：

Activity/Fragment 都默认实现了 LifecycleOwner 接口；
LifecycleRegistry 是 Lifecycle 唯一的实现类；
实现观察者（Observer）有三种方式：
- LifecycleObserver 配合 @OnLifecycleEvent 注解
- DefaultLifecycleObserver 拥有宿主所有生命周期事件
- LifecycleEventObserver 将宿主生命周期事件封装成 Lifecycle.Event
在 Activity/Fragment 中通过 getLifecycle() 方法获取到一个 LifecycleRegistry 对象；
通过调用 LifecycleRegistry 对象的 addObserver() 添加一个观察者（该观察者通过三种方式实现都可以）。

三、Fragment 如何实现 LifyCycle

在 Fragment 各个生命周期方法内部会利用 LifecycleRegistry 进行相应的事件分发。

public class Fragment implements LifecycleOwner {
   
   

    LifecycleRegistry mLifecycleRegistry;

    void performCreate(Bundle savedInstanceState) {
   
   
        onCreate(savedInstanceState);
        //ON_CREATE 事件在执行了 onCreate 方法之后分发 
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }

    void performStart() {
   
   
        onStart();
        //ON_START 事件在执行了 onStart 方法之后分发
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }

    void performResume() {
   
   
        onResume();
        //ON_RESUME 事件在执行了 onResume 方法之后分发
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    }

    void performPause() {
   
   
        //ON_PAUSE 事件在执行 onPause 方法执行之前分发
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
        onPause();
    }

    void performStop() {
   
   
        //ON_STOP 事件在执行 onStop 方法执行之前分发
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
        onStop();
    }

    void performDestroy() {
   
   
        //ON_DESTROY 事件在执行 onDestroy 方法执行之前分发
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
        onDestroy();
    }
}

四、Activity 如何实现 LifyCycle

Activity 实现 Lifecycle 需要借助于 ReportFragment 往 Activity 上添加一个 fragment。ReportFragment 没有任何的页面，它只负责在生命周期变化时利用 LifecycleRegistry 进行相应事件的分发。

之所以需要借助 ReportFragment ，目的是为了兼顾不是继承自 AppCompactActivity 的场景，同时也支持我们自定义 LifecycleOwner 的场景。

（一）ComponentActivity 的源码分析

以下是 ComponentActivity 的源码，在 onCreate 方法中往 Activity 里面添加了一个 fragment。

public class ComponentActivity extends Activity implements LifecycleOwner {
   
   

    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @SuppressLint("RestrictedApi")
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
   
   
        super.onCreate(savedInstanceState);
        //添加一个 fragment
        ReportFragment.injectIfNeededIn(this);
    }
}

补充一下 Activity 的继承关系：

（二）ReportFragment 的源码分析

下面来看看 ReportFragment 的源码。在 ReportFragment 中最主要的一个方法是 injectIfNeededIn。

public class ReportFragment extends Fragment {
   
   

    ...

    public static void injectIfNeededIn(Activity activity) {
   
   
        //1.如果 API >= 29 ,注册 ActivityLifecycleCallbacks
        if (Build.VERSION.SDK_INT >= 29) {
   
   
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }

        //2.添加一个 ReportFragment 到 Activity 中
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
   
   
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }

    ...

injectIfNeededIn 方法会做两件事情：

1.判断当前的 API Level，根据 API Level 选择监听 Activity 生命周期的时机和方式

（1）API Level >= 29

如果大于等于 29 的话，会注册一个 ActivityLifecycleCallbacks，

if (Build.VERSION.SDK_INT >= 29) {
   
   
    activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
}

ActivityLifecycleCallbacks 是 Application 的一个内部接口。

public interface ActivityLifecycleCallbacks {
   
   
        void onActivityCreated(@NonNull Activity activity, @Nullable Bundle savedInstanceState);
        void onActivityStarted(@NonNull Activity activity);
        void onActivityResumed(@NonNull Activity activity);
        void onActivityPaused(@NonNull Activity activity);
        void onActivityStopped(@NonNull Activity activity);
        void onActivityDestroyed(@NonNull Activity activity);
    }

以 Activity 的 onResume() 生命周期为例，如果我们注册了 ActivityLifecycleCallbacks，Android 系统会先回调 ActivityLifecycleCallbacks 的 onActivityResumed 方法，然后才执行 Android 本身的 onResume() 方法。

利用这个特点，我们可以注册一个自定义的 ActivityLifecycleCallbacks，在自定义的 ActivityLifecycleCallbacks 添加分发生命周期事件的逻辑来通知观察者：

public class ReportFragment extends Fragment {
   
   

    public static void injectIfNeededIn(Activity activity) {
   
   
        if (Build.VERSION.SDK_INT >= 29) {
   
   
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }

        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
   
   
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }

    @SuppressWarnings("deprecation")
    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
   
   
        ...

        if (activity instanceof LifecycleOwner) {
   
   
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
   
   
                //最终还是通过 LifecycleRegistry 来处理事件的分发
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

    //自定义 ActivityLifecycleCallbacks 来处理生命周期事件的分发，通知观察者
    static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
   
   

        ...

        @Override
        public void onActivityPostCreated(@NonNull Activity activity,
                @Nullable Bundle savedInstanceState) {
   
   
            //分发 ON_CREATE 事件
            dispatch(activity, Lifecycle.Event.ON_CREATE);
        }

        @Override
        public void onActivityPostStarted(@NonNull Activity activity) {
   
   
            //分发 ON_START 事件
            dispatch(activity, Lifecycle.Event.ON_START);
        }

        @Override
        public void onActivityPostResumed(@NonNull Activity activity) {
   
   
            //分发 ON_RESUME 事件
            dispatch(activity, Lifecycle.Event.ON_RESUME);
        }

        @Override
        public void onActivityPrePaused(@NonNull Activity activity) {
   
   
            //分发 ON_PAUSE 事件
            dispatch(activity, Lifecycle.Event.ON_PAUSE);
        }

        @Override
        public void onActivityPreStopped(@NonNull Activity activity) {
   
   
            //分发 ON_STOP 事件
            dispatch(activity, Lifecycle.Event.ON_STOP);
        }

        @Override
        public void onActivityPreDestroyed(@NonNull Activity activity) {
   
   
            //分发 ON_DESTROY 事件
            dispatch(activity, Lifecycle.Event.ON_DESTROY);
        }

        ...

    }
}

（2）API Level < 29

对于 API 小于 29 的情况，它的实现方式和 Fragment 的实现是一样的，在各个生命周期方法内利用 LifecycleRegistry 分发相应的 Lifecycle.Event 事件给每个观察者：

public class ReportFragment extends Fragment {
   
   

    public static void injectIfNeededIn(Activity activity) {
   
   
        if (Build.VERSION.SDK_INT >= 29) {
   
   
            activity.registerActivityLifecycleCallbacks(
                    new LifecycleCallbacks());
        }

        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
   
   
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
   
   
        super.onActivityCreated(savedInstanceState);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @Override
    public void onStart() {
   
   
        super.onStart();
        dispatch(Lifecycle.Event.ON_START);
    }

    @Override
    public void onResume() {
   
   
        super.onResume();
        dispatch(Lifecycle.Event.ON_RESUME);
    }

    @Override
    public void onPause() {
   
   
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }

    @Override
    public void onStop() {
   
   
        super.onStop();
        dispatch(Lifecycle.Event.ON_STOP);
    }

    @Override
    public void onDestroy() {
   
   
        super.onDestroy();
        dispatch(Lifecycle.Event.ON_DESTROY);
    }

    private void dispatch(@NonNull Lifecycle.Event event) {
   
   
        //在此处判断一下 API ，避免重复分发事件
        if (Build.VERSION.SDK_INT < 29) {
   
   
            dispatch(getActivity(), event);
        }
    }
}

2.在 injectIfNeededIn 中会创建一个 ReportFragment 添加到 Activity 中

public class ReportFragment extends Fragment {
   
   

    public static void injectIfNeededIn(Activity activity) {
   
   

        ...

        //往 Activity 中添加一个 ReportFragment
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
   
   
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            manager.executePendingTransactions();
        }
    }
}

五、LifecycleRegistry 源码分析

从前文的分析中，我们知道了 Activity/Fragment 是如何去实现 LifeCycle 的，对于生命周期事件的分发，它们最终都是交给了 LifecycleRegistry 去处理，因此，我们有比较去了解一下 LifecycleRegistry 内部的工作机制。

（一）addObserver() 源码分析

LifeCycle 是通过观察者模式去实现的，添加一个观察者的方式是调用 addObserver() 方法：

getLifecycle().addObserver(observer);

先来看一下完整的 addObserver() 方法：

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

        if (previous != null) {
   
   
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
   
   
            // it is null we should be destroyed. Fallback quickly
            return;
        }

        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
   
   
            pushParentState(statefulObserver.mState);
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
   
   
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }

下面，我们逐行代码来分析：

1.首先确定新添加的 Observer 的初始化状态

State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;

只要当前宿主的状态不是 DESTROYED，那么它的初始状态都是 INITIALIZED。

2.将 Observer 包装成 ObserverWithState

ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);

ObserverWithState 表示带有状态的 Observer，这个类后文会详细分析。

3.将 Observer 添加到集合中

ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

if (previous != null) {
   
   
    return;
}

通过 putIfAbsent() 方法将 ObserverWithState 添加到集合中，如果之前已经添加过了，putIfAbsent() 方法会直接返回之前添加过的 ObserverWithState，此时，程序会直接 return。

4.利用一个 while 循环将观察者和宿主的状态进行对齐

//首先计算出观察者应该达到的状态
State targetState = calculateTargetState(observer);
//通过 compareTo 方法，将观察者的状态和宿主当前状态做比较，如果小于0，说明两者状态还没有对齐
while ((statefulObserver.mState.compareTo(targetState) < 0
        && mObserverMap.contains(observer))) {
   
   
    pushParentState(statefulObserver.mState);
    //执行一次事件分发
    statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
    popParentState();
    //计算观察者下一个应该到达的状态，在下次循环中观察者状态还会与之对比，直到状态对齐，退出循环
    targetState = calculateTargetState(observer);
}

根据 while 循环的逻辑，我们可以得出一个结论：

在 Activity/Fragment 的任意生命周期方法内注册观察者都能接收到完整的生命周期事件。

比如，我们在 onResume() 方法内注册观察者：

while 第一次循环：分发 on_Create 事件，观察者状态 INITIALIZED -> CREATED
while 第二次循环：分发 on_Start 事件，观察者状态 CREATED -> STARTED
while 第三次循环：分发 on_Resume 事件，观察者状态 STARTED -> RESUMED

不过，建议最好是在 onCreate 方法中进行注册。

关于使用 compareTo 比较两个枚举值，请参考文章：

Java 枚举比较

（二）handleLifecycleEvent() 源码分析

handleLifecycleEvent() 方法主要是负责宿主生命周期变化后相应的事件分发。

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

1.首先根据需要分发的事件，获取宿主当前处于什么状态

假设分发的是 ON_START 事件，那么根据 getStateAfter() 方法我们可以知道，宿主当前是处于 STARTED 状态。

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

2.根据第一步获取的宿主状态设置当前的状态并通知观察者

private void moveToState(State next) {
   
   
        if (mState == next) {
   
   
            return;
        }
        //设置当前状态
        mState = next;

        ...

        //通知观察者
        sync();
    }

下面来看一下 sync 方法：

private void sync() {
   
   

    while (!isSynced()) {
   
   

        //如果宿主当前的状态 小于 mObserverMap 集合中最先添加的那个观察者的状态
        //则说明宿主可能发生了状态回退，比如当前是 RESUMED 状态，执行了onPause 则回退到STARTED 状态
        //此时调用 backwardPass 给集合中的每个一观察者分发一个 on_pause 事件，并同步它的状态。
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
   
   
            backwardPass(lifecycleOwner);
        }

        //如果宿主当前状态 大于 mObserverMap 集合中最先添加的那个观察者的状态
        //则说明宿主可能发生了状态前进，比如当前是 STARTED 状态，执行了onResume 则前进到RESUMED 状态
        //此时调用 forwardPass 给集合中的每个一观察者分发一个 on_resume 事件，并同步它的状态。
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
   
   
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

（三）ObserverWithState 源码分析

ObserverWithState 是 LifecycleRegistry 中持有观察者及其状态的内部类。

static class ObserverWithState {
   
   
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    //把传入的 LifecycleObserver 适配成 LifecycleEventObserver，目的是为了统一事件的分发形式。
    //在之前的文章里介绍过实现观察者有三种形式，每一种接收的事件类型都不一样，如果在分发的时候不统一事件分发的形式，将会变得很麻烦
    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;
    }
}

Jetpack 之 LifeCycle 组件原理解析