Kotlin 协程 让我们可以用同步代码来建立异步问题的模型。这是非常好的特性，但是目前大部分用例都专注于 I/O 任务或是并发操作。其实协程不仅在处理跨线程的问题有优势，还可以用来处理同一线程中的异步问题。

我认为有一个地方可以真正从中受益，那就是在 Android 视图系统中使用协程。

Android 视图 回调

Android 视图系统中尤其热衷于使用回调: 目前在 Android Framework 中，view 和 widgets 类中的回调有 80+ 个，在 Jetpack 中回调的数目更是超过了 200 个 (这里也包含了没有界面的依赖库)。

最常见的用法有以下几项:

• AnimatorListener 获取动画结束相关的事件
• RecyclerView.OnScrollListener 获取滑动状态变更事件
• View.OnLayoutChangeListener 获取 View 布局改变的事件

然后还有一些通过接受 Runnable 来执行异步操作的API，比如 View.post()、View.postDelayed() 等等。

正是因为 Android 上的 UI 编程从根本上就是异步的，所以造成了如此之多的回调。从测量、布局、绘制，到调度插入，整个过程都是异步的。通常情况下，一个类 (通常是 View) 调用系统方法，一段时间之后系统来调度执行，然后通过回调触发监听。

KTX 扩展方法

上述提及的 API，在 Jetpack 中都增加了扩展方法来提高开发效率。其中 View.doOnPreDraw()方法是我最喜欢的一个，该方法对等待下一次绘制被执行进行了极大的精简。其实还有很多我常用的方法，比如 View.doOnLayout()、Animator.doOnEnd()。

但是这些扩展方法也是仅止步于此，他们只是将旧风格的回调 API 改成了 Kotlin 中比较友好的基于 lambda 风格的 API。虽然用起来很优雅，但我们只是在用另一种方式处理回调，这还是没有解决复杂的 UI 的回调嵌套问题。既然我们在讨论异步操作，那在这种情况下，我们可以使用协程优化这些问题么？

使用协程解决问题

这里假定您已经对协程有一定的理解，如果接下来的内容对您来说会有些陌生，可以通过我们今年早期的系列文章进行回顾: 在 Android 开发中使用协程 | 背景介绍。

挂起函数 (Suspending functions) 是协程的基础组成部分，它允许我们以非阻塞的方式编写代码。这种特性非常适用于我们处理 Android UI，因为我们不想阻塞主线程，阻塞主线程会带来性能上的问题，比如: jank。

suspendCancellableCoroutine

在 Kotlin 协程库中，有很多协程的构造器方法，这些构造器方法内部可以使用挂起函数来封装回调的 API。最主要的 API 是 suspendCoroutine() 和 suspendCancellableCoroutine()，后者是可以被取消的。

我们推荐始终使用 suspendCancellableCoroutine()，因为这个方法可以从两个维度处理协程的取消操作:

#1: 可以在异步操作完成之前取消协程。如果某个 view 从它所在的层级中被移除，那么根据协程所处的作用域 (scope)，它有可能会被取消。举个例子: Fragment 返回出栈，通过处理取消事件，我们可以取消异步操作，并清除相关引用的资源。

#2: 在协程被挂起的时候，异步 UI 操作被取消或者抛出异常。并不是所有的操作都有已取消或出错的状态，但是这些操作有。就像后面 Animator 的示例中那样，我们必须把这些状态传递到协程中，让调用者可以处理错误的状态。

等待 View 被布局完成

让我们看一个例子，它封装了一个等待 View 传递下一次布局事件的任务 (比如说，我们改变了一个 TextView 中的内容，需要等待布局事件完成后才能获取该控件的新尺寸):

suspend fun View.awaitNextLayout() = suspendCancellableCoroutine<Unit> { cont ->

    // 这里的 lambda 表达式会被立即调用，允许我们创建一个监听器
    val listener = object : View.OnLayoutChangeListener {
        override fun onLayoutChange(...) {
            // 视图的下一次布局任务被调用
            // 先移除监听，防止协程泄漏
            view.removeOnLayoutChangeListener(this)
            // 最终，唤醒协程，恢复执行
            cont.resume(Unit)
        }
    }
    // 如果协程被取消，移除该监听
    cont.invokeOnCancellation { removeOnLayoutChangeListener(listener) }
    // 最终，将监听添加到 view 上
    addOnLayoutChangeListener(listener)

    // 这样协程就被挂起了，除非监听器中的 cont.resume() 方法被调用

}

