使用生命周期感知组件处理生命周期属于 Android Jetpack 的一部分。

生命周期感知组件会根据其他组件（例如活动和片段）的生命周期状态变化执行操作。这些组件可帮助您编写组织性更好、通常更轻量级的代码，从而更易于维护。

一种常见模式是在活动和片段的生命周期方法中实现依赖组件的操作。但是，这种模式会导致代码组织不佳并导致错误激增。通过使用生命周期感知组件，您可以将依赖组件的代码从生命周期方法移到组件本身。

androidx.lifecycle 包提供类和接口，使您可以构建生命周期感知组件，这些组件可以根据活动的当前生命周期状态自动调整其行为或片段。

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

假设我们有一个活动，它在屏幕上显示设备位置。一个常见的实现可能如下所示

Kotlin

internal class MyLocationListener(
        private val context: Context,
        private val callback: (Location) -> Unit
) {

    fun start() {
        // connect to system location service
    }

    fun stop() {
        // disconnect from system location service
    }
}

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        myLocationListener.start()
        // manage other components that need to respond
        // to the activity lifecycle
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

Java

class MyLocationListener {
    public MyLocationListener(Context context, Callback callback) {
        // ...
    }

    void start() {
        // connect to system location service
    }

    void stop() {
        // disconnect from system location service
    }
}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    @Override
    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, (location) -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        myLocationListener.start();
        // manage other components that need to respond
        // to the activity lifecycle
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

尽管此示例看起来不错，但在实际应用中，您最终会进行过多的调用来管理 UI 和其他组件以响应生命周期的当前状态。管理多个组件会在生命周期方法（例如 onStart() 和 onStop()）中放置大量代码，这使得它们难以维护。

此外，不能保证组件在活动或片段停止之前启动。如果我们需要执行长时间运行的操作（例如在 onStart() 中进行某些配置检查），则尤其如此。这可能会导致竞争条件，其中 onStop() 方法在 onStart() 之前完成，从而使组件保持活动状态的时间比所需时间更长。

Kotlin

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this) { location ->
            // update UI
        }
    }

    public override fun onStart() {
        super.onStart()
        Util.checkUserStatus { result ->
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start()
            }
        }
    }

    public override fun onStop() {
        super.onStop()
        myLocationListener.stop()
    }

}

Java

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, location -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        Util.checkUserStatus(result -> {
            // what if this callback is invoked AFTER activity is stopped?
            if (result) {
                myLocationListener.start();
            }
        });
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
    }
}

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

生命周期

Lifecycle 是一个类，它保存有关组件（例如活动或片段）的生命周期状态的信息，并允许其他对象观察此状态。

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

事件: 从框架和 Lifecycle 类分派的事件。这些事件映射到活动和片段中的回调事件。
状态: Lifecycle 对象跟踪的组件的当前状态。

图 1. 构成 Android 活动生命周期的状态和事件

将状态视为图的节点，将事件视为这些节点之间的边。

一个类可以通过实现 DefaultLifecycleObserver 并覆盖相应的方法（例如 onCreate、onStart 等）来监控组件的生命周期状态。然后，您可以通过调用 Lifecycle 类的 addObserver() 方法并传递观察者的实例来添加观察者，如下例所示

Kotlin

class MyObserver : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) {
        connect()
    }

    override fun onPause(owner: LifecycleOwner) {
        disconnect()
    }
}

myLifecycleOwner.getLifecycle().addObserver(MyObserver())

Java

public class MyObserver implements DefaultLifecycleObserver {
    @Override
    public void onResume(LifecycleOwner owner) {
        connect()
    }

    @Override
    public void onPause(LifecycleOwner owner) {
        disconnect()
    }
}

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

在上例中，myLifecycleOwner 对象实现了 LifecycleOwner 接口，这将在下一节中进行解释。

LifecycleOwner

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

