Network

Foundation framework provides a URLSession API to work with network.

URLSession coordinates a group of related, network data transfer tasks. It has a singleton shared session (which doesn’t have a configuration object) for basic requests. Or you can create a URLSession with one of three kinds of configurations:

• default session behaves much like the shared session, but lets you configure it. You can also assign a delegate to the default session to obtain data incrementally.
• ephemeral sessions - are similar to shared sessions, but don’t write caches, cookies, or credentials to disk.
• background sessions - let you perform uploads and downloads of content in the background while your app isn’t running.

There are three main types of session tasks:

• URLSessionDataTask returns downloaded data directly to the app in memory
• URLSessionUploadTask uploads data to the network in a request body
• URLSessionDownloadTask stores downloaded data to a file

URL class represents a URL.

URLComponents class allows to build url from its parts.

URLRequest represents a URL load request that is independent of protocol.

import Network
// ...
let session = URLSession.shared
let url = URL(string: "http://example.com")!

let task = session.dataTask(with: url, completionHandler: { data, response, error in

    // parse json, save to db and etc
    
    DispatchQueue.main.async {
      // update ui if necessary    
    }
})

task.resume() // execute task

You can also use other frameworks like Alamofire and its components (AlamofireImage)

There is also built-in Network framework (IOS12+) to work with network on low-level. It is replacement of Socket API.

build url

var components = URLComponents()
components.scheme = "https"
components.host = "example.com"
components.path = "/some/path"

// create url
let url = components.url

download files

To download files, you create a URLSessionDownloadTask from a URLSession. If you don’t care about receiving progress updates or other delegate callbacks during the download, you can use a completion handler.

let downloadTask = URLSession.shared.downloadTask(with: url) {
    urlOrNil, responseOrNil, errorOrNil in
    // check for and handle errors:
    // * errorOrNil should be nil
    // * responseOrNil should be an HTTPURLResponse with statusCode in 200..<299
    
    guard let fileURL = urlOrNil else { return }
    do {
        let documentsURL = try
            FileManager.default.url(for: .documentDirectory,
                                    in: .userDomainMask,
                                    appropriateFor: nil,
                                    create: false)
        let savedURL = documentsURL.appendingPathComponent(fileURL.lastPathComponent)
        try FileManager.default.moveItem(at: fileURL, to: savedURL)
    } catch {
        print ("file error: \(error)")
    }
}
downloadTask.resume()

If you want to receive progress updates you must use a delegate. You receive callbacks to your implementations of methods from the URLSessionTaskDelegate and URLSessionDownloadDelegate protocols.

//creating a URL session with a delegate

private lazy var urlSession = URLSession(configuration: .default,
                                         delegate: self,
                                         delegateQueue: nil)

// creating and starting a download task that uses a delegate
private func startDownload(url: URL) {
    let downloadTask = urlSession.downloadTask(with: url)
    downloadTask.resume()
    self.downloadTask = downloadTask
}

// handle progress in delegate method
func urlSession(_ session: URLSession,
                downloadTask: URLSessionDownloadTask,
                didWriteData bytesWritten: Int64,
                totalBytesWritten: Int64,
                totalBytesExpectedToWrite: Int64) {
     
     if downloadTask == self.downloadTask {
        let calculatedProgress = Float(totalBytesWritten) / Float(totalBytesExpectedToWrite)
        
        // update ui in main thread
        DispatchQueue.main.async {
            self.progressLabel.text = self.percentFormatter.string(from:
                NSNumber(value: calculatedProgress))
    }
}

// handle saving file in delegate method
func urlSession(_ session: URLSession,
                downloadTask: URLSessionDownloadTask,
                didFinishDownloadingTo location: URL) {
    // check for and handle errors:
    // * downloadTask.response should be an HTTPURLResponse with statusCode in 200..<299

    do {
        let documentsURL = try
            FileManager.default.url(for: .documentDirectory,
                                    in: .userDomainMask,
                                    appropriateFor: nil,
                                    create: false)
        let savedURL = documentsURL.appendingPathComponent(
            location.lastPathComponent)
        try FileManager.default.moveItem(at: location, to: savedURL)
    } catch {
        // handle filesystem error
    }
}

working with JSON

// prepare json data
let order = Order(customerId: "12345",
                  items: ["Cheese pizza", "Diet soda"])
guard let uploadData = try? JSONEncoder().encode(order) else {
    return
}

// prepare request
let url = URL(string: "https://example.com/post")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

// post json
let task = URLSession.shared.uploadTask(with: request, from: uploadData) 
        { data, response, error in
    if let error = error {
        print ("error: \(error)")
        return
    }
    
    guard let response = response as? HTTPURLResponse,
        (200...299).contains(response.statusCode) else {
        print ("server error")
        return
    }
    
    if let mimeType = response.mimeType,
        mimeType == "application/json",
        let data = data,
        let dataString = String(data: data, encoding: .utf8) {
            print ("got data: \(dataString)")
            // .. parse response json if necessary
    }
}
task.resume() // execute task

download in background

// creating a background URL session
private lazy var urlSession: URLSession = {
    let config = URLSessionConfiguration.background(withIdentifier: "MySession")
    config.isDiscretionary = true // wake up app when a task is completed
    config.sessionSendsLaunchEvents = true // wait for optimal conditions (WI-FI, ...)
    return URLSession(configuration: config, delegate: self, delegateQueue: nil)
}()

// creating a download task from a URL session
let backgroundTask = urlSession.downloadTask(with: url)
backgroundTask.earliestBeginDate = Date().addingTimeInterval(60 * 60)
backgroundTask.countOfBytesClientExpectsToSend = 200
backgroundTask.countOfBytesClientExpectsToReceive = 500 * 1024
backgroundTask.resume()

When app is in the background, the system may suspend your app while the download is performed in another process. To handle this case override application(_:handleEventsForBackgroundURLSession:completionHandler:) method of UIApplicationDelegate. This method receives the session identifier you created ("MySession" in our case) and a completion handler as its final parameter.

Store completion handler wherever it makes sense for your app, perhaps as a property of your app delegate, or of your class that implements URLSessionDownloadDelegate.

// storing the background download completion handler sent to the application delegate
func application(_ application: UIApplication,
                 handleEventsForBackgroundURLSession identifier: String,
                 completionHandler: @escaping () -> Void) {
        backgroundCompletionHandler = completionHandler
}

When all events have been delivered, the system calls the urlSessionDidFinishEvents(forBackgroundURLSession:) method of URLSessionDelegate. At this point, fetch the backgroundCompletionHandler stored by the app delegate and execute it.

// executing the background URL session completion handler on the main queue
func urlSessionDidFinishEvents(forBackgroundURLSession session: URLSession) {
    DispatchQueue.main.async {
        guard let appDelegate = UIApplication.shared.delegate as? AppDelegate,
            let backgroundCompletionHandler =
            appDelegate.backgroundCompletionHandler else {
                return
        }
        backgroundCompletionHandler()
    }
}

For more visibility into how the system is scheduling and performing your background tasks, download and install the Background Networking Profile onto your iOS device from the Bug Reporting Profiles and Logs page.