Cocoa Touch를 사용하여 iOS에서 인터넷에 연결되어 있는지 확인하고 싶습니다. 라이브러리를 또는 Cocoa 라이브러리를 사용하는 macOS .

나는 이것을 사용하여 이것을 수행하는 방법을 생각해 냈습니다 NSURL. 내가 한 방식은 약간 신뢰할 수없는 것 같습니다 (Google조차도 언젠가 다운되어 타사에 의존 할 수 있기 때문에 나쁜 것 같습니다) .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에서는 더 이상 사용되지 않습니다) 그렇다면 그렇게하는 더 좋은 방법은 무엇입니까?

중요 :이 점검은 항상 비동기 적으로 수행 해야합니다 . 아래 답변의 대부분은 동기식이므로 그렇지 않으면 앱이 중지됩니다.

빠른

1) CocoaPods 또는 Carthage를 통해 설치 하십시오 : https://github.com/ashleymills/Reachability.swift

2) 폐쇄를 통한 접근성 테스트

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

목표 -C

1) SystemConfiguration프로젝트에 프레임 워크를 추가 하지만 어디서나 포함시키는 것에 대해 걱정하지 마십시오.

2)의 토니 만의 버전을 추가 Reachability.h하고 Reachability.m프로젝트에 (여기 : https://github.com/tonymillion/Reachability )

3) 인터페이스 섹션 업데이트

#import "Reachability.h"

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

4) 그런 다음이 메소드를 호출 할 수있는 뷰 컨트롤러의 .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 다른 프로젝트와 이름 충돌로 실행할 수 있도록 클래스를 프로젝트에 가장 많이 사용되는 클래스 중 하나입니다. 이 경우, 당신은 쌍 중 하나의 이름을 변경해야 Reachability.h하고Reachability.m 문제를 해결하려면 파일 파일 합니다.

참고 : 사용 하는 도메인은 중요하지 않습니다. 모든 도메인에 대한 게이트웨이를 테스트하고 있습니다.

나는 일을 단순하게 유지하고 싶다. 내가하는 방법은 다음과 같습니다.

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

이 방법은 네트워크 상태가 변경 될 때까지 기다리지 않습니다. 요청하면 상태 만 테스트합니다.

Apple의 접근성 코드를 사용하여 클래스를 포함하지 않고도이를 올바르게 확인할 수있는 기능을 만들었습니다.

프로젝트에 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 입니다.

이것은 정답 이었지만 지금은 도달 가능성에 대한 알림을 구독해야하므로 구식입니다. 이 방법은 동 기적으로 확인합니다.

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

연결성 클래스는 SDK와 함께 제공되지 않고이 Apple 샘플 응용 프로그램 의 일부입니다 . 다운로드하여 프로젝트에 Reachability.h / m을 복사하십시오. 또한 프로젝트에 SystemConfiguration 프레임 워크를 추가해야합니다.

다음은 매우 간단한 답변입니다.

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의 모바일 웹 사이트를 사용하지만 신뢰할 수있는 웹 서버가있는 경우 최대 속도를 위해 문자가 하나만있는 작은 파일을 업로드 했습니다 .

장치가 어떻게 든 인터넷에 연결되어 있는지 확인하는 것이 원하는 모든 것이라면이 간단한 솔루션을 사용하는 것이 좋습니다. 사용자의 연결 방법을 알아야하는 경우 도달 가능성을 사용하는 것이 좋습니다.

주의 : 스레드가 웹 사이트를로드하는 동안 스레드가 잠시 차단됩니다. 내 경우에는 이것이 문제가되지 않았지만 이것을 고려해야합니다 (브래드가 이것을 지적한 것에 대한 신용).

내 앱에서 수행하는 방법은 다음과 같습니다. 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
        }
    })
}

오브젝티브 -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 은 다양한 유형의 네트워크 가용성을 확인하기 위해 샘플 코드 를 제공 합니다. 또는 iPhone 개발자 요리 책에 예가 있습니다.

참고 : Apple의 접근성 코드 사용에 대한이 답변에 대한 @KHG의 의견을 참조하십시오.

당신은 사용할 수 있습니다 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.

Apple은 정확히 다음을 수행하는 샘플 앱을 제공합니다.

접근성

접근성 클래스 만 업데이트되었습니다. 이제 다음을 사용할 수 있습니다.

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

