Lifecycle 源码解析（2.4.1 版本）

1、Lifecycle 简介

• Android Jetpack 库中的一员，具备宿主生命周期感知能力的组件，它能持有组件（如 Activity、Fragment）生命周期状态信息，并且允许其它观察者监听宿主的状态。
• 官方网站
• 官方文档

2、Lifecycle 配置与基本用法

2.1 依赖引入与配置

• 正常情况下无需单独引入 Lifecycle 相关库，因为androidx.appcompat:appcompat:1.4.1会自带 Lifecycle、LiveData、ViewModel 等依赖库。
• 如果想单独引入 Lifecycle 或者其其它相关扩展库可如下操作：

// 模块的 build.gradle
// 只有 Lifecycles（不带 ViewModel 或 LiveData）
implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.4.1'
// 注释处理器
kapt 'androidx.lifecycle:lifecycle-compiler:2.4.1'
// 替换 - 如果使用 Java8，请使用此注释处理器，而不是 lifecycle-compiler 注释处理器
implementation 'androidx.lifecycle:lifecycle-common-java8:2.4.1'
// 可选 - 在 Service 中实现 LifecycleOwner 的助手
implementation 'androidx.lifecycle:lifecycle-service:2.4.1'
// 可选 - ProcessLifecycleOwner 给整个 App 前后台切换提供生命周期监听
implementation 'androidx.lifecycle:lifecycle-process:2.4.1'

// LiveData
implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.4.1'
// 可选：对 LiveData 的 ReactiveStreams 支持
implementation 'androidx.lifecycle:lifecycle-reactivestreams-ktx:2.4.1'
// 可选 - LiveData 的测试助手
testImplementation 'androidx.arch.core:core-testing:2.1.0'

// ViewModel
implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.4.1'
// 用于 Compose 的 ViewModel 实用程序
implementation 'androidx.lifecycle:lifecycle-viewmodel-compose:2.4.1'
// ViewModel 的已保存状态模块
implementation 'androidx.lifecycle:lifecycle-viewmodel-savedstate:2.4.1'

2.2 基本用法

2.2.1 Lifecycle 简单使用

/**
 * 方式一：观察宿主的状态
 *
 * @Description: 自定义的 DefaultLifecycleObserver 观察者，用注解声明每个方法观察的宿主的状态
 */
class TestObserver : DefaultLifecycleObserver {

    override fun onCreate(owner: LifecycleOwner) {
        super.onCreate(owner)
        Log.d("TestObserver", "onCreate: ")
    }

    override fun onStart(owner: LifecycleOwner) {
        super.onStart(owner)
        Log.d("TestObserver", "onStart: ")
    }

    override fun onResume(owner: LifecycleOwner) {
        super.onResume(owner)
        Log.d("TestObserver", "onResume: ")
    }

    override fun onPause(owner: LifecycleOwner) {
        super.onPause(owner)
        Log.d("TestObserver", "onPause: ")
    }

    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        Log.d("TestObserver", "onStop: ")
    }

    override fun onDestroy(owner: LifecycleOwner) {
        super.onDestroy(owner)
        Log.d("TestObserver", "onDestroy: ")
    }
}

/**
 * 方式二：观察的宿主的状态
 *
 * @Description: 自定义的 DefaultLifecycleObserver 观察者，用注解声明每个方法观察的宿主的状态
 * @Author: xing.tang
 */
class TestEventObserver : LifecycleEventObserver {

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_CREATE -> {
                Log.d("TestEventObserver", "ON_CREATE: ")
            }
            Lifecycle.Event.ON_START -> {
                Log.d("TestEventObserver", "ON_START: ")
            }
            Lifecycle.Event.ON_RESUME -> {
                Log.d("TestEventObserver", "ON_RESUME: ")
            }
            Lifecycle.Event.ON_PAUSE -> {
                Log.d("TestEventObserver", "ON_PAUSE: ")
            }
            Lifecycle.Event.ON_STOP -> {
                Log.d("TestEventObserver", "ON_STOP: ")
            }
            Lifecycle.Event.ON_DESTROY -> {
                Log.d("TestEventObserver", "ON_DESTROY: ")
            }
        }
    }
}

