TappityServer.m (revision 46)

To get this branch, use:

bzr branch
/browse/iphone/tappity


//
//  TappityServer.m
//  Jigs
//
//  Created by döme on 25.10.2009.
//  Copyright 2009 __MyCompanyName__. All rights reserved.
//

#import "TappityServer.h"
#import "Tappity.h"


static void _setStandardSocketOpts(int socket)
{
    int yes = 1;
    setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (void *)&yes, sizeof(yes));
	int timeout = 2000;
	setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof(timeout));
	setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(timeout));
}

@interface UIApplication (TappityPrivate)
- (void)_playbackEvents:(id)arg1 atPlaybackRate:(float)arg2 messageWhenDone:(id)arg3 withSelector:(SEL)arg4;
@end

@implementation TappityServer

- (BOOL) threadActive: (id) key
{
	return [[activeThreads objectForKey: key] boolValue];
}

- (void) receivingThread: (id) info
{
	NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

	@synchronized(self)
	{
		[self retain];
	}

	while ([self threadActive: info])
	{
		struct timeval tv;
		fd_set readfds;
		fd_set writefds;
		fd_set errorfds;
		int maxSocket = -1;

		tv.tv_sec = 1;
		tv.tv_usec = 0;

		FD_ZERO(&readfds);
		FD_ZERO(&writefds);
		FD_ZERO(&errorfds);

		FD_SET(commsSocket, &readfds);
		FD_SET(commsSocket, &errorfds);
		maxSocket = MAX(maxSocket, commsSocket);
		
		if (maxSocket < 0)
		{
			//printf("No sockets, sleeping for a bit...\n");
			usleep(1000000);
			continue;
		}

		if (select(maxSocket+1, &readfds, &writefds, &errorfds, &tv) < 0)
		{
			perror("select");
			break;
		}

		if (FD_ISSET(commsSocket, &readfds))
		{
			NSLog(@"receiving...");
			if (!expectedMessageSize)
			{
				uint32_t buf = 0;
				int actuallyRead = 0;
			
				actuallyRead = recv(commsSocket, &buf, sizeof(uint32_t), MSG_PEEK);
				
				if (actuallyRead == sizeof(uint32_t))
				{
					actuallyRead = recv(commsSocket, &buf, sizeof(uint32_t), 0);
					expectedMessageSize = ntohl(buf);
					currentData = [[NSMutableData alloc] initWithLength: expectedMessageSize];
				}
				else if (!actuallyRead)
				{
					// close this socket as nothing read means connection closed
					close(commsSocket);
					self->commsSocket = 0;
					printf("Connection dropped.\n");
					break;
				}
				if (actuallyRead == -1)
				{
					close(commsSocket);
					self->commsSocket = 0;
					printf("Connection dropped with error.\n");
					break;
				}
			}
			else
			{
				size_t readAmount = expectedMessageSize - currentlyRead;
				int actuallyRead = 0;
			
				actuallyRead = recv(commsSocket, [currentData mutableBytes] + currentlyRead, readAmount, 0);
				if (actuallyRead == -1)
				{
					close(commsSocket);
					self->commsSocket = 0;
					printf("Connection dropped with error.\n");
					break;
				}
				currentlyRead += actuallyRead;
				
				if (currentlyRead == expectedMessageSize)
				{
					@synchronized(self)
					{
						expectedMessageSize = 0;
						/*
						if (!receivedPackets)
							receivedPackets = [[NSMutableArray alloc] init];
						[receivedPackets addObject: currentData];
						[currentData release];
						*/
						
					}
					[self performSelectorOnMainThread: @selector(tapReceived:) withObject: currentData waitUntilDone: NO];
					currentData = nil;
					currentlyRead = 0;
				}
			}

		}
	}

	@synchronized(self)
	{
		[self release];
	}

	[info release];
	[pool drain];
}


- (void) runThreadWithSelector: (SEL) selector
{
	@synchronized(self)
	{
		if (!activeThreads)
			activeThreads = [[NSMutableDictionary alloc] init];
		id number = [NSNumber numberWithInt: threadIds++];

		[activeThreads setObject: [NSNumber numberWithBool: YES] forKey: number];
		[NSThread detachNewThreadSelector: selector toTarget: self withObject: [number retain]];
	}
}

