How to call REST full API by providing headers in Swift

Question

I am quite new to Swift, we have a API server where we need to pass HEADERS like this:

Content-Type:application/json

Session:fb4e7f9b-0f31-4709-

I was looking in Google, the most basic example uses HTTP url call (i.e GET,POST) Do I need to use some third-party product to call REST API by providing headers?

I would appreciate if you provide some guideline and possibly some example articles where it's showing how do to REST API call by providing different type HEADERs.

Answer 1

import SystemConfiguration
import Foundation

public enum ReachabilityError: Error {
    case FailedToCreateWithAddress(sockaddr_in)
    case FailedToCreateWithHostname(String)
    case UnableToSetCallback
    case UnableToSetDispatchQueue
    case UnableToGetInitialFlags
}

@available(*, unavailable, renamed: "Notification.Name.reachabilityChanged")
public let ReachabilityChangedNotification = NSNotification.Name("ReachabilityChangedNotification")

public extension Notification.Name {
    static let reachabilityChanged = Notification.Name("reachabilityChanged")
}

public class Reachability {
    
    public typealias NetworkReachable = (Reachability) -> ()
    public typealias NetworkUnreachable = (Reachability) -> ()
    
    @available(*, unavailable, renamed: "Connection")
    public enum NetworkStatus: CustomStringConvertible {
        case notReachable, reachableViaWiFi, reachableViaWWAN
        public var description: String {
            switch self {
            case .reachableViaWWAN: return "Cellular"
            case .reachableViaWiFi: return "WiFi"
            case .notReachable: return "No Connection"
            }
        }
    }
    
    public enum Connection: CustomStringConvertible {
        case none, wifi, cellular
        public var description: String {
            switch self {
            case .cellular: return "Cellular"
            case .wifi: return "WiFi"
            case .none: return "No Connection"
            }
        }
    }
    
    public var whenReachable: NetworkReachable?
    public var whenUnreachable: NetworkUnreachable?
    
    @available(*, deprecated, renamed: "allowsCellularConnection")
    public let reachableOnWWAN: Bool = true
    
    /// Set to `false` to force Reachability.connection to .none when on cellular connection (default value `true`)
    public var allowsCellularConnection: Bool
    
    // The notification center on which "reachability changed" events are being posted
    public var notificationCenter: NotificationCenter = NotificationCenter.default
    
    @available(*, deprecated, renamed: "connection.description")
    public var currentReachabilityString: String {
        return "\(connection)"
    }
    
    @available(*, unavailable, renamed: "connection")
    public var currentReachabilityStatus: Connection {
        return connection
    }
    
    public var connection: Connection {
        if flags == nil {
            try? setReachabilityFlags()
        }
        
        switch flags?.connection {
        case .none?, nil: return .none
        case .cellular?: return allowsCellularConnection ? .cellular : .none
        case .wifi?: return .wifi
        }
    }
    
    fileprivate var isRunningOnDevice: Bool = {
#if targetEnvironment(simulator)
        return false
#else
        return true
#endif
    }()
    
    fileprivate var notifierRunning = false
    fileprivate let reachabilityRef: SCNetworkReachability
    fileprivate let reachabilitySerialQueue: DispatchQueue
    fileprivate(set) var flags: SCNetworkReachabilityFlags? {
        didSet {
            guard flags != oldValue else { return }
            reachabilityChanged()
        }
    }
    
    required public init(reachabilityRef: SCNetworkReachability, queueQoS: DispatchQoS = .default, targetQueue: DispatchQueue? = nil) {
        self.allowsCellularConnection = true
        self.reachabilityRef = reachabilityRef
        self.reachabilitySerialQueue = DispatchQueue(label: "uk.co.ashleymills.reachability", qos: queueQoS, target: targetQueue)
    }
    
    public convenience init?(hostname: String, queueQoS: DispatchQoS = .default, targetQueue: DispatchQueue? = nil) {
        guard let ref = SCNetworkReachabilityCreateWithName(nil, hostname) else { return nil }
        self.init(reachabilityRef: ref, queueQoS: queueQoS, targetQueue: targetQueue)
    }
    
