Two observers within the same app interfering with each other - swift

Question

I have two observers within my app, one that is ordered, one that isn't. The unordered observer seems to interfere with the ordered observer's results.
My database looks like this:
"events" : {
"Oo75nbcDsUK7vPWGDbnL" : {
"queue" : {
"K7THdbKzd2aSfaD9a0xmsszkReq1" : {
"queuePosition" : 1
},
"R5UwSxlH3vhH6SjTNMGfMoiaGae2" : {
"queuePosition" : 2
}
}
}
}
I have a class that handles the observer creation for the real-time database with the following static function:
static func listenToRtdbDocument<T: JSONDecodable>(_ refString: String, eventType: DataEventType = .value, orderedByChild: String? = nil, limit: Int? = nil, fromCollection collection: Firebase.RtdbCollections? = nil, completion: #escaping (_ decodedDoc: T?, _ error: Error?) -> ()) -> DatabaseHandle {
var query: DatabaseQuery
if let orderedByChild = orderedByChild {
query = rtdb.child(refString).queryOrdered(byChild: orderedByChild)
} else {
query = rtdb.child(refString)
}
if let limit = limit {
query.queryLimited(toFirst: UInt(limit))
}
return query.observe(eventType, with: { snapshot in
guard var docData = snapshot.value as? [String : Any] else {
completion(nil, nil)
return
}
docData["id"] = snapshot.key
let decodedDoc = T(json: docData)
completion(decodedDoc, nil)
}) { error in
completion(nil, error)
}
}
This creates the observer and then returns a DatabaseHandle reference. I use this function in two different places in my app. The first is inside a collection view cell model. This calls the function like so:
queuerRefString = "events/Oo75nbcDsUK7vPWGDbnL/queue/R5UwSxlH3vhH6SjTNMGfMoiaGae2"
func listenToQueuer(updateHandler: #escaping (QueuerJSONModel?) -> ()) {
guard queuerListener == nil,
let refString = queuerRefString else { return }
queuerListener = FirebaseClient.listenToRtdbDocument(refString) { (queuer: QueuerJSONModel?, error) in
guard error == nil else {
return
}
updateHandler(queuer)
}
}
The second is from a view controller model. This view controller gets presented over the collection view cell:
queueRefString = "events/Oo75nbcDsUK7vPWGDbnL/queue"
func listenToQueue() {
guard queueChildAddedListener == nil
let refString = queueRefString else { return }
queueChildAddedListener = FirebaseClient.listenToRtdbDocument(refString, eventType: .childAdded, orderedByChild: "queuePosition", limit: 25) { [weak self] (queuer: QueuerJSONModel?, error) in
guard let strongSelf = self,
let queuer = queuer,
error == nil else {
print("an error occurred")
return
}
strongSelf.queuers?.append(queuer)
}
}
For the ordered array observer, this always returns the current user first, and then the rest of the ordered queue. E.g. If the current user is at position 5, the queuers array will look like this:
5, 1, 2, 3, 4, 6, 7, 8, 9, 10
How can I stop them from interfering with each other??
UPDATE
How to reproduce:
Put this code in one view controller's viewDidLoad method:
let test1 = Database.database().reference()
.child("events/Oo75nbcDsUK7vPWGDbnL/queue/R5UwSxlH3vhH6SjTNMGfMoiaGae2")
.observe(.value, with: { snapshot in
guard var docData = snapshot.value as? [String : Any] else {
return
}
docData["id"] = snapshot.key
let queuer = QueuerJSONModel(json: docData)!
print("ok we got", queuer.queuePosition) // Prints out 2
})
Then put this code in another view controller's viewDidLoad method:
let test2 = Database.database().reference()
.child("events/Oo75nbcDsUK7vPWGDbnL/queue")
.queryOrdered(byChild: "queuePosition")
.queryLimited(toFirst: 25)
.observe(.childAdded, with: { snapshot in
guard var docData = snapshot.value as? [String : Any] else {
return
}
docData["id"] = snapshot.key
let queuer = QueuerJSONModel(json: docData)!
print("ok we got", queuer.queuePosition) // Prints out 2, then 1
})
First view the view controller that has test1 in, then view the one with test2 in. I use a tab bar controller to switch between the two.
Oddly, if these two pieces of code are put within the same viewDidLoad method of a view controller, then the ordered listener works as expected.

Answer 1

The behavior you're observing is because of to the way 'value' events are different from 'childAdded' events.
In your first observer (using .value), you're simply requesting all the data from events/Oo75nbcDsUK7vPWGDbnL/queue/R5UwSxlH3vhH6SjTNMGfMoiaGae2 in a single snapshot. If any data under the location changes while that observer is still added, your observer will get invoked again with a snapshot of everything at that location.
In your second observer (using .childAdded), you're requesting that your observer be called once for each child at events/Oo75nbcDsUK7vPWGDbnL/queue. If you have two children there, your observer will be called once for each child. As new children are added at that location, your observer will get called again, once for each new one.
The observers are not interfering with each other. They're just doing different things.

Answer 2

This is Firebase support's response to my question:
Apparently, this is an intended behavior. The idea of childAdded is, here is what you have retrieved so far, and what hasn't been added yet. So the childAdded gives R5UwSxlH3vhH6SjTNMGfMoiaGae2 as your preloaded data, and comes back with K7THdbKzd2aSfaD9a0xmsszkReq1 as your new data.
This way, even if you have requested it to be ordered, it won't necessarily come back ordered, if you have preloaded data on your device.