Gostaria de verificar se tenho uma conexão com a Internet no iOS usando as bibliotecas Cocoa Touch ou no macOS usando as bibliotecas Cocoa .

Eu vim com uma maneira de fazer isso usando um NSURL. A maneira como fiz isso parece um pouco confiável (porque até o Google poderia um dia ficar inoperante e confiar em terceiros parece ruim), e enquanto eu poderia verificar se há uma resposta de outros sites, se o Google não responder, parece um desperdício e uma sobrecarga desnecessária no meu aplicativo.

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

O que fiz de ruim (sem mencionar que stringWithContentsOfURLfoi preterido no iOS 3.0 e no macOS 10.4) e, em caso afirmativo, qual é a melhor maneira de fazer isso?

Importante : Essa verificação sempre deve ser realizada de forma assíncrona. A maioria das respostas abaixo é síncrona, portanto, tenha cuidado, caso contrário, você congelará seu aplicativo.

Rápido

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

2) Teste de acessibilidade via fechamentos

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

Objetivo-C

1) Adicione SystemConfigurationestrutura ao projeto, mas não se preocupe em incluí-la em qualquer lugar

2) Adicione a versão Reachability.he Reachability.mo projeto de Tony Million (encontrado aqui: https://github.com/tonymillion/Reachability )

3) Atualize a seção da interface

#import "Reachability.h"

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

4) Em seguida, implemente esse método no arquivo .m do seu controlador de exibição, que você pode chamar

// 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: A Reachabilityclasse é uma das classes mais usadas em projetos, portanto, você pode encontrar conflitos de nomenclatura com outros projetos. Se isso acontecer, você precisará renomear um dos pares de arquivos Reachability.he Reachability.mpara outra coisa para resolver o problema.

Nota: O domínio que você usa não importa. É apenas um teste para um gateway para qualquer domínio.

Eu gosto de manter as coisas simples. A maneira como faço isso é:

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

Então, eu uso isso sempre que quero ver se tenho uma conexão:

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

Este método não espera por status de rede alterado para fazer as coisas. Apenas testa o status quando você solicita.

Usando o código de acessibilidade da Apple, criei uma função que verificará isso corretamente sem que você precise incluir nenhuma classe.

Inclua o SystemConfiguration.framework no seu projeto.

Faça algumas importações:

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

Agora basta chamar esta função:

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

E o iOS 5 foi testado para você.

Essa costumava ser a resposta correta, mas agora está desatualizada, pois você deve assinar as notificações de acessibilidade. Este método verifica de forma síncrona:

Você pode usar a classe de acessibilidade da Apple. Também permitirá que você verifique se o Wi-Fi está ativado:

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

A classe de alcançabilidade não é fornecida com o SDK, mas faz parte desse aplicativo de amostra da Apple . Basta fazer o download e copiar Reachability.h / m no seu projeto. Além disso, você precisa adicionar a estrutura SystemConfiguration ao seu projeto.

Aqui está uma resposta muito simples:

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

O URL deve apontar para um site extremamente pequeno. Eu uso o site para celular do Google aqui, mas se eu tivesse um servidor da Web confiável, faria o upload de um arquivo pequeno com apenas um caractere para obter a velocidade máxima.

Se verificar se o dispositivo está de alguma forma ligado à Internet é tudo o que você quer fazer, eu definitivamente recomendo usar esta solução simples. Se você precisar saber como o usuário está conectado, usar a Acessibilidade é o caminho a percorrer.

Cuidado: Isso bloqueará brevemente seu tópico enquanto ele carrega o site. No meu caso, isso não foi um problema, mas você deve considerar isso (créditos ao Brad por apontar isso).

Aqui está como eu faço isso nos meus aplicativos: Embora um código de resposta de status 200 não garanta nada, ele é estável o suficiente para mim. Isso não exige tanto carregamento quanto as respostas do NSData postadas aqui, pois o meu apenas verifica a resposta HEAD.

Código 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
        }
    })
}

Código 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
         }
    }];
}

A Apple fornece um código de amostra para verificar os diferentes tipos de disponibilidade da rede. Como alternativa, há um exemplo no livro de receitas dos desenvolvedores do iPhone.

Nota: Consulte o comentário do @ KHG sobre esta resposta sobre o uso do código de acessibilidade da Apple.

Você pode usar Reachabilitypor  ( disponível aqui ).

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

A Apple fornece um aplicativo de exemplo que faz exatamente isso:

Acessibilidade

Somente a classe de alcançabilidade foi atualizada. Agora você pode usar:

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

Uma versão do alcançável para iOS 5 é darkseed / Reachability.h . Não é meu! =)