// 调用
class TestActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_test)
        // 方式一：观察宿主的生命周期状态
        lifecycle.addObserver(TestObserver())
        // 方式二：观察宿主的生命周期状态的两种写法
        lifecycle.addObserver(Test3EventObserver())
        lifecycle.addObserver(LifecycleEventObserver { source, event ->
            when (event) {
                Lifecycle.Event.ON_START -> {
                    Log.d("TestActivity", "ON_START: ")
                }
                Lifecycle.Event.ON_STOP -> {
                    Log.d("TestActivity", "ON_STOP: ")
                }
            }
        })
    }
}

2.2.2 普通 Activity 实现 Lifecycle

class TestActivity : Activity(), LifecycleOwner {

    private lateinit var mLifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mLifecycleRegistry = LifecycleRegistry(this)
        mLifecycleRegistry.currentState = Lifecycle.State.CREATED
        lifecycle.addObserver(LifecycleEventObserver { source, event ->
            when (event) {
                Lifecycle.Event.ON_START -> {
                    Log.d("TestActivity", "ON_START: ")
                }
                Lifecycle.Event.ON_STOP -> {
                    Log.d("TestActivity", "ON_STOP: ")
                }
            }
        })
    }

    override fun getLifecycle(): Lifecycle {
        return mLifecycleRegistry
    }

    override fun onStart() {
        super.onStart()
        mLifecycleRegistry.currentState = Lifecycle.State.STARTED
    }

    override fun onPause() {
        super.onPause()
        mLifecycleRegistry.currentState = Lifecycle.State.STARTED
    }

    override fun onDestroy() {
        super.onDestroy()
        mLifecycleRegistry.currentState = Lifecycle.State.DESTROYED
    }
}

2.2.3 ProcessLifecycleOwner 实现前后台切换

• 使用 ProcessLifecycleOwner 可以直接获取应用前后台切换状态（记得引入lifecycle-process依赖）

class MyApplication : Application() {

    override fun onCreate() {
        super.onCreate()
        // 注册 App 生命周期观察者
        ProcessLifecycleOwner.get().lifecycle.addObserver(ApplicationLifecycleObserver())
    }

    /**
     * Application 生命周期观察，提供整个应用进程的生命周期
     * 作用：监听应用程序进入前台或后台
     */
    private class ApplicationLifecycleObserver : LifecycleEventObserver {
        override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
            when (event) {
                Lifecycle.Event.ON_START -> {
                    Log.d("MyApplication", "onStateChanged: 应用程序移至前台")
                }
                Lifecycle.Event.ON_STOP -> {
                    Log.d("MyApplication", "onStateChanged: 应用程序移至后台")
                }
            }
        }
    }
}

3、Lifecycle 源码解析

3.1 Fragment 实现 Lifecycle

// Fragment.java
public class Fragment implements ComponentCallbacks, View.OnCreateContextMenuListener, LifecycleOwner,
        ViewModelStoreOwner, HasDefaultViewModelProviderFactory, SavedStateRegistryOwner,
        ActivityResultCaller {
    ...

    LifecycleRegistry mLifecycleRegistry;

    public Fragment() {
        initLifecycle();
    }

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

    @Override
    @NonNull
    public Lifecycle getLifecycle() {
        // 复写自 LifecycleOwner，所以必须创建 LifecycleRegistry 并返回
        return mLifecycleRegistry;
    }

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

    void performStart() {
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
        if (mView != null) {
            mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_START);
        }
    }
    .....

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

3.2 Activity 实现 Lifecycle

• 在介绍 Activity 实现 Lifecycle 之前，先简单了解下几个核心角色：
• Lifecycle：一个抽象类，持有组件生命周期状态（如 Activity 或 Fragment）的信息的类，并允许其他对象观察此状态。其宿主生命周期与宿主状态的对应关系如下：
  
• LifecycleOwner：Lifecycle 被观察者（持有者），实现该接口的类持有生命周期（Lifecycle 对象），该接口的生命周期（Lifecycle 对象）的改变会被其注册的观察者 LifecycleObserver 观察到并触发其对应的事件。
• LifecycleObserver：Lifecycle 观察者，实现该接口的类，可以通过被 LifecycleOwner 类的 addObserver() 方法注册，被注册后 LifecycleObserver 便可以观察到 LifecycleOwner 的生命周期事件。
• LifycycleRegistry：Lifecycle 是一个抽象类，其唯一实现类是 LifecycleRegistry，用来管理观察者和被观察者，并处理来自 LifeCycleOwner 的事件，然后再进行状态同步并通知所有的观察者。

