Blog / Programming

侧滑返回卡死:手势结束早于 startInteractiveTransition

最近修了一个挺有意思的 bug。在一个带自定义转场的编辑页里,从屏幕左边缘快速轻扫一下,偶尔整页就卡死了:画布的位置被一张静态图盖住,返回按钮点了没反应,再怎么侧滑也没反应。慢慢拖没事,正常甩也没事,偏偏是那种手指一碰就抬的轻扫会出问题。

修复本身没几行,但找原因花的时间比预想的长不少,中间还猜错了一次。问题最后出在一个平时根本不会去想的地方:dismiss() 返回的时候,交互转场其实还没有开始。

这套转场是怎么做的

先交代一下背景。列表页的卡片点进编辑页时,卡片会放大成编辑页的画布,是一个自定义的 hero 转场。返回有两种方式:点返回按钮,走普通的 dismiss 动画;或者从左边缘侧滑,走交互式 dismiss,hero 跟着手指缩回卡片的位置,松手后看位移和速度决定是完成还是取消。

侧滑的手势处理是很常见的写法:

Swift
@objc private func handleInteractiveDismissPan(_ pan: UIScreenEdgePanGestureRecognizer) {
    let translation = pan.translation(in: view)
    switch pan.state {
    case .began:
        interactor = InteractiveDismiss()
        dismiss(animated: true)                 // UIKit 在这里向 delegate 取走 interactor
    case .changed:
        interactor?.update(translation: translation, containerWidth: view.bounds.width)
    case .ended, .cancelled:
        let shouldFinish = translation.x > view.bounds.width * 0.35
            || pan.velocity(in: view).x > 800
        shouldFinish ? interactor?.finish() : interactor?.cancel()
        interactor = nil
    default:
        break
    }
}

InteractiveDismiss 是我们自己实现的 UIViewControllerInteractiveTransitioning。dismiss(animated:) 被调用后,UIKit 会通过 transitioning delegate 拿到它,之后在 startInteractiveTransition(_:) 里把 transitionContext 交给它,后面的 update、finish、cancel 都要靠这个 context 来推进转场。

卡在了哪一步?

遇到这种偶现的卡死,先别急着重启,趁现场还在,用 Lookin 把视图层级读一遍。读出来的状态是这样的:UITransitionView 里还留着 hero 视图,frame 正好等于画布的 frame,里面那张快照的 alpha 是 0,所以看起来就像是画布当前帧被冻住了;编辑页画布容器的 alpha 是 0,编辑页本身的 alpha 却还是 1;列表页那张源卡片是隐藏的。

这几个值放在一起看,指向性就很强了。hero 搭好了,画布和源卡片也都藏起来了,说明 startInteractiveTransition 已经跑完;可编辑页的 alpha 还是 1,说明一次 update 都没发生过。转场开了个头,然后就没人管了。

第一个猜测,错了

接下来回去读代码,很快找到了一个看起来非常合理的解释:cancel 之后有一段 0.25 秒的回弹动画,在它 completeTransition 之前,用户如果又开始了一次侧滑,UIKit 会把新转场往后推,于是手势结束的时候新转场还没开始。代码里也确实有佐证:.ended 的 cancel 分支会立刻复位状态,gestureRecognizerShouldBegin 也没有检查当前是否已经有转场在进行。

逻辑上完全说得通,我差点就按这个思路去改了。但这毕竟只是推测,所以还是先在整条链路上加了日志:手势的每个阶段、dismiss 前后的 transitionCoordinator、delegate 每次返回的是哪个 interactor、interactor 从创建到释放的完整生命周期、动画的 completion,以及容器里的子视图快照。

让日志说话

复现几次之后,卡死那一轮的日志是这样的(t 是 CACurrentMediaTime() 的小数部分):

t 日志 说明
.891 before dismiss: coordinator=nil 发起之前没有任何转场在进行
.892 delegate interactionControllerForDismissal → 0x…250 UIKit 当场取走了 interactor
.892 pan began handled dismiss() 已经返回,start 还没来
.892 pan ended progress=0.0 shouldFinish=false began 和 ended 在同一毫秒
.892 interactor cancel: context=nil → dropped cancel 被丢掉了
.895 interactor start id=0x…250 3ms 之后,转场才真正开始
之后 同一个 id 再没有 update、finish 或 cancel 转场就此挂起

