Because CFNetwork is a procedural C library, it has no concept of selectors, methods, self, or any of the other dynamic runtime goodies that make Objective-C so much fun. As a result, CFNetwork calls do not use delegates to notify you when something has happened and cannot call methods. CFNetwork doesn't know about objects, so it can't use an objet as a delegate.

CFNetwork integrates with your application's run loop. We haven't worked with it directly, but every iPhone program has a main loop that's managed by UIApplication. The main loop keeps running until it receives some kind of input that tells it to quit. In that loop, the application looks for inputs, such as fingers touching the screen or the phone being rotated, and dispatches events through the responder chain based on those inputs. During the run loop, the application also makes any other calls that are necessary, such as calling application delegate methods at the appropriate times.

The application allows you to register certain objects with the run loop. Each time through the run loop, those objects will have a chance to perform tasks and call out to delegates, in the case of Objective-C, or to callback functions, in the case of Core Foundation libraries like CFNetwork. We're not going to delve into the actual process of creating objects that can be registered in the run loop, but it's important to know that CFNetwork and many of the higher-level objective-C networking classes register with the run loop to do their work. This allows them to listen for network connection attempts, for example, or to check if data has been received without needing to create threads or fork child processes.

Because CFNetwork is a procedural library, when you register any CFNetwork functionality with the run loop, it uses good old-fashioned C callbacks when it needs to notify you that something has happened. This means that each of our socket callbacks must take the form of a C function that won't know anything about our application's classes—it's just a chunk of code. We'll look at how to deal with that in a moment.

In order to listen for connections, we need to create a socket. A socket represents one end of a network connection, and we can leverage CFNetwork to create it. To do that, first we declare a CFSocketContext, which is a data structure specifically created for configuring a socket.

CFSocketContext socketCtxt = {0, self, NULL, NULL, NULL};

CFSocketRef socket = CFSocketCreate(kCFAllocatorDefault, PF_INET, SOCK_STREAM,
        IPPROTO_TCP, kCFSocketAcceptCallBack,
        (CFSocketCallBack)&listenerAcceptCallback, &socketCtxt);

if (socket == NULL) {
        if (error) *error = [[NSError alloc]
            initWithDomain:kMyApplicationErrorDomain
            code:kNoSocketsAvailableError
            userInfo:nil];
        return NO;
    }

Our next task is to specify a port for our socket to listen on. A port is a virtual, numbered data connection. Port numbers run from 0 to 65535, with port 0 reserved for system use. Since we'll be advertising our service with Bonjour, we don't want to hard-code a port number and risk a conflict with another running program. Instead, we'll specify port 0, which tells the socket to pick an available port and use it.

In the following example, we set the listen port to any available port, and then determine which port was used. First, we need to declare a struct of the type sockaddr_in, which is a data structure from the socket API used for configuring a socket. The socket APIs are very old and are from a time when the names of data structures were kept intentionally terse, so forgive the cryptic nature of this code.

struct sockaddr_in addr4;
    memset(&addr4, 0, sizeof(addr4));
    addr4.sin_len = sizeof(addr4);
    addr4.sin_family = AF_INET;
    addr4.sin_port = 0;
    addr4.sin_addr.s_addr = htonl(INADDR_ANY);

In order to pass this struct into a CFNetwork call, we need to turn it into an instance of NSData:

NSData *address4 = [NSData dataWithBytes:&addr4 length:sizeof(addr4)];

We can then use the Core Foundation function CFSocketSetAddress to tell the socket on which port it should listen. If CFSocketSetAddress fails, it will return a value other than kCFSocketSuccess, and we do appropriate error handling:

if (kCFSocketSuccess != CFSocketSetAddress(socket, (CFDataRef)address4)) {
    if (error) *error = [[NSError alloc]
        initWithDomain:kMyApplicationErrorDomain

code:kUnableToSetListenAddressErrorCode
            userInfo:nil];
    if (socket) CFRelease(socket);
    socket = NULL;
    return NO;
}

You might have noticed that we actually cast our NSData instance to CFDataRef. Foundation and Core Foundation have a very special relationship. Many of the Objective-C objects that we use from Foundation have counterparts in Core Foundation. Through a special process called toll-free bridging, many of those items can be used interchangeably, either as an Objective-C object or as a Core Foundation object. In the preceding code example, we're creating an instance of NSData and passing it into a CFNetwork function called CFSocketSetAddress(), which expects a pointer to a CFData object. When you see a Core Foundation datatype that ends in ref, that means it's a pointer to something. In this case, CFDataRef is a pointer to a CFData. Because CFData and NSData are toll-free bridged, it's okay to simply cast our NSData instance as a CFDataRef.

Finally, we need to copy the information back from the socket, because the socket will have updated the fields with the correct port and address that were actually used. We need to copy that data back into addr4 so we can determine which port number was used.

NSData *addr = [(NSData *)CFSocketCopyAddress(socket) autorelease];
    memcpy(&addr4, [addr bytes], [addr length]);
    uint16_t port = ntohs(addr4.sin_port);

The last thing we need to do is to register our socket with our run loop. This will allow the socket to poll the specified port for connection attempts, and then call our callback function when a connection is received. Here is how we do that:

CFRunLoopRef cfrl = CFRunLoopGetCurrent();
CFRunLoopSourceRef source4 = CFSocketCreateRunLoopSource(kCFAllocatorDefault,
        socket, 0);
CFRunLoopAddSource(cfrl, source4, kCFRunLoopCommonModes);
CFRelease(source4);

Once our socket is registered with the run loop, any time that we receive a connection from a remote machine, the function we specified when we created the socket will be called. In that function, we need to create a pair of stream objects that represent the connection to the other machine. One of those stream objects will be used to receive data from the other machine, and the other one will be used to send data to the other machine.

Here's how you create the stream pair that represents the connection to the other machine:

static void listenerAcceptCallback (CFSocketRef theSocket, CFSocketCallBackType
theType, CFDataRef theAddress, const void *data, void *info) {

    if (theType == kCFSocketAcceptCallBack) {
        CFSocketNativeHandle socketHandle = *(CFSocketNativeHandle *)data;
        uint8_t name[SOCK_MAXADDRLEN];
        socklen_t namelen = sizeof(name);
        NSData *peer = nil;
        if (getpeername(socketHandle, (struct sockaddr *)name, &namelen) == 0) {
            peer = [NSData dataWithBytes:name length:namelen];
        }
        CFReadStreamRef readStream = NULL;
        CFWriteStreamRef writeStream = NULL;
        CFStreamCreatePairWithSocket(kCFAllocatorDefault, socketHandle,
            &readStream, &writeStream);
        if (readStream && writeStream) {
            CFReadStreamSetProperty(readStream,
                kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);
            CFWriteStreamSetProperty(writeStream,
            kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);

            self.inStream = readStream;

self.outStream = writeStream;
        } else {
            close(socketHandle);
        }
        if (readStream) CFRelease(readStream);
        if (writeStream) CFRelease(writeStream);
    }
}

In this particular example, we're just storing a reference to the stream pair. We'll talk about how to use them a little later in the chapter.

To stop listening for new connections, we must invalidate and release the socket. We don't need to remove it from the run loop, because invalidating the socket takes care of that for us. Here's all we need to do when we're finished with our CFSocket:

if (socket) {
    CFSocketInvalidate(socket);
    CFRelease(socket);
    socket = NULL;
}

When you advertise a service on the network using Bonjour, it's called publishing the service. Published services will be available for other computers to discover and connect to. The process of discovering another published service on the network is called searching for services. When you find a service and wish to connect to it, you need to resolve the service to get information about the address and port on which the service is running or, alternatively, you can ask the resolved service for a connection in the form of streams.

To advertise an available service, you need to create an instance of a class called NSNetService. To do that, you provide four pieces of information:

Here's what allocating a new net service might look like:

NSNetService *svc = [[NSNetService alloc] initWithDomain:@""
    type:@"_myprogram._tcp."
    name:@""
    port:15000];