// ComponentActivity.java
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner,
        ActivityResultRegistryOwner,
        ActivityResultCaller {
    ...
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        mSavedStateRegistryController.performRestore(savedInstanceState);
        mContextAwareHelper.dispatchOnContextAvailable(this);
        super.onCreate(savedInstanceState);
        // 通过 ReportFragment 来实现 ComponentActivity 对其的生命周期感知能力
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
            setContentView(mContentLayoutId);
        }
    }

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

• 由上述可知 ComponentActivity 是通过 ReportFragment 来实现对应其的生命周期感知能力，接着我们来看看 ReportFragment 源码。

// ReportFragment.java
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
public class ReportFragment extends android.app.Fragment {
    private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";

    public static void injectIfNeededIn(Activity activity) {
        // 如果是 Android 10 及以上，通过 registerActivityLifecycleCallbacks 的方式来实现生命周期的回调
        if (Build.VERSION.SDK_INT >= 29) {
            androidx.lifecycle.ReportFragment.LifecycleCallbacks.registerIn(activity);
        }
        // 在 API 29 之前，向 Activity 添加一个不可见的的 Fragment，以此来获取 Activity 的生命周期事件正确回调 的生命周期事件正确回调
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            // 将 Fragment 添加到 Activity
            manager.beginTransaction().add(new androidx.lifecycle.ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }

    // 分发 Lifecycle Event 事件
    @SuppressWarnings("deprecation")
    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

    static androidx.lifecycle.ReportFragment get(Activity activity) {
        return (androidx.lifecycle.ReportFragment) activity.getFragmentManager().findFragmentByTag(
                REPORT_FRAGMENT_TAG);
    }

    private androidx.lifecycle.ReportFragment.ActivityInitializationListener mProcessListener;

    private void dispatchCreate(androidx.lifecycle.ReportFragment.ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onCreate();
        }
    }

    private void dispatchStart(androidx.lifecycle.ReportFragment.ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onStart();
        }
    }

    private void dispatchResume(androidx.lifecycle.ReportFragment.ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onResume();
        }
    }

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

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

    @Override
    public void onResume() {
        super.onResume();
        dispatchResume(mProcessListener);
        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);
        // just want to be sure that we won't leak reference to an activity
        mProcessListener = null;
    }

    private void dispatch(@NonNull Lifecycle.Event event) {
        if (Build.VERSION.SDK_INT < 29) {// 在 API 29 之前，用次方法分发事件
            dispatch(getActivity(), event);
        }
    }

    void setProcessListener(androidx.lifecycle.ReportFragment.ActivityInitializationListener processListener) {
        mProcessListener = processListener;
    }

    interface ActivityInitializationListener {
        void onCreate();

        void onStart();

        void onResume();
    }

    // 如果是 Android 10 及以上，通过 registerActivityLifecycleCallbacks 的方式来实现生命周期的回调
    @RequiresApi(29)
    static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {

        static void registerIn(Activity activity) {
            activity.registerActivityLifecycleCallbacks(new androidx.lifecycle.ReportFragment.LifecycleCallbacks());
        }

        @Override
        public void onActivityCreated(@NonNull Activity activity,
                                      @Nullable Bundle bundle) {
        }

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

        @Override
        public void onActivityStarted(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostStarted(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_START);
        }

        @Override
        public void onActivityResumed(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPostResumed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_RESUME);
        }

        @Override
        public void onActivityPrePaused(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_PAUSE);
        }

        @Override
        public void onActivityPaused(@NonNull Activity activity) {
        }

        @Override
        public void onActivityPreStopped(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_STOP);
        }

        @Override
        public void onActivityStopped(@NonNull Activity activity) {
        }

        @Override
        public void onActivitySaveInstanceState(@NonNull Activity activity,
                                                @NonNull Bundle bundle) {
        }

        @Override
        public void onActivityPreDestroyed(@NonNull Activity activity) {
            dispatch(activity, Lifecycle.Event.ON_DESTROY);
        }

        @Override
        public void onActivityDestroyed(@NonNull Activity activity) {
        }
    }
}

• 通过上述代码可知在 injectIfNeededIn(activity) 方法中，如果是 Android 10 及以上，通过 registerActivityLifecycleCallbacks 的方式来实现生命周期的回调，如果是 Android 10 以下，则通过向 Activity 添加一个不可见的 Fragment，以此来获取 Activity 的生命周期事件正确回调。根据代码流程两者最终都调用了 ReportFragment#dispatch() 方法，然后方法内部最终又调用了 LifecycleRegistry#handleLifecycleEvent() 方法来处理生命周期事件。

