Check for internet connection with Swift

Question

When I try to check for an internet connection on my iPhone I get a bunch of errors  Can anyone help me to fix this   The code   import Foundation import SystemConfiguration  public class Reachability    class func isConnectedToNetwork   - gt  Bool        var zeroAddress   sockaddr in       zeroAddress sin len   UInt8 sizeofValue zeroAddress       zeroAddress sin family   sa family t AF INET       let defaultRouteReachability   withUnsafePointer  amp zeroAddress            SCNetworkReachabilityCreateWithAddress nil  UnsafePointer  0              var flags  SCNetworkReachabilityFlags   0      if SCNetworkReachabilityGetFlags defaultRouteReachability   amp flags     0           return false            let isReachable    flags  amp  UInt32 kSCNetworkFlagsReachable      0     let needsConnection    flags  amp  UInt32 kSCNetworkFlagsConnectionRequired      0      return  isReachable  amp  amp   needsConnection    true   false        The errors with the code     If it is unreadable  error 1 says       Int  is not convertible to  SCNetworkReachabilityFlags    Error 2  amp  3      Could not find an overload for  init  that accepts the supplied arguments

User · Accepted Answer

To solve the 4G issue mentioned in the comments I have used @AshleyMills reachability implementation as a reference and rewritten Reachability for Swift 3.1:

updated: Xcode 10.1 • Swift 4 or later

Reachability.swift file

import Foundation
import SystemConfiguration

class Reachability {
    var hostname: String?
    var isRunning = false
    var isReachableOnWWAN: Bool
    var reachability: SCNetworkReachability?
    var reachabilityFlags = SCNetworkReachabilityFlags()
    let reachabilitySerialQueue = DispatchQueue(label: "ReachabilityQueue")
    init(hostname: String) throws {
        guard let reachability = SCNetworkReachabilityCreateWithName(nil, hostname) else {
            throw Network.Error.failedToCreateWith(hostname)
        }
        self.reachability = reachability
        self.hostname = hostname
        isReachableOnWWAN = true
        try start()
    }
    init() throws {
        var zeroAddress = sockaddr_in()
        zeroAddress.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
        zeroAddress.sin_family = sa_family_t(AF_INET)
        guard let reachability = withUnsafePointer(to: &zeroAddress, {
            $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
                SCNetworkReachabilityCreateWithAddress(nil, $0)
            }
        }) else {
            throw Network.Error.failedToInitializeWith(zeroAddress)
        }
        self.reachability = reachability
        isReachableOnWWAN = true
        try start()
    }
    var status: Network.Status {
        return  !isConnectedToNetwork ? .unreachable :
                isReachableViaWiFi    ? .wifi :
                isRunningOnDevice     ? .wwan : .unreachable
    }
    var isRunningOnDevice: Bool = {
        #if targetEnvironment(simulator)
            return false
        #else
            return true
        #endif
    }()
    deinit { stop() }
}

extension Reachability {

    func start() throws {
        guard let reachability = reachability, !isRunning else { return }
        var context = SCNetworkReachabilityContext(version: 0, info: nil, retain: nil, release: nil, copyDescription: nil)
        context.info = Unmanaged<Reachability>.passUnretained(self).toOpaque()
        guard SCNetworkReachabilitySetCallback(reachability, callout, &context) else { stop()
            throw Network.Error.failedToSetCallout
        }
        guard SCNetworkReachabilitySetDispatchQueue(reachability, reachabilitySerialQueue) else { stop()
            throw Network.Error.failedToSetDispatchQueue
        }
        reachabilitySerialQueue.async { self.flagsChanged() }
        isRunning = true
    }

    func stop() {
        defer { isRunning = false }
        guard let reachability = reachability else { return }
        SCNetworkReachabilitySetCallback(reachability, nil, nil)
        SCNetworkReachabilitySetDispatchQueue(reachability, nil)
        self.reachability = nil
    }

    var isConnectedToNetwork: Bool {
        return isReachable &&
               !isConnectionRequiredAndTransientConnection &&
               !(isRunningOnDevice && isWWAN && !isReachableOnWWAN)
    }

    var isReachableViaWiFi: Bool {
        return isReachable && isRunningOnDevice && !isWWAN
    }

    /// Flags that indicate the reachability of a network node name or address, including whether a connection is required, and whether some user intervention might be required when establishing a connection.
    var flags: SCNetworkReachabilityFlags? {
        guard let reachability = reachability else { return nil }
        var flags = SCNetworkReachabilityFlags()
        return withUnsafeMutablePointer(to: &flags) {
            SCNetworkReachabilityGetFlags(reachability, UnsafeMutablePointer($0))
            } ? flags : nil
    }

    /// compares the current flags with the previous flags and if changed posts a flagsChanged notification
    func flagsChanged() {
        guard let flags = flags, flags != reachabilityFlags else { return }
        reachabilityFlags = flags
        NotificationCenter.default.post(name: .flagsChanged, object: self)
    }

    /// The specified node name or address can be reached via a transient connection, such as PPP.
    var transientConnection: Bool { return flags?.contains(.transientConnection) == true }

    /// The specified node name or address can be reached using the current network configuration.
    var isReachable: Bool { return flags?.contains(.reachable) == true }

    /// The specified node name or address can be reached using the current network configuration, but a connection must first be established. If this flag is set, the kSCNetworkReachabilityFlagsConnectionOnTraffic flag, kSCNetworkReachabilityFlagsConnectionOnDemand flag, or kSCNetworkReachabilityFlagsIsWWAN flag is also typically set to indicate the type of connection required. If the user must manually make the connection, the kSCNetworkReachabilityFlagsInterventionRequired flag is also set.
    var connectionRequired: Bool { return flags?.contains(.connectionRequired) == true }

    /// The specified node name or address can be reached using the current network configuration, but a connection must first be established. Any traffic directed to the specified name or address will initiate the connection.
    var connectionOnTraffic: Bool { return flags?.contains(.connectionOnTraffic) == true }

    /// The specified node name or address can be reached using the current network configuration, but a connection must first be established.
    var interventionRequired: Bool { return flags?.contains(.interventionRequired) == true }

    /// The specified node name or address can be reached using the current network configuration, but a connection must first be established. The connection will be established "On Demand" by the CFSocketStream programming interface (see CFStream Socket Additions for information on this). Other functions will not establish the connection.
    var connectionOnDemand: Bool { return flags?.contains(.connectionOnDemand) == true }

    /// The specified node name or address is one that is associated with a network interface on the current system.
    var isLocalAddress: Bool { return flags?.contains(.isLocalAddress) == true }

