Lifecycle 源码解析(2.4.1 版本)

2024-05-28 12:58

本文主要是介绍Lifecycle 源码解析(2.4.1 版本),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

文章目录

      • 1、Lifecycle 简介
      • 2、Lifecycle 配置与基本用法
        • 2.1 依赖引入与配置
        • 2.2 基本用法
          • 2.2.1 Lifecycle 简单使用
          • 2.2.2 普通 Activity 实现 Lifecycle
          • 2.2.3 ProcessLifecycleOwner 实现前后台切换
      • 3、Lifecycle 源码解析
        • 3.1 Fragment 实现 Lifecycle
        • 3.2 Activity 实现 Lifecycle
        • 3.3 Lifecycle 添加观察者
        • 3.4 Lifecycle 分发观察者状态
      • 4、Lifecycle 总结
      • 5、Lifecycle 相关问题
        • 5.1 Activity 是如何实现 Lifecycle 的事件分发的?
        • 5.2 Activity 为什么不内部实现而是引入 ReportFragment 呢?
        • 5.3 在 onResume() 方法中注册的观察者是否能够接收到完整的生命周期事件?
        • 5.4 @OnLifecycleEvent 为什么被废弃?

1、Lifecycle 简介

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

2、Lifecycle 配置与基本用法

2.1 依赖引入与配置
  • 正常情况下无需单独引入 Lifecycle 相关库,因为androidx.appcompat:appcompat:1.4.1会自带 LifecycleLiveDataViewModel 等依赖库。
  • 如果想单独引入 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:一个抽象类,持有组件生命周期状态(如 ActivityFragment)的信息的类,并允许其他对象观察此状态。其宿主生命周期与宿主状态的对应关系如下:
    Lifecycle 宿主生命周期与状态模型图
  • LifecycleOwnerLifecycle 被观察者(持有者),实现该接口的类持有生命周期(Lifecycle 对象),该接口的生命周期(Lifecycle 对象)的改变会被其注册的观察者 LifecycleObserver 观察到并触发其对应的事件。
  • LifecycleObserverLifecycle 观察者,实现该接口的类,可以通过被 LifecycleOwner 类的 addObserver() 方法注册,被注册后 LifecycleObserver 便可以观察到 LifecycleOwner 的生命周期事件。
  • LifycycleRegistryLifecycle 是一个抽象类,其唯一实现类是 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 集合中,计算当前 LifecycleState,通过循环检查方式向 ObserverWithState 逐步下发 Event 值;最终调用 sync() 方法,尝试同步其它观察者的生命周期状态。
  • (5)Lifecycle 分发观察者状态,都会调用到 LifecycleRegistry 类的 handleLifecycleEvent() 方法,其实就是根据下发的观察者状态,推导出当前目标的观察者状态,然后根据目标观察者状态过滤出所有未同步的观察者,并调用循环和其对应的判断条件,来进行向前或向后的分发事件,从而实现同步所有的观察者。
  • (6)这里需要注意的一点是,Lifecycle 有状态倒灌过程,也就是在任意生命周期中注册 LifecycleObserver,这个 LifecycleObserver 会把前面的生命周期回调都执行一遍,直到和注册时的生命周期状态同步。

5、Lifecycle 相关问题

5.1 Activity 是如何实现 Lifecycle 的事件分发的?
  • ComponentActivity 通过不可见的 ReportFragment 注入来实现,低版本的 Activity ,即没有继承 ComponentActivityActivity 类需要通过实现 LifecycleOwner 来自行实现。
5.2 Activity 为什么不内部实现而是引入 ReportFragment 呢?
  • 主要是为了兼顾不是继承自 AppCompactActivity 的使用场景。
5.3 在 onResume() 方法中注册的观察者是否能够接收到完整的生命周期事件?
  • 能,因为 Lifecycle 有状态倒灌过程,也就是在任意生命周期中注册 LifecycleObserver,这个 LifecycleObserver 会把前面的生命周期回调都执行一遍,直到和注册时的生命周期状态同步。
5.4 @OnLifecycleEvent 为什么被废弃?
  • Lifecycle2.4.0 版本,将 @OnLifecycleEvent 注解废弃了,官方建议用 LifecycleEventObserver 或者 DefaultLifecycleObserver 替代。
  • 因为注解要么依赖反射,会降低运行时性能,要么依靠 APT,降低编译速度。

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


