在檢查互聯網和主機網絡連接問題

Question

得到的問題是，以及如何解決這個問題。我嘗試互聯網是比我必須去SYNC過程。但我工作怎麼能做到這一點。

[TDatasyncmanager chekNetworkStatus:]': 
:incompatible types in initialization 
:switch quantity not an integer 

我想檢查這樣

TDatasyncmanager.h文件

#import "Reachability.h" 

@interface TDatasyncmanager : UIViewController 
{ 

    Reachability *internetReachable; 
    Reachability *hostReachable; 
    BOOL internetActive; 
    NSMutableData *webData; 
} 

-(void)chekNetworkStatus:(NSNotification*)notice; 
@end 

而且在TDatasyncmanager.m文件中的互聯網連接和主機的網絡連接

#import "TDatasyncmanager.h" 
#import "Reachability.h" 

@implementation TDatasyncmanager 
@synthesize internetActive; 




- (void)viewDidLoad { 
    [super viewDidLoad]; 
    //check for internet connection 
    [[NSNotification defaultCenter] addObserver:self selector:@selector(checkNetworkStatus:) name:kReachabilityChangedNotification object:nil]; 
    [internetReachable startNotifier]; 

    //check for apathwa to arandom host exits 
    hostReachable = [[Reachability reachabilityWithHostName:@"http://www.google.com"]retain]; 
    [hostReachable startNotifier]; 


    if(internetActive == YES) 
    { 
     NSLog(@"tokenapi:%@ annan %@",tokenapi,Contentid); 
     NSString *post; 
     NSData *postData = [post dataUsingEncoding:NSASCIIStringEncoding allowLossyConversion:YES]; 
     NSString *postLength = [NSString stringWithFormat:@"%d", [postData length]]; 
     NSLog(@"%@",postLength); 
     NSMutableURLRequest *request = [[[NSMutableURLRequest alloc] init] autorelease]; 
     [request setURL:[NSURL URLWithString:@"http://192.168.0.1:88/"]]; 
     [request setHTTPMethod:@"POST"]; 
     [request setValue:postLength forHTTPHeaderField:@"Content-Length"]; 
     [request setValue:@"application/x-www-form-urlencoded" forHTTPHeaderField:@"Content-Type"]; 
     [request setHTTPBody:postData]; 

     NSURLConnection *theConnection = [[NSURLConnection alloc] initWithRequest:request delegate:self]; 

     if (theConnection) { 
      webData = [[NSMutableData data] retain]; 
      NSLog(@"%@",webData); 
      //[theConnection start]; 
     } 

    } 

} 

-(void)chekNetworkStatus:(NSNotification *)notice 

{ 
    **//called after network status changes 

    NetworkStatus *internetStatus = [internetReachable currentReachabilityStatus];//:incompatible types in initialization 

    switch(internetStatus)//:switch quantity not an integer**  
    { 
     case NotReachable: 
     { 
      NSLog(@"The internet is down."); 
      self.internetActive = NO; 
      break; 
     } 
     case ReachableViaWiFi: 
     { 
      NSLog(@"The internet is working via WIFI."); 
      self.internetActive = YES; 
      break; 
     } 
     case ReachableViaWWAN: 
     { 
      NSLog(@"The internet is working via WWAN."); 
      self.internetActive = YES; 
      break; 
     } 
     default: 
     { 
      NSLog(@"The internet by defualt is Not working."); 
      self.internetActive = NO; 
      break; 
     } 
    } 
    NetworkStatus hostStatus = [hostReachable currentReachabilityStatus]; 
    switch (hostStatus) 
    { 
     case NotReachable: 
     { 
      NSLog(@"The internet is down."); 
      self.internetActive = NO; 
      break; 
     } 
     case ReachableViaWiFi: 
     { 
      NSLog(@"The internet is working Via WIFI."); 
      self.internetActive = YES; 
      break; 
     } 
     case ReachableViaWWAN: 
     { 
      NSLog(@"The internet is working Via WWAN."); 
      self.internetActive = YES; 
      break; 
     } 
     default: 
     { 
      NSLog(@"the internet is down."); 
      self.internetActive= NO; 
     } 
    } 
} 

Answer 1

