Swift-如何在Firebase中添加已删除的观察者

Question

I have a firebase observer like this

    let refHandle = firebaseRef.observe(of: DataEventType.value) { (snapshot) in
            ...
        }

It's working perfectly and at one certain point I am removing this observer because I want it to stop observation until I update the values. I am doing it by using the refHandle

firebaseRef?.removeObserver(withHandle: refHandle)

Now after updating the values how can I add the same observer again ? Firebase doesn't give any function to add the observer using the refHandle. The only function I have is this

firebaseRef?.addObserver(NSObject, forKeyPath: String, options: NSKeyValueObservingOptions, context: UnsafeMutableRawPointer?)

Now how can I get all these values from my previous observer so that I can pass them to this function.

Answer 1

For add an observer in fire base first make database reference of FIR child.

eg. let dbRef: FIRDatabaseReference = FIRDatabase.database().reference().child("child_name")

add observer like,

dbRef.observe(.value, with: { (snapshot) in
       let child = snapshot.children // return number of child 
  })

For remove observer,

create the handler for that reference,

var handle: UInt = 0
handler = dbRef.observe(.value, with: {(snapshot) in

  snapshot.ref.removeValue(completionBlock: {(error, ref) in

         if (error != nil)
                {
                    print("error is \(error)")
                    return
                }
                else
                {
                    dbRef.removeObserver(withHandle: handle) // remove specific observer
                    dbRef.removeAllObservers()// remove all observer
                    print("child removed successfully")
               }
       })
 })

Answer 2

First I think it's important to say that you don't need, and should not, remove this observer , the reason is that this observer observeSingleEventOf(.value) , as the name would suggest, reads the data only once, and then gets immediately removed. This might be ideal if you only need the data to be downloaded once and don't expect it to change so much (or at all) for example.

Also, I would recommend you to add a property at the top, within the class scope, to hold a reference to the Database Reference you would like to read from :

private let databaseRef: FIRDatabaseReference = FIRDatabase.database().reference().child("childNameGoesHere")

It's definitely useful whenever you need to remove an observer ( observe(.value) , observe(.childAdded) , and so on) at some point.

Now, in your case, holding a reference to it would also be the solution, since it seems like you need to add this observer again at some point later. And again, as I said, you don't need to remove your observe because it will get triggered only once. So you can just call again wherever you want by using your databaseRef:

databaseRef.observeSingleEvent(of: .value) { (snapshot) in
      // ...your code goes here
}

just like you did in the first place and it would work just fine :).

UPDATE:

This is how you would remove an observer, and re-add it later at some point :

import Firebase
import UIKit

class YourViewController: UIViewController {

// MARK: Private Properties

// You don't need to write the type of rootRef because it's inferred
private let rootRef = Database.database().reference() 

// MARK: LifeCycle

override func viewWillAppear(_ animated: Bool) {
       super.viewWillAppear(animated)

       // Add your observer
       rootRef.observe(of: .value, with: { (snapshot) in
              // Do your stuff here and store your data somewhere so you can use it later
       })
}

// MARK: User Interaction

func addRootObserver() {

     // here you need to make sure that you don't already have an observer at the same reference, otherwise it would duplicate your data.
      rootRef.removeAllObservers()

      // Add your observer
      rootRef.observe(of: .value, with: { (snapshot) in
              // Do some more stuff here
      })

}

func removeRootObserver() {

      // Remove your observer
      rootRef.removeAllObservers()

}

}

Now you can call your addRootObserver() and removeRootObserver() methods safely whenever you need.

For the handles, well you could do it using handles too (you would need to hold a reference to it too), but I would say it's more a question of personal preferences but of course it would work too :)

Answer 3

Issue is resolved not by using addObserver method but by doing this.

• Created a snapshot class level of var for snapshot

var dataSnapshot: ((DataSnapshot)->Void)?

• Saved the snapshot

dataSnapshot = { (snapshot: DataSnapshot) in .... }

• Set observer using data snapshot

firebaseRef.observe(DataEventType.value, with: dataSnapshot)

• Removed the observer

firebaseRef?.removeObserver(withHandle: refHandle)

• When I needed to add the observer again I just started another observer with the same snapshot

• Set observer using data snapshot

firebaseRef.observe(DataEventType.value, with: dataSnapshot)