Jetpack Lifecycle-五八三

Lifecycle 是 Android Jetpack 框架提供的能够感知宿主组件生命周期变化的组件，它能持有宿主（如 Activity 或 Fragment）生命周期状态的信息，并且允许其他观察者注册监听宿主的生命周期状态变化。这就使得我们不用主动去获取宿主的状态，有利于降低代码耦合度并更容易维护。

Lifecycle 可以让组件自己管理生命周期的逻辑，避免每次调用时的繁琐步骤，用 Lifecycle 实现的组件可以实现生命周期的监听，数据变化的监听等功能 ⁵。

依赖

Lifecycle 组件已集成到 AndroidX 中，无需添加额外依赖即可使用，可以在使用 AndroidX 的项目中直接访问相关的 API 。

使用

Lifecycle 有两种使用方式，第一种是通过继承 DefaultLifecycleObserver 可以拓展自己与生命周期相关的业务逻辑，下面是个例子：

class TestLifeCycleObserver: DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        super.onStart(owner)
        Log.i(this.javaClass.simpleName, "onStart")
    }









    override fun onStop(owner: LifecycleOwner) {
        super.onStop(owner)
        Log.i(this.javaClass.simpleName, "onStop")
    }


}

另一种方式是通过继承 LifecycleEventObserver 监听生命周期变化：

class TestLifeCycleObserver() : LifecycleEventObserver {
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        Log.i(this.javaClass.simpleName, "source: $source, event: $event")
    }

}

定义好 LifecycleObserver 的实现类后，在一个具有生命周期的容器组件中，通过 getLifecycle() 方法获取 Lifecycle 对象，通过该对象的 addObserver 和 removeObserver 方法来管理观察者。下面是个例子：

在具有生命周期的组件中例如 Activity 或 Fragment 添加监听：

class LifeCycleActivity : AppCompatActivity() {


    private val observer = TestLifeCycleObserver()





    private lateinit var binding: ActivityLifeCycleBinding






    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityLifeCycleBinding.inflate(layoutInflater)
        setContentView(binding.root)
        lifecycle.addObserver(observer)
    }




    override fun onDestroy() {
        super.onDestroy()
        lifecycle.removeObserver(observer)
    }
}

在上面的例子中，TestLifeCycleObserver 对象在 Activity 的 onCreate 中添加监听，onDestroy 中释放监听。这样 observer 依然能够接收到 onCreate 和 onDestroy 的回调。修改 TestLifeCycleObserver ：

 class TestLifeCycleObserver: DefaultLifecycleObserver {
    override fun onCreate(owner: LifecycleOwner) {

        super.onCreate(owner)

        Log.i(this.javaClass.simpleName, “onCreate”)
    }









    override fun onStart(owner: LifecycleOwner) {

        super.onStart(owner)

        Log.i(this.javaClass.simpleName, “onStart”)
    }




    override fun onStop(owner: LifecycleOwner) {

        super.onStop(owner)

        Log.i(this.javaClass.simpleName, “onStop”)
    }





    override fun onDestroy(owner: LifecycleOwner) {

        super.onDestroy(owner)

        Log.i(this.javaClass.simpleName, “onDestroy”)
    }


}

操作打开 LifeCycleActivity 并退出后，收到的日志为：

2023-06-15 14:58:09.006 TestLifeCycleObserver           I  onCreate
2023-06-15 14:58:09.010 TestLifeCycleObserver           I  onStart
2023-06-15 14:58:12.423 TestLifeCycleObserver           I  onStop
2023-06-15 14:58:12.425 TestLifeCycleObserver           I  onDestroy

源码分析

LifeCycleObserver

LifecycleObserver 是一个空的接口：

public interface LifecycleObserver {}

用来标记一个类具有生命周期能力，不能直接使用 LifecycleObserver ，而是通过实现 DefaultLifecycleObserver 或 LifecycleEventObserver 来接收生命周期事件。

FullLifecycleObserver 和 DefaultLifecycleObserver

上面的例子使用的是 DefaultLifecycleObserver ，它并没有直接继承自 LifecycleObserver ，而是继承自 FullLifecycleObserver ，在这个接口中，定义了对应 Activity 生命周期的各个方法。

interface FullLifecycleObserver extends LifecycleObserver {


    void onCreate(LifecycleOwner owner);





    void onStart(LifecycleOwner owner);






    void onResume(LifecycleOwner owner);

    void onPause(LifecycleOwner owner);


    void onStop(LifecycleOwner owner);

    void onDestroy(LifecycleOwner owner);
}

DefaultLifecycleObserver 实现 FullLifecycleObserver 接口并没有提供什么额外能力，只是提供了默认空实现，用于监听 LifecycleOwner 状态变化。

