Android Jetpack-Lifecycle

Android Jetpack-Lifecycle

为什么要使用Lifecycle？

Activity和Fragment是有生命周期的，有时候，我们的很多操作需要写在生命周期的方法中，比如，下载，文件操作等，这样很多情况下会导致，我们在Activity的生命周期方法中写越来越多的代码，Activity或者Fragment越来越臃肿，代码维护越来越困难。使用Lifecycle就可以很好的解决这类问题。Lifecycle代码简洁，我们可以通过实现LifecycleObserver接口，来监听生命周期，然后我们在Activity或者Fragment中去注册监听。

1. 几个重要的类和接口

• Lifecycle：Lifecycle是一个持有组件生命周期状态的信息的类，并允许其他对象观察此状态。
• Event：从框架和Lifecycle类派生的生命周期事件。这些事件映射到活动中的回调事件。
• State：由Lifecycle对象跟踪的组件的当前状态。
• LifecycleOwener：Lifecycle的持有者
  • 实现该接口的类持有生命周期（Lifecycle对象），该接口的生命周期（Lifecycle对象）的改变会被其注册的观察者LifecycleObserver观察到并触发其对应的事件。
• LifecycleObserver：Lifecycle观察者
  • 实现该接口的类，通过注解的方式，可以被LifecycleOwener类的addObserver(LifecycleObserver o)方式注册，被注册后，LifecycleObserver便可以观察到LifecycleOwener的生命周期。

LifecycleOwener

官网介绍

LifecycleOwner 是单一方法接口，表示类具有 Lifecycle。它具有一种方法（即 getLifecycle()），该方法必须由类实现。如果您尝试管理整个应用进程的生命周期，请参阅 ProcessLifecycleOwner。

此接口从各个类（如 Fragment 和 AppCompatActivity）抽象化 Lifecycle 的所有权，并允许编写与这些类搭配使用的组件。任何自定义应用类均可实现 LifecycleOwner 接口。

实现 LifecycleObserver 的组件可与实现 LifecycleOwner 的组件无缝协同工作，因为所有者（owener）可以提供生命周期，而观察者可以注册以观察生命周期。

简单来说，LifecycleOwener就是一个接口，谁实现了该接口，就持有一个Lifecycle对象，通过getLifecycle()方法返回一个继承了抽象类Lifecycle的LifecycleRegistry，然后调用addObserver()方法来注册监听。这样，该接口的生命周期（Lifecycle对象）的改变会被其注册的观察者LifecycleObserver观察到并触发对应的事件。

注意：Support Library 26.1.0及其以后的版本，Activity和Fragment已经实现了LifecycleOwener接口，所以，我们可以直接在Activity和Fragment中使用getLifecycle()方法来获取Lifecycle对象，并添加观察者监听。

LifecycleObserver

LifecycleObserver是一个观察者接口，实现了它，可以通过注解的方式，来管理生命周期的监听。只要在持有Lifecycle的类中注册了它，当生命周期发生变化时，它就能收到，进行我们自定义的操作。

2. 使用Lifecycle

1. 先写一个Presenter类，实现LifecycleObserver

public class Presenter implements LifecycleObserver {

    private static final String TAG = "Presenter";

    private LifecycleRegistry registry;
    public Presenter(LifecycleRegistry registry){
        this.registry = registry;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate(){
        Log.d("Lifecycle", "MainActivity: "+registry.getCurrentState().name());
        Log.d("Lifecycle", TAG+" onCreate: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart(){
        Log.d("Lifecycle", "MainActivity: "+registry.getCurrentState().name());
        Log.d("Lifecycle", TAG+" onStart: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume(){
        Log.d("Lifecycle", "MainActivity: "+registry.getCurrentState().name());
        Log.d("Lifecycle", TAG+" onResume: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause(){
        Log.d("Lifecycle", "MainActivity: "+registry.getCurrentState().name());
        Log.d("Lifecycle", TAG+" onPause: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop(){
        Log.d("Lifecycle", "MainActivity: "+registry.getCurrentState().name());
        Log.d("Lifecycle", TAG+" onStop: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy(){
        Log.d("Lifecycle", "MainActivity: "+registry.getCurrentState().name());
        Log.d("Lifecycle", TAG+" onDestroy: ");
    }
}

2.在Activity中注册这个观察者

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    private LifecycleRegistry registry;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d("Lifecycle", TAG+" onCreate: ");
        registry = (LifecycleRegistry) getLifecycle();
        Presenter presenter = new Presenter();
        registry.addObserver(presenter);

    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d("Lifecycle", TAG+" onStart: ");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d("Lifecycle", TAG+" onResume: ");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d("Lifecycle", TAG+" onPause: ");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d("Lifecycle", TAG+" onStop: ");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d("Lifecycle", TAG+" onDestroy: ");
    }
}

通过getLifecycle()获得MainActivity的Lifecycle对象，通过该对象添加观察者。

3. 运行效果

可以看到，当运行之后，Presenter中注解为@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)的方法，与MainActivity的onCreate()几乎同时执行。

点击返回，退出程序。

3. 注意

• 生命周期状态为CREATED时，表示onCreate()方法刚执行完或者onStop()方法刚执行完，也就是当前Activity不在前台，但是也没有处于销毁状态
• 生命周期状态为STARTED时，表示当前Activity处于可见但是不可交互，也就是onStart()方法刚执行完或者onPause()方法刚执行玩 的状态
• 生命周期状态为RESUMED时表示，当前Activity是在前台，并且可交互也就是在onResume()执行后
• 生命周期状态为DESTROYED，表示当前Activity还不存在，没有创建或者已经销毁，我们通常考虑较多的就是onDestroy()方法执行后，当前Activity已经销毁。

所以，如果我们要保证在Activity或者Fragment的有效生命周期内进行的操作，必须判断，当前lifecycle的状态是否至少是CREATED状态，避免Activity或者fragment销毁了以后，回调或者网络请求才回来，此时做一些操作会导致异常。

添加以下代码，就是我们把lifecycle对象传给观察者，让它自己去判断回调后的代码，保证至少是CREATED状态

private Lifecycle lifecycle;
   public MyObserver(Lifecycle lifecycle) {
        this.lifecycle = lifecycle;
    }
//然后再相应的回调方法中使用下面代码判断，保证数据回调回来，当前activity是存在的
    if (lifecycle.getCurrentState().isAtLeast(CREATED)) {
            //这里只是示例，不一定是CREATED
    }