Wie für eine aktive Internetverbindung auf iOS oder macOS zu überprüfen?

StackOverflow https://stackoverflow.com/questions/1083701

Frage

Ich würde gerne sehen, um zu überprüfen, ob ich eine Internetverbindung auf iOS habe mit dem Cocoa Touch Bibliotheken oder auf macOS die Cocoa Bibliotheken.

Ich kam mit einer Art und Weise, dies zu tun, um eine NSURL verwenden. Die Art und Weise habe ich es ein bisschen unzuverlässig scheint (denn auch Google könnte eines Tages nach unten sein und unter Berufung auf einen Dritten scheint schlecht), und während ich könnte prüfen, auf eine Antwort von einigen anderen Websites zu sehen, ob Google reagierte nicht, es scheint verschwenderisch und ein unnötiger Aufwand auf meiner Anwendung. 

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

Ist das, was ich habe schlecht getan, (nicht stringWithContentsOfURL zu erwähnen ist in iOS 3.0 veraltet und Mac OS 10.4) und wenn ja, was ist ein besserer Weg, dies zu erreichen?

War es hilfreich?

Lösung

Wichtig : Diese Prüfung sollte immer asynchron ausgeführt werden. Die Mehrheit der Antworten unten synchron sind so vorsichtig sein, sonst werden Sie Ihre Anwendung einfrieren.

Swift

Installieren

1) über CocoaPods oder Karthago: https://github.com/ashleymills/Reachability.swift

2) Test Erreichbarkeit über Schließungen 

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) SystemConfiguration Rahmen für das Projekt hinzufügen, aber keine Sorge über sich überall einschließlich

2) hinzufügen Tony Million Version von Reachability.h und Reachability.m zum Projekt (gefunden hier: https://github.com / tonymillion / Erreichbarkeits )

3) Aktualisieren der Schnittstellenbereich 

#import "Reachability.h"

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

4) Dann diese Methode in der .m-Datei Ihrer View-Controller implementieren, die Sie aufrufen können, 

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

Wichtiger Hinweis: Die Reachability Klasse ist eines der am häufigsten verwendeten Klassen in Projekten, so dass Sie in Namenskonflikte mit anderen Projekten laufen könnten. Wenn dies geschieht, werden Sie umbenennen eines der Paare von Reachability.h und Reachability.m Dateien auf etwas anderes, das Problem zu lösen.

Hinweis: Die Domain, die Sie verwenden keine Rolle. Es ist nur die Prüfung für ein Gateway zu einem beliebigen Domäne.

Andere Tipps

Ich mag Dinge einfach zu halten. Die Art, wie ich dies tun, ist: 

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

Dann benutze ich diese, wenn ich sehen möchte, wenn ich eine Verbindung haben: 

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

Diese Methode wartet nicht auf geänderte Netzwerkstatus, um Sachen zu tun. Es prüft nur den Status, wenn Sie bitten, es zu.

Mit Apples Erreichbarkeits Code, habe ich eine Funktion, die das richtig prüfen wird, ohne dass Sie alle Klassen enthalten sind.

Fügen Sie die SystemConfiguration.framework in Ihrem Projekt.

Machen Sie einige Importe: 

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

Jetzt diese Funktion rufen Sie einfach an: 

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

Und es ist iOS 5 für Sie getestet.

Dieses verwendet die richtige Antwort zu sein, aber es ist jetzt veraltet, wie Sie stattdessen Benachrichtigungen für Erreichbarkeits abonnieren sollten. Dieses Verfahren prüft synchron:

Sie können mit Apples Erreichbarkeits-Klasse. Es wird auch ermöglicht es Ihnen, zu überprüfen, ob Wi-Fi aktiviert ist: 

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

Die Erreichbarkeits Klasse ist nicht mit dem SDK geliefert, sondern ein Teil von diese Apple-Beispielanwendung . Reachability.h / m zu einem Projekt Einfach herunterladen, und kopiert. Außerdem haben Sie die Systemconfiguration Rahmen zu einem Projekt hinzuzufügen.

Hier ist eine sehr einfache Antwort: 

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

