Jetpack 系列(1)—— Lifecycle:生命周期感知型组件的基础

·  阅读 6332
Jetpack 系列(1)—— Lifecycle:生命周期感知型组件的基础

请点赞,你的点赞对我意义重大,满足下我的虚荣心。

🔥 Hi,我是小彭。本文已收录到 GitHub · Android-NoteBook 中。这里有 Android 进阶成长知识体系,有志同道合的朋友,关注公众号 [彭旭锐] 跟我一起成长。

前言

  • 生命周期是 Activity 的核心特性之一,也是 Android 视图开发无法规避的重要问题。 为了更加健壮地处理生命周期问题,Google 的解决方案是将生命周期定义为一套标准的行为模式,即 Lifecycle 框架。 这种方式不仅简化了在 Activity / Fragment 等生命周期宿主中分发生命周期事件的复杂度,还提供了自定义生命周期宿主的标准模板。
  • Lifecycle 是多个 Jetpack 组件的基础,例如我们熟悉的 LiveData 就是以 Lifecycle 为基础实现的生命周期感知型数据容器,因此我们选择将 Lifecycle 放在 Jetpack 系列的第一篇。

从这篇文章开始,我将带你全面掌握 Jetpack 组件,系列文章:

二、其他:

  • 1、AppStartup:轻量级初始化框架
  • 2、DataStore:新一代键值对存储方案
  • 3、Room:ORM 数据库访问框架
  • 4、WindowManager:加强对多窗口模式的支持
  • 5、WorkManager:加强对后台任务的支持
  • 6、Compose:新一代视图开发方案

1. 认识 Lifecycle

1.1 为什么要使用 Lifecycle?

Lifecycle 的主要作用是简化实现生命周期感知型组件的复杂度。 在传统的方式中,需要手动从外部宿主(如 Activity、Fragment 或自定义宿主)中将生命周期事件分发到功能组件内部,这势必会造成宿主代码复杂度增加。例如:

MyActivity.kt

// Activity 宿主
class MyActivity : AppCompatActivity() {

    private val myWorker = MyWorker()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 分发生命周期事件
        myWorker.init()
    }
		
    override fun onStart(){
        super.onStart()
        // 分发生命周期事件
        myWorker.onStart()
    }

    override fun onStop() {
        super.onStop()
        // 分发生命周期事件
        myWorker.onStop()
    }
}
复制代码

而使用 Lifecycle 组件后,能够将分发宿主生命周期事件的方法迁移到功能组件内部,宿主不再需要直接参与调整功能组件的生命周期。例如:

MyActivity.kt

// Activity 宿主
class MyActivity : AppCompatActivity() {

    private val myWorker = MyWorker()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 注册观察者
        lifecycle.addObserver(myWorker)
    }
}
复制代码

MyWorker.kt

class MyWorker : LifecycleEventObserver {

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        // 分发生命周期事件
        when (event) {
            Lifecycle.Event.ON_CREATE -> init()
            Lifecycle.Event.ON_START -> onStart()
            Lifecycle.Event.ON_STOP -> onStop()
        }
    }

    private fun init() {
        ...
    }

    private fun onStart() {
        ...
    }

    private fun onStop() {
        ...
    }
}
复制代码

1.2 Lifecycle 的设计思路

Lifecycle 整体上采用了观察者模式,核心的 API 是 LifecycleObserver 和 LifecycleOwner:

  • LifecycleObserver: 观察者 API;
  • LifecycleOwner: 被观察者 API,生命周期宿主需要实现该接口,并将生命周期状态分发 Lifecycle,从而间接分发给被观察者;
  • Lifecycle: 定义了生命周期的标准行为模式,属于 Lifecycle 框架的核心类,另外框架还提供了一个默认实现 LifecycleRegistry。

LifecycleObserver.java

public interface LifecycleObserver {
}
复制代码

LifecycleOwner.java

public interface LifecycleOwner {
    @NonNull
    Lifecycle getLifecycle();
}
复制代码

1.3 Lifecycle 的使用方法

  • 添加依赖: 在 build.gradle 中添加 Lifecycle 依赖,需要注意区分过时的方式:

模块 build.gradle

// 过时方式(lifecycle-extensions 不再维护)
implementation "androidx.lifecycle:lifecycle-extensions:2.4.0"

// 目前的方式:
def lifecycle_version = "2.5.0"

