Jetpack系列 - Lifecycle

前言

本文将开始Jetpack系列之Lifecycle的学习，为什么先说Lifecycle呢，因为Lifecycle是Jetpack的核心，我们熟悉的ViewModel,LiveData都是基于它实现的。（关于Jetpack大家也可以直接看Jetpack官网）

看完本文可以达到什么程度

掌握Lifecycle的基本原理及使用
掌握Activity Fragment是如何实现Lifecycle的。
掌握Lifecycle宿主分发

如果您已经达到上面的程度，那么可以不看下文了；

什么是Jetpack

简单点总结就是：Jetpack是众多组件的统称，而AndroidX是这些组件的统一包名。

什么是Lifecycle

Lifecycle也即是Jetpack众多组件之一，这个组件库代码也就是小十个类，如下：

Lifecycle库.png

简单点总结就是：Lifecycle组件抽象出了一套观察者(继承LifecycleObserver)，被观察者(继承LifecycleOwner,例如Fragment)，以及他们两之间事件分发的能力。

Lifecycle简单流程.png

Lifecycle是一个能感知宿主(LifecycleOwner)生命周期的组件。
允许其它观察者监听宿主生命周期状态。
省略了以前手动分发宿主生命周期的操作.(例如在onDestroy中去调用三方组件的销毁)。
宿主如何分发生命周期状态？之后再详细分析。

Lifecycle的使用

1). 首先得添加依赖，以下两种选一种就行

 //通常情况下，只需要添加appcompat就可以了
api 'androidx.appcompat:appcompat:1.1.0'
 //如果想单独使用，可引入下面这个依赖
api 'androidx.lifecycle:lifecycle-common:2.1.0'

2). 使用有如下三种方式：

实现LifecycleObserver，并使用@OnLifecycleEvent注解

// 1.自定义的组件，也是LifecycleObserver观察者
class MyObserver implements LifecycleObserver {
    // 在对应的方法上用注解声明想要观察的宿主生命周期
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreate(LifecycleOwner owner){
        // 宿主(例如Fragment)的onCreate事件分发
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void onDestroy(LifecycleOwner owner){
        // 宿主(例如Fragment)的onDestroy事件分发
    }
}
// 1.Fragment继承了LifecycleOwner，是个宿主
// 2.注册观察者,观察宿主生命周期变化
class MyFragment extends Fragment {
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        MyObserver observer = new MyObserver();
        getLifecycle().addObserver(observer);
    }
}

实现FullLifecyclerObserver，拥有生命周期所有事件，但FullLifecyclerObserver类对外不可见。

class MyObserver1 implements FullLifecycleObserver {
    @Override
    public void onCreate(LifecycleOwner owner) {
    }
    @Override
    public void onStart(LifecycleOwner owner) {
    }
    @Override
    public void onResume(LifecycleOwner owner) {
    }
    @Override
    public void onPause(LifecycleOwner owner) {
    }
    @Override
    public void onStop(LifecycleOwner owner) {
    }
    @Override
    public void onDestroy(LifecycleOwner owner) {
    }
}

LifecycleEventObserver宿主生命周期事件封装成 Lifecycle.Event，观察者根据Lifecycle.Event区分宿主的不同生命周期

// 源码
public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

class MyObserver2 implements LifecycleEventObserver {
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        switch (event){
            case ON_CREATE:
                // 宿主onCreate生命周期
                break;
            case ON_DESTROY:
                // 宿主onDestroy生命周期
                break;
        }
    }
}

3). 我们的Activity跟Fragment都是LifecycleOwner；也就是说一些自定义组件可以通过addObserver，在组件内部获得Activity跟Fragment的生命周期回调；举个例子：

/**
*  倒计时组件
*  1. 最原始的做法我们需要在Activity或Fragment的onDestroy中手动去停止。万一漏了就可能造成内存泄漏问题。
*  2. 有了Lifecycle，就能在组件内部去处理，再也不怕内存泄漏了
*/
public class CountDownTextView extends AppCompatTextView implements LifecycleObserver {
public CountDownTextView(......) {
        super(......);
        // 自动注册
        autoBindLifecycle(context);
    }
}
private void autoBindLifecycle(Context context) {
    ...
    xxx.getLifecycle().addObserver(this);
    ...
}

@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
private void onDestroy() {
    // 自动去做一些停止，释放资源等操作
    ......
}

