如何检查 iOS 或 macOS 上的活动互联网连接？

Question

我想使用 Cocoa Touch 库检查 iOS 上是否有互联网连接，或者在 macOS 上使用 Cocoa 库。

我想出了一种使用 NSURL 来做到这一点的方法。我这样做的方式似乎有点不可靠（因为即使谷歌有一天也可能会崩溃并且依赖第三方似乎很糟糕），虽然我可以检查其他网站的响应，如果谷歌没有响应，它确实对我的应用程序来说是浪费和不必要的开销。

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

我做得不好吗（更不用说 stringWithContentsOfURL 在 iOS 3.0 和 macOS 10.4 中已被弃用），如果是这样，有什么更好的方法来实现这一点？

Answer 1

重要：此检查应始终异步执行。下面的大多数答案都是同步的，所以要小心，否则你的应用程序会冻结。

---

Swift

1. 通过 CocoaPods 或 Carthage 安装：https://github.com/ashleymills/Reachability.swift

   
   

2. 通过闭包测试可达性

   让可达性=可达性()！
   
   reachability.whenReachable = { 可达性
       如果可达性.connection == .wifi {
           print("可通过 WiFi 连接")
       } 别的 {
           print("可通过蜂窝网络连接")
       }
   }
   
   可达性.whenUnreachable = { _ in
       print("无法访问")
   }
   
   做 {
       尝试reachability.startNotifier()
   } 抓住 {
       print("无法启动通知程序")
   }
   

---

Objective-C

1. 将 SystemConfiguration 框架添加到项目中，但不用担心将其包含在任何地方

2. 添加 Tony Million 版本的 Reachability.h 和 Reachability.m 到项目（在这里找到：https://github.com/tonymillion/Reachability）

3. 更新界面部分

   #import "Reachability.h"
   
   // 将其添加到视图控制器的 .m 文件中的界面中
   @interfaceMyViewController()
   {
       可达性 *internetReachableFoo;
   }
   @结尾
   

4. 然后在您可以调用的视图控制器的.m文件中实现此方法

   // 检查我们是否有互联网连接
   - (void)测试互联网连接
   {
       internetReachableFoo = [可达性reachabilityWithHostname:@"www.google.com"];
   
       // 互联网可访问
       internetReachableFoo.reachableBlock = ^(可达性*可达性)
       {
           // 在主线程更新UI
           dispatch_async(dispatch_get_main_queue(), ^{
               NSLog(@“耶耶，我们有互联网了！”);
           });
       };
   
       // 无法访问互联网
       internetReachableFoo.unreachableBlock = ^(可达性*可达性)
       {
           // 在主线程更新UI
           dispatch_async(dispatch_get_main_queue(), ^{
               NSLog(@"有人破坏了互联网:(");
           });
       };
   
       [internetReachableFoo startNotifier];
   }
   

重要提示：Reachability 类是项目中最常用的类之一，因此您可以运行与其他项目的命名冲突。如果发生这种情况，您必须将一对 Reachability.h 和 Reachability.m 文件重命名为其他文件才能解决该问题。

注意：您使用的域并不重要。它只是测试通往任何域的网关。

Answer 2

我喜欢让事情变得简单。我这样做的方法是：

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

然后，每当我想查看是否有连接时，我都会使用此方法：

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

此方法不会等待网络状态更改才能执行操作。它只是在您要求时测试状态。

Answer 3

使用 Apple 的 Reachability 代码，我创建了一个函数，可以正确检查这一点，而无需包含任何类。

在您的项目中包含 SystemConfiguration.framework。

进行一些导入：

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

现在只需调用此函数：

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

并且它已经为您进行了 iOS 5 测试。

Answer 4

这曾经是正确的答案，但现在已经过时了，因为您应该订阅通知以实现可达性。此方法同步检查：

---

您可以使用 Apple 的 Reachability 类。它还允许您检查 Wi-Fi 是否已启用：

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

Reachability 类不随 SDK 一起提供，而是 此 Apple 示例应用程序。只需下载它，然后将 Reachability.h/m 复制到您的项目中即可。此外，您还必须将 SystemConfiguration 框架添加到您的项目中。

Answer 5

这是一个非常简单的答案：

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

URL 应该指向一个非常小的网站。我在这里使用 Google 的移动网站，但如果我有可靠的网络服务器，我会上传一个仅包含一个字符的小文件以获得最大速度。