- (void) acceptThread: (id) info
{
	NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

	@synchronized(self)
	{
		[self retain];
	}

	while ([self threadActive: info])
	{

		struct timeval tv;
		fd_set readfds;
		fd_set writefds;
		fd_set errorfds;
		int maxSocket = -1;

		tv.tv_sec = 1;
		tv.tv_usec = 0;

		FD_ZERO(&readfds);
		FD_ZERO(&writefds);
		FD_ZERO(&errorfds);

		FD_SET(listenSocket, &readfds);
		FD_SET(listenSocket, &errorfds);
		maxSocket = MAX(maxSocket, listenSocket);
		
		if (maxSocket < 0)
		{
			printf("No sockets, sleeping for a bit...\n");
			usleep(1000000);
			continue;
		}
		
		//NSLog(@"listening for connection...");

		if (select(maxSocket+1, &readfds, &writefds, &errorfds, &tv) < 0)
		{
			perror("select");
			break;
		}

		if (FD_ISSET(listenSocket, &readfds))
		{
			NSLog(@"Accepting connection...");
			// accept
			socklen_t	sinSize = sizeof(struct sockaddr_in);
			struct sockaddr_in	peerAddress;
			int newSocket = accept(listenSocket, (struct sockaddr *)&peerAddress, &sinSize);
			
			_setStandardSocketOpts(newSocket);

			
			if (newSocket == -1)
			{
				if (errno == EWOULDBLOCK)
				{
				}
				else
				{
					printf("Error accepting connection.\n");
					break;
				}
			}
			
			if (commsSocket)
				close(commsSocket);

			// add socket to sockets list
			commsSocket = newSocket;
			
			
			[self runThreadWithSelector: @selector(receivingThread:)];
			
			NSLog(@"Accepted connection.");
		}

	}

	@synchronized(self)
	{
		[self release];
	}

	[info release];
	[pool drain];
}

- (BOOL) enableBonjourWithDomain:(NSString*)domain applicationProtocol:(NSString*)protocol name:(NSString*)name
{
	if(![domain length])
		domain = @""; //Will use default Bonjour registration doamins, typically just ".local"
	if(![name length])
		name = @""; //Will use default Bonjour name, e.g. the name assigned to the device in iTunes
	
	assert([protocol length] && listenSocket);
	
	NSLog(@"tappity port: %d", ntohs(myAddress.sin_port));

	netService = [[NSNetService alloc] initWithDomain: domain type: protocol name: name port: ntohs(myAddress.sin_port)];
	if(netService == nil)
		return NO;
	
	[netService setDelegate:self];
//	[netService scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
	[netService publish];
	
	return YES;
}

- (void) start
{
	NSLog(@"starting tappity server");
	myAddress.sin_family = AF_INET;					// host byte order
	myAddress.sin_port = htons(1234);				// short, network byte order, any port
	myAddress.sin_addr.s_addr = htonl(INADDR_ANY);	// auto-fill with my IP

	listenSocket = socket(PF_INET, SOCK_STREAM, 0);
	assert(listenSocket != -1);

	_setStandardSocketOpts(listenSocket);

	int err = bind(self->listenSocket, (struct sockaddr *)&myAddress, sizeof(myAddress));
	assert(-1 != err);
	
	err = listen(self->listenSocket, 1);
	assert(-1 != err);

	[self runThreadWithSelector: @selector(acceptThread:)];
	
	if([self enableBonjourWithDomain: @"" applicationProtocol: @"_tappity._tcp" name: @"tappity"])
		NSLog(@"tappity bounjour advertisments up and running");

}

static size_t _read_i8(const void* buf, uint8_t* p)
{
	uint8_t v = 0;
	memcpy(&v, buf, 1);
	*p = v;
	return 1;
}
static size_t _read_i16(const void* buf, uint16_t* p)
{
	uint16_t v = 0;
	memcpy(&v, buf, 2);
	*p = CFSwapInt16BigToHost(v);
	return 2;
}
static size_t _read_i32(const void* buf, uint32_t* p)
{
	uint32_t v = 0;
	memcpy(&v, buf, 4);
	*p = CFSwapInt32BigToHost(v);
	return 4;
}
static size_t _read_i64(const void* buf, uint64_t* p)
{
	uint64_t v = 0;
	memcpy(&v, buf, 8);
	*p = CFSwapInt64BigToHost(v);
	return 8;
}
static size_t _read_float(const void* buf, float* p)
{
	CFSwappedFloat32 v;
	memcpy(&v, buf, 4);
	*p = CFConvertFloat32SwappedToHost(v);
	return 4;
}