    /// Network traffic to the specified node name or address will not go through a gateway, but is routed directly to one of the interfaces in the system.
    var isDirect: Bool { return flags?.contains(.isDirect) == true }

    /// The specified node name or address can be reached via a cellular connection, such as EDGE or GPRS.
    var isWWAN: Bool { return flags?.contains(.isWWAN) == true }

    /// The specified node name or address can be reached using the current network configuration, but a connection must first be established. If this flag is set
    /// The specified node name or address can be reached via a transient connection, such as PPP.
    var isConnectionRequiredAndTransientConnection: Bool {
        return (flags?.intersection([.connectionRequired, .transientConnection]) == [.connectionRequired, .transientConnection]) == true
    }
}

func callout(reachability: SCNetworkReachability, flags: SCNetworkReachabilityFlags, info: UnsafeMutableRawPointer?) {
    guard let info = info else { return }
    DispatchQueue.main.async {
        Unmanaged<Reachability>
            .fromOpaque(info)
            .takeUnretainedValue()
            .flagsChanged()
    }
}

extension Notification.Name {
    static let flagsChanged = Notification.Name("FlagsChanged")
}

struct Network {
    static var reachability: Reachability!
    enum Status: String {
        case unreachable, wifi, wwan
    }
    enum Error: Swift.Error {
        case failedToSetCallout
        case failedToSetDispatchQueue
        case failedToCreateWith(String)
        case failedToInitializeWith(sockaddr_in)
    }
}

Usage

Initialize it in your AppDelegate.swift didFinishLaunchingWithOptions method and handle any errors that might occur:

import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    var window: UIWindow?
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        do {
            try Network.reachability = Reachability(hostname: "www.google.com")
        }
        catch {
            switch error as? Network.Error {
            case let .failedToCreateWith(hostname)?:
                print("Network error:\nFailed to create reachability object With host named:", hostname)
            case let .failedToInitializeWith(address)?:
                print("Network error:\nFailed to initialize reachability object With address:", address)
            case .failedToSetCallout?:
                print("Network error:\nFailed to set callout")
            case .failedToSetDispatchQueue?:
                print("Network error:\nFailed to set DispatchQueue")
            case .none:
                print(error)
            }
        }
        return true
    }
}

And a view controller sample:

import UIKit
class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        NotificationCenter.default
            .addObserver(self,
                         selector: #selector(statusManager),
                         name: .flagsChanged,
                         object: nil)
        updateUserInterface()
    }
    func updateUserInterface() {
        switch Network.reachability.status {
        case .unreachable:
            view.backgroundColor = .red
        case .wwan:
            view.backgroundColor = .yellow
        case .wifi:
            view.backgroundColor = .green
        }
        print("Reachability Summary")
        print("Status:", Network.reachability.status)
        print("HostName:", Network.reachability.hostname ?? "nil")
        print("Reachable:", Network.reachability.isReachable)
        print("Wifi:", Network.reachability.isReachableViaWiFi)
    }
    @objc func statusManager(_ notification: Notification) {
        updateUserInterface()
    }
}

Sample Project

User · Answer

