HTTP Request with Async Await

The API

For this tutorial, we'll make an HTTP get request to the Random Data API. We'll call the food endpoint, to get a random food item for every HTTP request. The link to the API is https://random-data-api.com/api/food/random_food.

Food model

We'll create a food model that follows the JSON object we find on the random food endpoint from Random Data API website.

// Food.swift

struct Food: Identifiable, Decodable {
    var id: Int
    var uid: String
    var dish: String
    var description: String
    var ingredient: String
    var measurement: String
}

With completion handlers

In the function below, we create an HTTP request using the old method - that is, with completion handler. You can see that the function spans many lines of code, and it can be hard to read. You can learn more about how to create an HTTP request with completion handlers in the HTTP request tutorial.

// Network.swift

func getRandomFoodWithCompletionHandler() {
    guard let url = URL(string: "https://random-data-api.com/api/food/random_food") else { fatalError("Missing URL") }

    let urlRequest = URLRequest(url: url)

    let dataTask = URLSession.shared.dataTask(with: urlRequest) { (data, response, error) in
        if let error = error {
            print("Request error: ", error)
            return
        }

        guard (response as? HTTPURLResponse)?.statusCode == 200 else { return }
        guard let data = data else { return }
				do {
             let decodedFood = try JSONDecoder().decode(Food.self, from: data)
             print("Completion handler decodedFood", decodedFood)
         } catch {
		         print("Error decoding", error)
         }
    }

    dataTask.resume()
}

In our view, let's initialize the network class at the top of the file.

// ContentView.swift

let network = Network()

Then, we can call the above function in the onAppear modifier to get our data printed on the console.

// ContentView.swift

.onAppear {
		network.getRandomFoodWithCompletionHandler()
}

Now when you build your application, you should see data printed on the console from the completion handler function!

Target iOS 15

For the purposes of this tutorial, make sure that your project targets iOS 15, because async await is only available for iOS 15 and later. To do so, go into your project settings > targets > General > Deployment Info and select iOS 15.0 in the dropdown menu. This will allow us to write concurrent code, without having to always wrap the code in an if available statement.

With async await

With async await, the same function is so much cleaner. First, let's define our function as asynchronous.

// Network.swift

func getRandomFood() async {

}

Note: async await functions are still in beta as of July 2021. For now, it's only available if you're under the Apple Developer Program. It should be available to all when Xcode 13 will be released, in Fall 2021.

Next, we'll keep the guard statement that makes sure we do have a url before continuing. We'll also keep the urlRequest variable.

// Network.swift

func getRandomFood() async {
    guard let url = URL(string: "https://random-data-api.com/api/food/random_food") else { fatalError("Missing URL") }
		let urlRequest = URLRequest(url: url)
}

Then, we'll call URLSession.shared.data to get the data from the URL we created. Since this is a network call, it can take some time to fetch the data. So we'll need to add the await keyword in front of the URLSession. Moreover, the URLSession call might throw an error, so we'll need to add the try keyword before the await. It might return us two things: some data, and a response, so we'll save them in their corresponding variable.

// Network.swift

func getRandomFood() async {
    guard let url = URL(string: "https://random-data-api.com/api/food/random_food") else { fatalError("Missing URL") }
		let urlRequest = URLRequest(url: url)
		let (data, response) = try await URLSession.shared.data(for: urlRequest)
}

Xcode will complain that the errors thrown within the function aren't handled, so we need to mark the getRandomFood function as throws, to let the program know that this function might throw an error.

// Network.swift

func getRandomFood() async throws {
    guard let url = URL(string: "https://random-data-api.com/api/food/random_food") else { fatalError("Missing URL") }
		let urlRequest = URLRequest(url: url)
		let (data, response) = try await URLSession.shared.data(for: urlRequest)
}

After getting the data and/or the response, we need to make sure that the status code of the response is 200 OK before continuing, so let's add a guard statement.

// Network.swift

func getRandomFood() async throws {
    guard let url = URL(string: "https://random-data-api.com/api/food/random_food") else { fatalError("Missing URL") }
		let urlRequest = URLRequest(url: url)
		let (data, response) = try await URLSession.shared.data(for: urlRequest)

		guard (response as? HTTPURLResponse)?.statusCode == 200 else { fatalError("Error while fetching data") }
}

Finally, we'll decode the data that we get into the Food model and print the decoded food.

// Network.swift

func getRandomFood() async throws {
    guard let url = URL(string: "https://random-data-api.com/api/food/random_food") else { fatalError("Missing URL") }
		let urlRequest = URLRequest(url: url)
		let (data, response) = try await URLSession.shared.data(for: urlRequest)

		guard (response as? HTTPURLResponse)?.statusCode == 200 else { fatalError("Error while fetching data") }
		let decodedFood = try JSONDecoder().decode(Food.self, from: data)
    print("Async decodedFood", decodedFood)
}

Call the function

In our view, we'll need to call the getRandomFood function in a task modifier, since onAppear doesn't support asynchronous code.

// ContentView.swift

.task {
		network.getRandomFood()
}

However, since this function is asynchronous and can throw an error, we'll need to add try await in front:

// ContentView.swift

.task {
		try await network.getRandomFood()
}

Now, Xcode will complain that errors thrown from the function aren't handled. So let's wrap our code in a do catch statement, and print the error if we ever run into one.

// ContentView.swift

.task {
		do {
				try await network.getRandomFood()
		} catch {
				print("Error", error)
		}
}

Build your application

Great, now the last step is simply to make sure we get data from the asynchronous function. Build your application, and you should see two decodedFood printed on the console: one from the completion handler function, and the other one from the asynchronous function!

Asynchronous functions make our code cleaner and easier to read, as they require less lines of code. Moreover, we can simultaneously run other code while we wait for the data to be fetched, freeing CPU usage and making our application more performant. You can learn more about concurrency in my course SwiftUI Concurrency.