    public convenience init?(queueQoS: DispatchQoS = .default, targetQueue: DispatchQueue? = nil) {
        var zeroAddress = sockaddr()
        zeroAddress.sa_len = UInt8(MemoryLayout<sockaddr>.size)
        zeroAddress.sa_family = sa_family_t(AF_INET)
        
        guard let ref = SCNetworkReachabilityCreateWithAddress(nil, &zeroAddress) else { return nil }
        
        self.init(reachabilityRef: ref, queueQoS: queueQoS, targetQueue: targetQueue)
    }
    
    deinit {
        stopNotifier()
    }
}

public extension Reachability {
    
    // MARK: - *** Notifier methods ***
    func startNotifier() throws {
        guard !notifierRunning else { return }
        
        let callback: SCNetworkReachabilityCallBack = { (reachability, flags, info) in
            guard let info = info else { return }
            
            let reachability = Unmanaged<Reachability>.fromOpaque(info).takeUnretainedValue()
            reachability.flags = flags
        }
        
        var context = SCNetworkReachabilityContext(version: 0, info: nil, retain: nil, release: nil, copyDescription: nil)
        context.info = UnsafeMutableRawPointer(Unmanaged<Reachability>.passUnretained(self).toOpaque())
        if !SCNetworkReachabilitySetCallback(reachabilityRef, callback, &context) {
            stopNotifier()
            throw ReachabilityError.UnableToSetCallback
        }
        
        if !SCNetworkReachabilitySetDispatchQueue(reachabilityRef, reachabilitySerialQueue) {
            stopNotifier()
            throw ReachabilityError.UnableToSetDispatchQueue
        }
        
        // Perform an initial check
        try setReachabilityFlags()
        
        notifierRunning = true
    }
    
    func stopNotifier() {
        defer { notifierRunning = false }
        
        SCNetworkReachabilitySetCallback(reachabilityRef, nil, nil)
        SCNetworkReachabilitySetDispatchQueue(reachabilityRef, nil)
    }
    
    // MARK: - *** Connection test methods ***
    @available(*, deprecated, message: "Please use `connection != .none`")
    var isReachable: Bool {
        return connection != .none
    }
    
    @available(*, deprecated, message: "Please use `connection == .cellular`")
    var isReachableViaWWAN: Bool {
        // Check we're not on the simulator, we're REACHABLE and check we're on WWAN
        return connection == .cellular
    }
    
    @available(*, deprecated, message: "Please use `connection == .wifi`")
    var isReachableViaWiFi: Bool {
        return connection == .wifi
    }
    
    var description: String {
        guard let flags = flags else { return "unavailable flags" }
        let W = isRunningOnDevice ? (flags.isOnWWANFlagSet ? "W" : "-") : "X"
        let R = flags.isReachableFlagSet ? "R" : "-"
        let c = flags.isConnectionRequiredFlagSet ? "c" : "-"
        let t = flags.isTransientConnectionFlagSet ? "t" : "-"
        let i = flags.isInterventionRequiredFlagSet ? "i" : "-"
        let C = flags.isConnectionOnTrafficFlagSet ? "C" : "-"
        let D = flags.isConnectionOnDemandFlagSet ? "D" : "-"
        let l = flags.isLocalAddressFlagSet ? "l" : "-"
        let d = flags.isDirectFlagSet ? "d" : "-"
        
        return "\(W)\(R) \(c)\(t)\(i)\(C)\(D)\(l)\(d)"
    }
}

fileprivate extension Reachability {
    
    func setReachabilityFlags() throws {
        try reachabilitySerialQueue.sync { [unowned self] in
            var flags = SCNetworkReachabilityFlags()
            if !SCNetworkReachabilityGetFlags(self.reachabilityRef, &flags) {
                self.stopNotifier()
                throw ReachabilityError.UnableToGetInitialFlags
            }
            
            self.flags = flags
        }
    }
    
    func reachabilityChanged() {
        let block = connection != .none ? whenReachable : whenUnreachable
        
        DispatchQueue.main.async { [weak self] in
            guard let self = self else { return }
            block?(self)
            self.notificationCenter.post(name: .reachabilityChanged, object: self)
        }
    }
}

extension SCNetworkReachabilityFlags {
    
    typealias Connection = Reachability.Connection
    
