如何检测firebase观察childAdded在达到queryLimit时停止调用？

Question

现在，我对使用 childAdded 数据事件类型观察的 firebase 感到非常困惑。我之所以使用 childAdded 来观察我的 firebase，是因为我想让我的列表页面 动态 firebase 是否有新数据插入。

我的问题是如何知道当达到 queryLimit 时观察是否停止调用？因为我有一个指示器，我想在达到 queryLimit 时将其关闭。

我的firebase结构如下：

root {
  talkID1(id by auto create) {
    attribute1 ...
    attribute2 ...
    attribute3 ...
    time
  }

  talkID2(id by auto create){
    ...
    time
  }

  ... // many talk ID which auto create by firebase

}

据我所知，如果使用 childAdd 进行观察，数据将一个孩子一个孩子地在回调中传递数据。因此，如果我在 firebase 中有 N 个数据，我认为它会调用 N，对吗？

下面是我的完成处理程序：

func receiveIfExist(completion: @escaping (_ data: (My data type) -> Void) {
    let requestWithQuery = Database.database.reference().child("root").queryOrdered(byChild: "time")

    requestWithQuery.queryLimited(toLast: 5).observe(.childAdded, with: { (snapshot) in
        guard let value = snapshot.value as? [String: Any] else { return }

        self.getSingleTalkInfo(key: snapshot.key, value: value, completion: { (data) in
            completion(data)
        })
    })
}

我在 viewDidLoad() 中调用 receiveIfExist 这个函数。

override func viewDidLoad() {
    super.viewDidLoad()

    self.myIndicator.startAnimating() // start running indicator
    self.receiveIfExist { (data) in

        self.handleTalk(with: data) // do something with request data
        self.myIndicator.stopAnimating() // WEIRD!!!! Please look comments below

        /* 
           I think it can not be added here because this completion will call N<=5 times just what I said before. 
           I think it should detect what my queryLimit data is and check the request data is this queryLimit data or not.
           If yes then stop indicator animating, if not then keep waiting the queryLimit reach.
        */
    } 
}

如何检测观察是否达到 queryLimit？

如果我能检测到，那么我可以在指示灯到达时关闭它。

谢谢！

Answer 1

queryLimited(toLast: 5)

意思是（用更简单的话来说）请获取最后 5 个值（顺序由查询的前一部分决定）

1.现在，由于您是按 times 对数据进行排序，因此将检索最后 5 次的值，因此您的观察者将被触发 5 次

2.请注意，如果您的记录少于 5 条，比如 2 条记录，那么它只会触发两次，因为最大限制是 5，而不是最小限制

3. 另一点是，如果添加了一个新孩子，并且当您根据时间再次对项目进行排序并且新孩子是最后 5 个项目之一，那么这个观察者将是再次触发。

所以要获得查询限制，您可以像这样在代码中进行一些更改：

func receiveIfExist(completion: @escaping (data: YourType, limitCount: Int) -> Void) {
    let requestWithQuery = Database.database.reference().child("root").queryOrdered(byChild: "time")

    requestWithQuery.queryLimited(toLast: 5).observe(.childAdded, with: { (snapshot) in
        guard let value = snapshot.value as? [String: Any] else { return }

        self.getSingleTalkInfo(key: snapshot.key, value: value, completion: { (data) in
            self.index = self.index + 1
            completion(data, self.index)
        })
    })
}

然后使用上面的函数如下：

var index = 0
override func viewDidLoad() {
    super.viewDidLoad()

    self.myIndicator.startAnimating() // start running indicator
    self.receiveIfExist { (data, limitCount) in

        self.handleTalk(with: data) // do something with request data
        if limitCount == 5 {
             self.myIndicator.stopAnimating()
        }


    } 
}

更新：

由于 Kevin 提出了非常好的观点，如果我们说只有两条记录并且索引永远不会等于 5 并且myIndicator 不会停止动画，那么上述解决方案将失败，

我想到的一个解决方案是：

首先，我们使用observeSingleEvent 获取孩子数：

func getChildrenCount(completion: @escaping (_ childrenCount: Int) -> Void){
    Database.database.reference().child("root").observeSingleEvent(of:.value with: { (snapshot) in

                   completion(snapshot.children.count)

    }
}  

然后我们应用查询来获取最后 5 个项目：

func receiveIfExist(completion: @escaping (data: YourType, limitCount: Int) -> Void) {
        let requestWithQuery = Database.database.reference().child("root").queryOrdered(byChild: "time")

        requestWithQuery.queryLimited(toLast: queryLimit).observe(.childAdded, with: { (snapshot) in
            guard let value = snapshot.value as? [String: Any] else { return }

            self.getSingleTalkInfo(key: snapshot.key, value: value, completion: { (data) in
                self.index = self.index + 1
                completion(data, self.index)
            })
        })
    }

然后在您的代码中使用此计数，如下所示：

var index = 0
var childrenCount = 0
var queryLimit = 5
override func viewDidLoad() {
    super.viewDidLoad()

    self.myIndicator.startAnimating() // start running indicator
    self.getChildrenCount {(snapChildrenCount) in
         self.childrenCount = snapChildrenCount

         self.receiveIfExist { (data, limitCount) in

        self.handleTalk(with: data) // do something with request data
        if (self.childrenCount < self.queryLimit && limitCount == self.childrenCount) || limitCount == self.queryLimit  {
             DispatchQueue.main.async {
                   self.myIndicator.stopAnimating()
             }

        }


    } 

    }

}

Answer 2

func receiveIfExist(limitCount: UInt, completion: @escaping (data: MyDataType) -> Void) {
    let requestWithQuery = Database.database.reference().child("root").queryOrdered(byChild: "time")

    requestWithQuery.queryLimited(toLast: limitCount).observe(.childAdded, with: { (snapshot) in
        guard let value = snapshot.value as? [String: Any] else { return }

        self.getSingleTalkInfo(key: snapshot.key, value: value, completion: { (data) in
            completion(data)
        })
    })
}

我也做这个功能只观察单个孩子的价值

let requestTalks = Database.database.reference().child("root")    

func getSingleTalk(by key: String = "", at limitType: TalkLimitType, completion: @escaping (_ eachData: MyDataType) -> Void) {

    var requestSingleTalk: DatabaseQuery {
        switch limitType {
        case .first :
            return self.requestTalks.queryOrdered(byChild: "time").queryLimited(toFirst: 1)

        case .last :
            return self.requestTalks.queryOrdered(byChild: "time").queryLimited(toLast: 1)

        case .specificKey :
            return self.requestTalks.child(key)
        }
    }

    requestSingleTalk.observeSingleEvent(of: .value, with: { (snapshot) in

        if limitType == .specificKey {
            guard let value = snapshot.value as? [String: Any] else { return }

            self.getSingleTalkInfo(key: snapshot.key, value: value, completion: { (data) in
                completion(data)
            })
        } else {
            guard let snapshotValue = snapshot.value as? NSDictionary,
                  let eachTalkKey = snapshotValue.allKeys[0] as? String,
                  let eachTalkValue = snapshotValue.value(forKey: eachTalkKey) as? [String: Any] else { return }

            self.getSingleTalkInfo(key: eachTalkKey, value: eachTalkValue, completion: { (data) in
                completion(data)
            })
        }
    })
}

因此，我可以在 viewDidLoad() 中执行类似的操作

override func viewDidLoad() {
    super.viewDidLoad()

    self.myIndicator.startAnimating()
    self.receiveIfExist(limitCount: 5) { (eachData) in
        self.handleTalk(with: eachData)
        self.getSingleTalk(at: .last, completion: { (lastData) in
            if eachData.keyID == lastData.keyID{
                DispatchQueue.main.async {
                    self.myIndicator.stopAnimating()
                }
            }
        })
    } 
}