public interface DefaultLifecycleObserver extends FullLifecycleObserver {
    @Override
    default void onCreate(@NonNull LifecycleOwner owner) {}





    @Override
    default void onStart(@NonNull LifecycleOwner owner) {}

    @Override
    default void onResume(@NonNull LifecycleOwner owner) {}


    @Override
    default void onPause(@NonNull LifecycleOwner owner) {}



    @Override
    default void onStop(@NonNull LifecycleOwner owner) {}



    @Override
    default void onDestroy(@NonNull LifecycleOwner owner) {}
}

需要注意的是，如果一个类同时实现了 DefaultLifecycleObserver 和 LifecycleEventObserver ，DefaultLifecycleObserver 的方法会优先调用，然后遵循 LifecycleEventObserver.onStateChanged(LifecycleOwner, Lifecycle.Event) 的回调顺序。

如果一个类实现了 DefaultLifecycleObserver 并同时使用 OnLifecycleEvent ，OnLifecycleEvent 注解将会被忽略。

OnLifecycleEvent

这是一个注解类，用于标记 LifecycleObserver 实现的方法，这些方法用于处理生命周期事件。
不推荐使用该注解，这个注解需要使用代码生成或反射，应该避免使用。尽量使用 DefaultLifecycleObserver 或 LifecycleEventObserver 替代。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Deprecated
public @interface OnLifecycleEvent {
    Lifecycle.Event value();
}

LifecycleEventObserver

LifecycleEventObserver 用于接收生命周期变化并派发给接收者。如果一个类同时实现了 DefaultLifecycleObserver ，DefaultLifecycleObserver 的方法将优先调用， onStateChanged 会在后续调用。

public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

需要注意的是，当一个类同时实现 DefaultLifecycleObserver 和 LifecycleEventObserver 时，打印顺序是 DefaultLifecycleObserver 的方法优先调用，LifecycleEventObserver 次之。
而如果两个类各自实现，打印顺序不遵循 DefaultLifecycleObserver 优先的规则。而是遵循 lifecycle.addObserver 方法的添加顺序执行回调的。

举例说明，下面是一个同时实现两者的方法：

class TestLifeCycleObserver: DefaultLifecycleObserver, LifecycleEventObserver {
    override fun onCreate(owner: LifecycleOwner) {

        super.onCreate(owner)

        Log.i(this.javaClass.simpleName, "onCreate")
    }









    override fun onStart(owner: LifecycleOwner) {

        super.onStart(owner)

        Log.i(this.javaClass.simpleName, "onStart")
    }




    override fun onStop(owner: LifecycleOwner) {

        super.onStop(owner)

        Log.i(this.javaClass.simpleName, "onStop")
    }





    override fun onDestroy(owner: LifecycleOwner) {

        super.onDestroy(owner)

        Log.i(this.javaClass.simpleName, "onDestroy")
    }




    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        Log.i(this.javaClass.simpleName, "source: $source, event: $event")
    }

}

当生命周期变化时，它的打印如下：

TestLifeCycleObserver           I  onCreate

TestLifeCycleObserver           I  source: com.chunyu.demo.lifecycle.LifeCycleActivity@a56a12e, event: ON_CREATE
TestLifeCycleObserver           I  onStart

TestLifeCycleObserver           I  source: com.chunyu.demo.lifecycle.LifeCycleActivity@a56a12e, event: ON_START
...

而如果分别创建一个类，这里用前面的 TestLifeCycleObserver 和 TestLifeCycleObserver2 为例，在 Activity 中的添加顺序：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    binding = ActivityLifeCycleBinding.inflate(layoutInflater)
    setContentView(binding.root)
    lifecycle.addObserver(observer1) // TestLifeCycleObserver
    lifecycle.addObserver(observer2) // TestLifeCycleObserver2
}

打印结果：

TestLifeCycleObserver           I  onCreate

TestLifeCycleObserver2          I  source: com.chunyu.demo.lifecycle.LifeCycleActivity@392d4cf, event: ON_CREATE
TestLifeCycleObserver           I  onStart

TestLifeCycleObserver2          I  source: com.chunyu.demo.lifecycle.LifeCycleActivity@392d4cf, event: ON_START

改变顺序为：

lifecycle.addObserver(observer2) // TestLifeCycleObserver2
lifecycle.addObserver(observer1) // TestLifeCycleObserver

打印结果为：

TestLifeCycleObserver2          I  source: com.chunyu.demo.lifecycle.LifeCycleActivity@a56a12e, event: ON_CREATE
TestLifeCycleObserver           I  onCreate
TestLifeCycleObserver2          I  source: com.chunyu.demo.lifecycle.LifeCycleActivity@a56a12e, event: ON_START
TestLifeCycleObserver           I  onStart