[svc scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
    [svc setDelegate:self];
    [svc publish];

[svc stop];

[svc publish];

-(void)netServiceWillPublish:(NSNetService *)netService;

- (void)netService:(NSNetService *)theNetService
        didNotPublish:(NSDictionary *)errorDict {
    NSNumber *errorDomain = [errorDict valueForKey:NSNetServicesErrorDomain];
    NSNumber *errorCode = [errorDict valueForKey:NSNetServicesErrorCode];
    NSLog(@"Unable to publish Bonjour service (Domain: %@, Error Code: %@)",
        errorDomain, errorCode);
    [theNetService stop];
}

- (void)netServiceDidStop:(NSNetService *)netService {
    netService.delegate = nil;
    self.netService = nil;
}

The process to discover published services on your local network is fairly similar to that of publishing a service. You first create an instance of NSNetServiceBrowser and set its delegate:

NSNetServiceBrowser *theBrowser = [[NSNetServiceBrowser alloc] init];
    theBrowser.delegate = self;

Then you call searchForServicesOfType:inDomain: to kick off the search. Unlike with NSNetService, you don't need to register a service browser with the run loop, though you do still need to specify a delegate; otherwise, you wouldn't ever find out about the other services. For the first argument, you pass the same Bonjour identifier that we discussed when we talked about publishing the domain. In the second argument, we follow Apple's recommendation and pass the empty string.

[theBrowser searchForServicesOfType:@"_myprogram._tcp" inDomain:@""];

When the browser completes its configuration and is ready to start looking for services, it will call the following method on its delegate:

- (void)netServiceBrowserWillSearch:(NSNetServiceBrowser *)browser

You do not need to implement this method, as there are no actions you must take at this point for the browser to find other services. It's just notifying you in case you want to update the status or take some action before it starts looking.

If the browser was unable to start a search for some reason, it will call the delegate method netServiceBrowser:didNotSearch: on its delegate. When this happens, you should stop the browser and do whatever error reporting is appropriate for your application. Here is a simple example:

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser
             didNotSearch:(NSDictionary *)errorDict {
    NSLog(@"Error browsing for service: %@", [errorDict
        objectForKey:NSNetServicesErrorCode]);
    [self.netServiceBrowser stop];
}

You should not release the browser at this point, even if you're finished with it. After you call the stop method here, or at any other time, it will trigger another delegate method call, which is where you should release the browser, like so:

- (void)netServiceBrowserDidStopSearch:(NSNetServiceBrowser *)browser {
    browser.delegate = nil;
    self.netServiceBrowser = nil;
}

When the browser finds a new service, it will call the delegate method netServiceBrowser:didFindService:moreComing:. The second argument the browser will pass to this method is an instance of NSNetService that can be resolved into an address or port, or turned into a stream pair, which you'll see how to do in a minute.

Typically, when notified about a new service, you add it to an array or other collection, so that you can let your user select from the available services. If the browser knows that there are more services coming, it will indicate this by passing YES for the last argument, which allows you to skip updating the user interface unnecessarily. The following is an example of what an implementation of this method might look like in a table view controller. Notice that we sort the data and reload the table only if there are no more services coming.

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser
           didFindService:(NSNetService *)aNetService
               moreComing:(BOOL)moreComing {
    if (![[self.publishedService name] isEqualToString:[aNetService name]])
        [discoveredServices addObject:aNetService];

    if (!moreComing) {
        [self.tableView reloadData];
        NSSortDescriptor *sd = [[NSSortDescriptor alloc] initWithKey:@"name"
            ascending:YES];

[discoveredServices sortUsingDescriptors:[NSArray arrayWithObject:sd]];
        [sd release];
    }
}

Another thing to notice here is that we're comparing browser's name to the name of another published service. This step is unnecessary if you haven't published a Bonjour service in your app. However, if you're both publishing and browsing, as we're going to do in our application, you typically don't want to display your own service to your users. If you've published one, it will be discovered by your browser, so you must manually exclude it from the list you show to the users.

Finally, if a service becomes unavailable, the browser will call another delegate method, which looks very similar to the last one, to let you know that one of the previously available services can no longer be found. Here's what that method might look like in a table view controller class:

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser
         didRemoveService:(NSNetService *)aNetService
               moreComing:(BOOL)moreComing {
    [discoveredServices removeObject:aNetService];

    if(!moreComing)
        [self.tableView reloadData];
}

If you want to connect to any of the discovered services, you do it by resolving the instance of NSNetService that was returned by the browser in the netServiceBrowser:didFindService:moreComing: method. To resolve it, all you need to do is call the method resolveWithTimeout:, specifying how long it should attempt to connect, or 0.0 to specify no timeout. If you were storing the discovered services in an array called discoveredServices, here is how you would resolve one of the services in that array:

NSNetService *selectedService = [discoveredServices objectAtIndex:selectedIndex];
    selectedService.delegate = self;
    [selectedService resolveWithTimeout:0.0];

Discovered services do not need to be registered with the run loop the way published ones do. Once you call resolveWithTimeout:, the service will then call delegate methods to tell you that the service was resolved, or to tell you that it couldn't be resolved.

If the service could not be resolved, for whatever reason, it will call the delegate method netService:didNotResolve:. At a minimum, you should stop the net service here. You should also do whatever error checking is appropriate to your application. Here's a simple implementation of this delegate method:

- (void)netService:(NSNetService *)sender didNotResolve:(NSDictionary *)errorDict {
    [sender stop];
    NSNumber *errorDomain = [errorDict valueForKey:NSNetServicesErrorDomain];
    NSNumber *errorCode = [errorDict valueForKey:NSNetServicesErrorCode];

NSLog(@"Unable to resolve Bonjour service (Domain: %@, Error Code: %@)",
        errorDomain, errorCode);
}

If the discovered service resolved successfully, then the delegate method netServiceDidResolveAddress: will be called. You can call the methods hostName and port on the service to find out its location and connect to it manually. An easier option is to ask the net service for a pair of streams already configured to connect to the remote service. Here's an example implementation of that delegate method. Note, however, that we don't do anything with the streams yet.

- (void)netServiceDidResolveAddress:(NSNetService *)service {

    NSInputStream *tempIn = nil;
    NSOutputStream *tempOut = nil;
    if (![service getInputStream:&tempIn outputStream:&tempOut]){
        NSLog(@"Could not start game with remote device",
            @"Could not start game with remote device") ];
        return;
    }
    // Open and use the streams
}

Why didn't we do anything with the streams? Because streams are complex enough to deserve their very own section, so we will now, very smoothly, segue into...

The first thing you need to do with any stream object is to open it. You can't use a stream that hasn't been opened.

Opening a stream tells it that you're ready to use it. Until it's open, a stream object really represents a potential rather than an actual stream. After you open a stream, you need to register it with your run loop, so that it can send and receive data without disrupting the flow of your application. And, as you've probably guessed, you need to set a delegate, so that the streams can notify you when things happen.

Here's what opening a pair of streams generally looks like:

[inStream scheduleInRunLoop:[NSRunLoop currentRunLoop]
        forMode:NSDefaultRunLoopMode];
    [outStream scheduleInRunLoop:[NSRunLoop currentRunLoop]
        forMode:NSDefaultRunLoopMode];

    inStream.delegate = self;
    outStream.delegate = self;

    if ([inStream streamStatus] == NSStreamStatusNotOpen)
        [inStream open];

    if ([outStream streamStatus] == NSStreamStatusNotOpen)
        [outStream open];

Just to be safe, we actually check the status of the stream and make sure it wasn't already opened elsewhere. With the streams retrieved from Bonjour or from a network listener, the streams won't be open, but we code defensively so we don't get burnt.

Streams have one delegate method—that's it, just one. But they call that one method whenever anything of interest happens on the streams. The delegate method is stream:handleEvent:, and it includes an event code that tells you what's going on with the stream. Let's look at the relevant event codes:

When notified, by receipt of an NSStreamEventHasBytesAvailable event, that there is data available on the stream, you can read the available data, or a portion of it, by calling read:maxLength: on the stream.

The first argument you need to pass is a buffer, or chunk of memory, into which the stream will copy the received data. The second parameter is the maximum number of bytes that your buffer can handle. This method will return the number of bytes actually read, or −1 if there was an error.

Here's an example of reading up to a kibibyte of data (yes, Virginia, there is such a thing as a kibibyte; check out this link to learn more: http://en.wikipedia.org/wiki/Kibibyte) from the stream:

uint8_t     buffer[1024];
NSInteger   bytesRead = [inStream read:buffer maxLength:1024];
if (bytesRead == −1) {
    NSError *error = [inStream streamError];
    NSLog(@"Error reading data: %@", [error localizedDescription]);
}

To send data to the connected device through the output stream, you call write:maxLength:, passing in a pointer to the data to send and the length of that data. Here's how you might send the contents of an NSData instance called dataToSend:

NSUInteger sendLength = [dataToSend length];
NSUInteger written = [outStream write:[dataToSend bytes] maxLength:sendLength];
if (written == −1) {
    NSError *error = [outStream streamError];
    NSLog(@"Error writing data: %@", [error localizedDescription]);
}

It's important at this point that you check written to make sure it matches sendLength. If it doesn't, that means only part of your data went through, and you need to resend the rest when you get another NSStreamEventHasBytesAvailable event from the stream.

We need the ability to convert multiple NSData instances into a single stream of bytes containing the length of the data and then the actual bytes. We also need a way to take a stream of bytes and reassemble those back into NSData instances. We're going to use categories to add this functionality to existing classes.

Because the stream won't necessarily be able to handle all the data we have to send, we're going to maintain a queue of all the data waiting to be sent in an NSArray. One of our categories will be on NSArray and will return a single NSData instance that holds a buffer of bytes representing everything in the array. We're also going to write a category on NSData to take a stream of bytes held in an instance of NSData and parse it back into the original objects. These categories will contain a single method each. Since they represent two sides of the same operation, we're going to place both categories in a single pair of files, just to minimize project clutter.

With your TicTacToe project open, single-click the Classes folder in the Groups & Files pane and press

Once the files have been created, single-click PacketCategories.h and replace the existing contents with the following:

#import <Foundation/Foundation.h>
#define kInvalidObjectException     @"Invalid Object Exception"

@interface NSArray(PacketSend)
-(NSData *)contentsForTransfer;
@end

@interface NSData(PacketSplit)
- (NSArray *)splitTransferredPackets:(NSData **)leftover;
@end

The one constant, kInvalidObjectException, will be used to throw an exception if our NSArray method is called on an array that contains objects other than instances of NSData. If we wanted to make this more robust, we might archive other objects into instances of NSData, throwing an exception only if the array contains an object that doesn't conform to NSCoding. For simplicity's sake and to be consistent with the approach used by GKSession, we're going to support just NSData instances in our application.

After that, we declare a category on NSArray that adds a single method called contentsForTransfer, which returns the entire contents of the array, ready to be sent through a stream to the other machine. The second category is on NSData. This method will reassemble all of the objects contained in a chunk of received data. In addition to returning an array with those objects, it also takes one argument called leftover. This pointer to a pointer will be used to return any incomplete objects. If an object is incomplete, the caller will need to wait for more bytes, append them to leftover, and then call this method again.

Switch over to PacketCategories.m and replace the existing contents with this:

#import "PacketCategories.h"

@implementation NSArray(PacketSend)
-(NSData *)contentsForTransfer {
    NSMutableData *ret = [NSMutableData data];
    for (NSData *oneData in self) {
        if (![oneData isKindOfClass:[NSData class]])
            [NSException raise:kInvalidObjectException format:
                @"arrayContentsForTransfer only supports instances of NSData"];

        uint64_t dataSize[1];
        dataSize[0] = [oneData length];
        [ret appendBytes:dataSize length:sizeof(uint64_t)];
        [ret appendBytes:[oneData bytes] length:[oneData length]];
    }
    return ret;
}
@end

