Jetpack之Lifecycle
1.什么是Lifecycle
Lifecycle是具备宿主生命周期感知能力的组件。它能持有组件（如Activity或Fragment）生命周期状态的信息，并且允许其他观察者监听宿主的状态。它也是Jetpack组件库的核心基础，包括我们就会讲到的LiveData，ViewModel组件等也都是基于它来实现的。
再也不用手动分发宿主生命周期，再也不用手动反注册了
2.Lifecycle的使用方法
使用Lifecycle前需要先添加依赖：
//通常情况下，只需要添加appcompat就可以了
api 'androidx.appcompat:appcompat:1.1.0'
//如果想单独使用，可引入下面这个依赖
api 'androidx.lifecycle:lifecycle-common:2.1.0'
复制代码被观察者
通过实现LifecycleOwner接口
androidx中的ComponentActivity和Fragment自生都已经实现了LifecycleOwner。
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner,
ViewModelStoreOwner,
HasDefaultViewModelProviderFactory,
SavedStateRegistryOwner,
OnBackPressedDispatcherOwner {}
//androidx.fragment.app.Fragment
public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
ViewModelStoreOwner, HasDefaultViewModelProviderFactory, SavedStateRegistryOwner {}
复制代码如果要自己实现可以参考androidx的Activity和Fragment的实现。
观察者
方式一：LifecycleObserver配合注解
//1. 自定义的LifecycleObserver观察者，用注解声明每一个观察者的宿主状态
class LocationObserver implements LifecycleObserver{
//宿主执行了onstart时，会分发该事件
@OnLifecycleEvent(Lifecycle.Event.ON_START)
void onStart(@NotNull LifecycleOwner owner){
//开启定位
}
//宿主执行了onstop时 会分发该事件
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
void onStop(@NotNull LifecycleOwner owner){
//停止定位
}
}
//2. 注册观察者,观察宿主生命周期状态变化
class MyFragment extends Fragment{
public void onCreate(Bundle bundle){
LocationObserver observer =new LocationObserver()
getLifecycle().addObserver(observer);
}
}
复制代码方式二：实现FullLifecyclerObserver接口
class LocationObserver implements FullLifecycleObserver{
void onCreate(LifecycleOwner owner);
void onStart(LifecycleOwner owner);
void onResume(LifecycleOwner owner);
void onPause(LifecycleOwner owner);
void onStop(LifecycleOwner owner);
void onDestroy(LifecycleOwner owner);
}
复制代码方式三：LifecycleEventObserver宿主生命周期事件封装成Lifecycle.Event
//1.源码
public interface LifecycleEventObserver extends LifecycleObserver {
void onStateChanged(LifecycleOwner source, Lifecycle.Event event);
}
//2.用法
class LocationObserver extends LifecycleEventObserver{
@override
void onStateChanged(LifecycleOwner source, Lifecycle.Event event){
//需要自行判断life-event是onstart, 还是onstop
}
}
复制代码上面的这两种Lifecycle写法比较推荐第二种和第三种，因为第一种你虽然用注解很爽，但是如果没有添加lifecycle-compiler这个注解处理器的话，运行时会使用反射的形式回调到对应的方法上。
订阅关系
//被观察者.addObserver(观察者)
getLifecycle().addObserver(presenter);
复制代码3.实现原理
引入的库
dependencies {
implementation "androidx.lifecycle:lifecycle-runtime:2.0.0"
implementation "androidx.lifecycle:lifecycle-extensions:2.0.0"
implementation "androidx.lifecycle:lifecycle-common-java8:2.0.0"
annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.0.0"
}
复制代码核心类
事件在分发宿主生命期事件的流程中涉及到三个类：
- LifecycleOwner ：Activity和Fragment都实现了该接口，用以生命周期观察，它是一个能够提供生命周期事件的宿主 。同时必须复写getLifecycle()方法提供一个Lifecycle对象；可以将其理解为观察者模式中的Observable。
- Lifecycle ：是一个抽象类 ，里面定义了两个枚举State宿主的状态，Event需要分发的事件的类型；
- LifecycleRegistry ：是Lifecycle的唯一实现类 ，主要用来负责注册Observer ，以及分发宿主状态事件给它们。LifecycleRegistr聚合多个LifecycleObserver，生命周期改变时通知LifecycleObserver进行相应的方法调用。
具体的类关系请看下面的Fragment的基本实现。
宿主生命周期监听
Fragment是如何实现Lifecycle的？
使用Fragment实现Lifecycle需要在各个生命周期方法内里用LifecycleRegistry分发相应的事件给每个观察者，以实现生命周期观察的能力：
public class Fragment implements LifecycleOwner {
LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
//复写自LifecycleOwner,所以必须new LifecycleRegistry对象返回
return mLifecycleRegistry;
}
void performCreate(){
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart(){
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
}
.....
void performResume(){
mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
}
}
复制代码Activity是如何实现Lifecycle的？
Activity实现Lifecycle需要借助于ReportFragment往Activity上添加一个fragment用以报告生命周期的变化。目的是为了兼容不是集成自
AppCompactActivity的场景，同时也支持我们自定义LifecycleOwener的场景。
public class ComponentActivity extends Activity implements LifecycleOwner{
private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
protected void onCreate(Bundle bundle) {
super.onCreate(savedInstanceState);
//往Activity上添加一个fragment,用以报告生命周期的变化
//目的是为了兼顾不是继承自AppCompactActivity的场景.
ReportFragment.injectIfNeededIn(this);
}
复制代码注意：ComponentActivity的部分生命周期是自己实现的，并不是全部都是ReportFragment实现的。
ReportFragment核心源码
这里的实现其实跟Fragment中的源码是一样的，在各个生命周期方法内利用LifecycleRegistry派发相应的Lifecycle.Event事件给每个观察者。
注意：在具体的生命周期的调用上有所差异：
SDK>=29:用LifecycleCallbacks进行回调
SDK<29:用ReportFragment的生命周期中调用
public class ReportFragment extends Fragment{
public static void injectIfNeededIn(Activity activity) {
//注意：在29以后对Activity注册了一个LifecycleCallbacks，这里的dispatch的调用时机有所差异
if (Build.VERSION.SDK_INT >= 29) {
activity.registerActivityLifecycleCallbacks(
new LifecycleCallbacks());
}
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
manager.executePendingTransactions();
}
}
@Override
public void onStart() {
super.onStart();
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatch(Lifecycle.Event.ON_RESUME);
}
@Override
public void onPause() {
super.onPause();
dispatch(Lifecycle.Event.ON_PAUSE);
}
@Override
public void onDestroy() {
super.onDestroy();
dispatch(Lifecycle.Event.ON_DESTROY);
}
//只要<29才借助的ReportFragment的生命周期
private void dispatch(@NonNull Lifecycle.Event event) {
if (Build.VERSION.SDK_INT < 29) {
dispatch(getActivity(), event);
}
//29之后的另外处理
}
//最终收拢在这里处理
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
//兼容Activity自己实现的LifecycleRegistryOwner
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);
}
}
}
}
复制代码SDK29以后的实现调用
//ReportFragment的静态内部类
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
@Override
public void onActivityCreated(@NonNull Activity activity,
@Nullable Bundle bundle) {
}
@Override
public void onActivityPostCreated(@NonNull Activity activity,
@Nullable Bundle savedInstanceState) {
//调用的是静态方法
dispatch(activity, Lifecycle.Event.ON_CREATE);
}
@Override
public void onActivityStarted(@NonNull Activity activity) {
}
@Override
public void onActivityPostStarted(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_START);
}
@Override
public void onActivityResumed(@NonNull Activity activity) {
}
@Override
public void onActivityPostResumed(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_RESUME);
}
@Override
public void onActivityPrePaused(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_PAUSE);
}
@Override
public void onActivityPaused(@NonNull Activity activity) {
}
@Override
public void onActivityPreStopped(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_STOP);
}
@Override
public void onActivityStopped(@NonNull Activity activity) {
}
@Override
public void onActivitySaveInstanceState(@NonNull Activity activity,
@NonNull Bundle bundle) {
}
@Override
public void onActivityPreDestroyed(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_DESTROY);
}
@Override
public void onActivityDestroyed(@NonNull Activity activity) {
}
}
复制代码在Activity中的生命周期对进行回调
//Activity
private void dispatchActivityCreated(@Nullable Bundle savedInstanceState) {
getApplication().dispatchActivityCreated(this, savedInstanceState);
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i = 0; i < callbacks.length; i++) {
((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityCreated(this,
savedInstanceState);
}
}
}
private void dispatchActivityPostCreated(@Nullable Bundle savedInstanceState) {
Object[] callbacks = collectActivityLifecycleCallbacks();
if (callbacks != null) {
for (int i = 0; i < callbacks.length; i++) {
//回调监听
((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityPostCreated(this,
savedInstanceState);
}
}
getApplication().dispatchActivityPostCreated(this, savedInstanceState);
}
复制代码而dispatch()方法则会判断Activity是否实现了LifecycleOwner接口，如果实现了该接口就调用LifecycleRegister的handleLifecycleEvent()
这样生命周期的状态就会借由LifecycleRegistry通知给各个LifecycleObserver从而调用其中对应Lifecycle.Event的方法。这种通过Fragment来感知Activity生命周期的方法其实在Glide的中也是有体现的。
宿主生命周期与宿主状态模型图
LifecycleRegistry在分发事件的时候会涉及到两个概念：
- 宿主生命周期 ：就是我们烂熟于心的onCreate,onStart,onResume,onPause,onStop...；
- 宿主的状态 ：这个不是很好理解，这个意思是指宿主执行了上述方法后，它处于对应周期的生命状态。
从下面这张图不难看出宿主生命周期与宿主状态的对应关系分裂为onCreate-Created、onStart-Started、onResume-Resumed、onPause-Started、onStop-Created、onDestroy-Destroyed，这里不用全部记住有个印象即可。
添加observer时，完整的生命周期事件分发
基于Lifecycle的特性我们在任意生命周期方法内注册观察者都能接受到完整的生命周期事件，比如在onResume中注册一个观察者，它会依次收到：
LifecycleEvent.onCreate -> LifecycleEvent.onStart -> LifecycleEvent.onResume
复制代码分发同步生命周期
添加Observer时完整的生命周期事件分发
这一点需要掌握，面试中是肯定会考察的。但是如果没有看过源码是回答不上来的：
public void addObserver(@NonNull LifecycleObserver observer) {
//1.初始状态。添加新的Observer时，会首先根据宿主的状态计算出它的初始状态，只要不是在onDestroy中注册的，它的初始状态都是INITIALIZED
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//2.将观察者和状态封装。
//会把observer包装成ObserverWithState，这个类主要是包含了观察者及其状态。每个事件都会经由这个对象类转发,这个类后面会来分析
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//3.添加到集合，如果之前已经添加过了，则return
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
if (previous != null) {
return;
}
State targetState = calculateTargetState(observer);
//4.同步状态
//这里的while循环，是实现上图状态同步与事件分发的主要逻辑
//拿观察者的状态和宿主当前状态做比较，如果小于0，说明两者状态还没有对齐。
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
//接着就会分发一次相应的事件，于此同时statefulObserver的mState对象也会被升级
//假设是在宿主的onresume方法内注册的该观察者
//第一次：分发on_Create事件，观察者状态INIT->CREATED
//第二次：分发on_Start事件，观察者状态CREATED->STARTED
//第三次：分发on_Resume事件，观察者状态STARTED->RESUMED
statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
//再一次计算观察者应该到达的状态，在下一轮循环中和宿主状态在做比较，知道两者状态对齐，退出循环。
targetState = calculateTargetState(observer);
}
}
复制代码宿主生命周期变化后相应事件的分发
这一点了解即可，面试中也不会考这一部分的内容：
//宿主生命周期变化时触发
public void handleLifecycleEvent(@NonNull Lifecycle.Event event){
//宿主的每个生命周期的变化都会分发一个对应的Lifecycle.Event，走到这里
//此时会根据需要分发的事件反推出宿主当前的状态
State next = getStateAfter(event);
// moveToState方法只是将传入的宿主新的state和前持有宿主状态作比对，然后保存一下。
moveToState(next);
}
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;
}
//如果宿主状态有变动，则调用sync方法来完成事件的分发和观察者状态的同步
private void sync() {
while (!isSynced()) {
//如果宿主当前转态 小于 mObserverMap集合中最先添加的那个观察者的状态
//则说明宿主可能发生了状态回退，比如当前是RESUMED状态，执行了onPause则回退到STARTED状态
//此时调用backwardPass把集合中的每个一观察者分发一个on_pause事件，并同步它的状态。
if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
backwardPass(lifecycleOwner);
}
//如果宿主当前转态 大于 mObserverMap集合中最先添加的那个观察者的状态
//则说明宿主可能发生了状态前进，比如当前是STARTED状态，执行了onResume则前进到RESUMED状态
//此时调用forwardPass把集合中的每个一观察者分发一个on_resume事件，并同步它的状态。
Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
if (!mNewEventOccurred && newest != null
&& mState.compareTo(newest.getValue().mState) > 0) {
forwardPass(lifecycleOwner);
}
}
}
复制代码同步状态
ObserverWithState：持有观察者及其状态的内部类
把传入的LifecycleObserver适配成LifecycleEventObserver，目的是为了统一事件的分发形式。
持有观察者的状态，方便与宿主状态做比对同步：
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
//把传入的LifecycleObserver适配成LifecycleEventObserver，目的是为了统一事件的分发形式
//因为我们前面提到观察者有三种类型,每种类型接收事件的形式并不一样，如果在分发的时候不统一事件分发的形式，将会变得很麻烦
//至于是如何适配转换的，由于不是本文重点，所以不再详细展开
//但核心思想这里说明一下，同学们自行看下就能明白
//它会判断传入的observer是前面提到的那一种类型，进而转换成对应的适配器类，适配器类会对onStateChanged方法进行适配，并以相应的方式(反射、中转、)把事件转发到我们的observer上
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
//再一次根据需要分发的事件类型反推出该观察者的状态,这样的好处是事件 & 状态 一一对应，不会出现跳跃。但阅读上可能会稍微有点绕
State newState = getStateAfter(event);
mState = min(mState, newState);
//把事件分发给被包装的对象，完成本次流程。
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
复制代码4.总结
本篇从三种用法+分发原理+面试考点 三个维度展开对Lifecycle组件的介绍，现在相信同学们已经掌握了Lifecycle的核心了。Lifecycle组件是Jetpack组件库的核心，一旦跟宿主生命周期挂钩，那可以做很多文章，后面讲到的LiveData、ViewModel都是基于它来实现的。
5.拓展
基于Lifecycle实现APP前后台切换事件观察的能力。
参考：使用 ProcessLifecycle 优雅地监听应用前后台切换
class AppLifecycleOwner implements LifecycleOwner{
LifecycleRegistry registry = new LifecycleRegistry(this)
@override
Lifecycle getLifecycle(){
return registry
}
void init(Application application){
//利用application的 ActivityLifecycleCallbacks 去监听每一个 Activity的onstart,onStop事件。
//计算出可见的Activity数量，从而计算出当前处于前台还是后台。然后分发给每个观察者
}
}作者：贾里
链接：https://juejin.cn/post/6953218024329445389
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
