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 .

J'ai trouvé un moyen de le faire en utilisant un NSURL. La façon dont je l'ai fait semble un peu peu fiable (car même Google pourrait un jour être en panne et s'appuyer sur un tiers semble mauvais), et même si je pouvais vérifier pour voir une réponse de certains autres sites Web si Google ne répondait pas, il ne semble gaspillage et une surcharge inutile sur ma demande.

- (BOOL) connectedToInternet
{
    NSString *URLString = [NSString stringWithContentsOfURL:[NSURL URLWithString:@"http://www.google.com"]];
    return ( URLString != NULL ) ? YES : NO;
}

Est-ce que j'ai mal agi (sans parler de la stringWithContentsOfURLdépréciation 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 sinon vous ferez geler votre application.

Rapide

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

2) Test d'accessibilité via les 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 un SystemConfigurationcadre au projet mais ne vous inquiétez pas de l'inclure n'importe où

2) Ajoutez la version de Tony Million de Reachability.het Reachability.mau projet (disponible ici: https://github.com/tonymillion/Reachability )

3) Mettre à jour la section 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 Reachabilityclasse est l'une des classes les plus utilisées dans les projets, vous pouvez donc rencontrer des conflits de dénomination avec d'autres projets. Si cela se produit, vous devrez renommer l'une des paires de fichiers Reachability.het Reachability.men 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. La façon dont je fais cela 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;
}

Ensuite, j'utilise ceci 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 que vous ayez à inclure de classes.

Incluez le SystemConfiguration.framework dans votre projet.

Faites quelques importations:

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

Appelez maintenant 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 désormais obsolète car vous devez vous abonner aux notifications pour être joignable à la place. Cette méthode vérifie de manière synchrone:

Vous pouvez utiliser la classe d'accessibilité 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 d'accessibilité n'est pas fournie avec le SDK, mais plutôt une partie de cet exemple d'application Apple . Téléchargez-le et copiez Reachability.h / m dans votre projet. Vous devez également ajouter le framework 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 avec un seul caractère pour une vitesse maximale.

Si vérifier que l'appareil est connecté d'une manière ou d'une autre à Internet est tout ce que vous voulez faire, je recommanderais certainement d'utiliser cette solution simple. Si vous avez besoin de savoir comment l'utilisateur est connecté, l'utilisation de l'accessibilité est la solution.

Attention: cela bloquera brièvement votre fil pendant qu'il charge le site Web. Dans mon cas, ce n'était pas un problème, mais vous devriez en tenir compte (merci à Brad pour l'avoir signalé).

Voici comment je le fais dans mes applications: bien qu'un code de réponse à 200 états 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 la mienne 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 un exemple de code pour vérifier les différents types de disponibilité du réseau. Alternativement, il y a un exemple dans le livre de cuisine des développeurs iPhone.

Remarque: veuillez consulter le commentaire de @ KHG sur cette réponse concernant l'utilisation du code d'accessibilité d'Apple.

Vous pouvez utiliser Reachabilitypar  ( 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:

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

Il y a une belle modernisation de l'accessibilité utilisant ARC et GCD:

Accessibilité

Si vous utilisez, AFNetworkingvous pouvez utiliser sa propre implémentation pour le statut d'accessibilité à Internet.

La meilleure façon d'utiliser AFNetworkingest de sous- AFHTTPClientclasser la classe et d'utiliser cette classe pour effectuer vos connexions réseau.

L'un des avantages de cette approche est que vous pouvez l'utiliser blockspour 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-classe" sur les documents AFNetworking ) 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 en utilisant spécifiquement les enums AFNetworkReachabilityStatusReachableViaWWANet AFNetworkReachabilityStatusReachableViaWiFi( plus ici ).

J'ai utilisé le code dans cette discussion , et il semble bien fonctionner (lire tout le fil!).

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 SystemConfigurationcadre à votre projet.

Étape 2: importez le code suivant dans votre headerfichier.

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

  Importer l'en-tête :#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 la classe d'accessibilité .

Il existe deux façons 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, reportez-vous à la section Accessibilité (développeur Apple).

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

Premièrement : ajouter CFNetwork.frameworkdans 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");
    }
}

Téléchargez d'abord la classe d'accessibilité et mettez le fichier reachability.h et reachabilty.m dans votre Xcode .

La meilleure façon est de créer une classe Functions commune (NSObject) afin que vous puissiez l'utiliser dans n'importe quelle classe. Ce sont deux méthodes pour une vérification d'accessibilité de 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;
}

Vous pouvez maintenant 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 <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ée simple et facile à utiliser, la bibliothèque SimplePingHelper .

Exemple de code: chrishulbert / SimplePingHelper ( GitHub )

1. Téléchargez le fichier d'accessibilité, https://gist.github.com/darkseed/1182373

2. Et ajoutez CFNetwork.frameworket 'SystemConfiguration.framework' dans le cadre

3. Faites #import "Reachability.h"

Premièrement : ajouter CFNetwork.frameworkdans 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");
    }
}

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)

}

La classe d'accessibilité est OK pour savoir si la connexion Internet est disponible ou non pour un appareil ...

Mais en cas d'accès à une ressource intranet :

Le ping du serveur intranet avec la classe d'accessibilité renvoie toujours true.

Ainsi, une solution rapide dans ce scénario serait de créer une méthode Web appelée pingmeavec d'autres méthodes Web sur le service. Le pingmedevrait 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 m'a été si utile, donc 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 cette URLRequest à faible délai d'attente.

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

-(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 indolore.

Outre l'accessibilité, vous pouvez également utiliser la bibliothèque d'assistance Simple Ping . Cela fonctionne vraiment bien 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;
    }
}

Importez la Reachable.hclasse dans votre ViewControlleret utilisez le code suivant pour vérifier la connectivité :

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

• Étape 1: ajoutez la classe d'accessibilité dans votre projet.
• Étape 2: importez 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 suit:

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