Lifecycle使用及原理讲解

Lifecycle是Google在2017年的IO大会上推出的 Android Architecture Components中的一个，这个组件的用处就是可以感知Activity的生命周期，先来看下它的简单使用：

public class SecondActivity extends AppCompatActivity {private static final String TAG = "SecondActivity";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_second);getLifecycle().addObserver(new SimpleLifecycle());Log.d(TAG, "onCreate: this is activity onCreate()");}@Overrideprotected void onStart() {super.onStart();Log.d(TAG, "onCreate: this is activity onStart()");}@Overrideprotected void onResume() {super.onResume();Log.d(TAG, "onCreate: this is activity onResume()");}@Overrideprotected void onPause() {super.onPause();Log.d(TAG, "onCreate: this is activity onPause()");}@Overrideprotected void onStop() {super.onStop();Log.d(TAG, "onCreate: this is activity onStop()");}@Overrideprotected void onDestroy() {super.onDestroy();Log.d(TAG, "onCreate: this is activity onDestroy()");}private class SimpleLifecycle implements LifecycleObserver{@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)private void onCreate(){Log.d(TAG, "onCreate: this is lifecycle onCreate()");}@OnLifecycleEvent(Lifecycle.Event.ON_START)private void onStart(){Log.d(TAG, "onCreate: this is lifecycle onStart()");}@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)private void onResume(){Log.d(TAG, "onCreate: this is lifecycle onResume()");}@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)private void onPause(){Log.d(TAG, "onCreate: this is lifecycle onPause()");}@OnLifecycleEvent(Lifecycle.Event.ON_STOP)private void onStop(){Log.d(TAG, "onCreate: this is lifecycle onStop()");}@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)private void onDestroy(){Log.d(TAG, "onCreate: this is lifecycle onDestroy()");}}
}

再来看下打印的日志：

12-24 15:00:26.270 13079-13079/com.example.ubt.myapplication D/SecondActivity: onCreate: this is activity onCreate()
12-24 15:00:26.271 13079-13079/com.example.ubt.myapplication D/SecondActivity: onCreate: this is lifecycle onCreate()onCreate: this is activity onStart()
12-24 15:00:26.272 13079-13079/com.example.ubt.myapplication D/SecondActivity: onCreate: this is lifecycle onStart()
12-24 15:00:26.276 13079-13079/com.example.ubt.myapplication D/SecondActivity: onCreate: this is activity onResume()onCreate: this is lifecycle onResume()
12-24 15:00:41.009 13079-13079/com.example.ubt.myapplication D/SecondActivity: onCreate: this is lifecycle onPause()
12-24 15:00:41.010 13079-13079/com.example.ubt.myapplication D/SecondActivity: onCreate: this is activity onPause()
12-24 15:00:41.467 13079-13079/com.example.ubt.myapplication D/SecondActivity: onCreate: this is lifecycle onStop()onCreate: this is activity onStop()
12-24 15:00:41.468 13079-13079/com.example.ubt.myapplication D/SecondActivity: onCreate: this is lifecycle onDestroy()
12-24 15:00:41.469 13079-13079/com.example.ubt.myapplication D/SecondActivity: onCreate: this is activity onDestroy()

从日志中可以看到SimpleLifecycle 感知到了Activity的生命周期，用法有两点需要主要

实现LifecycleObserver接口，这是一个空接口，要对应到activity的生命周期，需要@OnLifecycleEvent这个注解，这个注解需要传一个值Lifecycle.Event，这个值就代表activity对应的生命周期，下面的方法名可以随意定义；
接下来调用getLifecycle().addObserver(new SimpleLifecycle());这个方法就可以了，传入实现LifecycleObserver接口的对象就可以了。
使用就是这么简单，那其中的原理又是什么呢？如果要你实现，你会怎么去实现呢？看到这样一个功能，我首先想到的就是利用fragment，毕竟fragment拥有和activity相同的生命周期，那到底是不是呢？这里先来验证下，实现activity的onAttachFragment方法：

onAttachFragment(android.app.Fragment fragment){Log.d(TAG, "onAttachFragment: fragment = "+fragment);
}

