it-swarm.com.de

Wie kann ich unter iOS oder macOS nach einer aktiven Internetverbindung suchen?

Ich möchte prüfen, ob ich unter iOS eine Internetverbindung mit den Bibliotheken Cocoa Touch oder unter macOS mit den Bibliotheken Cocoa habe.

Ich habe einen Weg gefunden, dies mit einer NSURL zu tun. Die Art und Weise, wie ich es gemacht habe, scheint etwas unzuverlässig zu sein (da sogar Google eines Tages ausgefallen sein könnte und sich auf einen Dritten verlässt, scheint es schlecht zu sein), und obwohl ich nach einer Antwort von einigen anderen Websites suchen konnte, falls Google nicht antwortete scheint verschwenderisch und ein unnötiger Aufwand für meine Bewerbung.

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

Ist das, was ich getan habe, schlecht (ganz zu schweigen von stringWithContentsOfURL ist in iOS 3.0 und macOS 10.4 veraltet) und wenn ja, was ist der bessere Weg, dies zu erreichen?

1271
Brock Woolf

Important: Diese Prüfung sollte immer asynchron durchgeführt werden. Die Mehrzahl der Antworten ist synchron. Seien Sie also vorsichtig, da Sie sonst Ihre App einfrieren.


Schnell

1) Installation über CocoaPods oder Carthage: https://github.com/ashleymills/Reachability.Swift

2) Erreichbarkeit über Verschlüsse prüfen

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

Ziel c

1) Fügen Sie das SystemConfiguration-Framework zum Projekt hinzu

2) Fügen Sie Tony Millions Version von Reachability.h und Reachability.m zum Projekt hinzu (hier zu finden: https://github.com/tonymillion/Reachability )

3) Aktualisieren Sie den Schnittstellenabschnitt

#import "Reachability.h"

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

4) Implementieren Sie diese Methode anschließend in der .m-Datei Ihres View-Controllers, 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 eine der am häufigsten verwendeten Klassen in Projekten, sodass Sie möglicherweise Namenskonflikte mit anderen Projekten erhalten. In diesem Fall müssen Sie eines der Paare von Reachability.h- und Reachability.m-Dateien umbenennen, um das Problem zu beheben.

Hinweis: Die von Ihnen verwendete Domäne spielt keine Rolle. Es wird lediglich nach einem Gateway für eine beliebige Domäne gesucht.

1246
iwasrobbed

Ich mag es, Dinge einfach zu halten. Ich mache das so:

//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 das immer, wenn ich sehen möchte, ob ich eine Verbindung habe:

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

Diese Methode wartet nicht auf geänderte Netzwerkstatus, um etwas zu erledigen. Es testet nur den Status, wenn Sie ihn dazu auffordern.

305
cannyboy

Mit dem Reachability-Code von Apple habe ich eine Funktion erstellt, die dies korrekt überprüft, ohne dass Sie Klassen hinzufügen müssen.

Fügen Sie das SystemConfiguration.framework in Ihr Projekt ein.

Machen Sie einige Importe:

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

Rufen Sie jetzt einfach diese Funktion auf:

