查看: 100|回复: 0

Android 官方架构组件(一)——Lifecycle

[复制链接]

Android 官方架构组件(一)——Lifecycle[复制链接]

zhaishao 发表于 2019-1-17 14:21:00 [显示全部楼层] 回帖奖励 |倒序浏览 |阅读模式 回复:  0 浏览:  100
什么是Lifecycle?

Lifecycle 组件指的是 android.arch.lifecycle 包下提供的各种类与接口,可以让开发者构建能感知其他组件(主要指Activity 、Fragment)生命周期(lifecycle-aware)的类。
为什么要引进Lifecycle?

前面说了,Lifecycle能够让开发者构建能感知其他组件(主要指Activity 、Fragment)生命周期(lifecycle-aware)的类。划重点,让开发者构建能感知其他组件(主要指Activity 、Fragment)生命周期(lifecycle-aware)的类。在android开发的过程中,我们常常需要让一些操作能够感知Activity/Fragment的生命周期,从而实现在活动状态下允许操作,而在销毁状态下需要自动禁止操作,释放资源,防止内存泄露。例如大名鼎鼎的图片加载框架 Glide 在 Acticiy/Fragment 处于前台的时候加载图片,而在不可见的状态下停止图片的加载,又例如我们希望 RxJava 的 Disposable 能够在Activity/Fragment 销毁是自动 dispose。Lifecycle 的出现,让开发者们能够轻易地实现上述的功能。
免费获取安卓开发架构的资料(包括Fultter、高级UI、性能优化、架构师课程、 NDK、混合式开发(ReactNative+Weex)和一线互联网公司关于android面试的题目汇总可以加群:936332305 / 群链接:点击链接加入群聊【安卓开发架构】:https://jq.qq.com/?_wv=1027&k=515xp64


一个用Lifecycle改造的MVP例子

比如我们现在需要实现这样一个功能:监听某个 Activity 生命周期的变化,在生命周期改变的时候打印日志。

  • 一般做法构造回调的方式
    先定义基础IPresent接口:
  1.     public interface IPresent {
  2.    
  3.         void onCreate();
  4.         void onStart();
  5.         void onResume();
  6.         void onPause();
  7.         void onStop();
  8.         void onDestory();
  9.     }
复制代码
然后在自定义的Present中继承IPresent接口:
  1.     public class MyPresent implements IPresent {
  2.    
  3.         private String TAG = "tag";
  4.    
  5.         @Override
  6.         public void onCreate() {
  7.             LogUtil.i(TAG, "onCreate");
  8.         }
  9.    
  10.         @Override
  11.         public void onStart() {
  12.             LogUtil.i(TAG, "onStart");
  13.         }
  14.    
  15.         @Override
  16.         public void onResume() {
  17.             LogUtil.i(TAG, "onResume");
  18.         }
  19.    
  20.         @Override
  21.         public void onPause() {
  22.             LogUtil.i(TAG, "onPause");
  23.         }
  24.    
  25.         @Override
  26.         public void onStop() {
  27.             LogUtil.i(TAG, "onStop");
  28.         }
  29.    
  30.         @Override
  31.         public void onDestory() {
  32.             LogUtil.i(TAG, "onDestory");
  33.         }
复制代码
最后在Activity依次调用回调方法分发事件:
  1.     public class MyActivity extends AppCompatActivity {
  2.    
  3.         protected MyPresent myPresent;
  4.    
  5.         @Override
  6.         public void onCreate(@Nullable Bundle savedInstanceState, @Nullable PersistableBundle persistentState) {
  7.             super.onCreate(savedInstanceState, persistentState);
  8.             myPresent = new MyPresent();
  9.             myPresent.onCreate();
  10.         }
  11.    
  12.         @Override
  13.         protected void onStart() {
  14.             super.onStart();
  15.             myPresent.onStart();
  16.         }
  17.    
  18.         @Override
  19.         protected void onResume() {
  20.             super.onResume();
  21.             myPresent.onResume();
  22.         }
  23.    
  24.         @Override
  25.         protected void onPause() {
  26.             super.onPause();
  27.             myPresent.onPause();
  28.         }
  29.    
  30.         @Override
  31.         protected void onStop() {
  32.             super.onStop();
  33.             myPresent.onStop();
  34.         }
  35.    
  36.         @Override
  37.         protected void onDestroy() {
  38.             super.onDestroy();
  39.             myPresent.onDestory();
  40.         }
  41.     }
复制代码
通过这么一个简单的例子,我们可以看出,实现流程虽然很简单,但是代码实现繁琐,不够灵活,且代码侵入性太强。该例子只是展示了Present监听Activity生命周期,如果说还有类1,类2,类3……想要监听Activity的生命周期,那么就要在Activity的回调中添加对类1,类2,类3……的回调。这就引起了一个思考,我们是否能够实现Activity在生命周期发生变化时主动通知需求方的功能呢?可以的,答案就是Lifecycle。

  • Lifecycle实现Present 先实现
    MyPresent,同时在每一个方法实现上增加@OnLifecycleEvent(Lifecycle.Event.XXXX)注解,OnLifecycleEvent对应了Activity的生命周期方法:
  1.     public class MyPresent implements IPresent, LifecycleObserver {
  2.    
  3.         @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
  4.         @Override
  5.         public void onCreate() {
  6.             LogUtil.i(TAG, "onCreate");
  7.         }
  8.    
  9.         @OnLifecycleEvent(Lifecycle.Event.ON_START)
  10.         @Override
  11.         public void onStart() {
  12.             LogUtil.i(TAG, "onStart");
  13.         }
  14.    
  15.         @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
  16.         @Override
  17.         public void onResume() {
  18.             LogUtil.i(TAG, "onResume");
  19.         }
  20.    
  21.         @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
  22.         @Override
  23.         public void onPause() {
  24.             LogUtil.i(TAG, "onPause");
  25.         }
  26.    
  27.         @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
  28.         @Override
  29.         public void onStop() {
  30.             LogUtil.i(TAG, "onStop");
  31.         }
  32.    
  33.         @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
  34.         @Override
  35.         public void onDestory() {
  36.             LogUtil.i(TAG, "onDestory");
  37.         }
  38.     }
  39. 然后在需要监听的 Activity 中注册:
  40.     public class MyActivity extends AppCompatActivity {
  41.    
  42.         protected MyPresent myPresent;
  43.    
  44.         @Override
  45.         public void onCreate(@Nullable Bundle savedInstanceState, @Nullable PersistableBundle persistentState) {
  46.             super.onCreate(savedInstanceState, persistentState);
  47.    
  48.             getLifecycle().addObserver(new MyPresent()); //添加监听对象
  49.         }
  50.    
  51.     }
复制代码
运行如下:
  1.     com.cimu.lifecycle I/MyPresent : onCreate()
  2.     com.cimu.lifecycle I/MyPresent : onStart()
  3.     com.cimu.lifecycle I/MyPresent : onResume()
  4.     com.cimu.lifecycle I/MyPresent : onPause()
  5.     com.cimu.lifecycle I/MyPresent : onStop()
  6.     com.cimu.lifecycle I/MyPresent : onDestroy()
复制代码
是不是很简单,我们希望 MyPresent 感知监听 Activity 的生命周期,只需要在Activity中调用一句 getLifecycle().addObserver(new MyPresent()) 就可以了。Lifecycle 是怎样实现感知生命周期进而通知观察者的功能的呢?
进入源码分析了,前方大量眼花缭乱的代码~~~
Lifecycle源码分析

首先需要知道三个关键的东西:

  • LifecycleOwner:生命周期的事件分发者,在 Activity/Fragment 他们的生命周期发生变化的时发出相应的
    Event 给 LifecycleRegistry。
  • LifecycleObserver:生命周期的观察者,通过注解将处理函数与希望监听的Event绑定,当相应的Event发生时,LifecycleRegistry会通知相应的函数进行处理。
  • LifecycleRegistry:控制中心。它负责控制state的转换、接受分发event事件。
LifeCycle的源码分析,我们分为两个步骤来分析:

  • 注册/注销监听流程
  • 生命周期分发流程
注册/注销监听流程源码分析
从上面的 MVP 例子,我们已经知道,注册只需要调用getLifecycle().addObserver(observer) 即可,那么 addObserver 就可以作为源码分析的入口。
通过追踪,我们发现 getLifecycle 返回的是 SupportActivity 中的mLifecycleRegistry,类型为 LifecycleRegistry:
  1.     public class SupportActivity extends Activity implements LifecycleOwner {
  2.    
  3.         ......
  4.    
  5.         private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap
  6.                                                                  = new FastSafeIterableMap<>();
  7.         private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
  8.    
  9.         ......
  10.    
  11.         @Override
  12.         public Lifecycle getLifecycle() {
  13.             return mLifecycleRegistry;
  14.         }
  15.    
  16.         ......
  17.     }
复制代码
那么 addObserver 实际上是调用了 LifecycleRegistry 的 addObserver 方法。
在分析Lifecycling.getCallback()方法之前,我们先来看一下Lifecycle使用的三种基本使用方式:

  • 第一种使用方式。使用@onLifecycleEvent注解。注解处理器会将该注解解析并动态生成GeneratedAdapter代码,这个GeneratedAdapter会把对应的
    Lifecycle.Event
    封装为方法调用。最终通过GenericLifecycleObserver的onStateChanged方法调用生成的GeneratedAdapter的callMechods方法进行事件分发(结合下面例子理解)。
  1.        public class MyLifeCycleObserver implements LifeCycleObserver {
  2.         
  3.             @onLifecycleEvent(LifeCycle.Event.ON_CREATE)
  4.             public onCreate(LifeCycleOwner owner) {
  5.                  //doSomething
  6.             }
  7.         
  8.             @onLifecycleEvent(LifeCycle.Event.ON_DESTROY)
  9.             public onDestroy(LifeCycleOwner owner) {
  10.                 //doSomething
  11.             }
  12.         }
  13.         
  14.         public class MainActivity extends AppCompatActivity {
  15.         
  16.             @override
  17.             public void onCreate(savedInstanceState: Bundle?) {
  18.                 super.onCreate(savedInstanceState)
  19.                 setContentView(R.layout.activity_main)
  20.                 getLifecycle().addObserver(new MyLifeCycleObserver());
  21.             }
  22.         }
复制代码
上述的例子中的 MyLifeCycleObserver 将会在编译时,生成GeneratedAdapter代码如下:
  1.     public class MyLifeCycleObserver_LifecycleAdapter implements GeneratedAdapter {
  2.    
  3.         final MyLifeCycleObserver mReceiver;
  4.    
  5.         MyLifeCycleObserver_LifecycleAdapter(MyLifeCycleObserver receiver) {
  6.             //mReceiver就是我们开发者传入的MyLifeCycleObserver
  7.             this.mReceiver = receiver;
  8.         }
  9.    
  10.         //callMechod方法会被GenericLifecycleObserver的onStateChanged方法调用,用以分发生命周期
  11.         @Override
  12.         public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny, MethodCallsLogger logger) {
  13.             boolean hasLogger = logger != null;
  14.             if (onAny) {
  15.                 return;
  16.             }
  17.    
  18.             //如果生命周期事件是ON_CREATE,那么调用MyLifeCycleObserver的onCreate方法
  19.             if (event == Lifecycle.Event.ON_CREATE) {
  20.                 if (!hasLogger || logger.approveCall("onCreate", 2)) {
  21.                     mReceiver.onCreate(owner);
  22.                 }
  23.                 return;
  24.             }
  25.    
  26.             //如果生命周期事件是ON_DESTROY,那么调用MyLifeCycleObserver的onDestroy方法
  27.             if (event == Lifecycle.Event.ON_DESTROY) {
  28.                 if (!hasLogger || logger.approveCall("onDestroy", 2)) {
  29.                     mReceiver.onDestroy(owner);
  30.                 }
  31.                 return;
  32.             }
  33.         }
  34.     }
复制代码

  • 第二种使用方式。直接继承 GenericLifecycleObserver,并实现onStateChange 方法
  1.     public class MyLifeCycleObserver extends GenericLifeCycleObserver {
  2.         
  3.             @override
  4.             void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
  5.                 if(event == LifeCycleEvent.Event.ON_CREATE) {
  6.                     //dosomething
  7.                 } else if(event == LifeCycleEvent.Event.ON_DESTROY) {
  8.                     //doSomething
  9.                 }   
  10.             }
  11.         }
  12.         public class MainActivity extends AppCompatActivity {
  13.         
  14.             @override
  15.             public void onCreate(savedInstanceState: Bundle?) {
  16.                 super.onCreate(savedInstanceState)
  17.                 setContentView(R.layout.activity_main)
  18.                 getLifecycle().addObserver(new MyLifeCycleObserver());
  19.             }
  20.         }