static size_t _read_gspoint(const void* buf, GSTouchPointRef p)
{
	size_t bc = 0;

	bc += _read_i32(buf+bc, &p->unk0);
	bc += _read_float(buf+bc, &p->unk1);
	bc += _read_float(buf+bc, &p->touchSize);
	bc += _read_float(buf+bc, &p->x);
	bc += _read_float(buf+bc, &p->y);
	bc += _read_i32(buf+bc, (uint32_t*)&p->window);
	
	return bc;
}

- (GSEvent*) gsEventWithData: (NSData*) data
{
	GSEvent* gse = [[[GSEvent alloc] init] autorelease];
	
	size_t bc = 0;
	const void* buf = [data bytes];
	
	bc += _read_i32(buf+bc, &gse->type0);
	bc += _read_i32(buf+bc, &gse->type1);
	bc += _read_i32(buf+bc, &gse->r3);
	bc += _read_float(buf+bc, &gse->avgX0);
	bc += _read_float(buf+bc, &gse->avgY0);
	bc += _read_float(buf+bc, &gse->avgX1);
	bc += _read_float(buf+bc, &gse->avgY1);
	bc += _read_i32(buf+bc, &gse->processId);
	bc += _read_i64(buf+bc, &gse->timestamp);
	bc += _read_i32(buf+bc, (uint32_t*)&gse->window);
	bc += _read_i32(buf+bc, &gse->r11);
	bc += _read_i32(buf+bc, &gse->type12);
	bc += _read_i32(buf+bc, &gse->gesture13);
	bc += _read_i32(buf+bc, &gse->gesture14);
	bc += _read_i16(buf+bc, &gse->numInitialTouches);
	bc += _read_i16(buf+bc, &gse->numCurrentTouches);
	bc += _read_i32(buf+bc, &gse->r16);
	bc += _read_i32(buf+bc, &gse->r17);
	bc += _read_i32(buf+bc, &gse->r18);
	bc += _read_i32(buf+bc, &gse->r19);
	bc += _read_i32(buf+bc, &gse->r20);
	bc += _read_i32(buf+bc, &gse->r21);
	bc += _read_i8(buf+bc, &gse->r22_0);
	bc += _read_i8(buf+bc, &gse->numPoints);
	bc += _read_i16(buf+bc, &gse->r22_2);
	for (size_t i = 0; i < gse->numPoints; ++i)
		bc += _read_gspoint(buf+bc, gse->points + i);

	return gse;
}

- (void) tapReceived: (NSData*) tapData
{
	assert([tapData length] > 4);
	
	
	NSDictionary* tapDict = [NSPropertyListSerialization propertyListFromData: tapData mutabilityOption:NSPropertyListImmutable format: NULL errorDescription: NULL];
	assert(tapDict);
	switch([[tapDict objectForKey: TapIdKey] intValue])
	{
		case kTapTouchEvent:
		{
			NSLog(@"TOUCH EVENT");
			
			GSEvent* gse = [self gsEventWithData: [tapDict objectForKey: TapGSEventKey]];
			UIWindow* window = [[UIApplication sharedApplication] keyWindow];
			gse->window = window;
			for (size_t i = 0; i < gse->numPoints; ++i)
				gse->points[i].window = window;
			
			int phase = [[tapDict objectForKey: TapTouchPhaseKey] intValue];
			NSSet* touches = [UITouch _createTouchesWithGSEvent: gse phase: phase view: [[UIApplication sharedApplication] keyWindow]];
			
			assert([[UIApplication sharedApplication] keyWindow]);
			
			NSLog(@"%@", touches);

			UIEvent* event = [UIEvent alloc];
			
			Class touchesEventClass = objc_getClass("UITouchesEvent");
			if (touchesEventClass && ![[event class] isEqual: touchesEventClass])
			{
				event = [touchesEventClass alloc];
			}
			
			[event _initWithEvent: gse touches: touches];
			
			assert(event);
			
			[[UIApplication sharedApplication] sendEvent: event];
						
			
			break;
		}
		case kTapRecordedEvent:
		{
			NSLog(@"RECORDED EVENT");
			
			NSDictionary* eventDict = [tapDict objectForKey: TapRecordedEventKey];
			
			[[UIApplication sharedApplication] _playbackEvents:[NSArray arrayWithObject: eventDict] atPlaybackRate: 1.0f messageWhenDone: nil withSelector: nil];

			break;
		}
	}
	
}