如果您想要做的就是检查设备是否以某种方式连接到互联网，那么我绝对推荐使用这个简单的解决方案。如果您需要了解用户如何连接，那么使用 Reachability 是最佳选择。

小心：这会在加载网站时短暂阻止您的线程。就我而言，这不是问题，但您应该考虑这一点（感谢 Brad 指出了这一点）。

Answer 6

以下是我在应用程序中执行此操作的方法：虽然 200 状态响应代码不能保证任何内容，但它对我来说足够稳定。这不需要像这里发布的 NSData 答案那么多的加载，因为我的只是检查 HEAD 响应。

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

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

Answer 7

Apple 提供示例代码来检查不同类型的网络可用性。另外，iPhone 开发人员指南中还有一个示例。

注意：请参阅 @KHG 对此答案有关 Apple 可达性代码的使用的评论。

Answer 8

您可以通过  使用Reachability（可用在这里）。

#import "Reachability.h"

- (BOOL)networkConnection {
    return [[Reachability reachabilityWithHostName:@"www.google.com"] currentReachabilityStatus];
}

if ([self networkConnection] == NotReachable) { /* No Network */ } else { /* Network */ } //Use ReachableViaWiFi / ReachableViaWWAN to get the type of connection.

Answer 9

Apple 提供了一个示例应用程序来执行此操作：

Reachability

Answer 10

使用 iOS 12 或 macOS v10.14 (Mojave) 或更高版本时，您可以使用 NWPathMonitor 而不是史前的 Reachability 类。作为奖励，您可以轻松检测当前的网络连接类型：

import Network // Put this on top of your class

let monitor = NWPathMonitor()

monitor.pathUpdateHandler = { path in
    if path.status != .satisfied {
        // Not connected
    }
    else if path.usesInterfaceType(.cellular) {
        // Cellular 3/4/5g connection
    }
    else if path.usesInterfaceType(.wifi) {
        // Wi-Fi connection
    }
    else if path.usesInterfaceType(.wiredEthernet) {
        // Ethernet connection
    }
}

monitor.start(queue: DispatchQueue.global(qos: .background))

更多信息请参见：https://developer. apple.com/documentation/network/nwpathmonitor

Answer 11

仅更新了 Reachability 类。您现在可以使用：

Reachability* reachability = [Reachability reachabilityWithHostName:@"www.apple.com"];
NetworkStatus remoteHostStatus = [reachability currentReachabilityStatus];

if (remoteHostStatus == NotReachable) { NSLog(@"not reachable");}
else if (remoteHostStatus == ReachableViaWWAN) { NSLog(@"reachable via wwan");}
else if (remoteHostStatus == ReachableViaWiFi) { NSLog(@"reachable via wifi");}

Answer 12

如果您使用 AFNetworking 您可以使用其自己的实现来获取互联网可达性状态。

使用 AFNetworking 的最佳方法是子类化 AFHTTPClient 类并使用此类进行网络连接。

使用这种方法的优点之一是，当可达性状态发生变化时，您可以使用块来设置所需的行为。假设我创建了 AFHTTPClient 的单例子类（如 AFNetworking 文档）名为 BKHTTPClient，我会执行以下操作：

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

您还可以专门使用AFNetworkReachabilityStatusReachableViaWWAN 和 AFNetworkReachabilityStatusReachableViaWiFi 枚举（更多信息请参见此处）。

Answer 13

非常简单...尝试以下步骤：

第 1 步：将 SystemConfiguration 框架添加到您的项目中。

---

第 2 步：将以下代码导入到您的 header 文件中。

#import <SystemConfiguration/SystemConfiguration.h>

---

第 3 步：使用以下方法

• 类型 1：

  - (BOOL) currentNetworkStatus {
      [UIApplication共享应用程序].networkActivityIndi​​catorVisible = NO;
      BOOL 已连接；
      BOOL 已连接；
      const char *host = "www.apple.com";
      SCNetworkReachabilityRef 可达性 = SCNetworkReachabilityCreateWithName(NULL, 主机);
      SCNetworkReachabilityFlags 标志；
      连接 = SCNetworkReachabilityGetFlags(可达性, &flags);
      已连接=否；
      isConnected = 已连接 && (flags & kSCNetworkFlagsReachable) && !(flags & kSCNetworkFlagsConnectionRequired);
      CFRelease(可达性);
      返回已连接；
  }
  