iOS 5의 Reachability 버전은 darkseed / Reachability.h 입니다. 그건 내 것이 아니다! =)

도달 가능성에 대한 근사한 ARC 및 GCD 사용 현대화가 있습니다.

접근성

사용중인 경우 AFNetworking인터넷 연결 가능성 상태에 대해 자체 구현을 사용할 수 있습니다.

사용하는 가장 좋은 방법 AFNetworking은AFHTTPClient 클래스 하고이 클래스를 사용하여 네트워크 연결을 수행하는 것입니다.

이 방법을 사용하면 얻을 수있는 장점 중 하나는 연결 blocks가능성 상태가 변경 될 때 원하는 동작을 설정하는 데 사용할 수 있다는 것 입니다. 나는의 싱글 서브 클래스를 만든 것을 가정하면 AFHTTPClient(이하 "하위 클래스 노트"에서 말했듯에 AFNetworking 문서 이름) BKHTTPClient, 내가 뭔가를 같이 할 것입니다 :

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

또한 AFNetworkReachabilityStatusReachableViaWWAN및 AFNetworkReachabilityStatusReachableViaWiFi열거 형 ( 자세히보기 )을 사용하여 Wi-Fi 또는 WLAN 연결을 확인할 수도 있습니다 .

이 토론 에서 코드를 사용했는데 잘 작동하는 것 같습니다 ( 전체 읽기 스레드를 !).

나는 상상할 수있는 모든 종류의 연결 (애드혹 Wi-Fi와 같은)로 철저하게 테스트하지 않았습니다.

매우 간단합니다 .... 다음 단계를 수행하십시오.

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

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

또는 Reachability 클래스를 사용하십시오 .

iPhone SDK를 사용하여 인터넷 가용성을 확인하는 두 가지 방법이 있습니다.

1. Google 페이지가 열려 있는지 확인하십시오.

2. 접근성 등급

자세한 내용은 접근성 (Apple Developer)을 참조하십시오 .

http://huytd.github.io/datatify/를 사용 하십시오 . 라이브러리를 추가하고 직접 코드를 작성하는 것보다 쉽습니다.

첫 번째 : 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");
    }
}

먼저 접근성 클래스를 다운로드하고 reachability.h 및 reachabilty.m 파일을 Xcode 에 넣으십시오 .

가장 좋은 방법은 모든 클래스에서 사용할 수 있도록 공통 함수 클래스 (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;
}

이제이 클래스 메소드를 호출하여 모든 클래스의 네트워크 연결을 확인할 수 있습니다.

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

라이브러리 SimplePingHelper 사용이 간단하고 쉽다는 것을 알았습니다 .

샘플 코드 : chrishulbert / SimplePingHelper ( GitHub )

1. 접근성 파일 ( https://gist.github.com/darkseed/1182373)을 다운로드 하십시오.

2. 그리고 CFNetwork.framework프레임 워크에 'SystemConfiguration.framework'를 추가하십시오.

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

스위프트 3 / 스위프트 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)

}

도달 가능성 클래스는 인터넷 연결 장치에 또는 사용할 수없는 경우 찾아 OK입니다 ...

그러나 인트라넷 리소스 에 액세스하는 경우 :

접근성 클래스로 인트라넷 서버를 핑하면 항상 true를 리턴합니다.

따라서이 시나리오에서 빠른 솔루션 pingme은 서비스에서 다른 웹 메소드 와 함께 호출되는 웹 메소드를 작성하는 것 입니다. 는 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를 사용하여 항상 인트라넷 리소스의 연결 가능성을 확인합니다.

이 작업을 직접 수행하는 것은 매우 간단합니다. 다음 방법이 작동합니다. HTTP, HTTPS 등과 같은 호스트 이름 프로토콜이 이름과 함께 전달되지 않도록하십시오.

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

빠르고 간단합니다.

접근성 외에도 Simple Ping 도우미 라이브러리를 사용할 수도 있습니다 . 정말 훌륭하고 통합하기가 쉽습니다.

이것이 가장 좋은 대답이라고 생각합니다.

"예"는 연결된 것을 의미합니다. "아니오"는 연결이 끊어진 것을 의미합니다.

#import "Reachability.h"

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

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

Reachable.h에서 클래스를 가져 ViewController오고 다음 코드를 사용하여 연결 을 확인하십시오 .

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

• 1 단계 : 프로젝트에 접근성 클래스를 추가합니다.
• 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");
  }