Just figured this out for myself   Xcode  7 3 1  iOS 9 3 3  Using ashleymills Reachability swift as Reachability swift in my project  I created the following function   func hasConnectivity   - gt  Bool       do           let reachability  Reachability   try Reachability reachabilityForInternetConnection           let networkStatus  Int   reachability currentReachabilityStatus hashValue          return  networkStatus    0            catch              Handle error however you please         return false           Simply call hasConnectivity   where ever you need to check for a connection  This works for Wifi as well as Cellular     Adding ashleymills s Reachability swift so people dont have to move between sites   Copyright  c  2014  Ashley Mills All rights reserved   Redistribution and use in source and binary forms  with or without modification  are permitted provided that the following conditions are met   1  Redistributions of source code must retain the above copyright notice  this list of conditions and the following disclaimer   2  Redistributions in binary form must reproduce the above copyright notice  this list of conditions and the following disclaimer in the documentation and or other materials provided with the distribution   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS  AS IS  AND ANY EXPRESS OR IMPLIED WARRANTIES  INCLUDING  BUT NOT LIMITED TO  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT  INDIRECT  INCIDENTAL  SPECIAL  EXEMPLARY  OR CONSEQUENTIAL DAMAGES  INCLUDING  BUT NOT LIMITED TO  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES  LOSS OF USE  DATA  OR PROFITS  OR BUSINESS INTERRUPTION  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY  WHETHER IN CONTRACT  STRICT LIABILITY  OR TORT  INCLUDING NEGLIGENCE OR OTHERWISE  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE         Reachability swift version 2 2beta2  import SystemConfiguration import Foundation  public enum ReachabilityError  ErrorType       case FailedToCreateWithAddress sockaddr in      case FailedToCreateWithHostname String      case UnableToSetCallback     case UnableToSetDispatchQueue    public let ReachabilityChangedNotification    ReachabilityChangedNotification   func callback reachability SCNetworkReachability  flags  SCNetworkReachabilityFlags  info  UnsafeMutablePointer lt Void gt         let reachability   Unmanaged lt Reachability gt  fromOpaque COpaquePointer info   takeUnretainedValue        dispatch async dispatch get main queue              reachability reachabilityChanged flags            public class Reachability  NSObject        public typealias NetworkReachable    Reachability  - gt         public typealias NetworkUnreachable    Reachability  - gt          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                                        MARK  -     Public properties         public var whenReachable  NetworkReachable      public var whenUnreachable  NetworkUnreachable      public var reachableOnWWAN  Bool     public var notificationCenter   NSNotificationCenter defaultCenter        public var currentReachabilityStatus  NetworkStatus           if isReachable                 if isReachableViaWiFi                     return  ReachableViaWiFi                           if isRunningOnDevice                   return  ReachableViaWWAN                                 return  NotReachable            public var currentReachabilityString  String           return    currentReachabilityStatus              private var previousFlags  SCNetworkReachabilityFlags          MARK  -     Initialisation methods          required public init reachabilityRef  SCNetworkReachability            reachableOnWWAN   true         self reachabilityRef   reachabilityRef            public convenience init hostname  String  throws            let nodename    hostname as NSString  UTF8String         guard let ref   SCNetworkReachabilityCreateWithName nil  nodename  else   throw ReachabilityError FailedToCreateWithHostname hostname             self init reachabilityRef  ref             public class func reachabilityForInternetConnection   throws - gt  Reachability            var zeroAddress   sockaddr in           zeroAddress sin len   UInt8 sizeofValue zeroAddress           zeroAddress sin family   sa family t AF INET           guard let ref   withUnsafePointer  amp zeroAddress                SCNetworkReachabilityCreateWithAddress nil  UnsafePointer  0              else   throw ReachabilityError FailedToCreateWithAddress zeroAddress             return Reachability reachabilityRef  ref             public class func reachabilityForLocalWiFi   throws - gt  Reachability            var localWifiAddress  sockaddr in   sockaddr in sin len    uint8 t 0   sin family  sa family t 0   sin port  in port t 0   sin addr  in addr s addr  0   sin zero   0  0  0  0  0  0  0  0           localWifiAddress sin len   UInt8 sizeofValue localWifiAddress           localWifiAddress sin family   sa family t AF INET              IN LINKLOCALNETNUM is defined in  lt netinet in h gt  as 169 254 0 0         let address  UInt32   0xA9FE0000         localWifiAddress sin addr s addr   in addr t address bigEndian           guard let ref   withUnsafePointer  amp localWifiAddress                SCNetworkReachabilityCreateWithAddress nil  UnsafePointer  0              else   throw ReachabilityError FailedToCreateWithAddress localWifiAddress             return Reachability reachabilityRef  ref                MARK  -     Notifier methods         public func startNotifier   throws            guard  notifierRunning else   return            var context   SCNetworkReachabilityContext version  0  info  nil  retain  nil  release  nil  copyDescription  nil          context info   UnsafeMutablePointer Unmanaged passUnretained self  toOpaque             if  SCNetworkReachabilitySetCallback reachabilityRef   callback   amp context                stopNotifier               throw ReachabilityError UnableToSetCallback                    if  SCNetworkReachabilitySetDispatchQueue reachabilityRef   reachabilitySerialQueue                stopNotifier               throw ReachabilityError UnableToSetDispatchQueue                       Perform an intial check         dispatch async reachabilitySerialQueue       - gt  Void in             let flags   self reachabilityFlags             self reachabilityChanged flags                     notifierRunning   true            public func stopNotifier             defer   notifierRunning   false           guard let reachabilityRef   reachabilityRef else   return            SCNetworkReachabilitySetCallback reachabilityRef  nil  nil          SCNetworkReachabilitySetDispatchQueue reachabilityRef  nil                MARK  -     Connection test methods         public func isReachable   - gt  Bool           let flags   reachabilityFlags         return isReachableWithFlags flags             public func isReachableViaWWAN   - gt  Bool            let flags   reachabilityFlags             Check we re not on the simulator  we re REACHABLE and check we re on WWAN         return isRunningOnDevice  amp  amp  isReachable flags   amp  amp  isOnWWAN flags             public func isReachableViaWiFi   - gt  Bool            let flags   reachabilityFlags             Check we re reachable         if  isReachable flags                return false                       Must be on WiFi if reachable but not on an iOS device  i e  simulator          if  isRunningOnDevice               return true                       Check we re NOT on WWAN         return  isOnWWAN flags                MARK  -     Private methods         private var isRunningOnDevice  Bool              if  arch i386     arch x86 64    amp  amp  os iOS              return false          else             return true          endif              private var notifierRunning   false     private var reachabilityRef  SCNetworkReachability      private let reachabilitySerialQueue   dispatch queue create  uk co ashleymills reachability   DISPATCH QUEUE SERIAL       private func reachabilityChanged flags  SCNetworkReachabilityFlags             guard previousFlags    flags else   return            if isReachableWithFlags flags                if let block   whenReachable                   block self                          else               if let block   whenUnreachable                   block self                                   notificationCenter postNotificationName ReachabilityChangedNotification  object self           previousFlags   flags            private func isReachableWithFlags flags  SCNetworkReachabilityFlags  - gt  Bool            if  isReachable flags                return false                    if isConnectionRequiredOrTransient flags                return false                    if isRunningOnDevice               if isOnWWAN flags   amp  amp   reachableOnWWAN                      We don t want to connect when on 3G                  return false                                  return true               WWAN may be available  but not active until a connection has been established         WiFi may require a connection for VPN on Demand      private func isConnectionRequired   - gt  Bool           return connectionRequired              private func connectionRequired   - gt  Bool           let flags   reachabilityFlags         return isConnectionRequired flags                Dynamic  on demand connection      private func isConnectionOnDemand   - gt  Bool           let flags   reachabilityFlags         return isConnectionRequired flags   amp  amp  isConnectionOnTrafficOrDemand flags                Is user intervention required      private func isInterventionRequired   - gt  Bool           let flags   reachabilityFlags         return isConnectionRequired flags   amp  amp  isInterventionRequired flags             private func isOnWWAN flags  SCNetworkReachabilityFlags  - gt  Bool            if os iOS              return flags contains  IsWWAN           else             return false          endif           private func isReachable flags  SCNetworkReachabilityFlags  - gt  Bool           return flags contains  Reachable            private func isConnectionRequired flags  SCNetworkReachabilityFlags  - gt  Bool           return flags contains  ConnectionRequired            private func isInterventionRequired flags  SCNetworkReachabilityFlags  - gt  Bool           return flags contains  InterventionRequired            private func isConnectionOnTraffic flags  SCNetworkReachabilityFlags  - gt  Bool           return flags contains  ConnectionOnTraffic            private func isConnectionOnDemand flags  SCNetworkReachabilityFlags  - gt  Bool           return flags contains  ConnectionOnDemand            func isConnectionOnTrafficOrDemand flags  SCNetworkReachabilityFlags  - gt  Bool           return  flags intersect   ConnectionOnTraffic   ConnectionOnDemand   isEmpty           private func isTransientConnection flags  SCNetworkReachabilityFlags  - gt  Bool           return flags contains  TransientConnection            private func isLocalAddress flags  SCNetworkReachabilityFlags  - gt  Bool           return flags contains  IsLocalAddress            private func isDirect flags  SCNetworkReachabilityFlags  - gt  Bool           return flags contains  IsDirect            private func isConnectionRequiredOrTransient flags  SCNetworkReachabilityFlags  - gt  Bool           let testcase SCNetworkReachabilityFlags     ConnectionRequired   TransientConnection          return flags intersect testcase     testcase            private var reachabilityFlags  SCNetworkReachabilityFlags            guard let reachabilityRef   reachabilityRef else   return SCNetworkReachabilityFlags              var flags   SCNetworkReachabilityFlags           let gotFlags   withUnsafeMutablePointer  amp flags                SCNetworkReachabilityGetFlags reachabilityRef  UnsafeMutablePointer  0                      if gotFlags               return flags           else               return SCNetworkReachabilityFlags                        override public var description  String            var W  String         if isRunningOnDevice               W   isOnWWAN reachabilityFlags     W     -            else               W    X                    let R   isReachable reachabilityFlags     R     -          let c   isConnectionRequired reachabilityFlags     c     -          let t   isTransientConnection reachabilityFlags     t     -          let i   isInterventionRequired reachabilityFlags     i     -          let C   isConnectionOnTraffic reachabilityFlags     C     -          let D   isConnectionOnDemand reachabilityFlags     D     -          let l   isLocalAddress reachabilityFlags     l     -          let d   isDirect reachabilityFlags     d     -           return    W   R    c   t   i   C   D   l   d              deinit           stopNotifier            reachabilityRef   nil         whenReachable   nil         whenUnreachable   nil

