Je sais que cette question semblera être une dupe de beaucoup d'autres, cependant, je ne pense pas que le cas simple soit bien expliqué ici. Venant d'un arrière-plan Android et BlackBerry, les demandes HTTPUrlConnectionéchouent instantanément s'il n'y a pas de connexion disponible. Cela semble être un comportement complètement sensé, et j'ai été surpris de constater que NSURLConnectioniOS ne l'avait pas émulé.

Je comprends qu'Apple (et d'autres qui l'ont étendu) fournissent une Reachabilityclasse pour aider à déterminer l'état du réseau. J'étais heureux de voir cela pour la première fois et je m'attendais vraiment à voir quelque chose comme bool isNetworkAvailable(), mais à ma grande surprise, j'ai trouvé un système complexe nécessitant des enregistrements de notification et des rappels, et un tas de détails apparemment inutiles. Il doit y avoir un meilleur moyen.

Mon application gère déjà correctement les échecs de connexion, y compris l'absence de connectivité. L'utilisateur est informé de l'échec et l'application continue.

Ainsi, mes exigences sont simples: une fonction synchrone unique que je peux appeler avant toutes les requêtes HTTP pour déterminer si je devrais prendre la peine d'envoyer la requête ou non. Idéalement, il ne nécessite aucune configuration et renvoie simplement un booléen.

N'est-ce pas vraiment possible sur iOS?

J'ai fait un peu plus de recherche et je mets à jour ma réponse avec une solution plus actuelle. Je ne sais pas si vous l'avez déjà regardé, mais il existe un bel exemple de code fourni par Apple.

Téléchargez l'exemple de code ici

Incluez les fichiers Reachability.h et Reachability.m dans votre projet. Jetez un œil à ReachabilityAppDelegate.m pour voir un exemple sur la façon de déterminer l'accessibilité de l'hôte, l'accessibilité par WiFi, par WWAN, etc. Pour une vérification très simple de l'accessibilité du réseau, vous pouvez faire quelque chose comme ceci

Reachability *networkReachability = [Reachability reachabilityForInternetConnection];   
NetworkStatus networkStatus = [networkReachability currentReachabilityStatus];    
if (networkStatus == NotReachable) {        
    NSLog(@"There IS NO internet connection");        
} else {        
     NSLog(@"There IS internet connection");        
}

@ BenjaminPiette's: N'oubliez pas d'ajouter SystemConfiguration.framework à votre projet.

Étant donné que ce fil est le meilleur résultat sur Google pour ce type de question, j'ai pensé que je fournirais la solution qui fonctionnait pour moi. J'utilisais déjà AFNetworking , mais la recherche n'a révélé comment accomplir cette tâche avec AFNetworking qu'au milieu de mon projet.

Ce que vous voulez, c'est l' AFNetworkingReachabilityManager .

// -- Start monitoring network reachability (globally available) -- //
[[AFNetworkReachabilityManager sharedManager] startMonitoring];

[[AFNetworkReachabilityManager sharedManager] setReachabilityStatusChangeBlock:^(AFNetworkReachabilityStatus status) {

    NSLog(@"Reachability changed: %@", AFStringFromNetworkReachabilityStatus(status));


    switch (status) {
        case AFNetworkReachabilityStatusReachableViaWWAN:
        case AFNetworkReachabilityStatusReachableViaWiFi:
            // -- Reachable -- //
            NSLog(@"Reachable");
            break;
        case AFNetworkReachabilityStatusNotReachable:
        default:
            // -- Not reachable -- //
            NSLog(@"Not Reachable");
            break;
    }

}];

Vous pouvez également utiliser les éléments suivants pour tester l'accessibilité de manière synchrone (une fois la surveillance démarrée):

-(BOOL) isInternetReachable
{
    return [AFNetworkReachabilityManager sharedManager].reachable;
}

Désolé d'avoir répondu trop tard, mais j'espère que cette réponse pourra aider quelqu'un à l'avenir.

Voici un petit extrait de code C natif qui peut vérifier la connectivité Internet sans aucune classe supplémentaire.

Ajoutez les en-têtes suivants:

#include<unistd.h>
#include<netdb.h>

Code:

-(BOOL)isNetworkAvailable
{
    char *hostname;
    struct hostent *hostinfo;
    hostname = "google.com";
    hostinfo = gethostbyname (hostname);
    if (hostinfo == NULL){
        NSLog(@"-> no connection!\n");
        return NO;
    }
    else{
        NSLog(@"-> connection established!\n");
        return YES;
    }
}

Swift 3

func isConnectedToInternet() -> Bool {
    let hostname = "google.com"
    //let hostinfo = gethostbyname(hostname)
    let hostinfo = gethostbyname2(hostname, AF_INET6)//AF_INET6
    if hostinfo != nil {
        return true // internet available
      }
     return false // no internet
    }

J'utilise actuellement cette méthode synchrone simple qui ne nécessite aucun fichier supplémentaire dans vos projets ou délégués.

Importer:

#import <SystemConfiguration/SCNetworkReachability.h>

Créez cette méthode:

+(bool)isNetworkAvailable
{
    SCNetworkReachabilityFlags flags;
    SCNetworkReachabilityRef address;
    address = SCNetworkReachabilityCreateWithName(NULL, "www.apple.com" );
    Boolean success = SCNetworkReachabilityGetFlags(address, &flags);
    CFRelease(address);

    bool canReach = success
                    && !(flags & kSCNetworkReachabilityFlagsConnectionRequired)
                    && (flags & kSCNetworkReachabilityFlagsReachable);

    return canReach;
}

Ensuite, si vous avez mis ceci dans un MyNetworkClass:

if( [MyNetworkClass isNetworkAvailable] )
{
   // do something networky.
}

Si vous testez dans le simulateur, activez et désactivez le wifi de votre Mac, car il semble que le simulateur ignorera les paramètres du téléphone.

Mettre à jour:

1. À la fin, j'ai utilisé un thread / callback asynchrone pour éviter de bloquer le thread principal; et re-tester régulièrement pour que je puisse utiliser un résultat mis en cache - bien que vous devriez éviter de garder les connexions de données ouvertes inutilement.

2. Comme @thunk l'a décrit, il existe de meilleures URL à utiliser, qu'Apple utilise lui-même. http://cadinc.com/blog/why-your-apple-ios-7-device-wont-connect-to-the-wifi-network

C'est possible et c'est vraiment simple si vous le regardez lorsque vous avez terminé l'implémentation, ce qui est encore une fois - très simple, car les seuls éléments dont vous avez besoin sont deux variables booléennes: l'accessibilité à Internet et l'accessibilité de l'hôte (vous avez souvent besoin de plus d'une de ces ). Une fois que vous avez assemblé votre classe d'assistance qui peut déterminer l'état des connexions, vous ne vous souciez vraiment plus de l'implémentation nécessaire pour connaître ces procédures.

Exemple:

#import <Foundation/Foundation.h>

@class Reachability;

@interface ConnectionManager : NSObject {
    Reachability *internetReachable;
    Reachability *hostReachable;
}

@property BOOL internetActive;
@property BOOL hostActive;

- (void) checkNetworkStatus:(NSNotification *)notice;

@end

Et le fichier .m:

#import "ConnectionManager.h"
#import "Reachability.h"

@implementation ConnectionManager
@synthesize internetActive, hostActive;

-(id)init {
    self = [super init];
    if(self) {

    }
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(checkNetworkStatus:) name:kReachabilityChangedNotification object:nil];

    internetReachable = [[Reachability reachabilityForInternetConnection] retain];
    [internetReachable startNotifier];

    hostReachable = [[Reachability reachabilityWithHostName:@"www.apple.com"] retain];
    [hostReachable startNotifier];

    return self;
}

- (void) checkNetworkStatus:(NSNotification *)notice {
    NetworkStatus internetStatus = [internetReachable currentReachabilityStatus];
    switch (internetStatus)

    {
        case NotReachable:
        {
            NSLog(@"The internet is down.");
            self.internetActive = NO;

            break;

        }
        case ReachableViaWiFi:
        {
            NSLog(@"The internet is working via WIFI.");
            self.internetActive = YES;

            break;

        }
        case ReachableViaWWAN:
        {
            NSLog(@"The internet is working via WWAN.");
            self.internetActive = YES;

            break;

        }
    }

    NetworkStatus hostStatus = [hostReachable currentReachabilityStatus];
    switch (hostStatus)

    {
        case NotReachable:
        {
            NSLog(@"A gateway to the host server is down.");
            self.hostActive = NO;

            break;

        }
        case ReachableViaWiFi:
        {
            NSLog(@"A gateway to the host server is working via WIFI.");
            self.hostActive = YES;

            break;

        }
        case ReachableViaWWAN:
        {
            NSLog(@"A gateway to the host server is working via WWAN.");
            self.hostActive = YES;

            break;

        }
    }

}