Fragment如何实现Lifecycle

先看看整体架构图：

Lifecycle-fragment架构.png

Fragment中代码如下：

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);
  }  
}

Fragment实现了LifecycleOwner接口，是一个能提供生命周期事件的宿主

Fragment中通过Lifecycle addObserver()，来添加观察者。

Fragment中通过Lifecycle的具体实现类LifecycleRegistry来进行生命周期事件的分发。

Activity如何实现Lifecycle

Activity的实现跟Fragment稍有不同，不是利用自己的生命周期去分发事件，而是添加一个Fragment，通过Fragment的生命周期去分发。(为啥这样设计？？)

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); 
}

ReportFragment的实现原理跟Fragment类似，通过LifecycleRegistry对生命周期事件分发。

public class ReportFragment extends Fragment{
    public static void injectIfNeededIn(Activity activity) {
        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);
    }
    private void dispatch(Lifecycle.Event event) {
         Lifecycle lifecycle = activity.getLifecycle();
         if (lifecycle instanceof LifecycleRegistry) {
             ((LifecycleRegistry)   lifecycle).handleLifecycleEvent(event);
         }
}

生命周期事件及状态

先明确两个概念：Lifecycle类中有两个枚举，Event(事件),State(状态)。

Event：当宿主的生命周期有变化时，会发送相应的事件Event,如下：

void performCreate(Bundle savedInstanceState) {
  mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}

State：Lifecycle的实现类LifecycleRegistry中保存了mState，代表当前宿主的状态；宿主发送不同的事件，相应的State也会变化。

Event和State关系如下：

Lifecycle事件及状态.png

事件分发原理

首先先思考一个问题：如果是在Fragment的onResume中注册一个Observer，这个Observer还能收到Fragment的oncreate,onstart,onresume事件吗？
这里先给答案：可以收到，这几个事件在addObserver方法中就会去分发。
以这个为例来讲讲lifecycle的事件分发原理，主要看下LifecycleRegistry流程，先见下图：

LifecycleRegistry主要流程.png

上图就是一个大致的了解，要详细的认知还是得看源码：

Step1:初始化

public LifecycleRegistry(@NonNull LifecycleOwner provider) {
        mLifecycleOwner = new WeakReference<>(provider);
        mState = INITIALIZED;
    }

这个构造方法就是在Fragment的构造方法中调用，主要是对mState做了个初始化INITIALIZED

Step2：注册Observer

以下代码只展示一些主流程

public void addObserver(@NonNull LifecycleObserver observer) {
        // 1.添加新的Observer时，会根据宿主状态计算observer的初始状态
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        // 2.把初始状态跟observer封装成一个新的对象ObserverWithState
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        // 3. 计算宿主对象的状态
        State targetState = calculateTargetState(observer);
        ......
}

// Observer对象的封装对象
static class ObserverWithState {
        State mState;
      // 所有的Observer会转成LifecycleEventObserver类型
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            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;
        }
    }

把observer与State封装成ObserverWithState，这个对象对把observer统一转成LifecycleEventObserver类型；怎么转的大家可以详细看下Lifecycling中lifecycleEventObserver，这里不展开叙述了

Step3:对比Observer状态跟宿主状态

public void addObserver( LifecycleObserver observer) {
      以上是Step2
      ......
      // 1. 拿观察者的状态和宿主当前状态做比较，如果小于0，说明两者状态还没有对齐
      while ((statefulObserver.mState.compareTo(targetState) < 0,...){
          ......
      // 2.接着就会分发一次相应的事件，于此同时statefulObserver的mState对象也会被升级
          statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
      // 3.再一次计算观察者应该到达的状态
          targetState = calculateTargetState(observer);
      }
}

在以上三步后，在onResume中注册的Observer就能收到oncreate,onstart,onresume三个事件。当宿主在执行其他的生命周期时，会通过handleLifecycleEvent发送相应的事件。

Step4:宿主发送相应事件

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
      // 1. 获取事件相对应的状态
        State next = getStateAfter(event);
      // 2.同步到该状态，给所有的Observer发送事件
        moveToState(next);
    }

总结

看完本篇再回到开头的几项目标，是不是都掌握了呢？还没掌握可以对着源码再细细屡屡，相信一定能掌握Lifecycle的核心，之后要讲的LiveData，ViewModel都是基于它来实现的。