/*
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.

144
Andrew Zimmer

Dies war früher die richtige Antwort, aber sie ist jetzt veraltet, da Sie stattdessen Benachrichtigungen für die Erreichbarkeit abonnieren sollten. Diese Methode prüft synchron:


Sie können die Reachability-Klasse von Apple verwenden. Sie können auch prüfen, ob WLAN 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 Reachability-Klasse wird nicht mit dem SDK geliefert, sondern ist Teil der dieser Apple-Beispielanwendung . Laden Sie es einfach herunter und kopieren Sie Reachability.h/m in Ihr Projekt. Außerdem müssen Sie das SystemConfiguration-Framework zu Ihrem Projekt hinzufügen.

119
Daniel Rinser

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 benutze die mobile Website von Google hier, aber wenn ich einen zuverlässigen Webserver hätte, würde ich eine kleine Datei mit nur einem Zeichen hochladen - für maximale Geschwindigkeit.

Wenn Sie nur prüfen möchten, ob das Gerät irgendwie mit dem Internet verbunden ist, sollten Sie diese einfache Lösung verwenden. Wenn Sie wissen möchten, wie der Benutzer verbunden ist, empfiehlt sich die Verwendung von Erreichbarkeit.

Achtung: Dadurch wird Ihr Thread beim Laden der Website kurz blockiert. In meinem Fall war dies kein Problem, aber Sie sollten dies in Betracht ziehen (danken Brad dafür, dass Sie darauf hingewiesen haben).

80
Erik

So mache ich das in meinen Apps: Während ein Statuscode mit 200 Status nichts garantiert, ist er für mich stabil genug. Dies erfordert nicht so viel Laden wie die hier veröffentlichten NSData-Antworten, da meine lediglich die Antwort HEAD ü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
        }
    })
}

Ziel-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
         }
    }];
}
71
klcjr89

Apple liefert Beispielcode , um nach verschiedenen Arten der Netzwerkverfügbarkeit zu suchen. Alternativ gibt es ein Beispiel im Kochbuch des iPhone-Entwicklers.

Hinweis: Bitte beachten Sie den Kommentar von @ KHG zu dieser Antwort bezüglich der Verwendung des Erreichbarkeitscodes von Apple.

56
teabot

Sie können Reachability von  ( hier ) verwenden.

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

Apple bietet eine Beispiel-App, die genau dies ermöglicht:

Erreichbarkeit

39
user133319

Nur die Reachability-Klasse wurde aktualisiert. Sie können jetzt verwenden:

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

Eine Version von Reachability für iOS 5 ist darkseed/Reachability.h. Es ist nicht meins! =)

27
Alex

Es gibt hier eine schön aussehende, ARC- und GCD-nutzende Modernisierung der Erreichbarkeit:

Erreichbarkeit

25
JK Laiho

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

Die beste Möglichkeit, AFNetworking zu verwenden, ist die Unterklasse der AFHTTPClient-Klasse und die Verwendung dieser Klasse für Ihre Netzwerkverbindungen.

Ein Vorteil dieser Methode besteht darin, dass Sie mit blocks das gewünschte Verhalten einstellen können, wenn sich der Erreichbarkeitsstatus ändert. Angenommen, ich habe eine Singleton-Unterklasse von AFHTTPClient erstellt (wie in den "Unterklassungsnotizen" in AFNetworking docs ) mit dem Namen BKHTTPClient gesagt, würde ich Folgendes tun:

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

Sie können auch gezielt nach WLAN- oder WLAN-Verbindungen suchen, indem Sie die Enummen AFNetworkReachabilityStatusReachableViaWWAN und AFNetworkReachabilityStatusReachableViaWiFi ( more here ) verwenden.

22
Bruno Koga

Ich habe den Code in diese Diskussion verwendet, und es scheint gut zu funktionieren (lesen Sie den whole - Thread!).

Ich habe es nicht mit jeder erdenklichen Art von Verbindung (z. B. Ad-hoc-WLAN) ausgiebig getestet. 

18
Felixyz

 

Sehr einfach .... Versuchen Sie diese Schritte:

Schritt 1: Füge das SystemConfiguration-Framework zu deinem Projekt hinzu.


Schritt 2: Importiere den folgenden Code in deine header-Datei.

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

    Header importieren : #import "Reachability.h"

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

Schritt 4: Verwendung:

- (void)CheckInternet
{
    BOOL network = [self currentNetworkStatus];
    if (network)
    {
        NSLog(@"Network Available");
    }
    else
    {
        NSLog(@"No Network Available");
    }
}
14
svmrajesh
-(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;
}
}
12
Mutawe
- (void)viewWillAppear:(BOOL)animated
{
    NSString *URL = [NSString stringWithContentsOfURL:[NSURL URLWithString:@"http://www.google.com"]];

    return (URL != NULL ) ? YES : NO;
}

Oder verwenden Sie die Reachability-Klasse.

Es gibt zwei Möglichkeiten, die Verfügbarkeit des Internets mithilfe des iPhone SDK zu überprüfen:

1. Prüfen Sie, ob die Google-Seite geöffnet ist oder nicht.

2. Erreichbarkeitsklasse

Weitere Informationen finden Sie unter Reachability (Apple Developer).

11
IOS Rocks

Zuerst : CFNetwork.framework im Framework hinzufügen

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

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

10
Huy Tran

Es gibt auch eine andere Methode zum Überprüfen der Internetverbindung mithilfe des iPhone SDK.

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;
}
8
iProgrammer
  1. Laden Sie die Erreichbarkeitsdatei herunter, https://Gist.github.com/darkseed/1182373

  2. Fügen Sie im Framework CFNetwork.framework und 'SystemConfiguration.framework' hinzu

  3. #Import "Reachability.h" durchführen


First: Füge CFNetwork.framework im Framework hinzu

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

Dies selbst zu tun ist extrem einfach. Die folgende Methode wird funktionieren. Stellen Sie nur sicher, dass kein Hostnamenprotokoll wie HTTP, HTTPS usw. mit dem Namen übergeben wird.

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

8
Tony

Ich fand es einfach und leicht, die Bibliothek SimplePingHelper zu verwenden.

Beispielcode: chrishulbert/SimplePingHelper ( GitHub )

8
Piyush Dubey

Laden Sie zuerst die Erreichbarkeitsklasse herunter und legen Sie die Datei reachability.h und reachabilty.m in Ihren Xcode .

Der beste Weg ist, eine allgemeine Functions-Klasse (NSObject) zu erstellen, damit Sie jede Klasse verwenden können. Dies sind zwei Methoden für die Überprüfung der Erreichbarkeit von Netzwerkverbindungen:

+(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 Klassenmethode aufrufen.

8
Latika Tiwari

Neben der Erreichbarkeit können Sie auch die Simple Ping-Helper-Bibliothek verwenden. Es funktioniert wirklich schön und ist einfach zu integrieren.

7
user2538944

Mit der Reachability-Klasse können Sie feststellen, ob die Internetverbindung für ein Gerät verfügbar ist oder nicht.

Wenn Sie jedoch auf eine Intranet-Ressource zugreifen:

Ein Ping des Intranetservers mit der Erreichbarkeitsklasse gibt immer "true" zurück.

Eine schnelle Lösung in diesem Szenario wäre also die Erstellung einer Webmethode mit dem Namen pingme zusammen mit anderen Webmethoden für den Dienst. Die pingme sollte etwas zurückgeben.

Also schrieb ich die folgende Methode über allgemeine 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;
    }
}

Die obige Methode war für mich so nützlich, dass ich immer, wenn ich versuche, Daten an den Server zu senden, immer die Erreichbarkeit meiner Intranet-Ressource mit dieser niedrigen Timeout-URL-Anforderung prüfe.

7
Durai Amuthan.H

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;
    }
}
7
Mina Fawzy
  • Schritt 1: Fügen Sie die Erreichbarkeitsklasse Ihrem Projekt hinzu.
  • Schritt 2: Importieren Sie die Erreichbarkeitsklasse
  • Schritt 3: Erstellen Sie die unten stehende 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 auf:

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

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

Dies ist eine einfache Methode zur Überprüfung der Netzwerkverfügbarkeit, da unser Gerät an ein Netzwerk angeschlossen ist oder nicht. Es ist mir gelungen, es in Swift 3.0 und hier den endgültigen Code zu übersetzen. Die vorhandene Apple Reachability-Klasse und andere Bibliotheken von Drittanbietern schienen für die Übersetzung in Swift zu kompliziert zu sein.

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

Vergessen Sie nicht, "SystemConfiguration.framework" zu Ihrem Projektersteller 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")
  }
6
ViJay Avhad

Importieren Sie die Reachable.h-Klasse in Ihre ViewController-Datei und verwenden Sie den folgenden Code, um connectivity zu überprüfen:

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

Swift 3/Swift 4

Sie müssen zuerst importieren

import SystemConfiguration

Sie können die Internetverbindung mit der folgenden Methode überprüfen

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)

}
3
Dev_Tandel

Erstellen Sie ein Objekt von AFNetworkReachabilityManager und verwenden Sie den folgenden Code, um die Netzwerkkonnektivität zu verfolgen

self.reachabilityManager = [AFNetworkReachabilityManager managerForDomain:@"yourDomain"];
[self.reachabilityManager startMonitoring];
[self.reachabilityManager setReachabilityStatusChangeBlock:^(AFNetworkReachabilityStatus status) {
        switch (status) {
            case AFNetworkReachabilityStatusReachableViaWWAN:
            case AFNetworkReachabilityStatusReachableViaWiFi:
                break;
            case AFNetworkReachabilityStatusNotReachable:
                break;
            default:
                break;
        }
    }];
3
RandomGuy

"Erreichbarkeit.h" importieren

-(BOOL)netStat
{
    Reachability *test = [Reachability reachabilityForInternetConnection];
    return [test isReachable];
}
3
neo D1

Rufen Sie die Klasse Reachabilty von https://github.com/tonymillion/Reachability ab, fügen Sie das Systemkonfigurationsframework in Ihrem Projekt hinzu, importieren Sie Reachability.h in Ihre Klasse und implementieren Sie die benutzerdefinierten Methoden wie folgt:

- (BOOL)isConnectedToInternet
{
    //return NO; // Force for offline testing
    Reachability *hostReach = [Reachability reachabilityForInternetConnection];
    NetworkStatus netStatus = [hostReach currentReachabilityStatus];
    return !(netStatus == NotReachable);
}
3
K.D

Überprüfen Sie die Verfügbarkeit der Internetverbindung in (iOS) mit Xcode 9 und Swift 4.0.

Befolgen Sie die folgenden Schritte

Schritt 1: Erstellen Sie eine Erweiterungsdatei, und geben Sie ihr den Namen: ReachabilityManager.Swift . Fügen Sie dann die folgenden Codezeilen hinzu.

import Foundation
import SystemConfiguration
public class ConnectionCheck 
{    
   class func isConnectedToNetwork() -> Bool 
   {
    var zeroAddress = sockaddr_in()
    zeroAddress.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
    zeroAddress.sin_family = sa_family_t(AF_INET)

    guard let defaultRouteReachability = withUnsafePointer(to: &zeroAddress,         
    {
        $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
            SCNetworkReachabilityCreateWithAddress(nil, $0)
        }
    }) else {
        return false
    }

    var flags: SCNetworkReachabilityFlags = []
    if !SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) {
        return false
    }

    let isReachable = flags.contains(.reachable)
    let needsConnection = flags.contains(.connectionRequired)

    return (isReachable && !needsConnection)
   }
  }

Schritt 2: Rufen Sie die obige Nebenstelle mit dem nachstehenden Code an.

if ConnectionCheck.isConnectedToNetwork()
{
     print("Connected")
     //Online related Business logic
}
else{
     print("disConnected")
     // offline related business logic
}
2
praful argiddi
Pod `Alamofire` has `NetworkReachabilityManager`, you just have to create one function 

func isConnectedToInternet() ->Bool {
        return NetworkReachabilityManager()!.isReachable
}
2
Shruti Thombre

Für meine iOS-Projekte empfehle ich die Verwendung von

Erreichbarkeitsklasse

In Swift deklariert. Bei mir funktioniert es einfach prima

Wi-Fi und Mobilfunkdaten

.

 import SystemConfiguration

 public class Reachability {

 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(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 = SCNetworkReachabilityFlags(rawValue: 0)
    if SCNetworkReachabilityGetFlags(defaultRouteReachability!, &flags) == false {
        return false
    }

    let isReachable = (flags.rawValue & UInt32(kSCNetworkFlagsReachable)) != 0
    let needsConnection = (flags.rawValue & UInt32(kSCNetworkFlagsConnectionRequired)) != 0
    let ret = (isReachable && !needsConnection)
    return ret
} }

Bedingte Anweisung verwenden,

if Reachability.isConnectedToNetwork(){
          * Enter Your Code Here*
        }
    }
    else{
        print("NO Internet connection")
    }

Diese Klasse ist in fast allen Fällen nützlich, in denen Ihre App die Internetverbindung verwendet. Wenn die Bedingung z. B. erfüllt ist, kann die API aufgerufen oder eine Aufgabe ausgeführt werden.

Dies ist für Swift 3.0 und Async. Die meisten Antworten sind eine Synchronisationslösung, die Ihren Haupt-Thread blockiert, wenn Sie eine sehr langsame Verbindung haben. Diese Lösung ist besser, aber nicht perfekt, da Google die Konnektivität auf Google überprüft und Sie eine andere URL verwenden können.

func checkInternetConnection(completionHandler:@escaping (Bool) -> Void)
{
    if let url = URL(string: "http://www.google.com/")
    {
        var request = URLRequest(url: url)
        request.httpMethod = "HEAD"
        request.cachePolicy = .reloadIgnoringLocalAndRemoteCacheData
        request.timeoutInterval = 5

        let tast = URLSession.shared.dataTask(with: request, completionHandler:
        {
            (data, response, error) in

            completionHandler(error == nil)
        })
        tast.resume()
    }
    else
    {
        completionHandler(true)
    }
}
1
pierre23

Alamofire

Ich weiß, dass die Frage nach der Coca Touch-Lösung gefragt ist, aber ich möchte eine Lösung für Leute bereitstellen, die eine Internetverbindung mit iOS suchen und hier eine weitere Option haben.

Wenn Sie bereits Alamofire verwenden, können Sie davon profitieren.

Sie können Ihrer App die folgende Klasse hinzufügen und MNNetworkUtils.main.isConnected() aufrufen, um ein boolesches Verhalten darüber zu erhalten, ob eine Verbindung besteht oder nicht.

#import Alamofire

class MNNetworkUtils {
  static let main = MNNetworkUtils()
  init() {
    manager = NetworkReachabilityManager(Host: "google.com")
    listenForReachability()
  }

  private let manager: NetworkReachabilityManager?
  private var reachable: Bool = false
  private func listenForReachability() {
    self.manager?.listener = { [unowned self] status in
      switch status {
      case .notReachable:
        self.reachable = false
      case .reachable(_), .unknown:
        self.reachable = true
      }
    }
    self.manager?.startListening()
  }

  func isConnected() -> Bool {
    return reachable
  }
}

Dies ist eine Einzelklasse. Jedes Mal, wenn der Benutzer das Netzwerk verbindet oder trennt, überschreibt er self.reachable korrekt in true/false, da wir bei der Initialisierung des Singleton die NetworkReachabilityManager-Einstellung abhören.

Um die Erreichbarkeit zu überwachen, müssen Sie einen Host angeben. Zur Zeit verwende ich google.com. Sie können bei Bedarf zu einem anderen Host oder einem Ihrer Hosts wechseln.

0
nuynait

Bitte versuchen Sie dies, es wird Ihnen helfen (Swift 4)

1) Erreichbarkeit über CocoaPods oder Carthage installieren : Erreichbarkeit

2) Erreichbarkeit und Verwendung in Netzwerkklassen importieren

import Reachability
class Network {

   private let internetReachability : Reachability?
   var isReachable : Bool = false

   init() {

       self.internetReachability = Reachability.init()
       do{
           try self.internetReachability?.startNotifier()
           NotificationCenter.default.addObserver(self, selector: #selector(self.handleNetworkChange), name: .reachabilityChanged, object: internetReachability)
       }
       catch {
        print("could not start reachability notifier")
       }
   }

   @objc private func handleNetworkChange(notify: Notification) {

       let reachability = notify.object as! Reachability
       if reachability.connection != .none {
           self.isReachable = true
       }
       else {
           self.isReachable = false
       }
       print("Internet Connected : \(self.isReachable)") //Print Status of Network Connection
   }
}

3) Verwenden Sie wie unten, wo Sie brauchen.

var networkOBJ = Network()
// Use "networkOBJ.isReachable" for Network Status
print(networkOBJ.isReachable) 
0
Rohit Makwana

siehe Introducing Network.framework: A modern alternative to Socketshttps://developer.Apple.com/videos/play/wwdc2018/715/ wir sollten die Erreichbarkeit irgendwann beseitigen.

0
Zsolt