User · Answer

I have made my own solution using NSTimer and Alamofire   import Alamofire  public class ConnectionHelper  NSObject       var request  Alamofire Request       func isInternetConnected completionHandler  Bool - gt  Void            NSTimer scheduledTimerWithTimeInterval 5 0  target  self  selector   requestTimeout   userInfo  nil  repeats  false           request   Alamofire              request                  Method HEAD                   http   www testurl com                             response   response in                 if response 3  code    -999                       completionHandler                          false                                         else                       completionHandler                          true                                                              func requestTimeout             request  cancel             The NSTimer is used as a timeout  and was used due to unreliable results using the Alamofire timeout  The request should be made to a URL you trust to be reliable  such as your own server or the server that is hosting the services you depend on   When the timer expires  the request is cancelled and the results are returned using a completion handler   Usage   ConnectionHelper   isInternetConnected     internetConnected in     if internetConnected              Connected       else              Not connected

User · Answer

Updated version of  martin s answer for Swift 5  using Combine  This one also includes unavailibity reason check for iOS 14  import Combine import Network  enum NetworkType       case wifi     case cellular     case loopBack     case wired     case other    final class ReachabilityService  ObservableObject         Published var reachabilityInfos  NWPath       Published var isNetworkAvailable  Bool       Published var typeOfCurrentConnection  NetworkType       private let monitor   NWPathMonitor       private let backgroundQueue   DispatchQueue global qos   background       init             setUp              init with interFaceType  NWInterface InterfaceType            setUp              deinit           monitor cancel            private extension ReachabilityService        func setUp              monitor pathUpdateHandler      weak self  path in             self  reachabilityInfos   path             switch path status               case  satisfied                  print  quot ReachabilityService  satisfied quot                   self  isNetworkAvailable   true                 break             case  unsatisfied                  print  quot ReachabilityService  unsatisfied quot                    if  available iOS 14 2                           switch path unsatisfiedReason                        case  notAvailable                          print  quot ReachabilityService  unsatisfiedReason  notAvailable quot                           break                     case  cellularDenied                          print  quot ReachabilityService  unsatisfiedReason  cellularDenied quot                           break                     case  wifiDenied                          print  quot ReachabilityService  unsatisfiedReason  wifiDenied quot                           break                     case  localNetworkDenied                          print  quot ReachabilityService  unsatisfiedReason  localNetworkDenied quot                           break                      unknown default                          print  quot ReachabilityService  unsatisfiedReason  default quot                                           else                          Fallback on earlier versions                                    self  isNetworkAvailable   false                 break             case  requiresConnection                  print  quot ReachabilityService  requiresConnection quot                   self  isNetworkAvailable   false                 break              unknown default                  print  quot ReachabilityService  default quot                   self  isNetworkAvailable   false                           if path usesInterfaceType  wifi                    self  typeOfCurrentConnection    wifi               else if path usesInterfaceType  cellular                    self  typeOfCurrentConnection    cellular               else if path usesInterfaceType  loopback                    self  typeOfCurrentConnection    loopBack               else if path usesInterfaceType  wiredEthernet                    self  typeOfCurrentConnection    wired               else if path usesInterfaceType  other                    self  typeOfCurrentConnection    other                                  monitor start queue  backgroundQueue           Usage  In your view model  private let reachability   ReachabilityService    init         reachability  isNetworkAvailable sink    weak self  isConnected in         self  isConnected   isConnected    false       store in   amp cancelBag     In your controller  viewModel  isConnected sink    weak self  isConnected in     print  quot isConnected    isConnected  quot       DispatchQueue main async             Update your UI in here         store in   amp bindings

User · Answer

here is the same code with accepted answer but I find it more useful for some cases to use closures import SystemConfiguration  public class Reachability        class func isConnectedToNetwork isConnected    Bool  - gt                 var zeroAddress   sockaddr in sin len  0  sin family  0  sin port  0  sin addr  in addr s addr  0   sin zero   0  0  0  0  0  0  0  0           zeroAddress sin len   UInt8 MemoryLayout size ofValue  zeroAddress           zeroAddress sin family   sa family t AF INET           let defaultRouteReachability   withUnsafePointer to   amp zeroAddress                 0 withMemoryRebound to  sockaddr self  capacity  1   zeroSockAddress in                 SCNetworkReachabilityCreateWithAddress nil  zeroSockAddress                                   var flags  SCNetworkReachabilityFlags   SCNetworkReachabilityFlags rawValue  0          if SCNetworkReachabilityGetFlags defaultRouteReachability    amp flags     false               isConnected false                        Only Working for WIFI         let isReachable   flags     reachable         let needsConnection   flags     connectionRequired          return isReachable  amp  amp   needsConnection                        Working for Cellular and WIFI         let isReachable    flags rawValue  amp  UInt32 kSCNetworkFlagsReachable      0         let needsConnection    flags rawValue  amp  UInt32 kSCNetworkFlagsConnectionRequired      0         let ret    isReachable  amp  amp   needsConnection           isConnected ret           and here is how to use it  Reachability isConnectedToNetwork    isConnected  in     if isConnected             We have internet connection   get data from server       else             We don t have internet connection   load from database

User · Answer

As of iOS 12  NWPathMonitor replaced Reachability  Use this  import Network   struct Internet      private static let monitor   NWPathMonitor      static var active   false  static var expensive   false        Monitors internet connectivity changes  Updates with every change in connectivity       Updates variables for availability and if it s expensive  cellular    static func start       guard monitor pathUpdateHandler    nil else   return        monitor pathUpdateHandler     update in    Internet active   update status     satisfied   true   false    Internet expensive   update isExpensive   true   false          monitor start queue  DispatchQueue label   quot InternetMonitor quot            In use  Internet start    if Internet active       do something      if Internet expensive       device is using Cellular data or WiFi hotspot