    var connection: Connection {
        guard isReachableFlagSet else { return .none }
        
        // If we're reachable, but not on an iOS device (i.e. simulator), we must be on WiFi
#if targetEnvironment(simulator)
        return .wifi
#else
        var connection = Connection.none
        
        if !isConnectionRequiredFlagSet {
            connection = .wifi
        }
        
        if isConnectionOnTrafficOrDemandFlagSet {
            if !isInterventionRequiredFlagSet {
                connection = .wifi
            }
        }
        
        if isOnWWANFlagSet {
            connection = .cellular
        }
        
        return connection
#endif
    }
    
    var isOnWWANFlagSet: Bool {
#if os(iOS)
        return contains(.isWWAN)
#else
        return false
#endif
    }
    var isReachableFlagSet: Bool {
        return contains(.reachable)
    }
    var isConnectionRequiredFlagSet: Bool {
        return contains(.connectionRequired)
    }
    var isInterventionRequiredFlagSet: Bool {
        return contains(.interventionRequired)
    }
    var isConnectionOnTrafficFlagSet: Bool {
        return contains(.connectionOnTraffic)
    }
    var isConnectionOnDemandFlagSet: Bool {
        return contains(.connectionOnDemand)
    }
    var isConnectionOnTrafficOrDemandFlagSet: Bool {
        return !intersection([.connectionOnTraffic, .connectionOnDemand]).isEmpty
    }
    var isTransientConnectionFlagSet: Bool {
        return contains(.transientConnection)
    }
    var isLocalAddressFlagSet: Bool {
        return contains(.isLocalAddress)
    }
    var isDirectFlagSet: Bool {
        return contains(.isDirect)
    }
    var isConnectionRequiredAndTransientFlagSet: Bool {
        return intersection([.connectionRequired, .transientConnection]) == [.connectionRequired, .transientConnection]
    }
    
}

Answer 2

// MARK : Declare base URL
enum NetworkEnvironment {
    case qa
    case production
}

class APIEndPoint {
    // MARK : Returning base URL
    static var environmentBaseURL : String {
        switch NetworkManager.environment {
        case .production: return ""
        case .qa: return "https://www.jsonkeeper.com/"
        }
    }
        
    // MARK : Finally seted base URL for the end point
    static var baseURL: String {
        return environmentBaseURL
    }
    
    // MARK : List of sub URLs
    static let homeURL = "b/12D8"
}

Answer 3

 // MARK: -  get user list
    func getUserList(param : [String:Any]) {
        
        NetworkManager.shared.load(path: APIEndPoint.homeURL, method: .get, params: param) { (data, error, response) in
            
            if response!
            {
                guard let responseData = data else {
                    return
                }
                do {
                    print(responseData)
                    let jsonData = try JSONSerialization.jsonObject(with: responseData, options: .mutableContainers)
                    print(jsonData)
                    let apiResponse = try JSONDecoder().decode(User.self, from: responseData)
                    self.userList = apiResponse
                    self.delegate?.getUserListCompleted()
                    
                }catch {
                    print(error)
                }
                
            }
            
        }
    }

Answer 4

extension URL
{
    init(baseUrl: String, path: String, method: RequestMethod, params: [String:Any])
    {
        var components = URLComponents(string: baseUrl)!
        components.path += path
        
        switch method {
        case .get,.delete:
            var queryItems = components.queryItems ?? []
            queryItems.append(contentsOf: params.map {
                URLQueryItem(name: $0.key, value: String(describing: $0.value))
            })
            //print(queryItems)
            components.queryItems = queryItems
        default:
            break
        }
        //print(components.url!)
        self = components.url!
        
    }
}

extension URLRequest
{
    init(baseUrl: String, path: String, method: RequestMethod, params: [String:Any]) {
        let url = URL(baseUrl: baseUrl, path: path, method: method, params: params)
        
        //////////////My Code For Remove Percentages In URL//////////////////////////
        let urlWithPath = url.absoluteString.removingPercentEncoding
        let absoluteUrl = URL(string: urlWithPath!)!
        self.init(url: absoluteUrl)
        
        //self.init(url: url)
        let util = AuthToken.shared()
        httpMethod = method.rawValue
        setValue("application/json", forHTTPHeaderField: "Content-Type")
        if util.getToken() != "" {
            setValue(util.getToken(), forHTTPHeaderField: "Token")
        }
        
        switch method {
        case .post, .put:
            httpBody = try! JSONSerialization.data(withJSONObject: params, options: [])
        default:
            break
        }
    }
}