3.3 Lifecycle 添加观察者

// LifecycleRegistry.java
public class LifecycleRegistry extends Lifecycle {
    ...
    // 当前状态
    private State mState;
    
    // 持有对 LifecycleOwner 的弱引用，避免内存泄露
    private final WeakReference<LifecycleOwner> mLifecycleOwner;
    
    public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        this(provider, true);
    }

    private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
        mEnforceMainThread = enforceMainThread;
    }

    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        enforceMainThreadIfNeeded("addObserver");
        // 计算初始状态，如果当前 Lifecycle 状态不为 DESTROYED，我们就设置为初始状态
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        // 构造 ObserverWithState，即带状态的观察者，这个状态的作用：新的事件触发后遍历通知所有观察者时，判断是否已经通知这个观察者了
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        // 将 observer 对象和 statefulObserver 对象添加到 FastSafeIterableMap 数据结构中
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        if (previous != null) {
            // 一个 observer 不能多次加入到同一个 Lifecycle 中。如果 observer 之前已经传进来过了，则不重复添加，直接返回
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // 如果 LifecycleOwner 对象已经被回收了，则直接返回
            return;
        }
        // 判断该添加是否可重入，正常情况该标志永远为 false
        // mAddingObserverCounter != 0。会出现这种情况，是由于开发者先添加了一个 LifecycleObserver，
        // 当还在向其回调事件的过程中，在回调方法里又再次调用了 addObserver 方法添加了一个新的 LifecycleObserver
        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        // 计算当前 Lifecycle 的状态
        State targetState = calculateTargetState(observer);
        // 递增加一，标记当前正处于向新添加的 LifecycleObserver 回调 Event 值的过程
        mAddingObserverCounter++;
        // 新添加的观察者的状态小于当前状态，将它迁移到当前状态，例如当前状态为 RESUMED
        // ，则 Observer 将收到 ONCREATE、ONSTART、ONRESUME 事件
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            // 将 observer 已经遍历到的当前的状态值 mState 保存下来
            pushParentState(statefulObserver.mState);
            final Event event = Event.upFrom(statefulObserver.mState);
            if (event == null) {
                throw new IllegalStateException("no event up from " + statefulObserver.mState);
            }
            statefulObserver.dispatchEvent(lifecycleOwner, event);
            // 移除 mState
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }
    
    private State calculateTargetState(LifecycleObserver observer) {
        Map.Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);

        State siblingState = previous != null ? previous.getValue().mState : null;
        State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
                : null;
        return min(min(mState, siblingState), parentState);
    }
    
    static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            // 将 Observer 传给 Lifycycling 进行类型包装
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = event.getTargetState();
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }
    ...
}

• 通过上述代码可知：
• （1）计算初始状态，如果当前 Lifecycle 状态不为 DESTROYED，我们就设置为初始状态；
• （2）将传入的 observer 对象包装为 ObserverWithState，判断 observer 是否已添加到 map 数据中；
• （3）若未添加到 map 中，计算当前 Lifecycle的State，通过循环检查方式向 ObserverWithState 逐步下发 Event 值；
• （4）最终调用 sync() 方法，尝试同步其它观察者的生命周期状态。

3.4 Lifecycle 分发观察者状态

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    enforceMainThreadIfNeeded("handleLifecycleEvent");
    moveToState(event.getTargetState());
}

private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
        mNewEventOccurred = true;
        // we will figure out what to do on upper level.
        return;
    }
    mHandlingEvent = true;
    sync();
    mHandlingEvent = false;
}

private boolean isSynced() {
    if (mObserverMap.size() == 0) {
        return true;
    }
    State eldestObserverState = mObserverMap.eldest().getValue().mState;
    State newestObserverState = mObserverMap.newest().getValue().mState;
    return eldestObserverState == newestObserverState && mState == newestObserverState;
}