User · Answer

This is my version  Essentially it doesn t bring anything new  I bound it to UIDevice   import UIKit import SystemConfiguration  extension UIDevice        open class var isConnectedToNetwork  Bool           get               var zeroAddress   sockaddr in               zeroAddress sin len   UInt8 MemoryLayout size ofValue  zeroAddress               zeroAddress sin family   sa family t AF INET               guard                 let defaultRouteReachability  SCNetworkReachability   withUnsafePointer to   amp zeroAddress                         0 withMemoryRebound to  sockaddr self  capacity  1                            SCNetworkReachabilityCreateWithAddress nil   0                                                            var flags  SCNetworkReachabilityFlags   SCNetworkReachabilityFlags   as SCNetworkReachabilityFlags                   SCNetworkReachabilityGetFlags defaultRouteReachability   amp flags                  else   return false                return flags contains  reachable   amp  amp   flags contains  connectionRequired                      print  Network status availability        UIDevice isConnectedToNetwork    true     false

User · Answer

here my solution for swift 2 3 with the lib  Reachability swift   Go into your Podfile and add    pod  ReachabilitySwift      gt  2 4     swift 2 3   Then into your terminal    pod install   Then create a new file ReachabilityManager and add code below    import Foundation import ReachabilitySwift  enum ReachabilityManagerType       case Wifi     case Cellular     case None    class ReachabilityManager       static let sharedInstance   ReachabilityManager        private var reachability  Reachability      private var reachabilityManagerType  ReachabilityManagerType    None       private init             do               self reachability   try Reachability reachabilityForInternetConnection             catch               print  Unable to create Reachability               return                    NSNotificationCenter defaultCenter   addObserver self  selector   selector ReachabilityManager reachabilityChanged      name  ReachabilityChangedNotification object  self reachability          do              try self reachability startNotifier            catch              print  could not start reachability notifier                         objc private func reachabilityChanged note  NSNotification             let reachability   note object as  Reachability          if reachability isReachable                 if reachability isReachableViaWiFi                     self reachabilityManagerType    Wifi               else                   self reachabilityManagerType    Cellular                         else               self reachabilityManagerType    None                    extension ReachabilityManager        func isConnectedToNetwork   - gt  Bool           return reachabilityManagerType     None            How use it   go into your AppDelegate swift and add the code below    func application application  UIApplication  didFinishLaunchingWithOptions launchOptions   NSObject  AnyObject    - gt  Bool        ReachabilityManager sharedInstance     Then when you want to check if the device is connected to internet do    if ReachabilityManager sharedInstance isConnectedToNetwork           Connected   else        Not connected

User · Answer

If you are using Alamofire  you can do something like this   let configuration   NSURLSessionConfiguration defaultSessionConfiguration   configuration timeoutIntervalForRequest   15   Set timeouts in sec configuration timeoutIntervalForResource   15  let alamoFireManager   Alamofire Manager configuration configuration  alamoFireManager  request  GET   https   yourURL com   parameters  headers  encoding   URL                        validate                                  responseJSON   response in                                  if let error   response result error                                      switch error code                                      case -1001                                          print  Slow connection                                           return                                     case -1009                                          print  No Connection                                            return                                     default  break

User · Answer

For Swift 3  Swift 4  working with cellular and Wi-Fi    import SystemConfiguration  public class Reachability        class func isConnectedToNetwork   - gt  Bool            var zeroAddress   sockaddr in sin len  0  sin family  0  sin port  0  sin addr  in addr s addr  0   sin zero   0  0  0  0  0  0  0  0           zeroAddress sin len   UInt8 MemoryLayout size ofValue  zeroAddress           zeroAddress sin family   sa family t AF INET           let defaultRouteReachability   withUnsafePointer to   amp zeroAddress                 0 withMemoryRebound to  sockaddr self  capacity  1   zeroSockAddress in                 SCNetworkReachabilityCreateWithAddress nil  zeroSockAddress                                   var flags  SCNetworkReachabilityFlags   SCNetworkReachabilityFlags rawValue  0          if SCNetworkReachabilityGetFlags defaultRouteReachability    amp flags     false               return false                       Only Working for WIFI         let isReachable   flags     reachable         let needsConnection   flags     connectionRequired          return isReachable  amp  amp   needsConnection                        Working for Cellular and WIFI         let isReachable    flags rawValue  amp  UInt32 kSCNetworkFlagsReachable      0         let needsConnection    flags rawValue  amp  UInt32 kSCNetworkFlagsConnectionRequired      0         let ret    isReachable  amp  amp   needsConnection           return ret            Usage   if Reachability isConnectedToNetwork        print  Internet Connection Available     else      print  Internet Connection not Available

User · Answer

If someone is already using  Alamofire then -  struct Connectivity     static let sharedInstance   NetworkReachabilityManager      static var isConnectedToInternet Bool         return self sharedInstance isReachable           Usage   if Connectivity isConnectedToInternet        print  Connected      else        print  No Internet

User · Answer

iOS12 Swift 4 and Swift 5 If you just want to check the connection  and your lowest target is iOS12  then you can use NWPathMonitor import Network  It needs a little setup with some properties  let internetMonitor   NWPathMonitor   let internetQueue   DispatchQueue label   quot InternetMonitor quot   private var hasConnectionPath   false  I created a function to get it going  You can do this on view did load or anywhere else  I put a guard in so you can call it all you want to get it going  func startInternetTracking            only fires once     guard internetMonitor pathUpdateHandler    nil else           return           internetMonitor pathUpdateHandler     update in         if update status     satisfied               print  quot Internet connection on  quot               self hasConnectionPath   true           else               print  quot no internet connection  quot               self hasConnectionPath   false                     internetMonitor start queue  internetQueue         will tell you if the device has an Internet connection     - Returns  true if there is some kind of connection func hasInternet   - gt  Bool       return hasConnectionPath    Now you can just call the helper function hasInternet   to see if you have one  It updates in real time  See Apple documentation for NWPathMonitor  It has lots more functionality like cancel   if you need to stop tracking the connection  type of internet you are looking for  etc  https   developer apple com documentation network nwpathmonitor

User · Answer

