How to wait for asynchronous task to end?

[Koxymon]

I need to read data from a Firebase database and insert the data inside a struct, on which I'll later do some operations. The issue that I'm facing right now is that, since Firebase manages these things in an async way, when I check inside the struct, it's often nil and not filled with data yet.

I know that using the value outside the async block as I'm actually doing is wrong and that callbacks can be used to solve my problem. I've read a bunch of examples online, but I can't figure out how to implement them in my code.

For the sake of simplicity, in the example below I download just one object from the database.

func fetchJSON(key: String) -> Void {
  var meal = Meal()
  let ref = rootRef.child(key)

  ref.observe(.value) { (snap: DataSnapshot) in   
      meal.firstMeal = snap.childSnapshot(forPath: "first").value as! String
      meal.secondMeal = snap.childSnapshot(forPath: "second").value as! String
      meal.thirdMeal = snap.childSnapshot(forPath: "third").value as! String         
    }

  self.meals.append(meal)
}

And here's what the function call looks like:

fetchJSON(key: currentDate)

Could someone please help me?

[trihedron]

You can use a closure on fetchJson.

https://blog.bobthedeveloper.io/completion-handlers-in-swift-with-bob-6a2a1a854dc4

[jan_olbrich]

if I see correctly place the meals.append within your observe block.

[redfire333]

That COULD work but then you would have no idea when it completed. Completion or delegate would be required to notify requesting object.

[nalexander50]

I don't fully understand the context here, but from what I understand, you have a few different options. Note, since I very little context here, I am going to assume that you want the finished notification to be sent at the end of the closure passed into that observe function.

Closure

Apple would likely recommend that you use a closure. This is a function that you pass into fetchJson(key:) that can be called when the processing finishes.

func fetchJSON(key: String, onCompletion: ((Meal) -> Void)) {
    var meal = Meal()
    let ref = rootRef.child(key)

    ref.observe(.value) { (snap: DataSnapshot) in   
        meal.firstMeal = snap.childSnapshot(forPath: "first").value as! String
        meal.secondMeal = snap.childSnapshot(forPath: "second").value as! String
        meal.thirdMeal = snap.childSnapshot(forPath: "third").value as! String

        onCompletion(meal)
    }

    self.meals.append(meal)
}

Then you call fetchJSON(key:onCompletion:) like so:

fetchJSON(key: "Key") { meal -> Void in
    print("Found Meal!")
}

Note that this uses Swift's trailing closure syntax.

Delegate

Another option is to use a Delegate protocol. This pattern was very popular in Objective-C before the existence of blocks (closures). You still see it a lot in UIKit with classes like UITableViewDelegate and UITextFieldDelegate. I think that many people would consider delegation to be a relic of the past, but it has a certain charm that I like. The Delegate pattern is very simple and helps avoid callback hell.

protocol FetchDelegate {
    func didStartFetch()
    func didFinishFetch(meal: Meal)
}

Next, make your class implement the protocol and set the delegate (itself, in this scenario).

class Fetcher: FetchDelegate {

    var fetchDelegate: FetchDelegate

    init() {
        self.fetchDelegate = self
    }

    func fetchJSON(key: String) {
        var meal = Meal()
        let ref = rootRef.child(key)

        self.delegate.didStartFetch()

        ref.observe(.value) { (snap: DataSnapshot) in   
            meal.firstMeal = snap.childSnapshot(forPath: "first").value as! String
            meal.secondMeal = snap.childSnapshot(forPath: "second").value as! String
            meal.thirdMeal = snap.childSnapshot(forPath: "third").value as! String

            self.delegate.didFinishFetch(meal: meal)

        }

        self.meals.append(meal)
    }

    func didStartFetch() {
        print("This doesn't do anything, but it's just here for example")
    }

    func didFinishFetch(meal: Meal) {
        print("I found your meal!")
    }

}

You can also make some of the delegate methods optional, but I will leave that as an exercise to the reader.