注意这里传入的参数，看看里面是不是有fragment给我们返回，再来看下打印结果：
12-24 16:13:05.682 20810-20810/com.example.ubt.myapplication D/SecondActivity: onAttachFragment: fragment = m{9fb1708 #0 android.arch.lifecycle.LifecycleDispatcher.report_fragment_tag}
可以看到确实是利用fragment实现的，接下来再去看看源码是如何实现的，这里的入口是getLifecycle()，跟着这个方法下去，最终来到SupportActivity，这里就是为了实现Lifecycle单独提出来的activity，不长，那就全部来看看：

public class SupportActivity extends Activity implements LifecycleOwner {/*** Storage for {@link ExtraData} instances.** <p>Note that these objects are not retained across configuration changes</p>*/private SimpleArrayMap<Class<? extends ExtraData>, ExtraData> mExtraDataMap =new SimpleArrayMap<>();private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);/*** Store an instance of {@link ExtraData} for later retrieval by class name* via {@link #getExtraData}.** <p>Note that these objects are not retained across configuration changes</p>** @see #getExtraData* @hide*/@RestrictTo(LIBRARY_GROUP)public void putExtraData(ExtraData extraData) {mExtraDataMap.put(extraData.getClass(), extraData);}@Override@SuppressWarnings("RestrictedApi")protected void onCreate(@Nullable Bundle savedInstanceState) {super.onCreate(savedInstanceState);ReportFragment.injectIfNeededIn(this);}@CallSuper@Overrideprotected void onSaveInstanceState(Bundle outState) {mLifecycleRegistry.markState(Lifecycle.State.CREATED);super.onSaveInstanceState(outState);}/*** Retrieves a previously set {@link ExtraData} by class name.** @see #putExtraData* @hide*/@RestrictTo(LIBRARY_GROUP)public <T extends ExtraData> T getExtraData(Class<T> extraDataClass) {return (T) mExtraDataMap.get(extraDataClass);}@Overridepublic Lifecycle getLifecycle() {return mLifecycleRegistry;}/*** @hide*/@RestrictTo(LIBRARY_GROUP)public static class ExtraData {}
}

这里有mExtraDataMap和mLifecycleRegistry 两个属性，一开始就初始化了，下面的方法都是围绕这两个属性展开的，mExtraDataMap就是一个保存数据的集合，这个很好理解，接下来重点要看的就是mLifecycleRegistry ，不过在这之前还是先来看看onCreate()方法中的ReportFragment.injectIfNeededIn(this)这段代码，嗯…，那看来得去看看ReportFragment了，这个类也不长，就全部来看看：

public class ReportFragment extends Fragment {private static final String REPORT_FRAGMENT_TAG = "android.arch.lifecycle"+ ".LifecycleDispatcher.report_fragment_tag";public static void injectIfNeededIn(Activity activity) {// ProcessLifecycleOwner should always correctly work and some activities may not extend// FragmentActivity from support lib, so we use framework fragments for activitiesandroid.app.FragmentManager manager = activity.getFragmentManager();if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();// Hopefully, we are the first to make a transaction.manager.executePendingTransactions();}}static ReportFragment get(Activity activity) {return (ReportFragment) activity.getFragmentManager().findFragmentByTag(REPORT_FRAGMENT_TAG);}private ActivityInitializationListener mProcessListener;private void dispatchCreate(ActivityInitializationListener listener) {if (listener != null) {listener.onCreate();}}private void dispatchStart(ActivityInitializationListener listener) {if (listener != null) {listener.onStart();}}private void dispatchResume(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(Lifecycle.Event event) {Activity activity = getActivity();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);}}}void setProcessListener(ActivityInitializationListener processListener) {mProcessListener = processListener;}interface ActivityInitializationListener {void onCreate();void onStart();void onResume();}
}

先来看看injectIfNeededIn（）这个方法，这里面的逻辑很好理解，就是在activity中添加当前这个fragment，这样ReportFragment 就拥有了和activity一样的生命周期了（看来和前面猜想差不多了），再来看看其中的一个生命周期方法，这里就选onResume（）了，先调用了dispatchResume(mProcessListener)，这里默认mProceListener为null，再来看dispatch(Lifecycle.Event.ON_RESUME)：