@implementation NSData(PacketSplit)
- (NSArray *)splitTransferredPackets:(NSData **)leftover {

    NSMutableArray *ret = [NSMutableArray array];
    const unsigned char *beginning = [self bytes];
    const unsigned char *offset = [self bytes];
    NSInteger bytesEnd = (NSInteger)offset + [self length];

    while ((NSInteger)offset < bytesEnd) {
        uint64_t dataSize[1];
        NSInteger dataSizeStart = offset - beginning;
        NSInteger dataStart = dataSizeStart + sizeof(uint64_t);

        NSRange headerRange = NSMakeRange(dataSizeStart, sizeof(uint64_t));
        [self getBytes:dataSize range:headerRange];

        if ((dataStart + dataSize[0] + (NSInteger)offset) > bytesEnd) {
            NSInteger lengthOfRemainingData = [self length] - dataSizeStart;
            NSRange dataRange = NSMakeRange(dataSizeStart, lengthOfRemainingData);
            *leftover = [self subdataWithRange:dataRange];

            return ret;
        }

        NSRange dataRange = NSMakeRange(dataStart, dataSize[0]);
        NSData *parsedData = [self subdataWithRange:dataRange];

        [ret addObject:parsedData];
        offset = offset + dataSize[0] + sizeof(uint64_t);

}
    return ret;
}
@end

These two categories might appear a little intimidating because they're dealing with bytes, but they're really quite straightforward. The first just creates an instance of NSMutableData to hold the stream of bytes, and then iterates over the array. For each object, it first adds the length of the object as a 64-byte integer, and then appends the actual data bytes from the object. When it's finished iterating, it returns the mutable data that contains the formatted stream of bytes.

The second method might be a little more intimidating looking, but all it's doing is looping through the bytes of self, which will be an instance of NSData that holds data formatted by the previous method. It first reads a uint64_t, a 64-byte integer that should hold the length of the object that follows, and then reads that number of bytes into a new instance of NSData, which it adds to a mutable array that will be returned. It continues to do this until it reaches the end of the data. If it gets to the end of the data and has an incomplete object, it sends that object's data back to the calling method using that pointer to a pointer argument, leftover.

Now that we have a way to split up and recombine objects from the stream, let's write our OnlineSession object. Create a new file by selecting the Classes folder and pressing

Single-click OnlineSession.h and replace the current contents with this new version:

#import <Foundation/Foundation.h>
#define kOnlineSessionErrorDomain   @"Online Session Domain"
#define kFailedToSendDataErrorCode  1000
#define kDataReadErrorCode          1001

#define kBufferSize                 512

@class OnlineSession;
@protocol OnlineSessionDelegate
- (void)onlineSessionReadyForUse:(OnlineSession *)session;
@optional
- (void)onlineSession:(OnlineSession *)session
         receivedData:(NSData *)data;
- (void)onlineSession:(OnlineSession *)session
 encounteredReadError:(NSError *)error;
- (void)onlineSession:(OnlineSession *)session
encounteredWriteError:(NSError *)error;
- (void)onlineSessionDisconnected:(OnlineSession *)session;
@end

@interface OnlineSession : NSObject {
    id                          delegate;

NSInputStream               *inStream;
    NSOutputStream              *outStream;

    BOOL                        writeReady;
    BOOL                        readReady;

    NSMutableArray              *packetQueue;
    NSData                      *readLeftover;
    NSData                      *writeLeftover;
}
@property (nonatomic, assign) id<OnlineSessionDelegate> delegate;

- (id)initWithInputStream:(NSInputStream *)theInStream
             outputStream:(NSOutputStream *)theOutStream;
- (BOOL)sendData:(NSData *)data error:(NSError **)error;
- (BOOL)isReadyForUse;
@end

Let's take a look at what we're doing here. First, we define a few constants for an error domain for our session object, as well as some error codes to represent errors we might encounter:

#define kOnlineSessionErrorDomain   @"Online Session Domain"
#define kFailedToSendDataErrorCode  1000
#define kDataReadErrorCode          1001

After that, we define another constant that will set the size of our read buffer. Remember that when we read data from a stream, we need to create a buffer of a specific size, and then inform the stream of the maximum number of bytes we can accept in a single read operation. This constant will be used to allocate the memory and also will be passed in to the stream's read method as the maxLength parameter. Depending on the size of the data you need to transfer, you might want to tweak this value, but it's generally a good idea to read from the stream in small chunks. Apple typically recommends either 512 or 1024 per read. Since the data we send in our application is relatively small, we went with the smaller suggested value of 512.

#define kBufferSize                 512

Our session will have a delegate, and we will inform the delegate when certain things happen. We create a protocol to define the methods that our delegate can and must implement. Because we haven't yet declared our OnlineSession class (which will happen below the protocol), we use the @class keyword to tell the compiler that the class actually exists, even though the compiler hasn't seen it yet. The only required method is the one used to receive data from peers; however, we provide methods to inform the delegate of pretty much any stream event that the application might need to know about.

@class OnlineSession;
@protocol OnlineSessionDelegate
- (void)onlineSessionReadyForUse:(OnlineSession *)session;
@optional
- (void)onlineSession:(OnlineSession *)session
         receivedData:(NSData *)data;
- (void)onlineSession:(OnlineSession *)session
 encounteredReadError:(NSError *)error;

- (void)onlineSession:(OnlineSession *)session
encounteredWriteError:(NSError *)error;
- (void)onlineSessionDisconnected:(OnlineSession *)session;
@end

Next, we define the OnlineSession class and declare its instance variables:

@interface OnlineSession : NSObject {
    id                          delegate;

    NSInputStream               *inStream;
    NSOutputStream              *outStream;

    BOOL                        writeReady;
    BOOL                        readReady;

    NSMutableArray              *packetQueue;
    NSData                      *readLeftover;
    NSData                      *writeLeftover;

}

We have a delegate, a stream pair, a pair of BOOLs that will be used to keep track of whether the streams are ready to use, and then a mutable array to keep a queue of unsent data. When our write method is called, if the streams aren't ready or if there is no space available on the output stream, we'll queue up the data by adding it to the packetQueue array, and then send the queued data when we get a space available event from outStream. The last two instance variables are used to keep track of partial packets. Remember that we won't always be able to send an entire object, nor will we always receive objects in a single chunk, so we need a way to keep track of the leftover data.

The only one of our instance variables that ever needs to be changed by another class is delegate, so we declare a property for delegate. Unlike the underlying instance variable, we declare the property as id<OnlineSessionDelegate>, which means that we accept any object, but require it to conform to the OnlineSessionDelegate protocol that we defined earlier. If another object tries to assign a delegate that doesn't conform to that protocol, it will generate a compile-time warning, because we've declared the property this way.

@property (nonatomic, assign) id<OnlineSessionDelegate> delegate;

One really important thing to note here is that we use assign rather than retain for our delegate. This is a standard convention in Cocoa and Cocoa Touch. Generally speaking, objects should not retain their delegate unless there's a compelling reason to do so. As a result, your delegate properties should always be declared with the assign keyword.

Finally, we declare a whopping three instance methods in our header: an init method, a method to send data, and a method to determine if the session is ready for use.

- (id)initWithInputStream:(NSInputStream *)theInStream
             outputStream:(NSOutputStream *)theOutStream;
- (BOOL)sendData:(NSData *)data error:(NSError **)error;
- (BOOL)isReadyForUse;

Save your file.

Now, switch over to OnlineSession.m and replace the contents with the following:

#import "OnlineSession.h"
#import "PacketCategories.h"

@interface OnlineSession()
- (void)sendQueuedData;
@end

#pragma mark -
@implementation OnlineSession
@synthesize delegate;

#pragma mark -
- (id)initWithInputStream:(NSInputStream *)theInStream
             outputStream:(NSOutputStream *)theOutStream {
    if (self = [super init]) {

        inStream = [theInStream retain];
        outStream = [theOutStream retain];

        [inStream scheduleInRunLoop:[NSRunLoop currentRunLoop]
            forMode:NSDefaultRunLoopMode];
        [outStream scheduleInRunLoop:[NSRunLoop currentRunLoop]
            forMode:NSDefaultRunLoopMode];

        inStream.delegate = self;
        outStream.delegate = self;

        if ([inStream streamStatus] == NSStreamStatusNotOpen)
            [inStream open];

        if ([outStream streamStatus] == NSStreamStatusNotOpen)
            [outStream open];

        packetQueue = [[NSMutableArray alloc] init];
    }
    return self;
}

- (BOOL)sendData:(NSData *)data error:(NSError **)error {

    if (data == nil || [data length] == 0)
        return NO;

    [packetQueue addObject:data];

    if ([outStream hasSpaceAvailable])
        [self sendQueuedData];

    return YES;
}

- (BOOL)isReadyForUse {
    return readReady && writeReady;
}

- (void)dealloc {
    [inStream close];
    [inStream removeFromRunLoop:[NSRunLoop currentRunLoop]
        forMode:NSDefaultRunLoopMode];
    inStream.delegate = nil;
    [inStream release];

    [outStream close];
    [outStream removeFromRunLoop:[NSRunLoop currentRunLoop]
        forMode:NSDefaultRunLoopMode];
    outStream.delegate = nil;
    [outStream release];

    [packetqueue release];
    [writeLeftover release];
    [readLeftover release];

    [super dealloc];
}

