Comment vérifier une connexion Internet active sur iOS ou macOS?
-
23-08-2019 - |
Question
Je voudrais vérifier si j'ai une connexion Internet sur iOS en utilisant Cocoa les bibliothèques ou sur macOS en utilisant le
Je suis venu avec une façon de le faire en utilisant un Est-ce que je l'ai fait mal, (sans parler NSURL
. La façon dont je l'ai fait il semble un peu fiable (parce que même Google pourrait un jour vers le bas et compter sur un tiers semble mauvais), et alors que je pouvais vérifier une réponse de certains autres sites si Google n'a pas répondu, il ne semble surcharge inutile et un inutile sur ma demande. - (BOOL) connectedToInternet
{
NSString *URLString = [NSString stringWithContentsOfURL:[NSURL URLWithString:@"http://www.google.com"]];
return ( URLString != NULL ) ? YES : NO;
}
stringWithContentsOfURL
est désapprouvée dans iOS 3.0 et Mac OS 10.4) Quelle est la meilleure façon d'y parvenir? Et si oui,
La solution
Important : Ce contrôle devrait toujours être effectué de manière asynchrone. La majorité des réponses ci-dessous sont synchrones alors faites attention, sinon vous bloquera votre application.
Swift
1) Installation via CocoaPods ou Carthage: https://github.com/ashleymills/Reachability.swift
2) joignabilité de test 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")
}
Objective-C
1) Ajouter cadre SystemConfiguration
au projet, mais ne vous inquiétez pas, y compris partout
2) Ajouter la version de Tony Million de Reachability.h
et Reachability.m
au projet (qui se trouve ici: https://github.com / tonymillion / Atteignabilité )
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) mettre en œuvre 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 afin que vous pourriez rencontrer les conflits de noms avec d'autres projets. Si cela se produit, vous devrez renommer l'une des paires de fichiers Reachability.h
et Reachability.m
à quelque chose d'autre pour résoudre le problème.
Remarque: Le domaine que vous utilisez n'a pas d'importance. Il teste juste pour une passerelle à un domaine.
Autres conseils
Je tiens à garder les choses simples. La façon dont je le fais est:
//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;
}
Alors, j'utilise ce 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 statuts de réseau modifiés afin de faire des choses. Il teste juste le statut lorsque vous demandez à.
En utilisant le code joignabilité d'Apple, j'ai créé une fonction qui va vérifier cela correctement sans que vous ayez à inclure toutes les classes.
Inclure le SystemConfiguration.framework dans votre projet.
Faire des importations:
#import <sys/socket.h>
#import <netinet/in.h>
#import <SystemConfiguration/SystemConfiguration.h>
Maintenant, il suffit d'appeler 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 il est iOS 5 testé pour vous.
Cette habitude d'être la bonne réponse, mais il est maintenant obsolète que vous devez vous abonner aux notifications pour joignabilité à la place. Cette méthode vérifie de manière synchrone:
Vous pouvez utiliser la classe joignabilité d'Apple. Il 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 est joignabilité pas fourni avec le SDK, mais plutôt une partie de cet exemple d'application d'Apple . Il suffit de le télécharger et copier Reachability.h / m à votre projet. , Vous devez également ajouter le cadre de 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 extrêmement faible. J'utilise le site Web mobile de Google, mais si j'avais un serveur web fiable je télécharger un petit fichier avec un seul personnage dans ce pour une vitesse maximale.
Si vérifier si l'appareil est en quelque sorte connecté à Internet est tout ce que vous voulez faire, je vous recommande vivement d'utiliser cette solution simple. Si vous avez besoin de savoir comment l'utilisateur est connecté, en utilisant joignabilité est le chemin à parcourir.
Attention: Ceci va bloquer brièvement votre fil pendant qu'il charge le site. Dans mon cas, cela n'a pas été un problème, mais vous devriez considérer ceci (crédits à Brad pour avoir signalé).
Voici comment je le fais dans mes applications: Alors qu'un code de réponse d'état 200 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, que le mien ne vérifie que la réponse HEAD.
Swift Code
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 de l'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 différents types de disponibilité du réseau. Sinon il y a un dans le livre de cuisine développeurs iPhone.
Remarque:. S'il vous plaît voir @ commentaire de KHG sur cette réponse concernant l'utilisation du code de joignabilité d'Apple
Vous pouvez utiliser Reachability
par ( 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.
Seule la classe joignabilité a été mis à 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 pour iOS sur joignabilité 5 est Darkseed / Reachability.h . Ce n'est pas le mien! =)
Si vous utilisez AFNetworking
vous pouvez utiliser sa propre implémentation pour le statut Internet joignabilité.
La meilleure façon d'utiliser AFNetworking
est de sous-classe la classe AFHTTPClient
et utiliser cette classe pour faire vos connexions réseau.
L'un des avantages de cette approche est que vous pouvez utiliser blocks
pour définir le comportement souhaité lorsque les changements d'état de joignabilité. En supposant que j'ai créé une sous-classe singleton de AFHTTPClient
(comme dit sur les « notes » sur AFNetworking docs ) nom 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 une connexion Wi-Fi ou les connexions WLAN en utilisant spécifiquement les énumérations AFNetworkReachabilityStatusReachableViaWWAN
et AFNetworkReachabilityStatusReachableViaWiFi
( plus ).
Je l'ai utilisé le code cette discussion , et il semble fonctionner très bien (lire le tout fil!).
Je ne l'ai pas testé de manière exhaustive avec tous les types imaginables de connexion (comme ad hoc Wi-Fi).
Très simple .... Essayez ces étapes:
Étape 1:. Ajouter le cadre de SystemConfiguration
dans votre projet
Étape 2: Importer 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; }
É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:[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 le classe joignabilité .
Il y a deux façons de vérifier la disponibilité d'Internet en utilisant l'iPhone SDK:
1. Vérifiez la page Google est ouverte ou non.
2. Joignabilité classe
Pour plus d'informations, s'il vous plaît se référer à joignabilité (Apple Developer).
Utilisez http://huytd.github.io/datatify/ . Il est plus facile que l'ajout de bibliothèques et le code d'écriture par vous-même.
Première : 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");
}
}
Tout d'abord télécharger la classe et de mettre joignabilité reachability.h et le fichier reachabilty.m dans votre .
La meilleure façon est de faire une classe de fonctions communes (NSObject) afin que vous puissiez l'utiliser toute la classe. Ce sont deux méthodes pour vérifier la connexion réseau joignabilité:
+(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 une classe en appelant cette méthode de classe.
Il y a aussi une autre méthode pour vérifier la connexion Internet à l'aide du SDK iPhone.
Essayez de mettre en œuvre 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;
}
Je l'ai trouvé simple et facile à utiliser la bibliothèque SimplePingHelper .
Exemple de code: chrishulbert / SimplePingHelper ( GitHub )
-
Télécharger le fichier joignabilité, https://gist.github.com/darkseed/1182373
-
Et d'ajouter
CFNetwork.framework
et 'SystemConfiguration.framework' dans le cadre -
Do #import "Reachability.h"
Première : Ajouter CFNetwork.framework
dans le cadre
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");
}
}
classe joignabilité est OK pour savoir si la connexion Internet est disponible à un appareil ou non ...
Mais en cas d'accès à un intranet ressource :
interroger le serveur d'intranet avec la classe joignabilité retourne toujours vrai.
une solution rapide dans ce scénario serait de créer une méthode Web appelée pingme
ainsi que d'autres webMethods sur le service.
Le pingme
doit retourner 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 était si utile pour moi, chaque fois que je tente d'envoyer des données au serveur je toujours vérifier l'accessibilité de ma ressource intranet utilisant ce faible délai d'attente URLRequest.
Pour faire vous-même est extrêmement simple. La méthode suivante fonctionnera. Juste être sûr de ne pas autoriser un protocole de nom d'hôte tel que HTTP, HTTPS, etc. à transmettre avec le nom.
-(BOOL)hasInternetConnection:(NSString*)urlAddress
{
SCNetworkReachabilityRef ref = SCNetworkReachabilityCreateWithName(kCFAllocatorDefault, [urlAddress UTF8String]);
SCNetworkReachabilityFlags flags;
if (!SCNetworkReachabilityGetFlags(ref, &flags))
{
return NO;
}
return flags & kSCNetworkReachabilityFlagsReachable;
}
Il est simple et rapide et indolore.
En dehors de joignabilité vous pouvez également utiliser le . Il fonctionne vraiment agréable et est simple à intégrer.
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;
}
}
Importation classe Reachable.h
dans votre ViewController
et utilisez le code suivant pour vérifier connectivité :
#define hasInternetConnection [[Reachability reachabilityForInternetConnection] isReachable]
if (hasInternetConnection){
// To-do block
}
- Étape 1:. Ajoutez la classe joignabilité dans votre projet
- Étape 2: Importez la classe joignabilité
-
É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 suit:
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 en (iOS) Xcode 8, Swift 3.0
Ceci est la méthode simple pour vérifier la disponibilité du réseau comme notre appareil est connecté à un réseau ou non. J'ai réussi à le traduire à Swift 3.0 et ici le code final. La classe d'Apple joignabilité existants et d'autres bibliothèques tierces parties semblaient être trop compliqué à traduire par Swift.
Cela fonctionne pour les 3G, 4G et les connexions WiFi.
Ne pas oublier d'ajouter « SystemConfiguration.framework » à votre générateur 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")
}