    private void dispatch(Lifecycle.Event event) {Activity activity = getActivity();//在新的版本中LifecycleRegistryOwner已经被废弃，由下面的LifecycleOwner替代了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);}}}

在新的版本中会执行下面的if语句，还记得前面SupportActivity的属性mLifecycleRegistry么，这里getLifecycle()返回的就是这个属性，它的类型是LifecycleRegistry，这里调用了它的handleLifecycleEvent(event)方法，看来handleLifecycleEvent(event)会去分发activity生命周期事件，那么现在再回过看：
mLifecycleRegistry = new LifecycleRegistry(this)，那就再来看看LifecycleRegistry这个类是如何去分发事件的，切入点就是handleLifecycleEvent(event)这个方法：

    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {//根据event判断当前是在那个生命周期里State next = getStateAfter(event);//知道了当前所处的生命周期，就可以去执行已经注册的LifecycleObserver对应的生命周期方法moveToState(next);}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;}throw new IllegalArgumentException("Unexpected event value " + event);}private void moveToState(State next) {//如果当前所处的状态与要执行的状态一致就没必要再去执行了，直接返回if (mState == next) {return;}mState = next;//mHandlingEvent表示是否正在处理状态，mAddingObserverCounter表示当前通过addObserver（）添加进来的LifecycleObserver，如果当前正在处理状态并且mAddingObserverCounter的不为0就直接返回，意思就是说当前正在处理状态的时候添加了LifecycleObserver进来（可能是在回调中添加的），那么这时候在这里就直接返回了if (mHandlingEvent || mAddingObserverCounter != 0) {mNewEventOccurred = true;// we will figure out what to do on upper level.return;}mHandlingEvent = true;//这里就是对状态的同步了sync();mHandlingEvent = false;}

接着就来看看sync（）方法的是如何去处理时间分发的：

    private void sync() {LifecycleOwner lifecycleOwner = mLifecycleOwner.get();if (lifecycleOwner == null) {Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "+ "new events from it.");return;}//这个while循环就是判断是否把所有添加进来的LifecycleObserver的状态全部同步完成了while (!isSynced()) {//这里置false，当在执行回调时置为true，可以让后面执行的函数更快的返回mNewEventOccurred = false;// no need to check eldest for nullability, because isSynced does it for us.//mObserverMap里的元素的状态是非递增排列的，这样eldest的state最大，newest的state最小//同步状态时分为两种情况，一是执行：onCreate（），onStart（），onResume（），这种对应下面的forwardPass（）方法//二是执行：onPause（），onStop（），onDestroy（），对应下面的backwardPass（）方法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);}}mNewEventOccurred = false;}

通过对上面代码的分析，生命周期事件分发由backwardPass（）和forwardPass（）去执行，这里就主要说下backwardPass（），明白backwardPass（）也就明白forwardPass（）了：

    private void backwardPass(LifecycleOwner lifecycleOwner) {//这里是对mObserverMap进行降序迭代Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =mObserverMap.descendingIterator();while (descendingIterator.hasNext() && !mNewEventOccurred) {Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();//这里就是获取添加进来的LifecycleObserver，然后在进行状态的分发ObserverWithState observer = entry.getValue();while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred&& mObserverMap.contains(entry.getKey()))) {//这里就是根据现在所处的状态判断接下来该执行的状态，比如现在要执行onPause（）方法，那么所处的状态是RESUMED的，看downEvent（） 的方法，返回的是ON_PAUSE，那就说接下来要执行的是onPause（）方法Event event = downEvent(observer.mState);pushParentState(getStateAfter(event));//这里就是对状态的分发，进而转化为对应的生命周期事件，这里就不在跟下去了observer.dispatchEvent(lifecycleOwner, event);popParentState();}}}private static Event downEvent(State state) {switch (state) {case INITIALIZED:throw new IllegalArgumentException();case CREATED:return ON_DESTROY;case STARTED:return ON_STOP;case RESUMED:return ON_PAUSE;case DESTROYED:throw new IllegalArgumentException();}throw new IllegalArgumentException("Unexpected state value " + state);}

到这里为止，生命周期对应事件的分发差不多就理了一遍，不过记住一点，生命周期的分发实际是通过fragment去实现的。
最后再来看下添加LifecycleObserver 的逻辑：

    public void addObserver(@NonNull LifecycleObserver observer) {State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;//对observer进行一层封装，这里面会对observer的注解进行处理，生成一个adapterObserverWithState statefulObserver = new ObserverWithState(observer, initialState);//将observer保存起来，后面同步状态时就是通过遍历这个集合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 quicklyreturn;}boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;//计算当前的状态，已确定需要执行的状态，比如observer是在onResume（）添加进来的，那么这时候就需要去执行observer的onCreate（）和onStart（）方法，下面同步状态主要也是这个作用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 recalculatetargetState = calculateTargetState(observer);}if (!isReentrance) {// we do sync only on the top level.sync();}mAddingObserverCounter--;}

这样，整个流程就梳理完了，如有不对的地方欢迎指正，一起学习。

参考资料： Android arch components 源码分析（2）—— Lifecycle

Lifecycle使用及原理讲解相关推荐

Android Android-skin-support 换肤方案原理讲解
文章目录前言思考一下开源库中找到答案结束语前言请先查看这两篇文章 LayoutInflater.Factory Android xml解析到View的过程 Android 无需自定义Vi ...
php 伪静态 page-18.html,PHP 伪静态实现技术原理讲解
PHP 伪静态实现技术原理讲解发布于 2015-01-18 23:52:58 | 129 次阅读 | 评论: 0 | 来源: 网友投递 PHP开源脚本语言PHP(外文名: Hypertext Pre ...
nginx反向代理原理讲解
一 .概述反向代理(Reverse Proxy)方式是指以代理服务器来接受Internet上的连接请求,然后将请求转发给内部网络上的服务器:并将从服务器上得到的结果 ...
微信小游戏开发教程-2D游戏原理讲解
微信小游戏开发教程-2D游戏原理讲解原理为了更加形象的描述,这里先上一张图: 背景 a. 首先,我们看到背景好像是一张无限长的图片在向下移动.实际则不然,这是一张顶部和底部刚好重叠的图片.这是一种 ...
解密汽车全景行车安全系统的前世和今生——第二讲：原理讲解
解密汽车全景行车安全系统的前世和今生--第二讲:原理讲解来源:深圳市汽车电子行业协会作者:姜卫忠发布时间:2013-3-7 浏览(4648)次解密汽车全景行车安全系统的前世和今生第二讲:全 ...
pureMVC简单示例及其原理讲解四(Controller层)
本节将讲述pureMVC示例中的Controller层. Controller层有以下文件组成: AddUserCommand.as DeleteUserCommand.as ModelPrepCom ...
IoT物联网嵌入式设备中30种常见传感器模块简介及原理讲解
IoT物联网嵌入式设备中30种常见传感器模块简介及原理讲解 0.前言一.光学传感器模块: 1. 光敏传感器模块: 2. 红外避障模块 3. 循迹传感器模块 4. U型光电传感器模块 5. 红外接收模 ...
艺点动画-跟随原理讲解
艺点动画-跟随原理讲解如果要想顺便解决就业问题的话,可以去试试看成都艺点动画,这家教学质量, 蛮高的毕业后是可以直接在公司里面上班的方法/步骤 1.什么是动画里的跟随? 动画的跟随指的是:物体在运 ...
酷狗音乐的爬取，基于python，从无到有完整教程-上：搭建环境及爬取原理讲解
酷狗音乐的爬取,基于python,从无到有完整教程,使用微软新edge作为虚拟浏览器搭建环境及爬取原理讲解 ⬇⬇⬇ 编码环境及工具准备: 编码工具:PyCharm 所需的库: import requ ...

Lifecycle使用及原理讲解

Lifecycle使用及原理讲解相关推荐

最新文章

热门文章