Lubię, żeby wszystko było proste. 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ę zobaczyć, czy mam połączenie:

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

Ta metoda nie czeka na zmienione statusy sieci w celu zrobienia rzeczy. To tylko testuje status, kiedy go o to poprosisz.

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

Dołącz konfigurację systemu.framework w Twoim projekcie.

Make some imports:

#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 jest iOS 5 przetestowany dla Ciebie.

To była poprawna odpowiedź, ale teraz jest nieaktualna, ponieważ zamiast tego powinieneś subskrybować powiadomienia o osiągalności. Metoda ta sprawdza synchronicznie:

Możesz użyć klasy osiągalności Apple. Pozwoli to również sprawdzić, 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 SDK, ale raczej część tej przykładowej aplikacji Apple . Wystarczy go pobrać i skopiować.h / m do twojego projektu. Ponadto, musisz dodać SystemConfiguration framework do twojego 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 tutaj z mobilnej strony Google, ale gdybym miał niezawodny serwer WWW, załadowałbym mały plik z jednym znakiem dla maksymalnej prędkości.

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

Ostrożnie: to na krótko zablokuje Twój wątek podczas ładowania strony. W moim przypadku nie było to problemem, ale powinieneś to rozważyć(podziękowania dla Brada za wskazanie tego).

Oto Jak to robię w moich aplikacjach: chociaż kod odpowiedzi statusu 200 niczego nie gwarantuje, jest wystarczająco stabilny dla mnie. To nie wymaga tyle ładowania, jak odpowiedzi nsdata opublikowane tutaj, jak mój po prostu sprawdza odpowiedź głowy.

Kod Swift

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

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

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

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

        UIApplication.sharedApplication().networkActivityIndicatorVisible = false

        let rsp = response as! NSHTTPURLResponse?

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

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

        if (internet)
        {
            // "Internet" aka Apple's region universal URL reachable
        }
        else
        {
            // No "Internet" aka Apple's region universal URL un-reachable
        }
    })
}

Objective-C Code

typedef void(^connection)(BOOL);

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

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

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

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

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

Apple dostarcza przykładowy kod w celu sprawdzenia dostępności różnych typów sieci. Alternatywnie istnieje Przykład w książce kucharskiej twórców iPhone ' a.

Uwaga: proszę zapoznać się z komentarzem @ KHG na temat tej odpowiedzi dotyczącej użycia kodu osiągalności Apple.

Możesz użyć Reachability by ( 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 dostarcza 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 iOS 5 jest darkseed / Reachability.h. To nie moje! =)

Jest tu ładnie wyglądający, ARC - i GCD-wykorzystujący modernizację osiągalności:

Osiągalność

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

Najlepszym sposobem użycia AFNetworking jest podklasa klasy AFHTTPClient i użycie tej klasy do wykonywania połączeń sieciowych.

Jedną z zalet tego podejścia jest to, że można użyć blocks, Aby ustawić pożądane zachowanie, gdy zmieni się status osiągalności. Przypuśćmy, że stworzyłem podklasę Singletona AFHTTPClient (Jak napisano w" subclassing notes " na AFNetworking docs ) nazwane BKHTTPClient, zrobiłbym coś takiego:

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

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

Nie testowałem go wyczerpująco z każdym możliwym rodzajem połączenia (jak ad hoc Wi-Fi).

Bardzo proste.... Wypróbuj poniższe kroki:

Krok 1: Dodaj Framework SystemConfiguration do swojego projektu.

Krok 2: zaimportuj poniższy kod do pliku header.

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

  Import header : #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żyć klasy osiągalności .

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

2. Klasa Osiągalności

Aby uzyskać więcej informacji, zapoznaj się z osiągalność (Apple Developer).

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

Pierwszy : dodaj CFNetwork.framework w 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ść osiągalność.h i reachabilty.plik m w twoim Xcode .

Najlepszym sposobem jest utworzenie wspólnej klasy funkcji (NSObject), aby można było jej używać w dowolnej klasie. Są to 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 przez wywołanie tej metody klasy.

Istnieje również inna metoda sprawdzania połączenia z Internetem 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;
}

Zrobienie tego samemu jest niezwykle proste. Będzie działać następująca metoda. Pamiętaj tylko, aby nie zezwalać na protokół nazwy hosta, taki jak HTTP, HTTPS itp. do podania nazwiska.

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

Znalazłem to proste i łatwe w użyciu biblioteki SimplePingHelper .

Przykładowy kod: chrishulbert / SimplePingHelper (GitHub )

1. Pobierz plik Reachability, https://gist.github.com/darkseed/1182373

2. I dodać CFNetwork.framework i ' SystemConfiguration.framework " in framework

3. Do # import " Reachability.h "

Pierwszy : dodaj CFNetwork.framework w 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");
    }
}

Klasa osiągalności jest w porządku, aby sprawdzić, czy połączenie internetowe jest dostępne dla urządzenia, czy nie...

Ale w przypadku dostępu do zasobu intranetowego :

Pingowanie serwera intranetowego z klasą osiągalności zawsze zwraca true.

Więc szybkim rozwiązaniem w tym scenariuszu byłoby stworzenie metody internetowej o nazwie pingme wraz z innymi webmethods w usłudze. pingme powinien coś zwrócić.

Więc napisałem następującą metodę na Funkcje wspólne

-(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, więc za każdym razem, gdy próbuję wysłać jakieś dane do serwera, zawsze sprawdzam dostępność mojego zasobu intranetowego za pomocą tego zapytania URLRequest o niskim limicie czasu.

Oprócz osiągalności możesz również użyć prostej biblioteki Ping helper . Działa naprawdę ładnie i jest prosty w integracji.

Myślę, że ta jest najlepszą odpowiedzią.

"tak" oznacza połączony. "Nie" oznacza odłączony.

#import "Reachability.h"

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

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

Importuj Reachable.h klasę w swoim ViewController i 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 projekcie.
• Krok 2: Import klasy 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łanie funkcji 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");
  }
  

Sprawdzanie dostępności połączenia internetowego w (iOS) Xcode 8 , Swift 3.0

Jest to prosta metoda sprawdzania dostępności sieci, tak jak nasze urządzenie jest podłączone do dowolnej sieci lub nie. Udało mi się przetłumaczyć go na Swift 3.0 i tutaj ostateczny kod. Istniejąca Klasa osiągalności Apple i inne biblioteki stron trzecich wydawały się zbyt skomplikowane, aby przetłumaczyć je na Swift.

To działa zarówno dla połączeń 3G, 4G i WiFi.

Don ' t zapomnij dodać " Konfiguracja systemowa.framework" do twojego konstruktora projektów.

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