原文地址:
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.chinasem.cn/article/1010632

相关文章

nginx -t、nginx -s stop 和 nginx -s reload 命令的详细解析(结合应用场景)

《nginx-t、nginx-sstop和nginx-sreload命令的详细解析(结合应用场景)》本文解析Nginx的-t、-sstop、-sreload命令,分别用于配置语法检... 以下是关于 nginx -t、nginx -s stop 和 nginx -s reload 命令的详细解析,结合实际应

MyBatis中$与#的区别解析

《MyBatis中$与#的区别解析》文章浏览阅读314次,点赞4次,收藏6次。MyBatis使用#{}作为参数占位符时,会创建预处理语句(PreparedStatement),并将参数值作为预处理语句... 目录一、介绍二、sql注入风险实例一、介绍#(井号):MyBATis使用#{}作为参数占位符时,会

PostgreSQL的扩展dict_int应用案例解析

《PostgreSQL的扩展dict_int应用案例解析》dict_int扩展为PostgreSQL提供了专业的整数文本处理能力,特别适合需要精确处理数字内容的搜索场景,本文给大家介绍PostgreS... 目录PostgreSQL的扩展dict_int一、扩展概述二、核心功能三、安装与启用四、字典配置方法

深度解析Java DTO(最新推荐)

《深度解析JavaDTO(最新推荐)》DTO(DataTransferObject)是一种用于在不同层(如Controller层、Service层)之间传输数据的对象设计模式,其核心目的是封装数据,... 目录一、什么是DTO?DTO的核心特点:二、为什么需要DTO?(对比Entity)三、实际应用场景解析

深度解析Java项目中包和包之间的联系

《深度解析Java项目中包和包之间的联系》文章浏览阅读850次,点赞13次,收藏8次。本文详细介绍了Java分层架构中的几个关键包:DTO、Controller、Service和Mapper。_jav... 目录前言一、各大包1.DTO1.1、DTO的核心用途1.2. DTO与实体类(Entity)的区别1

Java中的雪花算法Snowflake解析与实践技巧

《Java中的雪花算法Snowflake解析与实践技巧》本文解析了雪花算法的原理、Java实现及生产实践,涵盖ID结构、位运算技巧、时钟回拨处理、WorkerId分配等关键点,并探讨了百度UidGen... 目录一、雪花算法核心原理1.1 算法起源1.2 ID结构详解1.3 核心特性二、Java实现解析2.

使用Python绘制3D堆叠条形图全解析

《使用Python绘制3D堆叠条形图全解析》在数据可视化的工具箱里,3D图表总能带来眼前一亮的效果,本文就来和大家聊聊如何使用Python实现绘制3D堆叠条形图,感兴趣的小伙伴可以了解下... 目录为什么选择 3D 堆叠条形图代码实现:从数据到 3D 世界的搭建核心代码逐行解析细节优化应用场景:3D 堆叠图

深度解析Python装饰器常见用法与进阶技巧

《深度解析Python装饰器常见用法与进阶技巧》Python装饰器(Decorator)是提升代码可读性与复用性的强大工具,本文将深入解析Python装饰器的原理,常见用法,进阶技巧与最佳实践,希望可... 目录装饰器的基本原理函数装饰器的常见用法带参数的装饰器类装饰器与方法装饰器装饰器的嵌套与组合进阶技巧

解析C++11 static_assert及与Boost库的关联从入门到精通

《解析C++11static_assert及与Boost库的关联从入门到精通》static_assert是C++中强大的编译时验证工具,它能够在编译阶段拦截不符合预期的类型或值,增强代码的健壮性,通... 目录一、背景知识:传统断言方法的局限性1.1 assert宏1.2 #error指令1.3 第三方解决

全面解析MySQL索引长度限制问题与解决方案

《全面解析MySQL索引长度限制问题与解决方案》MySQL对索引长度设限是为了保持高效的数据检索性能,这个限制不是MySQL的缺陷,而是数据库设计中的权衡结果,下面我们就来看看如何解决这一问题吧... 目录引言:为什么会有索引键长度问题?一、问题根源深度解析mysql索引长度限制原理实际场景示例二、五大解决