Managing asynchronous calls to web API in iOS

Question

I am fetching data (news articles) in JSON format from a web service. The fetched data needs to be converted to an Article object and that object should be stored or updated in the database. I am using Alamofire for sending requests to the server and Core Data for database management.
My approach to this was to create a DataFetcher class for fetching JSON data and converting it to Article object:

class DataFetcher {

    var delegate:DataFetcherDelegate?

    func fetchArticlesFromUrl(url:String, andCategory category:ArticleCategory) {
        //convert json to article
        //send articles to delegate

        getJsonFromUrl(url) { (json:JSON?,error:NSError?) in
            if error != nil {
                print("An error occured while fetching json : \(error)")
            }
            if json != nil {
                let articles = self.getArticleFromJson(json!,andCategory: category)
                self.delegate?.receivedNewArticles(articles, fromCategory: category)
            }
        }
    }

After I fetch the data I send it to DataImporter class to store it in database:

func receivedNewArticles(articles: [Article], fromCategory category:ArticleCategory) {

        //update the database with new articles
        //send articles to delegate
        delegate?.receivedUpdatedArticles(articles, fromCategory:category)
    }

The DataImporter class sends the articles to its delegate that is in my case the ViewController. This pattern was good when I had only one API call to make (that is fetchArticles), but now I need to make another call to the API for fetching categories. This call needs to be executed before the fetchArticles call in the ViewController.
This is the viewDidLoad method of my viewController:

override func viewDidLoad() {
        super.viewDidLoad()

        self.dataFetcher = DataFetcher()
        let dataImporter = DataImporter()
        dataImporter.delegate = self
        self.dataFetcher?.delegate = dataImporter

        self.loadCategories()
        self.loadArticles()
    }

My questions are:

1. What is the best way to ensure that one the call to the API gets executed before the other one?
2. Is the pattern that I implemented good since I need to make different method for different API calls?

Answer 1

1. What is the best way to ensure that one the call to the API gets executed before the other one?

If you want to ensure that two or more asynchronous functions execute sequentially, you should first remember this:

• If you implement a function which calls an asynchronous function, the calling function becomes asynchronous as well.

• An asynchronous function should have a means to signal the caller that it has finished.

If you look at the network function getJsonFromUrl - which is an asynchronous function - it has a completion handler parameter which is one approach to signal the caller that the underlying task (a network request) has finished.

Now, fetchArticlesFromUrl calls the asynchronous function getJsonFromUrl and thus becomes asynchronous as well. However, in your current implementation it has no means to signal the caller that its underlying task (getJsonFromUrl) has finished. So, you first need to fix this, for example, through adding an appropriate completion handler and ensuring that the completion handler will eventually be called from within the body.

The same is true for your function loadArticles and loadCategories. I assume, these are asynchronous and require a means to signal the caller that the underlying task has finished - for example, by adding a completion handler parameter.

Once you have a number of asynchronous functions, you can chain them - that is, they will be called sequentially:

Given, two asynchronous functions:

func loadCategories(completion: (AnyObject?, ErrorType?) -> ())
func loadArticles(completion: (AnyObject?, ErrorType?) -> ())

Call them as shown below:

loadCategories { (categories, error) in
    if let categories = categories {
        // do something with categories:
        ...
        // Now, call loadArticles:
        loadArticles { (articles, error) in
            if let articles = articles {
                // do something with the articles
                ...
            } else {
                // handle error:
                ...
            }
        }
    } else {
        // handler error
        ...
    }
}

2. Is the pattern that I implemented good since I need to make different method for different API calls?

IMHO, you should not merge two functions into one where one performs the network request and the other processes the returned data. Just let them separated. The reason is, you might want to explicitly specify the "execution context" - that is, the dispatch queue, where you want the code to be executed. Usually, Core Data, CPU bound functions and network functions should not or cannot share the same dispatch queue - possibly also due to concurrency constraints. Due to this, you may want to have control over where your code executes through a parameter which specifies a dispatch queue.

If processing data may take perceivable time (e.g. > 100ms) don't hesitate and execute it asynchronously on a dedicated queue (not the main queue). Chain several asynchronous functions as shown above.

So, your code may consist of four asynchronous functions, network request 1, process data 1, network request 2, process data 2. Possibly, you need another function specifically for storing the data into Core Data.

Other hints:

Unless there's a parameter which can be set by the caller and which explicitly specifies the "execution context" (e.g. a dispatch queue) where the completion handler should be called on, it is preferred to submit the call of the completion handler on a concurrent global dispatch queue. This performs faster and avoids dead locks. This is in contrast to Alamofire that usually calls the completion handlers on the main thread per default and is prone to dead locks and also performs suboptimal. If you can configure the queue where the completion handler will be executed, please do this.

Prefere to execute functions and code on a dispatch queue which is not associated to the main thread - e.g. not the main queue. In your code, it seems, the bulk of processing the data will be executed on the main thread. Just ensure that UIKit methods will execute on the main thread.