if your project has a target above or equal iOS 12 and uses combine you could use this little piece of code  import Combine import Network  enum NerworkType       case wifi     case cellular     case loopBack     case wired     case other    protocol ReachabilityServiceContract       var reachabilityInfos  PassthroughSubject lt NWPath  Never gt    get set       var isNetworkAvailable  CurrentValueSubject lt Bool  Never gt    get set       var typeOfCurrentConnection  PassthroughSubject lt NerworkType  Never gt    get set      final class ReachabilityService  ReachabilityServiceContract       var reachabilityInfos  PassthroughSubject lt NWPath  Never gt     init       var isNetworkAvailable  CurrentValueSubject lt Bool  Never gt     init false      var typeOfCurrentConnection  PassthroughSubject lt NerworkType  Never gt     init        private let monitor  NWPathMonitor     private let backgroudQueue   DispatchQueue global qos   background       init             monitor   NWPathMonitor           setUp              init with interFaceType  NWInterface InterfaceType            monitor   NWPathMonitor requiredInterfaceType  interFaceType          setUp              deinit           monitor cancel            private extension ReachabilityService       func setUp                  monitor pathUpdateHandler      weak self  path in             self  reachabilityInfos send path              switch path status               case  satisfied                  self  isNetworkAvailable send true              case  unsatisfied   requiresConnection                  self  isNetworkAvailable send false               unknown default                  self  isNetworkAvailable send false                            if path usesInterfaceType  wifi                    self  typeOfCurrentConnection send  wifi                else if path usesInterfaceType  cellular                    self  typeOfCurrentConnection send  cellular                else if path usesInterfaceType  loopback                    self  typeOfCurrentConnection send  loopBack                else if path usesInterfaceType  wiredEthernet                    self  typeOfCurrentConnection send  wired                else if path usesInterfaceType  other                    self  typeOfCurrentConnection send  other                                       monitor start queue  backgroudQueue           Just subscribe to the variable you want to follow and you should be updated of any changes

User · Answer

For swift 3  I couldn t use just reachability from RAJAMOHAN-S solutions since it returns  true  if there is WiFi but no Internet  Thus  I implemented second validation via URLSession class and completion handler    Here is the whole class    import Foundation import SystemConfiguration  public class Reachability    class func isConnectedToNetwork   - gt  Bool    var zeroAddress   sockaddr in sin len  0  sin family  0  sin port  0  sin addr  in addr s addr  0   sin zero   0  0  0  0  0  0  0  0   zeroAddress sin len   UInt8 MemoryLayout size ofValue  zeroAddress   zeroAddress sin family   sa family t AF INET   let defaultRouteReachability   withUnsafePointer to   amp zeroAddress       0 withMemoryRebound to  sockaddr self  capacity  1   zeroSockAddress in     SCNetworkReachabilityCreateWithAddress nil  zeroSockAddress         var flags  SCNetworkReachabilityFlags   SCNetworkReachabilityFlags rawValue  0  if SCNetworkReachabilityGetFlags defaultRouteReachability    amp flags     false     return false       Working for Cellular and WIFI let isReachable    flags rawValue  amp  UInt32 kSCNetworkFlagsReachable      0 let needsConnection    flags rawValue  amp  UInt32 kSCNetworkFlagsConnectionRequired      0 let ret    isReachable  amp  amp   needsConnection   return ret      class func isInternetAvailable webSiteToPing  String   completionHandler   escaping  Bool  - gt  Void        1  Check the WiFi Connection guard isConnectedToNetwork   else     completionHandler false    return       2  Check the Internet Connection var webAddress    https   www google com     Default Web Site if let     webSiteToPing     webAddress   webSiteToPing     guard let url   URL string  webAddress  else     completionHandler false    print  could not create url from    webAddress      return    let urlRequest   URLRequest url  url  let session   URLSession shared let task   session dataTask with  urlRequest  completionHandler     data  response  error  in   if error    nil    response    nil       completionHandler false      else       completionHandler true            task resume         And you call this like this  for example    Reachability isInternetAvailable webSiteToPing  nil     isInternetAvailable  in   guard isInternetAvailable else          Inform user for example     return           Do some action if there is Internet

User · Answer

While it may not directly determine whether the phone is connected to a network  the simplest   cleanest   solution would be to  ping  Google  or some other server   which isn t possible unless the phone is connected to a network    private var urlSession URLSession         var newConfiguration URLSessionConfiguration    default     newConfiguration waitsForConnectivity   false     newConfiguration allowsCellularAccess   true     return URLSession configuration  newConfiguration       public func canReachGoogle   - gt  Bool       let url   URL string   https   8 8 8 8       let semaphore   DispatchSemaphore value  0      var success   false     let task   urlSession dataTask with  url         data  response  error in         if error    nil                       success   false                   else                       success   true                   semaphore signal              task resume       semaphore wait        return success     If you re concerned that the server may be down or may block your IP  you can always ping multiple servers in a similar fashion and return whether any of them are reachable  Or have someone set up a dedicated server just for this purpose

User · Answer

With the help of below code you can check for internet Connection for both cellular network as well as for wifi   language - Swift 3 0   import UIKit import Foundation import SystemConfiguration  class NetworkConnection  UIViewController      class func isConnectedToNetwork   - gt  Bool       var zeroAddress   sockaddr in sin len  0  sin family  0  sin port  0  sin addr  in addr s addr  0   sin zero   0  0  0  0  0  0  0  0       zeroAddress sin len   UInt8 MemoryLayout size ofValue  zeroAddress       zeroAddress sin family   sa family t AF INET       guard let defaultRouteReachability   withUnsafePointer to   amp zeroAddress           0 withMemoryRebound to  sockaddr self  capacity  1            SCNetworkReachabilityCreateWithAddress nil   0                 else         return false            var flags  SCNetworkReachabilityFlags   SCNetworkReachabilityFlags rawValue  0      if SCNetworkReachabilityGetFlags defaultRouteReachability   amp flags     false         return false           let isReachable    flags rawValue  amp  UInt32 kSCNetworkFlagsReachable      0     let needsConnection    flags rawValue  amp  UInt32 kSCNetworkFlagsConnectionRequired      0     return  isReachable  amp  amp   needsConnection         class func checkConnection sender UIViewController       if NetworkConnection isConnectedToNetwork      true         print  Connected to the internet             Do something       else         print  No internet connection         let alertController   UIAlertController title   No Internet Available   message      preferredStyle  UIAlertControllerStyle alert        let okAction   UIAlertAction title   Ok   style  UIAlertActionStyle default   result UIAlertAction  - gt  Void in         return               alertController addAction okAction        sender present alertController  animated  true  completion  nil            Do something