---

• 类型 2：

  导入标头：#import "Reachability.h"

  - (BOOL)当前网络状态
  {
      可达性*可达性= [可达性reachabilityForInternetConnection];
      NetworkStatus networkStatus = [可达性currentReachabilityStatus];
      返回网络状态！=不可到达；
  }
  

---

第 4 步：

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

Answer 14

-(void)newtworkType {

 NSArray *subviews = [[[[UIApplication sharedApplication] valueForKey:@"statusBar"] valueForKey:@"foregroundView"]subviews];
NSNumber *dataNetworkItemView = nil;

for (id subview in subviews) {
    if([subview isKindOfClass:[NSClassFromString(@"UIStatusBarDataNetworkItemView") class]]) {
        dataNetworkItemView = subview;
        break;
    }
}


switch ([[dataNetworkItemView valueForKey:@"dataNetworkType"]integerValue]) {
    case 0:
        NSLog(@"No wifi or cellular");
        break;

    case 1:
        NSLog(@"2G");
        break;

    case 2:
        NSLog(@"3G");
        break;

    case 3:
        NSLog(@"4G");
        break;

    case 4:
        NSLog(@"LTE");
        break;

    case 5:
        NSLog(@"Wifi");
        break;


    default:
        break;
}
}

Answer 15

- (void)viewWillAppear:(BOOL)animated
{
    NSString *URL = [NSString stringWithContentsOfURL:[NSURL URLWithString:@"http://www.google.com"]];

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

或者使用Reachability 类。

使用 iPhone SDK 检查互联网可用性的方法有两种：

1.检查Google页面是否打开。

2. Reachability 类

有关详细信息，请参阅可达性（Apple 开发人员）。

Answer 16

首先：在框架中添加CFNetwork.framework

代码：ViewController.m

#import "Reachability.h"

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

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

Answer 17

Swift 3 / Swift 4

您必须先导入

import SystemConfiguration

您可以使用以下方法检查互联网连接：

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

Answer 18

对于我的 iOS 项目，我建议使用

可达性等级

在 Swift 中声明。对我来说，它工作得很好

Wi-Fi 和蜂窝数据

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

使用条件语句，

if Reachability.isConnectedToNetwork() {
    // Enter your code here
}
}
else {
    print("NO Internet connection")
}

此类在您的应用使用 Internet 连接的几乎所有情况下都很有用。
例如，如果条件为真，则可以调用API或可以执行任务。

Answer 19

1. 下载可达性文件，https://gist.github.com/darkseed/1182373

2. 并在框架中添加 CFNetwork.framework 和 'SystemConfiguration.framework'

3. Do #import "Reachability.h"

首先：在框架中添加CFNetwork.framework

代码：ViewController.m

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

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

Answer 20

首先下载reachability类并将reachability.h和reachabilty.m文件放入您的Xcode中。

最好的方法是创建一个通用的 Functions 类（NSObject），以便您可以在任何类中使用它。这是用于网络连接可达性检查的两种方法：

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

现在，您可以通过调用此类方法来检查任何类中的网络连接。

Answer 21

还有另一种方法使用 iPhone SDK 检查互联网连接。

尝试为网络连接实现以下代码。

#import <SystemConfiguration/SystemConfiguration.h>
#include <netdb.h>

/**
     Checking for network availability. It returns
     YES if the network is available.
*/
+ (BOOL) connectedToNetwork
{

    // Create zero addy
    struct sockaddr_in zeroAddress;
    bzero(&zeroAddress, sizeof(zeroAddress));
    zeroAddress.sin_len = sizeof(zeroAddress);
    zeroAddress.sin_family = AF_INET;

    // Recover reachability flags
    SCNetworkReachabilityRef defaultRouteReachability =
        SCNetworkReachabilityCreateWithAddress(NULL, (struct sockaddr *)&zeroAddress);
    SCNetworkReachabilityFlags flags;

    BOOL didRetrieveFlags = SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags);
    CFRelease(defaultRouteReachability);

    if (!didRetrieveFlags)
    {
        printf("Error. Could not recover network reachability flags\n");
        return NO;
    }

    BOOL isReachable = ((flags & kSCNetworkFlagsReachable) != 0);
    BOOL needsConnection = ((flags & kSCNetworkFlagsConnectionRequired) != 0);

    return (isReachable && !needsConnection) ? YES : NO;
}