// If lower than SDK 5 : Otherwise, remove the observer as pleased.

- (void)dealloc {
    [[NSNotificationCenter defaultCenter] removeObserver:self];
    [super dealloc];
}

@end

Quelqu'un a déjà résolu ce problème d'une manière simple et réutilisable. DDGReachability.

EDIT: Ou tonymillion/Reachability.

J'ai extrait le code et mis en une seule méthode, j'espère que cela aiderait les autres.

#import <SystemConfiguration/SystemConfiguration.h>

#import <netinet/in.h>
#import <netinet6/in6.h>

...

- (BOOL)isInternetReachable
{    
    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);
    SCNetworkReachabilityFlags flags;

    if(reachability == NULL)
        return false;

    if (!(SCNetworkReachabilityGetFlags(reachability, &flags)))
        return false;

    if ((flags & kSCNetworkReachabilityFlagsReachable) == 0)
        // if target host is not reachable
        return false;


    BOOL isReachable = false;


    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
        isReachable = true;
    }


    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
            isReachable = true;
        }
    }

    if ((flags & kSCNetworkReachabilityFlagsIsWWAN) == kSCNetworkReachabilityFlagsIsWWAN)
    {
        // ... but WWAN connections are OK if the calling application
        //     is using the CFNetwork (CFSocketStream?) APIs.
        isReachable = true;
    }


    return isReachable;


}

J'écris la version rapide de la réponse acceptée ici , au cas où si quelqu'un la trouve utile, le code est écrit swift 2,

Vous pouvez télécharger les fichiers requis à partir de SampleCode

Ajouter Reachability.het Reachability.mdéposer à votre projet,

Maintenant, il faudra créer un Bridging-Header.hfichier s'il n'en existe pas pour votre projet,

À l'intérieur de votre Bridging-Header.hfichier, ajoutez cette ligne:

#import "Reachability.h"

Maintenant, pour vérifier la connexion Internet

static func isInternetAvailable() -> Bool {
    let networkReachability : Reachability = Reachability.reachabilityForInternetConnection()
    let networkStatus : NetworkStatus = networkReachability.currentReachabilityStatus()

    if networkStatus == NotReachable {
        print("No Internet")
        return false
    } else {
        print("Internet Available")
        return true
    }

}

Je pense que cela pourrait aider.

[[AFNetworkReachabilityManager sharedManager] startMonitoring];

if([AFNetworkReachabilityManager sharedManager].isReachable)
{
    NSLog(@"Network reachable");
}
else
{   
   NSLog(@"Network not reachable");
}

Vous pouvez également essayer celui-ci si vous avez déjà configuré AFNetworking dans votre projet.

-(void)viewDidLoad{  // -- add connectivity notification --//
[[NSNotificationCenter defaultCenter ] addObserver:self selector:@selector(ReachabilityDidChangeNotification:) name:AFNetworkingReachabilityDidChangeNotification object:nil];}
-(void)ReachabilityDidChangeNotification:(NSNotification *)notify
{
// -- NSLog(@"Reachability changed: %@", AFStringFromNetworkReachabilityStatus(status));  -- //
NSDictionary *userInfo =[notif userInfo];
AFNetworkReachabilityStatus status= [[userInfo valueForKey:AFNetworkingReachabilityNotificationStatusItem] intValue];
switch (status)
{
    case AFNetworkReachabilityStatusReachableViaWWAN:
    case AFNetworkReachabilityStatusReachableViaWiFi:
        // -- Reachable -- //
// -- Do your stuff when internet connection is available -- //
        [self getLatestStuff];
        NSLog(@"Reachable");
        break;
    case AFNetworkReachabilityStatusNotReachable:
    default:
        // -- Not reachable -- //
        // -- Do your stuff for internet connection not available -- //
NSLog(@"Not Reachable");
        break;
}
}