User · Answer

I have checked out implementing Ashley Mill s Reachability class without Cocoa Pods Dependancy Manager  The idea is to make the Reachability  dependency free in the project    Xcode 7 2 - Swift 2 1  1  https   github com ashleymills Reachability swift  Download add the Reachability class to the project    Note  While adding  please make sure  copy items if needed  is ticked   2  Make an AppManager swift class   This class will cater as Public Model class where public methods  amp  data will be added and can be utilised in any VC       AppManager swift  import UIKit import Foundation  class AppManager  NSObject      var delegate AppManagerDelegate    nil     private var  useClosures Bool   false     private var reachability  Reachability      private var  isReachability Bool   false     private var  reachabiltyNetworkType  String       var isReachability Bool           get  return  isReachability             var reachabiltyNetworkType String       get  return  reachabiltyNetworkType                       Create a shared instance of AppManager     final  class var sharedInstance   AppManager           struct Static               static var instance   AppManager                    if   Static instance    nil                Static instance   AppManager                      return Static instance                Reachability Methods     func initRechabilityMonitor             print  initialize rechability              do               let reachability   try Reachability reachabilityForInternetConnection               self reachability   reachability           catch ReachabilityError FailedToCreateWithAddress let address                print  Unable to create nReachability with address  n  address                return           catch            if   useClosures                reachability  whenReachable     reachability in                 self notifyReachability reachability                            reachability  whenUnreachable     reachability in                 self notifyReachability reachability                          else               self notifyReachability reachability                      do               try reachability  startNotifier             catch               print  unable to start notifier               return                               private func notifyReachability reachability Reachability            if reachability isReachable                 self  isReachability   true    Determine Network Type        if reachability isReachableViaWiFi                self  reachabiltyNetworkType   CONNECTION NETWORK TYPE WIFI NETWORK rawValue         else           self  reachabiltyNetworkType   CONNECTION NETWORK TYPE WWAN NETWORK rawValue                    else               self  isReachability   false self  reachabiltyNetworkType   CONNECTION NETWORK TYPE OTHER rawValue                     NSNotificationCenter defaultCenter   addObserver self  selector   reachabilityChanged    name  ReachabilityChangedNotification  object  reachability            func reachabilityChanged note  NSNotification            let reachability   note object as  Reachability         dispatch async dispatch get main queue                  if  self  useClosures                    self reachability  whenReachable     reachability in                     self notifyReachability reachability                                    self reachability  whenUnreachable     reachability in                     self notifyReachability reachability                                  else                   self notifyReachability reachability                            self delegate  reachabilityStatusChangeHandler reachability                      deinit           reachability  stopNotifier           if    useClosures                NSNotificationCenter defaultCenter   removeObserver self  name  ReachabilityChangedNotification  object  nil                      3   Make a Delegate Class  I use delegate method to notify the connectivity status       Protocols swift  import Foundation  objc protocol AppManagerDelegate NSObjectProtocol        func reachabilityStatusChangeHandler reachability Reachability      4  Make Parent class of UIViewController  Inheritance method   The parent class have methods which are accessible all child VCs        UIappViewController swift      import UIKit      class UIappViewController  UIViewController AppManagerDelegate           var manager AppManager   AppManager sharedInstance          override func viewDidLoad                 super viewDidLoad               manager delegate   self                   override func didReceiveMemoryWarning                 super didReceiveMemoryWarning                     func reachabilityStatusChangeHandler reachability  Reachability                if reachability isReachable                     print  isReachable                 else                   print  notReachable                                   5  Start Real time Internet Connectivity Monitoring in AppDelegate   func application application  UIApplication  didFinishLaunchingWithOptions launchOptions   NSObject  AnyObject    - gt  Bool       AppManager sharedInstance initRechabilityMonitor   return true     6  I have added a Swift File Name AppReference to store constant enum values       AppReference swift  import Foundation  enum CONNECTION NETWORK TYPE   String      case WIFI NETWORK    Wifi    case WWAN NETWORK    Cellular    case OTHER    Other       7   On ViewController  ex  You want to call an API only if network is available       ViewController swift          import UIKit  class ViewController  UIappViewController     var reachability Reachability     override func viewDidLoad         super viewDidLoad       manager delegate   self      if AppManager sharedInstance isReachability              print  net available           call API from here         else         dispatch async dispatch get main queue              print  net not available             Show Alert                       Determine Network Type     if AppManager sharedInstance reachabiltyNetworkType     Wifi               print   Wifi             else if  AppManager sharedInstance reachabiltyNetworkType     Cellular               print   Cellular             else         dispatch async dispatch get main queue              print  Network not reachable                        override func viewWillAppear animated  Bool          override func didReceiveMemoryWarning             The sample can be downloaded   https   github com alvinreuben Reachability-Sample  Upgraded to Swift 3 1- https   github com alvinvgeorge Reachability-UpgradedToSwift3

User · Answer

Use this for Swift-5  import Foundation import UIKit import SystemConfiguration  public class InternetConnectionManager                 private init                             public static func isConnectedToNetwork   - gt  Bool                    var zeroAddress   sockaddr in           zeroAddress sin len   UInt8 MemoryLayout size ofValue  zeroAddress           zeroAddress sin family   sa family t AF INET          guard let defaultRouteReachability   withUnsafePointer to   amp zeroAddress                              0 withMemoryRebound to  sockaddr self  capacity  1                                     SCNetworkReachabilityCreateWithAddress nil   0                                                         else                            return false                   var flags   SCNetworkReachabilityFlags           if  SCNetworkReachabilityGetFlags defaultRouteReachability   amp flags                return false                   let isReachable    flags rawValue  amp  UInt32 kSCNetworkFlagsReachable      0         let needsConnection    flags rawValue  amp  UInt32 kSCNetworkFlagsConnectionRequired      0         return  isReachable  amp  amp   needsConnection                Usage  if InternetConnectionManager isConnectedToNetwork        print  quot Connected quot    else      print  quot Not Connected quot      Or Just use this framework for more Utilities  Link

User · Answer

