Jetpack架构组件:Lifecycle

前言

Lifecycle,是用于帮助开发者管理Activity和Fragment的生命周期,它是LiveData和ViewModel的基础。

Lifecycle 出现原因

比如说,某个界面中发起了一条网络请求,但是当请求得到响应时,界面或许已经关闭了,这个时候就不应该继续对响应的结果进行处理。因此,需要时刻感知到Activity的生命周期,以便在适当的时候进行相应的逻辑控制。

通常的做法是:监听器的方式来对Activity的生命周期进行感知:

public class ExJetPackActivity extends AppCompatActivity {

    private MyObserver  observer;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_ex_jetpack);
        observer=new MyObserver();
    }
    
    @Override
    protected void onResume() {
        super.onResume();
        observer.activityResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
        observer.activityPause();
    }
    
    class MyObserver implements LifecycleObserver{

        void  activityResume(){
        }
        
        void  activityPause(){
        }
    }
}

可以看到,为了让MyObserver能够感知到Activity 的生命周期,需要重写Activity 相应的生命周期方法,然后再通MyObserver。但实际开发中,可能会有多个组件在Activity的生命周期中进行回调,这样Activity的生命周期的方法中可能就需要放大量的代码,这就使得它们难以维护。如果我们在组件中做了耗时操作(比如在onStart方法),这种写法就无法保证组件在Activity或者Fragment停止之前完成启动。因此我们需要一个能管理Activity和Fragment的生命周期的库,这个库就是Lifecycle。

Lifecycle的使用

依赖

implementation "androidx.lifecycle:lifecycle-extensions:2.2.0"

Lifecycle 用法

新建一个MyObsever 类,并实现LifecycleObserver 接口。

class MyObserver implements LifecycleObserver{

        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        void  activityResume(){
            Log.e(TAG,"执行activityResume()方法");
        }
        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        void  activityPause(){
            Log.e(TAG,"activityPause()方法");
        }
    }

MyObserver实现了接口LifecycleObserver,LifecycleObserver用于标记一个类是生命周期观察者。LifecycleObserver是一个空方法接口,在接口中声明自己定义的方法。然后在activityResume() 方法、activityPause()方法上使用了@OnLifecycleEvent注解,并传入了一种声明生命周期事件。生命周期事件类型有:ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY分别匹配Activity中相应的生命周期回调;另外还有一种ON_ANY类型,表示可以匹配Activity的任何生命周期。

public class ExJetPackActivity extends AppCompatActivity {

    public static final String TAG="ExJetPackActivity";

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_ex_jetpack);
        // 注释1
        getLifecycle().addObserver(new MyObserver());
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.e(TAG,"执行onResume()方法");
    }


    @Override
    protected void onPause() {
        super.onPause();
        Log.e(TAG,"执行onPause()方法");
    }

}

执行结果:
ExJetPackActivity: 执行onResume()方法
ExJetPackActivity: 执行activityResume()方法
ExJetPackActivity: 执行activityPause()方法
ExJetPackActivity: 执行onPause()方法

注释1 处代码调用LifecycleOwner的getLifecycle()方法,得到一个Lifecycle对象,然后再调用addObserver()方法来观察LifecycleOwner的生命周期,再把MyObserver 对象传进去。这样MyObserver就可以观察Activity的生命周期变化了,LifecycleOwner可以理解为被观察者。

只要Activity或者Fragment属于AndroidX库的,他们本身就是一个LifecycleOwner的实例,这部分工作已经由AndroidX库自动帮我们完成了。

自定义LifecycleOwner

如果想实现自定义LifecycleOwner,可以使用LifecycleRegistry,它是Lifecycle的实现类。

public class ExJetPackActivity extends AppCompatActivity {

    public static final String TAG="ExJetPackActivity";

    private LifecycleRegistry registry;
    
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_ex_jetpack);

        registry=new LifecycleRegistry(this);
        registry.setCurrentState(Lifecycle.State.CREATED);
    }

    @Override
    protected void onStart() {
        super.onStart();
        registry.setCurrentState(Lifecycle.State.STARTED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return registry;
    }
    
}

getLifecycle()返回lifecycleRegistry实例。lifecycleRegistry实例则是在onCreate创建,并且在各个生命周期内调用setCurrentState()方法完成生命周期事件的传递。

ProcessLifecycleOwner

使用ProcessLifecycleOwner可以直接获取应用前后台切换状态。

依赖:

implementation "androidx.lifecycle:lifecycle-process:2.3.1"

使用ProcessLifecycleOwner.get()获取ProcessLifecycleOwner,代码如下:

class AppApplication extends Application{
    
    @Override
    public void onCreate() {
        super.onCreate();
        ProcessLifecycleOwner.get().getLifecycle().addObserver(new AppObserver());
    }
}

public class AppObserver implements LifecycleObserver {

    private static final String TAG = "AppObserver";

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    private void onAppForeground() {
        Log.e(TAG, "进入前台");
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    private void onAppBackground() {
        Log.w(TAG, "进入后台");
    }

}

Lifecycle 生命周期状态与事件

MyObserver 能够感知到Activity 的生命周期发生变化,同时要想主动获取当前的生命周期状态,可以在MyObserver 的构造函数中将Lifecycle对象传进来即可。

class MyObserver implements LifecycleObserver{
    private Lifecycle mLifecycle;
    
    public MyObserver(Lifecycle mLifecycle){
        this.mLifecycle=mLifecycle;
    }
     
 }

有了Lifecycle对象之后,可以调用lifecycle.currentState来主动获知当前的生命周期状态。

Lifecycle 事件和状态:

// 事件
public enum Event {
        /**
         * Constant for onCreate event of the {@link LifecycleOwner}.
         */
        ON_CREATE,
        /**
         * Constant for onStart event of the {@link LifecycleOwner}.
         */
        ON_START,
        /**
         * Constant for onResume event of the {@link LifecycleOwner}.
         */
        ON_RESUME,
        /**
         * Constant for onPause event of the {@link LifecycleOwner}.
         */
        ON_PAUSE,
        /**
         * Constant for onStop event of the {@link LifecycleOwner}.
         */
        ON_STOP,
        /**
         * Constant for onDestroy event of the {@link LifecycleOwner}.
         */
        ON_DESTROY,
        /**
         * An {@link Event Event} constant that can be used to match all events.
         */
        ON_ANY
    }
    
 // 状态
public enum State {
        /**
         * Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch
         * any more events. For instance, for an {@link android.app.Activity}, this state is reached
         * right before Activity's {@link android.app.Activity#onDestroy() onDestroy} call.
         */
        DESTROYED,

        /**
         * Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is
         * the state when it is constructed but has not received
         * {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.
         */
        INITIALIZED,

        /**
         * Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state
         * is reached in two cases:
         * 
    *
  • after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call; *
  • right before {@link android.app.Activity#onStop() onStop} call. *
*/
CREATED, /** * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state * is reached in two cases: *
    *
  • after {@link android.app.Activity#onStart() onStart} call; *
  • right before {@link android.app.Activity#onPause() onPause} call. *
*/
STARTED, /** * Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state * is reached after {@link android.app.Activity#onResume() onResume} is called. */ RESUMED; }

事件和状态对应关系:
Jetpack架构组件:Lifecycle_第1张图片

你可能感兴趣的:(AndRoid,基础与进阶,jetpack,Lifecycle)