复制代码

  • 第三种使用方式。继承 DefaultLifecycleObserver 接口(DefaultLifecycleObserver 又继承自
    FullLifecycleObserver接口),并实现 FullLifecycleObserver 接口的
    onCreate、onStart、onResume、onPause、onStop、onDestroy 等对应各自生命周期的方法
  1.        class MyLifycycleObserver implements DefaultLifecycleObserver {
  2.         
  3.             @Override
  4.             public void onCreate(@NonNull LifecycleOwner owner) {
  5.                 //doSomething
  6.             }
  7.         
  8.             ......
  9.         
  10.             @Override
  11.             public void onDestroy(@NonNull LifecycleOwner owner) {
  12.                 //doSomething   
  13.             }
  14.         }
  15.         
  16.         public class MainActivity extends AppCompatActivity {\
  17.         
  18.             @override
  19.             public void onCreate(savedInstanceState: Bundle?) {
  20.                 super.onCreate(savedInstanceState)
  21.                 setContentView(R.layout.activity_main)
  22.                 getLifecycle().addObserver(new MyLifeCycleObserver());
  23.             }
  24.         }
复制代码
上面我们学习了使用 Lifecycle 的三种基本方法,下面我们简单看看Lifecycling.getCallback()方法是如何生成GenericLifecycleObserver具体实现类返回的:
//首先,我们先熟悉一下resolveObserverCallbackType这个方法,这个方法在Lifecycling.getCallback()
//中被调用,getCallback中会根据它的返回值决定返回什么类型的GenericLifecycleObserver实现类
  1.     public class MyPresent implements IPresent {
  2.    
  3.         private String TAG = "tag";
  4.    
  5.         @Override
  6.         public void onCreate() {
  7.             LogUtil.i(TAG, "onCreate");
  8.         }
  9.    
  10.         @Override
  11.         public void onStart() {
  12.             LogUtil.i(TAG, "onStart");
  13.         }
  14.    
  15.         @Override
  16.         public void onResume() {
  17.             LogUtil.i(TAG, "onResume");
  18.         }
  19.    
  20.         @Override
  21.         public void onPause() {
  22.             LogUtil.i(TAG, "onPause");
  23.         }
  24.    
  25.         @Override
  26.         public void onStop() {
  27.             LogUtil.i(TAG, "onStop");
  28.         }
  29.    
  30.         @Override
  31.         public void onDestory() {
  32.             LogUtil.i(TAG, "onDestory");
  33.         }
  34. 0
复制代码
好了,Lifecycling.getCallback() 如果真的要详细的分析,篇幅会很大,在这里,我们粗略的分析了下。大家如果想深入了解,自己结合源码看是最好不过的。
总结一下注册的流程:


  • Acitivty 中调用 LifecycleRegistry 的 addObserver,传入一个LifecycleObserver
  • 传入的 LifecycleObserver 被封装成一个 ObserverWithState
    存入集合中,当生命周期发生改变的时候,就会遍历这个ObserverWithState集合,并且调用ObserverWithState的dispatchEvent进行分发
  • 在ObserverWithState构造方法中,调用了Lifecycling.getCallback(observer)生成了具体的
    GenericLifecycleObserver对象返回。在ObserverWithState的dispatchEvent()方法中调用了GenericLifecycleObserver对象的onStateChanged方法进行事件分发
至于注销流程就很简单了,直接将observer从集合中remove,代码如下:
  1.     public class MyPresent implements IPresent {
  2.    
  3.         private String TAG = "tag";
  4.    
  5.         @Override
  6.         public void onCreate() {
  7.             LogUtil.i(TAG, "onCreate");
  8.         }
  9.    
  10.         @Override
  11.         public void onStart() {
  12.             LogUtil.i(TAG, "onStart");
  13.         }
  14.    
  15.         @Override
  16.         public void onResume() {
  17.             LogUtil.i(TAG, "onResume");
  18.         }
  19.    
  20.         @Override
  21.         public void onPause() {
  22.             LogUtil.i(TAG, "onPause");
  23.         }
  24.    
  25.         @Override
  26.         public void onStop() {
  27.             LogUtil.i(TAG, "onStop");
  28.         }
  29.    
  30.         @Override
  31.         public void onDestory() {
  32.             LogUtil.i(TAG, "onDestory");
  33.         }
  34. 1
复制代码
生命周期的分发流程
我们注册observer的时候,实际上是调用了SupportActivity中的mLifecycleRegistry对象的方法,那么我们分析下SupportActivity的onCreate方法:
  1.     public class MyPresent implements IPresent {
  2.    
  3.         private String TAG = "tag";
  4.    
  5.         @Override
  6.         public void onCreate() {
  7.             LogUtil.i(TAG, "onCreate");
  8.         }
  9.    
  10.         @Override
  11.         public void onStart() {
  12.             LogUtil.i(TAG, "onStart");
  13.         }
  14.    
  15.         @Override
  16.         public void onResume() {
  17.             LogUtil.i(TAG, "onResume");
  18.         }
  19.    
  20.         @Override
  21.         public void onPause() {
  22.             LogUtil.i(TAG, "onPause");
  23.         }
  24.    
  25.         @Override
  26.         public void onStop() {
  27.             LogUtil.i(TAG, "onStop");
  28.         }
  29.    
  30.         @Override
  31.         public void onDestory() {
  32.             LogUtil.i(TAG, "onDestory");
  33.         }
  34. 2
复制代码
在onCreate中调用了 ReportFragment 的 injectIfNeedIn 方法。这个方法其实就是往 Activity 中添加了一个 Fragment。我们知道,Fragment是依附于Activity上的,Fragment的生命周期跟随Activity的生命周期。既然这个ReportFragment能够感知Activity的生命周期,那么它是不是就是负责将生命周期事件分发给LifecycleObserver的呢?
  1.     public class MyPresent implements IPresent {
  2.    
  3.         private String TAG = "tag";
  4.    
  5.         @Override
  6.         public void onCreate() {
  7.             LogUtil.i(TAG, "onCreate");
  8.         }
  9.    
  10.         @Override
  11.         public void onStart() {
  12.             LogUtil.i(TAG, "onStart");
  13.         }
  14.    
  15.         @Override
  16.         public void onResume() {
  17.             LogUtil.i(TAG, "onResume");
  18.         }
  19.    
  20.         @Override
  21.         public void onPause() {
  22.             LogUtil.i(TAG, "onPause");
  23.         }
  24.    
  25.         @Override
  26.         public void onStop() {
  27.             LogUtil.i(TAG, "onStop");
  28.         }
  29.    
  30.         @Override
  31.         public void onDestory() {
  32.             LogUtil.i(TAG, "onDestory");
  33.         }
  34. 3
复制代码
ReportFragment 的代码很好理解,我们能够在代码里面发现Lifecycle.Event.xxx事件,并且在它的生命周期回调方法中将Lifecycle.Event.xxx事件传给了dispatch方法,很明显是用来分发生命周期的。在ReportFragment的dispatch方法中,调用了LifecycleRegistry的
  1.     public class MyPresent implements IPresent {
  2.    
  3.         private String TAG = "tag";
  4.    
  5.         @Override
  6.         public void onCreate() {
  7.             LogUtil.i(TAG, "onCreate");
  8.         }
  9.    
  10.         @Override
  11.         public void onStart() {
  12.             LogUtil.i(TAG, "onStart");
  13.         }
  14.    
  15.         @Override
  16.         public void onResume() {
  17.             LogUtil.i(TAG, "onResume");
  18.         }
  19.    
  20.         @Override
  21.         public void onPause() {
  22.             LogUtil.i(TAG, "onPause");
  23.         }
  24.    
  25.         @Override
  26.         public void onStop() {
  27.             LogUtil.i(TAG, "onStop");
  28.         }
  29.    
  30.         @Override
  31.         public void onDestory() {
  32.             LogUtil.i(TAG, "onDestory");
  33.         }
  34. 4
复制代码
可以总结为下面这样一张图:

downEvent 在图中表示从一个状态到他下面的那个状态,upEvent 则是往上。
接下来我们看 sync():
  1.     public class MyPresent implements IPresent {
  2.    
  3.         private String TAG = "tag";
  4.    
  5.         @Override
  6.         public void onCreate() {
  7.             LogUtil.i(TAG, "onCreate");
  8.         }
  9.    
  10.         @Override
  11.         public void onStart() {
  12.             LogUtil.i(TAG, "onStart");
  13.         }
  14.    
  15.         @Override
  16.         public void onResume() {
  17.             LogUtil.i(TAG, "onResume");
  18.         }
  19.    
  20.         @Override
  21.         public void onPause() {
  22.             LogUtil.i(TAG, "onPause");
  23.         }
  24.    
  25.         @Override
  26.         public void onStop() {
  27.             LogUtil.i(TAG, "onStop");
  28.         }
  29.    
  30.         @Override
  31.         public void onDestory() {
  32.             LogUtil.i(TAG, "onDestory");
  33.         }
  34. 5
复制代码
sync() 的主要作用就是根据把 mObserverMap 里所有元素的状态都同步为 mState。
提示:在看这 forwardPass 以及 backwardPass 这两个方法时,参考上面的状态转换图

  • 假设当前集合中所有 ObserverWithState 元素都处于 CREATED 状态。此时接着收到了一个 ON_START
    事件,从图可以看出,接下来应该是要转换到S TARTED 状态。由于 STARTED 大于
    CREATED,所以会执行forwardPass方法。forwardPass里调用
    upEvent(observer.mState),返回从CREATED往上到STARTED需要发送的事件,也就是ON_START,于是ON_START事件发送给了观察者。
  • 假设当前
    LifecycleRegistry的mState处于RESUMED状态。然后调用addObserver方法新添加一个LifecycleObserver,该observer会被封装成ObserverWithState存进集合中,此时这个新的ObserverWithState处于INITIALIZED状态,由于RESUMED大于INITIALIZED,所以会执行forwardPass方法。ObserverWithState的状态会按照
    INITIALIZED -> CREATED -> STARTED -> RESUMED 这样的顺序变迁。
总结

一些个人疑问:
疑点1:为什么不直接在 SupportActivity 的生命周期函数中给 Lifecycle分发生命周期事件,而是要加一个 Fragment 呢?
因为不是所有的页面都继承AppCompatActivity,为了兼容非AppCompatActivity,所以封装一个同样具有生命周期的Fragment来给Lifecycle分发生命周期事件。显然Fragment
侵入性低。
疑点2:为什么用ReportFragment分发生命周期而不直接使用ActivityLifecycleCallbacks 的回调来处理 Lifecycle生命周期的变化?
由于 ActivityLifecycleCallbacks 的回调比 Fragment 和 Activity
还要早,实际上未真正执行对应的生命周期方法
Lifecycle 的分析我们在这里就到此为止了,最后附上幅流程图,帮助理解并记忆:

免费获取安卓开发架构的资料(包括Fultter、高级UI、性能优化、架构师课程、 NDK、混合式开发(ReactNative+Weex)和一线互联网公司关于android面试的题目汇总可以加群:936332305 / 群链接:点击链接加入群聊【安卓开发架构】:https://jq.qq.com/?_wv=1027&k=515xp64

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

1
QQ