RSS

(root)/iphone/tappity : 55 : common/source/SocketMessenger.m

To get this branch, use:
bzr branch /browse/iphone/tappity

« back to all changes in this revision

Viewing changes to common/source/SocketMessenger.m

Dömötör Gulyás
2009-11-17 20:31:56
Revision ID: dognotdog@gmail.com-20091117193156-xtzpna81g3ga8pjd
fixes bug in sending thread condition wait; adds -isConnected method; messenger object now passed in dict for -dataReceived: so delegate can tell where the call is coming from

Show diffs side-by-side

added added

removed removed

common/source/SocketMessenger.m
49
49
 
50
50
NSString* SocketMessageIdKey    = @"SocketMessageId";
51
51
NSString* SocketMessageDataKey  = @"SocketMessageData";
 
52
NSString* SocketMessengerKey    = @"SocketMessenger";
52
53
 
53
 
const int kSocketMessengerTerminateMsg = -1;
 
54
//const int kSocketMessengerTerminateMsg = -1;
54
55
 
55
56
 
56
57
@interface SocketMessenger (Private)
77
78
        return self;
78
79
}
79
80
 
 
81
- (BOOL) isConnected
 
82
{
 
83
        return commsSocket != -1;
 
84
}
 
85
 
80
86
- (BOOL) threadActive: (id) key
81
87
{
82
88
        return [[activeThreads objectForKey: key] boolValue];
221
227
                                //NSLog(@"dataReceived (%d) #%d", (int) [currentData length], currentMessageId);
222
228
 
223
229
                                if (receiveDataOnMainThread)
224
 
                                        [delegate performSelectorOnMainThread: @selector(dataReceived:) withObject: [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt: currentMessageId], SocketMessageIdKey, currentData, SocketMessageDataKey, nil] waitUntilDone: NO];
 
230
                                        [delegate performSelectorOnMainThread: @selector(dataReceived:) withObject: [NSDictionary dictionaryWithObjectsAndKeys: self, SocketMessengerKey, [NSNumber numberWithInt: currentMessageId], SocketMessageIdKey, currentData, SocketMessageDataKey, nil] waitUntilDone: NO];
225
231
                                else
226
 
                                        [delegate dataReceived: [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt: currentMessageId], SocketMessageIdKey, currentData, SocketMessageDataKey, nil]];
 
232
                                        [delegate dataReceived: [NSDictionary dictionaryWithObjectsAndKeys: self, SocketMessengerKey, [NSNumber numberWithInt: currentMessageId], SocketMessageIdKey, currentData, SocketMessageDataKey, nil]];
227
233
 
228
234
                                currentData = nil;
229
235
                                currentlyRead = 0;
297
303
        while (txThreadShouldRun)
298
304
        {
299
305
                [sendLock lock];
300
 
                        while (![sendQueue count])
301
 
                                [sendLock wait];
 
306
                while (![sendQueue count] && txThreadShouldRun)
 
307
                        [sendLock wait];
302
308
                                
303
 
                //NSLog(@"sending");
304
 
                
305
 
                NSDictionary* dict = [[sendQueue objectAtIndex: 0] retain];
306
 
                NSData* data = [dict objectForKey: SocketMessageDataKey];
307
 
                uint32_t messageId = [[dict objectForKey: SocketMessageIdKey] intValue];
308
 
                [sendQueue removeObjectAtIndex: 0];
 
309
                NSDictionary* dict = nil;
 
310
                if ([sendQueue count])
 
311
                {
 
312
                        dict = [[sendQueue objectAtIndex: 0] retain];
 
313
                        [sendQueue removeObjectAtIndex: 0];
 
314
                }
309
315
                
310
316
                [sendLock unlock];
311
 
 
312
 
                size_t sizeToSend = 8;
313
 
                size_t dataSent = 0;
314
 
                uint32_t header[2] = {htonl(messageId), htonl([data length])};
315
 
                int err = 0;
316
 
                int socket = -1;
317
 
 
318
 
                @synchronized(self)
319
 
                {
320
 
                        socket = commsSocket;
321
 
                }
322
317
                
323
 
                //printf("sending %d bytes\n", (int) sizeToSend);
324
 
 
325
 
                while (dataSent < sizeToSend)
 
318
                if (dict)
326
319
                {
327
 
                        if ((err = send(socket, header + dataSent, sizeToSend - dataSent, 0)) == -1)
 
320
                        NSData* data = [dict objectForKey: SocketMessageDataKey];
 
321
                        uint32_t messageId = [[dict objectForKey: SocketMessageIdKey] intValue];
 
322
 
 
323
                        size_t sizeToSend = 8;
 
324
                        size_t dataSent = 0;
 
325
                        uint32_t header[2] = {htonl(messageId), htonl([data length])};
 
326
                        int err = 0;
 
327
                        int socket = -1;
 
328
 
 
329
                        @synchronized(self)
328
330
                        {
329
 
                                perror("send");
330
 
                                goto SEND_ERR;
 
331
                                socket = commsSocket;
331
332
                        }
332
 
                        else
333
 
                                dataSent += err;
334
 
                }
335
 
                
336
 
                if (err != -1)
337
 
                {
338
 
                        sizeToSend = [data length];
339
 
                        dataSent = 0;
 
333
                        
 
334
                        //printf("sending %d bytes\n", (int) sizeToSend);
 
335
 
340
336
                        while (dataSent < sizeToSend)
341
337
                        {
342
 
                                if ((err = send(socket, [data bytes] + dataSent, sizeToSend - dataSent, 0)) == -1)
 
338
                                if ((err = send(socket, header + dataSent, sizeToSend - dataSent, 0)) == -1)
343
339
                                {
344
340
                                        perror("send");
345
341
                                        goto SEND_ERR;
346
342
                                }
347
343
                                else
348
344
                                        dataSent += err;
349
 
                                        
350
 
                        }
 
345
                        }
 
346
                        
 
347
                        if (err != -1)
 
348
                        {
 
349
                                sizeToSend = [data length];
 
350
                                dataSent = 0;
 
351
                                while (dataSent < sizeToSend)
 
352
                                {
 
353
                                        if ((err = send(socket, [data bytes] + dataSent, sizeToSend - dataSent, 0)) == -1)
 
354
                                        {
 
355
                                                perror("send");
 
356
                                                goto SEND_ERR;
 
357
                                        }
 
358
                                        else
 
359
                                                dataSent += err;
 
360
                                                
 
361
                                }
 
362
                        }
 
363
                        
 
364
                        if (err == -1)
 
365
                                goto SEND_ERR;
 
366
 
 
367
                        [dict release];
351
368
                }
352
 
                
353
 
                if (err == -1)
354
 
                        goto SEND_ERR;
355
 
 
356
 
                [dict release];
357
369
                continue;
358
370
 
359
371
SEND_ERR:
736
748
        server.netService = [[NSNetService alloc] initWithDomain: domain type: protocol name: name port: server.portnum];
737
749
        if(server.netService == nil)
738
750
                return NO;
739
 
        
 
751
 
740
752
        [server.netService setDelegate: self];
741
753
//      [server.netService scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
742
754
        [server.netService publish];

Loggerhead 1.17 is a web-based interface for Bazaar branches