LifecycleOwner

在上面的例子中经常出现一个类型 LifecycleOwner ，实现该接口的类具有 Android 生命周期的能力，需要提供生命周期事件。
这些事件可以被自定义组件用来处理生命周期变化，而不需要在 Activity 或 Fragment 中实现任何代码。

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}

AndroidX 中的 AppCompatActivity 的继承关系中，由 ComponentActivity 实现了 LifecycleOwner 接口：

// in ComponentActivity
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

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

在的无参构造方法中调用了 getLifecycle 方法获取 Lifecycle 对象，并添加了一些监听：

public ComponentActivity() {
    Lifecycle lifecycle = getLifecycle();
    if (lifecycle == null) {
        throw new IllegalStateException("getLifecycle() returned null in ComponentActivity");
    }



    // ...
    getLifecycle().addObserver(new LifecycleEventObserver() {
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
            if (event == Lifecycle.Event.ON_DESTROY) {
                // Clear out the available context
                mContextAwareHelper.clearAvailableContext();
                // And clear the ViewModelStore
                if (!isChangingConfigurations()) {
                    getViewModelStore().clear();
                }
            }
        }
    });
    getLifecycle().addObserver(new LifecycleEventObserver() {
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
            ensureViewModelStore();
            getLifecycle().removeObserver(this);
        }
    });
    // ...
}

这里简化了一些代码，核心逻辑是获取一个 LifeCycle 对象，添加了一些监听，这些监听主要用于处理 ViewModelStore ，这也说明在 AndroidX 下默认提供了 Lifecycle 配合 ViewModel 框架的支持。

LifecycleOwner 的另一个实现是 androidx.fragment.app.Fragment 。也是创建了一个 LifecycleRegistry 对象。

Lifecycle

Lifecycle 是一个抽象类，定义了一个拥有 Android 生命周期的对象。Fragment 和 FragmentActivity 类实现了 LifecycleOwner 接口，它有 getLifecycle 方法来访问 Lifecycle。你也可以在自己的类中实现 LifecycleOwner。

在这个类中，
Lifecycle.Event.ON_CREATE、Lifecycle.Event.ON_START、Lifecycle.Event.ON_RESUME 事件是在 LifecycleOwner 的相关方法返回后调用的。

Lifecycle.Event.ON_PAUSE、Lifecycle.Event.ON_STOP、Lifecycle.Event.ON_DESTROY 事件是在调用 LifecycleOwner 的相关方法之前调用的。

例如，Lifecycle.Event.ON_START 将在 onStart 返回后调用，Lifecycle.Event.ON_STOP 将在调用 onStop 之前调用。这为你提供了关于拥有者所处状态的某些保证。

这就解释了为什么我们在 Activity 的 onCreate 添加监听，仍然能够收到 Lifecycle.Event.ON_CREATE 事件，因为 LifecycleObserver 的调用是在 Activity 的 onCreate 方法返回后调用的。

Lifecycle 中定义了生命周期的事件类型：

public enum Event {

    ON_CREATE,
    ON_START,
    ON_RESUME,
    ON_PAUSE,
    ON_STOP,
    ON_DESTROY,
    ON_ANY;
}

状态：

public enum Event {

    DESTROYED,
    INITIALIZED,
    CREATED,
    STARTED,
    RESUMED;
}

对应的状态含义是：

DESTROYED：LifecycleOwner 的销毁状态。在这个事件之后，这个 Lifecycle 将不再分派任何事件。例如，对于一个 Activity，这个状态是在 Activity 的 onDestroy 调用之前达到的。
INITIALIZED：LifecycleOwner 的初始化状态。对于一个 Activity，这是它被构造但尚未收到 onCreate 调用时的状态。
CREATED：LifecycleOwner 的创建状态。对于一个 Activity，这个状态会在两种情况下达到：
- onCreate 调用后
- onStop 调用前
STARTED：LifecycleOwner 的开始状态。对于一个 Activity，这个状态会在两种情况下达到：
- onStart 调用后
- onPause 调用前
RESUMED：LifecycleOwner 的开始状态。对于一个 Activity，这个状态会在 onResume 方法调用后到达。
这样整体顺序就是下面的流程：

LifecycleRegistry

在前面 LifecycleOwner 中的实现类中都是通过 LifecycleRegistry 来作为返回的 Lifecycle 对象的，LifecycleRegistry 是 Lifecycle 的实现，能够处理多个监听。

public LifecycleRegistry(@NonNull LifecycleOwner provider) {
    this(provider, true);
}






private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
    mLifecycleOwner = new WeakReference<>(provider);
    mState = INITIALIZED;
    mEnforceMainThread = enforceMainThread;
}