Swift 5 import SystemConfiguration      protocol Utilities    extension NSObject  Utilities       enum ReachabilityStatus           case notReachable         case reachableViaWWAN         case reachableViaWiFi                var currentReachabilityStatus  ReachabilityStatus                    var zeroAddress   sockaddr in           zeroAddress sin len   UInt8 MemoryLayout lt sockaddr in gt  size          zeroAddress sin family   sa family t AF INET          guard let defaultRouteReachability   withUnsafePointer to   amp zeroAddress                 0 withMemoryRebound to  sockaddr self  capacity  1                    SCNetworkReachabilityCreateWithAddress nil   0                           else               return  notReachable                            var flags  SCNetworkReachabilityFlags              if  SCNetworkReachabilityGetFlags defaultRouteReachability   amp flags                return  notReachable                            if flags contains  reachable     false                  The target host is not reachable              return  notReachable                   else if flags contains  isWWAN     true                  WWAN connections are OK if the calling application is using the CFNetwork APIs              return  reachableViaWWAN                   else if flags contains  connectionRequired     false                  If the target host is reachable and no connection is required then we ll assume that you re on Wi-Fi                return  reachableViaWiFi                   else if  flags contains  connectionOnDemand     true    flags contains  connectionOnTraffic     true   amp  amp  flags contains  interventionRequired     false                  The connection is on-demand  or on-traffic  if the calling application is using the CFSocketStream or higher APIs and no  user  intervention is needed             return  reachableViaWiFi                   else               return  notReachable                    In any method use the below condition if currentReachabilityStatus     notReachable          Network Unavailable   else          Network Available

User · Answer

Create a new Swift file within your project  name it Reachability swift  Cut  amp  paste the following code into it to create your class  import Foundation import SystemConfiguration  open class Reachability            class func isConnectedToNetwork   - gt  Bool                    var zeroAddress   sockaddr in           zeroAddress sin len   UInt8 MemoryLayout size ofValue  zeroAddress           zeroAddress sin family   sa family t AF INET                   let defaultRouteReachability   withUnsafePointer to   amp zeroAddress                 0 withMemoryRebound to  sockaddr self  capacity  1   zeroSockAddress in                 SCNetworkReachabilityCreateWithAddress nil  zeroSockAddress                                           var flags   SCNetworkReachabilityFlags           if  SCNetworkReachabilityGetFlags defaultRouteReachability    amp flags                return false                   let isReachable    flags rawValue  amp  UInt32 kSCNetworkFlagsReachable      0         let needsConnection    flags rawValue  amp  UInt32 kSCNetworkFlagsConnectionRequired      0         return  isReachable  amp  amp   needsConnection           you can call Reachability from anywhere of your code  just like if Reachability isConnectedToNetwork         print  quot Network is connected quot     else       print  quot Network is not connected quot

User · Answer

Create a new Swift file within your project  name it Reachability swift  Cut  amp  paste the following code into it to create your class   import Foundation import SystemConfiguration  public class Reachability        class func isConnectedToNetwork   - gt  Bool            var zeroAddress   sockaddr in sin len  0  sin family  0  sin port  0  sin addr  in addr s addr  0   sin zero   0  0  0  0  0  0  0  0           zeroAddress sin len   UInt8 sizeofValue zeroAddress           zeroAddress sin family   sa family t AF INET           let defaultRouteReachability   withUnsafePointer  amp zeroAddress                SCNetworkReachabilityCreateWithAddress kCFAllocatorDefault  UnsafePointer  0                      var flags  SCNetworkReachabilityFlags   SCNetworkReachabilityFlags rawValue  0          if SCNetworkReachabilityGetFlags defaultRouteReachability    amp flags     false                return false                    let isReachable   flags     Reachable         let needsConnection   flags     ConnectionRequired          return isReachable  amp  amp   needsConnection            You can check internet connection anywhere in your project using this code   if Reachability isConnectedToNetwork         println  Internet connection OK     else       println  Internet connection FAILED       If the user is not connected to the internet  you may want to show them an alert dialog to notify them   if Reachability isConnectedToNetwork         println  Internet connection OK     else       println  Internet connection FAILED       var alert   UIAlertView title   No Internet Connection   message   Make sure your device is connected to the internet    delegate  nil  cancelButtonTitle   OK       alert show       Explanation   We are making a reusable public class and a method which can be used anywhere in the project to check internet connectivity  We require adding Foundation and System Configuration frameworks    In the public class Reachability  the method isConnectedToNetwork   - gt  Bool     will return a bool value about internet connectivity  We use a if loop to perform required actions on case  I hope this is enough  Cheers

User · Answer

Apple has introduced Network Framework in iOS12   import Foundation import Network  class NetworkReachability       var pathMonitor  NWPathMonitor     var path  NWPath     lazy var pathUpdateHandler    NWPath  - gt  Void      path in     self path   path     if path status    NWPath Status satisfied           print  Connected         else if path status    NWPath Status unsatisfied           print  unsatisfied         else if path status    NWPath Status requiresConnection           print  requiresConnection             let backgroudQueue   DispatchQueue global qos   background   init         pathMonitor   NWPathMonitor       pathMonitor pathUpdateHandler   self pathUpdateHandler     pathMonitor start queue  backgroudQueue          func isNetworkAvailable   - gt  Bool           if let path   self path              if path status    NWPath Status satisfied               return true                              return false

User · Answer

struct Connectivity       static let sharedInstance   NetworkReachabilityManager        static var isConnectedToInternet Bool           return self sharedInstance isReachable          Now call it if Connectivity isConnectedToInternet      call your methods here     else      show alert for noInternet

User · Answer

Although it does not directly answers your question  I would like to mention Apple recentely had this talk   https   developer apple com videos play wwdc2018 714   At around 09 55 he talks about doing this stuff you are asking about    Check connection If connection -  Do something If no connection -  Do something else  wait  retry     However  this has a few pitfalls    What if in step 2 it says it has a connection  but 0 5 seconds later he hasn t  What if the user is behind a proxy Last but not least  what if some answers here can not determine the connectivity right   I am sure that if you rapidly switch your connection  go to wi-fi and turn it off  just make it complicated   it almost never can correctly determine whetever I got a connection or not   Quote from the video   There is no way to guarentee whether a future operation will succeed or not    The following points are some best practices according to Apple    set waitsForConnectivity to true  https   developer apple com documentation foundation urlsessionconfiguration 2908812-waitsforconnectivity  respond to the delegate method taskIsWaitingForConnectivity  https   developer apple com documentation foundation urlsessiontaskdelegate 2908819-urlsession   This is Apple s recommended way to check for connectivity  as mentioned in the video at 33 25    According to the talk  there shouldn t be any reason to pre-check whetever you got internet connection or not  since it may not be accurate at the time you send your request to the server

[ios] Check for internet connection with Swift

Examples related to ios

Examples related to swift

Examples related to xcode

Examples related to reachability