Check network status in Swift

Question

How can I check network status in Swift? In Objective-C Reachability.h .m files were available. What now? How can I check whether I am online or offline?

Answer 1

If you're looking for a Swift implementation of Apple's Reachability class, you could take a look at this:

http://github.com/ashleymills/Reachability.swift

It's a drop in class, using notifications and closures.

Answer 2

You can still use Reachability in Swift. Logan has a good answer on how to add objective-c files to a bridging header here. Once you have your bridging header set up, you can call the Reachability methods from your Swift code. Something like this would work:

class func hasConnectivity() -> Bool {
    let reachability: Reachability = Reachability.reachabilityForInternetConnection()
    let networkStatus: Int = reachability.currentReachabilityStatus().value
    return networkStatus != 0
}

Answer 3

i will give best solution, hope its helpful.

import Foundation
import SystemConfiguration

public class Reachability {
    class func isConnectedToNetwork()->Bool{

        var Status:Bool = false
        let url = NSURL(string: "http://google.com/")
        let request = NSMutableURLRequest(URL: url!)
        request.HTTPMethod = "HEAD"
        request.cachePolicy = NSURLRequestCachePolicy.ReloadIgnoringLocalAndRemoteCacheData
        request.timeoutInterval = 10.0

        var response: NSURLResponse?

        var data = NSURLConnection.sendSynchronousRequest(request, returningResponse: &response, error: nil) as NSData?

        if let httpResponse = response as? NSHTTPURLResponse {
            if httpResponse.statusCode == 200 {
                Status = true
            }

        }
        else
        {

            let alert = UIAlertView(title: "No Internet Connection", message: "Make sure your device is connected to the internet.", delegate: nil, cancelButtonTitle: "OK")
            alert.show()
        }

        return Status
    }
}

How to access or call in other classes:

 if Reachability.isConnectedToNetwork() == true {

// write your code

}

Answer 4

First add Reachability.swift file into your project that you can get from here below link

https://github.com/pavangandhi/TestProject/tree/master/TestProject/AppConstants

Use the below given code to test app is connected with internet or not :

// check internet connectivity if its returns YES means its connect with internet, Wifi and cellular data

class func isConnectedToNetwork() -> Bool 
{
    let reachability = Reachability.reachabilityForInternetConnection()

    if reachability.isReachable() || reachability.isReachableViaWiFi() || reachability.isReachableViaWWAN()
    {
        return true
    }
    else
    {
        return false
    }
}

Note : You need to add Reachability.swift file into your project before adding this code.

Answer 5

I've been using the code from this article successfully. Though after releasing my app I realized that google.com is blocked in China and this code is flawed in countries where Google is blocked. So I adjusted it to check a second URL if the first one fails. If the second one succeeds, then I save it as the preferred URL.

Edit: While the following code is still valid, after using it in the wild I noticed that testing the network by loading a URL can cause unacceptable delays when the user is connected to a weak (non-4G) cellular data connection. I now use the Reachability class as suggested by @Ashley Mills above.

public class Network {

class func isConnectedToNetwork() -> Bool{
    let defaults = NSUserDefaults.standardUserDefaults()

    var networkStatus:Bool = false
    let urlA = NSURL(string: "http://google.com/")
    let urlB = NSURL(string: "http://baidu.com/")

    let urlDict:[String:NSURL] = ["A":urlA!, "B":urlB!]

    var preference = "A"

    if let temp = defaults.stringForKey("preferredNetworkURL") {
        preference = temp //check the last successful URL or A by default
    } else {
        defaults.setObject(preference, forKey: "preferredNetworkURL")
    }

    networkStatus = Network.fetchURL(urlDict[preference]!, pref:preference)

    if networkStatus == false {
        //check the URL which hasn't been checked
        if preference == "A" {
            preference = "B"
        } else {
            preference = "A"
        }
        networkStatus = Network.fetchURL(urlDict[preference]!, pref:preference)
        println("NETWORK STATUS: \(networkStatus)")
        //if preference "B" returns true, then Baidu.com is available and user is likely in a country where Google is blocked
    }

    return networkStatus
}

class func fetchURL(url:NSURL, pref:String) -> Bool {
    println("URL PREFERENCE: \(pref)")
    let defaults = NSUserDefaults.standardUserDefaults()
    let request = NSMutableURLRequest(URL: url)
    request.HTTPMethod = "HEAD"
    request.cachePolicy = NSURLRequestCachePolicy.ReloadIgnoringLocalAndRemoteCacheData
    request.timeoutInterval = 10.0

    var response: NSURLResponse?

    var data = NSURLConnection.sendSynchronousRequest(request, returningResponse: &response, error: nil) as NSData?

    if let httpResponse = response as? NSHTTPURLResponse {
        if httpResponse.statusCode == 200 {
            defaults.setObject(pref, forKey: "preferredNetworkURL") //remember the URL that succeeded and check it first next time
            return true
        } else {
            return false
        }
    } else {
        return false
    }
}

}

