(root)/iphone/common : 60 : tappity/source/TappityServer.m

//

//  TappityServer.m

//  Jigs

//

//  Created by döme on 25.10.2009.

//

 

/*

 * Copyright (c) 2009 Doemoetoer Gulyas.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. The name of the author may not be used to endorse or promote products

 *    derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

 

 

#import "TappityServer.h"

#import "Tappity.h"

#import <QuartzCore/QuartzCore.h>

#import <OpenGLES/ES1/gl.h>

#import <OpenGLES/EAGL.h>

#import <CoreLocation/CoreLocation.h>

#import <objc/runtime.h>

 

 

@interface CLLocationManager (TappityServer)

 

- (void) setDelegate_tappity: (id) delegate;

- (void) startUpdatingLocation_tappity;

- (void) stopUpdatingLocation_tappity;

- (void) startUpdatingHeading_tappity;

- (void) stopUpdatingHeading_tappity;

 

@end

 

@interface UIAccelerometer (TappityServer)

 

- (void) setUpdateInterval_tappity: (NSTimeInterval) dt;

 

@end

 

@interface EAGLContext (TappityServer)

 

- (BOOL)presentRenderbuffer_tappity:(NSUInteger)target;

 

 

@end

 

 

@implementation CLLocationManager (TappityServer)

 

- (void) setDelegate_tappity: (id) obj

{

        if ([obj respondsToSelector: @selector(locationManager:didUpdateToLocation:fromLocation:)])

        {

                [[TappityServer sharedServer] setLocationDelegate: obj];

        }

        if ([obj respondsToSelector: @selector(locationManager:didUpdateHeading:)])

        {

                [[TappityServer sharedServer] setHeadingDelegate: obj];

        }

        [self setDelegate_tappity: obj];

 

}

 

- (void) startUpdatingLocation_tappity

{

        [[TappityServer sharedServer] sendData: [NSData data] withIdentifier: kTapStartUpdatingLocation];

        [self startUpdatingLocation_tappity];

}

 

- (void) stopUpdatingLocation_tappity

{

        [[TappityServer sharedServer] sendData: [NSData data] withIdentifier: kTapStopUpdatingLocation];

        [self stopUpdatingLocation_tappity];

}

 

- (void) startUpdatingHeading_tappity

{

        [[TappityServer sharedServer] sendData: [NSData data] withIdentifier: kTapStartUpdatingHeading];

        [self startUpdatingHeading_tappity];

}

 

- (void) stopUpdatingHeading_tappity

{

        [[TappityServer sharedServer] sendData: [NSData data] withIdentifier: kTapStopUpdatingHeading];

        [self stopUpdatingHeading_tappity];

}

 

 

@end

 

@implementation UIAccelerometer (TappityServer)

 

- (void) setUpdateInterval_tappity: (NSTimeInterval) dt

{

        [[TappityServer sharedServer] setAccelerometerUpdateInterval: dt];

        

        [self setUpdateInterval_tappity: dt];

}

 

@end

 

@implementation EAGLContext (TappityServer)

 

- (BOOL)presentRenderbuffer_tappity:(NSUInteger)target

{

        [TappityServer glGrabPoint];

        return [self presentRenderbuffer_tappity: target];

}

 

 

@end

 

static void swapMethods(Class c, SEL sela, SEL selb)

{

        Method ma = class_getInstanceMethod(c, sela);

        Method mb = class_getInstanceMethod(c, selb);

        method_exchangeImplementations(ma, mb);

        

}

 

static void catch_pipe(int sig_num)

{

    signal(SIGPIPE, catch_pipe);

}

 

__attribute__((constructor)) void initTappityServer(void)

{

//      __builtin_printf("MOOOOOOOOOOOOOOO\n");

        /* TODO:

                1. intercept UIAccelerometer

                2. intercept CLLocationManager

                class_getInstanceMethod(), method_setImplementation()

        */

 

        NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

        

        NSString* name = [[NSBundle mainBundle] bundleIdentifier];

        

        [[TappityServer sharedServer] startBonjourServerWithName: name protocol: @"_tappity._tcp" port: 1234];

        

        Class lmc = NSClassFromString(@"CLLocationManager");

        if (lmc)

        {

                swapMethods(lmc, @selector(setDelegate:), @selector(setDelegate_tappity:));

                swapMethods(lmc, @selector(startUpdatingHeading:), @selector(startUpdatingHeading_tappity:));

                swapMethods(lmc, @selector(startUpdatingLocation:), @selector(startUpdatingLocation_tappity:));

        }

 

        Class accc = [UIAccelerometer class];

        swapMethods(accc, @selector(setUpdateInterval:), @selector(setUpdateInterval_tappity:));

 

        Class glc = NSClassFromString(@"EAGLContext");

        if (glc)

                swapMethods(glc, @selector(presentRenderbuffer:), @selector(presentRenderbuffer_tappity:));

 

        

        [pool drain];

        

        signal(SIGPIPE, catch_pipe);

 

}

 

 

 

 