struct NetworkManager {
    static let environment : NetworkEnvironment = .qa
    private init(){}
    static let shared = NetworkManager();
    private var baseURL = APIEndPoint.baseURL
    
    func load(path:String, method:RequestMethod, params:[String:Any], completion:@escaping(_ responseObject:Data?, _ error:Error?, _ isSuccess: Bool?) -> Void) -> Void{
        
        let reachability = Reachability()
        if(reachability?.connection == .wifi || reachability?.connection == .cellular)
        {
            // Creating the URLRequest object
            let request = URLRequest(baseUrl: baseURL, path: path, method: method, params: params)
            
            let task = URLSession.shared.dataTask(with: request) {
                (data, response, error) in
                if error != nil
                {
                    completion(nil, nil, false)
                }
                else
                {
                    completion(data, nil, true)
                }
            }
            task.resume()
        }
        else
        {
            completion(nil, nil, false)
        }
    }
}

Answer 5

import Foundation

// MARK : Declare API request type
enum RequestMethod: String {
    case get = "GET"
    case post = "POST"
    case put = "PUT"
    case delete = "DELETE"
}

Answer 6

with header fields

static func getFeed(Completion:@escaping(FeedElement)->Void)
    {
        let urlString = NSString(format: "https://api-nhdev.india.com/api/v1/feeds/1/10/Kondapur") as String
        
        guard let url = URL(string:urlString)
         else {
             return
        }
        
        let header: HTTPHeaders = [
            "Authorization": YOUR_AUTH_ID
        ]
        
        let request = NSMutableURLRequest(url: url as URL)
            request.allHTTPHeaderFields = header
            request.httpMethod = "GET"
            let session = URLSession.shared

            let mData = session.dataTask(with: request as URLRequest) { (data, response, error) -> Void in
                guard let dataResponse = data,
                    error == nil else {
                        print(error?.localizedDescription ?? "Response Error")
                        return }
                do{
                    //here dataResponse received from a network request
                 let decoder = JSONDecoder()
                 let codabledata = try decoder.decode(FeedElement.self, from: dataResponse)
                    print(codabledata)
                 //Response result
                 Completion(codabledata)
                    
                } catch let parsingError {
                    print("Error", parsingError)
                }
            }
            mData.resume()
    }
}

Answer 7

By using Alamofire it's pretty simple.

let headers: HTTPHeaders = [
    "Content-Type": "application/json",
    "Session": "fb4e7f9b-0f31-4709-"
]

Alamofire.request("https://httpbin.org/headers", headers: headers).responseJSON { response in
   //Parse or print your response.
}

By using urlRequest

let header: HTTPHeaders = [
    "Content-Type": "application/json",
    "Session": "fb4e7f9b-0f31-4709-"
]
var urlRequest = URLRequest(url: URL(string: "your request url goes here."), cachePolicy: .useProtocolCachePolicy, timeoutInterval: 10)
urlRequest.allHTTPHeaderFields = header
urlRequest.httpMethod = //.get, .post, .put
URLSession.shared.dataTask(with: urlRequest) { (data, response, error) in
            if let error = error {
                print(error)
            } else if let data = data ,let responseCode = response as? HTTPURLResponse {
                do {
                  // Parse your response here.
                   }
                }
                catch let parseJSONError {
                    print("error on parsing request to JSON : \(parseJSONError)")
                }
            }
        }.resume()

Answer 8

import Foundation

let url = URL(string: "")!
var request = URLRequest(url: url)
request.allHTTPHeaderFields = [
  "Content-Type": "application/json",
  "Session": "fb4e7f9b-0f31-4709-"
]

URLSession.shared.dataTask(with: request) { (data, response, error) in
  guard error == nil else { return }
  guard let data = data, let response = response else { return }
  // handle data
}.resume()

Answer 9

The URLRequest type documentation outlines all of the different properties you can set. You need to create a URLRequest instance and then use URLSession to perform the request.