Die URL sollte auf eine extrem kleine Website verweisen. Ich verwende Google Mobile Website hier, aber wenn ich einen zuverlässigen Web-Server hätte, würde ich laden eine kleine Datei mit nur einem Zeichen in ihm für maximale Geschwindigkeit.

Wenn geprüft wird, ob es das Gerät irgendwie mit dem Internet verbunden ist alles, was Sie tun wollen, würde ich auf jeden Fall empfehlen, diese einfache Lösung. Wenn Sie wissen müssen, wie der Benutzer verbunden ist, unter Verwendung von Erreichbarkeits ist der Weg zu gehen.

Achtung: Dies wird der Thread kurz blockieren, während es auf der Website lädt. In meinem Fall war dies kein Problem, aber Sie sollten diese (Kredite an Brad für den Hinweis) in Betracht ziehen.

Hier ist, wie ich es tue in meinen apps: Während ein 200-Statusantwortcode nicht alles garantieren, ist es für mich stabil genug ist. Dies gilt nicht so viel Belastung erfordern, da die NSData Antworten hier gepostet, wie ich nur die HEAD-Antwort überprüft.

Swift Code 

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

Objective-C-Code 

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-liefert Beispielcode für verschiedene Arten von Netzwerk-Verfügbarkeit zu überprüfen. Alternativ gibt es ein Beispiel in dem iPhone-Entwickler Kochbuch.

. Hinweis: finden Sie unter @ KHG Kommentar zu dieser Antwort in Bezug auf die Verwendung von Apples Erreichbarkeits Code

Sie Reachability von  nutzen könnten ( verfügbar hier ). 

#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 stellt eine Beispielanwendung, die tut genau dies:

Erreichbarkeits

Nur die Erreichbarkeits Klasse wird aktualisiert. Sie können nun verwendet werden: 

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

Eine Version auf Erreichbarkeits für iOS 5 ist Darkseed / Reachability.h . Es ist nicht meins! =)

Es gibt eine gut aussehenden, ARC- und GCD betriebene Modernisierung von Erreichbarkeits hier:

Erreichbarkeits

Wenn Sie mit AFNetworking eine eigene Implementierung für den Internet-Erreichbarkeitsstatus verwenden können.

Der beste Weg, AFNetworking zu verwenden ist, um die AFHTTPClient Klasse, Unterklasse und diese Klasse verwenden, um Ihre Netzwerkverbindungen zu tun.

Einer der Vorteile dieses Ansatzes ist, dass Sie blocks verwenden können, um das gewünschte Verhalten, wenn die Erreichbarkeitsstatus ändert einzustellen. Angenommen, dass ich eine Singleton-Unterklasse von AFHTTPClient erstellt haben (wie gesagt auf den „Subclassing Hinweise“ auf AFNetworking docs ) genannt BKHTTPClient, ich möchte etwas tun: 

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

Sie könnten auch für Wi-Fi oder WLAN-Verbindungen überprüfen speziell auf die AFNetworkReachabilityStatusReachableViaWWAN und AFNetworkReachabilityStatusReachableViaWiFi Aufzählungen mit ( mehr hier ).

Ich habe den Code in diese Diskussion , und es scheint gut zu funktionieren (lesen sie die ganze Thread!).

Ich habe es nicht erschöpfend mit jeder denkbaren Art von Verbindung (wie Ad-hoc-Wi-Fi) getestet.

Sehr einfach .... Versuchen Sie diese Schritte:

Schritt 1:. Fügen Sie den SystemConfiguration Rahmen in Ihr Projekt

Schritt 2: Importieren Sie den folgenden Code in der Datei header

. 
#import <SystemConfiguration/SystemConfiguration.h>

Schritt 3: Verwenden Sie die folgende Methode

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

  • Typ 2:

    Import Header : #import "Reachability.h" 

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

Schritt 4: Wie zu verwenden: 

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

Oder verwenden Sie die Erreichbarkeits Klasse .

Es gibt zwei Möglichkeiten, die Internetverfügbarkeit mit dem iPhone SDK zu überprüfen:

1. Überprüfen Sie die Google-Seite geöffnet ist oder nicht.

2. Erreichbarkeits Klasse

Weitere Informationen finden Sie auf Erreichbarkeits (Apple Developer).