Voici une bonne solution pour vérifier la connectivité à l'aide de Swift, sans utiliser l'accessibilité. Je l'ai trouvé sur ce blog .

Créez un nouveau fichier Swift dans votre projet appelé Network.swift(par exemple). Collez ce code dans ce fichier:

import Foundation

public class Network {

    class func isConnectedToNetwork()->Bool{

        var Status:Bool = false
        let url = NSURL(string: "http://google.com/")
        let request = NSMutableURLRequest(URL: url!)
        request.HTTPMethod = "HEAD"
        request.cachePolicy = NSURLRequestCachePolicy.ReloadIgnoringLocalAndRemoteCacheData
        request.timeoutInterval = 10.0

        var response: NSURLResponse?

        var data = NSURLConnection.sendSynchronousRequest(request, returningResponse: &response, error: nil) as NSData?

        if let httpResponse = response as? NSHTTPURLResponse {
            if httpResponse.statusCode == 200 {
                Status = true
            }
        }

        return Status
    }
}

Vous pouvez ensuite vérifier la connectivité n'importe où dans votre projet en utilisant:

if Network.isConnectedToNetwork() == true {
    println("Internet connection OK")
} else {
    println("Internet connection FAILED")
}

EDIT: Cela ne fonctionnera pas pour les URL réseau (voir les commentaires)

À partir d'iOS 5, il existe une nouvelle méthode d'instance NSURL:

- (BOOL)checkResourceIsReachableAndReturnError:(NSError **)error

Dirigez-le vers le site Web qui vous intéresse ou dirigez-le vers apple.com; Je pense que c'est le nouvel appel d'une ligne pour voir si Internet fonctionne sur votre appareil.

Je n'étais pas non plus satisfait des options de vérification Internet disponibles (pourquoi n'est-ce pas une API native?!?!)

Mon propre problème était la perte de 100% des paquets - lorsqu'un appareil est connecté au routeur, mais que le routeur n'est pas connecté à Internet. L'accessibilité et d'autres seront suspendues pendant des siècles. J'ai créé une classe de singleton utilitaire pour gérer cela en ajoutant un délai d'attente asynchrone. Cela fonctionne bien dans mon application. J'espère que ça aide. Voici le lien sur github:

https://github.com/fareast555/TFInternetChecker

Vérification de la disponibilité de la connexion Internet dans (iOS) Xcode 8.2, Swift 3.0

Il s'agit d'une méthode simple pour vérifier la disponibilité du réseau. J'ai réussi à le traduire en Swift 2.0 et ici le code final. La classe d'accessibilité Apple existante et d'autres bibliothèques tierces semblaient trop compliquées à traduire en Swift.

Cela fonctionne pour les connexions 3G 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 Reachability {
class 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)
   }
}

// Check network connectivity from anywhere in project by using this code.

if Reachability.isConnectedToNetwork() == true {
     print("Internet connection OK")
} else {
 print("Internet connection FAILED")
}

Remplacement de l'accessibilité d'Apple réécrit en Swift avec fermetures , inspiré par tonymillion: https://github.com/ashleymills/Reachability.swift

1. Déposez le fichier Reachability.swiftdans votre projet. Vous pouvez également utiliser CocoaPods ou Carthage - Voir la section Installation du fichier README du projet.

2. Recevez des notifications sur la connectivité réseau:

   //declare this property where it won't go out of scope relative to your listener
   let reachability = Reachability()!
   
   reachability.whenReachable = { reachability in
       if reachability.isReachableViaWiFi {
           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")
   }

   et pour arrêter les notifications

   reachability.stopNotifier()

Alamofire

Si vous utilisez déjà Alamofire pour toutes les API RESTful, 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 se connecte ou se déconnecte du réseau, il remplace self.reachablecorrectement true / false, car nous commençons à écouter l' NetworkReachabilityManagerinitialisation sur singleton.

Aussi, afin de surveiller l'accessibilité, vous devez fournir un hôte, actuellement j'utilise, google.comn'hésitez pas à changer pour tout autre hôte ou l'un des vôtres si nécessaire.