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

生命周期感知组件会根据另一个组件（例如活动和片段）的生命周期状态的变化执行操作。这些组件可帮助您生成组织更完善且通常更轻量级的代码，更易于维护。

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

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

Android 框架中定义的大多数应用组件都附加了生命周期。生命周期由操作系统或在您的进程中运行的框架代码管理。它们是 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等）来监控组件的生命周期状态。然后，您可以通过调用addObserver()方法（Lifecycle类的函数）并传入观察者的实例来添加观察者，如下例所示。

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应调用相应的组件来获取数据，然后将结果提供回 UI 控制器。
使用数据绑定来维护视图和 UI 控制器之间的清晰界面。这允许您使视图更具声明性，并最大限度地减少您需要在活动和片段中编写的更新代码。如果您更喜欢在 Java 编程语言中执行此操作，请使用Butter Knife之类的库来避免样板代码并获得更好的抽象。
如果您的 UI 复杂，请考虑创建一个presenter类来处理 UI 修改。这可能是一项费力的任务，但它可以使您的 UI 组件更易于测试。
避免在ViewModel中引用View或Activity上下文。如果ViewModel的生命周期比活动长（在配置更改的情况下），您的活动就会泄漏，并且垃圾收集器无法正确处理。
使用Kotlin 协程来管理长时间运行的任务和其他可以异步运行的操作。

生命周期感知组件的用例

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

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

处理停止事件

当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 类相似行为的类，都必须实现由Lifecycle 版本beta 2及更低版本提供的解决方法。

其他资源

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

示例

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

Codelabs

Android 生命周期感知组件

博客

介绍 Android Sunflower

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

Kotlin

Java

Kotlin

Java

生命周期

Kotlin

Java

LifecycleOwner

Kotlin

Java

Kotlin

Java

实现自定义 LifecycleOwner

Kotlin

Java

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

生命周期感知组件的用例

处理停止事件

其他资源

示例

Codelabs

博客

为您推荐

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