此接口将Lifecycle 的所有权从各个类（例如Fragment和AppCompatActivity）中抽象出来，并允许编写与之协同工作的组件。任何自定义应用程序类都可以实现LifecycleOwner接口。

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

对于位置跟踪示例，我们可以使MyLocationListener类实现DefaultLifecycleObserver，然后在onCreate()方法中使用活动的Lifecycle对其进行初始化。这允许MyLocationListener类自给自足，这意味着对生命周期状态变化做出反应的逻辑是在MyLocationListener中声明的，而不是在活动中。让各个组件存储自己的逻辑，使得活动和片段的逻辑更容易管理。

Kotlin

class MyActivity : AppCompatActivity() {
    private lateinit var myLocationListener: MyLocationListener

    override fun onCreate(...) {
        myLocationListener = MyLocationListener(this, lifecycle) { location ->
            // update UI
        }
        Util.checkUserStatus { result ->
            if (result) {
                myLocationListener.enable()
            }
        }
    }
}

Java

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当前状态不佳，则避免调用某些回调。例如，如果回调在保存活动状态后运行片段事务，则会触发崩溃，因此我们永远不想调用该回调。

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

Kotlin

internal class MyLocationListener(
        private val context: Context,
        private val lifecycle: Lifecycle,
        private val callback: (Location) -> Unit
): DefaultLifecycleObserver {

    private var enabled = false

    override fun onStart(owner: LifecycleOwner) {
        if (enabled) {
            // connect
        }
    }

    fun enable() {
        enabled = true
        if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
            // connect if not connected
        }
    }

    override fun onStop(owner: LifecycleOwner) {
        // disconnect if connected
    }
}

Java

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

    @Override
    public void onStart(LifecycleOwner owner) {
        if (enabled) {
           // connect
        }
    }

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

    @Override
    public void onStop(LifecycleOwner owner) {
        // disconnect if connected
    }
}

通过此实现，我们的LocationListener类完全感知生命周期。如果我们需要从另一个活动或片段使用我们的LocationListener，我们只需要初始化它即可。所有设置和拆卸操作都由类本身管理。

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

实现自定义 LifecycleOwner

Support Library 26.1.0 及更高版本中的片段和活动已实现LifecycleOwner接口。

如果您有一个想要使其成为LifecycleOwner的自定义类，您可以使用LifecycleRegistry类，但是您需要将事件转发到该类，如下面的代码示例所示。

Kotlin

class MyActivity : Activity(), LifecycleOwner {

    private lateinit var lifecycleRegistry: LifecycleRegistry

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleRegistry = LifecycleRegistry(this)
        lifecycleRegistry.markState(Lifecycle.State.CREATED)
    }

    public override fun onStart() {
        super.onStart()
        lifecycleRegistry.markState(Lifecycle.State.STARTED)
    }

    override fun getLifecycle(): Lifecycle {
        return lifecycleRegistry
    }
}

Java

public class MyActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    public void onStart() {
        super.onStart();
        lifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }
}

生命周期感知组件的最佳实践

保持您的UI控制器（活动和片段）尽可能精简。它们不应该尝试获取自己的数据；相反，应该使用ViewModel来执行此操作，并观察LiveData对象以将更改反映回视图。
尝试编写数据驱动的UI，其中UI控制器的职责是随着数据变化更新视图，或将用户操作通知回ViewModel。
将您的数据逻辑放在ViewModel类中。ViewModel应作为UI控制器和应用程序其余部分之间的连接器。但请注意，ViewModel不负责获取数据（例如，从网络）。相反，ViewModel应该调用相应的组件来获取数据，然后将结果提供回UI控制器。
使用数据绑定来维护视图和UI控制器之间的简洁接口。这允许您使视图更具声明性，并最大限度地减少您需要在活动和片段中编写的更新代码。如果您更喜欢使用Java编程语言执行此操作，请使用Butter Knife之类的库来避免样板代码并获得更好的抽象。
如果您的UI很复杂，请考虑创建一个Presenter类来处理UI修改。这可能是一项费力的任务，但它可以使您的UI组件更容易测试。
避免在ViewModel中引用View或Activity上下文。如果ViewModel比活动存活时间长（在配置更改的情况下），您的活动就会泄漏，并且不会被垃圾收集器正确处理。
使用Kotlin协程来管理长时间运行的任务和其他可以异步运行的操作。