// Lifecycle 核心类
implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"
// Lifecycle 注解处理器(用于处理 @OnLifecycleEvent 注解)
kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
// 应用进程级别 Lifecycle
implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
复制代码
  • 注册观察者: Lifecycle 通过 addObserver(LifecycleObserver) 接口注册观察者,支持通过注解或非注解的方式注册观察者,共分为 3 种:

    • 1、LifecycleObserver(注解方式 ,不推荐): 在这个场景使用注解处理有种杀鸡用牛刀的嫌疑,并没有比其他两种方式有优势。注解方式存在注解处理过程,并且如果在依赖时遗漏注解处理器的话,还会退化为使用反射回调,因此不推荐使用。
    lifecycle.addObserver(object : LifecycleObserver {
    
        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        fun create() = {}
    
        @OnLifecycleEvent(Lifecycle.Event.ON_START)
        fun start() = {}
    
        @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
        fun resume() = {}
    
        @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
        fun pause() = {}
    
        @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
        fun stop() = {}
    
        @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        fun destroy() = {}
    })
    复制代码
    • 2、LifecycleEventObserver(非注解方式,推荐)
    lifecycle.addObserver(object : LifecycleEventObserver {
        override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
            when (event) {
                ON_CREATE -> {}
                ON_START -> {}
                ON_RESUME -> {}
                ON_PAUSE -> {}
                ON_STOP -> {}
                ON_DESTROY -> {}
                ON_ANY -> {}
            }
        }
    })
    复制代码
    • 3、DefaultLifecycleObserver(非注解方式,推荐)
    // DefaultLifecycleObserver 是 FullLifecycleObserver 接口的空实现
    lifecycle.addObserver(object : DefaultLifecycleObserver {
        
        override fun onCreate(owner: LifecycleOwner) {}
    
        override fun onStart(owner: LifecycleOwner) {}
    
        override fun onResume(owner: LifecycleOwner) {}
    
        override fun onPause(owner: LifecycleOwner) {}
    
        override fun onStop(owner: LifecycleOwner) {}
    
        override fun onDestroy(owner: LifecycleOwner) {}
    })
    复制代码

注意: Lifecycle 内部会禁止一个观察者注册到多个宿主上。这很好理解,要是绑定了多个宿主的话,Lifecycle 就不知道以哪个宿主的生命周期为准了。

1.4 预定义的宿主

目前,Android 预定义的 Lifecycle 宿主有 3 个:Activity、Fragment 和应用进程级别的宿主 ProcessLifecycleOwner:

  • 1、Activity(具体实现在 androidx.activity.ComponentActivity)
  • 2、Fragment
  • 3、ProcessLifecycleOwner

前两个宿主大家都很熟悉了,第 3 个宿主 ProcessLifecycleOwner 则提供整个应用进程级别 Activity 的生命周期,能够支持非毫秒级别精度监听应用前后台切换的场景。

  • Lifecycle.Event.ON_CREATE: 在应用进程启动时分发,只会分发一次;
  • Lifecycle.Event.ON_START:在应用进程进入前台(STARTED)时分发,可能分发多次;
  • Lifecycle.Event.ON_RESUME:在应用进程进入前台(RESUMED)时分发,可能分发多次;
  • Lifecycle.Event.ON_PAUSE:在应用退出前台(PAUSED)时分发,可能分发多次;
  • Lifecycle.Event.ON_STOP:在应用退出前台(STOPPED)时分发,可能分发多次;
  • Lifecycle.EVENT.ON_DESTROY:注意,不会被分发。

使用示例

ProcessLifecycleOwner.get().lifecycle.addObserver(object: LifecycleEventObserver{
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        ...
    }
})
复制代码

1.5 自定义宿主

观察者必须绑定到宿主 LifecycleOwner 上,你可以使用系统预定义的宿主,或根据需要自定义宿主。主要步骤是实现 LifecycleOwner 并在内部将生命周期事件分发给调度器 LifecycleRegistry。模板如下:

LifecycleOwner.java

public interface LifecycleOwner {
    Lifecycle getLifecycle();
}
复制代码

MyLifecycleOwner.kt

/**
 * 自定义宿主模板
 */
class MyLifecycleOwner : LifecycleOwner {

    private val mLifecycleRegistry = LifecycleRegistry(this)

    override fun getLifecycle() = mLifecycleRegistry

    fun create() {
        // 并将生命周期状态分发给被观察者
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
    }

    fun start() {
        // 并将生命周期状态分发给被观察者
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
    }

    fun stop() {
        // 并将生命周期状态分发给被观察者
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
    }
    ...
}
复制代码