- (void) stream:(NSStream *)stream
    handleEvent:(NSStreamEvent)eventCode {
    switch(eventCode) {
        case NSStreamEventOpenCompleted:
            if (stream == inStream)
                readReady = YES;
            else
                writeReady = YES;
            if ([self isReadyForUse] &&
                [delegate respondsToSelector:@selector(onlineSessionReadyForUse:)])
                [delegate onlineSessionReadyForUse:self];
            break;
         case NSStreamEventHasBytesAvailable:
            if (stream == inStream) {

                if ([inStream hasBytesAvailable]) {

                    NSMutableData *data = [NSMutableData data];

                    if (readLeftover != nil) {
                        [data appendData:readLeftover];
                        [readLeftover release];
                        readLeftover = nil;
                    }

                    NSInteger       bytesRead;
                    static uint8_t  buffer[kBufferSize];

                    bytesRead = [inStream read:buffer maxLength:kBufferSize];
                    if (bytesRead == −1 && [delegate respondsToSelector:
                        @selector(onlineSession:encounteredReadError:)]) {
                        NSError *error = [[NSError alloc]
                            initWithDomain:kOnlineSessionErrorDomain
                            code:kDataReadErrorCode userInfo:nil];
                        [delegate onlineSession:self encounteredReadError:error];
                        [error release];

return;
                    }
                    else if (bytesRead > 0) {
                        [data appendBytes:buffer length:bytesRead];

                        NSArray *dataPackets = [data splitTransferredPackets:
                            &readLeftover];

                        if (readLeftover)
                            [readLeftover retain];

                        for (NSData *onePacketData in dataPackets)
                            [delegate onlineSession:self
                                receivedData:onePacketData];
                    }
                }
            }
            break;
       case NSStreamEventErrorOccurred: {
            NSError *theError = [stream streamError];
            if (stream == inStream)
                if (delegate && [delegate respondsToSelector:
                    @selector(onlineSession:encounteredReadError:)])
                    [delegate onlineSession:self encounteredReadError:theError];
                else{
                    if (delegate && [delegate respondsToSelector:
                        @selector(onlineSession:encounteredWriteError:)])
                        [delegate onlineSession:self
                            encounteredWriteError:theError];
                }

            break;
        }
        case NSStreamEventHasSpaceAvailable:
            if (stream == outStream) {
                [self sendQueuedData];
            }
            break;
        case NSStreamEventEndEncountered:
            if (delegate && [delegate respondsToSelector:
                @selector(onlineSessionDisconnected:)])
                [delegate onlineSessionDisconnected:self];
                readReady = NO;
                writeReady = NO;
            break;
        default:
            break;
    }
}

- (void)sendQueuedData {

    if (writeLeftover == nil && [packetQueue count] == 0)
        return; // Nothing to send!

    NSMutableData *dataToSend = [NSMutableData data];

if (writeLeftover != nil) {
        [dataToSend appendData:writeLeftover];
        [writeLeftover release];
        writeLeftover = nil;
    }

    [dataToSend appendData:[packetQueue contentsForTransfer]];
    [packetQueue removeAllObjects];

    NSUInteger sendLength = [dataToSend length];
    NSUInteger written = [outStream write:[dataToSend bytes] maxLength:sendLength];

    if (written == −1) {
        if (delegate && [delegate respondsToSelector:
            @selector(onlineSession:encounteredWriteError:)])
            [delegate onlineSession:self encounteredWriteError:
                [outStream streamError]];
    }
    if (written != sendLength) {
        NSRange leftoverRange = NSMakeRange(written, [dataToSend length] - written);
        writeLeftover = [[dataToSend subdataWithRange:leftoverRange] retain];
    }
}

@end

This is a little gnarly looking, but we've already covered pretty much everything we do in this class. In the initWithInputStream:outputStream: method, we retain and keep a reference to the two streams, schedule them both with the run loop, and then open the streams if they aren't already open. We also create our mutable array to serve as our packet queue.

- (id)initWithInputStream:(NSInputStream *)theInStream
             outputStream:(NSOutputStream *)theOutStream {
    if (self = [super init]) {
        [theInStream retain];
        inStream = theInStream;

        [theOutStream retain];
        outStream = theOutStream;

        [inStream scheduleInRunLoop:[NSRunLoop currentRunLoop]
            forMode:NSDefaultRunLoopMode];
        [outStream scheduleInRunLoop:[NSRunLoop currentRunLoop]
            forMode:NSDefaultRunLoopMode];

        inStream.delegate = self;
        outStream.delegate = self;

        if ([inStream streamStatus] == NSStreamStatusNotOpen)
            [inStream open];

        if ([outStream streamStatus] == NSStreamStatusNotOpen)
            [outStream open];

        packetQueue = [[NSMutableArray alloc] init];
    }

return self;
}

In our sendData: method, we add the new object to the queue and, if there's space available, we call the method sendQueuedData, which will attempt to send as much of the queued data as the stream will take. If there is no space available on the stream, we don't do anything other than add the data to the queue. It will be sent when we are notified that there is space available on the stream.

- (BOOL)sendData:(NSData *)data error:(NSError **)error {

    if (data == nil || [data length] == 0)
        return NO;

    [packetQueue addObject:data];

    if ([outStream hasSpaceAvailable])
        [self sendQueuedData];

    return YES;
}

The isReadyForUse method just does a logical AND operation on the two BOOL instance variables that are used to track whether the two streams are available for use. It returns YES if both streams are ready; otherwise, it returns NO. You'll see where we set these values a little later in the chapter.

- (BOOL)isReadyForUse {
    return readReady && writeReady;
}

Our dealloc method is pretty standard. The only differences from the regular dealloc methods we're used to writing is that we need to close the streams, remove them from the run loop, and set their delegate to nil.

- (void)dealloc {
    [inStream close];
    [inStream removeFromRunLoop:[NSRunLoop currentRunLoop]
        forMode:NSDefaultRunLoopMode];
    inStream.delegate = nil;
    [inStream release];

    [outStream close];
    [outStream removeFromRunLoop:[NSRunLoop currentRunLoop]
        forMode:NSDefaultRunLoopMode];
    outStream.delegate = nil;
    [outStream release];

    [super dealloc];
}

The next method is a bit of a doozy. It's that stream delegate method we discussed earlier—the one that is called with different event codes. This is where most of the work happens in our OnlineSession class. Let's look at each of the event codes separately.

If we are notified that a stream has finished opening, we check which stream sent us the event and set the appropriate value to YES. After we do that, we check to see if both are YES and, if they are, we inform our delegate that the session is ready to use if the delegate has implemented that method.

case NSStreamEventOpenCompleted:
            if (stream == inStream)
                readReady = YES;
            else
                writeReady = YES;
            if ([self isReadyForUse] &&
                [delegate respondsToSelector:@selector(onlineSessionReadyForUse:)])
                [delegate onlineSessionReadyForUse:self];
            break;

If we are notified that there are bytes available on a stream, we first make sure we're getting this event from the input stream. In theory, we should never get this event from an output stream, but we code defensively just in case. We also create an instance of NSMutableData to hold the received data. If there is any leftover data, we combine the new data with the leftover data, which we will be stored in readLeftover, before processing it. This way, every time new data comes in, we have all the unprocessed data in one place.

case NSStreamEventHasBytesAvailable:
            if (stream == inStream) {

                if ([inStream hasBytesAvailable]) {

                    NSMutableData *data = [NSMutableData data];

                    if (readLeftover != nil) {
                        [data appendData:readLeftover];
                        [readLeftover release];
                        readLeftover = nil;
                    }

Now we read the data into a buffer. We check to make sure we didn't encounter an error and, if we did, we notify our delegate about the error.

NSInteger       bytesRead;
                    static uint8_t  buffer[kBufferSize];

                    bytesRead = [inStream read:buffer maxLength:kBufferSize];
                    if (bytesRead == −1 && [delegate respondsToSelector:
                        @selector(onlineSession:encounteredReadError:)]) {
                        NSError *error = [[NSError alloc]
                            initWithDomain:kOnlineSessionErrorDomain
                            code:kDataReadErrorCode userInfo:nil];
                        [delegate onlineSession:self encounteredReadError:error];
                        [error release];
                        return;
                    }

If there wasn't an error, we use the category method we created earlier to decode objects from the data we've received. If any objects were decoded, we inform our delegate. If there is any leftover data, we retain it so that it will be here the next time this event is called.

else if (bytesRead > 0) {
                        [data appendBytes:buffer length:bytesRead];

                        NSArray *dataPackets = [data splitTransferredPackets:
                            &readLeftover];

                        if (readLeftover)
                            [readLeftover retain];

                        for (NSData *onePacketData in dataPackets)
                            [delegate onlineSession:self
                                receivedData:onePacketData];
                    }
                }
            }
            break;

If we get an error event, all we do is pass it on to our delegate method.

case NSStreamEventErrorOccurred: {
            NSError *theError = [stream streamError];
            if (stream == inStream)
                if (delegate && [delegate respondsToSelector:
                    @selector(onlineSession:encounteredReadError:)])
                    [delegate onlineSession:self encounteredReadError:theError];
                else {
                    if (delegate && [delegate respondsToSelector:
                        @selector(onlineSession:encounteredWriteError:)])
                        [delegate onlineSession:self
                            encounteredWriteError:theError];
                }
            break;
        }

When the output stream tells us that there's space available, we call sendQueuedData to send any unsent data.

case NSStreamEventHasSpaceAvailable:
            if (stream == outStream) {
                [self sendQueuedData];
            }
            break;

Finally, if we are notified that the stream has been closed for any reason, we inform our delegate of the fact, and mark both streams as no longer ready for use. Because the streams act as a pair, we don't bother to check which one informed us—we just assume that if one is closed, both are closed.

case NSStreamEventEndEncountered:
            if (delegate && [delegate respondsToSelector:
                @selector(onlineSessionDisconnected:)])
                [delegate onlineSessionDisconnected:self];

readReady = NO;
                writeReady = NO;
            break;

We're almost finished with OnlineSession. We just need to look at the sendQueuedData method. First, if there's no leftover data and nothing queued, we return, because there's no reason to do anything else.

- (void)sendQueuedData {
    if (writeLeftover == nil && [packetQueue count] == 0)
        return; // Nothing to send!

We next create an instance of NSMutableData. We use that instance to combine the queued data with the leftover data into a single chunk, and then clear the queue.

NSMutableData *dataToSend = [NSMutableData data];

    if (writeLeftover!= nil) {
        [dataToSend appendData: writeLeftover];
        [writeLeftover release];
        writeLeftover = nil;
    }

    [dataToSend appendData:[packetQueue contentsForTransfer]];
    [packetQueue removeAllObjects];

Now that we have all the data that needs to be sent in a single instance of NSMutableData, we try to send it.

NSUInteger sendLength = [dataToSend length];
    NSUInteger written = [outStream write:[dataToSend bytes] maxLength:sendLength];

If we encountered a write error, we notify our delegate.

if (written == −1) {
        if (delegate && [delegate respondsToSelector:
            @selector(onlineSession:encounteredWriteError:)])
            [delegate onlineSession:self encounteredWriteError:
                [outStream streamError]];
    }

Then, if the amount sent is not equal to the length of the data we needed to send, we extract the part that didn't get sent and store it in writeLeftover, so we'll have it the next time we try to send queued data.

if (written != sendLength) {
        NSRange leftoverRange = NSMakeRange(written, [dataToSend length] - written);
         writeLeftover = [[dataToSend subdataWithRange:leftoverRange] retain];

    }
}

