Add no-internet connection monitoring

Package.swift

@@ -19,7 +19,10 @@ let package = Package(
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
         // Targets can depend on other targets in this package, and on products in packages which this package depends on.
         .target(
-            name: "Jetworking"
+            name: "Jetworking",
+            linkerSettings: [
+                .linkedFramework("SystemConfiguration")
+            ]
         ),
         .testTarget(
             name: "JetworkingTests",

Sources/Jetworking/Client/Client.swift

@@ -9,11 +9,21 @@ enum APIError: Error {
 
 public final class Client {
     public typealias RequestCompletion<ResponseType> = (HTTPURLResponse?, Result<ResponseType, Error>) -> Void
+
+    internal enum Task {
+        case dataTask(request: URLRequest, completion: ((Data?, URLResponse?, Error?) -> Void))
+        case downloadTask(request: URLRequest)
+        case uploadDataTask(request: URLRequest, data: Data)
+        case uploadFileTask(request: URLRequest, fileURL: URL)
+    }
+
     // MARK: - Properties
     private let configuration: Configuration
 
     private lazy var session: URLSession = .init(configuration: .default)
 
+    private let taskExecutor: ClientTaskExecutor = .default
+
     private lazy var requestExecutor: RequestExecutor = {
         switch configuration.requestExecutorType {
         case .sync:
@@ -93,7 +103,7 @@ public final class Client {
     public func get<ResponseType>(endpoint: Endpoint<ResponseType>, _ completion: @escaping RequestCompletion<ResponseType>) -> CancellableRequest? {
         do {
             let request: URLRequest = try createRequest(forHttpMethod: .GET, and: endpoint)
-            return requestExecutor.send(request: request) { [weak self] data, urlResponse, error in
+            let task: Task = .dataTask(request: request) { [weak self] data, urlResponse, error in
                 self?.handleResponse(
                     data: data,
                     urlResponse: urlResponse,
@@ -102,6 +112,7 @@ public final class Client {
                     completion: completion
                 )
             }
+            return try taskExecutor.perform(task, on: requestExecutor)
         } catch {
             enqueue(completion(nil, .failure(error)))
         }
@@ -114,7 +125,7 @@ public final class Client {
         do {
             let bodyData: Data = try configuration.encoder.encode(body)
             let request: URLRequest = try createRequest(forHttpMethod: .POST, and: endpoint, and: bodyData)
-            return requestExecutor.send(request: request) { [weak self] data, urlResponse, error in
+            let task: Task = .dataTask(request: request) { [weak self] data, urlResponse, error in
                 self?.handleResponse(
                     data: data,
                     urlResponse: urlResponse,
@@ -123,6 +134,7 @@ public final class Client {
                     completion: completion
                 )
             }
+            return try taskExecutor.perform(task, on: requestExecutor)
         } catch {
             enqueue(completion(nil, .failure(error)))
         }
@@ -135,7 +147,7 @@ public final class Client {
         do {
             let bodyData: Data = try configuration.encoder.encode(body)
             let request: URLRequest = try createRequest(forHttpMethod: .PUT, and: endpoint, and: bodyData)
-            return requestExecutor.send(request: request) { [weak self] data, urlResponse, error in
+            let task: Task = .dataTask(request: request) { [weak self] data, urlResponse, error in
                 self?.handleResponse(
                     data: data,
                     urlResponse: urlResponse,
@@ -144,6 +156,7 @@ public final class Client {
                     completion: completion
                 )
             }
+            return try taskExecutor.perform(task, on: requestExecutor)
         } catch {
             enqueue(completion(nil, .failure(error)))
         }
@@ -160,7 +173,7 @@ public final class Client {
         do {
             let bodyData: Data = try configuration.encoder.encode(body)
             let request: URLRequest = try createRequest(forHttpMethod: .PATCH, and: endpoint, and: bodyData)
-            return requestExecutor.send(request: request) { [weak self] data, urlResponse, error in
+            let task: Task = .dataTask(request: request) { [weak self] data, urlResponse, error in
                 self?.handleResponse(
                     data: data,
                     urlResponse: urlResponse,
@@ -169,6 +182,7 @@ public final class Client {
                     completion: completion
                 )
             }
+            return try taskExecutor.perform(task, on: requestExecutor)
         } catch {
             enqueue(completion(nil, .failure(error)))
         }
@@ -180,7 +194,7 @@ public final class Client {
     public func delete<ResponseType>(endpoint: Endpoint<ResponseType>, parameter: [String: Any] = [:], _ completion: @escaping RequestCompletion<ResponseType>) -> CancellableRequest? {
         do {
             let request: URLRequest = try createRequest(forHttpMethod: .DELETE, and: endpoint)
-            return requestExecutor.send(request: request) { [weak self] data, urlResponse, error in
+            let task: Task = .dataTask(request: request) { [weak self] data, urlResponse, error in
                 self?.handleResponse(
                     data: data,
                     urlResponse: urlResponse,
@@ -189,6 +203,7 @@ public final class Client {
                     completion: completion
                 )
             }
+            return try taskExecutor.perform(task, on: requestExecutor)
         } catch {
             enqueue(completion(nil, .failure(error)))
         }
@@ -206,7 +221,7 @@ public final class Client {
         guard checkForValidDownloadURL(url) else { return nil }
 
         let request: URLRequest = .init(url: url)
-        let task = downloadExecutor.download(request: request)
+        let task = try? taskExecutor.perform(.downloadTask(request: request), on: downloadExecutor)
         task.flatMap {
             executingDownloads[$0.identifier] = DownloadHandler(
                 progressHandler: progressHandler,
@@ -224,7 +239,10 @@ public final class Client {
         _ completion: @escaping UploadHandler.CompletionHandler
     ) -> CancellableRequest? {
         let request: URLRequest = .init(url: url, httpMethod: .POST)
-        let task = uploadExecutor.upload(request: request, fromFile: fileURL)
+        let task = try? taskExecutor.perform(
+            .uploadFileTask(request: request, fileURL: fileURL),
+            on: uploadExecutor
+        )
         task.flatMap {
             executingUploads[$0.identifier] = UploadHandler(
                 progressHandler: progressHandler,
@@ -259,7 +277,10 @@ public final class Client {
         // TODO: Extract into constants
         request.setValue("\(multipartType.rawValue); boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
 
-        let task = uploadExecutor.upload(request: request, from: multipartData)
+        let task = try? taskExecutor.perform(
+            .uploadDataTask(request: request, data: multipartData),
+            on: uploadExecutor
+        )
         task.flatMap {
             executingUploads[$0.identifier] = UploadHandler(
                 progressHandler: progressHandler,

Sources/Jetworking/Client/Executor/ClientTaskExecutor.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+enum ClientTaskError: Error {
+    case unexpectedTaskExecution
+
+    static let connectionUnavailable = NSError(
+        domain: URLError.errorDomain,
+        code: URLError.Code.notConnectedToInternet.rawValue,
+        userInfo: nil
+    )
+}
+
+final class ClientTaskExecutor: NSObject {
+    internal static let `default` = ClientTaskExecutor()
+
+    private var reachabilityManager: NetworkReachabilityMonitor?
+
+    init(reachabilityMonitor: NetworkReachabilityMonitor? = NetworkReachabilityManager.default) {
+        self.reachabilityManager = reachabilityMonitor
+        super.init()
+
+        do {
+            try self.reachabilityManager?.startListening(on: .main) { _ in }
+        } catch {
+            NSLog("[WARNING] Faild to start network monitor. Error: \(error)")
+        }
+    }
+
+    func perform<T>(_ task: Client.Task, on executor: T) throws -> CancellableRequest? {
+        guard reachabilityManager == nil || reachabilityManager?.isReachable == true else {
+            throw ClientTaskError.connectionUnavailable
+        }
+
+        switch (executor, task) {
+            case (is RequestExecutor, let .dataTask(request, completionHandler)) :
+                return (executor as! RequestExecutor).send(request: request, completionHandler)
+
+            case (is DownloadExecutor, let .downloadTask(request)):
+                return (executor as! DownloadExecutor).download(request: request)
+
+            case (is UploadExecutor, let .uploadDataTask(request, data)):
+                return (executor as! UploadExecutor).upload(request: request, from: data)
+
+            case (is UploadExecutor, let .uploadFileTask(request, fileURL)):
+                return (executor as! UploadExecutor).upload(request: request, fromFile: fileURL)
+
+            default:
+                throw ClientTaskError.unexpectedTaskExecution
+        }
+    }
+}

Sources/Jetworking/Extensions/SCNetworkReachabilityFlags+Extension.swift

@@ -0,0 +1,25 @@
+import Foundation
+import SystemConfiguration
+
+extension SCNetworkReachabilityFlags {
+    var isReachableViaCellular: Bool {
+        #if os(iOS)
+        return contains(.isWWAN)
+        #else
+        return false
+        #endif
+    }
+
+    var isReachableViaNetworkInterface: Bool {
+        contains(.reachable) &&
+        (!contains(.connectionRequired) || canEstablishConnectionAutomatically)
+    }
+
+    private var canEstablishConnection: Bool {
+        !intersection([.connectionOnTraffic, .connectionOnDemand]).isEmpty
+    }
+
+    private var canEstablishConnectionAutomatically: Bool {
+        canEstablishConnection && !contains(.interventionRequired)
+    }
+}

Sources/Jetworking/Utility/Reachability/NetworkReachability.swift

@@ -0,0 +1,43 @@
+import Foundation
+import SystemConfiguration
+
+/// Typealias for the state of network reachability.
+public typealias NetworkReachabilityState = NetworkReachability.State
+
+/// A container for all enumerations related to network state.
+public enum NetworkReachability {
+    /// Defines the various connection types detected by reachability flags.
+    public enum ConnectionInterface: Equatable {
+        /// Wired ethernet or WiFi.
+        case wiredOrWirelessLAN
+
+        /// Cellular connection.
+        case cellular
+    }
+
+    /// Defines the various states of network reachability.
+    public enum State: Equatable {
+        /// It could not be determined whether the network is reachable.
+        case notDetermined
+
+        /// The network is not reachable.
+        case unreachable
+
+        /// The network is reachable over an interface `ConnectionInterface`.
+        case reachable(ConnectionInterface)
+
+        init(_ flags: SCNetworkReachabilityFlags) {
+            guard flags.isReachableViaNetworkInterface else {
+                self = .unreachable
+                return
+            }
+
+            var networkStatus: Self = .reachable(.wiredOrWirelessLAN)
+            if flags.isReachableViaCellular {
+                networkStatus = .reachable(.cellular)
+            }
+
+            self = networkStatus
+        }
+    }
+}