Comment vérifier une connexion Internet active sur iOS ou MacOS?

Je voudrais vérifier si j’ai une connexion Internet sur iOS en utilisant les bibliothèques Cocoa Touch ou sur macOS en utilisant les bibliothèques Cocoa .

Je suis venu avec un moyen de le faire en utilisant un NSURL . La façon dont je l’ai fait semble un peu peu fiable (parce que même un jour, Google pourrait être en panne et compter sur un tiers semble mauvais) et même si je pouvais vérifier si Google ne répondait pas, semble gaspiller et une surcharge inutile sur ma demande.

 - (BOOL) connectedToInternet { NSSsortingng *URLSsortingng = [NSSsortingng ssortingngWithContentsOfURL:[NSURL URLWithSsortingng:@"http://www.google.com"]]; return ( URLSsortingng != NULL ) ? YES : NO; } 

Est-ce que ce que j’ai mal fait (pour ne pas mentionner ssortingngWithContentsOfURL est obsolète dans iOS 3.0 et macOS 10.4) et si oui, quelle est la meilleure façon d’y parvenir?

Important : cette vérification doit toujours être effectuée de manière asynchrone. La majorité des réponses ci-dessous sont synchrones, alors faites attention à ne pas geler votre application.


Rapide

1) Installer via CocoaPods ou Carthage: https://github.com/ashleymills/Reachability.swift

2) Test d’accessibilité via des fermetures

 let reachability = Reachability()! reachability.whenReachable = { reachability in if reachability.connection == .wifi { print("Reachable via WiFi") } else { print("Reachable via Cellular") } } reachability.whenUnreachable = { _ in print("Not reachable") } do { try reachability.startNotifier() } catch { print("Unable to start notifier") } 

Objectif c

1) Ajoutez le framework SystemConfiguration au projet mais ne vous souciez pas de l’inclure n’importe où

2) Ajouter la version de Reachability.h et Reachability.m de Tony Million au projet (trouvée ici: https://github.com/tonymillion/Reachability )

3) Mettre à jour la section d’interface

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

4) Ensuite, implémentez cette méthode dans le fichier .m de votre contrôleur de vue que vous pouvez appeler

 // 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]; } 

Remarque importante: La classe Reachability est l’une des classes les plus utilisées dans les projets. Vous pouvez donc rencontrer des conflits de noms avec d’autres projets. Si cela se produit, vous devrez renommer une des paires de fichiers Reachability.h et Reachability.m pour résoudre le problème.

Remarque: le domaine que vous utilisez n’a pas d’importance. Il suffit de tester une passerelle vers un domaine.

J’aime garder les choses simples. La façon dont je fais cela est la suivante:

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

Ensuite, je l’utilise chaque fois que je veux voir si j’ai une connexion:

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

Cette méthode n’attend pas les états de réseau modifiés pour faire des choses. Il teste simplement le statut lorsque vous le lui demandez.

En utilisant le code d’accessibilité d’Apple, j’ai créé une fonction qui vérifiera cela correctement sans avoir à inclure de classes.

Incluez le fichier SystemConfiguration.framework dans votre projet.

Faites des importations:

 #import  #import  #import  

