IOS හි කොකෝවා ස්පර්ශ පුස්තකාල භාවිතා කරමින් හෝ කොකෝවා පුස්තකාල භාවිතා කරන මැකෝස් මත අන්තර්ජාල සම්බන්ධතාවයක් තිබේදැයි බැලීමට මම කැමතියි .

මම මෙය භාවිතා කර ක්‍රමයක් භාවිතා කළෙමි NSURL. මා එය කළ ආකාරය තරමක් විශ්වාසදායක නොවන බව පෙනේ (මක්නිසාද යත් ගූගල් පවා එක් දිනක් පහත් වී තෙවන පාර්ශවයක් මත යැපීම නරක යැයි පෙනේ), සහ ගූගල් ප්‍රතිචාර නොදැක්වුවහොත් වෙනත් වෙබ් අඩවි වලින් ප්‍රතිචාරයක් ලබා ගැනීමට මට හැකි අතර, මගේ යෙදුමෙහි නාස්තියක් සහ අනවශ්‍ය පොදු කාර්යයක් ලෙස පෙනේ.

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

මා කර ඇති දේ නරකද, ( stringWithContentsOfURLiOS 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")
}

පරමාර්ථය-සී

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 හි 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 ඔබ වෙනුවෙන් පරීක්ෂා කර ඇත.

මෙය නිවැරදි පිළිතුර විය, නමුත් දැන් එය යල් පැන ගිය බැවින් ඒ වෙනුවට ප්‍රතික්‍රියාශීලීත්වය සඳහා වන දැනුම්දීම් සඳහා ඔබ දායක විය යුතුය. මෙම ක්‍රමය සමකාලීනව පරික්ෂා කරයි:

ඔබට 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 සමඟ නැව්ගත නොකෙරේ, නමුත් මෙම ඇපල් නියැදි යෙදුමේ කොටසකි . එය බාගත කර 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 ඉතා කුඩා වෙබ් අඩවියකට යොමු කළ යුතුය. මම මෙහි ගූගල් ජංගම වෙබ් අඩවිය භාවිතා කරමි, නමුත් මට විශ්වාසදායක වෙබ් සේවාදායකයක් තිබේ නම් උපරිම වේගය සඳහා එක් අක්ෂරයක් සහිත කුඩා ගොනුවක් උඩුගත කරමි .

උපාංගය කෙසේ හෝ අන්තර්ජාලයට සම්බන්ධ වී ඇත්දැයි පරීක්ෂා කිරීම ඔබට කිරීමට අවශ්‍ය සියල්ල නම්, මම අනිවාර්යයෙන්ම මෙම සරල විසඳුම භාවිතා කිරීම නිර්දේශ කරමි. පරිශීලකයා සම්බන්ධ වන්නේ කෙසේදැයි ඔබට දැන ගැනීමට අවශ්‍ය නම්, ප්‍රතික්‍රියාශීලීත්වය භාවිතා කිරීම යනු යා යුතු මාර්ගයයි.

ප්‍රවේශම් වන්න: මෙය වෙබ් අඩවිය පූරණය කරන අතරතුර ඔබේ නූල් කෙටියෙන් අවහිර කරනු ඇත. මගේ නඩුවේදී, මෙය ගැටළුවක් නොවීය, නමුත් ඔබ මෙය සලකා බැලිය යුතුය (මෙය පෙන්වා දීම සඳහා බ්‍රැඩ්ට බැර).

මෙන්න මම මගේ යෙදුම් වල එය කරන්නේ කෙසේද: 200 තත්ව ප්‍රතිචාර කේතයක් කිසිවක් සහතික නොකරන නමුත් එය මට ප්‍රමාණවත් තරම් ස්ථාවර වේ. මෙහි පළ කර ඇති එන්එස්ඩේටා පිළිතුරු තරම් පැටවීම අවශ්‍ය නොවේ, මගේ පමණක් හෙඩ් ප්‍රතිචාරය පරීක්ෂා කරයි.