We're finished with OnlineSession.m. Make sure you save it.

As we discussed earlier in the chapter, we need to listen for network connections if we're going to advertise a service using Bonjour. Now, let's create a class to encapsulate listening for a network connection.

Create a new file using the same Objective-C class template we've used twice already in this chapter. Name the new file OnlineListener.m, and have it create OnlineListener.h for you as well.

Once the files are created, single-click OnlineListener.h and replace the current contents with the following:

#import <Foundation/Foundation.h>
#define kOnlineListenerErrorDomain @"Online Session Listener Session Domain"
#define kOnlineListenerErrorNoSocketsAvailable    1000
#define kOnlineListenerErrorCouldntBindToAddress  1001
#define kOnlineListenerErrorStreamError           1002

@class OnlineListener;
@protocol OnlineListenerDelegate
- (void) acceptedConnectionForListener:(OnlineListener *)theListener
                           inputStream:(NSInputStream *)theInputStream
                          outputStream:(NSOutputStream *)theOutputStream;
@optional
- (void) onlineListener:(OnlineListener *)theListener
       encounteredError:(NSError *)error;
@end

@interface OnlineListener : NSObject {
    id delegate;
    uint16_t port;
    CFSocketRef socket;
}
@property (nonatomic, assign) id<OnlineListenerDelegate> delegate;
@property uint16_t  port;

- (BOOL)startListening:(NSError **)error;
- (void)stopListening;

@end

Once again, we have constants for an error domain, a few error codes that we'll need, a formal protocol to define one method that this class's delegate must implement, and a second method that it can define if necessary. The required method will be called when a connection attempt is detected, and it will pass to the delegate the stream pair that was created. The optional method is called when a connection was attempted but failed.

We have three instance variables this time: a delegate, a port number, and a CFSocketRef, which is that CFNetwork socket object we discussed earlier in the chapter. We expose only the delegate and the port number as properties, because there's really no reason why external objects would need direct access to the socket. We're not using a specific port number, which means the object that creates the listener will need to retrieve the port number so it can pass it to Bonjour.

The class itself has only two methods: one to tell it to start listening and one to tell it to stop listening. Nice and simple.

Make sure you save OnlineListener.h before continuing.

Single-click OnlineListener.m and replace its contents with the following:

#import "OnlineListener.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <CFNetwork/CFSocketStream.h>

#pragma mark CFNetwork C Callbacks
static void onlineListenerAcceptCallback (CFSocketRef theSocket, CFSocketCallBackType theType, CFDataRef theAddress, const void *data, void *info) {
    OnlineListener *listener = (OnlineListener *)info;
    id listenerDelegate = listener.delegate;
    if (theType == kCFSocketAcceptCallBack) {
        CFSocketNativeHandle nativeSocket = *(CFSocketNativeHandle *)data;
        uint8_t name[SOCK_MAXADDRLEN];
        socklen_t namelen = sizeof(name);
        NSData *peer = nil;
        if (getpeername(nativeSocket, (struct sockaddr *)name, &namelen) == 0) {
            peer = [NSData dataWithBytes:name length:namelen];
        }
        CFReadStreamRef readStream = NULL;
        CFWriteStreamRef writeStream = NULL;
        CFStreamCreatePairWithSocket(kCFAllocatorDefault, nativeSocket, &readStream,
            &writeStream);
        if (readStream && writeStream) {
            CFReadStreamSetProperty(readStream,
                kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);
            CFWriteStreamSetProperty(writeStream,
                kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);
            if (listenerDelegate && [listenerDelegate respondsToSelector:
               @selector(acceptedConnectionForListener:inputStream:outputStream:)]){
               [listenerDelegate acceptedConnectionForListener:listener
                   inputStream:(NSInputStream *)readStream
                   outputStream:(NSOutputStream *)writeStream];
            }
        } else {
            close(nativeSocket);
            if ([listenerDelegate
                respondsToSelector:@selector(onlineListener:encounteredError:)]) {
                NSError *error = [[NSError alloc]
                    initWithDomain:kOnlineListenerErrorDomain
                    code:kOnlineListenerErrorStreamError userInfo:nil];
                [listenerDelegate onlineListener:listener encounteredError:error];
                [error release];
            }
        }
        if (readStream) CFRelease(readStream);
        if (writeStream) CFRelease(writeStream);
    }
}

#pragma mark -

@implementation OnlineListener
@synthesize delegate;
@synthesize port;
#pragma mark -
#pragma mark Listener Methods
- (BOOL)startListening:(NSError **)error {
    CFSocketContext socketCtxt = {0, self, NULL, NULL, NULL};
    socket = CFSocketCreate(kCFAllocatorDefault, PF_INET, SOCK_STREAM, IPPROTO_TCP, kCFSocketAcceptCallBack, (CFSocketCallBack)&onlineListenerAcceptCallback, &socketCtxt);

    if (socket == NULL) {
        if (error) *error = [[NSError alloc]
            initWithDomain:kOnlineListenerErrorDomain
            code:kOnlineListenerErrorNoSocketsAvailable
            userInfo:nil];
        return NO;
    }

    int ret = 1;
    setsockopt(CFSocketGetNative(socket), SOL_SOCKET, SO_REUSEADDR, (void *)&ret,
        sizeof(ret));

    struct sockaddr_in addr4;
    memset(&addr4, 0, sizeof(addr4));
    addr4.sin_len = sizeof(addr4);
    addr4.sin_family = AF_INET;
    addr4.sin_port = 0;
    addr4.sin_addr.s_addr = htonl(INADDR_ANY);
    NSData *address4 = [NSData dataWithBytes:&addr4 length:sizeof(addr4)];

    if (kCFSocketSuccess != CFSocketSetAddress(socket, (CFDataRef)address4)) {
        if (error) *error = [[NSError alloc]
            initWithDomain:kOnlineListenerErrorDomain
            code:kOnlineListenerErrorCouldntBindToAddress
            userInfo:nil];
        if (socket)
            CFRelease(socket);
        socket = NULL;
        return NO;
    }

    NSData *addr = [(NSData *)CFSocketCopyAddress(socket) autorelease];
    memcpy(&addr4, [addr bytes], [addr length]);
    self.port = ntohs(addr4.sin_port);

    CFRunLoopRef cfrl = CFRunLoopGetCurrent();
    CFRunLoopSourceRef source4 = CFSocketCreateRunLoopSource(kCFAllocatorDefault,
        socket, 0);
    CFRunLoopAddSource(cfrl, source4, kCFRunLoopCommonModes);
    CFRelease(source4);

    return ret;
}

- (void)stopListening {
    if (socket) {
        CFSocketInvalidate(socket);

CFRelease(socket);
        socket = NULL;
    }
}

- (void)dealloc {
    [self stopListening];
    [super dealloc];
}

@end

We begin by importing some header files you may not have seen before. The first three are part of the old-school socket API. We need to include these because we use some of the constants and functions they contain when we set up our listener. We also import a CFNetwork header file used to retrieve streams from a CFSocket.

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <CFNetwork/CFSocketStream.h>

Next, before our class implementation, we have a C function. This is our socket callback function that will be called whenever a connection attempt is detected.