Há uma modernização de acessibilidade de boa aparência, usando ARC e GCD aqui:

Acessibilidade

Se você estiver usando, AFNetworkingpoderá usar sua própria implementação para o status de acessibilidade da Internet.

A melhor maneira de usar AFNetworkingé subclassificar oAFHTTPClient classe e usá-la para fazer suas conexões de rede.

Uma das vantagens de usar essa abordagem é que você pode usar blockspara definir o comportamento desejado quando o status de alcançabilidade for alterado. Supondo que eu criei uma subclasse singleton de AFHTTPClient(como dito nas "Notas de subclassificação" nos documentos da AFNetworking ) denominada BKHTTPClient, eu faria algo como:

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

Você também pode verificar se há conexões Wi-Fi ou WLAN usando especificamente as enumerações AFNetworkReachabilityStatusReachableViaWWANe AFNetworkReachabilityStatusReachableViaWiFi( mais aqui ).

Eu usei o código nesta discussão e parece funcionar bem (leia toda a tópico!).

Não testei exaustivamente com todos os tipos de conexão possíveis (como Wi-Fi ad hoc).

Muito simples .... Tente estas etapas:

Etapa 1: adicione a SystemConfigurationestrutura ao seu projeto.

Etapa 2: importe o seguinte código no seu headerarquivo.

#import <SystemConfiguration/SystemConfiguration.h>

Etapa 3: Use o seguinte método

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

  Cabeçalho de importação :#import "Reachability.h"

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

Etapa 4: Como usar:

- (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 use a classe de alcançabilidade .

Há duas maneiras de verificar a disponibilidade da Internet usando o iPhone SDK:

1. Verifique se a página do Google está aberta ou não.

2. Classe de acessibilidade

Para mais informações, consulte Acessibilidade (Apple Developer).

Use http://huytd.github.io/datatify/ . É mais fácil do que adicionar bibliotecas e escrever código sozinho.

Primeiro : adicionar CFNetwork.frameworkna estrutura

Código :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");
    }
}

Primeiro, baixe a classe de acessibilidade e coloque o arquivo reachability.he reachabilty.m no seu Xcode .

A melhor maneira é criar uma classe de funções comum (NSObject) para que você possa usá-la em qualquer classe. Estes são dois métodos para uma verificação de acessibilidade da conexão de rede:

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

Agora você pode verificar a conexão de rede em qualquer classe chamando esse método de classe.

Há também outro método para verificar a conexão com a Internet usando o iPhone SDK.

Tente implementar o seguinte código para a conexão de rede.

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

Achei simples e fácil de usar a biblioteca SimplePingHelper .

Código de exemplo: chrishulbert / SimplePingHelper ( GitHub )

1. Faça o download do arquivo de acessibilidade, https://gist.github.com/darkseed/1182373

2. E adicione CFNetwork.frameworke 'SystemConfiguration.framework' na estrutura

3. Importe #import "Reachability.h"

Primeiro : adicionar CFNetwork.frameworkna estrutura

Código :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

Você deve primeiro importar

import SystemConfiguration

Você pode verificar a conexão à Internet com o seguinte método

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)

}

A classe Acessibilidade é OK para descobrir se a conexão com a Internet está disponível para um dispositivo ou não ...

Mas no caso de acessar um recurso da intranet :

Efetuar ping no servidor da intranet com a classe de alcançabilidade sempre retorna true.

Portanto, uma solução rápida nesse cenário seria criar um método da web chamado pingmejunto com outros métodos da web no serviço. O pingmedeve retornar algo.

Então, eu escrevi o seguinte método em funções comuns

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

O método acima foi muito útil para mim; portanto, sempre que tento enviar alguns dados para o servidor, sempre verifico a acessibilidade do meu recurso da intranet usando este URLRequest de tempo limite baixo.

Fazer isso sozinho é extremamente simples. O método a seguir irá funcionar. Apenas certifique-se de não permitir que um protocolo de nome de host como HTTP, HTTPS etc. seja passado com o nome.

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

É rápido, simples e indolor.

Além da acessibilidade, você também pode usar a biblioteca auxiliar Simple Ping . Funciona muito bem e é simples de integrar.

Eu acho que essa é a melhor resposta.

"Sim" significa conectado. "Não" significa desconectado.

#import "Reachability.h"

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

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

Importe a Reachable.hclasse no seu ViewControllere use o seguinte código para verificar a conectividade :

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

• Etapa 1: adicione a classe de acessibilidade em seu projeto.
• Etapa 2: Importar a classe Acessibilidade

• Etapa 3: Crie a função abaixo

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

• Etapa 4: chame a função como abaixo:

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