Chciałbym sprawdzić, czy mam połączenie internetowe w systemie iOS za pomocą bibliotek Cocoa Touch lub w systemie macOS za pomocą bibliotek Cocoa .

Wymyśliłem sposób na zrobienie tego za pomocą NSURL. Sposób, w jaki to zrobiłem, wydaje się nieco niewiarygodny (ponieważ nawet Google może pewnego dnia przestać działać, a poleganie na stronie trzeciej wydaje się złe) i chociaż mogłem sprawdzić, czy nie ma odpowiedzi z innych witryn, jeśli Google nie zareaguje, wydaje się marnotrawstwem i niepotrzebnym kosztem mojej aplikacji.

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

Czy to, co zrobiłem źle, (nie wspominając o tym stringWithContentsOfURLjest przestarzałe w iOS 3.0 i macOS 10.4), a jeśli tak, to jaki jest lepszy sposób na osiągnięcie tego?

Ważne : to sprawdzenie należy zawsze wykonywać asynchronicznie. Większość poniższych odpowiedzi jest zsynchronizowana, więc bądź ostrożny, w przeciwnym razie zawiesisz aplikację.

Szybki

1) Zainstaluj za pośrednictwem CocoaPods lub Carthage: https://github.com/ashleymills/Reachability.swift

2) Test osiągalności poprzez zamknięcia

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

Cel C

1) Dodaj SystemConfigurationplatformę do projektu, ale nie martw się o włączenie go w dowolnym miejscu

2) Dodaj wersję Tony Milliona Reachability.hi Reachability.mdo projektu (znalezione tutaj: https://github.com/tonymillion/Reachability )

3) Zaktualizuj sekcję interfejsu

#import "Reachability.h"

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

4) Następnie zaimplementuj tę metodę w pliku m kontrolera widoku, który możesz wywołać

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

Ważna uwaga:Reachability klasa jest jednym z najczęściej używanych klas w projektach więc może napotkasz nazywania konfliktów z innymi projektami. Jeśli tak się stanie, będziesz musiał zmienić nazwę jednej pary plików Reachability.hi Reachability.mna inną, aby rozwiązać problem.

Uwaga: używana domena nie ma znaczenia. To tylko testowanie bramy do dowolnej domeny.

Lubię upraszczać sprawy. Tak to robię:

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

Następnie używam tego, gdy chcę sprawdzić, czy mam połączenie:

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

Ta metoda nie czeka na zmianę statusu sieci w celu wykonania różnych czynności. Po prostu testuje status, kiedy o to poprosisz.

Korzystając z kodu osiągalności Apple, stworzyłem funkcję, która sprawdzi to poprawnie bez konieczności dołączania żadnych klas.

Uwzględnij SystemConfiguration.framework w swoim projekcie.

Dokonaj importu:

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

Teraz wystarczy wywołać tę funkcję:

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

I to iOS 5 przetestowany dla Ciebie.

Kiedyś była to poprawna odpowiedź, ale teraz jest nieaktualna, ponieważ zamiast tego należy subskrybować powiadomienia o osiągalności. Ta metoda sprawdza synchronicznie:

Możesz użyć klasy osiągalności Apple. Umożliwi to również sprawdzenie, czy Wi-Fi jest włączone:

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

Klasa osiągalności nie jest dostarczana z zestawem SDK, ale jest częścią tej przykładowej aplikacji Apple . Wystarczy go pobrać i skopiować Reachability.h / m do swojego projektu. Musisz także dodać platformę SystemConfiguration do swojego projektu.

Oto bardzo prosta odpowiedź:

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

Adres URL powinien wskazywać na bardzo małą stronę internetową. Korzystam z mobilnej witryny Google, ale gdybym miał niezawodny serwer internetowy, przesłałbym mały plik z tylko jednym znakiem dla maksymalnej prędkości.

Jeśli sprawdzanie, czy urządzenie jest w jakiś sposób podłączone do Internetu, jest wszystkim, co chcesz zrobić, zdecydowanie polecam skorzystanie z tego prostego rozwiązania. Jeśli chcesz wiedzieć, w jaki sposób użytkownik jest połączony, skorzystaj z Reachability.

Ostrożnie: spowoduje to krótkie zablokowanie twojego wątku podczas ładowania strony. W moim przypadku nie był to problem, ale powinieneś to rozważyć (podziękowania dla Brada za zwrócenie na to uwagi).

Oto jak to robię w moich aplikacjach: kod 200 statusu nie gwarantuje niczego, jest dla mnie wystarczająco stabilny. Nie wymaga to tak dużego ładowania, jak zamieszczone tutaj odpowiedzi NSData, ponieważ moje tylko sprawdzają odpowiedź HEAD.

