pero - ¿Cómo comprobar una conexión activa a Internet en iOS o macOS?

mi mac se desconecta del wifi constantemente

Question

Me gustaría verificar si tengo una conexión a Internet en iOS utilizando las bibliotecas de Cocoa Touch o en macOS utilizando las bibliotecas de Cocoa

Se me ocurrió una manera de hacer esto usando un NSURL . La forma en que lo hice me parece un poco poco confiable (porque incluso Google podría estar un día deprimido y confiar en un tercero parece malo), y si bien podría verificar si hay alguna respuesta de otros sitios web si Google no responde, Parece un desperdicio y una sobrecarga innecesaria en mi aplicación.

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

Es lo que he hecho mal (por no mencionar que stringWithContentsOfURL está en desuso en iOS 3.0 y macOS 10.4) y, de ser así, ¿cuál es la mejor manera de lograrlo?

Answer 1

1. Descargue el archivo de accesibilidad, https://gist.github.com/darkseed/1182373

2. Y agregue CFNetwork.framework y ''SystemConfiguration.framework'' en el marco

3. Hacer #importar "Reachability.h"

Primero : Añadir CFNetwork.framework en marco

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

Answer 2

Apple proporciona una aplicación de muestra que hace exactamente esto:

Reachability

Answer 3

Apple suministra código de muestra para verificar diferentes tipos de disponibilidad de red. Alternativamente, hay un example en el libro de cocina de los desarrolladores de iPhone.

Nota: consulte el comentario de @KHG sobre esta respuesta con respecto al uso del código de accesibilidad de Apple.

Answer 4

Aquí hay una respuesta muy simple:

NSURL *scriptUrl = [NSURL URLWithString:@"http://www.google.com/m"];
NSData *data = [NSData dataWithContentsOfURL:scriptUrl];
if (data)
NSLog(@"Device is connected to the Internet");
else
NSLog(@"Device is not connected to the Internet");

La URL debe apuntar a un sitio web extremadamente pequeño. Utilizo el sitio web móvil de Google aquí, pero si tuviera un servidor web confiable, subiría un pequeño archivo con un solo carácter para la máxima velocidad.

Si comprobar que el dispositivo está conectado de alguna manera a Internet es todo lo que quiere hacer, definitivamente recomendaría usar esta solución simple. Si necesita saber cómo está conectado el usuario, usar Reachability es el camino a seguir.

Cuidado: esto bloqueará brevemente su hilo mientras carga el sitio web. En mi caso, esto no fue un problema, pero debería considerar esto (se lo agradezco a Brad por señalarlo).

Answer 5

Aquí se encuentra una modernización de Reachability que usa ARC y GCD:

github.com/tonymillion/Reachability

Answer 6

Así es como lo hago en mis aplicaciones: aunque un código de respuesta de estado 200 no garantiza nada, es lo suficientemente estable para mí. Esto no requiere tanta carga como las respuestas de NSData publicadas aquí, ya que la mía solo comprueba la respuesta HEAD.

código SWIFT

func checkInternet(flag:Bool, completionHandler:(internet:Bool) -> Void)
{
UIApplication.sharedApplication().networkActivityIndicatorVisible = true
let url = NSURL(string: "http://www.appleiphonecell.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 Apple''s region universal URL reachable
}
else
{
// No "Internet" aka Apple''s region universal URL un-reachable
}
})
}

Código Objective-C

typedef void(^connection)(BOOL);
- (void)checkInternet:(connection)block
{
NSURL *url = [NSURL URLWithString:@"http://www.appleiphonecell.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 Apple''s region universal URL reachable
}
else
{
// No "Internet" aka Apple''s region universal URL un-reachable
}
}];
}

Answer 7

Esta solía ser la respuesta correcta, pero ahora está desactualizada, ya que debería suscribirse a las notificaciones para lograr la accesibilidad. Este método comprueba sincrónicamente:

Puedes usar la clase de Alcance de Apple. También le permitirá comprobar si Wi-Fi está habilitado:

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 clase de Alcance no se incluye con el SDK, sino que forma parte de esta aplicación de ejemplo de Apple . Solo descárguelo y copie Reachability.h / m a su proyecto. Además, debe agregar el marco SystemConfiguration a su proyecto.

