ios - iOS または macOS でアクティブなインターネット接続を確認するにはどうすればよいですか?

Question

Cocoa Touchライブラリを使用する iOS または Cocoaライブラリを使用する macOSでインターネット接続があるかどうかを確認したいと思います。

を使用してこれを行う方法を思いつきましたNSURL。私が行った方法は少し信頼性がないように思えます (Google でさえいつかダウンする可能性があり、サードパーティに依存するのは良くないように思われるため)。私のアプリケーションでは無駄で不必要なオーバーヘッドのようです。

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

私がやったことは悪いことですか (言うまでもなくstringWithContentsOfURL、iOS 3.0 と macOS 10.4 では非推奨です)、もしそうなら、これを達成するためのより良い方法は何ですか?

score 1307 · Accepted Answer

重要：このチェックは常に非同期で実行する必要があります。以下の回答の大部分は同期的であるため、注意してください。そうしないと、アプリがフリーズします。

迅速

CocoaPodsまたはCarthage経由でインストール：https ：//github.com/ashleymills/Reachability.swift

クロージャを介して到達可能性をテストする

let reachability = Reachability()!

reachability.whenReachable = { reachability in
    if reachability.connection == .wifi {
        print("Reachable via WiFi")
    } else {
        print("Reachable via Cellular")
    }
}

reachability.whenUnreachable = { _ in
    print("Not reachable")
}

do {
    try reachability.startNotifier()
} catch {
    print("Unable to start notifier")
}

Objective-C

プロジェクトにフレームワークを追加SystemConfigurationしますが、どこにでも含める必要はありません
Tony MillionのバージョンReachability.hとReachability.mをプロジェクトに追加します（ここにあります：https ：//github.com/tonymillion/Reachability ）

インターフェイスセクションを更新します

#import "Reachability.h"

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

次に、このメソッドを、呼び出すことができるViewControllerの.mファイルに実装します。

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

重要な注意：このReachabilityクラスはプロジェクトで最もよく使用されるクラスの1つであるため、他のプロジェクトとの名前の競合が発生する可能性があります。これが発生した場合、問題を解決するにはReachability.h、ファイルのペアの1つを別の名前に変更する必要があります。Reachability.m

注：使用するドメインは関係ありません。これは、任意のドメインへのゲートウェイをテストしているだけです。

score 314 · Accepted Answer

私は物事をシンプルに保つのが好きです。私がこれを行う方法は次のとおりです。

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

このメソッドは、処理を行うためにネットワークステータスの変更を待機しません。要求されたときにステータスをテストするだけです。

score 146 · Accepted Answer

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です。

score 123 · Accepted Answer

これは以前は正解でしたが、代わりに到達可能性のために通知を購読する必要があるため、現在は時代遅れです。このメソッドは同期的にチェックします。

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 フレームワークをプロジェクトに追加する必要があります。

score 82 · Accepted Answer

これは非常に簡単な答えです：

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 は、非常に小さな Web サイトを指している必要があります。ここでは Google のモバイル Web サイトを使用していますが、信頼できる Web サーバーがあれば、最大速度のために1 文字だけの小さなファイルをアップロードします。

デバイスが何らかの方法でインターネットに接続されているかどうかを確認するだけなら、このシンプルなソリューションを使用することを強くお勧めします。ユーザーがどのように接続されているかを知る必要がある場合は、Reachability を使用することをお勧めします。

注意: これにより、Web サイトをロードしている間、スレッドが一時的にブロックされます。私の場合、これは問題ではありませんでしたが、これを考慮する必要があります (これを指摘してくれた Brad の功績によるものです)。

score 73 · Accepted Answer

アプリでこれを行う方法は次のとおりです。200 ステータス応答コードは何も保証しませんが、私にとっては十分に安定しています。私の場合はHEAD応答をチェックするだけなので、ここに投稿されたNSDataの回答ほど多くの読み込みは必要ありません。

スウィフトコード

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

score 57 · Accepted Answer

Apple は、さまざまな種類のネットワークの可用性を確認するためのサンプルコードを提供しています。あるいは、iPhone 開発者クックブックに例があります。

注: Apple の到達可能性コードの使用に関するこの回答に対する @KHG のコメントを参照してください。

score 46 · Accepted Answer

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.

score 40 · Accepted Answer

40

Apple は、まさにこれを行うサンプルアプリを提供しています。

到達可能性

于 2009-07-05T08:58:25.503 に答える

score 33 · Accepted Answer

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

score 27 · Accepted Answer

iOS 5 の Reachability のバージョンはdarkseed/Reachability.hです。私のものではありません！=)

score 25 · Accepted Answer

見栄えの良い、ARC および GCD を使用した到達可能性のモダナイゼーションがここにあります。

到達可能性

score 22 · Accepted Answer

使用している場合はAFNetworking、インターネットの到達可能性ステータスに独自の実装を使用できます。

最適な使用方法AFNetworkingは、クラスをサブクラス化し、AFHTTPClientこのクラスを使用してネットワーク接続を行うことです。

