一、使用 LifeCycle 解耦页面与组件

Jetpack 提供了两个类：LifecycleOwner（被观察者）和 LifecycleObserver（观察者）。通过观察者模式，实现对页面生命周期的监听。

Activity

监听 Activity 生命周期时，只需要实现观察者的那一部分代码，即让自定义组件实现 LifecycleObserver 接口即可。
类可以通过向其方法添加注解来监控组件的生命周期状态。然后，您可以通过调用 Lifecycle 类的 addObserver() 方法并传递观察者的实例来添加观察者

/**
 * @author yuchen
 * @date 2020/8/20  3:43 PM
 * 此类就是我们的自定义组件
 * 对于组件中那些需要在页面生命周期发生变化时得到通知的方法，
 * 我们需要在这些方法上使用@OnLifecycleEvent(Lifecycle.Event.ON_XXX)标签进行标识。
 * 这样，当页面生命周期发生变化时，这些被标示过的方法便会被自动调用
 */
public class MyLocationListener implements LifecycleObserver {
    private static final String TAG = "MyLocationListener";

    public MyLocationListener(Activity context,
                              OnLocationChangedListener onLocationChangedListener) {
        // 初始化操作
    }


    /**
     * 当Activity执行onResume()方法时，该方法会被自动调用
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private void startGetLocation() {
        Log.d(TAG, "startGetLocation: ");
    }


    /**
     * 当Activity执行onPause()方法时，该方法会被自动调用
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private void stopGetLocation() {
        Log.d(TAG, "stopGetLocation: ");
    }

    /**
     * 当地理位置变化，通过此接口通知调用者
     */
    public interface OnLocationChangedListener {
        /**
         * 位置变化
         *
         * @param latitude
         * @param longitude
         */
        void onChanged(double latitude, double longitude);
    }
    
}

在 Activity 中，只需要引入 MyLocationListener，通过 getLifecycle( ).addObserver( ) 方法，将观察者与被观察者绑定起来。

/**
 * @author yuchen
 * @date 2020/8/21  10:10 AM
 */
public class MainActivity extends AppCompatActivity {

    private MyLocationListener mMyLocationListener;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mMyLocationListener = new MyLocationListener(this,
                new MyLocationListener.OnLocationChangedListener() {
                    @Override
                    public void onChanged(double latitude, double longitude) {
                        Toast.makeText(MainActivity.this, "", Toast.LENGTH_SHORT).show();
                    }
                });
        getLifecycle().addObserver(mMyLocationListener);
    }
}

Fragment

Fragment 同 Activity 一样，也默认实现了 LifecycleOwner 接口。因此，以上案例同样适用于 Fragment。

二、使用 LifecycleService 解耦 Service 与组件

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);
    }
}

三、使用 ProcessLifecycleOwner 监听应用程序的生命周期

LifeCylce 提供了一个名为 ProcessLifecycleOwner 的类，以方便我们知道整个应用程序的生命周期情况。而且不会给项目增加任何的耦合度。
如需使用，先添加依赖
implementation ‘androidx.lifecycle:lifecycle-extensions:2.2.0’
ProcessLifecycleOwner 的使用方式与 Activity、Fragment、Service 是类似的，其本质也是观察者模式，由于我们要观察的是整个应用程序，因此，需要在 Application 中进行相关代码的编写。
先写自定义组件

/**
 * @author yuchen
 * @date 2020/8/20  5:57 PM
 */
public class ApplicationObserver implements LifecycleObserver {
    private String TAG = this.getClass().getName();

    /**
     * 在应用的整个生命周期只会被调用一次
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreated() {
        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 中使用

/**
 * @author yuchen
 * @date 2020/8/20  5:35 PM
 */
public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        ProcessLifecycleOwner.get()
                .getLifecycle()
                .addObserver(new ApplicationObserver());
    }
}

来自：https://www.yuque.com/gaodubukeni/myandroid/lifecycle