Concurrency Demystified

Transcript

00:02Now, you’ll refactor NewsService to replace concurrency based on the completion handler with async/await.

00:09In NewsService.swift, start by defining a new protocol function to load the news with async/await.

protocol NewsService {
  ...
  func latestNews() async throws -> [Article]
}

00:20The first difference to the previous definition is already in the function signature:

func latestNews() async throws -> [Article]

00:25Instead of taking a completion handler that will receive a Result that needs to be resolved, the function simply returns an array of Article objects.

00:35If there’s an error during the processing, the function throws an error.

00:39Last but not least, the keyword async indicates that the function can be suspended during its execution, unblocking the CPU cores to run other code.

00:51You should now see an error indicating that the NewsAPIService does not conform to the NewsService protocol. Lets fix this by implementing the new function:

func latestNews() async throws -> [Article] {
  // 1. Async network request
  let (data, response) = try await URLSession.shared.data(from: Self.newsURL)

  // 2. Response parsing
  guard let httpResponse = response as? HTTPURLResponse, httpResponse.isOK else {
    Logger.main.error("Network response error")
    throw NewsServiceError.serverResponseError
  }

  // 3. Response decoding
  let apiResponse = try JSONDecoder().decode(Response.self, from: data)
  Logger.main.info("Response status: \(apiResponse.status)")
  Logger.main.info("Total results: \(apiResponse.totalResults)")

  // 4. Filtering
  return apiResponse.articles.filter { $0.author != nil && $0.urlToImage != nil }
}

01:05The first line uses URLSession.shared.data(from:) to perform an asynchronous network request:

let (data, response) = try await URLSession.shared.data(from: Self.newsURL)

01:11This method fetches the contents of the specified URL as a tuple containing the retrieved data and the URL response.

01:20The await keyword is used to suspend the function’s execution until the asynchronous operation completes. This allows the function to wait for the network request to finish without blocking the calling (main) thread.

01:32If there’s any error in network operation, URLSession throws an error that will be propagated in the error response chain.

01:40After the network request is completed, the function checks if the response is an HTTPURLResponse and its status code indicates success (200). If not, the function throws a NewsServiceError.serverResponseError:

guard let httpResponse = response as? HTTPURLResponse, httpResponse.isOK else {
  Logger.main.error("Network response error")
  throw NewsServiceError.serverResponseError
}

01:55If the response is valid, the function attempts to decode the received data into an array of Article using JSONDecoder(). If decoding fails, it throws an error:

let apiResponse = try JSONDecoder().decode(Response.self, from: data)
Logger.main.info("Response status: \(apiResponse.status)")
Logger.main.info("Total results: \(apiResponse.totalResults)")

02:05Finally, the results are filtered and returned:

return apiResponse.articles.filter { $0.author != nil && $0.urlToImage != nil }

02:08Before we continue, there is one more error we need to take care of. Notice, that the MockNewsService does not conform to the NewsService protocol. Lets fix this by adding the following function to the MockNewsService class:

func latestNews() async throws -> [Article] {
  return [
    Article(
      title: "Lorem Ipsum",
      url: URL(string: "https://apple.com"),
      author: "Author",
      description:
      """
      Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
      incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam...
      """,
      urlToImage: "https://picsum.photos/300"
    )
  ]
}

02:23Lets go back to the latestNews implementation of NewsAPIService. Notice that the execution flow is now linear, from the top to the bottom of the function. No more going back and forth, as in the previous case.

02:40Furthermore, the compiler now enforces that the function will either return a value or throw an error.

02:47Try to comment out the line where the function throws the error:

//throw NewsServiceError.serverResponseError

02:51You’ll see that the compiler complains about the error:

'guard' body must not fall through, consider using a 'return' or 'throw'
to exit the scope

02:54Open NewsViewModel.swift.

02:55Adapt the function fetchLatestNews with the following code:

func fetchLatestNews() {
  news.removeAll()

  // 1. Use `Task` to run asynchronous code in a synchronous context
  Task {
    // 2. Need `try await` because the function is `async throws`
    let news = try await newsService.latestNews()
    // 3
    self.news = news
  }
}

03:06Here’s what’s happening in the code:

1. 03:09The Task instruction allows asynchronous code to run within a synchronous context, as the function fetchLatestNews().

2. 03:16Since latestNews is now an asynchronous function, you need to use the keyword await (and try) when calling it.

3. 03:23The news variable triggers UI updates, so it needs to be updated on the main thread.

03:28In this case, the code inside the Task closure is executed asynchronously, but by default, it inherits the execution context of the caller.

03:38Since it’s called from the main thread, any updates to self.news inside the Task closure will also happen on the main thread.

03:47Now go ahead and run the app on the simulator. You should see that the news app should work just fine with our refactoring.