static void onlineListenerAcceptCallback (CFSocketRef theSocket,
    CFSocketCallBackType theType, CFDataRef theAddress,
const void *data, void *info) {

Since this is a C function, it does not have access to Objective-C constructs such as self. So how do we access our delegate from within this function? When we created the socket, we created a socket context struct, and embedded a pointer to self in that struct. That embedded pointer is passed to this function as its last parameter, info. We'll cast that pointer to an instance of OnlineListener, which will give us access to the listener's delegate.

OnlineListener *listener = (OnlineListener *)info;
    id listenerDelegate = listener.delegate;

Next, we make sure that we got the right type of callback. Although we registered to receive only one type of callback, we still want to code defensively. Remember that CFWriteStreamRef is toll-free bridged to NSOutputStream, and CFReadStreamRef is toll-free bridged to NSInputStream, so once we've created the stream pair, we pass them to the listener's delegate.

if (theType == kCFSocketAcceptCallBack) {

Then we retrieve a stream pair that represents the connection that was made:

CFSocketNativeHandle nativeSocket = *(CFSocketNativeHandle *)data;
        uint8_t name[SOCK_MAXADDRLEN];
        socklen_t namelen = sizeof(name);
        NSData *peer = nil;
        if (getpeername(nativeSocket, (struct sockaddr *)name, &namelen) == 0) {
            peer = [NSData dataWithBytes:name length:namelen];
        }
        CFReadStreamRef readStream = NULL;

CFWriteStreamRef writeStream = NULL;
        CFStreamCreatePairWithSocket(kCFAllocatorDefault, nativeSocket, &readStream,
            &writeStream);
        if (readStream && writeStream) {
            CFReadStreamSetProperty(readStream,
                kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);
            CFWriteStreamSetProperty(writeStream,
                kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanTrue);
            if (listenerDelegate && [listenerDelegate respondsToSelector:
               @selector(acceptedConnectionForListener:inputStream:outputStream:)]){
               [listenerDelegate acceptedConnectionForListener:self
                   inputStream:inStream outputStream:outStream];
        } else {

If there was a problem, we close the socket and notify our delegate, assuming it has implemented the onlineListener:encounteredError: method.

close(nativeSocket);
            if ([listenerDelegate
                respondsToSelector:@selector(onlineListener:encounteredError:)]) {
                NSError *error = [[NSError alloc]
                    initWithDomain:kOnlineListenerErrorDomain
                    code:kOnlineListenerErrorStreamError userInfo:nil];
                [listenerDelegate onlineListener:listener encounteredError:error];
                [error release];
            }
        }

When we're finished, we release both of the streams. CFRelease acts like release in Objective-C. It doesn't deallocate the object, but just decrements the object's retain count. It will be the delegate's responsibility to retain the streams if it's going to continue using them.

if (readStream) CFRelease(readStream);
        if (writeStream) CFRelease(writeStream);
    }
}

The startListening: method goes through the process we described earlier to create and configure a socket, and register it with the run loop. If there's anything here that you're not comfortable with, go back and review the "Setting Up a Listener" section earlier in this chapter.

The next method is stopListening. All it needs to do is invalidate and release the socket.

- (void)stopListening {
    if (socket) {
        CFSocketInvalidate(socket);
        CFRelease(socket);
        socket = NULL;
    }
}

Since we're not using GameKit when the user selects online play, we must implement our own controller class to display the available peers and to let the user select one of them. Our current controller class, TicTacToeViewController, will present this new view controller's view modally, which will add just a touch of complexity to our application. The new view controller class will create and be the delegate for an instance of NSNetServiceBrowser, but when the user selects a peer, it's actually TicTacToeViewController that will need to be the delegate for the resolved service, because the resolution will happen after the modal view has been dismissed.

Creating the Peer Browser Files

Create another new class, and just to shake things up, let's choose a different file template this time. Select UIViewController subclass, and make sure the UITableViewController subclass check box is not selected, but that the With XIB for user interface box is checked (Figure 9-4). Call this new file OnlinePeerBrowser.m, and have it create OnlinePeerBrowser.h also.

Figure 9.4. When choosing the file template for creating the peer browser, you should select UIViewController subclass and also check the box labeled With XIB for user interface.

After it creates the file, you should drag OnlinePeerBrowser.xib to the Resources folder in the Groups & Files pane where it belongs.

#import <UIKit/UIKit.h>

@interface OnlinePeerBrowser : UIViewController
        <UITableViewDelegate, UITableViewDataSource> {

    UITableView         *tableView;
    NSNetServiceBrowser *netServiceBrowser;

    NSMutableArray      *discoveredServices;
}
@property (nonatomic, retain) IBOutlet UITableView *tableView;
@property (nonatomic, retain) NSNetServiceBrowser *netServiceBrowser;
@property (nonatomic, retain) NSMutableArray *discoveredServices;
- (IBAction)cancel;
@end

Building the Peer Browser Interface

Double-click OnlinePeerBrowser.xib to open Interface Builder. Once it opens, drag a Toolbar from the library to the window labeled View, and place it snugly against the bottom of the window. Double-click the toolbar's one button to edit the button's title, and change it to say Cancel. Press return to commit the title change.

The toolbar button should still be selected. Control-drag from the button to File's Owner, and select the cancel action to connect the button to that action method.

Next, drag a Table View from the library over to the window. As you move it over the View window, it should automatically resize itself to the space available above the toolbar. Drop the table onto the view so it takes up the remainder of the space. Press

Save the nib and quit Interface Builder.

#import "OnlinePeerBrowser.h"
#import "TicTacToeViewController.h"

@implementation OnlinePeerBrowser
@synthesize tableView;
@synthesize netServiceBrowser;
@synthesize discoveredServices;

#pragma mark -
#pragma mark Action Methods
- (IBAction)cancel {
    [self.netServiceBrowser stop];
    self.netServiceBrowser.delegate = nil;
    self.netServiceBrowser = nil;

    [(TicTacToeViewController *)self.parentViewController browserCancelled];
}

#pragma mark -
#pragma mark Superclass Overrides
- (void)viewDidLoad {
    NSNetServiceBrowser *theBrowser = [[NSNetServiceBrowser alloc] init];
    theBrowser.delegate = self;

    [theBrowser searchForServicesOfType:kBonjourType inDomain:@""];
    self.netServiceBrowser = theBrowser;
    [theBrowser release];

    self.discoveredServices = [NSMutableArray array];

}

- (void)viewDidUnload {
    self.tableView = nil;
}

- (void)dealloc {
    [tableView release];
    if (netServiceBrowser != nil) {
        [self.netServiceBrowser stop];
        self.netServiceBrowser.delegate = nil;
    }
    [netServiceBrowser release];
    [discoveredServices release];
    [super dealloc];
}

#pragma mark -
#pragma mark Table View Methods
- (NSInteger)tableView:(UITableView *)theTableView numberOfRowsInSection:(NSInteger)section {
    return [discoveredServices count];
}

- (NSString *)tableView:(UITableView *)theTableView titleForHeaderInSection:(NSInteger)section {
    return NSLocalizedString(@"Available Peers", @"Available Peers");
}

- (UITableViewCell *)tableView:(UITableView *)theTableView
        cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    static NSString *identifier = @"Browser Cell Identifier";

    UITableViewCell *cell = [tableView
        dequeueReusableCellWithIdentifier:identifier];
    if (cell == nil) {
        cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault
            reuseIdentifier:identifier] autorelease];
    }
    NSUInteger row = [indexPath row];
    cell.textLabel.text = [[discoveredServices objectAtIndex:row] name];
    return cell;
}

- (void)tableView:(UITableView *)theTableView
        didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    NSNetService *selectedService = [discoveredServices
       objectAtIndex:[indexPath row]];
    selectedService.delegate = self.parentViewController;
    [selectedService resolveWithTimeout:0.0];

    TicTacToeViewController *parent =
        (TicTacToeViewController *)self.parentViewController;
    parent.netService = selectedService;

    [self.netServiceBrowser stop];

    [self.parentViewController dismissModalViewControllerAnimated:YES];
}

#pragma mark -
#pragma mark Net Service Browser Delegate Methods
- (void)netServiceBrowserDidStopSearch:(NSNetServiceBrowser *)browser {
    self.netServiceBrowser.delegate = nil;
    self.netServiceBrowser = nil;
}

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser
             didNotSearch:(NSDictionary *)errorDict {
    NSLog(@"Error browsing for service: %@", [errorDict
        objectForKey:NSNetServicesErrorCode]);
    [self.netServiceBrowser stop];
}

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser
           didFindService:(NSNetService *)aNetService
               moreComing:(BOOL)moreComing {
    TicTacToeViewController *parent =
        (TicTacToeViewController *)self.parentViewController;
    if (![[parent.netService name] isEqualToString:[aNetService name]]){
        [discoveredServices addObject:aNetService];
        NSSortDescriptor *sd = [[NSSortDescriptor alloc]
            initWithKey:@"name" ascending:YES];
        [discoveredServices sortUsingDescriptors:[NSArray arrayWithObject:sd]];
        [sd release];
    }

    if(!moreComing)
        [self.tableView reloadData];
}

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser
         didRemoveService:(NSNetService *)aNetService
               moreComing:(BOOL)moreComing {
    [discoveredServices removeObject:aNetService];

    if(!moreComing)
        [self.tableView reloadData];
}

@end

- (IBAction)cancel {
    [self.netServiceBrowser stop];
    self.netServiceBrowser.delegate = nil;
    self.netServiceBrowser = nil;

    [(TicTacToeViewController *)self.parentViewController browserCancelled];
}

- (void)viewDidLoad {
    NSNetServiceBrowser *theBrowser = [[NSNetServiceBrowser alloc] init];
    theBrowser.delegate = self;

    [theBrowser searchForServicesOfType:kBonjourType inDomain:@""];
    self.netServiceBrowser = theBrowser;

[theBrowser release];

    self.discoveredServices = [NSMutableArray array];
}

- (NSInteger)tableView:(UITableView *)theTableView numberOfRowsInSection:(NSInteger)section {
    return [discoveredServices count];
}

- (NSString *)tableView:(UITableView *)theTableView titleForHeaderInSection:(NSInteger)section {
    return NSLocalizedString(@"Available Peers", @"Available Peers");
}

- (UITableViewCell *)tableView:(UITableView *)theTableView
        cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    static NSString *identifier = @"Browser Cell Identifier";

    UITableViewCell *cell = [tableView
        dequeueReusableCellWithIdentifier:identifier];
    if (cell == nil) {
        cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault
            reuseIdentifier:identifier] autorelease];
    }
    NSUInteger row = [indexPath row];
    cell.textLabel.text = [[discoveredServices objectAtIndex:row] name];
    return cell;
}

- (void)tableView:(UITableView *)theTableView
didSelectRowAtIndexPath:(NSIndexPath *)indexPath {

    NSNetService *selectedService = [discoveredServices
       objectAtIndex:[indexPath row]];

selectedService.delegate = self.parentViewController;
    [selectedService resolveWithTimeout:0.0];

    TicTacToeViewController *parent =
        (TicTacToeViewController *)self.parentViewController;
    parent.netService = selectedService;

    [self.netServiceBrowser stop];

    [self.parentViewController dismissModalViewControllerAnimated:YES];
}

- (void)netServiceBrowserDidStopSearch:(NSNetServiceBrowser *)browser {
    self.netServiceBrowser.delegate = nil;
    self.netServiceBrowser = nil;
}

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser
             didNotSearch:(NSDictionary *)errorDict {
    NSLog(@"Error browsing for service: %@", [errorDict
        objectForKey:NSNetServicesErrorCode]);
    [self.netServiceBrowser stop];
}

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser
           didFindService:(NSNetService *)aNetService
               moreComing:(BOOL)moreComing {
    TicTacToeViewController *parent =
        (TicTacToeViewController *)self.parentViewController;
    if (![[parent.netService name] isEqualToString:[aNetService name]]){
        [discoveredServices addObject:aNetService];
        NSSortDescriptor *sd = [[NSSortDescriptor alloc]
            initWithKey:@"name" ascending:YES];
        [discoveredServices sortUsingDescriptors:[NSArray arrayWithObject:sd]];
        [sd release];
    }

    if(!moreComing)
        [self.tableView reloadData];
}

