再谈协程之Lifecycle潜行者

Posted 2021-11-24 eclipse_xu

点击上方蓝字关注我，知识会给你力量

Lifecycle

国际惯例，官网镇楼

https://developer.android.com/topic/libraries/architecture/lifecycle

关于Lifecycle的基本使用，这里就不详细介绍了，毕竟官网讲的很清楚了，而且大部分时间，我们也用太感知细节，这也是JetPack的魅力所在。

Lifecycle作为JetPack的核心组件之一，在JetPack的多个组件中都扮演着非常重要的角色。

大部分时候，我们在使用JetPack的组件时，都不需要特别考虑Lifecycle，这得益于大部分JetPack组件的Lifecycle Aware特性，类似lifecycleScope、ViewModelScope都可以在生命周期结束时，自动对资源进行释放，可以说，Lifecycle是JetPack组件的脊梁，而且大部分时间，可以开箱即用，不用做太多配置就可以直接掌控生命周期。

Activity可以作为LifecycleOwner，在AAC架构中扮演着重要的作用，那么Activity是怎么关联Lifecycle的呢？

AppCompatActivity继承自FragmentActivity，FragmentActivity继承自ComponentActivity，在ComponentActivity中，通过LifecycleRegistry来关联生命周期，但是ComponentActivity并没有直接处理生命周期，而是通过ReportFragment来进行代理。

在ComponentActivity的onCreate中，对ReportFragment进行了初始化，代码如下所示。

ReportFragment.injectIfNeededIn(this);

在ReportFragment中，对不同版本做了兼容处理：

image-20210915161754312

在ReportFragment中，通过activity.getLifecycle()来获取Activity中申明的LifecycleRegistry，并对生命周期进行管理。

在App初始化的时候，Android利用ContentProvider来初始化ProcessLifecycleOwnerInitializer，在这里，又会对LifecycleDispatcher和ProcessLifecycleOwner中的ActivityInitializationListener进行初始化，从而实现生命周期的感知。

❝

细心的读者可能发现了，这里使用的是已经被废弃的android.app.Fragment，其原因就是为了兼容旧版本的Fragment所做的妥协。

❞

lifecycleScope

lifecycleScope是Lifecycle的拓展函数，是Lifecycle对协程的支持，所以要使用lifecycleScope必须要先引入Lifecycle。

lifecycleScope也是CoroutineScope，所以也支持launch函数来构建，但是lifecycleScope提供了更加精确的，带生命周期的创建函数，如下所示。

lifecycleScope.launchWhenCreated{}
lifecycleScope.launchWhenStarted{}
lifecycleScope.launchWhenResumed{}

分别对应Activity的生命周期。

lifecycleScope可以直接使用，也可以针对特定的生命周期控制，一般写法有如下两种。

• 直接使用

lifecycleScope.launch {
    XXXX
}

• 带特定生命周期控制，有两种方式

// 方式1
lifecycleScope.launchWhenStarted {
  XXX
}
// 方式2
lifecycleScope.launch {
    whenStarted {
   XXX
    }
}

lifecycleScope能自动取消协程，避免泄漏的原理其实非常简单，就是在Lifecycle的生命周期回调中，在onDestroy中对协程做Cancel操作。

image-20210728173437294

lifecycleScope的这种处理方式具有很强的指导意义，我们在平时的代码实现中，都可以借用这种方式来对生命周期进行自动管理。

普通组件感知生命周期

普通的组件是无法感知生命周期的，但是借助Lifecycle，我们就可以很轻松的为任意组件增加对生命周期的感知，其原理实际上就是对普通组件增加LifecycleEventObserver的实现，这样在LifecycleOwner的生命周期发生改变时，就能在onStateChanged中获取对应的生命周期变化了，代码如下所示。

@SuppressLint("ViewConstructor")
class LifecycleAwareView @JvmOverloads constructor(
    context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0, lifecycleOwner: LifecycleOwner
) : View(context, attrs, defStyleAttr), LifecycleEventObserver {

    init {
        // Do something init
        Log.d("xys", "Init-------")
        lifecycleOwner.lifecycle.addObserver(this)
    }

    private fun release() {
        // Do something release
        Log.d("xys", "Release-------")
    }

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when (event) {
            Lifecycle.Event.ON_DESTROY -> {
                release()
                source.lifecycle.removeObserver(this)
            }
        }
    }
}

如上所示，这是一个非常简单的自定义View，只不过实现了LifecycleEventObserver接口，并在init的时候增加监听，并对onStateChanged做了处理，增加了View在生命周期结束时的处理。

调用如下。

binding.root.addView(LifecycleAwareView(this, lifecycleOwner = this))

传入对应的LifecycleOwner即可。

