Swift async/await监听Firebase数据重复resume崩溃问题咨询

withCheckedContinuation 仅适配单次返回结果的异步桥接场景，按照约定resume方法只能调用一次，调用完成后对应的await流程就已经结束，后续再触发resume必然导致崩溃。
你当前将持续触发回调的observe监听接口包裹在withCheckedContinuation中的思路本身不成立：哪怕把continuation存为可选、第一次resume后置空来规避崩溃，第一次回调触发后函数就已经返回，后续的数据更新根本无法传递到上层调用方，完全达不到持续监听位置更新的目的。
另外你实现的getDriverSingleLocation方法逻辑本身是成立的——observeSingleEvent只会触发一次回调，刚好匹配continuation的单次返回特性，只是代码里漏了driverReference的赋值逻辑。

对于多次回调、持续推送更新的监听场景，在Swift Concurrency体系下应该使用AsyncStream做桥接，它原生支持多次向异步流推送新值，完全匹配Firebase实时数据监听的场景，同时保持全链路异步特性。

修正后的完整代码如下：

class StoreFirebase {
    private let ref = Database.database().reference()
    var driverObserver: UInt?
    var driverReference: DatabaseReference?
    
    // 单次获取数据的方法逻辑保留，补全引用赋值即可
    func getDriverSingleLocation(_ uuid: String) async -> Result<StoreData, Error> {
        let queryRef = ref.child("driversAvailable").child(uuid)
        driverReference = queryRef
        
        return await withCheckedContinuation { continuation in
            queryRef.observeSingleEvent(of: .value) { (snapshot) in
                if let dictionary = snapshot.value as? StoreData {
                    continuation.resume(returning: .success(dictionary))
                } else {
                    continuation.resume(returning: .failure(HTTPError(.badRequest)))
                }
            }
        }
    }
    
    // 持续监听场景改用AsyncStream实现
    func getDriverLocationStream(_ uuid: String) -> AsyncStream<Result<StoreData, Error>> {
        let driverRef = ref.child("driversAvailable").child(uuid)
        self.driverReference = driverRef
        
        return AsyncStream { continuation in
            // 注册Firebase数据监听
            let observerHandle = driverRef.observe(.value) { snapshot in
                if let dictionary = snapshot.value as? StoreData {
                    // 每次数据更新直接向流中推送新值，无单次调用限制
                    continuation.yield(.success(dictionary))
                } else {
                    continuation.yield(.failure(HTTPError(.badRequest)))
                }
            }
            self.driverObserver = observerHandle
            
            // 流终止时自动移除监听，避免泄漏
            continuation.onTermination = { @Sendable [weak self] _ in
                driverRef.removeObserver(withHandle: observerHandle)
                self?.driverObserver = nil
                self?.driverReference = nil
            }
        }
    }
}

调用方式 #

通过for await遍历异步流即可持续拿到最新的位置更新，保持原生异步写法的一致性：

Task {
    let locationStream = StoreFirebase().getDriverLocationStream("目标用户UUID")
    for await locationResult in locationStream {
        switch locationResult {
        case .success(let locationData):
            // 处理最新位置数据，比如更新UI
            print("收到位置更新：", locationData)
        case .failure(let error):
            // 处理数据解析错误
            print("数据获取失败：", error)
        }
    }
}

• 不要用可选值包裹continuation、resume后置空的方案绕开崩溃，这种写法本质上丢失了后续所有数据更新，完全无法实现持续监听的需求
• 实现AsyncStream时必须添加onTermination回调，在流被取消时主动移除Firebase的监听句柄，避免内存泄漏和无效的网络开销
• 单次拉取数据的场景可以继续保留withCheckedContinuation搭配observeSingleEvent的实现，不需要强行改成流逻辑

内容的提问来源于stack exchange，提问作者Guillermo