Then anywhere I need to check for a network connection I call:

if Network.isConnectedToNetwork() == true {
    //perform network dependent actions
} else {
    var alert = UIAlertView(title: "Network Unavailable", message: "Please connect to the internet in order to proceed.", delegate: self, cancelButtonTitle: "OK")
    alert.show()
}

Answer 6

Checking the Internet connection availability in (iOS) Xcode 7.2 , Swift 2.0

This is simple method for checking the network availability. I managed to translate it to Swift 2.0 and here the final code. The existing Apple Reachability class and other third party libraries seemed to be too complicated to translate to Swift. This works for both 3G and WiFi connections. Don’t forget to add “SystemConfiguration.framework” to your network.

 //Create new swift class file Reachability in your project.

 import SystemConfiguration


 public class InternetReachability {

  class func isConnectedToNetwork() -> 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(&zeroAddress) {
              SCNetworkReachabilityCreateWithAddress(nil, UnsafePointer($0)).takeRetainedValue()
        }

       var flags: SCNetworkReachabilityFlags = 0
        if SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) == 0 {
            return false
       }

       let isReachable = (flags & UInt32(kSCNetworkFlagsReachable)) != 0
       let needsConnection = (flags & UInt32(kSCNetworkFlagsConnectionRequired)) != 0

       return isReachable && !needsConnection
  }

  }

// Check network connectivity from anywhere in project by using this code.

   if InternetReachability.isConnectedToNetwork() == true {
          print("Internet connection OK")
    } else {
         print("Internet connection FAILED")
  }

Answer 7

@blwinters I rewrote this code to work with closures and work in the latest version of swift.

import AVFoundation
public class Network {

    class func isConnectedToNetwork(resultHandler: (isTrue: Bool) -> Void) {
        let defaults = NSUserDefaults.standardUserDefaults()

        let urlA = NSURL(string: "http://google.com/")
        let urlB = NSURL(string: "http://baidu.com/")

        let urlDict:[String:NSURL] = ["A":urlA!, "B":urlB!]

        var preference = "A"

        if let temp = defaults.stringForKey("preferredNetworkURL") {
            preference = temp //check the last successful URL or A by default
        } else {
            defaults.setObject(preference, forKey: "preferredNetworkURL")
        }

        Network.fetchURL(urlDict[preference]!, pref:preference) {
            isTrue in
            if isTrue == true {
                print("NETWORK STATUS: \(isTrue)")
                resultHandler(isTrue: isTrue)
            } else {
                //check the URL which hasn't been checked
                if preference == "A" {
                    preference = "B"
                } else {
                    preference = "A"
                }
                Network.fetchURL(urlDict[preference]!, pref:preference) {
                    isTrue in
                    print("NETWORK STATUS: \(isTrue)")
                    resultHandler(isTrue: isTrue)
                }
                //if preference "B" returns true, then Baidu.com is available and user is likely in a country where Google is blocked
            }
        }
    }

    class func fetchURL(url:NSURL, pref:String, resultHandler: (isTrue: Bool) -> Void) {
        print("URL PREFERENCE: \(pref)")
        let defaults = NSUserDefaults.standardUserDefaults()
        let request = NSMutableURLRequest(URL: url)
        request.HTTPMethod = "HEAD"
        request.cachePolicy = NSURLRequestCachePolicy.ReloadIgnoringLocalAndRemoteCacheData
        request.timeoutInterval = 10.0

        var returnBool = false
        let session = NSURLSession(configuration: .defaultSessionConfiguration())
        let dataTask = session.dataTaskWithRequest(request) {
            (let data, let response, let error) in
            if let httpResponse = response as? NSHTTPURLResponse {
                if httpResponse.statusCode == 200 {
                    defaults.setObject(pref, forKey: "preferredNetworkURL") //remember the URL that succeeded and check it first next time
                    returnBool = true
                    resultHandler(isTrue: returnBool)
                } else {
                    returnBool = false
                    resultHandler(isTrue: returnBool)
                }
            } else {
                returnBool = false
                resultHandler(isTrue: returnBool)
            }
        }
        dataTask.resume()
    }
}

Then you use it like so

    Network.isConnectedToNetwork(){
        isConnected in
        if isConnected == true {
            dispatch_async(dispatch_get_main_queue()) {
                    //perform network dependent actions
                    //can remove the dispatch async if non UI actions
            }
        } else {
            dispatch_async(dispatch_get_main_queue()) {
                let alertController = UIAlertController(title: "Network Unavailable", message: "Please connect to the internet in order to proceed.", preferredStyle: UIAlertControllerStyle.Alert)
                alertController.addAction(UIAlertAction(title: "OK", style: UIAlertActionStyle.Default,handler: nil))
                self.presentViewController(alertController, animated: true, completion: nil)
            }
        }
    }