A common challenge for mobile development is dealing with multiple API endpoints that deliver heterogeneous data that you’d rather process as one single dataset.

This may arise for many reasons including

  • you don’t want to proceed unless you have all the data
  • it will be harder to keep local database integrity if you process each response data individually

I would normally use a DispatchGroup to achieve this. Launch multiple requests and use the semaphore controls to wait until all the responses have come back.

For example…

let dispatchGroup = DispatchGroup()
var errors = [Error]()
var image1: UIImage?
var image2: UIImage?

dispatchGroup.enter()
URLSession.shared.dataTask(with: url1) { (data, response, error) in
    if let data = data, let image = UIImage(data: data) {
        image1 = image
    } else {
        errors.append(error ?? ImageFetchError.somethingWrong)
    }
    dispatchGroup.leave()
}.resume()

dispatchGroup.enter()
URLSession.shared.dataTask(with: url2) { (data, response, error) in
    if let data = data, let image = UIImage(data: data) {
        image2 = image
    } else {
        errors.append(error ?? ImageFetchError.somethingWrong)
    }
    dispatchGroup.leave()
}.resume()

dispatchGroup.wait()

if !errors.isEmpty {
    print(errors)
} else {
    imageView1.image = image1
    imageView2.image = image2
}

Not too bad if we’re just waiting for two requests, but the mess of juggling of responses and errors does not scale nicely when we inevitably end up with five or six endpoints that we need to coordinate.

One of the highlights at WWDC 2019 was the introduction of the Combine framework. The session Advanced Networking 1 session at WWDC2019 session starts with…

Networking is inherently asynchronous, that’s why it’s perfect to adopt Combine.

Can we use Combine for this problem?


Coordinating multiple requests with Combine

The Combine extension to URLSession is particularly neat as it handles the error cases nicely.

let dataTask1 = URLSession.shared
    .dataTaskPublisher(for: url1)
    .map { data, _ in UIImage(data: data) ?? UIImage() }

let dataTask2 = URLSession.shared
    .dataTaskPublisher(for: url2)
    .map { data, _ in UIImage(data: data) ?? UIImage() }

dataTask1.zip(dataTask2)
    .receive(on: RunLoop.main)
    .sink(receiveCompletion: {
        if case .failure(let error) = $0 {
            print(error)
        }
    }, receiveValue: { [weak self] (image1, image2) in
        self?.imageView1.image = image1
        self?.imageView2.image = image2
    })
    .store(in: &subscriptions)

A simple zip() does the trick!

This method scales well when you have many requests to coordinate.

Of course, you could also just sort out your backend APIs… 😀