Answer 8

Hacer esto tú mismo es extremadamente simple. El siguiente método funcionará. Solo asegúrese de no permitir que un protocolo de nombre de host como HTTP, HTTPS, etc. se pase con el nombre.

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

Es rápido simple e indoloro.

Answer 9

He usado el código en esta discusión , y parece funcionar bien (¡lea el hilo completo !).

No lo he probado exhaustivamente con cada tipo de conexión concebible (como Wi-Fi ad hoc).

Answer 10

La clase de Alcance está bien para averiguar si la conexión a Internet está disponible para un dispositivo o no ...

Pero en caso de acceder a un recurso de intranet :

Hacer ping al servidor de la intranet con la clase de accesibilidad siempre devuelve verdadero.

Por lo tanto, una solución rápida en este escenario sería crear un método web llamado pingmejunto con otros métodos web en el servicio. El pingmedebe devolver algo.

Así que escribí el siguiente método en funciones comunes

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

El método anterior fue muy útil para mí, por lo que siempre que trato de enviar algunos datos al servidor, siempre verifico la accesibilidad de mi recurso de intranet utilizando esta URLRequest de baja disponibilidad.

Answer 11

Me gusta mantener las cosas simples. La forma en que hago esto es:

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

Luego, uso esto cuando quiero ver si tengo una conexión:

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

Este método no espera a que cambien los estados de la red para hacer cosas. Solo prueba el estado cuando lo pides.

Answer 12

Me pareció simple y fácil de usar la biblioteca SimplePingHelper .

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

Answer 13

Primero descargue la clase de accesibilidad y coloque el archivo reachability.h y reachabilty.m en su Xcode .

La mejor manera es hacer una clase de Funciones común (NSObject) para que puedas usarla en cualquier clase. Estos son dos métodos para una verificación de accesibilidad de la conexión de red:

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

Ahora puede verificar la conexión de red en cualquier clase llamando a este método de clase.

Answer 14

Puede usar Reachability by  ( disponible aquí ).

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

Answer 15

Si está utilizando AFNetworking , puede usar su propia implementación para el estado de accesibilidad de Internet.

La mejor manera de usar AFNetworking es subclasificar la clase AFHTTPClient y usar esta clase para hacer sus conexiones de red.

Una de las ventajas de usar este enfoque es que puede usar blocks para establecer el comportamiento deseado cuando cambia el estado de accesibilidad. Suponiendo que he creado una subclase singleton de AFHTTPClient (como se dice en las "Notas de Subclasificación " en los documentos de AFNetworking ) llamado BKHTTPClient , haría algo como:

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

También puede buscar conexiones Wi-Fi o WLAN específicamente utilizando las AFNetworkReachabilityStatusReachableViaWWAN y AFNetworkReachabilityStatusReachableViaWiFi ( más aquí ).

Answer 16

Solo la clase de Alcance ha sido actualizada. Ahora puedes 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");}

Answer 17

También hay otro método para verificar la conexión a Internet usando el iPhone SDK.

Intente implementar el siguiente código para la conexión de red.

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

Answer 18

Una versión de Reachability para iOS 5 es darkseed/Reachability.h . ¡No es mío! =)

Answer 19

Usando el código de Alcance de Apple, creé una función que verificará esto correctamente sin que tenga que incluir ninguna clase.

Incluya SystemConfiguration.framework en su proyecto.

Hacer algunas importaciones:

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

Ahora solo llama a esta función:

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

Y es iOS 5 probado para ti.

Answer 20

Utilice http://huytd.github.io/datatify/ . Es más fácil que agregar bibliotecas y escribir código por ti mismo.

Answer 21

Importante : esta comprobación siempre debe realizarse de forma asíncrona. La mayoría de las respuestas a continuación son sincrónicas, así que ten cuidado, de lo contrario congelarás tu aplicación.

Rápido

1) Instale a través de CocoaPods o Carthage: https://github.com/ashleymills/Reachability.swift

2) Probar la accesibilidad a través de cierres

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

C objetivo

1) Agregue el marco SystemConfiguration al proyecto pero no se preocupe por incluirlo en cualquier lugar

2) Agregue la versión de Tony Million de Reachability.h Reachability.m al proyecto (que se encuentra aquí: github.com/tonymillion/Reachability )