- (void)netServiceBrowser:(NSNetServiceBrowser *)browser
         didRemoveService:(NSNetService *)aNetService
               moreComing:(BOOL)moreComing {
    [discoveredServices removeObject:aNetService];

    if(!moreComing)
        [self.tableView reloadData];
}

@end

Single-click TicTacToeViewController.h so we can make the changes necessary to support online play. Add the bold code shown here to your existing file.

#import <UIKit/UIKit.h>
#import <GameKit/GameKit.h>
#import "OnlineSession.h"
#import "OnlineListener.h"

#define kTicTacToeSessionID     @"com.apress.TicTacToe.session"
#define kTicTacToeArchiveKey    @"com.apress.TicTacToe"
#define kBonjourType            @"_tictactoe._tcp."

typedef enum GameStates {
    kGameStateBeginning,
    kGameStateRollingDice,
    kGameStateMyTurn,
    kGameStateOpponentTurn,
    kGameStateInterrupted,
    kGameStateDone
} GameState;

typedef enum BoardSpaces {
    kUpperLeft = 1000, kUpperMiddle, kUpperRight,
    kMiddleLeft, kMiddleMiddle, kMiddleRight,
    kLowerLeft, kLowerMiddle, kLowerRight
} BoardSpace;

typedef enum PlayerPieces {
    kPlayerPieceUndecided,
    kPlayerPieceO,
    kPlayerPieceX
} PlayerPiece;

@class TicTacToePacket;

@interface TicTacToeViewController : UIViewController
    <GKPeerPickerControllerDelegate, GKSessionDelegate, UIAlertViewDelegate
    , OnlineSessionDelegate, OnlineListenerDelegate>
 {
    UIButton    *newGameButton;
    UILabel     *feedbackLabel;

    GKSession   *session;
    NSString    *peerID;

    GameState   state;

    NSInteger   myDieRoll;
    NSInteger   opponentDieRoll;

    PlayerPiece piece;
    UIImage     *xPieceImage;
    UIImage     *oPieceImage;

    BOOL        dieRollReceived;
    BOOL        dieRollAcknowledged;

    // Online Play
    NSNetService     *netService;
    OnlineSession    *onlineSession;
    OnlineListener   *onlineSessionListener;

}
@property(nonatomic, retain) IBOutlet UIButton *newGameButton;
@property(nonatomic, retain) IBOutlet UILabel *feedbackLabel;

@property(nonatomic, retain) GKSession        *session;
@property(nonatomic, copy) NSString           *peerID;

@property GameState state;

@property(nonatomic, retain) UIImage *xPieceImage;
@property(nonatomic, retain) UIImage *oPieceImage;

@property (nonatomic, retain) NSNetService       *netService;
@property (nonatomic, retain) OnlineSession      *onlineSession;
@property (nonatomic, retain) OnlineListener     *onlineSessionListener;

- (IBAction)newGameButtonPressed;
- (IBAction)gameSpacePressed:(id)sender;
- (void)resetBoard;
- (void)startNewGame;
- (void)resetDieState;
- (void)sendPacket:(TicTacToePacket *)packet;
- (void)sendDieRoll;
- (void)checkForGameEnd;
- (void)handleReceivedData:(NSData *)data;
- (void)browserCancelled;
@end

Most of the new code is self-explanatory. We declared a constant that is a valid Bonjour type identifier for our game. That identifier is used both when we publish our service and when we search for other services. We also conform our class to the two protocols used by OnlineSession and OnlineListener for their delegates, and we add instance variables to hold an instance of those two classes. The former will be used to communicate with the other peer if we're in online play; the other will be used to listen for connections when we want to start a new game.

We also added two new methods. One is used by the OnlinePeerBrowser class and is called when the user presses the Cancel button. The other requires a little bit of explanation. In our original version of the app, we had a switch statement right in the data receive handler used by GameKit to inform us that there was received data. In order to avoid duplicating the logic that handles those received packets now that we have two potential sources of data, we're going to move the logic to its own method, which will then be called both from GameKit's data receive handler, as well as from the data receive handler for our online session object.

Save TicTacToeViewController.h.

Now, switch over to TicTacToeViewController.m. At the top of the file, add the bold code shown here.

#import "TicTacToeViewController.h"
#import "TicTacToePacket.h"
#import "OnlinePeerBrowser.h"

@interface TicTacToeViewController()
- (void)showErrorAlertWithTitle:(NSString *)title message:(NSString *)message;
@end

@implementation TicTacToeViewController
#pragma mark -
#pragma mark Synthesized Properties
@synthesize newGameButton;
@synthesize feedbackLabel;
@synthesize session;
@synthesize peerID;
@synthesize state;
@synthesize xPieceImage;
@synthesize oPieceImage;

@synthesize netService;
@synthesize onlineSession;
@synthesize onlineSessionListener;

#pragma mark -
#pragma mark Private Methods
- (void)showErrorAlertWithTitle:(NSString *)alertTitle message:(NSString *)message {
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:alertTitle
          message:message delegate:self
          cancelButtonTitle:NSLocalizedString(@"Bummer", @"Bummer")
          otherButtonTitles:nil];
    [alert show];

[alert release];
}

#pragma mark -
#pragma mark Game-Specific Methods
- (IBAction)newGameButtonPressed {
...

Because we're going to be creating instances of OnlinePeerBrowser, we need to import its header. We also use an Objective-C extension to declare a new private method for showing error alerts. In the previous version of our app, we showed alerts in only a handful of places. We'll add another handful to support errors encountered during online play, and that means we are now going to have that same task, which requires multiple lines of code, in many different places. By creating a method that displays an alert, we can replace several lines of code in multiple places in our class with a one-line call to this method.

Next, look for the existing method called newGameButtonPressed. We're still going to use the peer picker, but we need to tell it that we're also supporting online play. Add the following code to the newGameButtonPressed method to do that:

- (IBAction)newGameButtonPressed {

    dieRollReceived = NO;
    dieRollAcknowledged = NO;

    newGameButton.hidden = YES;
    GKPeerPickerController*    picker;

    picker = [[GKPeerPickerController alloc] init];
    picker.delegate = self;

    picker.connectionTypesMask = GKPeerPickerConnectionTypeOnline |
                                 GKPeerPickerConnectionTypeNearby;
    [picker show];
}

Scroll down now to just after the checkForGameEnd method but before the viewDidLoad method. We need to add those two new methods we declared in our header, and this is a good place to do it. Add the two new methods in bold after the existing checkForGameEnd method, like so:

if (state == kGameStateDone)
        [self performSelector:@selector(startNewGame) withObject:nil
        afterDelay:3.0];
}

