Lifecycle 源码解析（2.4.1 版本）

本文主要是介绍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: LifecycleRegistryoverride fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)mLifecycleRegistry = LifecycleRegistry(this)mLifecycleRegistry.currentState = Lifecycle.State.CREATEDlifecycle.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@NonNullpublic 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 implementsContextAware,LifecycleOwner,ViewModelStoreOwner,HasDefaultViewModelProviderFactory,SavedStateRegistryOwner,OnBackPressedDispatcherOwner,ActivityResultRegistryOwner,ActivityResultCaller {...private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);@Overrideprotected 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@Overridepublic 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 添加到 Activitymanager.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();}}@Overridepublic void onActivityCreated(Bundle savedInstanceState) {super.onActivityCreated(savedInstanceState);dispatchCreate(mProcessListener);dispatch(Lifecycle.Event.ON_CREATE);}@Overridepublic void onStart() {super.onStart();dispatchStart(mProcessListener);dispatch(Lifecycle.Event.ON_START);}@Overridepublic void onResume() {super.onResume();dispatchResume(mProcessListener);dispatch(Lifecycle.Event.ON_RESUME);}@Overridepublic void onPause() {super.onPause();dispatch(Lifecycle.Event.ON_PAUSE);}@Overridepublic void onStop() {super.onStop();dispatch(Lifecycle.Event.ON_STOP);}@Overridepublic void onDestroy() {super.onDestroy();dispatch(Lifecycle.Event.ON_DESTROY);// just want to be sure that we won't leak reference to an activitymProcessListener = 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());}@Overridepublic void onActivityCreated(@NonNull Activity activity,@Nullable Bundle bundle) {}@Overridepublic void onActivityPostCreated(@NonNull Activity activity,@Nullable Bundle savedInstanceState) {dispatch(activity, Lifecycle.Event.ON_CREATE);}@Overridepublic void onActivityStarted(@NonNull Activity activity) {}@Overridepublic void onActivityPostStarted(@NonNull Activity activity) {dispatch(activity, Lifecycle.Event.ON_START);}@Overridepublic void onActivityResumed(@NonNull Activity activity) {}@Overridepublic void onActivityPostResumed(@NonNull Activity activity) {dispatch(activity, Lifecycle.Event.ON_RESUME);}@Overridepublic void onActivityPrePaused(@NonNull Activity activity) {dispatch(activity, Lifecycle.Event.ON_PAUSE);}@Overridepublic void onActivityPaused(@NonNull Activity activity) {}@Overridepublic void onActivityPreStopped(@NonNull Activity activity) {dispatch(activity, Lifecycle.Event.ON_STOP);}@Overridepublic void onActivityStopped(@NonNull Activity activity) {}@Overridepublic void onActivitySaveInstanceState(@NonNull Activity activity,@NonNull Bundle bundle) {}@Overridepublic void onActivityPreDestroyed(@NonNull Activity activity) {dispatch(activity, Lifecycle.Event.ON_DESTROY);}@Overridepublic 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;}@Overridepublic 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 方法添加了一个新的 LifecycleObserverboolean 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);// 移除 mStatepopParentState();// mState / subling may have been changed recalculatetargetState = 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();// 遍历所有 Observerwhile (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();// 遍历所有 Observerwhile (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，降低编译速度。

这篇关于Lifecycle 源码解析（2.4.1 版本）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---