Kod SWIFT

func checkInternet(flag:Bool, completionHandler:(internet:Bool) -> Void)
{
    UIApplication.sharedApplication().networkActivityIndicatorVisible = true

    let url = NSURL(string: "http://www.google.com/")
    let request = NSMutableURLRequest(URL: url!)

    request.HTTPMethod = "HEAD"
    request.cachePolicy = NSURLRequestCachePolicy.ReloadIgnoringLocalAndRemoteCacheData
    request.timeoutInterval = 10.0

    NSURLConnection.sendAsynchronousRequest(request, queue:NSOperationQueue.mainQueue(), completionHandler:
    {(response: NSURLResponse!, data: NSData!, error: NSError!) -> Void in

        UIApplication.sharedApplication().networkActivityIndicatorVisible = false

        let rsp = response as! NSHTTPURLResponse?

        completionHandler(internet:rsp?.statusCode == 200)
    })
}

func yourMethod()
{
    self.checkInternet(false, completionHandler:
    {(internet:Bool) -> Void in

        if (internet)
        {
            // "Internet" aka Google URL reachable
        }
        else
        {
            // No "Internet" aka Google URL un-reachable
        }
    })
}

Kod celu C

typedef void(^connection)(BOOL);

- (void)checkInternet:(connection)block
{
    NSURL *url = [NSURL URLWithString:@"http://www.google.com/"];
    NSMutableURLRequest *headRequest = [NSMutableURLRequest requestWithURL:url];
    headRequest.HTTPMethod = @"HEAD";

    NSURLSessionConfiguration *defaultConfigObject = [NSURLSessionConfiguration ephemeralSessionConfiguration];
    defaultConfigObject.timeoutIntervalForResource = 10.0;
    defaultConfigObject.requestCachePolicy = NSURLRequestReloadIgnoringLocalAndRemoteCacheData;

    NSURLSession *defaultSession = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue: [NSOperationQueue mainQueue]];

    NSURLSessionDataTask *dataTask = [defaultSession dataTaskWithRequest:headRequest
        completionHandler:^(NSData *data, NSURLResponse *response, NSError *error)
    {
        if (!error && response)
        {
            block([(NSHTTPURLResponse *)response statusCode] == 200);
        }
    }];
    [dataTask resume];
}

- (void)yourMethod
{
    [self checkInternet:^(BOOL internet)
    {
         if (internet)
         {
             // "Internet" aka Google URL reachable
         }
         else
         {
             // No "Internet" aka Google URL un-reachable
         }
    }];
}

Apple dostarcza przykładowy kod, aby sprawdzić dostępność różnych typów sieci. Alternatywnie istnieje przykład w książce kucharskiej dla programistów iPhone'a.

Uwaga: zapoznaj się z komentarzem @ KHG do tej odpowiedzi na temat wykorzystania kodu osiągalności Apple.

Możesz użyć Reachabilitydo  ( dostępny tutaj ).

#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 udostępnia przykładową aplikację, która robi dokładnie to:

Osiągalność

Zaktualizowano tylko klasę osiągalności. Możesz teraz użyć:

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

Wersja na Reachability na iOS 5 to Darkseed / Reachability.h . To nie moje! =)

Jest tutaj ładnie wyglądająca, wykorzystująca ARC i GCD modernizacja osiągalności:

Osiągalność

Jeśli używasz AFNetworking , możesz użyć własnej implementacji dla statusu dostępności do Internetu.

Najlepszym sposobem na użycie AFNetworkingjest podklasęAFHTTPClient klasy i wykorzystanie tej klasy do wykonywania połączeń sieciowych.

Jedną z zalet korzystania z tego podejścia jest to, że można użyć blocksdo ustawienia pożądanego zachowania, gdy zmienia się status osiągalności. Przypuśćmy, że stworzyłem singletonową podklasę o nazwie AFHTTPClient(jak napisano w „notatkach dotyczących podklasy” w dokumentach AFNetworking ) BKHTTPClient, zrobiłbym coś takiego:

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

Można również sprawdzić, Wi-Fi lub połączenia WLAN za pomocą specjalnie AFNetworkReachabilityStatusReachableViaWWANi AFNetworkReachabilityStatusReachableViaWiFistałe teksty ( więcej tutaj ).

Użyłem kodu w tej dyskusji i wydaje się, że działa dobrze (przeczytaj całość wątek!).

Nie przetestowałem go wyczerpująco z każdym możliwym rodzajem połączenia (np. Ad hoc Wi-Fi).

Bardzo proste .... Wypróbuj następujące kroki:

Krok 1: Dodaj SystemConfigurationramę do swojego projektu.

Krok 2: Zaimportuj następujący kod do swojego headerpliku.

