iOS 또는 MACOS에서 활성 인터넷 연결을 확인하는 방법은 무엇입니까?

https://stackoverflow.com/questions/1083701

23-08-2019
|

문제

iOS에서 인터넷에 연결되어 있는지 확인하고 싶습니다. 코코아 터치 라이브러리 또는 MACOS를 사용하여 코코아 도서관.

나는 NSURL. 내가 한 방식은 약간 신뢰할 수없는 것처럼 보입니다 (Google조차도 언젠가는 제 3 자에게 의존하고 나쁘게 의존 할 수 있기 때문에). Google이 응답하지 않으면 다른 웹 사이트의 응답을 확인할 수 있지만 IT 내 응용 프로그램에서 낭비적이고 불필요한 오버 헤드가 나타납니다.

- (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) 코코 포드 또는 카르타고를 통해 설치 : 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) Tony Million의 버전을 추가하십시오 Reachability.h 그리고 Reachability.m 프로젝트에 (여기서 찾을 수 있습니다 : https://github.com/tonymillion/reachility)

3) 인터페이스 섹션을 업데이트하십시오

#import "Reachability.h"

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

4) 그런 다음 호출 할 수있는 View Controller의 .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의 도달 가능성 클래스를 사용할 수 있습니다. 또한 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 샘플 응용 프로그램. 다운로드하고 프로젝트에 도달 가능성을 복사하십시오. 또한 프로젝트에 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 상태 응답 코드는 아무것도 보장하지 않지만 나에게 충분히 안정적입니다. 이것은 여기에 게시 된 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
         }
    }];
}

사과 용품 샘플 코드 다양한 유형의 네트워크 가용성을 확인합니다. 대안 적으로 예시 iPhone Developers Cookbook에서.

메모: Apple의 도달 가능성 코드 사용과 관련 하여이 답변에 대한 @KHG의 의견을 참조하십시오.

당신은 사용할 수 있습니다 Reachability by  (여기에서 사용할 수 있습니다).

#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의 도달 가능성에 대한 버전은입니다 Darkseed/Reachability.h. 내 것이 아니야! =))

도달 가능성의 멋진 모습, 아크 및 GCD 사용 현대화가 있습니다.

도달 가능성

사용하는 경우 AFNetworking 인터넷 도달 성 상태에 자체 구현을 사용할 수 있습니다.

사용하는 가장 좋은 방법 AFNetworking 서브 클래스입니다 AFHTTPClient 클래스 및이 클래스를 사용하여 네트워크 연결을 수행하십시오.

이 접근법을 사용하는 장점 중 하나는 사용할 수 있다는 것입니다. blocks 도달 가능성 상태가 변경 될 때 원하는 동작을 설정합니다. 내가 싱글 톤 서브 클래스를 만들었다 고 가정했다 AFHTTPClient ( "서브 클래스 노트"에서 언급했듯이 Afnetworking 문서) 명명 된 BKHTTPClient, 나는 다음과 같은 일을 할 것입니다.

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

특별히 사용하는 Wi-Fi 또는 WLAN 연결을 확인할 수도 있습니다. AFNetworkReachabilityStatusReachableViaWWAN 그리고 AFNetworkReachabilityStatusReachableViaWiFi 열거여기 더).

코드를 사용했습니다 이 토론, 그리고 그것은 잘 작동하는 것 같습니다 (읽기 전부의 실!).

나는 상상할 수있는 모든 종류의 연결 (Ad Hoc Wi-Fi)에 대해 철저하게 테스트하지 않았습니다.

매우 간단합니다 ....이 단계를 시도하십시오.

1 단계: 추가 SystemConfiguration 프로젝트 프레임 워크.

2 단계: 다음 코드를 귀하에게 가져옵니다 header 파일.

#import <SystemConfiguration/SystemConfiguration.h>

3 단계 : : 다음 방법을 사용하십시오

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

Type 2:

헤더 가져 오기 : #import "Reachability.h"

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

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

또는 사용하십시오 도달 가능성 클래스.

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

먼저 도달 가능성 클래스를 다운로드하고 도달 가능성을 넣고 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)

도달 가능성 파일을 다운로드하고 https://gist.github.com/darkseed/1182373
그리고 추가 CFNetwork.framework 및 프레임 워크의 'SystemConfiguration.framework'
#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");
    }
}

그만큼 도달 가능성 클래스 인터넷 연결을 장치에 사용할 수 있는지 확인해도 괜찮습니다 ...

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

도달 가능성 클래스로 인트라넷 서버를 핑하는 것은 항상 사실을 반환합니다.

따라서이 시나리오에서 빠른 솔루션은 웹 메소드를 만드는 것입니다. 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;
}

빠르고 단순하고 고통스럽지 않습니다.

도달 가능성 외에도 사용할 수도 있습니다 간단한 핑 헬퍼 라이브러리. 정말 훌륭하고 통합하기가 간단합니다.

나는 이것이 최고의 대답이라고 생각합니다.

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

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

(iOS) Xcode 8, Swift 3.0에서 인터넷 연결 가용성 확인

이것은 우리의 장치가 네트워크에 연결되어 있거나없는 것처럼 네트워크 가용성을 확인하는 간단한 방법입니다. 나는 그것을 Swift 3.0으로 번역하고 여기서 최종 코드로 번역했습니다. 기존의 Apple 도달 가능성 클래스 및 기타 제 3 자 라이브러리는 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")
  }

라이센스 : CC-BY-SA ~와 함께 속성

제휴하지 않습니다 StackOverflow