欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Android Jetpack-Lifecycle

程序员文章站 2022-06-09 23:33:27
...

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

此接口从各个类(如 FragmentAppCompatActivity)抽象化 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. 运行效果

Android Jetpack-Lifecycle

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

点击返回,退出程序。

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
    }
相关标签: Android jetpack