How to check for an active Internet connection on iOS or OSX?

I would like to check to see if I have an Internet connection on iOS using the Cocoa Touch libraries or on OSX using the Cocoa libraries.

I came up with a way to do this using an NSURL. The way I did it seems a bit unreliable (because even Google could one day be down and relying on a third party seems bad), and while I could check to see for a response from some other websites if Google didn’t respond, it does seem wasteful and an unnecessary overhead on my application.

  • Comparing Two Arrays
  • Core Data: Fetch result from multiple entities or relationship
  • NSArray of united Arrays
  • Split an NSString into an array in Objective-C
  • iPhone TBXML Looping And Parsing Data
  • How do I read image files directly from a zip without extracting to disk?
  • - (BOOL) connectedToInternet
    {
        NSString *URLString = [NSString stringWithContentsOfURL:[NSURL URLWithString:@"http://www.google.com"]];
        return ( URLString != NULL ) ? YES : NO;
    }
    

    Is what I have done bad? (Not to mention stringWithContentsOfURL is deprecated in iOS 3.0 and OSX 10.4) and if so, what is a better way to accomplish this?

    30 Solutions Collect From Internet About “How to check for an active Internet connection on iOS or OSX?”

    METHOD 1: Use a simple (ARC and GCD compatible) class to do it

    1) Add SystemConfiguration framework to the project but don’t worry about including it anywhere

    2) Add Tony Million’s version of Reachability.h and Reachability.m to the project (found here: https://github.com/tonymillion/Reachability)

    3) Update the interface section

    #import "Reachability.h"
    
    // Add this to the interface in the .m file of your view controller
    @interface MyViewController ()
    {
        Reachability *internetReachableFoo;
    }
    @end
    

    4) Then implement this method in the .m file of your view controller which you can call

    // Checks if we have an internet connection or not
    - (void)testInternetConnection
    {   
        internetReachableFoo = [Reachability reachabilityWithHostname:@"www.google.com"];
    
        // Internet is reachable
        internetReachableFoo.reachableBlock = ^(Reachability*reach)
        {
            // Update the UI on the main thread
            dispatch_async(dispatch_get_main_queue(), ^{
                NSLog(@"Yayyy, we have the interwebs!");
            });
        };
    
        // Internet is not reachable
        internetReachableFoo.unreachableBlock = ^(Reachability*reach)
        {
            // Update the UI on the main thread
            dispatch_async(dispatch_get_main_queue(), ^{
                NSLog(@"Someone broke the internet :(");
            });
        };
    
        [internetReachableFoo startNotifier];
    }
    

    METHOD 2: Do it yourself the old way using Apple’s outdated Reachability class

    1) Add SystemConfiguration framework to the project but don’t worry about including it anywhere

    2) Add Apple’s version of Reachability.h and Reachability.m to the project (you can get those here)

    3) Add @class Reachability; to the .h file of where you are implementing the code

    4) Create a couple instances to check in the interface section of the .h file:

    Reachability* internetReachable;
    Reachability* hostReachable;
    

    5) Add a method in the .h for when the network status updates:

    -(void) checkNetworkStatus:(NSNotification *)notice;
    

    6) Add #import "Reachability.h" to the .m file where you are implementing the check

    7) In the .m file of where you are implementing the check, you can place this in one of the first methods called (init or viewWillAppear or viewDidLoad etc):

    -(void) viewWillAppear:(BOOL)animated
    {
        // check for internet connection
        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(checkNetworkStatus:) name:kReachabilityChangedNotification object:nil];
    
        internetReachable = [Reachability reachabilityForInternetConnection];
        [internetReachable startNotifier];
    
        // check if a pathway to a random host exists
        hostReachable = [Reachability reachabilityWithHostName:@"www.apple.com"];
        [hostReachable startNotifier];
    
        // now patiently wait for the notification
    }
    

    8) Set up the method for when the notification gets sent and set whatever checks or call whatever methods you may have set up (in my case, I just set a BOOL)

    -(void) checkNetworkStatus:(NSNotification *)notice
    {
        // called after network status changes
        NetworkStatus internetStatus = [internetReachable currentReachabilityStatus];
        switch (internetStatus)
        {
            case NotReachable:
            {
                NSLog(@"The internet is down.");
                self.internetActive = NO;
    
                break;
            }
            case ReachableViaWiFi:
            {
                NSLog(@"The internet is working via WIFI.");
                self.internetActive = YES;
    
                break;
            }
            case ReachableViaWWAN:
            {
                NSLog(@"The internet is working via WWAN.");
                self.internetActive = YES;
    
                break;
            }
        }
    
        NetworkStatus hostStatus = [hostReachable currentReachabilityStatus];
        switch (hostStatus)
        {
            case NotReachable:
            {
                NSLog(@"A gateway to the host server is down.");
                self.hostActive = NO;
    
                break;
            }
            case ReachableViaWiFi:
            {
                NSLog(@"A gateway to the host server is working via WIFI.");
                self.hostActive = YES;
    
                break;
            }
            case ReachableViaWWAN:
            {
                NSLog(@"A gateway to the host server is working via WWAN.");
                self.hostActive = YES;
    
                break;
            }
        }
    }
    

    9) In your dealloc or viewWillDisappear or similar method, remove yourself as an observer

    -(void) viewWillDisappear:(BOOL)animated
    {
        [[NSNotificationCenter defaultCenter] removeObserver:self];
    }
    

    Note: There might be an instance using viewWillDisappear where you receive a memory warning and the observer never gets unregistered so you should account for that as well.


    Note: The domain you use doesn’t matter. It’s just testing for a gateway to any domain.

    Important Note: The Reachability class is one of the most used classes in projects so you might run into naming conflicts with other projects like ShareKit. If this happens, you’ll have to rename one of the pairs of Reachability.h and Reachability.m files to something else to resolve the issue.

    I like to keep things simple. The way I do this is:

    //Class.h
    #import "Reachability.h"
    #import <SystemConfiguration/SystemConfiguration.h>
    
    - (BOOL)connected;
    
    //Class.m
    - (BOOL)connected
    {
        Reachability *reachability = [Reachability reachabilityForInternetConnection];
        NetworkStatus networkStatus = [reachability currentReachabilityStatus];
        return networkStatus != NotReachable;
    }
    

    Then, I use this whenever I want to see if I have a connection:

    if (![self connected]) {
        // Not connected
    } else {
        // Connected. Do some Internet stuff
    }
    

    This method doesn’t wait for changed network statuses in order to do stuff. It just tests the status when you ask it to.

    Using Apple’s Reachability code, I created a function that’ll check this correctly without you having to include any classes.

    Include the SystemConfiguration.framework in your project.

    Make some imports:

    #import <sys/socket.h>
    #import <netinet/in.h>
    #import <SystemConfiguration/SystemConfiguration.h>
    

    Now just call this function:

    /*
    Connectivity testing code pulled from Apple's Reachability Example: https://developer.apple.com/library/content/samplecode/Reachability
     */
    +(BOOL)hasConnectivity {
        struct sockaddr_in zeroAddress;
        bzero(&zeroAddress, sizeof(zeroAddress));
        zeroAddress.sin_len = sizeof(zeroAddress);
        zeroAddress.sin_family = AF_INET;
    
        SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr*)&zeroAddress);
        if (reachability != NULL) {
            //NetworkStatus retVal = NotReachable;
            SCNetworkReachabilityFlags flags;
            if (SCNetworkReachabilityGetFlags(reachability, &flags)) {
                if ((flags & kSCNetworkReachabilityFlagsReachable) == 0)
                {
                    // If target host is not reachable
                    return NO;
                }
    
                if ((flags & kSCNetworkReachabilityFlagsConnectionRequired) == 0)
                {
                    // If target host is reachable and no connection is required
                    //  then we'll assume (for now) that your on Wi-Fi
                    return YES;
                }
    
    
                if ((((flags & kSCNetworkReachabilityFlagsConnectionOnDemand ) != 0) ||
                     (flags & kSCNetworkReachabilityFlagsConnectionOnTraffic) != 0))
                {
                    // ... and the connection is on-demand (or on-traffic) if the
                    //     calling application is using the CFSocketStream or higher APIs.
    
                    if ((flags & kSCNetworkReachabilityFlagsInterventionRequired) == 0)
                    {
                        // ... and no [user] intervention is needed
                        return YES;
                    }
                }
    
                if ((flags & kSCNetworkReachabilityFlagsIsWWAN) == kSCNetworkReachabilityFlagsIsWWAN)
                {
                    // ... but WWAN connections are OK if the calling application
                    //     is using the CFNetwork (CFSocketStream?) APIs.
                    return YES;
                }
            }
        }
    
        return NO;
    }
    

    And it’s iOS 5 tested for you.

    This used to be the correct answer, but it is now outdated as you should subscribe to notifications for reachability instead. This method checks synchronously:


    You can use Apple’s Reachability class. It will also allow you to check if Wi-Fi is enabled:

    Reachability* reachability = [Reachability sharedReachability];
    [reachability setHostName:@"www.example.com"];    // Set your host name here
    NetworkStatus remoteHostStatus = [reachability remoteHostStatus];
    
    if (remoteHostStatus == NotReachable) { }
    else if (remoteHostStatus == ReachableViaWiFiNetwork) { }
    else if (remoteHostStatus == ReachableViaCarrierDataNetwork) { }
    

    The Reachability class is not shipped with the SDK, but rather a part of this Apple sample application. Just download it, and copy Reachability.h/m to your project. Also, you have to add the SystemConfiguration framework to your project.

    Here’s a very simple answer:

    NSURL *scriptUrl = [NSURL URLWithString:@"http://www.google.com/m"];
    NSData *data = [NSData dataWithContentsOfURL:scriptUrl];
    if (data)
        NSLog(@"Device is connected to the Internet");
    else
        NSLog(@"Device is not connected to the Internet");
    

    The URL should point to an extremely small website. I use Google’s mobile website here, but if I had a reliable web server I’d upload a small file with just one character in it for maximum speed.

    If checking whether the device is somehow connected to the Internet is everything you want to do, I’d definitely recommend using this simple solution. If you need to know how the user is connected, using Reachability is the way to go.

    Careful: This will briefly block your thread while it loads the website. In my case, this wasn’t a problem, but you should consider this (credits to Brad for pointing this out).

    Here is how I do it in my apps: While a 200 status response code doesn’t guarantee anything, it is stable enough for me. This doesn’t require as much loading as the NSData answers posted here, as mine just checks the HEAD response.

    Swift Code

    func checkInternet(flag:Bool, completionHandler:(internet:Bool) -> Void)
    {
        UIApplication.sharedApplication().networkActivityIndicatorVisible = true
    
        let url = NSURL(string: "http://www.appleiphonecell.com/")
        let request = NSMutableURLRequest(URL: url!)
    
        request.HTTPMethod = "HEAD"
        request.cachePolicy = NSURLRequestCachePolicy.ReloadIgnoringLocalAndRemoteCacheData
        request.timeoutInterval = 10.0
    
        NSURLConnection.sendAsynchronousRequest(request, queue:NSOperationQueue.mainQueue(), completionHandler:
        {(response: NSURLResponse!, data: NSData!, error: NSError!) -> Void in
    
            UIApplication.sharedApplication().networkActivityIndicatorVisible = false
    
            let rsp = response as! NSHTTPURLResponse?
    
            completionHandler(internet:rsp?.statusCode == 200)
        })
    }
    
    func yourMethod()
    {
        self.checkInternet(false, completionHandler:
        {(internet:Bool) -> Void in
    
            if (internet)
            {
                // "Internet" aka Apple's region universal URL reachable
            }
            else
            {
                // No "Internet" aka Apple's region universal URL un-reachable
            }
        })
    }
    

    Objective-C Code

    typedef void(^connection)(BOOL);
    
    - (void)checkInternet:(connection)block
    {
        NSURL *url = [NSURL URLWithString:@"http://www.appleiphonecell.com/"];
        NSMutableURLRequest *headRequest = [NSMutableURLRequest requestWithURL:url];
        headRequest.HTTPMethod = @"HEAD";
    
        NSURLSessionConfiguration *defaultConfigObject = [NSURLSessionConfiguration ephemeralSessionConfiguration];
        defaultConfigObject.timeoutIntervalForResource = 10.0;
        defaultConfigObject.requestCachePolicy = NSURLRequestReloadIgnoringLocalAndRemoteCacheData;
    
        NSURLSession *defaultSession = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue: [NSOperationQueue mainQueue]];
    
        NSURLSessionDataTask *dataTask = [defaultSession dataTaskWithRequest:headRequest
            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error)
        {
            if (!error && response)
            {
                block([(NSHTTPURLResponse *)response statusCode] == 200);
            }
        }];
        [dataTask resume];
    }
    
    - (void)yourMethod
    {
        [self checkInternet:^(BOOL internet)
        {
             if (internet)
             {
                 // "Internet" aka Apple's region universal URL reachable
             }
             else
             {
                 // No "Internet" aka Apple's region universal URL un-reachable
             }
        }];
    }
    

    Apple supplies sample code to check for different types of network availability. Alternatively there is an example in the iPhone developers cookbook.

    Note: Please see @KHG’s comment on this answer regarding the use of Apple’s reachability code.

    You could use Reachability by  (available here).

    #import "Reachability.h"
    
    - (BOOL)networkConnection {
        return [[Reachability reachabilityWithHostName:@"www.google.com"] currentReachabilityStatus];
    }
    
    if ([self networkConnection] == NotReachable) { /* No Network */ } else { /* Network */ } //Use ReachableViaWiFi / ReachableViaWWAN to get the type of connection.
    

    Apple provides a sample app which does exactly this:

    Reachability

    Only the Reachability class has been updated. You can now use:

    Reachability* reachability = [Reachability reachabilityWithHostName:@"www.apple.com"];
    NetworkStatus remoteHostStatus = [reachability currentReachabilityStatus];
    
    if (remoteHostStatus == NotReachable) { NSLog(@"not reachable");}
    else if (remoteHostStatus == ReachableViaWWAN) { NSLog(@"reachable via wwan");}
    else if (remoteHostStatus == ReachableViaWiFi) { NSLog(@"reachable via wifi");}
    

    A version on Reachability for iOS 5 is darkseed/Reachability.h. It’s not mine! =)

    There’s a nice-looking, ARC- and GCD-using modernization of Reachability here:

    Reachability

    If you’re using AFNetworking you can use its own implementation for internet reachability status.

    The best way to use AFNetworking is to subclass the AFHTTPClient class and use this class to do your network connections.

    One of the advantages of using this approach is that you can use blocks to set the desired behavior when the reachability status changes. Supposing that I’ve created a singleton subclass of AFHTTPClient (as said on the “Subclassing notes” on AFNetworking docs) named BKHTTPClient, I’d do something like:

    BKHTTPClient *httpClient = [BKHTTPClient sharedClient];
    [httpClient setReachabilityStatusChangeBlock:^(AFNetworkReachabilityStatus status)
    {
        if (status == AFNetworkReachabilityStatusNotReachable) 
        {
        // Not reachable
        }
        else
        {
            // Reachable
        }
    }];
    

    You could also check for Wi-Fi or WLAN connections specifically using the AFNetworkReachabilityStatusReachableViaWWAN and AFNetworkReachabilityStatusReachableViaWiFi enums (more here).

    I’ve used the code in this discussion, and it seems to work fine (read the whole thread!).

    I haven’t tested it exhaustively with every conceivable kind of connection (like ad hoc Wi-Fi).

    Very simple…. Try these steps:

    Step 1: Add the SystemConfiguration framework into your project.


    Step 2: Import the following code into your header file.

    #import <SystemConfiguration/SystemConfiguration.h>
    

    Step 3: Use the following method

    • Type 1:

      - (BOOL) currentNetworkStatus {
          [UIApplication sharedApplication].networkActivityIndicatorVisible = NO;
          BOOL connected;
          BOOL isConnected;
          const char *host = "www.apple.com";
          SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithName(NULL, host);
          SCNetworkReachabilityFlags flags;
          connected = SCNetworkReachabilityGetFlags(reachability, &flags);
          isConnected = NO;
          isConnected = connected && (flags & kSCNetworkFlagsReachable) && !(flags & kSCNetworkFlagsConnectionRequired);
          CFRelease(reachability);
          return isConnected;
      }
      

    • Type 2:

      Import header : #import "Reachability.h"

      - (BOOL)currentNetworkStatus
      {
          Reachability *reachability = [Reachability reachabilityForInternetConnection];
          NetworkStatus networkStatus = [reachability currentReachabilityStatus];
          return networkStatus != NotReachable;
      }
      

    Step 4: How to use:

    - (void)CheckInternet
    {
        BOOL network = [self currentNetworkStatus];
        if (network)
        {
            NSLog(@"Network Available");
        }
        else
        {
            NSLog(@"No Network Available");
        }
    }
    
    -(void)newtworkType {
    
     NSArray *subviews = [[[[UIApplication sharedApplication] valueForKey:@"statusBar"] valueForKey:@"foregroundView"]subviews];
    NSNumber *dataNetworkItemView = nil;
    
    for (id subview in subviews) {
        if([subview isKindOfClass:[NSClassFromString(@"UIStatusBarDataNetworkItemView") class]]) {
            dataNetworkItemView = subview;
            break;
        }
    }
    
    
    switch ([[dataNetworkItemView valueForKey:@"dataNetworkType"]integerValue]) {
        case 0:
            NSLog(@"No wifi or cellular");
            break;
    
        case 1:
            NSLog(@"2G");
            break;
    
        case 2:
            NSLog(@"3G");
            break;
    
        case 3:
            NSLog(@"4G");
            break;
    
        case 4:
            NSLog(@"LTE");
            break;
    
        case 5:
            NSLog(@"Wifi");
            break;
    
    
        default:
            break;
    }
    }
    
    - (void)viewWillAppear:(BOOL)animated
    {
        NSString *URL = [NSString stringWithContentsOfURL:[NSURL URLWithString:@"http://www.google.com"]];
    
        return (URL != NULL ) ? YES : NO;
    }
    

    Or use the Reachability class.

    There are two ways to check Internet availability using the iPhone SDK:

    1. Check the Google page is opened or not.

    2. Reachability Class

    For more information, please refer to Reachability (Apple Developer).

    Use http://huytd.github.io/datatify/. It’s easier than adding libraries and write code by yourself.

    First: Add CFNetwork.framework in framework

    Code: ViewController.m

    #import "Reachability.h"
    
    - (void)viewWillAppear:(BOOL)animated
    {
        Reachability *r = [Reachability reachabilityWithHostName:@"www.google.com"];
        NetworkStatus internetStatus = [r currentReachabilityStatus];
    
        if ((internetStatus != ReachableViaWiFi) && (internetStatus != ReachableViaWWAN))
        {
            /// Create an alert if connection doesn't work
            UIAlertView *myAlert = [[UIAlertView alloc]initWithTitle:@"No Internet Connection"   message:NSLocalizedString(@"InternetMessage", nil)delegate:nil cancelButtonTitle:@"Ok" otherButtonTitles:nil];
            [myAlert show];
            [myAlert release];
        }
        else
        {
             NSLog(@"INTERNET IS CONNECT");
        }
    }
    

    First download the reachability class and put reachability.h and reachabilty.m file in your Xcode.

    The best way is to make a common Functions class (NSObject) so that you can use it any class. These are two methods for a network connection reachability check:

    +(BOOL) reachabiltyCheck
    {
        NSLog(@"reachabiltyCheck");
        BOOL status =YES;
        [[NSNotificationCenter defaultCenter] addObserver:self
                                              selector:@selector(reachabilityChanged:)
                                              name:kReachabilityChangedNotification
                                              object:nil];
        Reachability * reach = [Reachability reachabilityForInternetConnection];
        NSLog(@"status : %d",[reach currentReachabilityStatus]);
        if([reach currentReachabilityStatus]==0)
        {
            status = NO;
            NSLog(@"network not connected");
        }
        reach.reachableBlock = ^(Reachability * reachability)
        {
            dispatch_async(dispatch_get_main_queue(), ^{
            });
        };
        reach.unreachableBlock = ^(Reachability * reachability)
        {
            dispatch_async(dispatch_get_main_queue(), ^{
            });
        };
        [reach startNotifier];
        return status;
    }
    
    +(BOOL)reachabilityChanged:(NSNotification*)note
    {
        BOOL status =YES;
        NSLog(@"reachabilityChanged");
        Reachability * reach = [note object];
        NetworkStatus netStatus = [reach currentReachabilityStatus];
        switch (netStatus)
        {
            case NotReachable:
                {
                    status = NO;
                    NSLog(@"Not Reachable");
                }
                break;
    
            default:
                {
                    if (!isSyncingReportPulseFlag)
                    {
                        status = YES;
                        isSyncingReportPulseFlag = TRUE;
                        [DatabaseHandler checkForFailedReportStatusAndReSync];
                    }
                }
                break;
        }
        return status;
    }
    
    + (BOOL) connectedToNetwork
    {
        // Create zero addy
        struct sockaddr_in zeroAddress;
        bzero(&zeroAddress, sizeof(zeroAddress));
        zeroAddress.sin_len = sizeof(zeroAddress);
        zeroAddress.sin_family = AF_INET;
    
        // Recover reachability flags
        SCNetworkReachabilityRef defaultRouteReachability = SCNetworkReachabilityCreateWithAddress(NULL, (struct sockaddr *)&zeroAddress);
        SCNetworkReachabilityFlags flags;
        BOOL didRetrieveFlags = SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags);
        CFRelease(defaultRouteReachability);
        if (!didRetrieveFlags)
        {
            NSLog(@"Error. Could not recover network reachability flags");
            return NO;
        }
        BOOL isReachable = flags & kSCNetworkFlagsReachable;
        BOOL needsConnection = flags & kSCNetworkFlagsConnectionRequired;
        BOOL nonWiFi = flags & kSCNetworkReachabilityFlagsTransientConnection;
        NSURL *testURL = [NSURL URLWithString:@"http://www.apple.com/"];
        NSURLRequest *testRequest = [NSURLRequest requestWithURL:testURL  cachePolicy:NSURLRequestReloadIgnoringLocalCacheData timeoutInterval:20.0];
        NSURLConnection *testConnection = [[NSURLConnection alloc] initWithRequest:testRequest delegate:self];
        return ((isReachable && !needsConnection) || nonWiFi) ? (testConnection ? YES : NO) : NO;
    }
    

    Now you can check network connection in any class by calling this class method.

    To do this yourself is extremely simple. The following method will work. Just be sure to not allow a hostname protocol such as HTTP, HTTPS, etc. to be passed in with the name.

    -(BOOL)hasInternetConnection:(NSString*)urlAddress
    {
        SCNetworkReachabilityRef ref = SCNetworkReachabilityCreateWithName(kCFAllocatorDefault, [urlAddress UTF8String]);
        SCNetworkReachabilityFlags flags;
        if (!SCNetworkReachabilityGetFlags(ref, &flags))
        {
            return NO;
        }
        return flags & kSCNetworkReachabilityFlagsReachable;
    }
    

    It is quick simple and painless.

    I found it simple and easy to use library SimplePingHelper.

    Sample code: chrishulbert/SimplePingHelper (GitHub)

    The Reachability class is OK to find out if the Internet connection is available to a device or not…

    But in case of accessing an intranet resource:

    Pinging the intranet server with the reachability class always returns true.

    So a quick solution in this scenario would be to create a web method called pingme along with other webmethods on the service.
    The pingme should return something.

    So I wrote the following method on common functions

    -(BOOL)PingServiceServer
    {
        NSURL *url=[NSURL URLWithString:@"http://www.serveraddress/service.asmx/Ping"];
    
        NSMutableURLRequest *urlReq=[NSMutableURLRequest requestWithURL:url];
    
        [urlReq setTimeoutInterval:10];
    
        NSURLResponse *response;
    
        NSError *error = nil;
    
        NSData *receivedData = [NSURLConnection sendSynchronousRequest:urlReq
                                                     returningResponse:&response
                                                                 error:&error];
        NSLog(@"receivedData:%@",receivedData);
    
        if (receivedData !=nil)
        {
            return YES;
        }
        else
        {
            NSLog(@"Data is null");
            return NO;
        }
    }
    

    The above method was so useful for me, so whenever I try to send some data to the server I always check the reachability of my intranet resource using this low timeout URLRequest.

    I think this one is the best answer.

    “Yes” means connected. “No” means disconnected.

    #import "Reachability.h"
    
     - (BOOL)canAccessInternet
    {
        Reachability *IsReachable = [Reachability reachabilityForInternetConnection];
        NetworkStatus internetStats = [IsReachable currentReachabilityStatus];
    
        if (internetStats == NotReachable)
        {
            return NO;
        }
        else
        {
            return YES;
        }
    }
    
    1. Download the Reachability file, https://gist.github.com/darkseed/1182373

    2. And add CFNetwork.framework and ‘SystemConfiguration.framework’ in framework

    3. Do #import “Reachability.h”

    First: Add CFNetwork.framework in framework

    Code: ViewController.m

    - (void)viewWillAppear:(BOOL)animated
    {
        Reachability *r = [Reachability reachabilityWithHostName:@"www.google.com"];
        NetworkStatus internetStatus = [r currentReachabilityStatus];
    
        if ((internetStatus != ReachableViaWiFi) && (internetStatus != ReachableViaWWAN))
        {
            /// Create an alert if connection doesn't work
            UIAlertView *myAlert = [[UIAlertView alloc]initWithTitle:@"No Internet Connection"   message:NSLocalizedString(@"InternetMessage", nil)delegate:nil cancelButtonTitle:@"Ok" otherButtonTitles:nil];
            [myAlert show];
            [myAlert release];
        }
        else
        {
             NSLog(@"INTERNET IS CONNECT");
        }
    }
    

    Checking the Internet connection availability in (iOS) Xcode 8 , Swift 3.0

    This is simple method for checking the network availability like our device is connected to any network or not. I have managed to translate it to Swift 3.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,4G and WiFi connections.

    Don’t forget to add “SystemConfiguration.framework” to your project builder.

    //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")
      }
    

    Import Reachable.h class in your ViewController, and use the following code to check connectivity:

         #define hasInternetConnection [[Reachability reachabilityForInternetConnection] isReachable]
         if (hasInternetConnection){
               // To-do block
         }
    

    There is also another method to check Internet connection using the iPhone SDK.

    Try to implement the following code for the network connection.

    #import <SystemConfiguration/SystemConfiguration.h>
    #include <netdb.h>
    
    /**
         Checking for network availability. It returns
         YES if the network is available.
    */
    + (BOOL) connectedToNetwork
    {
    
        // Create zero addy
        struct sockaddr_in zeroAddress;
        bzero(&zeroAddress, sizeof(zeroAddress));
        zeroAddress.sin_len = sizeof(zeroAddress);
        zeroAddress.sin_family = AF_INET;
    
        // Recover reachability flags
        SCNetworkReachabilityRef defaultRouteReachability =
            SCNetworkReachabilityCreateWithAddress(NULL, (struct sockaddr *)&zeroAddress);
        SCNetworkReachabilityFlags flags;
    
        BOOL didRetrieveFlags = SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags);
        CFRelease(defaultRouteReachability);
    
        if (!didRetrieveFlags)
        {
            printf("Error. Could not recover network reachability flags\n");
            return NO;
        }
    
        BOOL isReachable = ((flags & kSCNetworkFlagsReachable) != 0);
        BOOL needsConnection = ((flags & kSCNetworkFlagsConnectionRequired) != 0);
    
        return (isReachable && !needsConnection) ? YES : NO;
    }
    

    Apart from reachability you may also use the Simple Ping helper library. It works really nice and is simple to integrate.

    • Step 1: Add the Reachability class in your Project.
    • Step 2: Import the Reachability class
    • Step 3: Create the below function

      - (BOOL)checkNetConnection {
          self.internetReachability = [Reachability reachabilityForInternetConnection];
          [self.internetReachability startNotifier];
          NetworkStatus netStatus = [self.internetReachability currentReachabilityStatus];
          switch (netStatus) {
              case NotReachable:
              {
                  return NO;
              }
      
              case ReachableViaWWAN:
              {
                   return YES;
              }
      
              case ReachableViaWiFi:
              {
                   return YES;
              }
          }
      }
      
    • Step 4: Call the function as below:

      if (![self checkNetConnection]) {
          [GlobalFunctions showAlert:@""
                           message:@"Please connect to the Internet!"
                           canBtntitle:nil
                           otherBtnTitle:@"Ok"];
          return;
      }
      else
      {
          Log.v("internet is connected","ok");
      }