LifeCycle

LifeCycle的诞生

在Android应用程序开发中，解耦很大程度上表现为系统组件的生命周期与普通组件之间的解耦。普通组件在使用过程中通常需要依赖于系统组件的生命周期。
我们经常需要在页面的onCreate()方法中对组件进行初始化，在onPause()方法中停止组件，而在页面的onDestroy()方法中对组件进行资源回收。这样的方式会让页面与组件之间的耦合度变高。但是这种工作又不得不做，如果不这样做可能会导致内存泄漏。
我们希望我们对自定义组件的管理，不依赖于页面生命周期的回调方法。希望在页面生命周期发生变化时，也能够及时收到通知，这在组件化和架构设计中显得很重要
在这种需求中，Google提供了LifeCycle作为解决方案。LifeCycle可以帮助开发者创建可感知生命周期的组件，这样组件能够在内部管理自己的生命周期，从而降低模块间的耦合度，并降低内存泄漏的发生。

LifeCycle的原理

LifeCycle为我们提供了两个类：LifeCycleOwner(被观察者)和LifecycleObserver(观察者)，通过观察者模式，实现对页面生命周期的监听
在新版本的SDK中，Activity和Fragment已经默认实现了LifeCycleOwner接口。

使用LifeCycle解耦页面与组件

• 案例说明
  假设又这样一个需求：用户在打开某个页面时，获取用户当前的地理位置，我们通常会这样做

 package com.probuing.jetpacklsn;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.util.Log;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "main";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initLocationManage();
    }

    @Override
    protected void onResume() {
        super.onResume();
        startGetLocation();
    }

    @Override
    protected void onPause() {
        super.onPause();
        pauseGetLocation();
    }
    private void pauseGetLocation() {
        Log.d(TAG, "pauseGetLocation: 暂停获取用户位置");
    }
    private void startGetLocation() {
        Log.d(TAG, "startGetLocation: 开始获取用户位置");
    }
    private void initLocationManage() {
        Log.d(TAG, "initLocationManage: 初始化位置管理器");
    }
}

解决方案

我们利用LifeCycle改写，我们将Activity独立出去

1. 编写一个名为MyLocationListener的类，该组件实现LifecycleObserver接口。与获取地理位置相关的代码在该类中完成

package com.probuing.jetpacklsn;

import android.app.Activity;
import android.util.Log;

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;

public class MyLocationListenerManager implements LifecycleObserver {
    private static final String TAG = MainActivity.TAG;
    private final OnLocationChangeListener listener;

    public MyLocationListenerManager(Activity context, OnLocationChangeListener onLocationChangeListener) {
        this.listener = onLocationChangeListener;
        initLocationManager();
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void initLocationManager() {
        Log.d(TAG, "initLocationManager");
        listener.onInit();
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private void startGetLocation() {
        Log.d(TAG, "startGetLocation");
        listener.onGetStart();
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private void pauseGetLocation() {
        Log.d(TAG, "pauseGetLocation");
        listener.onGetPause();
    }
}

2. 定义接口

public interface OnLocationChangeListener {
    void onInit();

    void onGetStart();

    void onGetPause();
}

3. 在Activity中通过getLifecycle().addObserver()将观察者与被观察者绑定

public class MainActivity extends AppCompatActivity implements OnLocationChangeListener {

    public static final String TAG = "main";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MyLocationListenerManager locationListenerManager = new MyLocationListenerManager(this, this);
        //将观察者与被观察者锁定
        getLifecycle().addObserver(locationListenerManager);
    }


    @Override
    public void onInit() {
        Log.d(TAG, "onInit: onManageInit");
    }

    @Override
    public void onGetStart() {
        Log.d(TAG, "onGetStart: onManageStart");
    }

    @Override
    public void onGetPause() {
        Log.d(TAG, "onGetPause: onManagePause");
    }
}

使用LifecycleService解耦Service与组件

LifeCycleService基本介绍

Android提供了一个名为LifecycleService的类，该类继承自Service，并实现了LifecycleOwner接口。与Activity/Fragment类似，Service也提供了一个名为getLifecycle()的方法供我们使用。

LifecycleService的具体使用

1. build.gradle添加相关依赖

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

2. 创建一个名为MyService的类，并让它继承自LifecycleService。

public class MyService extends LifecycleService {
    private MyServiceObserver observer;

    public MyService() {
        observer = new MyServiceObserver();
        getLifecycle().addObserver(observer);
    }
}

3. 创建MyServiceObserver类，该类实现LifecycleObserver接口，然后使用注解@OnLifecycleEvent标签来标识希望能够在Service生命周期发生变化时同步调用的方法

public class MyServiceObserver implements LifecycleObserver {
    private  final String TAG = getClass().getName();

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void startGetLocation(){
        Log.d(TAG, "startGetLocation: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    private void stopGetLocation(){
        Log.d(TAG, "stopGetLocation: ");
    }
}

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

ProcessLifecycleOwner的存在意义

有时候我们会希望：我们的想知道应用程序当前处于前台还是后台，或者应用程序从后台回到前台时。我们能够得到通知。ProcessLifecycleOwner便可以让我们知道整个应用的生命周期情况

ProcessLifecycleOwner的具体使用方法

1. build.gradle中添加相关依赖

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

2. ProcessLifecycleOwner的使用方式与Activity、Fragment和Service是类似的，本质也是观察者模式

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

3. 定义观察者 ApplicationObserver类，该类实现LifecycleObserver接口

public class ApplicationObserver implements LifecycleObserver {
    private static final String TAG = "Application";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    private void onCreate(){
        Log.d(TAG, "onCreate: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    private void onStart(){
        Log.d(TAG, "onStart: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    private void onResume(){
        Log.d(TAG, "onResume: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    private void onPause(){
        Log.d(TAG, "onPause: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    private void onStop(){
        Log.d(TAG, "onStop: ");
    }
}