for Checking Network Present Status We Need Two Classes 
    Reachability.h 


     #import <Foundation/Foundation.h> 
     #import <SystemConfiguration/SystemConfiguration.h> 

     typedef enum { 
      NotReachable = 0, 
      ReachableViaWiFi, 
      ReachableViaWWAN 
     } NetworkStatus; 
     #define kReachabilityChangedNotification @"kNetworkReachabilityChangedNotification" 

     @interface Reachability: NSObject 
     { 
      BOOL localWiFiRef; 
      SCNetworkReachabilityRef reachabilityRef; 
     } 

     //reachabilityWithHostName- Use to check the reachability of a particular host name. 
     + (Reachability*) reachabilityWithHostName: (NSString*) hostName; 

     //reachabilityWithAddress- Use to check the reachability of a particular IP address. 
     + (Reachability*) reachabilityWithAddress: (const struct sockaddr_in*) hostAddress; 

     //reachabilityForInternetConnection- checks whether the default route is available. 
     // Should be used by applications that do not connect to a particular host 
     + (Reachability*) reachabilityForInternetConnection; 

     //reachabilityForLocalWiFi- checks whether a local wifi connection is available. 
     + (Reachability*) reachabilityForLocalWiFi; 

     //Start listening for reachability notifications on the current run loop 
     - (BOOL) startNotifer; 
     - (void) stopNotifer; 

     - (NetworkStatus) currentReachabilityStatus; 
     //WWAN may be available, but not active until a connection has been established. 
     //WiFi may require a connection for VPN on Demand. 
     - (BOOL) connectionRequired; 
     @end 

    Reachability.m 

    #import <sys/socket.h> 
    #import <netinet/in.h> 
    #import <netinet6/in6.h> 
    #import <arpa/inet.h> 
    #import <ifaddrs.h> 
    #import <netdb.h> 

    #import <CoreFoundation/CoreFoundation.h> 

    #import "Reachability.h" 

    #define kShouldPrintReachabilityFlags 1 

    static void PrintReachabilityFlags(SCNetworkReachabilityFlags flags, const char* comment) 
    { 
    #if kShouldPrintReachabilityFlags 

     NSLog(@"Reachability Flag Status: %c%c %c%c%c%c%c%c%c %s\n", 
       (flags & kSCNetworkReachabilityFlagsIsWWAN)    ? 'W' : '-', 
       (flags & kSCNetworkReachabilityFlagsReachable)   ? 'R' : '-', 

       (flags & kSCNetworkReachabilityFlagsTransientConnection) ? 't' : '-', 
       (flags & kSCNetworkReachabilityFlagsConnectionRequired) ? 'c' : '-', 
       (flags & kSCNetworkReachabilityFlagsConnectionOnTraffic) ? 'C' : '-', 
       (flags & kSCNetworkReachabilityFlagsInterventionRequired) ? 'i' : '-', 
       (flags & kSCNetworkReachabilityFlagsConnectionOnDemand) ? 'D' : '-', 
       (flags & kSCNetworkReachabilityFlagsIsLocalAddress)  ? 'l' : '-', 
       (flags & kSCNetworkReachabilityFlagsIsDirect)    ? 'd' : '-', 
       comment 
       ); 
    #endif 
    } 


    @implementation Reachability 
    static void ReachabilityCallback(SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags, void* info) 
    { 
     #pragma unused (target, flags) 
     NSCAssert(info != NULL, @"info was NULL in ReachabilityCallback"); 
     NSCAssert([(NSObject*) info isKindOfClass: [Reachability class]], @"info was wrong class in ReachabilityCallback"); 

     //We're on the main RunLoop, so an NSAutoreleasePool is not necessary, but is added defensively 
     // in case someon uses the Reachablity object in a different thread. 
     NSAutoreleasePool* myPool = [[NSAutoreleasePool alloc] init]; 

     Reachability* noteObject = (Reachability*) info; 
     // Post a notification to notify the client that the network reachability changed. 
     [[NSNotificationCenter defaultCenter] postNotificationName: kReachabilityChangedNotification object: noteObject]; 

     [myPool release]; 
    } 

    - (BOOL) startNotifer 
    { 
     BOOL retVal = NO; 
     SCNetworkReachabilityContext context = {0, self, NULL, NULL, NULL}; 
     if(SCNetworkReachabilitySetCallback(reachabilityRef, ReachabilityCallback, &context)) 
     { 
      if(SCNetworkReachabilityScheduleWithRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode)) 
      { 
       retVal = YES; 
      } 
     } 
     return retVal; 
    } 

    - (void) stopNotifer 
    { 
     if(reachabilityRef!= NULL) 
     { 
      SCNetworkReachabilityUnscheduleFromRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode); 
     } 
    } 

    - (void) dealloc 
    { 
     [self stopNotifer]; 
     if(reachabilityRef!= NULL) 
     { 
      CFRelease(reachabilityRef); 
     } 
     [super dealloc]; 
    } 

    + (Reachability*) reachabilityWithHostName: (NSString*) hostName; 
    { 
     Reachability* retVal = NULL; 
     SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithName(NULL, [hostName UTF8String]); 
     if(reachability!= NULL) 
     { 
      retVal= [[[self alloc] init] autorelease]; 
      if(retVal!= NULL) 
      { 
       retVal->reachabilityRef = reachability; 
       retVal->localWiFiRef = NO; 
      } 
     } 
     return retVal; 
    } 

    + (Reachability*) reachabilityWithAddress: (const struct sockaddr_in*) hostAddress; 
    { 
     SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr*)hostAddress); 
     Reachability* retVal = NULL; 
     if(reachability!= NULL) 
     { 
      retVal= [[[self alloc] init] autorelease]; 
      if(retVal!= NULL) 
      { 
       retVal->reachabilityRef = reachability; 
       retVal->localWiFiRef = NO; 
      } 
     } 
     return retVal; 
    } 

    + (Reachability*) reachabilityForInternetConnection; 
    { 
     struct sockaddr_in zeroAddress; 
     bzero(&zeroAddress, sizeof(zeroAddress)); 
     zeroAddress.sin_len = sizeof(zeroAddress); 
     zeroAddress.sin_family = AF_INET; 
     return [self reachabilityWithAddress: &zeroAddress]; 
    } 

    + (Reachability*) reachabilityForLocalWiFi; 
    { 
     [super init]; 
     struct sockaddr_in localWifiAddress; 
     bzero(&localWifiAddress, sizeof(localWifiAddress)); 
     localWifiAddress.sin_len = sizeof(localWifiAddress); 
     localWifiAddress.sin_family = AF_INET; 
     // IN_LINKLOCALNETNUM is defined in <netinet/in.h> as 169.254.0.0 
     localWifiAddress.sin_addr.s_addr = htonl(IN_LINKLOCALNETNUM); 
     Reachability* retVal = [self reachabilityWithAddress: &localWifiAddress]; 
     if(retVal!= NULL) 
     { 
      retVal->localWiFiRef = YES; 
     } 
     return retVal; 
    } 

    #pragma mark Network Flag Handling 

    - (NetworkStatus) localWiFiStatusForFlags: (SCNetworkReachabilityFlags) flags 
    { 
     PrintReachabilityFlags(flags, "localWiFiStatusForFlags"); 

     BOOL retVal = NotReachable; 
     if((flags & kSCNetworkReachabilityFlagsReachable) && (flags & kSCNetworkReachabilityFlagsIsDirect)) 
     { 
      retVal = ReachableViaWiFi; 
     } 
     return retVal; 
    } 

    - (NetworkStatus) networkStatusForFlags: (SCNetworkReachabilityFlags) flags 
    { 
     PrintReachabilityFlags(flags, "networkStatusForFlags"); 
     if ((flags & kSCNetworkReachabilityFlagsReachable) == 0) 
     { 
      // if target host is not reachable 
      return NotReachable; 
     } 

     BOOL retVal = NotReachable; 

     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 
      retVal = ReachableViaWiFi; 
     } 


     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 
        retVal = ReachableViaWiFi; 
       } 
      } 

     if ((flags & kSCNetworkReachabilityFlagsIsWWAN) == kSCNetworkReachabilityFlagsIsWWAN) 
     { 
      // ... but WWAN connections are OK if the calling application 
      //  is using the CFNetwork (CFSocketStream?) APIs. 
      retVal = ReachableViaWWAN; 
     } 
     return retVal; 
    } 

    - (BOOL) connectionRequired; 
    { 
     NSAssert(reachabilityRef != NULL, @"connectionRequired called with NULL reachabilityRef"); 
     SCNetworkReachabilityFlags flags; 
     if (SCNetworkReachabilityGetFlags(reachabilityRef, &flags)) 
     { 
      return (flags & kSCNetworkReachabilityFlagsConnectionRequired); 
     } 
     return NO; 
    } 

    - (NetworkStatus) currentReachabilityStatus 
    { 
     NSAssert(reachabilityRef != NULL, @"currentNetworkStatus called with NULL reachabilityRef"); 
     NetworkStatus retVal = NotReachable; 
     SCNetworkReachabilityFlags flags; 
     if (SCNetworkReachabilityGetFlags(reachabilityRef, &flags)) 
     { 
      if(localWiFiRef) 
      { 
       retVal = [self localWiFiStatusForFlags: flags]; 
      } 
      else 
      { 
       retVal = [self networkStatusForFlags: flags]; 
      } 
     } 
     return retVal; 
    } 
    @end 


After That In Which Class You Want To Know STATUS .... 
.H 
@class Reachability 
Reachability* internetReachable; 
    Reachability* hostReachable; 
.m 
internetReachable =[Reachability reachabilityForInternetConnection]; 
NetworkStatus internetStatus = [internetReachable currentReachabilityStatus]; 
    switch (internetStatus) 
    { 
     case Not Reachable: 
     { 
       // No Internet Connection     
     } 
     default: 
     { // Internet Available    
     } 
    } 

Answer 2

注 - 我t的NSNotificationCenter你想引用 - 不只是NSNotification。