Jetpack-Lifecycle

使用生命周期感知型组件处理生命周期

生命周期感知型组件可执行操作来响应另一个组件（如 Activity 和 Fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。

一种常见的模式是在 Activity 和 Fragment 的生命周期方法中实现依赖组件的操作。但是，这种模式会导致代码条理性很差而且会扩散错误。通过使用生命周期感知型组件，您可以将依赖组件的代码从生命周期方法移入组件本身中。

androidx.lifecycle 软件包提供了可用于构建生命周期感知型组件的类和接口 - 这些组件可以根据 Activity 或 Fragment 的当前生命周期状态自动调整其行为。

注意：要将 androidx.lifecycle 导入 Android 项目，请参阅 Lifecycle 版本说明中关于声明依赖项的说明。

在 Android 框架中定义的大多数应用组件都存在生命周期。生命周期由操作系统或进程中运行的框架代码管理。它们是 Android 运作方式的核心，应用必须遵循它们。如果不这样做，可能会引发内存泄露甚至应用崩溃。

androidx.lifecycle 软件包提供的类和接口可帮助您以弹性和隔离的方式解决这些问题。

生命周期

Lifecycle 是一个类，用于存储有关组件（如 Activity 或 Fragment）的生命周期状态的信息，并允许其他对象观察此状态。

Lifecycle 使用两种主要枚举跟踪其关联组件的生命周期状态：

事件

从框架和 Lifecycle 类分派的生命周期事件。这些事件映射到 Activity 和 Fragment 中的回调事件。

状态

由 Lifecycle 对象跟踪的组件的当前状态。

您可以将状态看作图中的节点，将事件看作这些节点之间的边。

类可以通过向其方法添加注解来监控组件的生命周期状态。然后，您可以通过调用 Lifecycle 类的 addObserver() 方法并传递观察者的实例来添加观察者，如以下示例中所示：

    public class MyObserver implements LifecycleObserver {
        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        public void connectListener() {
            ...
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        public void disconnectListener() {
            ...
        }
    }

    myLifecycleOwner.getLifecycle().addObserver(new MyObserver());
    

在上面的示例中，myLifecycleOwner 对象实现了 LifecycleOwner 接口，我们将在接下来的部分中对该接口进行说明。

---

LifecycleOwner

LifecycleOwner是单一方法接口，表示类具有 Lifecycle。它具有一种方法（即 getLifecycle()），该方法必须由类实现。如果您尝试管理整个应用进程的生命周期，请参阅ProcessLifecycleOwner。

此接口从各个类（如 Fragment和 AppCompatActivity）抽象化Lifecycle 的所有权，并允许编写与这些类搭配使用的组件。任何自定义应用类均可实现LifecycleOwner接口。

实现 LifecycleObserver的组件可与实现 LifecycleOwner的组件无缝协同工作，因为所有者可以提供生命周期，而观察者可以注册以观察生命周期。

对于位置跟踪示例，我们可以让 MyLocationListener 类实现LifecycleObserver，然后在 onCreate() 方法中使用 Activity 的 Lifecycle对其进行初始化。这样，MyLocationListener 类便可以“自给自足”，这意味着，对生命周期状态的变化做出响应的逻辑会在 MyLocationListener（而不是在 Activity）中进行声明。让各个组件存储自己的逻辑，可使 Activity 和 Fragment 逻辑更易于管理。

    class MyActivity extends AppCompatActivity {
        private MyLocationListener myLocationListener;

        public void onCreate(...) {
            myLocationListener = new MyLocationListener(this, getLifecycle(), location -> {
                // update UI
            });
            Util.checkUserStatus(result -> {
                if (result) {
                    myLocationListener.enable();
                }
            });
      }
    }
    

一个常见的用例是，如果 Lifecycle 现在未处于良好的状态，则应避免调用某些回调。例如，如果回调在 Activity 状态保存后运行 Fragment 事务，就会引发崩溃，因此我们绝不能调用该回调。

为简化此用例，Lifecycle 类允许其他对象查询当前状态。

    class MyLocationListener implements LifecycleObserver {
        private boolean enabled = false;
        public MyLocationListener(Context context, Lifecycle lifecycle, Callback callback) {
           ...
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        void start() {
            if (enabled) {
               // connect
            }
        }

        public void enable() {
            enabled = true;
            if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
                // connect if not connected
            }
        }

        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
        void stop() {
            // disconnect if connected
        }
    }
    

对于此实现，LocationListener 类可以完全感知生命周期。如果我们需要从另一个 Activity 或 Fragment 使用 LocationListener，只需对其进行初始化。所有设置和拆解操作都由类本身管理。

如果库提供了需要使用 Android 生命周期的类，我们建议您使用生命周期感知型组件。库客户端可以轻松集成这些组件，而无需在客户端进行手动生命周期管理。

---

实现自定义 LifecycleObserver

/**
 * 生命周期
 */
public class LifecycleActivity extends AppCompatActivity {

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

        getLifecycle().addObserver(new MyObserver());
    }

}

public class MyObserver implements LifecycleObserver {


    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void onCreate() {
        log("onCreate()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void onStart() {
        log("onStart()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
        log("onResume()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
        log("onPause()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void onStop() {
        log("onStop()");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
        log("onDestroy()");
    }


    /**
     * 日志输出
     *
     * @param msg
     */
    private void log(String msg) {
        Log.i("MyObserver", "log: --->" + msg);
    }

}

经过上面的操作 MyObserver 也有了Activity的生命周期

实现原理源码分析

一、Activity 实现 Lifecycle

• LifecycleOwner 接口用于标记其实现类具备 Lifecycle 对象
  ComponentActivity 和Fragment 都实现了该接口

 public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
 }
 
 class ComponentActivity implements LifecycleOwner{
 
    //LifecycleRegistry观察者添加和事件分发  
   private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
      @NonNull
      @Override
      public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
      }

      @SuppressLint("RestrictedApi")
      @Override
      protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            //往Activity上添加一个fragment,用以监听生命周期的变化
           //其目的是为了兼顾不是继承自AppCompactActivity的场景.
            ReportFragment.injectIfNeededIn(this);
      }

     public ComponentActivity() {
         //添加观察者
         getLifecycle().addObserver(new LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner source,
                    @NonNull Lifecycle.Event event) {
            }
        });
    }
} 

• Lifecycle接口Lifecycle 声明了 添加观察者 移除观察者等相关函数（抽象）

public abstract class Lifecycle {

  @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
  @NonNull
  AtomicReference