/*
- (void)performTouches: (NSSet*) touches inView: (UIView *)view
{
    UITouch *touch = [[UITouch alloc] initInView:view];
    UIEvent *eventDown = [[UIEvent alloc] initWithTouch:touch];
    
    [touch.view touchesBegan:[eventDown allTouches] withEvent:eventDown];
    
    [touch setPhase:UITouchPhaseEnded];
    UIEvent *eventUp = [[UIEvent alloc] initWithTouch:touch];
    
    [touch.view touchesEnded:[eventUp allTouches] withEvent:eventUp];
    
    [eventDown release];
    [eventUp release];
    [touch release];
}
*/

- (void) dealloc
{
	
	[netService stop];
	[netService release];

	[activeThreads release];

	[super dealloc];
}

@end

Loggerhead 1.17 is a web-based interface for Bazaar branches

Line	Revision	Contents
1	46	//
2		// TappityServer.m
3		// Jigs
4		//
5		// Created by döme on 25.10.2009.
6		// Copyright 2009 __MyCompanyName__. All rights reserved.
7		//
8
9		#import "TappityServer.h"
10		#import "Tappity.h"
11
12
13		static void _setStandardSocketOpts(int socket)
14		{
15		int yes = 1;
16		setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (void *)&yes, sizeof(yes));
17		int timeout = 2000;
18		setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof(timeout));
19		setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(timeout));
20		}
21
22		@interface UIApplication (TappityPrivate)
23		- (void)_playbackEvents:(id)arg1 atPlaybackRate:(float)arg2 messageWhenDone:(id)arg3 withSelector:(SEL)arg4;
24		@end
25
26		@implementation TappityServer
27
28		- (BOOL) threadActive: (id) key
29		{
30		return [[activeThreads objectForKey: key] boolValue];
31		}
32
33		- (void) receivingThread: (id) info
34		{
35		NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
36
37		@synchronized(self)
38		{
39		[self retain];
40		}
41
42		while ([self threadActive: info])
43		{
44		struct timeval tv;
45		fd_set readfds;
46		fd_set writefds;
47		fd_set errorfds;
48		int maxSocket = -1;
49
50		tv.tv_sec = 1;
51		tv.tv_usec = 0;
52
53		FD_ZERO(&readfds);
54		FD_ZERO(&writefds);
55		FD_ZERO(&errorfds);
56
57		FD_SET(commsSocket, &readfds);
58		FD_SET(commsSocket, &errorfds);
59		maxSocket = MAX(maxSocket, commsSocket);
60
61		if (maxSocket < 0)
62		{
63		//printf("No sockets, sleeping for a bit...\n");
64		usleep(1000000);
65		continue;
66		}
67
68		if (select(maxSocket+1, &readfds, &writefds, &errorfds, &tv) < 0)
69		{
70		perror("select");
71		break;
72		}
73
74		if (FD_ISSET(commsSocket, &readfds))
75		{
76		NSLog(@"receiving...");
77		if (!expectedMessageSize)
78		{
79		uint32_t buf = 0;
80		int actuallyRead = 0;
81
82		actuallyRead = recv(commsSocket, &buf, sizeof(uint32_t), MSG_PEEK);
83
84		if (actuallyRead == sizeof(uint32_t))
85		{
86		actuallyRead = recv(commsSocket, &buf, sizeof(uint32_t), 0);
87		expectedMessageSize = ntohl(buf);
88		currentData = [[NSMutableData alloc] initWithLength: expectedMessageSize];
89		}
90		else if (!actuallyRead)
91		{
92		// close this socket as nothing read means connection closed
93		close(commsSocket);
94		self->commsSocket = 0;
95		printf("Connection dropped.\n");
96		break;
97		}
98		if (actuallyRead == -1)
99		{
100		close(commsSocket);
101		self->commsSocket = 0;
102		printf("Connection dropped with error.\n");
103		break;
104		}
105		}
106		else
107		{
108		size_t readAmount = expectedMessageSize - currentlyRead;
109		int actuallyRead = 0;
110
111		actuallyRead = recv(commsSocket, [currentData mutableBytes] + currentlyRead, readAmount, 0);
112		if (actuallyRead == -1)
113		{
114		close(commsSocket);
115		self->commsSocket = 0;
116		printf("Connection dropped with error.\n");
117		break;
118		}
119		currentlyRead += actuallyRead;
120
121		if (currentlyRead == expectedMessageSize)
122		{
123		@synchronized(self)
124		{
125		expectedMessageSize = 0;
126		/*
127		if (!receivedPackets)
128		receivedPackets = [[NSMutableArray alloc] init];
129		[receivedPackets addObject: currentData];
130		[currentData release];
131		*/
132
133		}
134		[self performSelectorOnMainThread: @selector(tapReceived:) withObject: currentData waitUntilDone: NO];
135		currentData = nil;
136		currentlyRead = 0;
137		}
138		}
139
140		}
141		}
142
143		@synchronized(self)
144		{
145		[self release];
146		}
147
148		[info release];
149		[pool drain];
150		}
151
152
153		- (void) runThreadWithSelector: (SEL) selector
154		{
155		@synchronized(self)
156		{
157		if (!activeThreads)
158		activeThreads = [[NSMutableDictionary alloc] init];
159		id number = [NSNumber numberWithInt: threadIds++];
160
161		[activeThreads setObject: [NSNumber numberWithBool: YES] forKey: number];
162		[NSThread detachNewThreadSelector: selector toTarget: self withObject: [number retain]];
163		}
164		}
165
166		- (void) acceptThread: (id) info
167		{
168		NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
169
170		@synchronized(self)
171		{
172		[self retain];
173		}
174
175		while ([self threadActive: info])
176		{
177
178		struct timeval tv;
179		fd_set readfds;
180		fd_set writefds;
181		fd_set errorfds;
182		int maxSocket = -1;
183
184		tv.tv_sec = 1;
185		tv.tv_usec = 0;
186
187		FD_ZERO(&readfds);
188		FD_ZERO(&writefds);
189		FD_ZERO(&errorfds);
190
191		FD_SET(listenSocket, &readfds);
192		FD_SET(listenSocket, &errorfds);
193		maxSocket = MAX(maxSocket, listenSocket);
194
195		if (maxSocket < 0)
196		{
197		printf("No sockets, sleeping for a bit...\n");
198		usleep(1000000);
199		continue;
200		}
201
202		//NSLog(@"listening for connection...");
203
204		if (select(maxSocket+1, &readfds, &writefds, &errorfds, &tv) < 0)
205		{
206		perror("select");
207		break;
208		}
209
210		if (FD_ISSET(listenSocket, &readfds))
211		{
212		NSLog(@"Accepting connection...");
213		// accept
214		socklen_t sinSize = sizeof(struct sockaddr_in);
215		struct sockaddr_in peerAddress;
216		int newSocket = accept(listenSocket, (struct sockaddr *)&peerAddress, &sinSize);
217
218		_setStandardSocketOpts(newSocket);
219
220
221		if (newSocket == -1)
222		{
223		if (errno == EWOULDBLOCK)
224		{
225		}
226		else
227		{
228		printf("Error accepting connection.\n");
229		break;
230		}
231		}
232
233		if (commsSocket)
234		close(commsSocket);
235
236		// add socket to sockets list
237		commsSocket = newSocket;
238
239
240		[self runThreadWithSelector: @selector(receivingThread:)];
241
242		NSLog(@"Accepted connection.");
243		}
244
245		}
246
247		@synchronized(self)
248		{
249		[self release];
250		}
251
252		[info release];
253		[pool drain];
254		}
255
256		- (BOOL) enableBonjourWithDomain:(NSString)domain applicationProtocol:(NSString)protocol name:(NSString*)name
257		{
258		if(![domain length])
259		domain = @""; //Will use default Bonjour registration doamins, typically just ".local"
260		if(![name length])
261		name = @""; //Will use default Bonjour name, e.g. the name assigned to the device in iTunes
262
263		assert([protocol length] && listenSocket);
264
265		NSLog(@"tappity port: %d", ntohs(myAddress.sin_port));
266
267		netService = [[NSNetService alloc] initWithDomain: domain type: protocol name: name port: ntohs(myAddress.sin_port)];
268		if(netService == nil)
269		return NO;
270
271		[netService setDelegate:self];
272		// [netService scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
273		[netService publish];
274
275		return YES;
276		}
277
278		- (void) start
279		{
280		NSLog(@"starting tappity server");
281		myAddress.sin_family = AF_INET; // host byte order
282		myAddress.sin_port = htons(1234); // short, network byte order, any port
283		myAddress.sin_addr.s_addr = htonl(INADDR_ANY); // auto-fill with my IP
284
285		listenSocket = socket(PF_INET, SOCK_STREAM, 0);
286		assert(listenSocket != -1);
287
288		_setStandardSocketOpts(listenSocket);
289
290		int err = bind(self->listenSocket, (struct sockaddr *)&myAddress, sizeof(myAddress));
291		assert(-1 != err);
292
293		err = listen(self->listenSocket, 1);
294		assert(-1 != err);
295
296		[self runThreadWithSelector: @selector(acceptThread:)];
297
298		if([self enableBonjourWithDomain: @"" applicationProtocol: @"_tappity._tcp" name: @"tappity"])
299		NSLog(@"tappity bounjour advertisments up and running");
300
301		}
302
303		static size_t _read_i8(const void* buf, uint8_t* p)
304		{
305		uint8_t v = 0;
306		memcpy(&v, buf, 1);
307		*p = v;
308		return 1;
309		}
310		static size_t _read_i16(const void* buf, uint16_t* p)
311		{
312		uint16_t v = 0;
313		memcpy(&v, buf, 2);
314		*p = CFSwapInt16BigToHost(v);
315		return 2;
316		}
317		static size_t _read_i32(const void* buf, uint32_t* p)
318		{
319		uint32_t v = 0;
320		memcpy(&v, buf, 4);
321		*p = CFSwapInt32BigToHost(v);
322		return 4;
323		}
324		static size_t _read_i64(const void* buf, uint64_t* p)
325		{
326		uint64_t v = 0;
327		memcpy(&v, buf, 8);
328		*p = CFSwapInt64BigToHost(v);
329		return 8;
330		}
331		static size_t _read_float(const void* buf, float* p)
332		{
333		CFSwappedFloat32 v;
334		memcpy(&v, buf, 4);
335		*p = CFConvertFloat32SwappedToHost(v);
336		return 4;
337		}
338
339		static size_t _read_gspoint(const void* buf, GSTouchPointRef p)
340		{
341		size_t bc = 0;
342
343		bc += _read_i32(buf+bc, &p->unk0);
344		bc += _read_float(buf+bc, &p->unk1);
345		bc += _read_float(buf+bc, &p->touchSize);
346		bc += _read_float(buf+bc, &p->x);
347		bc += _read_float(buf+bc, &p->y);
348		bc += _read_i32(buf+bc, (uint32_t*)&p->window);
349
350		return bc;
351		}
352
353		- (GSEvent) gsEventWithData: (NSData) data
354		{
355		GSEvent* gse = [[[GSEvent alloc] init] autorelease];
356
357		size_t bc = 0;
358		const void* buf = [data bytes];
359
360		bc += _read_i32(buf+bc, &gse->type0);
361		bc += _read_i32(buf+bc, &gse->type1);
362		bc += _read_i32(buf+bc, &gse->r3);
363		bc += _read_float(buf+bc, &gse->avgX0);
364		bc += _read_float(buf+bc, &gse->avgY0);
365		bc += _read_float(buf+bc, &gse->avgX1);
366		bc += _read_float(buf+bc, &gse->avgY1);
367		bc += _read_i32(buf+bc, &gse->processId);
368		bc += _read_i64(buf+bc, &gse->timestamp);
369		bc += _read_i32(buf+bc, (uint32_t*)&gse->window);
370		bc += _read_i32(buf+bc, &gse->r11);
371		bc += _read_i32(buf+bc, &gse->type12);
372		bc += _read_i32(buf+bc, &gse->gesture13);
373		bc += _read_i32(buf+bc, &gse->gesture14);
374		bc += _read_i16(buf+bc, &gse->numInitialTouches);
375		bc += _read_i16(buf+bc, &gse->numCurrentTouches);
376		bc += _read_i32(buf+bc, &gse->r16);
377		bc += _read_i32(buf+bc, &gse->r17);
378		bc += _read_i32(buf+bc, &gse->r18);
379		bc += _read_i32(buf+bc, &gse->r19);
380		bc += _read_i32(buf+bc, &gse->r20);
381		bc += _read_i32(buf+bc, &gse->r21);
382		bc += _read_i8(buf+bc, &gse->r22_0);
383		bc += _read_i8(buf+bc, &gse->numPoints);
384		bc += _read_i16(buf+bc, &gse->r22_2);
385		for (size_t i = 0; i < gse->numPoints; ++i)
386		bc += _read_gspoint(buf+bc, gse->points + i);
387
388		return gse;
389		}
390
391		- (void) tapReceived: (NSData*) tapData
392		{
393		assert([tapData length] > 4);
394
395
396		NSDictionary* tapDict = [NSPropertyListSerialization propertyListFromData: tapData mutabilityOption:NSPropertyListImmutable format: NULL errorDescription: NULL];
397		assert(tapDict);
398		switch([[tapDict objectForKey: TapIdKey] intValue])
399		{
400		case kTapTouchEvent:
401		{
402		NSLog(@"TOUCH EVENT");
403
404		GSEvent* gse = [self gsEventWithData: [tapDict objectForKey: TapGSEventKey]];
405		UIWindow* window = [[UIApplication sharedApplication] keyWindow];
406		gse->window = window;
407		for (size_t i = 0; i < gse->numPoints; ++i)
408		gse->points[i].window = window;
409
410		int phase = [[tapDict objectForKey: TapTouchPhaseKey] intValue];
411		NSSet* touches = [UITouch _createTouchesWithGSEvent: gse phase: phase view: [[UIApplication sharedApplication] keyWindow]];
412
413		assert([[UIApplication sharedApplication] keyWindow]);
414
415		NSLog(@"%@", touches);
416
417		UIEvent* event = [UIEvent alloc];
418
419		Class touchesEventClass = objc_getClass("UITouchesEvent");
420		if (touchesEventClass && ![[event class] isEqual: touchesEventClass])
421		{
422		event = [touchesEventClass alloc];
423		}
424
425		[event _initWithEvent: gse touches: touches];
426
427		assert(event);
428
429		[[UIApplication sharedApplication] sendEvent: event];
430
431
432		break;
433		}
434		case kTapRecordedEvent:
435		{
436		NSLog(@"RECORDED EVENT");
437
438		NSDictionary* eventDict = [tapDict objectForKey: TapRecordedEventKey];
439
440		[[UIApplication sharedApplication] _playbackEvents:[NSArray arrayWithObject: eventDict] atPlaybackRate: 1.0f messageWhenDone: nil withSelector: nil];
441
442		break;
443		}
444		}
445
446		}
447
448
449		/*
450		- (void)performTouches: (NSSet) touches inView: (UIView )view
451		{
452		UITouch *touch = [[UITouch alloc] initInView:view];
453		UIEvent *eventDown = [[UIEvent alloc] initWithTouch:touch];
454
455		[touch.view touchesBegan:[eventDown allTouches] withEvent:eventDown];
456
457		[touch setPhase:UITouchPhaseEnded];
458		UIEvent *eventUp = [[UIEvent alloc] initWithTouch:touch];
459
460		[touch.view touchesEnded:[eventUp allTouches] withEvent:eventUp];
461
462		[eventDown release];
463		[eventUp release];
464		[touch release];
465		}
466		*/
467
468		- (void) dealloc
469		{
470
471		[netService stop];
472		[netService release];
473
474		[activeThreads release];
475
476		[super dealloc];
477		}
478
479		@end