Changeset 893 for apps/iphone/superbook/trunk/ShareKit/Reachability/Reachability.m

Timestamp:

09/06/11 10:22:08 (22 months ago)

Author:

henri

Message:

Fixed issues related to adding ShareKit?

Location:

apps/iphone/superbook/trunk/ShareKit

Files:

• . (modified) (1 prop)
• Reachability/Reachability.m (modified) (5 diffs)

apps/iphone/superbook/trunk/ShareKit/Reachability/Reachability.m

@@ -4 +4 @@
  Abstract: Basic demonstration of how to use the SystemConfiguration Reachablity APIs.
  
- Version: 2.1
+ Version: 2.2
  
  Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple Inc.
@@ -44 +44 @@
  Copyright (C) 2010 Apple Inc. All Rights Reserved.
  
-*/
+ */
 
 #import <sys/socket.h>
@@ -57 +57 @@
 #import "Reachability.h"
 
-#define kShouldPrintReachabilityFlags 0
+#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
-                        );
+          (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
 }
@@ -83 +83 @@
 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];
+#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) startNotifier
 {
-        BOOL retVal = NO;
-        SCNetworkReachabilityContext    context = {0, self, NULL, NULL, NULL};
-        if(SCNetworkReachabilitySetCallback(reachabilityRef, ReachabilityCallback, &context))
-        {
-                if(SCNetworkReachabilityScheduleWithRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode))
-                {
-                        retVal = YES;
-                }
-        }
-        return retVal;
+    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) stopNotifier
 {
-        if(reachabilityRef!= NULL)
-        {
-                SCNetworkReachabilityUnscheduleFromRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
-        }
+    if(reachabilityRef!= NULL)
+    {
+        SCNetworkReachabilityUnscheduleFromRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
+    }
 }
 
 - (void) dealloc
 {
-        [self stopNotifier];
-        if(reachabilityRef!= NULL)
-        {
-                CFRelease(reachabilityRef);
-        }
-        [super dealloc];
+    [self stopNotifier];
+    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* 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;
+    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];
+    struct sockaddr_in zeroAddress;
+    bzero(&zeroAddress, sizeof(zeroAddress));
+    zeroAddress.sin_len = sizeof(zeroAddress);
+    zeroAddress.sin_family = AF_INET;
+    return [self reachabilityWithAddress: &zeroAddress];
 }
 
 + (Reachability*) reachabilityForLocalWiFi;
 {
-        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;
+    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;
 }
 
@@ -191 +191 @@
 - (NetworkStatus) localWiFiStatusForFlags: (SCNetworkReachabilityFlags) flags
 {
-        PrintReachabilityFlags(flags, "localWiFiStatusForFlags");
-
-        BOOL retVal = NotReachable;
-        if((flags & kSCNetworkReachabilityFlagsReachable) && (flags & kSCNetworkReachabilityFlagsIsDirect))
-        {
-                retVal = ReachableViaWiFi;      
-        }
-        return retVal;
+    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;
+    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;
+    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;
+    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