3) Actualizar la sección de interfaz.

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

4) Luego implemente este método en el archivo .m de su controlador de vista al que puede llamar

// 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 clase de Reachability es una de las clases más utilizadas en los proyectos, por lo que podría tener conflictos de nombres con otros proyectos. Si esto sucede, tendrá que cambiar el nombre de uno de los pares de archivos Reachability.m a otra cosa para resolver el problema.

Nota: el dominio que uses no importa. Es solo la prueba de una puerta de enlace a cualquier dominio.

Answer 22

Primero : Añadir CFNetwork.framework en marco

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

Answer 23

Verificación de la disponibilidad de la conexión a Internet en (iOS) Xcode 8, Swift 3.0

Este es un método simple para verificar la disponibilidad de la red, ya que nuestro dispositivo está conectado a cualquier red o no. He logrado traducirlo a Swift 3.0 y aquí el código final. La clase existente de Apple Reachability y otras bibliotecas de terceros parecían ser demasiado complicadas para traducir a Swift.

Esto funciona tanto para conexiones 3G, 4G y WiFi.

No olvide agregar "SystemConfiguration.framework" a su generador de proyectos.

//Create new swift class file Reachability in your project.
import SystemConfiguration
public class InternetReachability {
class func isConnectedToNetwork() -> Bool {
var zeroAddress = sockaddr_in(sin_len: 0, sin_family: 0, sin_port: 0, sin_addr: in_addr(s_addr: 0), sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
zeroAddress.sin_len = UInt8(sizeofValue(zeroAddress))
zeroAddress.sin_family = sa_family_t(AF_INET)
let defaultRouteReachability = withUnsafePointer(&zeroAddress) {
SCNetworkReachabilityCreateWithAddress(nil, UnsafePointer($0)).takeRetainedValue()
}
var flags: SCNetworkReachabilityFlags = 0
if SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) == 0 {
return false
}
let isReachable = (flags & UInt32(kSCNetworkFlagsReachable)) != 0
let needsConnection = (flags & UInt32(kSCNetworkFlagsConnectionRequired)) != 0
return isReachable && !needsConnection
}
}
// Check network connectivity from anywhere in project by using this code.
if InternetReachability.isConnectedToNetwork() == true {
print("Internet connection OK")
} else {
print("Internet connection FAILED")
}

Answer 24

Creo que esta es la mejor respuesta.

"Sí" significa conectado. "No" significa desconectado.

#import "Reachability.h"
- (BOOL)canAccessInternet
{
Reachability *IsReachable = [Reachability reachabilityForInternetConnection];
NetworkStatus internetStats = [IsReachable currentReachabilityStatus];
if (internetStats == NotReachable)
{
return NO;
}
else
{
return YES;
}
}

Answer 25

Muy simple ... Prueba estos pasos:

Paso 1: Agregue el marco SystemConfiguration a su proyecto.

Paso 2: Importe el siguiente código en su archivo de header .

#import <SystemConfiguration/SystemConfiguration.h>

Paso 3: Usa el siguiente 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:

  Cabecera de importación : #import "Reachability.h"

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

Paso 4: Cómo utilizar:

- (void)CheckInternet
{
BOOL network = [self currentNetworkStatus];
if (network)
{
NSLog(@"Network Available");
}
else
{
NSLog(@"No Network Available");
}
}

Answer 26

Además de la accesibilidad, también puede utilizar la chrishulbert/SimplePingHelper . Funciona muy bien y es fácil de integrar.

Answer 27

Importe la Reachable.hclase en su ViewController, y use el siguiente código para verificar la conectividad :

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

Answer 28

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

O use la clase de Alcance .

Hay dos formas de verificar la disponibilidad de Internet usando el iPhone SDK:

1. Comprobar si la página de Google está abierta o no.

2. Clase de accesibilidad

Para obtener más información, consulte Reachability (Desarrollador Apple).

Answer 29

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

Answer 30

• Paso 1: Agregue la clase de Alcance en su Proyecto.
• Paso 2: importar la clase de accesibilidad

• Paso 3: Crea la siguiente función

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

• Paso 4: Llame a la función como se muestra a continuación:

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