此方法仅支持协程中一个维度的取消 (＃1 操作)，因为布局操作没有错误状态供我们监听。

接下来我们就可以这样使用了:

viewLifecycleOwner.lifecycleScope.launch {
    // 将该视图设置为不可见，再设置一些文字
    titleView.isInvisible = true
    titleView.text = "Hi everyone!"

    // 等待下一次布局事件的任务，然后才可以获取该视图的高度
    titleView.awaitNextLayout()

    // 布局任务被执行
    // 现在，我们可以将视图设置为可见，并其向上平移，然后执行向下的动画
    titleView.isVisible = true
    titleView.translationY = -titleView.height.toFloat()
    titleView.animate().translationY(0f)
}

我们为 View 的布局创建了一个 await 函数。用同样的方法可以替代很多常见的回调，比如 doOnPreDraw()，它是在 View 得到绘制时调用的方法；再比如 postOnAnimation()，在动画的下一帧开始时调用的方法，等等。

作用域

不知道您有没有发现这样一个问题，在上面的例子中，我们使用了 lifecycleScope 来启动协程，为什么要这样做呢？

为了避免发生内存泄漏，在我们操作 UI 的时候，选择合适的作用域来运行协程是极其重要的。幸运的是，我们的 View 有一些范围合适的 Lifecycle。我们可以使用扩展属性 lifecycleScope 来获得一个绑定生命周期的 CoroutineScope。

LifecycleScope 被包含在 AndroidX 的 lifecycle-runtime-ktx 依赖库中，可以在 这里找到更多信息。

我们最常用的生命周期的持有者 (lifecycle owner) 就是 Fragment 中的 viewLifecycleOwner，只要加载了 Fragment 的视图，它就会处于活跃状态。一旦 Fragment 的视图被移除，与之关联的 lifecycleScope 就会自动被取消。又由于我们已经为挂起函数中添加了对取消操作的支持，所以 lifecycleScope 被取消时，所有与之关联的协程都会被清除。

等待 Animator 执行完成

我们再来看一个例子来加深理解，这次是等待 Animator 执行结束:

suspend fun Animator.awaitEnd() = suspendCancellableCoroutine<Unit> { cont ->

    // 增加一个处理协程取消的监听器，如果协程被取消，
    // 同时执行动画监听器的 onAnimationCancel() 方法，取消动画
    cont.invokeOnCancellation { cancel() }

    addListener(object : AnimatorListenerAdapter() {
        private var endedSuccessfully = true

        override fun onAnimationCancel(animation: Animator) {
            // 动画已经被取消，修改是否成功结束的标志
            endedSuccessfully = false
        }

        override fun onAnimationEnd(animation: Animator) {

            // 为了在协程恢复后的不发生泄漏，需要确保移除监听
            animation.removeListener(this)
            if (cont.isActive) {

                // 如果协程仍处于活跃状态
                if (endedSuccessfully) {
                    // 并且动画正常结束，恢复协程
                    cont.resume(Unit)
                } else {
                    // 否则动画被取消，同时取消协程
                    cont.cancel()
                }
            }
        }
    })
}

这个方法支持两个维度的取消，我们可以分别取消动画或者协程:

#1: 在 Animator 运行的时候，协程被取消 。我们可以通过 invokeOnCancellation 回调方法来监听协程何时被取消，这能让我们同时取消动画。

#2: 在协程被挂起的时候，Animator 被取消 。我们通过 onAnimationCancel() 回调来监听动画被取消的事件，通过调用协程的 cancel() 方法来取消挂起的协程。

这就是使用挂起函数等待方法执行来封装回调的基本使用了。

组合使用

到这里，您可能有这样的疑问，"看起来不错，但是我能从中收获什么呢？" 单独使用其中某个方法，并不会产生多大的作用，但是如果把它们组合起来，便能发挥巨大的威力。

下面是一个使用 Animator.awaitEnd() 来依次运行 3 个动画的示例:

viewLifecycleOwner.lifecycleScope.launch {
    ObjectAnimator.ofFloat(imageView, View.ALPHA, 0f, 1f).run {
        start()
        awaitEnd()
    }

    ObjectAnimator.ofFloat(imageView, View.TRANSLATION_Y, 0f, 100f).run {
        start()
        awaitEnd()
    }

    ObjectAnimator.ofFloat(imageView, View.TRANSLATION_X, -100f, 0f).run {
        start()
        awaitEnd()
    }
}