2. Lifecycle 实现原理分析

2.1 注册观察者的执行过程

Lifecycle#addObserver() 最终会分发到调度器 LifecycleRegistry 中,其中会将观察者和观察者持有的状态包装为一个节点,并且在注册时将观察者状态同步推进到与宿主相同的状态中。

LifecycleRegistry.java

private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = new FastSafeIterableMap<>();

private State mState;

@Override
public void addObserver(LifecycleObserver observer) {
    // 观察者的初始状态:要么是 DESTROYED,要么是 INITIALIZED,确保观察者可以介绍到完整的事件流
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

    ...

    // 将观察者推进到宿主最新的状态
    State targetState = calculateTargetState(observer);
    while ((statefulObserver.mState.compareTo(targetState) < 0 && mObserverMap.contains(observer))) {
        pushParentState(statefulObserver.mState);
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
        popParentState();
        // mState / subling may have been changed recalculate
        targetState = calculateTargetState(observer);
    }
		...
}

@Override
public void removeObserver(@NonNull LifecycleObserver observer) {
    mObserverMap.remove(observer);
}

// ObserverWithState:观察者及其观察状态
static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        // 用适配器包装观察者,实现对不同形式观察者的统一分发
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }
}
复制代码

2.2 Lifecycle 如何适配不同类型的观察者

为了适配上面提到的不同类型的观察者,LifecycleRegistry 还为它们提供了一个适配层:非注解的方式会包装为一个 LifecycleEventObserver 的适配器对象,对于注解的方式,如果项目中引入了 annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version" ,会在编译时生成工具类 MyObserver_LifecycleAdapter ,否则会使用反射回调注解方法。

LifecycleRegistry.java

// ObserverWithState:观察者及其观察状态
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 = getStateAfter(event);
        mState = min(mState, newState);
        // 回调 onStateChanged() 方法
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}
复制代码

Lifecycling.java

@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    // 1. 观察者同时实现 LifecycleEventObserver 和 FullLifecycleObserver
    if (isLifecycleEventObserver && isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, (LifecycleEventObserver) object);
    }
    // 2. 观察者只实现 FullLifecycleObserver
    if (isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
    }
    // 3. 观察者只实现 LifecycleEventObserver
    if (isLifecycleEventObserver) {
        return (LifecycleEventObserver) object;
    }

    // 4. 观察者使用注解方式:
    final Class<?> klass = object.getClass();
    int type = getObserverConstructorType(klass);
    if (type == GENERATED_CALLBACK) {
        // APT 自动生成的 MyObserver_LifecycleAdapter
        List<Constructor<? extends GeneratedAdapter>> constructors = sClassToAdapters.get(klass);
        if (constructors.size() == 1) {
            GeneratedAdapter generatedAdapter = createGeneratedAdapter( constructors.get(0), object);
            return new SingleGeneratedAdapterObserver(generatedAdapter);
        }
        GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
        for (int i = 0; i < constructors.size(); i++) {
            adapters[i] = createGeneratedAdapter(constructors.get(i), object);
        }
        return new CompositeGeneratedAdaptersObserver(adapters);
    }
    // 反射调用
    return new ReflectiveGenericLifecycleObserver(object);
}
复制代码

FullLifecycleObserverAdapter.java

class FullLifecycleObserverAdapter implements LifecycleEventObserver {
    private final FullLifecycleObserver mFullLifecycleObserver;
    private final LifecycleEventObserver mLifecycleEventObserver;

    FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,LifecycleEventObserver lifecycleEventObserver) {
        mFullLifecycleObserver = fullLifecycleObserver;
        mLifecycleEventObserver = lifecycleEventObserver;
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        // 分发到 mFullLifecycleObserver 和 mLifecycleEventObserver
    }
}
复制代码

2.3 Lifecycle 如何感知 Activity 生命周期

宿主的生命周期事件需要分发到调度器 LifecycleRegistry 中,在高版本有直接观察 Activity 生命周期的 API,而在低版本使用无界面的 Fragment 间接观察 Activity 的生命周期。

androidx.activity.ComponentActivity.java

public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner ...{
    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

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

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ...
        ReportFragment.injectIfNeededIn(this);
        ...
    }
}
复制代码

ReportFragment.java

// 空白 Fragment
public class ReportFragment extends Fragment {
    public static void injectIfNeededIn(Activity activity) {
        if (Build.VERSION.SDK_INT >= 29) {
            // 在高版本有直接观察 Activity 生命周期的 API
            activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
        }
        // 在低版本使用无界面的 Fragment 间接观察 Activity 的生命周期
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }

    // 从 registerActivityLifecycleCallbacks() 或 Fragment 回调回来
    static void dispatch(Activity activity, Lifecycle.Event event) {
        ...
        // 分发声明周期事件
        activity.getLifecycle().handleLifecycleEvent(event);
    }
}
复制代码

2.4 Lifecycle 分发生命周期事件的过程

当宿主的生命周期发生变化时,会分发到 LifecycleRegistry#handleLifecycleEvent(Lifecycle.Event),将观察者的状态回调到最新的状态上。

LifecycleRegistry.java

private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =new FastSafeIterableMap<>();

private final WeakReference<LifecycleOwner> mLifecycleOwner;

public LifecycleRegistry(@NonNull LifecycleOwner provider) {
    mLifecycleOwner = new WeakReference<>(provider);
    mState = INITIALIZED;
}

// 分发生命周期事件
public void handleLifecycleEvent(Lifecycle.Event event) {
    // 通过事件获得下一个状态
    State next = getStateAfter(event);
    // 执行状态转移
    moveToState(next);
}

private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
        mNewEventOccurred = true;
        // we will figure out what to do on upper level.
        return;
    }
    mHandlingEvent = true;
    sync();
    mHandlingEvent = false;
}

private void sync() {
    // isSynced() 判断所有观察者状态是否同步到最新状态
    while (!isSynced()) {
        mNewEventOccurred = false;
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            // 生命周期回退,最终调用 ObserverWithState#dispatchEvent() 分发事件
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null && mState.compareTo(newest.getValue().mState) > 0) {
            // 生命周期前进,最终调用 ObserverWithState#dispatchEvent() 分发事件
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}
复制代码

3. Lifecycle 实践案例

3.1 使用 Lifecycle 解决 Dialog 内存泄漏

在 Activity 结束时,如果 Activity 上还存在未关闭的 Dialog,则会导致内存泄漏:

WindowLeaked: Activtiy MainActivity has leaked window DecorView@dfxxxx[MainActivity] thas was originally added here
复制代码

解决方法:

  • 方法 1:在 Activity#onDestroy() 中手动调用 Dialog#dismiss();
  • 方法 2:替换为 DialogFragment,内部会在 Fragment#onDestroyView() 时关闭 Dialog;
  • 方法 3:自定义 BaseDialog,使用 Lifecycle 监听宿主 DESTROYED 生命周期关闭 Dialog:

BaseDialog.kt

class BaseDialog(context: Context) : Dialog(context), LifecycleEventObserver {
    init {
        if (context is ComponentActivity) {
            context.lifecycle.addObserver(this)
        }
    }

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        if (Lifecycle.Event.ON_DESTROY == event) {
            if (isShowing) {
                dismiss()
            }
        }
    }
}
复制代码

3.2 生命周期感知型协程

Lifecycle 也加强了对 Kotlin 协程的支持 LifecycleCoroutineScope,我们可以构造出与生命周期相关联的协程作用域,主要支持 2 个特性:

  • 1、在宿主消亡(DESTROYED)时,自动取消协程;
  • 2、在宿主离开指定生命周期状态时挂起,在宿主重新进入指定生命周期状态时恢复协程(例如 launchWhenResumed)。

使用示例

// 示例 1
lifecycleScope.launch {

}
// 示例 2(内部等价于示例 3)
lifecycleScope.launchWhenResumed {

}
// 示例 3
lifecycleScope.launch {
    whenResumed {

    }
}
复制代码

1、自动取消协程实现原理分析: 核心在于 LifecycleCoroutineScopeImpl 中,内部在初始化时会注册一个观察者到宿主生命周期上,并在宿主进入 DESTROYED 时取消(cancel)协程。

LifecycleOwner.kt

// 基于 LifecycleOwner 的扩展函数
public val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope
    get() = lifecycle.coroutineScope
复制代码

Lifecycle.kt

public val Lifecycle.coroutineScope: LifecycleCoroutineScope
    get() {
        // 已简化
        val newScope = LifecycleCoroutineScopeImpl(
            this,
            SupervisorJob() + Dispatchers.Main.immediate
        )
        newScope.register()
        return newScope
    }

public abstract class LifecycleCoroutineScope internal constructor() : CoroutineScope {
    internal abstract val lifecycle: Lifecycle

    ...