Maintenant, appelez simplement cette fonction:

 /* 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; } 

Et c’est iOS 5 testé pour vous.

Auparavant, la réponse était correcte, mais elle est désormais obsolète car vous devez vous abonner aux notifications pour vous rendre à l’accessibilité. Cette méthode vérifie de manière synchrone:


Vous pouvez utiliser la classe d’accessibilité d’Apple. Cela vous permettra également de vérifier si le Wi-Fi est activé:

 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) { } 

La classe Reachability n’est pas fournie avec le SDK, mais fait plutôt partie de cet exemple d’application Apple . Il suffit de le télécharger et de copier Reachability.h / m sur votre projet. De plus, vous devez append la structure SystemConfiguration à votre projet.

Voici une réponse très simple:

 NSURL *scriptUrl = [NSURL URLWithSsortingng:@"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"); 

L’URL devrait pointer vers un site extrêmement petit. J’utilise le site Web mobile de Google ici, mais si j’avais un serveur Web fiable, je téléchargerais un petit fichier contenant un seul caractère pour une vitesse maximale.

Si vous voulez vérifier si le périphérique est connecté à Internet, je vous recommande vivement d’utiliser cette solution simple. Si vous avez besoin de savoir comment l’utilisateur est connecté, l’utilisation de Reachability est la voie à suivre.

Attention: cela bloquera brièvement votre fil pendant qu’il charge le site. Dans mon cas, ce n’était pas un problème, mais vous devriez considérer cela (des crédits à Brad pour l’avoir souligné).

Voici comment je le fais dans mes applications: alors qu’un code de réponse à 200 états ne garantit rien, il est assez stable pour moi. Cela ne nécessite pas autant de chargement que les réponses NSData affichées ici, car le mien vérifie simplement la réponse HEAD.

Code rapide

 func checkInternet(flag:Bool, completionHandler:(internet:Bool) -> Void) { UIApplication.sharedApplication().networkActivityIndicatorVisible = true let url = NSURL(ssortingng: "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 } }) } 

Code Objective-C

 typedef void(^connection)(BOOL); - (void)checkInternet:(connection)block { NSURL *url = [NSURL URLWithSsortingng:@"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 fournit un exemple de code pour vérifier différents types de disponibilité réseau. Il existe également un exemple dans le livre de recettes des développeurs iPhone.

Note: Veuillez consulter le commentaire de @KHG sur cette réponse concernant l’utilisation du code d’accessibilité d’Apple.

Vous pouvez utiliser Reachability par  ( disponible ici ).

 #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 fournit un exemple d’application qui fait exactement ceci:

Accessibilité

Seule la classe d’accessibilité a été mise à jour. Vous pouvez maintenant utiliser:

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

Une version sur Reachability pour iOS 5 est darkseed / Reachability.h . Ce n’est pas le mien! =)

Ici, il y a une belle modernisation de l’aptitude à l’utilisation d’ARC et de GCD:

Accessibilité

Si vous utilisez AFNetworking vous pouvez utiliser sa propre implémentation pour obtenir le statut d’accessibilité Internet.

La meilleure façon d’utiliser AFNetworking consiste à sous- AFHTTPClient classe AFHTTPClient et à utiliser cette classe pour effectuer vos connexions réseau.

L’un des avantages de cette approche est que vous pouvez utiliser des blocks pour définir le comportement souhaité lorsque l’état de l’accessibilité change. En supposant que j’ai créé une sous-classe singleton de AFHTTPClient (comme indiqué dans les “Notes de sous- classement ” sur les documents AFNetworking ) nommés BKHTTPClient , je ferais quelque chose comme:

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

Vous pouvez également vérifier les connexions Wi-Fi ou WLAN en utilisant spécifiquement les AFNetworkReachabilityStatusReachableViaWWAN et AFNetworkReachabilityStatusReachableViaWiFi ( plus ici ).

J’ai utilisé le code dans cette discussion et cela semble fonctionner correctement (lisez le fil entier !).

Je ne l’ai pas testé de manière exhaustive avec chaque type de connexion imaginable (comme le Wi-Fi ad hoc).

Très simple …. Essayez ces étapes:

Étape 1: Ajoutez le framework SystemConfiguration à votre projet.


Étape 2: Importez le code suivant dans votre fichier d’en- header .

 #import  

Étape 3: Utilisez la méthode suivante

  • 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:

    Importer en-tête : #import "Reachability.h" Import #import "Reachability.h"

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

Étape 4: Comment utiliser:

 - (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:[NSClassFromSsortingng(@"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 { NSSsortingng *URL = [NSSsortingng ssortingngWithContentsOfURL:[NSURL URLWithSsortingng:@"http://www.google.com"]]; return (URL != NULL ) ? YES : NO; } 

Ou utilisez la classe d’accessibilité .

Il existe deux manières de vérifier la disponibilité d’Internet à l’aide du SDK iPhone:

1. Vérifiez que la page Google est ouverte ou non.

2. Classe d’accessibilité

Pour plus d’informations, veuillez vous reporter à Reachability (Développeur Apple).

Utilisez http://huytd.github.io/datatify/ . C’est plus facile que d’append des bibliothèques et d’écrire du code par vous-même.

Tout d’abord : Ajouter CFNetwork.framework dans le cadre

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:NSLocalizedSsortingng(@"InternetMessage", nil)delegate:nil cancelButtonTitle:@"Ok" otherButtonTitles:nil]; [myAlert show]; [myAlert release]; } else { NSLog(@"INTERNET IS CONNECT"); } } 

Commencez par télécharger la classe d’accessibilité et placez le fichier reachability.h et reachabilty.m dans votre Xcode .

Le meilleur moyen est de créer une classe de fonctions commune (NSObject) afin de pouvoir l’utiliser dans n’importe quelle classe. Ce sont deux méthodes pour un contrôle d’accessibilité de la connexion réseau:

 +(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 didResortingeveFlags = SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags); CFRelease(defaultRouteReachability); if (!didResortingeveFlags) { 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 URLWithSsortingng:@"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; } 

Maintenant, vous pouvez vérifier la connexion réseau dans n’importe quelle classe en appelant cette méthode de classe.

Il existe également une autre méthode pour vérifier la connexion Internet à l’aide du SDK iPhone.

Essayez d’implémenter le code suivant pour la connexion réseau.

 #import  #include  /** 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 didResortingeveFlags = SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags); CFRelease(defaultRouteReachability); if (!didResortingeveFlags) { 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; } 

Faire cela vous-même est extrêmement simple. La méthode suivante fonctionnera. Veillez simplement à ne pas autoriser un protocole de nom d’hôte tel que HTTP, HTTPS, etc. avec le nom.

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

Il est rapide simple et indolore.

J’ai trouvé la bibliothèque SimplePingHelper simple et facile à utiliser.

Exemple de code: chrishulbert / SimplePingHelper ( GitHub )

La classe d’accessibilité est correcte pour savoir si la connexion Internet est disponible pour un périphérique ou non …

Mais en cas d’access à une ressource intranet :

Faire un ping sur le serveur intranet avec la classe d’accessibilité renvoie toujours true.

Une solution rapide dans ce scénario serait donc de créer une méthode Web appelée pingme avec d’autres méthodes Web sur le service. Le pingme devrait retourner quelque chose.

J’ai donc écrit la méthode suivante sur les fonctions communes

 -(BOOL)PingServiceServer { NSURL *url=[NSURL URLWithSsortingng:@"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; } } 

La méthode ci-dessus m’a été très utile, donc chaque fois que j’essaie d’envoyer des données sur le serveur, je vérifie toujours l’accessibilité de ma ressource intranet en utilisant cette URLRequest à faible délai d’expiration.

Je pense que celui-ci est la meilleure réponse.

“Oui” signifie connecté. “Non” signifie déconnecté.

 #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:NSLocalizedSsortingng(@"InternetMessage", nil)delegate:nil cancelButtonTitle:@"Ok" otherButtonTitles:nil]; [myAlert show]; [myAlert release]; } else { NSLog(@"INTERNET IS CONNECT"); } } 

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 } 

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

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