@implementation TappityServer

 

+ (void) initialize

{

        

}

 

- (id) init

{

        if (!(self = [super init]))

                return nil;

 

        desiredFrameInterval = 0.333;

        

        messenger = [[SocketMessenger alloc] init];

        [messenger setReceiveDataOnMainThread: YES];

        [messenger setDelegate: self];

        

        return self;

}

 

- (void) sendData: (NSData*) data withIdentifier: (NSInteger) messageId

{

        [messenger sendData: data withIdentifier: messageId];

}

 

- (void) startBonjourServerWithName: (NSString*) name protocol: (NSString*) protocol port: (int) port

{

        [messenger startBonjourServerWithName: name protocol: protocol port: port];

}

 

- (void) connectionWasEstablished: (SocketMessenger*) theMessenger

{

        if (locationDelegate)

                [messenger sendData: [NSData data] withIdentifier: kTapStartUpdatingLocation];

        if (headingDelegate)

                [messenger sendData: [NSData data] withIdentifier: kTapStartUpdatingHeading];

 

        [self performSelectorOnMainThread: @selector(startScreenieTimer) withObject: nil waitUntilDone: NO];

}

 

- (void) startScreenieTimer

{

        [captureTimer invalidate];

        captureTimer = [NSTimer scheduledTimerWithTimeInterval: desiredFrameInterval target: self selector: @selector(captureScreen) userInfo: nil repeats: YES];

        

        

        if (!capturedImagesCondition)

                capturedImagesCondition = [[NSCondition alloc] init];

 

        [messenger runThreadWithTarget: self selector: @selector(imageConversionThread:)];

}

 