生命周期感知组件的用例

生命周期感知组件可以使您更轻松地在各种情况下管理生命周期。以下是一些示例：

在粗粒度和细粒度位置更新之间切换。使用生命周期感知组件在您的位置应用程序可见时启用细粒度位置更新，并在应用程序处于后台时切换到粗粒度更新。LiveData（一个生命周期感知组件）允许您的应用程序在用户更改位置时自动更新UI。
停止和启动视频缓冲。使用生命周期感知组件尽快启动视频缓冲，但将播放延迟到应用程序完全启动后。您还可以使用生命周期感知组件在应用程序被销毁时终止缓冲。
启动和停止网络连接。使用生命周期感知组件在应用程序处于前台时启用网络数据的实时更新（流式传输），并在应用程序进入后台时自动暂停。
暂停和恢复动画drawable。使用生命周期感知组件处理在应用程序处于后台时暂停动画drawable，并在应用程序处于前台后恢复drawable。

处理onStop事件

当Lifecycle属于AppCompatActivity或Fragment时，Lifecycle的状态将变为CREATED，并且当AppCompatActivity或Fragment的onSaveInstanceState()被调用时，将分派ON_STOP事件。

当Fragment或AppCompatActivity的状态通过onSaveInstanceState()保存时，其UI被认为是不可变的，直到调用ON_START。在保存状态后尝试修改UI可能会导致应用程序导航状态不一致，这就是为什么如果应用程序在保存状态后运行FragmentTransaction，FragmentManager会抛出异常的原因。有关详细信息，请参阅commit()。

LiveData通过在观察者的关联Lifecycle至少处于STARTED状态之前才调用其观察者来防止这种情况。在幕后，它会在决定调用其观察者之前调用isAtLeast()。

不幸的是，AppCompatActivity的onStop()方法是在onSaveInstanceState()之后调用的，这留下了一个UI状态更改不允许但Lifecycle尚未移动到CREATED状态的间隙。

为了防止此问题，beta2及更低版本的Lifecycle类将状态标记为CREATED，而不会分派事件，以便任何检查当前状态的代码都能获得真实值，即使事件直到系统调用onStop()时才会分派。

不幸的是，此解决方案有两个主要问题：

在API级别23及更低版本上，即使Android系统被另一个活动部分覆盖，它实际上也会保存活动的状体。换句话说，Android系统会调用onSaveInstanceState()，但不一定调用onStop()。这会创建一个潜在的较长间隔，在此间隔内，观察者仍然认为生命周期处于活动状态，即使其UI状态无法修改。
任何想要公开与LiveData类类似行为的类都必须实现Lifecyclebeta 2及更低版本提供的解决方法。

其他资源

要了解有关使用生命周期感知组件处理生命周期的更多信息，请查阅以下其他资源。

示例

Android 架构组件基础示例
Sunflower，一个演示使用架构组件的最佳实践的演示应用程序

Codelabs

Android生命周期感知组件

博客

Android Sunflower介绍

使用生命周期感知组件处理生命周期 属于 Android Jetpack 的一部分。

Kotlin

Java

Kotlin

Java

生命周期

Kotlin

Java

LifecycleOwner

Kotlin

Java

Kotlin

Java

实现自定义 LifecycleOwner

Kotlin

Java

生命周期感知组件的最佳实践

生命周期感知组件的用例

处理onStop事件

其他资源

示例

Codelabs

博客

为您推荐

使用生命周期感知组件处理生命周期属于 Android Jetpack 的一部分。