导语
还在为View层生命周期的监听而烦恼吗？快来使用 Lifecycle 吧。同时 ，LiveData 与 ViewModel 的也依赖于 Lifecycle 框架。
主要内容
- Lifecycle简介&基础使用
- Lifecycle的原理
具体内容
Lifecycle简介&基础使用
为什么要引进Lifecycle
我们在处理Activity或者Fragment组件的生命周期相关时，不可避免会遇到这样的问题：
我们在Activity的onCreate()中初始化某些成员（比如MVP架构中的Presenter，或者AudioManager、MediaPlayer等），然后在onStop中对这些成员进行对应处理，在onDestroy中释放这些资源，这样导致我们的代码也许会像这样：
class MyPresenter{
public MyPresenter() {
}
void create() {
//do something
}
void destroy() {
//do something
}
}
class MyActivity extends AppCompatActivity {
private MyPresenter presenter;
public void onCreate(...) {
presenter= new MyPresenter ();
presenter.create();
}
public void onDestroy() {
super.onDestroy();
presenter.destory();
}
}
代码没有问题，关键问题是，实际生产环境中 ，这样的代码会非常复杂，你最终会有太多的类似调用并且会导致 onCreate() 和 onDestroy() 方法变的非常臃肿。
解决方案
Lifecycle 是一个类，它持有关于组件（如 Activity 或 Fragment）生命周期状态的信息，并且允许其他对象观察此状态。
Prestener继承LifecycleObserver接口：
public interface IPresenter extends LifecycleObserver {
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
void onCreate(@NotNull LifecycleOwner owner);
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
void onDestroy(@NotNull LifecycleOwner owner);
@OnLifecycleEvent(Lifecycle.Event.ON_ANY)
void onLifecycleChanged(@NotNull LifecycleOwner owner,
@NotNull Lifecycle.Event event);
}
public class BasePresenter implements IPresenter {
private static final String TAG = "com.qingmei2.module.base.BasePresenter";
@Override
public void onLifecycleChanged(@NotNull LifecycleOwner owner, @NotNull Lifecycle.Event event) {
}
@Override
public void onCreate(@NotNull LifecycleOwner owner) {
Log.d("tag", "BasePresenter.onCreate" + this.getClass().toString());
}
@Override
public void onDestroy(@NotNull LifecycleOwner owner) {
Log.d("tag", "BasePresenter.onDestroy" + this.getClass().toString());
}
}
这里我直接将我想要观察到Presenter的生命周期事件都列了出来，然后封装到BasePresenter 中，这样每一个BasePresenter 的子类都能感知到Activity容器对应的生命周期事件，并在子类重写的方法中，对应相应行为。
在Activity/Fragment容器中添加Observer：
public class MainActivity extends AppCompatActivity {
private IPresenter mPresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.d("tag", "onCreate" + this.getClass().toString());
setContentView(R.layout.activity_main);
mPresenter = new MainPresenter(this);
getLifecycle().addObserver(mPresenter);//添加LifecycleObserver
}
@Override
protected void onDestroy() {
Log.d("tag", "onDestroy" + this.getClass().toString());
super.onDestroy();
}
}
如此，每当Activity发生了对应的生命周期改变，Presenter就会执行对应事件注解的方法：
除onCreate和onDestroy事件之外，Lifecycle一共提供了所有的生命周期事件，只要
通过注解进行声明，就能够使LifecycleObserver观察到对应的生命周期事件：
//以下为logcat日志
01-08 23:21:01.702 D/tag: onCreate class com.cc.demo.mvp.ui.MainActivity
01-08 23:21:01.778 D/tag: onCreate class com.cc.demo.mvp.presenter.MainPresenter
01-08 23:21:21.074 D/tag: onDestroy class com.cc.demo.mvp.presenter.MainPresenter
01-08 23:21:21.074 D/tag: onDestroy class com.cc.demo.mvp.ui.MainActivity
Lifecycle的原理
先说结论：
借鉴 Android 架构组件（一）——Lifecycle 的一张图进行简单的概括：
我们先将重要的这些类挑选出来：
- LifecycleObserver接口（ Lifecycle观察者）：实现该接口的类，通过注解的方式，可以通过被LifecycleOwner类的addObserver(LifecycleObserver o)方法注册,被注册后，LifecycleObserver便可以观察到LifecycleOwner的生命周期事件。
- LifecycleOwner接口（Lifecycle持有者）：实现该接口的类持有生命周期(Lifecycle对象)，该接口的生命周期(Lifecycle对象)的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件。
- Lifecycle(生命周期)：和LifecycleOwner不同的是，LifecycleOwner本身持有Lifecycle对象，LifecycleOwner通过其Lifecycle getLifecycle()的接口获取内部Lifecycle对象。
- State(当前生命周期所处状态)：如图所示。
- Event(当前生命周期改变对应的事件)：如图所示，当Lifecycle发生改变，如进入onCreate,会自动发出ON_CREATE事件。
了解了这些类和接口的职责，接下来原理分析就简单很多了，我们以Fragment为例，来看下实际Fragment等类和上述类或接口的联系：
Fragment：LifecycleOwner
Fragment(Activity同理，我们本文以Fragment为例，下同)：实现了LifecycleOwner接口，这意味着Fragment对象持有生命周期对象（Lifecycle），并可以通过Lifecycle getLifecycle()方法获取内部的Lifecycle对象：
public class Fragment implements xxx, LifecycleOwner {
//...省略其他
LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
}
public interface LifecycleOwner {
@NonNull
Lifecycle getLifecycle();
}
可以看到， getLifecycle() 方法返回的是 LifecycleRegistry 对象，而 LifecycleRegistry 对象继承了 Lifecycle ，这个后面再讲。
持有 Lifecycle 有什么用呢？实际上在 Fragment 的生命周期内，都会发送对应的生命周期事件给内部的 LifecycleRegistry 对象处理：
public class Fragment implements xxx, LifecycleOwner {
//...
void performCreate(Bundle savedInstanceState) {
onCreate(savedInstanceState); //1.先执行生命周期方法
//...省略代码
//2.生命周期事件分发
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart() {
onStart();
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
void performResume() {
onResume();
//...
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
void performPause() {
//3.注意，调用顺序变了
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
//...
onPause();
}
void performStop() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
//...
onStop();
}
void performDestroy() {
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
//...
onDestroy();
}
}
随着Fragment不同走到不同的生命周期，除了暴露给我们的生命周期方法 onCreate/onStart/..../onDestroy 等，同时，Fragment内部的Lifecycle对象（就是mLifecycleRegistry）还将生命周期对应的事件作为参数传给了 handleLifecycleEvent() 方法。
同时，你会发现Fragment中performCreate()、performStart()、performResume()会先调用自身的onXXX()方法，然后再调用LifecycleRegistry的handleLifecycleEvent()方法；而在performPause()、performStop()、performDestroy()中会先LifecycleRegistry的handleLifecycleEvent()方法 ，然后调用自身的onXXX()方法。
参照 Android 架构组件（一）——Lifecycle 中的时序图：
我们从图中可以看到，当Fragment将生命周期对应的事件交给其内部的Lifecycle处理后， LifecycleObserver 就能够接收到对应的生命周期事件，这是如何实现的呢？
LifecycleRegistry：Lifecycle
首先确认一点，LifecycleRegistry 就是 Lifecycle 的子类：
public class LifecycleRegistry extends Lifecycle {
}
我们看一下 Lifecycle 类：
public abstract class Lifecycle {
//注册LifecycleObserver （比如Presenter）
public abstract void addObserver(@NonNull LifecycleObserver observer);
//移除LifecycleObserver
public abstract void removeObserver(@NonNull LifecycleObserver observer);
//获取当前状态
public abstract State getCurrentState();
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_ANY
}
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED;
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
}
Lifecycle没什么要讲的，几个抽象方法也能看懂，作为Lifecycle的子类，LifecycleRegistry 同样也能通过addObserver方法注册LifecycleObserver （就是Presenter），当LifecycleRegistry 本身的生命周期改变后（可以想象，内部一定有一个成员变量State记录当前的生命周期），LifecycleRegistry 就会逐个通知每一个注册的LifecycleObserver ，并执行对应生命周期的方法。
我们看一下LifecycleRegistry 的handleLifecycleEvent()方法：
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
State next = getStateAfter(event);
moveToState(next);
}
看方法的名字我们就可以知道，handleLifecycleEvent方法会通过 getStateAfter 获取当前应处的状态并修改 Lifecycle 本身的 State 值，紧接着遍历所 LifecycleObserver 并同步且通知其状态发生变化，因此就能触发 LifecycleObserver 对应的生命周期事件。