/*

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) doEventPlayback

{

        [[UIApplication sharedApplication] _playbackEvents: queuedEvents atPlaybackRate: 1.0f messageWhenDone: self withSelector: @selector(eventPlaybackDone:)];

        

        [queuedEvents autorelease];

        queuedEvents = nil;

        eventPlaybackBusy = YES;

}

- (void) eventPlaybackDone:(NSDictionary*)detail

{

        if ([queuedEvents count])

        {

                [self doEventPlayback];

        }

        else

                eventPlaybackBusy = NO;

}

 

- (void) dataReceived: (NSDictionary*) dataDict

{

        uint32_t messageId = [[dataDict objectForKey: SocketMessageIdKey] intValue];

        

//      NSLog(@"received messageid %d", messageId);

 

        NSData* tapData = [dataDict objectForKey: SocketMessageDataKey];

        

//      NSDictionary* tapDict = [NSPropertyListSerialization propertyListFromData: tapData mutabilityOption:NSPropertyListImmutable format: NULL errorDescription: NULL];

        assert(tapData);

        switch(messageId)

        {

/*

                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:

                {                       

                        NSDictionary* eventDict = [NSPropertyListSerialization propertyListFromData: tapData mutabilityOption:NSPropertyListImmutable format: NULL errorDescription: NULL];

                        

                        if (!queuedEvents)

                                queuedEvents = [[NSMutableArray alloc] init];

 

                        [queuedEvents addObject: eventDict];

                        

                        if (!eventPlaybackBusy)

                        {

                                [self doEventPlayback];

                        }

                        break;

                }

                case kTapAcceleration:

                {                       

                        NSArray* accel = [NSPropertyListSerialization propertyListFromData: tapData mutabilityOption:NSPropertyListImmutable format: NULL errorDescription: NULL];

                        

                        UIAccelerometer* accm = [UIAccelerometer sharedAccelerometer];

                        float x = [[accel objectAtIndex: 0] floatValue];

                        float y = [[accel objectAtIndex: 1] floatValue];

                        float z = [[accel objectAtIndex: 2] floatValue];

                        [accm _acceleratedInX: x y: y z: z timestamp: [[accel objectAtIndex: 3] doubleValue]];

                        

                        break;

                }

                case kTapLocation:

                {

                        static CLLocation* oldLoc = nil;

                        CLLocation* loc = [NSKeyedUnarchiver unarchiveObjectWithData: tapData];

                        if ([locationDelegate respondsToSelector: @selector(locationManager:didUpdateToLocation:fromLocation:)])

                        {

                                [locationDelegate locationManager: (id)self didUpdateToLocation: loc fromLocation: oldLoc];

                        }

                        oldLoc = loc;

                        break;

                }

                case kTapCompass:

                {

                        CLHeading* hdg = [NSKeyedUnarchiver unarchiveObjectWithData: tapData];

                        if ([headingDelegate respondsToSelector: @selector(locationManager:didUpdateHeading:)])

                        {

                                [headingDelegate locationManager: (id)self didUpdateHeading: hdg];

                        }

                        break;

                }

                case kTapStartSendingVisualFeedback:

                {

                        NSLog(@"enabling visual uplink");

                        enableVisualFeedback = YES;

                        break;

                }

        }

        

        [tapData release];

        

}

 

- (UIImage *) imageFromView: (UIView *) theView

{

        UIGraphicsBeginImageContext(theView.frame.size);

        CGContextRef context = UIGraphicsGetCurrentContext();

//      [theView.layer drawInContext:context];

        [theView.layer renderInContext:context];

        UIImage *theImage = UIGraphicsGetImageFromCurrentImageContext();

        UIGraphicsEndImageContext();

        return theImage;

}

 

- (void) convertAndSendImage: (UIImage*) img

{               

        [capturedImagesCondition lock];

 

        if (!capturedImagesQueue)

                capturedImagesQueue = [[NSMutableArray alloc] init];

 

        [capturedImagesQueue addObject: img];

        

        [capturedImagesCondition signal];

        [capturedImagesCondition unlock];

                

}

 

- (void) captureScreen

{

        NSTimeInterval now = [NSDate timeIntervalSinceReferenceDate];

        

        if ((now < lastGlUpdate + 2.0*desiredFrameInterval))

                return;

                

        // return if any gl has been updated at all

        if (lastGlUpdate || !enableVisualFeedback)

                return;

        

        [self performSelectorOnMainThread: @selector(getWindowToCapture) withObject: nil waitUntilDone: NO];

 

        UIWindow* window = windowToCapture;

        

        UIImage* img = [self imageFromView: window];

        

        lastQuartzUpdate = now;

        

        if (img)

                [self convertAndSendImage: img];

}

 

- (void) imageConversionThread: (id) info

{

        NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

 

        @synchronized(self)

        {

                [self retain];

        }

 

        while ([messenger threadActive: info])

        {

                NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

 

                [capturedImagesCondition lock];

                        while (![capturedImagesQueue count])

                                [capturedImagesCondition wait];

                                

                //NSLog(@"sending");

                

                UIImage* img = [[[capturedImagesQueue objectAtIndex: 0] retain] autorelease];

                [capturedImagesQueue removeObjectAtIndex: 0];

                

                [capturedImagesCondition unlock];

 

                NSData* imgData = UIImagePNGRepresentation(img);

        

                if (imgData)

                        [messenger sendData: imgData withIdentifier: kTapRawScreenshot];

 

                

                [pool drain];

 

        }

        

 

        [messenger threadWillExit: info];

 

        @synchronized(self)

        {

                [self release];

        }

 

        [info release];

        [pool drain];

}

 

 

 

 

- (void) getWindowToCapture

{

        @synchronized(self)

        {

                [windowToCapture release];

                windowToCapture = [[[UIApplication sharedApplication] keyWindow] retain];

        }

}

- (void) screenieThread: (id) info

{

        NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

 

        @synchronized(self)

        {

                [self retain];

        }

 

 

        while ([messenger threadActive: info])

        {

                [self captureScreen];

                usleep(200);

        }

 

        [messenger threadWillExit: info];

 

        @synchronized(self)

        {

                [self release];

        }

 

        [info release];

        [pool drain];

}

 

 

- (void) setAccelerometerUpdateInterval: (NSTimeInterval) dt

{

        CFSwappedFloat64 sdt = CFConvertFloat64HostToSwapped(dt);

        NSData* data = [NSData dataWithBytes: &sdt length: sizeof(CFSwappedFloat64)];

        [messenger sendData: data withIdentifier: kTapAccelerometerUpdateInterval];

}

 

/*

- (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];

}

*/

 

