Firebase Firestore Listener Fires Multiple Times

I am using Firebase Firestore for an iOS app.

I have a promise function I run that loops through an array and writes a document for each array item via a Firestore batch query.

In parallel, I have a listener on the collection which my function writes documents under.

To avoid having the listener fire repeatedly, I remove the listener prior to running the promise function. Once the promise function is complete, I reattach the listener in the promise function's completion handler.

My problem is, despite having done this, I notice that the listener fires repeatedly after attaching instead of just firing once.

Any guidance would be greatly appreciated. I tried delaying reattaching the listener via DispatchQueue.asyncAfter and have observed the number of times the listener fire go down, so perhaps the issue relates to a delay in the network call being reflected/executed in Firestore?

> Update: I split the batch operation into individual operations, which
> included both write and delete operations. In one of the write
> operations' completion handlers, I fulfill the promise function. This
> seems to offer a workaround for my issue...but does have me worried
> about other batch operations I have elsewhere and wonder if there is
> altogether better solution... :/

private var listener: ListenerRegistration?

func writeTo(ids: [String]) -> Promise<Void> {

toggleListener(isActive: false)

return Promise.value(ids).thenMap { id in
    Promise<String> { resolver in

        let batch = self.db.batch()
        
        let refOne = self.db.collection(collectionOne).document(id)
        let refTwo = self.db.collection(collectionOne).document(id).collection(collectionTwo).document()
                                
        batch.setData(["x": "x"], forDocument: refOne)
                    
        batch.setData([ "x": "x"], forDocument: refTwo)
            
        batch.commit { error in
            
            resolver.fulfill(id)
        }
    }
}
.done { uids in
            
    toggleListener(isActive: true)
}
}

func toggleListener(isActive: Bool) {

if isActive {
    
    listener = db.collection(collectionOne).addSnapshotListener{ snapshot, error in
        
        print("listening")
    }
    
} else {
    
    listener?.remove()
    listener = nil
}
}

The issue is that the batched writes are sent as a single request to Firestore, but Firestore processes each write in the batch independently. This means that if one write succeeds and another fails, the listener could be triggered multiple times - once for each successful write.

So a better approach would be to use a transaction that ensures that all writes are processed together, atomically, so the listener will only be triggered once. This is why using a transaction instead of a batch write can help you avoid multiple listener triggers.

Here I have use Transactions instead of batch writes:

func writeTo(ids: [String]) -> Promise<Void> {
    toggleListener(isActive: false)

    return Promise.value(ids).thenMap { id in
        self.db.runTransaction { transaction -> String in
            let refOne = self.db.collection(collectionOne).document(id)
            let refTwo = refOne.collection(collectionTwo).document()
            
            transaction.setData(["x": "x"], forDocument: refOne)
            transaction.setData(["x": "x"], forDocument: refTwo)
            
            return id
        }
    }.done { uids in
        toggleListener(isActive: true)
    }
}

func toggleListener(isActive: Bool) {
    if isActive {
        if listener == nil {
            listener = db.collection(collectionOne).addSnapshotListener { snapshot, error in
                print("listening")
            }
        }
    } else {
        listener?.remove()
        listener = nil
    }
}

Here, we're using runTransaction instead of a batch write. The transaction ensures that the writes to refOne and refTwo are applied atomically, so the listener will only be triggered once.

Reference : Batched writes and Updating data with transactions