Vorrei verificare se ho una connessione Internet su iOS usando le librerie Cocoa Touch o su macOS usando le librerie Cocoa .

Ho trovato un modo per farlo usando un NSURL. Il modo in cui l'ho fatto sembra un po 'inaffidabile (perché anche un giorno Google potrebbe essere inattivo e fare affidamento su una terza parte sembra male), e mentre potrei controllare per vedere una risposta da altri siti Web se Google non ha risposto, sembra dispendioso e un sovraccarico inutile sulla mia domanda.

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

È ciò che ho fatto di male (per non parlare del fatto che stringWithContentsOfURLè deprecato in iOS 3.0 e macOS 10.4) e, in tal caso, qual è il modo migliore per farlo?

Importante : questo controllo deve essere sempre eseguito in modo asincrono. La maggior parte delle risposte di seguito sono sincrone, quindi fai attenzione, altrimenti congelerai la tua app.

veloce

1) Installa tramite CocoaPods o Carthage: https://github.com/ashleymills/Reachability.swift

2) Test di raggiungibilità tramite chiusure

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) Aggiungi un SystemConfigurationframework al progetto ma non preoccuparti di includerlo ovunque

2) Aggiungi la versione di Tony Million Reachability.he Reachability.mal progetto (disponibile qui: https://github.com/tonymillion/Reachability )

3) Aggiorna la sezione dell'interfaccia

#import "Reachability.h"

// Add this to the interface in the .m file of your view controller
@interface MyViewController ()
{
    Reachability *internetReachableFoo;
}
@end

4) Quindi implementare questo metodo nel file .m del controller della vista che è possibile chiamare

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

Nota importante: la Reachabilityclasse è una delle classi più utilizzate nei progetti, pertanto è possibile che si verifichino conflitti di denominazione con altri progetti. In questo caso, dovrai rinominare una delle coppie di Reachability.he Reachability.mfile in qualcos'altro per risolvere il problema.

Nota: il dominio che usi non ha importanza. Sta solo testando un gateway per qualsiasi dominio.

Mi piace mantenere le cose semplici. Il modo in cui lo faccio è:

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

Quindi, lo uso ogni volta che voglio vedere se ho una connessione:

if (![self connected]) {
    // Not connected
} else {
    // Connected. Do some Internet stuff
}

Questo metodo non attende gli stati di rete modificati per eseguire operazioni. Verifica solo lo stato quando lo chiedi.

Usando il codice di raggiungibilità di Apple, ho creato una funzione che lo controllerà correttamente senza che tu debba includere alcuna classe.

Includi SystemConfiguration.framework nel tuo progetto.

Effettua alcune importazioni:

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

Ora chiama questa funzione:

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

Ed è iOS 5 testato per te.

Questa era la risposta corretta, ma ora è obsoleta in quanto è necessario sottoscrivere le notifiche per la raggiungibilità. Questo metodo controlla in modo sincrono:

Puoi utilizzare la classe di raggiungibilità di Apple. Ti permetterà anche di verificare se il Wi-Fi è abilitato:

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 di raggiungibilità non viene fornita con l'SDK, ma piuttosto una parte di questa applicazione di esempio Apple . Scaricalo e copia Reachability.h / m nel tuo progetto. Inoltre, devi aggiungere il framework SystemConfiguration al tuo progetto.

Ecco una risposta molto semplice:

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 dovrebbe puntare a un sito Web estremamente piccolo. Uso il sito Web mobile di Google qui, ma se avessi un server Web affidabile, caricarei un piccolo file con un solo carattere per la massima velocità.

Se verificare se il dispositivo è in qualche modo connesso a Internet è tutto ciò che vuoi fare, ti consiglio vivamente di utilizzare questa semplice soluzione. Se hai bisogno di sapere come è connesso l'utente, utilizzare Raggiungibilità è la strada da percorrere.

Attenzione: questo bloccherà brevemente il tuo thread mentre carica il sito web. Nel mio caso, questo non è stato un problema, ma dovresti considerare questo (crediti a Brad per averlo sottolineato).

Ecco come lo faccio nelle mie app: Mentre un codice di risposta di stato 200 non garantisce nulla, è abbastanza stabile per me. Questo non richiede tanto caricamento quanto le risposte NSData pubblicate qui, poiché la mia controlla solo la risposta HEAD.

codice SWIFT

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

Codice Obiettivo-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 fornisce un codice di esempio per verificare la disponibilità di diversi tipi di rete. In alternativa c'è un esempio nel ricettario degli sviluppatori di iPhone.

Nota: vedi il commento di @ KHG su questa risposta sull'uso del codice di raggiungibilità di Apple.

È possibile utilizzare Reachabilityda  ( disponibile qui ).

#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 fornisce un'app di esempio che fa esattamente questo:

raggiungibilità

È stata aggiornata solo la classe di raggiungibilità. Ora puoi usare:

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

Una versione su Raggiungibilità per iOS 5 è darkseed / Reachability.h . Non è mio! =)

C'è un bell'aspetto, ARC e GCD-che utilizza la modernizzazione della raggiungibilità qui:

raggiungibilità

Se stai usando AFNetworking , puoi utilizzare la propria implementazione per lo stato di raggiungibilità di Internet.

Il modo migliore per usare AFNetworkingè sottoclasse ilAFHTTPClient classe e utilizzare questa classe per eseguire le connessioni di rete.

Uno dei vantaggi dell'utilizzo di questo approccio è che è possibile utilizzare blocksper impostare il comportamento desiderato quando lo stato di raggiungibilità cambia. Supponendo di aver creato una sottoclasse singleton di AFHTTPClient(come detto nelle "Note sulla sottoclasse" nei documenti di AFNetworking ) BKHTTPClient, farei qualcosa del tipo:

BKHTTPClient *httpClient = [BKHTTPClient sharedClient];
[httpClient setReachabilityStatusChangeBlock:^(AFNetworkReachabilityStatus status)
{
    if (status == AFNetworkReachabilityStatusNotReachable) 
    {
    // Not reachable
    }
    else
    {
        // Reachable
    }
}];

Si potrebbe anche verificare la presenza di connessioni Wi-Fi o WLAN specificamente utilizzando l' AFNetworkReachabilityStatusReachableViaWWANe AFNetworkReachabilityStatusReachableViaWiFienumerazioni ( di più qui ).

Ho usato il codice in questa discussione e sembra funzionare bene (leggi il tutto thread!).

Non l'ho testato esaurientemente con ogni tipo immaginabile di connessione (come il Wi-Fi ad hoc).

Molto semplice .... Prova questi passaggi:

Passaggio 1: aggiungere il SystemConfigurationframework al progetto.

Passaggio 2: importare il seguente codice nel headerfile.

#import <SystemConfiguration/SystemConfiguration.h>

Passaggio 3: utilizzare il seguente metodo

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

• Tipo 2:

  Importa intestazione :#import "Reachability.h"

  - (BOOL)currentNetworkStatus
  {
      Reachability *reachability = [Reachability reachabilityForInternetConnection];
      NetworkStatus networkStatus = [reachability currentReachabilityStatus];
      return networkStatus != NotReachable;
  }

Passaggio 4: come usare:

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

Oppure usa la classe di Raggiungibilità .

Esistono due modi per verificare la disponibilità di Internet utilizzando l'SDK di iPhone:

1. Controlla che la pagina di Google sia aperta o meno.

2. Classe di raggiungibilità

Per ulteriori informazioni, fare riferimento a Raggiungibilità (sviluppatore Apple).

Usa http://huytd.github.io/datatify/ . È più facile che aggiungere librerie e scrivere codice da soli.

Primo : AggiungiCFNetwork.framework nel framework

Codice :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");
    }
}

Per prima cosa scarica la classe di raggiungibilità e inserisci i file reachability.h e reachabilty.m nel tuo Xcode .

Il modo migliore è creare una classe Funzioni comune (NSObject) in modo da poterla utilizzare in qualsiasi classe. Questi sono due metodi per un controllo di raggiungibilità della connessione di rete:

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

Ora puoi controllare la connessione di rete in qualsiasi classe chiamando questo metodo di classe.

Esiste anche un altro metodo per verificare la connessione a Internet utilizzando l'SDK di iPhone.

Prova a implementare il seguente codice per la connessione di rete.

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

Ho trovato semplice e facile da usare la libreria SimplePingHelper .

Codice di esempio: chrishulbert / SimplePingHelper ( GitHub )

1. Scarica il file di raggiungibilità, https://gist.github.com/darkseed/1182373

2. E aggiungi CFNetwork.frameworke 'SystemConfiguration.framework' nel framework

3. Fai #import "Reachability.h"

Primo : aggiungiCFNetwork.framework nel framework

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

Devi prima importare

import SystemConfiguration

È possibile verificare la connessione Internet con il seguente metodo

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 di raggiungibilità è OK per scoprire se la connessione Internet è disponibile per un dispositivo o no ...

Ma in caso di accesso a una risorsa intranet :

Il ping del server Intranet con la classe di raggiungibilità restituisce sempre true.

Quindi una soluzione rapida in questo scenario sarebbe quella di creare un metodo web chiamato pingmeinsieme ad altri metodi web sul servizio. Ilpingme dovrebbe restituire qualcosa.

Quindi ho scritto il seguente metodo su funzioni comuni

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

Il metodo di cui sopra è stato molto utile per me, quindi ogni volta che provo a inviare alcuni dati al server controllo sempre la raggiungibilità della mia risorsa intranet usando questo URLRequest a basso timeout.

Farlo da soli è estremamente semplice. Il seguente metodo funzionerà. Assicurati solo di non consentire a un protocollo hostname come HTTP, HTTPS, ecc. Di essere passato con il nome.

-(BOOL)hasInternetConnection:(NSString*)urlAddress
{
    SCNetworkReachabilityRef ref = SCNetworkReachabilityCreateWithName(kCFAllocatorDefault, [urlAddress UTF8String]);
    SCNetworkReachabilityFlags flags;
    if (!SCNetworkReachabilityGetFlags(ref, &flags))
    {
        return NO;
    }
    return flags & kSCNetworkReachabilityFlagsReachable;
}

È veloce, semplice e indolore.

Oltre alla raggiungibilità, puoi anche utilizzare la libreria di supporto Simple Ping . Funziona davvero bene ed è semplice da integrare.

Penso che questa sia la migliore risposta.

"Sì" significa connesso. "No" significa disconnesso.

#import "Reachability.h"

 - (BOOL)canAccessInternet
{
    Reachability *IsReachable = [Reachability reachabilityForInternetConnection];
    NetworkStatus internetStats = [IsReachable currentReachabilityStatus];

    if (internetStats == NotReachable)
    {
        return NO;
    }
    else
    {
        return YES;
    }
}

Importa la Reachable.hclasse nel tuo ViewControllere usa il seguente codice per verificare la connettività :

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

• Passaggio 1: aggiungi la classe di raggiungibilità nel tuo progetto.
• Passaggio 2: importare la classe di raggiungibilità

• Passaggio 3: creare la funzione seguente

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

• Passaggio 4: chiamare la funzione come di seguito:

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