第一行就把之前的猜测推翻了:发起 dismiss 之前 coordinator 是 nil,根本没有什么重叠的转场。

问题不在上一次转场,而在这一次转场自己身上:pan ended 和 interactor cancel 都跑在了 interactor start 的前面。

start 到底什么时候被调用?

翻了一下之前正常侧滑的日志,start 也从来不是在 dismiss() 里同步调用的,总是晚个 3 到 10 毫秒。dismiss() 当场做的事情只有两件:向 delegate 要 animator 和 interactor,然后把它们强持有。真正调用 startInteractiveTransition(_:) 要等到之后。

平时这点延迟完全感觉不到。正常侧滑时,手势的下一个事件大概 16 毫秒后才到,那时候转场早就开始了,update、finish、cancel 都能拿到 context。可如果手指一碰就抬,began 和 ended 会在同一帧里送过来,cancel() 就抢在了 start 前面:

正常侧滑与极短轻扫的时序对比 正常侧滑中,startInteractiveTransition 在 3 毫秒时开始,16 毫秒后的手势事件都能拿到 transitionContext。极短轻扫中,began 和 ended 在同一帧,cancel 在 start 之前执行并被丢弃,3 毫秒后 start 建好 hero,此后转场永远挂起。 0ms +3ms +16ms 之后 正常侧滑 手势 Pan UIKit Interactor began changed … ended dismiss():取走 interactor start:transitionContext 就绪 update finish / cancel ✓ 极短轻扫(卡死) 手势 Pan UIKit Interactor began + ended(同一帧) dismiss() cancel():context == nil → 被丢弃 start:建 hero、隐藏画布和源卡片 挂起:再也没有 update / finish / cancel
同一个 interactor,两种手势节奏。问题只出在「ended 早于 start」的那一种。

再看一下当时的 cancel():

Swift
func cancel() {
    guard let context = transitionContext else {
        transitionContext?.completeTransition(false)   // context 就是 nil,这行什么也不做
        return
    }
    // …回弹动画,结束时 completeTransition(false)
}

guard 的 else 分支看起来像是做了兜底,可 transitionContext 这时候就是 nil,对 nil 调用 completeTransition 什么也不会发生。也就是说,这次 cancel 被悄无声息地吞掉了。紧接着 VC 把自己手里的 interactor 置空,但 UIKit 那边还持有着它。3 毫秒后,UIKit 照常调用 startInteractiveTransition,hero 搭好了,画布藏起来了,然后再也没有人来收尾。

为什么之后怎么滑都没用?

这次 dismiss 转场一直没有完成,在 UIKit 看来它还在进行中。之后不管是侧滑还是点返回,都会再调一次 dismiss(),而 UIKit 会直接忽略掉:日志里 delegate 再也没有被询问过,新创建的 interactor 一次都没有被 start,最后安安静静地 deinit 了。

有点像在餐厅点菜:dismiss() 是下单,后厨要过几毫秒才接单。客人在接单之前说了“算了”,服务员手里还没单子,这句话就没人记下;后厨照常把菜端上桌,从此一直摆着,而且一次只做一单,后面的单一概不收。

修复:让 interactor 记住自己走到了哪一步

想明白之后,修法就比较清楚了。既然没办法保证 start 一定早于手势结束,那就不去依赖这个顺序,而是让 interactor 自己记录当前处于哪个阶段:start 之前收到的结束信号先存起来,等 start 把场景搭好之后再执行。因此,VC 和手势判定的代码都不用动。

InteractiveDismiss 的阶段状态机 四个阶段依次为 waitingStart、interacting、ending、completed。waitingStart 阶段收到 finish 或 cancel 时只记下 pendingEnd;startInteractiveTransition 进入 interacting,补一次 update 并执行 pendingEnd;finish 或 cancel 进入 ending 并播放动画;动画结束先置 completed 再 completeTransition。ending 和 completed 阶段的重复调用一律忽略。 waitingStart interacting ending completed finish() / cancel() 只记下 pendingEnd start:搭好场景 补一次 update 执行 pendingEnd finish() / cancel() 播放动画 动画结束:先置 completed 再 completeTransition 这两个阶段里的重复调用一律忽略
结束信号可以早于 start 到达,但只会在 start 之后、且只执行一次。

改完之后,interactor 大概是这样:

Swift
final class InteractiveDismiss: NSObject, UIViewControllerInteractiveTransitioning {
    private enum Phase { case waitingStart, interacting, ending, completed }
    private enum PendingEnd { case finish, cancel }

    private var phase: Phase = .waitingStart
    private var pendingEnd: PendingEnd?
    private var lastTranslation: CGPoint?
    private var lastContainerWidth: CGFloat = 1
    private var transitionContext: UIViewControllerContextTransitioning?

    func startInteractiveTransition(_ context: UIViewControllerContextTransitioning) {
        transitionContext = context
        setUpHero(in: context)                 // 建 hero,隐藏画布和源卡片
        phase = .interacting

        // start 之前收到的手势信息,在这里补上
        if let t = lastTranslation {
            applyProgress(translation: t, containerWidth: lastContainerWidth)
        }
        if let end = pendingEnd {
            pendingEnd = nil
            self.end(end)
        }
    }

    func update(translation: CGPoint, containerWidth: CGFloat) {
        lastTranslation = translation          // 无论何时都先记下
        lastContainerWidth = containerWidth
        guard phase == .interacting else { return }
        applyProgress(translation: translation, containerWidth: containerWidth)
    }

    func finish() { end(.finish) }
    func cancel() { end(.cancel) }

    private func end(_ kind: PendingEnd) {
        switch phase {
        case .waitingStart:
            pendingEnd = kind                  // start 还没来:先存着
        case .ending, .completed:
            return                             // 只收尾一次
        case .interacting:
            guard let context = transitionContext else { return }
            phase = .ending
            let finished = kind == .finish
            finished ? context.finishInteractiveTransition()
                     : context.cancelInteractiveTransition()
            animateEnd(finished: finished) { [self] in
                phase = .completed             // 先置状态,再通知 UIKit
                context.completeTransition(finished)
            }
        }
    }
}

有几处细节值得多说一句。update 不管处在哪个阶段都会先记下最新的位移,只有进入 .interacting 之后才真正去驱动 hero,这样 start 里补的那一次 update,用的就是手势最后的真实位置。动画的 completion 里先把阶段改成 .completed,再去调用 completeTransition,保证一次转场只会被完成一次。原来那句对 nil 无效的 completeTransition(false) 也直接删掉了,留着它只会让人误以为这里已经兜过底。

也想过别的办法

修的时候还考虑过几种思路,最后都没有用。

一种是在 start 里回头读手势的状态。问题是 .ended 之后手势很快就会被重置成 .possible,速度也拿不到了,根本判断不了应该 finish 还是 cancel。

另一种是在 .ended 的时候把 delegate 返回的 interactor 置空,或者把 wantsInteractiveStart 设成 false。可惜都来不及:UIKit 在 dismiss() 里就已经把 interactor 拿走了,而 wantsInteractiveStart 还需要配合 interruptibleAnimator 才有意义。

还有一种是在 gestureRecognizerShouldBegin 里加个判断,转场进行中就不让手势开始。这能减少一些重复触发,但已经挂起的那一次还是挂着,属于治标不治本。

怎么稳定复现

这种 bug 靠手去试很难稳定复现,最后交给了自动化。在模拟器里从左边缘 50pt 以内做向右的轻扫,duration 设成 0.03 到 0.05 秒,然后一直循环“进入编辑页、轻扫、没返回就点返回按钮”。有一个前提要注意:源卡片得在列表页上可见,因为转场要知道 hero 该缩回哪里,卡片不可见的时候侧滑本来就会被禁用。

判断有没有命中,不用盯画面,看日志就行:只要某个 interactor 的 pan ended 出现在它自己的 interactor start 之前,就说明碰上了这个时序。修复前,这样的轮次会卡死;修复后,它应该弹回编辑页,并且还能继续操作。

最后

回头看,这个 bug 的根源是一个默认的假设:调用 dismiss() 之后,转场就已经开始了。平时这个假设几乎总是成立,所以代码里处处都在依赖它,直到一次足够快的轻扫把它打破。写交互转场时,update、finish、cancel 都应该按“可能早于 start 到达”来处理。

另一个教训是关于排查方式的。那个关于重叠转场的猜测,单看代码几乎挑不出毛病,如果没有先打日志确认顺序,很可能会顺着它改出一个看似合理、其实没解决问题的修复。时序相关的问题,还是先让日志告诉你谁先谁后,再去想为什么。