/*** 同步所有的观察者 */
private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                + "garbage collected. It is too late to change lifecycle state.");
    }
    // 循环遍历所有未同步的观察者
    while (!isSynced()) {
        mNewEventOccurred = false;
        // 根据当前状态和 mObserverMap 中的 eldest（最老的观察者）和 newest（最新的观察者）的状态做对比
        // ，判断当前状态是向前还是向后，比如由 STARTED 到 RESUMED 是状态向前，反过来就是状态向后
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            // 向后分发事件
            backwardPass(lifecycleOwner);
        }
        Map.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) {
    // 获取一个按添加 Observer 顺序的迭代器
    Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
            mObserverMap.iteratorWithAdditions();
    // 遍历所有 Observer
    while (ascendingIterator.hasNext() && !mNewEventOccurred) {
        Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
        ObserverWithState observer = entry.getValue();
        // 如果当前 Observer 的 State 小于 mState，则递增当前状态
        while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            // 递增当前状态
            pushParentState(observer.mState);
            final Event event = Event.upFrom(observer.mState);
            if (event == null) {
                throw new IllegalStateException("no event up from " + observer.mState);
            }
            // 分发事件
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}

private void backwardPass(LifecycleOwner lifecycleOwner) {
    // 获取一个按添加 Observer 顺序的迭代器
    Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
    // 遍历所有 Observer
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
        Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
        ObserverWithState observer = entry.getValue();
        // 如果当前 Observer 的 State 小于 mState，则递增当前状态
        while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            // 递增当前状态
            Event event = Event.downFrom(observer.mState);
            if (event == null) {
                throw new IllegalStateException("no event down from " + observer.mState);
            }
            pushParentState(event.getTargetState());
            // 分发事件
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}

• 通过上述代码可知：
• 就是根据下发的观察者状态，推导出当前目标的观察者状态，然后根据目标观察者状态过滤出所有未同步的观察者，并调用循环和其对应的判断条件，来进行向前或向后的分发事件，从而实现同步所有的观察者。

4、Lifecycle 总结

• （1）Lifecycle 的核心设计模式就是观察者模式，LifeCycleOwner 是被观察者，LifecycleObserver 是观察者，LifecycleRegistry 用来管理观察者和被观察者，并处理来自 LifeCycleOwner 的事件，然后再进行状态同步并通知所有的观察者。
• （2）Fragment 是通过实现 LifeCycleOwner 接口，并在 Fragment 中的 performCreate()、performResume() 等方法中调用 LifecycleRegistry 类的 handleLifecycleEvent() 方法来下发生命周期事件。
• （3）而 Activity 则是在其基类的 ComponentActivity 中的 onCreate() 方法通过 ReportFragment 的注入来实现对其生命周期的感知。
• （4）Lifecycle 添加观察者，都会调用到 LifecycleRegistry 类的 addObserver() 方法，首先计算初始状态，如果当前 Lifecycle 状态不为 DESTROYED 状态，我们就设置为初始状态；然后将传入的 observer 对象包装为 ObserverWithState，判断 observer 是否已添加到 map 集合数据中；若未添加到 map 集合中，计算当前 Lifecycle 的 State，通过循环检查方式向 ObserverWithState 逐步下发 Event 值；最终调用 sync() 方法，尝试同步其它观察者的生命周期状态。
• （5）Lifecycle 分发观察者状态，都会调用到 LifecycleRegistry 类的 handleLifecycleEvent() 方法，其实就是根据下发的观察者状态，推导出当前目标的观察者状态，然后根据目标观察者状态过滤出所有未同步的观察者，并调用循环和其对应的判断条件，来进行向前或向后的分发事件，从而实现同步所有的观察者。
• （6）这里需要注意的一点是，Lifecycle 有状态倒灌过程，也就是在任意生命周期中注册 LifecycleObserver，这个 LifecycleObserver 会把前面的生命周期回调都执行一遍，直到和注册时的生命周期状态同步。

5、Lifecycle 相关问题

5.1 Activity 是如何实现 Lifecycle 的事件分发的？

• ComponentActivity 通过不可见的 ReportFragment 注入来实现，低版本的 Activity ，即没有继承 ComponentActivity 的 Activity 类需要通过实现 LifecycleOwner 来自行实现。

5.2 Activity 为什么不内部实现而是引入 ReportFragment 呢？

• 主要是为了兼顾不是继承自 AppCompactActivity 的使用场景。

5.3 在 onResume() 方法中注册的观察者是否能够接收到完整的生命周期事件？

• 能，因为 Lifecycle 有状态倒灌过程，也就是在任意生命周期中注册 LifecycleObserver，这个 LifecycleObserver 会把前面的生命周期回调都执行一遍，直到和注册时的生命周期状态同步。

5.4 @OnLifecycleEvent 为什么被废弃？

• 在 Lifecycle 的 2.4.0 版本，将 @OnLifecycleEvent 注解废弃了，官方建议用 LifecycleEventObserver 或者 DefaultLifecycleObserver 替代。
• 因为注解要么依赖反射，会降低运行时性能，要么依靠 APT，降低编译速度。