Comment vérifier une connexion Internet active sur iOS ou macOS?
J'aimerais vérifier si je dispose d'une connexion Internet sur iOS avec les bibliothèques Cocoa Touch ou sur macOS avec les bibliothèques Cocoa .
J'ai trouvé un moyen de faire cela en utilisant une NSURL. Cela semble un peu peu fiable (car même Google pourrait un jour tomber en panne et s’appuyer sur une tierce partie semble mauvais), et bien que je puisse vérifier la réponse de certains autres sites Web si Google ne répond pas, il semble inutile et inutile pour ma candidature.
- (BOOL) connectedToInternet
{
NSString *URLString = [NSString stringWithContentsOfURL:[NSURL URLWithString:@"http://www.google.com"]];
return ( URLString != NULL ) ? YES : NO;
}
Est-ce que ce que j'ai fait est mauvais (pour ne pas mentionner que stringWithContentsOfURL est obsolète dans iOS 3.0 et macOS 10.4) et si oui, quel meilleur moyen d'y parvenir?
Important: Cette vérification devrait toujours être effectuée de manière asynchrone. La majorité des réponses ci-dessous sont synchrones, alors faites attention, sinon vous gèlerez votre application.
Rapide
1) Installez via CocoaPods ou Carthage: https://github.com/ashleymills/Reachability.Swift
2) Tester l'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 cadre SystemConfiguration au projet mais ne vous inquiétez pas de l'inclure n'importe où
2) Ajouter la version de Tonycode des Reachability.h et Reachability.m 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) Puis 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 d'attribution de nom avec d'autres projets. Si cela se produit, vous devrez renommer l'une des paires de fichiers Reachability.h et Reachability.m en quelque chose d'autre pour résoudre le problème.
Remarque: Le domaine que vous utilisez n'a pas d'importance. Il s'agit simplement de tester une passerelle vers n'importe quel domaine.
J'aime garder les choses simples. Voici comment je le fais:
//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;
}
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 changements d'état du réseau pour pouvoir effectuer certaines tâches. Il teste simplement le statut lorsque vous le lui demandez.
À l'aide du code d'accessibilité d'Apple, j'ai créé une fonction qui le vérifie correctement sans que vous ayez à inclure de classes.
Inclure le SystemConfiguration.framework dans votre projet.
Faire des importations:
#import <sys/socket.h>
#import <netinet/in.h>
#import <SystemConfiguration/SystemConfiguration.h>
Maintenant, appelez 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, c'était la bonne réponse, mais elle est maintenant obsolète, vous devez plutôt vous abonner à des notifications d'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 d'accessibilité n'est pas livrée avec le SDK, mais fait partie de cet exemple d'application Apple . Il suffit de le télécharger et de copier Reachability.h/m dans votre projet. En outre, vous devez ajouter la structure SystemConfiguration à votre projet.
Voici une réponse très simple:
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");
L'URL doit pointer vers un site Web 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 tout ce que vous voulez faire est de vérifier si le périphérique est d'une manière ou d'une autre connecté à Internet, je vous recommande vivement d'utiliser cette solution simple. Si vous avez besoin de savoir comment l'utilisateur est connecté, utilisez Accessibilité est la voie à suivre.
Attention: Ceci bloquera brièvement votre thread pendant le chargement du site. Dans mon cas, ce n'était pas un problème, mais vous devriez en tenir compte (merci à Brad de l'avoir signalé).
Voici comment je le fais dans mes applications: Bien qu'un code de réponse de statut 200 ne garantisse rien, il est suffisamment stable pour moi. Cela ne nécessite pas autant de chargement que les réponses NSData publié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(string: "http://www.google.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 Google URL reachable
}
else
{
// No "Internet" aka Google URL un-reachable
}
})
}
Code Objective-C
typedef void(^connection)(BOOL);
- (void)checkInternet:(connection)block
{
NSURL *url = [NSURL URLWithString:@"http://www.google.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 Google URL reachable
}
else
{
// No "Internet" aka Google URL un-reachable
}
}];
}
Apple fournit exemple de code pour vérifier les différents types de disponibilité du réseau. Alternativement, il existe un exemple dans le livre de cuisine des développeurs iPhone.
Remarque: Voir le commentaire de @ KHG sur cette réponse concernant l'utilisation du code d'accessibilité d'Apple.
Vous pouvez utiliser Reachability de ( 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 cela:
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 de l'accessibilité pour iOS 5 est darkseed/Reachability.h. Ce n'est pas le mien! =)
Il y a ici une modernisation de Nice de l'accessibilité utilisant Nice et ARCD:
Si vous utilisez AFNetworking , vous pouvez utiliser sa propre implémentation pour le statut d'accessibilité Internet.
La meilleure façon d'utiliser AFNetworking consiste à sous-classer la classe AFHTTPClient et à utiliser cette classe pour établir vos connexions réseau.
L'un des avantages de cette approche est que vous pouvez utiliser blocks pour définir le comportement souhaité lorsque l'état d'accessibilité change. Supposons que j'ai créé une sous-classe singleton de AFHTTPClient (comme indiqué dans les "Notes de sous-classement" sur AFNetworking docs ) nommée 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 à l'aide des enumérations AFNetworkReachabilityStatusReachableViaWWAN et AFNetworkReachabilityStatusReachableViaWiFi ( plus ici ).
J'ai utilisé le code dans cette discussion , et il semble bien fonctionner (lisez le fil whole!).
Je ne l'ai pas testé de manière exhaustive avec tous les types de connexion imaginables (comme le Wi-Fi ad hoc).
Très simple .... Essayez ces étapes:
Étape 1: Ajoutez le cadre SystemConfiguration à votre projet.
Étape 2: Importez le code suivant dans votre fichier header.
#import <SystemConfiguration/SystemConfiguration.h>
É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:
En-tête d'importation :
#import "Reachability.h"- (BOOL)currentNetworkStatus { Reachability *reachability = [Reachability reachabilityForInternetConnection]; NetworkStatus networkStatus = [reachability currentReachabilityStatus]; return networkStatus != NotReachable; }
Etape 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:[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;
}
Ou utilisez la classe Accessibilité.
Il existe deux manières de vérifier la disponibilité d'Internet à l'aide du kit de développement logiciel (SDK) pour iPhone:
1. Vérifiez que la page Google est ouverte ou non.
2. Classe d'atteignabilité
Pour plus d'informations, reportez-vous à Accessibilité (développeur Apple).
First : 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:NSLocalizedString(@"InternetMessage", nil)delegate:nil cancelButtonTitle:@"Ok" otherButtonTitles:nil];
[myAlert show];
[myAlert release];
}
else
{
NSLog(@"INTERNET IS CONNECT");
}
}
Utilisez http://huytd.github.io/datatify/ . C'est plus facile que d'ajouter des bibliothèques et d'écrire du code vous-même.
Il existe également une autre méthode pour vérifier la connexion Internet à l'aide du SDK de l'iPhone.
Essayez d'implémenter le code suivant pour la connexion réseau.
#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;
}
Téléchargez le fichier d'accessibilité, https://Gist.github.com/darkseed/1182373
Et ajoutez
CFNetwork.frameworket 'SystemConfiguration.framework' dans le cadreNe #import "Accessibilité.h"
First: Ajouter CFNetwork.framework dans le 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");
}
}
Faire cela vous-même est extrêmement simple. La méthode suivante fonctionnera. Veillez simplement à ne pas autoriser la transmission d’un nom de protocole tel que HTTP, HTTPS, etc.
-(BOOL)hasInternetConnection:(NSString*)urlAddress
{
SCNetworkReachabilityRef ref = SCNetworkReachabilityCreateWithName(kCFAllocatorDefault, [urlAddress UTF8String]);
SCNetworkReachabilityFlags flags;
if (!SCNetworkReachabilityGetFlags(ref, &flags))
{
return NO;
}
return flags & kSCNetworkReachabilityFlagsReachable;
}
C'est simple, rapide et sans douleur.
J'ai trouvé la bibliothèque simple et facile à utiliser SimplePingHelper .
Exemple de code: chrishulbert/SimplePingHelper ( GitHub )
Commencez par télécharger la classe d'accessibilité, puis placez les fichiers 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 avec n'importe quelle classe. Voici deux méthodes de vérification de l'accessibilité d'une 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 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;
}
Maintenant, vous pouvez vérifier la connexion réseau dans n'importe quelle classe en appelant cette méthode.
En plus de l'accessibilité, vous pouvez également utiliser la bibliothèque Bibliothèque d'aide simple Ping . Cela fonctionne vraiment bien et est simple à intégrer.
La La classe d'accessibilité permet de savoir si la connexion Internet est disponible ou non pour un périphérique ...
Mais en cas d'accès à une ressource intranet :
L'envoi d'une commande ping au serveur intranet avec la classe d'accessibilité renvoie toujours la valeur true.
Une solution rapide dans ce scénario consisterait donc à créer une méthode Web appelée pingme ainsi que d'autres méthodes Web sur le service . La pingme devrait renvoyer quelque chose.
J'ai donc écrit la méthode suivante sur les fonctions communes
-(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;
}
}
La méthode ci-dessus m'a été très utile. Ainsi, chaque fois que j'essaie d'envoyer des données au serveur, je vérifie toujours l'accessibilité de ma ressource intranet à l'aide de ce délai d'expiration court URLRequest.
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;
}
}
- Étape 1: Ajoutez la classe d'accessibilité dans votre projet.
- Étape 2: Importer la classe d'accessibilité
Étape 3: Créer la fonction ci-dessous
- (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; } } }Étape 4: Appelez la fonction comme ci-dessous:
if (![self checkNetConnection]) { [GlobalFunctions showAlert:@"" message:@"Please connect to the Internet!" canBtntitle:nil otherBtnTitle:@"Ok"]; return; } else { Log.v("internet is connected","ok"); }
Vérification de la disponibilité de la connexion Internet sous (iOS) Xcode 8, Swift 3.0
C'est une méthode simple pour vérifier la disponibilité du réseau, que notre appareil soit connecté à un réseau ou non. J'ai réussi à le traduire en Swift 3.0 et ici le code final. La classe Apple Reachability existante et les bibliothèques tierces semblaient trop compliquées pour être traduites en Swift.
Cela fonctionne pour les connexions 3G, 4G et WiFi.
N’oubliez pas d’ajouter “SystemConfiguration.framework” à votre constructeur de projet.
//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")
}
Importez la classe Reachable.h dans votre ViewController et utilisez le code suivant pour vérifier connectivity :
#define hasInternetConnection [[Reachability reachabilityForInternetConnection] isReachable]
if (hasInternetConnection){
// To-do block
}
Swift 3/Swift 4
Vous devez d'abord importer
import SystemConfiguration
Vous pouvez vérifier la connexion Internet avec la méthode suivante
func isConnectedToNetwork() -> 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: &zeroAddress) {
$0.withMemoryRebound(to: sockaddr.self, capacity: 1) {zeroSockAddress in
SCNetworkReachabilityCreateWithAddress(nil, zeroSockAddress)
}
}
var flags = SCNetworkReachabilityFlags()
if !SCNetworkReachabilityGetFlags(defaultRouteReachability!, &flags) {
return false
}
let isReachable = (flags.rawValue & UInt32(kSCNetworkFlagsReachable)) != 0
let needsConnection = (flags.rawValue & UInt32(kSCNetworkFlagsConnectionRequired)) != 0
return (isReachable && !needsConnection)
}
Créez un objet de AFNetworkReachabilityManager et utilisez le code suivant pour suivre la connectivité réseau
self.reachabilityManager = [AFNetworkReachabilityManager managerForDomain:@"yourDomain"];
[self.reachabilityManager startMonitoring];
[self.reachabilityManager setReachabilityStatusChangeBlock:^(AFNetworkReachabilityStatus status) {
switch (status) {
case AFNetworkReachabilityStatusReachableViaWWAN:
case AFNetworkReachabilityStatusReachableViaWiFi:
break;
case AFNetworkReachabilityStatusNotReachable:
break;
default:
break;
}
}];
importer "Accessibilité.h"
-(BOOL)netStat
{
Reachability *test = [Reachability reachabilityForInternetConnection];
return [test isReachable];
}
Obtenez la classe Reachabilty de https://github.com/tonymillion/Reachability , ajoutez le cadre de configuration système à votre projet, importez Reachability.h dans votre classe et implémentez les méthodes personnalisées ci-dessous:
- (BOOL)isConnectedToInternet
{
//return NO; // Force for offline testing
Reachability *hostReach = [Reachability reachabilityForInternetConnection];
NetworkStatus netStatus = [hostReach currentReachabilityStatus];
return !(netStatus == NotReachable);
}
Vérifiez la disponibilité de la connexion Internet dans (iOS) à l'aide de Xcode 9 et Swift 4.0
Suivez les étapes ci-dessous
Étape 1: Créez un fichier d'extension et nommez-le: ReachabilityManager.Swift puis ajoutez les lignes de code ci-dessous.
import Foundation
import SystemConfiguration
public class ConnectionCheck
{
class func isConnectedToNetwork() -> Bool
{
var zeroAddress = sockaddr_in()
zeroAddress.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
zeroAddress.sin_family = sa_family_t(AF_INET)
guard let defaultRouteReachability = withUnsafePointer(to: &zeroAddress,
{
$0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
SCNetworkReachabilityCreateWithAddress(nil, $0)
}
}) else {
return false
}
var flags: SCNetworkReachabilityFlags = []
if !SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) {
return false
}
let isReachable = flags.contains(.reachable)
let needsConnection = flags.contains(.connectionRequired)
return (isReachable && !needsConnection)
}
}
Étape 2: Appelez le poste ci-dessus à l'aide du code ci-dessous.
if ConnectionCheck.isConnectedToNetwork()
{
print("Connected")
//Online related Business logic
}
else{
print("disConnected")
// offline related business logic
}
Pod `Alamofire` has `NetworkReachabilityManager`, you just have to create one function
func isConnectedToInternet() ->Bool {
return NetworkReachabilityManager()!.isReachable
}
Pour mes projets iOS, je recommande d'utiliser
Classe d'atteignabilité
Déclaré à Swift. Pour moi, ça marche tout simplement bien avec
Données Wi-Fi et cellulaires
.
import SystemConfiguration
public class Reachability {
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(MemoryLayout.size(ofValue: zeroAddress))
zeroAddress.sin_family = sa_family_t(AF_INET)
let defaultRouteReachability = withUnsafePointer(to: &zeroAddress) {
$0.withMemoryRebound(to: sockaddr.self, capacity: 1) {zeroSockAddress in
SCNetworkReachabilityCreateWithAddress(nil, zeroSockAddress)
}
}
var flags: SCNetworkReachabilityFlags = SCNetworkReachabilityFlags(rawValue: 0)
if SCNetworkReachabilityGetFlags(defaultRouteReachability!, &flags) == false {
return false
}
let isReachable = (flags.rawValue & UInt32(kSCNetworkFlagsReachable)) != 0
let needsConnection = (flags.rawValue & UInt32(kSCNetworkFlagsConnectionRequired)) != 0
let ret = (isReachable && !needsConnection)
return ret
} }
Utiliser une déclaration conditionnelle,
if Reachability.isConnectedToNetwork(){
* Enter Your Code Here*
}
}
else{
print("NO Internet connection")
}
Cette classe est utile dans presque tous les cas, votre application utilise la connexion Internet. Par exemple, si la condition est vraie, une API peut être appelée ou une tâche peut être exécutée.
Ceci est pour Swift 3.0 et async. La plupart des réponses sont une solution de synchronisation qui bloquera votre thread principal si votre connexion est très lente. Cette solution est meilleure mais pas parfaite car elle repose sur Google pour vérifier la connectivité, alors n'hésitez pas à utiliser une autre URL.
func checkInternetConnection(completionHandler:@escaping (Bool) -> Void)
{
if let url = URL(string: "http://www.google.com/")
{
var request = URLRequest(url: url)
request.httpMethod = "HEAD"
request.cachePolicy = .reloadIgnoringLocalAndRemoteCacheData
request.timeoutInterval = 5
let tast = URLSession.shared.dataTask(with: request, completionHandler:
{
(data, response, error) in
completionHandler(error == nil)
})
tast.resume()
}
else
{
completionHandler(true)
}
}
Alamofire
Je sais que la question concerne la solution Coca Touch, mais je souhaite proposer une solution aux personnes qui ont effectué une recherche de connexion Internet sur iOS et qui disposeront d'une option supplémentaire.
Si vous utilisez déjà Alamofire , voici ce que vous pouvez en tirer.
Vous pouvez ajouter la classe suivante à votre application et appeler MNNetworkUtils.main.isConnected() pour obtenir un booléen indiquant si elle est connectée ou non.
#import Alamofire
class MNNetworkUtils {
static let main = MNNetworkUtils()
init() {
manager = NetworkReachabilityManager(Host: "google.com")
listenForReachability()
}
private let manager: NetworkReachabilityManager?
private var reachable: Bool = false
private func listenForReachability() {
self.manager?.listener = { [unowned self] status in
switch status {
case .notReachable:
self.reachable = false
case .reachable(_), .unknown:
self.reachable = true
}
}
self.manager?.startListening()
}
func isConnected() -> Bool {
return reachable
}
}
Ceci est une classe singleton. Chaque fois que l'utilisateur connecte ou déconnecte le réseau, il remplace self.reachable par true/false correctement, car nous commençons à écouter NetworkReachabilityManager lors de l'initialisation du singleton.
De plus, afin de contrôler l'accessibilité, vous devez fournir un hôte. Actuellement, j'utilise google.com. N'hésitez pas à passer à un autre hôte ou à l'un des vôtres si nécessaire.
Veuillez essayer ceci, cela vous aidera (Swift 4)
1) Installation Accessibilité via CocoaPods ou Carthage: Accessibilité
2) Accessibilité et utilisation dans la classe réseau
import Reachability
class Network {
private let internetReachability : Reachability?
var isReachable : Bool = false
init() {
self.internetReachability = Reachability.init()
do{
try self.internetReachability?.startNotifier()
NotificationCenter.default.addObserver(self, selector: #selector(self.handleNetworkChange), name: .reachabilityChanged, object: internetReachability)
}
catch {
print("could not start reachability notifier")
}
}
@objc private func handleNetworkChange(notify: Notification) {
let reachability = notify.object as! Reachability
if reachability.connection != .none {
self.isReachable = true
}
else {
self.isReachable = false
}
print("Internet Connected : \(self.isReachable)") //Print Status of Network Connection
}
}
3) Utilisez comme ci-dessous où vous avez besoin.
var networkOBJ = Network()
// Use "networkOBJ.isReachable" for Network Status
print(networkOBJ.isReachable)
voir Introducing Network.framework: A modern alternative to Socketshttps://developer.Apple.com/videos/play/wwdc2018/715/ nous devrions nous débarrasser de l'accessibilité à un moment donné.