这是一个很常见的使用案例，您可以把这些动画放进 AnimatorSet 中来实现同样的效果。

但是这里使用的方法适用于不同类型的异步操作: 我们使用一个 ValueAnimator，一个 RecyclerView 的平滑滚动，以及一个 Animator 来举例:

viewLifecycleOwner.lifecycleScope.launch {
    // #1: ValueAnimator
    imageView.animate().run {
        alpha(0f)
        start()
        awaitEnd()
    }

    // #2: RecyclerView smooth scroll
    recyclerView.run {
        smoothScrollToPosition(10)
        // 该方法和其他方法类似，等待当前的滑动完成，我们不需要刻意关注实现
        // 代码可以在文末的引用中找到
        awaitScrollEnd()
    }

    // #3: ObjectAnimator
    ObjectAnimator.ofFloat(textView, View.TRANSLATION_X, -100f, 0f).run {
        start()
        awaitEnd()
    }
}

试着用 AnimatorSet 实现一下吧！如果不用协程，那就意味着我们要监听每一个操作，在回调中执行下一个操作，这回调层级想想都可怕。

通过把不同的异步操作转换为协程的挂起函数，我们获得了简洁明了地编排它们的能力。

我们还可以更进一步...

**如果我们希望 ValueAnimator 和平滑滚动同时开始，然后在两者都完成之后启动 ObjectAnimator，该怎么做呢？**那么在使用了协程之后，我们可以使用 async() 来并发地执行我们的代码：

viewLifecycleOwner.lifecycleScope.launch {
    val anim1 = async {
        imageView.animate().run {
            alpha(0f)
            start()
            awaitEnd()
        }
    }

    val scroll = async {
        recyclerView.run {
            smoothScrollToPosition(10)
            awaitScrollEnd()
        }
    }

    // 等待以上两个操作全部完成
    anim1.await()
    scroll.await()

    // 此时，anim1 和滑动都完成了，我们开始执行 ObjectAnimator
    ObjectAnimator.ofFloat(textView, View.TRANSLATION_X, -100f, 0f).run {
        start()
        awaitEnd()
    }
}

但是如果您还想让滚动延迟执行怎么办呢？ (类似 Animator.startDelay 方法) 那么使用协程也有很好的实现，我们可以用 delay() 方法:

viewLifecycleOwner.lifecycleScope.launch {
    val anim1 = async {
        // ...
    }

    val scroll = async {
        // 我们希望在 anim1 完成后，延迟 200ms 执行滚动
        delay(200)

        recyclerView.run {
            smoothScrollToPosition(10)
            awaitScrollEnd()
        }
    }

    // …
}

如果我们想重复动画，那么我们可以使用 repeat() 方法，或者使用 for 循环实现。下面是一个 view 淡入淡出 3 次的例子:

viewLifecycleOwner.lifecycleScope.launch {
    repeat(3) {
        ObjectAnimator.ofFloat(textView, View.ALPHA, 0f, 1f, 0f).run {
            start()
            awaitEnd()
        }
    }
}

您甚至可以通过重复计数来实现更精妙的功能。假设您希望淡入淡出在每次重复中逐渐变慢:

viewLifecycleOwner.lifecycleScope.launch {
    repeat(3) { repetition ->
        ObjectAnimator.ofFloat(textView, View.ALPHA, 0f, 1f, 0f).run {
            // 第一次执行持续 150ms，第二次：300ms，第三次：450ms
            duration = (repetition + 1) * 150L
            start()
            awaitEnd()
        }
    }
}

在我看来，这就是在 Android 视图系统中使用协程能真正发挥作用的地方。我们就算不去组合不同类型的回调，也能创建复杂的异步变换，或是将不同类型的动画组合起来。

通过使用与我们应用中数据层相同的协程开发原语，还能使 UI 编程更便捷。对于刚接触代码的人来说， await 方法要比看似会断开的回调更具可读性。

最后

希望通过本文，您可以进一步思考协程还可以在哪些其他的 API 中发挥作用。

接下来的文章中，我们将探讨如何使用协程来组织一个复杂的变换动画，其中也包括了一些常见 View 的实现，感兴趣的读者请继续关注我们的更新。