Jetpack 之 LifeCycle 组件使用详解,【金三银四

二、LifeCycle 的使用

=============================================================================

Jetpack 为我们提供了两个接口:

被观察者:LifecycleOwner

观察者:LifecycleObserver

被监听的系统组件需要去实现 LifecycleOwner 接口,观察者需要实现 LifecycleObserver 接口。

(一)使用场景1:使用 LifeCycle 解耦页面与组件


(1)解耦 Activity

第一步:添加依赖

Jetpack 之 LifeCycle 组件使用详解,【金三银四

implementation ‘androidx.appcompat:appcompat:1.2.0’

在 AndroidX 里面 ComponentActivity 已经默认实现了 LifecycleOwner 接口。如果项目没有迁移到 AndroidX,还是用的 Support 库,新版本的 SDK 也通过 SupportActivity 实现了 LifecycleOwner 接口。

Jetpack 之 LifeCycle 组件使用详解,【金三银四

在 LifecycleOwner 接口中,只有一个 getLifecycle 方法。

第二步:实现观察者

如果是想监听某个 Activity 的生命周期,需要我们做的就是自定义组件,实现 LifecycleObserver 接口即可,该接口没有接口方法,不需要任何具体的实现。

比如以刚刚的视频播放为例:

  1. 创建一个 MyVideoPlayListener 类,实现 LifecycleObserver 接口,与视频播放相关的逻辑全在这个类里面完成。对于组件里面需要在 Activity 生命周期变化时得到通知的方法,用 @OnLifecycleEvent(Lifecycle.Event.ON_XXX) 注解进行标记,这样当 Activity 生命周期发生变化时,被标记过的方法便会被自动调用。

public class MyVideoPlayListener implements LifecycleObserver {

private static String TAG = “MyVideoPlayListener”;

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)

private void initVideo(){

Log.d(TAG,“initVideo”);

}

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)

private void startPlay(){

Log.d(TAG,“startPlay”);

}

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)

private void pausePlay(){

Log.d(TAG,“pausePlay”);

}

}

2.在 MainActivity 中对 MyVideoPlayListener 进行引用即可。

public class MainActivity extends AppCompatActivity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

MyVideoPlayListener listener = new MyVideoPlayListener();

getLifecycle().addObserver(listener);

}

}

(2)解耦 Fragment

在新版的 SDK 中,Fragment 同样也默认实现了 LifecycleOwner 接口,因此,以上的例子同样适合于 Fragment。

(二)使用场景2:使用 LifecycleService 解耦 Service 与组件


(1)LifecycleService 基本介绍

Android 中拥有生命周期的组件除了 Activity/Fragment ,还有一个非常重要的组件就是 Service。LifecycleService 就是用来监听和解耦 Service 组件的。

public class LifecycleService extends Service implements LifecycleOwner {

private final ServiceLifecycleDispatcher mDispatcher = new ServiceLifecycleDispatcher(this);

@Override

@NonNull

public Lifecycle getLifecycle() {

return mDispatcher.getLifecycle();

}

}

(2)具体使用方法

第一步:添加相关依赖

implementation “androidx.lifecycle:lifecycle-service:2.2.0”

第二步:创建 MyServiceObserver 类,实现 LifecycleObserver 接口。使用 @OnLifecycleEvent 标记希望在 Server 生命周期发生变化时得到同步调用的方法。

public class MyServiceObserver implements LifecycleObserver {

private static String TAG = “MyServiceObserver”;

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)

private void initVideo(){

Log.d(TAG,“initVideo”);

}

@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)

private void pausePlay(){

Log.d(TAG,“stopPlay”);

}

}

第三步:创建一个 MyService 的类,继承 LifecycleService。由于 LifecycleService 是 Service 的直接子类,所以使用起来与普通的 Service 没有差别。

public class MyService extends LifecycleService {

private MyServiceObserver myServiceObserver;

public MyService(){

myServiceObserver = new MyServiceObserver();

getLifecycle().addObserver(myServiceObserver);

}

}

(三)使用场景3:使用 ProcessLifecycleOwner 监听应用程序的生命周期


具有生命周期的组件除了 Activity、Fragment 和 Service 外,还有 Application。ProcessLifecycleOwner 就是用来监听整个应用程序的生命周期情况。

具体使用方法:

第一步:添加依赖项

implementation “androidx.lifecycle:lifecycle-process:2.2.0”

第二步:定义一个 ApplicationObserver,实现 LifecycleObserver 接口。

public class ApplicationObserver implements LifecycleObserver {

private String TAG = this.getClass().getName();

/**

  • 在应用程序的整个生命周期中只会被调用一次

*/

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)

public void onCreate() {

Log.d(TAG,“Lifecycle.Event.ON_CREATE”);

}

@OnLifecycleEvent(Lifecycle.Event.ON_START)

public void onStart() {

Log.d(TAG,“Lifecycle.Event.ON_START”);

}

@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)

public void onResume() {

Log.d(TAG,“Lifecycle.Event.ON_RESUME”);

}

@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)

public void onPause() {

Log.d(TAG,“Lifecycle.Event.ON_PAUSE”);

}

@OnLifecycleEvent(Lifecycle.Event.ON_STOP)

public void onStop() {

Log.d(TAG,“Lifecycle.Event.ON_STOP”);

}

/**

  • 永远不会被调用,系统不会分发调用 ON_DESTROY 事件

*/

@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)

public void onDestroy() {

Log.d(TAG,“Lifecycle.Event.ON_DESTROY”);

}

}

第三步:在 Application 中关联 ApplicationObserver。

public class App extends Application {

@Override

public void onCreate() {

super.onCreate();

ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationObserver());

}

}

注意事项:

  1. ProcessLifecycleOwner 是针对整个应用程序的监听,与 Activity 的数量无关。

  2. Lifecycle.Event.ON_CREATE 只会被调用一次,而 Lifecycle.Event.ON_DESTROY 永远不会被调用。

  3. Lifecycle.Event.ON_PAUSE 和 Lifecycle.Event.ON_STOP 的调用会有一定的延后,因为系统需要为“屏幕旋转,由于配置发生变化而导致的 Activity 重新创建” 的情况预留一些时间。

rride

public void onCreate() {

super.onCreate();

ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationObserver());

}

}

注意事项:

  1. ProcessLifecycleOwner 是针对整个应用程序的监听,与 Activity 的数量无关。

  2. Lifecycle.Event.ON_CREATE 只会被调用一次,而 Lifecycle.Event.ON_DESTROY 永远不会被调用。

  3. Lifecycle.Event.ON_PAUSE 和 Lifecycle.Event.ON_STOP 的调用会有一定的延后,因为系统需要为“屏幕旋转,由于配置发生变化而导致的 Activity 重新创建” 的情况预留一些时间。

上一篇:Android Jetpack架构开发组件化应用实战,ndk开发教程


下一篇:Android架构组件JetPack之DataBinding玩转MVVM开发实战(四)