- (void)handleReceivedData:(NSData *)data {

    NSKeyedUnarchiver *unarchiver = [[NSKeyedUnarchiver alloc]
        initForReadingWithData:data];
    TicTacToePacket *packet = [unarchiver decodeObjectForKey:kTicTacToeArchiveKey];

    switch (packet.type) {
        case kPacketTypeDieRoll:
            opponentDieRoll = packet.dieRoll;
            TicTacToePacket *ack = [[TicTacToePacket alloc]
                initAckPacketWithDieRoll:opponentDieRoll];
            [self sendPacket:ack];
            [ack release];
            dieRollReceived = YES;
            break;
        case kPacketTypeAck:
            if (packet.dieRoll != myDieRoll) {
                NSLog(@"Ack packet doesn't match opponentDieRoll (mine: %d, 

send: %d", packet.dieRoll, myDieRoll);
            }
            dieRollAcknowledged = YES;
            break;
        case kPacketTypeMove:{
            UIButton *theButton = (UIButton *)[self.view viewWithTag:packet.space];
            [theButton setImage:(piece == kPlayerPieceO) ? xPieceImage : oPieceImage
                forState:UIControlStateNormal];
            state = kGameStateMyTurn;
            feedbackLabel.text = NSLocalizedString(@"Your Turn", @"Your Turn");
            [self checkForGameEnd];
        }
            break;
        case kPacketTypeReset:
            if (state == kGameStateDone)
                [self resetDieState];
        default:
            break;
    }

    if (dieRollReceived == YES && dieRollAcknowledged == YES)
        [self startGame];
}

- (void)browserCancelled {
    [self dismissModalViewControllerAnimated:YES];
    newGameButton.hidden = NO;
    feedbackLabel.text = @"";
}
#pragma mark -
#pragma mark Superclass Overrides

- (void)viewDidLoad {
...

Now look for the existing method called sendPacket: and delete it. We're going to replace it with a new version that can send over either a GKSession instance or an OnlineSession instance. Because the new sendPacket: is no longer a GameKit-specific method, we should put this version above viewDidLoad. Insert this new version of sendPacket: above viewDidLoad, directly below the two methods you just added.

- (void) sendPacket:(TicTacToePacket *)packet {

    NSMutableData *data = [[NSMutableData alloc] init];
    NSKeyedArchiver *archiver = [[NSKeyedArchiver alloc]
        initForWritingWithMutableData:data];
    [archiver encodeObject:packet forKey:kTicTacToeArchiveKey];
    [archiver finishEncoding];

    NSError *error = nil;

    if (session) {
        if (![session sendDataToAllPeers:data withDataMode:GKSendDataReliable
            error:&error]) {
            // You will do real error handling
            NSLog(@"Error sending data: %@", [error localizedDescription]);
        }
    }else {
        if (![onlineSession sendData:data error:&error]) {
            // Ditto
            NSLog(@"Error sending data: %@", [error localizedDescription]);
        }
    }
    [archiver release];
    [data release];
}

The only real difference here is that we check to see if session, which is the GameKit session, is nil. If it's not nil, then we send data using it. If it is nil, we know we're in online play, and we must use onlineSession.

Scroll down some more. If you typed your code exactly the way it appeared in the previous chapter, you should have a #pragma line that identifies when the peer picker delegate methods start. It should look something like this:

#pragma mark -
#pragma mark GameKit Peer Picker Delegate Methods

Right after that, we need to add another method. If you don't have that #pragma line, then just search for the first method that takes an instance of GKPeerPickercontroller * as an argument, and add the new method before that method.

The peer picker has a delegate method called peerPickerController:didSelect ConnectionType:. We didn't need to implement this method in the previous chapter because we supported only one connection type. If, as we've now done, we tell the peer picker to offer online play, when users make their choice, it will call this delegate method to inform us about which option was selected. If Online was selected, we need to dismiss the peer picker and take over manually. If Nearby was selected, we don't need to do anything. Add the following new method to handle online play:

- (void)peerPickerController:(GKPeerPickerController *)picker
        didSelectConnectionType:(GKPeerPickerConnectionType)type {
    if (type == GKPeerPickerConnectionTypeOnline) {
        picker.delegate = nil;
        [picker dismiss];
        [picker autorelease];

        OnlineListener *theListener = [[OnlineListener alloc] init];
        self.onlineSessionListener = theListener;
        theListener.delegate = self;
        [theListener release];

        NSError *error;
        if (![onlineSessionListener startListening:&error]) {
            [self showErrorAlertWithTitle:NSLocalizedString(
                @"Error starting listener", @"Error starting listener")
                message:NSLocalizedString(
                @"Unable to start online play", @"Unable to start")];
        }

        NSNetService *theService = [[NSNetService alloc] initWithDomain:@""
            type:kBonjourType name:@"" port:onlineSessionListener.port];
        self.netService = theService;
        [theService release];

        [self.netService scheduleInRunLoop:[NSRunLoop currentRunLoop]
            forMode:NSRunLoopCommonModes];
        [self.netService setDelegate:self];
        [self.netService publish];


        OnlinePeerBrowser *controller = [[OnlinePeerBrowser alloc]
            initWithNibName:@"OnlinePeerBrowser" bundle:nil];
        [self presentModalViewController:controller animated:YES];
        [controller release];
    }
}

After we dismiss the peer picker, we create and start an instance of OnlineListener, which will start listening for connections. We then start advertising our listener using Bonjour. After we do that, we create an instance of OnlinePeerBrowser and present it modally so the user can choose who to play against online, if more than one peer is available.

Down a little further in the file, there should be a method called session:didFailWithError:. We can shorten that method by a few lines, courtesy of our snazzy new error alert method, like so:

- (void)session:(GKSession *)theSession didFailWithError:(NSError *)error {
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:
        NSLocalizedString(@"Error Connecting!", @"Error Connecting!")

message:NSLocalizedString(@"Unable to establish the connection.",
        @"Unable to establish the connection.")
        delegate:self
        cancelButtonTitle:NSLocalizedString(@"Bummer", @"Bummer")
        otherButtonTitles:nil];
    [alert show];
    [alert release];
    [self showErrorAlertWithTitle:NSLocalizedString(@"Peer Disconnected!",
        @"Peer Disconnected!") message:NSLocalizedString(
        @"Your opponent has disconnected, or the connection has been lost",
        @"Your opponent has disconnected, or the connection has been lost")];
    theSession.available = NO;
    [theSession disconnectFromAllPeers];
    theSession.delegate = nil;
    [theSession setDataReceiveHandler:nil withContext:nil];
    self.session = nil;
}

There are several other places in the existing code where you can make the same change. We're not going to show you every one, and it won't hurt anything to leave them as they are. But if you want to shorten your code, you can replace any of the existing code that shows an alert with a call to our new alert method.

Next, look for a method called receiveData:fromPeer:inSession:context:. It should be in with your other GameKit methods (you can just use the function pop-up to navigate to it). This method currently contains the logic to handle a packet received from the peer. Since we've moved this logic into handleReceivedData:, we can trim out the logic and replace it with a single call:

- (void)receiveData:(NSData *)data fromPeer:(NSString *)peer
    inSession: (GKSession *)theSession context:(void *)context {
    [self handleReceivedData:data];
}

Now, scroll down to the bottom of the file. We need to add a few delegate methods for NSNetService to handle resolving discovered services. We also need to add the delegate methods for OnlineSession and OnlineListener. We have a bunch of new methods to add. We're going to add a few methods at a time and then explain them, but all of the code from here until the end of the chapter should go at the end of the file, directly above the @end declaration.

First up are the delegate methods that are called when a net service failed to publish or when it is stopped. If the service couldn't publish, we throw up an error alert. When the service stops, we set its delegate to nil and release it.

#pragma mark -
#pragma mark Net Service Delegate Methods (Publishing)
- (void)netService:(NSNetService *)theNetService
     didNotPublish:(NSDictionary *)errorDict {
    NSNumber *errorDomain = [errorDict valueForKey:NSNetServicesErrorDomain];
    NSNumber *errorCode = [errorDict valueForKey:NSNetServicesErrorCode];
    [self showErrorAlertWithTitle:NSLocalizedString(@"Unable to connect",
        @"Unable to connect") message:[NSString
        stringWithFormat:NSLocalizedString(
        @"Unable to publish Bonjour service(%@/%@)",

@"Unable to publish Bonjour service(%@/%@)"), errorDomain, errorCode] ];

    [theNetService stop];
}

- (void)netServiceDidStop:(NSNetService *)netService {
    self.netService.delegate = nil;
    self.netService = nil;
}

Next up is an NSNetService delegate that is called whenever an error is encountered. This is called if an error is encountered either with publishing a service or resolving one. All we do is show an alert.

#pragma mark -
#pragma mark Net Service Delegate Methods (General)
- (void)handleError:(NSNumber *)error withService:(NSNetService *)service {
    [self showErrorAlertWithTitle:NSLocalizedString(@"A network error occurred.",
        @"A network error occurred.") message:[NSString stringWithFormat:
        NSLocalizedString(
        @"An error occurred with service %@.%@.%@, error code = %@",
        @"An error occurred with service %@.%@.%@, error code = %@"),
        [service name], [service type], [service domain], error]];
}

There are two delegate methods related to resolving discovered services: one is called if the service could not be resolved, and one is called if it resolves successfully. If it fails to resolve, we just show an alert and stop trying to resolve the service.

#pragma mark -
#pragma mark Net Service Delegate Methods (Resolving)
- (void)netService:(NSNetService *)sender didNotResolve:(NSDictionary *)errorDict {

    NSNumber *errorDomain = [errorDict valueForKey:NSNetServicesErrorDomain];
    NSNumber *errorCode = [errorDict valueForKey:NSNetServicesErrorCode];
    [self showErrorAlertWithTitle:NSLocalizedString(@"Unable to connect",
        @"Unable to connect") message:[NSString stringWithFormat:
        NSLocalizedString(@"Could not start game with remote device (%@/%@)",
        @"Could not start game with remote device (%@/%@)"), errorDomain,
        errorCode] ];
    [sender stop];
}

If it resolved successfully, then we stop listening for new connections and get the stream pair for the connection. If we're not able to get the stream pair, we show an error alert; otherwise, we create an OnlineSession object with the stream pair.

- (void)netServiceDidResolveAddress:(NSNetService *)service {

    [self.onlineSessionListener stopListening];
    self.onlineSessionListener = nil;

    NSInputStream *tempIn = nil;
    NSOutputStream *tempOut = nil;
    if (![service getInputStream:&tempIn outputStream:&tempOut]){
        [self showErrorAlertWithTitle:NSLocalizedString(@"Unable to connect",
            @"Unable to connect") message:NSLocalizedString(
            @"Could not start game with remote device",

@"Could not start game with remote device") ];
        return;
    }

    OnlineSession *theSession = [[OnlineSession alloc]
        initWithInputStream:tempIn outputStream:tempOut];
    theSession.delegate = self;
    self.onlineSession = theSession;
    [theSession release];
}

When an OnlineListener detects a connection, it notifies its delegate. In that case, we also create an OnlineSession object with the stream pair we got from the listener.

#pragma mark -
#pragma mark Online Session Listener Delegate Methods
- (void) acceptedConnectionForListener:(OnlineListener *)theListener
                           inputStream:(NSInputStream *)theInputStream
                          outputStream:(NSOutputStream *)theOutputStream {
    OnlineSession *theSession = [[OnlineSession alloc]
        initWithInputStream:theInputStream outputStream:theOutputStream];
    theSession.delegate = self;
    self.onlineSession = theSession;

    [theSession release];
}

Our OnlineSession object, regardless of whether it was created by resolving a service or by accepting a connection from another machine, will call onlineSessionReadyForUse: when both streams are open. In this method, we check to see if we're still presenting a modal view controller, which would be the case if we received a connection from another machine; if so, we dismiss it. Then we start a new game.

#pragma mark -
#pragma mark Online Session Delegate Methods
- (void)onlineSessionReadyForUse:(OnlineSession *)session {
    if (self.modalViewController)
        [self dismissModalViewControllerAnimated:YES];

    [self startNewGame];
}

When we receive data from the OnlineSession, all we need to do is pass that on to the handleReceivedData: method.

- (void)onlineSession:(OnlineSession *)session receivedData:(NSData *)data {
    [self handleReceivedData:data];
}

If any of the three OnlineSessionDelegate error methods are called, we throw up an error alert and kill the session.

- (void)onlineSession:(OnlineSession *)session
 encounteredReadError:(NSError *)error {
    [self showErrorAlertWithTitle:NSLocalizedString(@"Error reading",
        @"Error Reading") message:NSLocalizedString(@"Could not read sent packet",
        @"Could not read sent packet")];
    self.onlineSession = nil;

}
- (void)onlineSession:(OnlineSession *)session
    encounteredWriteError:(NSError *)error {
    [self showErrorAlertWithTitle:NSLocalizedString(@"Error Writing",
        @"Error Writing") message:NSLocalizedString(@"Could not send packet",
        @"Could not send packet")];
    self.onlineSession = nil;
}
- (void)onlineSessionDisconnected:(OnlineSession *)session {
    [self showErrorAlertWithTitle:NSLocalizedString(@"Peer Disconnected",
        @"Peer Disconnected") message:NSLocalizedString(
        @"Your opponent disconnected or otherwise could not be reached.",
        @"Your opponent disconnected or otherwise could not be reached")];
    self.onlineSession = nil;
}
@end