So che questa domanda sembrerà essere un inganno di molti altri, tuttavia, non credo che il caso semplice sia ben spiegato qui. Proveniente da un background Android e BlackBerry, le richieste HTTPUrlConnectionfalliscono istantaneamente se non è disponibile alcuna connessione. Questo sembra un comportamento completamente sano, e sono stato sorpreso di scoprire che NSURLConnectionin iOS non lo ha emulato.

Comprendo che Apple (e altri che l'hanno esteso) forniscono una Reachabilityclasse per aiutare a determinare lo stato della rete. Sono stato felice di vederlo per primo e mi aspettavo di vedere qualcosa del genere bool isNetworkAvailable(), ma invece con mia sorpresa ho trovato un sistema complesso che richiedeva registrazioni e richiamate delle notifiche e un sacco di dettagli apparentemente non necessari. Deve esserci un modo migliore.

La mia app gestisce già correttamente gli errori di connessione, inclusa la connettività. L'utente viene avvisato dell'errore e l'app procede.

Quindi i miei requisiti sono semplici: singola funzione sincrona che posso chiamare prima di tutte le richieste HTTP per determinare se dovrei preoccuparmi di inviare effettivamente la richiesta o meno. Idealmente non richiede alcuna configurazione e restituisce solo un valore booleano.

Questo non è davvero possibile su iOS?

Ho fatto un po 'più di ricerca e sto aggiornando la mia risposta con una soluzione più attuale. Non sono sicuro che tu l'abbia già visto, ma esiste un buon codice di esempio fornito da Apple.

Scarica qui il codice di esempio

Includi i file Reachability.h e Reachability.m nel tuo progetto. Dai un'occhiata a ReachabilityAppDelegate.m per vedere un esempio su come determinare la raggiungibilità dell'host, la raggiungibilità tramite WiFi, WWAN ecc. Per un controllo molto semplice della raggiungibilità della rete, puoi fare qualcosa del genere

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

@ BenjaminPiette: non dimenticare di aggiungere SystemConfiguration.framework al tuo progetto.

Visto che questa discussione è il miglior risultato di Google per questo tipo di domanda, ho pensato che avrei fornito la soluzione che funzionava per me. Stavo già utilizzando AFNetworking , ma la ricerca non ha rivelato come eseguire questo compito con AFNetworking fino a metà del mio progetto.

Quello che vuoi è 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;
    }

}];

È inoltre possibile utilizzare quanto segue per testare la raggiungibilità in modo sincrono (una volta avviato il monitoraggio):

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

Ci scusiamo per la risposta troppo tardi, ma spero che questa risposta possa aiutare qualcuno in futuro.

Di seguito è riportato un piccolo frammento di codice C nativo che può controllare la connettività Internet senza alcuna classe aggiuntiva.

Aggiungi le seguenti intestazioni:

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

Codice:

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

Attualmente utilizzo questo semplice metodo sincrono che non richiede file extra nei tuoi progetti o delegati.

Importare:

#import <SystemConfiguration/SCNetworkReachability.h>

Crea questo metodo:

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

Quindi, se lo hai inserito in un MyNetworkClass:

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

Se stai testando nel simulatore, attiva e disattiva il wifi del tuo Mac, poiché sembra che il simulatore ignorerà le impostazioni del telefono.

Aggiornare:

1. Alla fine ho usato un thread / callback asincrono per evitare di bloccare il thread principale; e ripetere regolarmente i test in modo da poter utilizzare un risultato memorizzato nella cache, anche se è necessario evitare di tenere inutilmente aperte le connessioni dati.

2. Come descritto da @thunk, ci sono URL migliori da usare, che Apple stessa usa. http://cadinc.com/blog/why-your-apple-ios-7-device-wont-connect-to-the-wifi-network

È possibile ed è davvero semplice se lo guardi quando finisci l'implementazione, il che è di nuovo - molto semplice, poiché gli unici elementi di cui hai bisogno sono due variabili booleane: la raggiungibilità di Internet e la raggiungibilità dell'host (spesso hai bisogno di più di una di queste ). Dopo aver assemblato la tua classe di supporto in grado di determinare lo stato delle connessioni, in realtà non ti importa più dell'implementazione necessaria per conoscere queste procedure.

