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

StackOverflow https://stackoverflow.com/questions/1083701

Était-ce utile?

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.

Apple propose une application d'échantillon qui fait exactement ceci:

joignabilité

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! =)

Il y a un beau, et ARC- GCD utilisant la modernisation de joignabilité ici:

joignabilité

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

  1. Télécharger le fichier joignabilité, https://gist.github.com/darkseed/1182373

  2. Et d'ajouter CFNetwork.framework et 'SystemConfiguration.framework' dans le cadre

  3. 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")
  }
Non affilié à StackOverflow
scroll top