ස්විෆ්ට් කේතය

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

පරමාර්ථ-සී කේතය

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 සංවර්ධකයින්ගේ කුක් පොතේ උදාහරණයක් තිබේ.

සටහන: කරුණාකර Apple KHG විසින් ඇපල් හි ප්‍රතික්‍රියාශීලීතා කේතය භාවිතා කිරීම සම්බන්ධයෙන් මෙම පිළිතුර පිළිබඳ අදහස් දැක්වීම බලන්න.

ඔබට Reachabilityby මගින් භාවිතා කළ හැකිය ( මෙහි ඇත ).

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

ඇපල් විසින් නියැදි යෙදුමක් සපයන අතර එය හරියටම මෙය කරයි:

ප්‍රතික්‍රියාශීලී බව

යාවත්කාලීන කර ඇත්තේ ප්‍රතික්‍රියාශීලීතා පන්තිය පමණි. ඔබට දැන් භාවිතා කළ හැකිය:

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 docs හි "උප පංති සටහන්" හි සඳහන් පරිදි ) BKHTTPClientමම තනි තනි උප පංතියක් නිර්මාණය කර ඇතැයි සිතමු , මම එවැනි දෙයක් කරන්නෙමි:

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

ඔබට AFNetworkReachabilityStatusReachableViaWWANසහ AFNetworkReachabilityStatusReachableViaWiFienums භාවිතා කරමින් 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 පන්තිය භාවිතා කරන්න .

අයිෆෝන් එස්ඩීකේ භාවිතයෙන් අන්තර්ජාල උපයෝජ්‍යතාව පරීක්ෂා කිරීමට ක්‍රම දෙකක් තිබේ:

1. ගූගල් පිටුව විවෘතව තිබේද නැද්ද යන්න පරීක්ෂා කරන්න.

2. ප්‍රතික්‍රියාශීලී පන්තිය

වැඩි විස්තර සඳහා කරුණාකර ප්‍රතික්‍රියාශීලීතාව (ඇපල් සංවර්ධක) වෙත යොමු වන්න .

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 සහ reachabilly.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;
}

දැන් ඔබට මෙම පන්ති ක්‍රමය ඇමතීමෙන් ඕනෑම පන්තියක ජාල සම්බන්ධතාවය පරීක්ෂා කළ හැකිය.

අයිෆෝන් එස්ඩීකේ භාවිතයෙන් අන්තර්ජාල සම්බන්ධතාවය පරීක්ෂා කිරීමට තවත් ක්‍රමයක් තිබේ.

ජාල සම්බන්ධතාවය සඳහා පහත කේතය ක්‍රියාත්මක කිරීමට උත්සාහ කරන්න.

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

සිම්පල් පිං හෙල්පර් පුස්තකාලය භාවිතා කිරීම සරල හා පහසු බව මට පෙනී ගියේය .

නියැදි කේතය: chrishulbert / SimplePingHelper ( GitHub )

1. Reachability ගොනුව බාගන්න, https://gist.github.com/darkseed/1182373

2. CFNetwork.frameworkරාමුව තුළ 'SystemConfiguration.framework' එකතු කර එකතු කරන්න

3. # ආයාත කරන්න "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)

}

මෙම Reachability පන්තියේ මෙම අන්තර්ජාල සම්බන්ධතාවයක් උපකරණයක් ලබා ගත හැක හෝ නොවේ නම් සොයා ගැනීමට හරි තමයි ...

නමුත් අන්තර් ජාල සම්පතකට ප්‍රවේශවීමේදී :

ප්‍රතික්‍රියාශීලී පන්තිය සමඟ අන්තර් ජාල සේවාදායකය සම්බන්ධ කිරීම සැමවිටම සත්‍ය වේ.

එබැවින් මෙම තත්වය තුළ ඉක්මන් විසඳුමක් 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");
  }