static UIImage* imageFromGLData(NSData* data)

{

    // make data provider with data.

    CGDataProviderRef provider = CGDataProviderCreateWithData(NULL, [data bytes], [data length], NULL);

   

    // prep the ingredients

    int bitsPerComponent = 8;

    int bitsPerPixel = 32;

    int bytesPerRow = 4 * 320;

    CGColorSpaceRef colorSpaceRef = CGColorSpaceCreateDeviceRGB();

    CGBitmapInfo bitmapInfo = kCGBitmapByteOrderDefault;

    CGColorRenderingIntent renderingIntent = kCGRenderingIntentDefault;

   

    // make the cgimage

    CGImageRef imageRef = CGImageCreate(320, 480, bitsPerComponent, bitsPerPixel, bytesPerRow, colorSpaceRef, bitmapInfo, provider, NULL, NO, renderingIntent);

   

    // then make the uiimage from that

    UIImage *myImage = [UIImage imageWithCGImage:imageRef];

    return myImage;

}

 

static NSData* dataFromGL(void)

{

    NSInteger myDataLength = 320 * 480 * 4;

        

        NSMutableData* data = [NSMutableData dataWithLength: myDataLength];

   

    // allocate array and read pixels into it.

    void* buffer = [data mutableBytes];

    glReadPixels(0, 0, 320, 480, GL_RGBA, GL_UNSIGNED_BYTE, buffer);

        

        size_t bpr = 4*320;

        void* rowbuf = calloc(1, bpr);

        

        // swap image in Y

        for (size_t i = 0; i < 480/2; ++i)

        {

                memcpy(rowbuf, buffer + i*bpr, bpr);

                memcpy(buffer + i*bpr, buffer + (480-i-1)*bpr, bpr);

                memcpy(buffer + (480-i-1)*bpr, rowbuf, bpr);

        }

        

        free(rowbuf);

 

        return data;

}

 

- (void) glGrabPoint

{

        if (!enableVisualFeedback)

                return;

 

        NSTimeInterval now = [NSDate timeIntervalSinceReferenceDate];

        if (lastGlUpdate + desiredFrameInterval < now)

        {

                NSData* rawData = dataFromGL();

                UIImage* image = imageFromGLData(rawData);

                

                NSData* data = UIImagePNGRepresentation(image);

                

                [messenger sendData: data withIdentifier: kTapRawScreenshot];

                

                lastGlUpdate = now;

        }

}

 

+ (void) glGrabPoint

{

        [[self sharedServer] glGrabPoint];

}

 

+ (id) sharedServer

{

        static id sharedInstance = nil;

        if (!sharedInstance)

                sharedInstance = [[TappityServer alloc] init];

        

        

        return sharedInstance;

}

 

- (void) dealloc

{

 

        [captureTimer invalidate];

        

        [messenger terminateConnection];

        [messenger release];

        

        [capturedImagesCondition release];

        [capturedImagesQueue release];

 

        [super dealloc];

}

 

@synthesize locationDelegate, headingDelegate;

 

@end