#import <SystemConfiguration/SystemConfiguration.h>

Krok 3: Użyj następującej metody

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

  Importuj nagłówek :#import "Reachability.h"

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

Krok 4: Jak używać:

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

Lub użyj klasy Reachability .

Istnieją dwa sposoby sprawdzenia dostępności Internetu za pomocą iPhone SDK:

1. Sprawdź, czy strona Google jest otwarta, czy nie.

2. Klasa osiągalności

Aby uzyskać więcej informacji, zobacz Reachability (Apple Developer).

Użyj http://huytd.github.io/datatify/ . To łatwiejsze niż samodzielne dodawanie bibliotek i pisanie kodu.

Po pierwsze : dodaj CFNetwork.frameworkw ramach

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

Najpierw pobierz klasę osiągalności i umieść plik reachability.h i reachabilty.m w swoim Xcode .

Najlepszym sposobem jest utworzenie wspólnej klasy Functions (NSObject), aby można było z niej korzystać w dowolnej klasie. Są dwie metody sprawdzania osiągalności połączenia sieciowego:

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

Teraz możesz sprawdzić połączenie sieciowe w dowolnej klasie, wywołując tę ​​metodę klasy.

Istnieje również inna metoda sprawdzania połączenia internetowego za pomocą iPhone SDK.

Spróbuj zaimplementować następujący kod dla połączenia sieciowego.

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

Uznałem, że jest to prosta i łatwa w użyciu biblioteka SimplePingHelper .

Przykładowy kod: chrishulbert / SimplePingHelper ( GitHub )

1. Pobierz plik osiągalności, https://gist.github.com/darkseed/1182373

2. I dodaj CFNetwork.frameworki „SystemConfiguration.framework” w ramach

3. Wykonaj #import „Reachability.h”

Po pierwsze : dodaj CFNetwork.frameworkw ramach

Kod :ViewController.m

- (void)viewWillAppear:(BOOL)animated
{
    Reachability *r = [Reachability reachabilityWithHostName:@"www.google.com"];
    NetworkStatus internetStatus = [r currentReachabilityStatus];

    if ((internetStatus != ReachableViaWiFi) && (internetStatus != ReachableViaWWAN))
    {
        /// Create an alert if connection doesn't work
        UIAlertView *myAlert = [[UIAlertView alloc]initWithTitle:@"No Internet Connection"   message:NSLocalizedString(@"InternetMessage", nil)delegate:nil cancelButtonTitle:@"Ok" otherButtonTitles:nil];
        [myAlert show];
        [myAlert release];
    }
    else
    {
         NSLog(@"INTERNET IS CONNECT");
    }
}

Swift 3 / Swift 4

Musisz najpierw zaimportować

import SystemConfiguration

Możesz sprawdzić połączenie internetowe następującą metodą

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)

}

Klasa osiągalności jest OK, aby dowiedzieć się, czy połączenie internetowe jest dostępne na urządzeniu, czy nie ...

Ale w przypadku dostępu do zasobu intranetowego :

Pingowanie serwera intranetowego za pomocą klasy osiągalności zawsze zwraca wartość true.

Tak więc szybkim rozwiązaniem w tym scenariuszu byłoby utworzenie metody internetowej wywoływanej pingmewraz z innymi metodami sieciowymi w usłudze. pingmePowinien powrócić coś.

Napisałem więc następującą metodę dotyczącą popularnych funkcji

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

Powyższa metoda była dla mnie bardzo przydatna, dlatego za każdym razem, gdy próbuję wysłać dane do serwera, zawsze sprawdzam dostępność mojego zasobu intranetowego przy użyciu tego żądania URLR o niskim limicie czasu.

Wykonanie tego samemu jest niezwykle proste. Działa następująca metoda. Pamiętaj tylko, aby nie dopuścić do przekazania protokołu nazwy hosta, takiego jak HTTP, HTTPS itp., Wraz z nazwą.

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

Jest szybki, prosty i bezbolesny.

Oprócz osiągalności możesz także skorzystać z biblioteki pomocnika Simple Ping . Działa naprawdę ładnie i jest łatwy do zintegrowania.

Myślę, że to najlepsza odpowiedź.

„Tak” oznacza podłączony. „Nie” oznacza rozłączony.

#import "Reachability.h"

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

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

Zaimportuj Reachable.hklasę do swojego ViewControlleri użyj następującego kodu, aby sprawdzić łączność :

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

• Krok 1: Dodaj klasę osiągalności w swoim projekcie.
• Krok 2: Zaimportuj klasę osiągalności

• Krok 3: Utwórz poniższą funkcję

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

• Krok 4: Wywołaj funkcję jak poniżej:

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