Esempio:

#import <Foundation/Foundation.h>

@class Reachability;

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

@property BOOL internetActive;
@property BOOL hostActive;

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

@end

E il file .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

Qualcuno ha risolto questo problema in modo semplice e riutilizzabile prima. DDGReachability.

MODIFICA: Or tonymillion/Reachability.

Ho estratto il codice e messo in un unico metodo, spero che possa aiutare gli altri.

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


}

Sto scrivendo la versione rapida della risposta accettata qui , nel caso in cui qualcuno la trovi utile, il codice è scritto rapidamente 2,

È possibile scaricare i file richiesti da SampleCode

Aggiungi Reachability.he Reachability.marchivia al tuo progetto,

Ora sarà necessario creare il Bridging-Header.hfile se non esiste nessuno per il tuo progetto,

All'interno del tuo Bridging-Header.hfile aggiungi questa riga:

#import "Reachability.h"

Ora per verificare la connessione a 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
    }

}

Penso che questo potrebbe aiutare ..

[[AFNetworkReachabilityManager sharedManager] startMonitoring];

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

Puoi anche provare questo se hai già configurato AFNetworking nel tuo progetto.

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

Ecco una buona soluzione per controllare la connettività usando Swift, senza usare la raggiungibilità. L'ho trovato su questo blog .

Crea un nuovo file Swift nel tuo progetto chiamato Network.swift (ad esempio). Incolla questo codice all'interno di quel file:

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

È quindi possibile verificare la connettività in qualsiasi punto del progetto utilizzando:

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

EDIT: questo non funzionerà per gli URL di rete (vedi commenti)

A partire da iOS 5, esiste un nuovo metodo di istanza NSURL:

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

Puntalo al sito web che ti interessa o indirizzalo a apple.com; Penso che sia la nuova chiamata a una linea per vedere se Internet sta funzionando sul tuo dispositivo.

Inoltre, non ero soddisfatto delle opzioni di controllo di Internet disponibili (Perché questa non è un'API nativa?!?!)

Il mio problema era con una perdita di pacchetti del 100%: quando un dispositivo è collegato al router, ma il router non è connesso a Internet. Raggiungibilità e altri resteranno in sospeso per secoli. Ho creato una classe singleton di utilità per gestirla aggiungendo un timeout asincrono. Funziona bene nella mia app. Spero che sia d'aiuto. Ecco il link su github:

https://github.com/fareast555/TFInternetChecker

Verifica della disponibilità della connessione Internet in (iOS) Xcode 8.2, Swift 3.0

Questo è un metodo semplice per verificare la disponibilità della rete. Sono riuscito a tradurlo in Swift 2.0 e qui il codice finale. L'attuale classe di raggiungibilità di Apple e altre librerie di terze parti sembravano troppo complicate per essere tradotte in Swift.

Funziona con connessioni 3G e WiFi.

Non dimenticare di aggiungere "SystemConfiguration.framework" al generatore di progetti.

//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")
}

Sostituzione per la raggiungibilità di Apple riscritta in Swift con chiusure , ispirata a tonymillion: https://github.com/ashleymills/Reachability.swift

1. Rilascia il file Reachability.swiftnel tuo progetto. In alternativa, usa CocoaPods o Carthage - Vedi la sezione Installazione del README del progetto.

2. Ricevi notifiche sulla connettività di rete:

   //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")
   }

   e per interrompere le notifiche

   reachability.stopNotifier()

Alamofire

Se stai già utilizzando Alamofire per tutte le API RESTful, ecco cosa puoi trarne beneficio.

Puoi aggiungere la seguente classe alla tua app e chiamare MNNetworkUtils.main.isConnected()per ottenere un valore booleano sulla connessione o meno.

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

Questa è una classe singleton. Ogni volta, quando l'utente si connette o disconnette la rete, verrà sovrascritto self.reachablecorrettamente su true / false, perché iniziamo ad ascoltare l' NetworkReachabilityManagerinizializzazione di singleton on.

Inoltre, al fine di monitorare la raggiungibilità, è necessario fornire un host, attualmente sto usando google.comsentiti libero di passare a qualsiasi altro host o uno dei tuoi, se necessario.