Verwenden Sie http://huytd.github.io/datatify/ . Es ist einfacher als das Hinzufügen Bibliotheken und Code schreiben selbst.

Erste : In CFNetwork.framework im Rahmen

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

Zuerst die Erreichbarkeit Klasse herunterladen und setzen reachability.h und reachabilty.m Datei in Ihrem Xcode .

Der beste Weg ist es, eine gemeinsame Funktionen Klasse (NSObject) zu machen, so dass Sie es jede Klasse nutzen können. Dies sind zwei Methoden für eine Netzwerkverbindung Erreichbarkeitsprüfung: 

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

Jetzt können Sie die Netzwerkverbindung in jeder Klasse überprüfen, indem Sie diese Klasse Methode aufrufen.

Es gibt auch eine andere Methode Internet-Verbindung mit dem iPhone SDK zu überprüfen.

Versuchen Sie den folgenden Code für die Netzwerkverbindung zu implementieren. 

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

Ich fand es einfach und leicht Bibliothek verwenden SimplePingHelper .

Beispielcode: chrishulbert / SimplePingHelper ( GitHub )

  1. Laden Sie die Erreichbarkeits Datei, https://gist.github.com/darkseed/1182373

  2. Und fügen CFNetwork.framework und 'SystemConfiguration.framework' im Rahmen

  3. Sie #import "Reachability.h"


Erste : In CFNetwork.framework im Rahmen

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

Die Erreichbarkeits Klasse OK ist, um herauszufinden, ob die Internetverbindung zu einem Gerät verfügbar ist oder nicht ...

Aber bei dem Zugriff auf eine Intranetressource :

Pingen des Intranet-Server mit der Erreichbarkeits Klasse immer true zurück.

So eine schnelle Lösung in diesem Szenario wäre eine Web-Methode namens pingme erstellen zusammen mit anderen webmethods auf dem Dienst. Die pingme sollte etwas zurück.

Also schrieb ich die folgende Methode auf gemeinsame Funktionen 

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

Das obige Verfahren war so nützlich für mich, so, wenn ich versuche, einige Daten an den Server zu senden, überprüfe ich immer die Erreichbarkeit meiner Intranetressource mit diesem niedrigen Timeout URLRequest.

Um dies zu tun, um sich ist extrem einfach. Die folgende Methode funktioniert. Nur sicher sein, nicht einen Hostnamen Protokoll wie HTTP, HTTPS zulassen, usw. mit dem Namen übergeben werden. 

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

Es ist schnell einfach und schmerzlos.

Neben der Erreichbarkeit können Sie auch die Einfache Ping Helfer Bibliothek . Es funktioniert wirklich schön und ist einfach zu integrieren.

Ich denke, das ist die beste Antwort.

"Ja" bedeutet verbunden. "Nein" bedeutet getrennt. 

#import "Reachability.h"

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

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

Import Reachable.h Klasse in Ihrer ViewController, und verwenden Sie den folgenden Code überprüfen Konnektivität : 

     #define hasInternetConnection [[Reachability reachabilityForInternetConnection] isReachable]
     if (hasInternetConnection){
           // To-do block
     }
  • Schritt 1:. Fügen Sie die Erreichbarkeits Klasse in Ihrem Projekt
  • Schritt 2: Importieren der Erreichbarkeits-Klasse

  • Schritt 3: Erstellen Sie die unten Funktion 

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

  • Schritt 4: Rufen Sie die Funktion wie folgt: 

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

Überprüfen der Internetverbindung Verfügbarkeit in (iOS) Xcode 8, Swift 3.0

  

Dies ist einfache Methode zur Überprüfung der Netzwerkverfügbarkeit wie unser Gerät mit einem Netzwerk verbunden ist oder nicht. Ich habe es geschafft, es zu Swift 3.0 zu übersetzen und hier den endgültigen Code. Die bestehende Apple-Erreichbarkeits-Klasse und andere Drittanbieter-Bibliotheken schienen zu kompliziert werden, um Swift zu übersetzen.

     

Dies funktioniert sowohl für 3G, 4G und WiFi-Verbindungen.

     

Vergessen Sie nicht, „SystemConfiguration.framework“ in Ihr Projekt Builder hinzuzufügen. 

//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")
  }
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top