    // 开启协程再调用 whenResumed
    public fun launchWhenResumed(block: suspend CoroutineScope.() -> Unit): Job = launch {
        lifecycle.whenResumed(block)
    }
}

// 实现类
internal class LifecycleCoroutineScopeImpl(
    override val lifecycle: Lifecycle,
    override val coroutineContext: CoroutineContext
) : LifecycleCoroutineScope(), LifecycleEventObserver {
    init {
        // 立即取消协程
        if (lifecycle.currentState == Lifecycle.State.DESTROYED) {
            coroutineContext.cancel()
        }
    }

    fun register() {
        // 绑定宿主生命周期
        launch(Dispatchers.Main.immediate) {
            if (lifecycle.currentState >= Lifecycle.State.INITIALIZED) {
                lifecycle.addObserver(this@LifecycleCoroutineScopeImpl)
            } else {
                coroutineContext.cancel()
            }
        }
    }

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        // 分发宿主生命周期事件
        if (lifecycle.currentState <= Lifecycle.State.DESTROYED) {
            // 取消协程
            lifecycle.removeObserver(this)
            coroutineContext.cancel()
        }
    }
}
复制代码

2、关联指定生命周期实现原理分析: 实现原理也是类似的,launchWhenResumed() 内部在 LifecycleContro 中注册观察者,最终通过协程调度器 PausingDispatcher 挂起(pause)或恢复(resume)协程。

PausingDispatcher.kt

public suspend fun <T> LifecycleOwner.whenResumed(block: suspend CoroutineScope.() -> T): T =
    lifecycle.whenResumed(block)

public suspend fun <T> Lifecycle.whenResumed(block: suspend CoroutineScope.() -> T): T {
    return whenStateAtLeast(Lifecycle.State.RESUMED, block)
}

public suspend fun <T> Lifecycle.whenStateAtLeast(
    minState: Lifecycle.State,
    block: suspend CoroutineScope.() -> T
): T = withContext(Dispatchers.Main.immediate) {
    val job = coroutineContext[Job] ?: error("when[State] methods should have a parent job")
    // 分发器,内部持有一个分发队列,用于支持暂停协程
    val dispatcher = PausingDispatcher()
    val controller = LifecycleController(this@whenStateAtLeast, minState, dispatcher.dispatchQueue, job)
    try {
        withContext(dispatcher, block)
    } finally {
        controller.finish()
    }
}
复制代码

LifecycleController.kt

@MainThread
internal class LifecycleController(
    private val lifecycle: Lifecycle,
    private val minState: Lifecycle.State,
    private val dispatchQueue: DispatchQueue,
    parentJob: Job
) {
    private val observer = LifecycleEventObserver { source, _ ->
        // 分发宿主生命周期事件
        if (source.lifecycle.currentState == Lifecycle.State.DESTROYED) {
            // 取消协程
            parentJob.cancel()
            lifecycle.removeObserver(observer)
            dispatchQueue.finish()
        } else if (source.lifecycle.currentState < minState) {
            // 暂停协程
            dispatchQueue.pause()
        } else {
            // 恢复协程
            dispatchQueue.resume()
        }
    }

    init {
        // 直接取消协程
        if (lifecycle.currentState == Lifecycle.State.DESTROYED) {
            // 取消协程
            parentJob.cancel()
            lifecycle.removeObserver(observer)
            dispatchQueue.finish()
        } else {
            lifecycle.addObserver(observer)
        }
    }
}
复制代码

3.3 安全地观察 Flow 数据流

我们知道,Kotlin Flow 不具备生命周期感知的能力(当然了,Flow 是 Kotlin 生态的组件,不是仅针对 Android 生态的组件),那么 Flow 观察者如何保证在安全的生命周期订阅数据呢?

  • 方法 1:使用生命周期感知型协程(不推荐)
  • 方法 2:使用 Flow#flowWithLifecycle() API(推荐)

具体分析在 4、Flow:LiveData 的替代方案 这篇文章里都讲过,这里不重复。


4. 总结

到这里,Jetpack 中最基础的 Lifecycle 组件就讲完了,下几篇文章我们将讨论基于 Lifecycle 实现的其他 Jetpack 组件,你知道是什么吗?关注我,带你了解更多。


参考资料

你的点赞对我意义重大!微信搜索公众号 [彭旭锐],希望大家可以一起讨论技术,找到志同道合的朋友,我们下次见!

我正在参与掘金技术社区创作者签约计划招募活动,点击链接报名投稿

收藏成功!
已添加到「」, 点击更改