Answer 22

自己做这件事非常简单。下面的方法会起作用。请确保不允许将主机名协议（例如 HTTP、HTTPS 等）与名称一起传入。

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

它快速简单且无痛。

Answer 23

我认为这是最好的答案。

“是”表示已连接。 “否”意味着断开连接。

#import "Reachability.h"

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

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

Answer 24

Reachability 类可以确定设备的 Internet 连接是否可用...

但是在访问 Intranet 资源时：

使用以下命令对 Intranet 服务器执行 Ping 操作 ：可达性类始终返回 true。

因此，这种情况下的快速解决方案是创建一个名为 pingme 的 Web 方法以及服务上的其他 Web 方法。
pingme 应该返回一些东西。

所以我在常用功能上写了以下方法

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

上面的方法对我来说非常有用，所以每当我尝试向服务器发送一些数据时，我总是使用这个低超时 URLRequest 检查我的内网资源的可达性。

Answer 25

Swift 5 及更高版本：

public class Reachability {
    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)
    }

像这样调用此类：

if Reachability.isConnectedToNetwork() == true {
    // Do something
} else {
    // Do something
}

Answer 26

• 第 1 步：在您的项目中添加 Reachability 类。
• 步骤 2：导入 Reachability 类

• 步骤 3：创建以下函数

  - (BOOL)checkNetConnection {
      self.internetReachability = [可达性reachabilityForInternetConnection];
      [self.internetReachability startNotifier];
      NetworkStatus netStatus = [self.internetReachability currentReachabilityStatus];
      开关（网络状态）{
          无法到达的情况：
          {
              返回否；
          }
  
          可通过 WWAN 访问的情况：
          {
               返回是；
          }
  
          可通过WiFi可达的情况：
          {
               返回是；
          }
      }
  }
  

• 步骤 4：调用函数如下：

  if (![self checkNetConnection]) {
      [GlobalFunctions showAlert:@""
                       message:@“请连接到互联网！”
                       可以Btntitle：无
                       otherBtnTitle:@"好的"];
      返回;
  }
  别的
  {
      Log.v("互联网已连接","确定");
  }
  

Answer 27

检查 (iOS) Xcode 8、Swift 3.0 中的互联网连接可用性

这是检查网络可用性的简单方法，例如我们的设备是否连接到任何网络。我已成功将其翻译为 Swift 3.0，这里是最终代码。现有的 Apple Reachability 类和其他第三方库似乎太复杂，无法转换为 Swift。

这适用于 3G、4G 和 WiFi 连接。

不要忘记将“SystemConfiguration.framework”添加到您的项目构建器中。

//Create new swift class file Reachability in your project.
import SystemConfiguration
public class InternetReachability {

class func isConnectedToNetwork() -> Bool {
   var zeroAddress = sockaddr_in(sin_len: 0, sin_family: 0, sin_port: 0, sin_addr: in_addr(s_addr: 0), sin_zero: (0, 0, 0, 0, 0, 0, 0, 0))
   zeroAddress.sin_len = UInt8(sizeofValue(zeroAddress))
   zeroAddress.sin_family = sa_family_t(AF_INET)
   let defaultRouteReachability = withUnsafePointer(&zeroAddress) {
          SCNetworkReachabilityCreateWithAddress(nil, UnsafePointer($0)).takeRetainedValue()
   }
   var flags: SCNetworkReachabilityFlags = 0
   if SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags) == 0 {
          return false
   }
   let isReachable = (flags & UInt32(kSCNetworkFlagsReachable)) != 0
   let needsConnection = (flags & UInt32(kSCNetworkFlagsConnectionRequired)) != 0

   return isReachable && !needsConnection
  }
}

// Check network connectivity from anywhere in project by using this code.
 if InternetReachability.isConnectedToNetwork() == true {
         print("Internet connection OK")
  } else {
         print("Internet connection FAILED")
  }

Answer 28

在 ViewController 中导入 Reachable.h 类，并使用以下代码检查连接性：

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

Answer 29

导入“可达性.h”

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

Answer 30

创建AFNetworkReachabilityManager对象并使用以下代码来跟踪网络连接

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