このアプローチを使用する利点の 1 つはblocks、到達可能性ステータスが変化したときに目的の動作を設定できることです。という名前のシングルトンサブクラスを作成したと仮定すると( AFNetworking docsAFHTTPClientの「サブクラス化に関する注意事項」で説明されているように) 、次のようにします。BKHTTPClient

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

AFNetworkReachabilityStatusReachableViaWWANおよびAFNetworkReachabilityStatusReachableViaWiFi列挙型を使用して、Wi-Fi または WLAN 接続を確認することもできます(詳細はこちら)。

score 18 · Accepted Answer

このディスカッションのコードを使用しましたが、問題なく動作しているようです (スレッド全体を読んでください!)。

考えられるすべての種類の接続 (アドホック Wi-Fi など) で徹底的にテストしたわけではありません。

score 15 · Accepted Answer

非常に簡単です....次の手順を試してください。

ステップ 1:SystemConfigurationフレームワークをプロジェクトに追加します。

ステップ 2:次のコードをファイルにインポートしheaderます。

#import <SystemConfiguration/SystemConfiguration.h>

ステップ 3:次の方法を使用する

タイプ 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;
}

タイプ 2:

ヘッダーのインポート:#import "Reachability.h"

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

ステップ 4:使用方法:

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

score 10 · Accepted Answer

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

score 8 · Accepted Answer

最初に到達可能性クラスをダウンロードし、reachability.h および reachabilty.m ファイルをXcodeに配置します。

最善の方法は、共通の関数クラス (NSObject) を作成して、どのクラスでも使用できるようにすることです。これらは、ネットワーク接続の到達可能性チェックの 2 つの方法です。

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

このクラスメソッドを呼び出すことで、任意のクラスでネットワーク接続を確認できるようになりました。

score 8 · Accepted Answer

ライブラリSimplePingHelperはシンプルで使いやすいことがわかりました。

サンプルコード: chrishulbert/SimplePingHelper ( GitHub )

score 8 · Accepted Answer

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

score 7 · Accepted Answer

これがベストアンサーだと思います。

「はい」は接続を意味します。「いいえ」は切断を意味します。

#import "Reachability.h"

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

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

score 7 · Accepted Answer

到達可能性とは別に、Simple Ping ヘルパーライブラリを使用することもできます。それは本当にうまく機能し、統合が簡単です。

score 6 · Accepted Answer

ステップ 1: プロジェクトに Reachability クラスを追加します。
ステップ 2: 到達可能性クラスをインポートする

ステップ 3: 以下の関数を作成する

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

ステップ 4: 以下のように関数を呼び出します。

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

score 6 · Accepted Answer

Reachable.hにクラスをインポートViewControllerし、次のコードを使用して接続を確認します。

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

score 6 · Accepted Answer

6

于 2015-12-17T12:14:31.013 に答える

score 3 · Accepted Answer

https://github.com/tonymillion/Reachabilityから Reachabilty クラスを取得し、プロジェクトにシステム構成フレームワークを追加し、クラスに Reachability.h をインポートして、以下のようにカスタムメソッドを実装します。

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

score 3 · Accepted Answer

import "Reachability.h"

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

score 3 · Accepted Answer

のオブジェクトを作成し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;
        }
    }];

score 3 · Accepted Answer

Xcode 9 および Swift 4.0 を使用して (iOS) でインターネット接続の可用性を確認する

以下の手順に従ってください

ステップ1：

拡張ファイルを作成し、ReachabilityManager.swiftという名前を付けます。次に、以下のコード行を追加します。

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

ステップ 2:以下のコードを使用して、上記の拡張機能を呼び出します。

if ConnectionCheck.isConnectedToNetwork()
{
     print("Connected")
     // Online related Business logic
}
else{
     print("disConnected")
     // Offline related business logic
}

score 2 · Accepted Answer

これは Swift 3.0 および async 用です。ほとんどの回答は、接続が非常に遅い場合にメインスレッドをブロックする同期ソリューションです。

このソリューションは優れていますが、Google に依存して接続を確認するため、完全ではありません。別の URL を自由に使用してください。

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

score 2 · Accepted Answer

Network.framework の紹介: Sockets の最新の代替手段を参照してください。

ある時点で到達可能性を取り除く必要があります。

score 1 · Accepted Answer

アラモファイア

質問が Coca Touch ソリューションを求めていることは承知していますが、iOS でインターネット接続を検索し、ここにもう 1 つのオプションがあることを確認した人向けのソリューションを提供したいと考えています。

すでにAlamofireを使用している場合は、次のメリットがあります。

次のクラスをアプリに追加し、呼び出しMNNetworkUtils.main.isConnected()て、接続されているかどうかのブール値を取得できます。

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

これはシングルトンクラスです。ユーザーがネットワークに接続または切断するたびに、 on シングルトンの初期化self.reachableのリッスンを開始するため、正しく true/false にオーバーライドされます。NetworkReachabilityManager

また、到達可能性を監視するには、ホストを提供する必要があります。現在、私は google.com を使用していますが、必要に応じて他のホストやあなたのホストに自由に変更してください。クラス名とファイル名をプロジェクトに一致するものに変更します。