构造方法中需要传递一个 LifecycleOwner 参数，内部持有这个对象的弱引用。设置默认状态为初始化状态 INITIALIZED ，默认启用强制主线程。

一般情况下我们获取 Lifecycle 后主要方法是 addObserver 和 removeObserver ，所以本文只关注这两个核心逻辑。

addObserver

addObserver 方法用于添加监听：

public void addObserver(@NonNull LifecycleObserver observer) {
    enforceMainThreadIfNeeded("addObserver");
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);






    if (previous != null) {
        return;
    }
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        // it is null we should be destroyed. Fallback quickly
        return;
    }

    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        pushParentState(statefulObserver.mState);
        final Event event = Event.upFrom(statefulObserver.mState);
        if (event == null) {
            throw new IllegalStateException("no event up from " + statefulObserver.mState);
        }
        statefulObserver.dispatchEvent(lifecycleOwner, event);
        popParentState();
        // mState / subling may have been changed recalculate
        targetState = calculateTargetState(observer);
    }

    if (!isReentrance) {
        // we do sync only on the top level.
        sync();
    }
    mAddingObserverCounter--;
}

这个方法用于将一个 LifecycleObserver 对象添加到观察者列表中。方法首先检查当前线程是否为主线程，然后创建一个 ObserverWithState 对象来存储观察者和其初始状态。接着，它会尝试将这个 ObserverWithState 对象添加到 mObserverMap 中。如果添加成功，它会计算目标状态并在 while 循环中分派事件，直到观察者的状态达到目标状态。最后，如果当前不是在处理事件或添加观察者，它会调用 sync 方法来同步状态。

FastSafeIterableMap

LifecycleObserver 对象保存到了 mObserverMap 中，类型是 FastSafeIterableMap ，这是一个自定义列表，用于保存观察者，并能够在遍历过程中处理删除/添加。它是一个类似于 LinkedHashMap 的数据结构，它支持在迭代过程中进行修改。它比 SafeIterableMap 占用更多的内存，并且不是线程安全的。

ObserverWithState

ObserverWithState 对象用来存储观察者和其初始状态，内部使用到了 LifecycleEventObserver 来发出通知：

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;





    ObserverWithState(LifecycleObserver observer, State initialState) {
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }



    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = event.getTargetState();
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }


}

其中 dispatchEvent 方法做了状态的顺序校验，并且通过 LifecycleEventObserver 发送事件更新。

removeObserver

public void removeObserver(@NonNull LifecycleObserver observer) {
    enforceMainThreadIfNeeded("removeObserver");
    // we consciously decided not to send destruction events here in opposition to addObserver.
    // Our reasons for that:
    // 1. These events haven't yet happened at all. In contrast to events in addObservers, that
    // actually occurred but earlier.
    // 2. There are cases when removeObserver happens as a consequence of some kind of fatal
    // event. If removeObserver method sends destruction events, then a clean up routine becomes
    // more cumbersome. More specific example of that is: your LifecycleObserver listens for
    // a web connection, in the usual routine in OnStop method you report to a server that a
    // session has just ended and you close the connection. Now let's assume now that you
    // lost an internet and as a result you removed this observer. If you get destruction
    // events in removeObserver, you should have a special case in your onStop method that
    // checks if your web connection died and you shouldn't try to report anything to a server.
    mObserverMap.remove(observer);
}

这个方法用于从观察者列表中移除一个 LifecycleObserver 对象。方法首先检查当前线程是否为主线程，然后从 mObserverMap 中移除指定的观察者。与 addObserver 方法不同，这个方法不会发送销毁事件。这是一个有意识的决定，原因是这些事件还没有发生，而且在某些情况下，removeObserver 可能是由于某种致命事件而发生的。如果 removeObserver 方法发送销毁事件，那么清理过程会变得更加复杂。

Application 生命周期监听

在 Application 中可以调用 registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks) 方法，在这里可以监控整个 App 的 Activity 生命周期变化情况。
通过该接口，可以实现应用前后台切换的监控。

application.registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacks {
    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
        TODO("Not yet implemented")
    }


    override fun onActivityStarted(activity: Activity) {
        TODO("Not yet implemented")
    }



    override fun onActivityResumed(activity: Activity) {
        TODO("Not yet implemented")
    }




    override fun onActivityPaused(activity: Activity) {
        TODO("Not yet implemented")
    }

    override fun onActivityStopped(activity: Activity) {
        TODO("Not yet implemented")
    }




    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {
        TODO("Not yet implemented")
    }


    override fun onActivityDestroyed(activity: Activity) {
        TODO("Not yet implemented")
    }
})

文章版权归作者所有，未经允许请勿转载，侵权请联系 admin@trc20.tw 删除。

THE END

Android
# Android Jetpack