=============================================================================
Jetpack 为我们提供了两个接口：
被观察者：LifecycleOwner
观察者：LifecycleObserver
被监听的系统组件需要去实现 LifecycleOwner 接口，观察者需要实现 LifecycleObserver 接口。
（1）解耦 Activity
第一步：添加依赖
implementation ‘androidx.appcompat:appcompat:1.2.0’
在 AndroidX 里面 ComponentActivity 已经默认实现了 LifecycleOwner 接口。如果项目没有迁移到 AndroidX，还是用的 Support 库，新版本的 SDK 也通过 SupportActivity 实现了 LifecycleOwner 接口。
在 LifecycleOwner 接口中，只有一个 getLifecycle 方法。
第二步：实现观察者
如果是想监听某个 Activity 的生命周期，需要我们做的就是自定义组件，实现 LifecycleObserver 接口即可，该接口没有接口方法，不需要任何具体的实现。
比如以刚刚的视频播放为例：
- 创建一个 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());
}
}
注意事项：
-
ProcessLifecycleOwner 是针对整个应用程序的监听，与 Activity 的数量无关。
-
Lifecycle.Event.ON_CREATE 只会被调用一次，而 Lifecycle.Event.ON_DESTROY 永远不会被调用。
-
Lifecycle.Event.ON_PAUSE 和 Lifecycle.Event.ON_STOP 的调用会有一定的延后，因为系统需要为“屏幕旋转，由于配置发生变化而导致的 Activity 重新创建” 的情况预留一些时间。
rride
public void onCreate() {
super.onCreate();
ProcessLifecycleOwner.get().getLifecycle().addObserver(new ApplicationObserver());
}
}
注意事项：
-
ProcessLifecycleOwner 是针对整个应用程序的监听，与 Activity 的数量无关。
-
Lifecycle.Event.ON_CREATE 只会被调用一次，而 Lifecycle.Event.ON_DESTROY 永远不会被调用。
-
Lifecycle.Event.ON_PAUSE 和 Lifecycle.Event.ON_STOP 的调用会有一定的延后，因为系统需要为“屏幕旋转，由于配置发生变化而导致的 Activity 重新创建” 的情况预留一些时间。