Проблема заключается в том, что и как это решить. Я пытаюсь подключиться к Интернету, чем я должен пойти для процесса 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;
        }
    }
}
1
Harish 26 Авг 2011 в 10:42

2 ответа

Лучший ответ
    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            
        }
    }   
2
Srinivas 26 Авг 2011 в 07:00

ПРИМЕЧАНИЕ. Это NSNotificationCenter, на который вы хотите ссылаться, а не только NSNotification.

0
user1686700 26 Сен 2013 в 13:50