Lifecycle in RecyclerView

比较常见的LifecycleOwner是Activity和Fragment，通常我们也是以这两个作为程序运行的承载界面，将生命周期与它们绑定是合理的，但在RecyclerView的场景下，这个界面生命周期的粒度就有些太粗了，如果我们在某个ViewHolder中发起网络请求，当这个ViewHolder被回收，那么这个请求在未处理的情况下，就会导致内存泄漏，所以通常的做法是ViewHolder的事件通过回调的方式托管到Activity，这样的方式，在业务开发场景下，是合理的，但是却不利于业务组件的封装。

首先，将业务逻辑回调到Activity，业务组件就只能以Activity作为使用范围，无法更加精细的控制组件粒度。

其次，回调托管写起来也比较麻烦。

所以，如果能自动管理ViewHolder的生命周期，那么就可以以ViewHolder，甚至是其中的View来作为业务组件的粒度划分，这样可以将业务逻辑统一处理而不用担心内存泄漏，而且业务方在使用时，可以直接黑盒使用某个业务组件，不必关心其中的逻辑。

❝

当然这种处理也是要分场景考虑的，其中一个重点就是这个组件是偏业务还是偏功能，也就是是否要将业务逻辑统一包进组件，想清楚这个问题后，才能去开发一个业务组件。

❞

那么我们如何来控制一个View的生命周期呢？

View其实提供了一个OnAttachStateChangeListener，可以回调View的onViewAttachedToWindow和onViewDetachedFromWindow，这就可以作为View的生命周期监控，再利用协程的CompletionHandler，来获得协程执行完成的回调，就可以对View的生命周期做处理了，代码如下所示。

private class ViewStateListener(
    private val view: View,
    private val job: Job
) : View.OnAttachStateChangeListener, CompletionHandler {
    override fun onViewDetachedFromWindow(v: View) {
        view.removeOnAttachStateChangeListener(this)
        Log.d("xys", "release")
        job.cancel()
    }

    override fun onViewAttachedToWindow(v: View) {}

    override fun invoke(cause: Throwable?) {
        view.removeOnAttachStateChangeListener(this)
        job.cancel()
    }
}

接下来，我们通过协程拦截器，在协程执行前，注入对View的监听，代码如下所示。

private class ViewAutoDisposeInterceptor(
    private val view: View
) : ContinuationInterceptor {
    override val key: CoroutineContext.Key<*>
        get() = ContinuationInterceptor

    override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> {
        val job = continuation.context[Job]
        if (job != null) {
            view.addOnAttachStateChangeListener(ViewStateListener(view, job))
        }
        return continuation
    }
}

最后，我们创建一个拓展函数，给View返回一个协程作用域，这个协程作用域可以在Viewdetached的时候，自动cancel协程的执行，从而避免内存泄漏，代码如下所示。

private const val TAG = R.id.autodispose_view_tag

val View.autoDisposeScope: CoroutineScope
    get() {
        val exist = getTag(TAG) as? CoroutineScope
        if (exist != null) {
            return exist
        }
        val newScope = CoroutineScope(
            SupervisorJob() +
                    Dispatchers.Main +
                    ViewAutoDisposeInterceptor(this)
        )
        setTag(TAG, newScope)
        return newScope
    }

这里给View设置了Tag，从而可以更好的利用缓存。

有了View、ViewHolder的生命周期管理，就可以很好的将耗时业务逻辑的处理封装到View、ViewHolder中，示例代码如下所示。

internal class SampleAdapter : RecyclerView.Adapter<RecyclerView.ViewHolder>() {
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder =
        object : RecyclerView.ViewHolder(TextView(parent.context)) {}

    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
        (holder.itemView as TextView).text = position.toString()
        val job = holder.itemView.autoDisposeScope.launch {
            delay(1000)
            Log.d("xys", "success $position")
        }
        job.invokeOnCompletion {
            Log.d("xys", "complete $position")
        }
    }

    override fun getItemCount(): Int = 300
}

这样就可以对任意View、ViewHolder创建自适应生命周期管理的协程作用域，从而实现autoDispose的功能。

向大家推荐下我的网站 https://xuyisheng.top/  点击原文一键直达

专注 Android-Kotlin-Flutter 欢迎大家访问

往期推荐

• flutter与compose的爱恨情仇
  

• 从精准化测试看ASM在Android中的强势插入-读懂diff
  

• 闲言碎语——第四期
  

• ConstraintLayout2.0一篇写不完之MotionLabel
  

本文原创公众号：群英传，授权转载请联系微信(Tomcat_xu)，授权后，请在原创发表24小时后转载。

< END >

作者：徐宜生

更文不易，点个“三连”支持一下👇