| /* |
| * Copyright (C) 2015 Apple Inc. 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. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``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 APPLE INC. OR ITS CONTRIBUTORS |
| * 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 "config.h" |
| #import "HIDEventGenerator.h" |
| |
| #import "GeneratedTouchesDebugWindow.h" |
| #import "IOKitSPI.h" |
| #import "UIKitTestSPI.h" |
| #import <mach/mach_time.h> |
| #import <wtf/Assertions.h> |
| #import <wtf/BlockPtr.h> |
| #import <wtf/RetainPtr.h> |
| #import <wtf/SoftLinking.h> |
| |
| SOFT_LINK_PRIVATE_FRAMEWORK(BackBoardServices) |
| SOFT_LINK(BackBoardServices, BKSHIDEventSetDigitizerInfo, void, (IOHIDEventRef digitizerEvent, uint32_t contextID, uint8_t systemGestureisPossible, uint8_t isSystemGestureStateChangeEvent, CFStringRef displayUUID, CFTimeInterval initialTouchTimestamp, float maxForce), (digitizerEvent, contextID, systemGestureisPossible, isSystemGestureStateChangeEvent, displayUUID, initialTouchTimestamp, maxForce)); |
| |
| NSString* const TopLevelEventInfoKey = @"events"; |
| NSString* const HIDEventInputType = @"inputType"; |
| NSString* const HIDEventTimeOffsetKey = @"timeOffset"; |
| NSString* const HIDEventTouchesKey = @"touches"; |
| NSString* const HIDEventPhaseKey = @"phase"; |
| NSString* const HIDEventInterpolateKey = @"interpolate"; |
| NSString* const HIDEventTimestepKey = @"timestep"; |
| NSString* const HIDEventCoordinateSpaceKey = @"coordinateSpace"; |
| NSString* const HIDEventStartEventKey = @"startEvent"; |
| NSString* const HIDEventEndEventKey = @"endEvent"; |
| NSString* const HIDEventTouchIDKey = @"id"; |
| NSString* const HIDEventPressureKey = @"pressure"; |
| NSString* const HIDEventXKey = @"x"; |
| NSString* const HIDEventYKey = @"y"; |
| NSString* const HIDEventTwistKey = @"twist"; |
| NSString* const HIDEventMajorRadiusKey = @"majorRadius"; |
| NSString* const HIDEventMinorRadiusKey = @"minorRadius"; |
| |
| NSString* const HIDEventInputTypeHand = @"hand"; |
| NSString* const HIDEventInputTypeFinger = @"finger"; |
| NSString* const HIDEventInputTypeStylus = @"stylus"; |
| |
| NSString* const HIDEventCoordinateSpaceTypeGlobal = @"global"; |
| NSString* const HIDEventCoordinateSpaceTypeContent = @"content"; |
| |
| NSString* const HIDEventInterpolationTypeLinear = @"linear"; |
| NSString* const HIDEventInterpolationTypeSimpleCurve = @"simpleCurve"; |
| |
| NSString* const HIDEventPhaseBegan = @"began"; |
| NSString* const HIDEventPhaseStationary = @"stationary"; |
| NSString* const HIDEventPhaseMoved = @"moved"; |
| NSString* const HIDEventPhaseEnded = @"ended"; |
| NSString* const HIDEventPhaseCanceled = @"canceled"; |
| |
| static const NSTimeInterval fingerLiftDelay = 0.05; |
| static const NSTimeInterval multiTapInterval = 0.15; |
| static const NSTimeInterval fingerMoveInterval = 0.016; |
| static const NSTimeInterval longPressHoldDelay = 2.0; |
| static const IOHIDFloat defaultMajorRadius = 5; |
| static const IOHIDFloat defaultPathPressure = 0; |
| static const long nanosecondsPerSecond = 1e9; |
| |
| NSUInteger const HIDMaxTouchCount = 5; |
| |
| |
| |
| static int fingerIdentifiers[HIDMaxTouchCount] = { 2, 3, 4, 5, 1 }; |
| |
| typedef enum { |
| InterpolationTypeLinear, |
| InterpolationTypeSimpleCurve, |
| } InterpolationType; |
| |
| typedef enum { |
| HandEventNull, |
| HandEventTouched, |
| HandEventMoved, |
| HandEventChordChanged, |
| HandEventLifted, |
| HandEventCanceled, |
| StylusEventTouched, |
| StylusEventMoved, |
| StylusEventLifted, |
| } HandEventType; |
| |
| typedef struct { |
| int identifier; |
| CGPoint point; |
| IOHIDFloat pathMajorRadius; |
| IOHIDFloat pathPressure; |
| UInt8 pathProximity; |
| BOOL isStylus; |
| IOHIDFloat azimuthAngle; |
| IOHIDFloat altitudeAngle; |
| } SyntheticEventDigitizerInfo; |
| |
| static CFTimeInterval secondsSinceAbsoluteTime(CFAbsoluteTime startTime) |
| { |
| return (CFAbsoluteTimeGetCurrent() - startTime); |
| } |
| |
| static double linearInterpolation(double a, double b, double t) |
| { |
| return (a + (b - a) * t ); |
| } |
| |
| static double simpleCurveInterpolation(double a, double b, double t) |
| { |
| return (a + (b - a) * sin(sin(t * M_PI / 2) * t * M_PI / 2)); |
| } |
| |
| |
| static CGPoint calculateNextCurveLocation(CGPoint a, CGPoint b, CFTimeInterval t) |
| { |
| return CGPointMake(simpleCurveInterpolation(a.x, b.x, t), simpleCurveInterpolation(a.y, b.y, t)); |
| } |
| |
| typedef double(*pressureInterpolationFunction)(double, double, CFTimeInterval); |
| static pressureInterpolationFunction interpolations[] = { |
| linearInterpolation, |
| simpleCurveInterpolation, |
| }; |
| |
| static void delayBetweenMove(int eventIndex, double elapsed) |
| { |
| // Delay next event until expected elapsed time. |
| double delay = (eventIndex * fingerMoveInterval) - elapsed; |
| if (delay > 0) { |
| struct timespec moveDelay = { 0, static_cast<long>(delay * nanosecondsPerSecond) }; |
| nanosleep(&moveDelay, NULL); |
| } |
| } |
| |
| @interface HIDEventGenerator () |
| @property (nonatomic, strong) NSMutableDictionary *eventCallbacks; |
| @property (nonatomic, strong) NSArray<UIView *> *debugTouchViews; |
| @end |
| |
| @implementation HIDEventGenerator { |
| IOHIDEventSystemClientRef _ioSystemClient; |
| SyntheticEventDigitizerInfo _activePoints[HIDMaxTouchCount]; |
| NSUInteger _activePointCount; |
| } |
| |
| + (HIDEventGenerator *)sharedHIDEventGenerator |
| { |
| static HIDEventGenerator *eventGenerator = nil; |
| if (!eventGenerator) |
| eventGenerator = [[HIDEventGenerator alloc] init]; |
| |
| return eventGenerator; |
| } |
| |
| + (unsigned)nextEventCallbackID |
| { |
| static unsigned callbackID = 0; |
| return ++callbackID; |
| } |
| |
| - (instancetype)init |
| { |
| self = [super init]; |
| if (!self) |
| return nil; |
| |
| for (NSUInteger i = 0; i < HIDMaxTouchCount; ++i) |
| _activePoints[i].identifier = fingerIdentifiers[i]; |
| |
| _eventCallbacks = [[NSMutableDictionary alloc] init]; |
| |
| return self; |
| } |
| |
| - (void)dealloc |
| { |
| [_eventCallbacks release]; |
| [_debugTouchViews release]; |
| [super dealloc]; |
| } |
| |
| |
| |
| - (void)_sendIOHIDKeyboardEvent:(uint64_t)timestamp usage:(uint32_t)usage isKeyDown:(bool)isKeyDown |
| { |
| RetainPtr<IOHIDEventRef> eventRef = adoptCF(IOHIDEventCreateKeyboardEvent(kCFAllocatorDefault, |
| timestamp, |
| kHIDPage_KeyboardOrKeypad, |
| usage, |
| isKeyDown, |
| kIOHIDEventOptionNone)); |
| [self _sendHIDEvent:eventRef.get()]; |
| } |
| |
| static IOHIDDigitizerTransducerType transducerTypeFromString(NSString * transducerTypeString) |
| { |
| if ([transducerTypeString isEqualToString:HIDEventInputTypeHand]) |
| return kIOHIDDigitizerTransducerTypeHand; |
| |
| if ([transducerTypeString isEqualToString:HIDEventInputTypeFinger]) |
| return kIOHIDDigitizerTransducerTypeFinger; |
| |
| if ([transducerTypeString isEqualToString:HIDEventInputTypeStylus]) |
| return kIOHIDDigitizerTransducerTypeStylus; |
| |
| ASSERT_NOT_REACHED(); |
| return 0; |
| } |
| |
| static UITouchPhase phaseFromString(NSString *string) |
| { |
| if ([string isEqualToString:HIDEventPhaseBegan]) |
| return UITouchPhaseBegan; |
| |
| if ([string isEqualToString:HIDEventPhaseStationary]) |
| return UITouchPhaseStationary; |
| |
| if ([string isEqualToString:HIDEventPhaseMoved]) |
| return UITouchPhaseMoved; |
| |
| if ([string isEqualToString:HIDEventPhaseEnded]) |
| return UITouchPhaseEnded; |
| |
| if ([string isEqualToString:HIDEventPhaseCanceled]) |
| return UITouchPhaseCancelled; |
| |
| return UITouchPhaseStationary; |
| } |
| |
| static InterpolationType interpolationFromString(NSString *string) |
| { |
| if ([string isEqualToString:HIDEventInterpolationTypeLinear]) |
| return InterpolationTypeLinear; |
| |
| if ([string isEqualToString:HIDEventInterpolationTypeSimpleCurve]) |
| return InterpolationTypeSimpleCurve; |
| |
| return InterpolationTypeLinear; |
| } |
| |
| - (IOHIDDigitizerEventMask)eventMaskFromEventInfo:(NSDictionary *)info |
| { |
| IOHIDDigitizerEventMask eventMask = 0; |
| NSArray *childEvents = info[HIDEventTouchesKey]; |
| for (NSDictionary *touchInfo in childEvents) { |
| UITouchPhase phase = phaseFromString(touchInfo[HIDEventPhaseKey]); |
| // If there are any new or ended events, mask includes touch. |
| if (phase == UITouchPhaseBegan || phase == UITouchPhaseEnded || phase == UITouchPhaseCancelled) |
| eventMask |= kIOHIDDigitizerEventTouch; |
| // If there are any pressure readings, set mask must include attribute |
| if ([touchInfo[HIDEventPressureKey] floatValue]) |
| eventMask |= kIOHIDDigitizerEventAttribute; |
| } |
| |
| return eventMask; |
| } |
| |
| // Returns 1 for all events where the fingers are on the glass (everything but ended and canceled). |
| - (CFIndex)touchFromEventInfo:(NSDictionary *)info |
| { |
| NSArray *childEvents = info[HIDEventTouchesKey]; |
| for (NSDictionary *touchInfo in childEvents) { |
| UITouchPhase phase = phaseFromString(touchInfo[HIDEventPhaseKey]); |
| if (phase == UITouchPhaseBegan || phase == UITouchPhaseMoved || phase == UITouchPhaseStationary) |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| // FIXME: callers of _createIOHIDEventType could switch to this. |
| - (IOHIDEventRef)_createIOHIDEventWithInfo:(NSDictionary *)info |
| { |
| uint64_t machTime = mach_absolute_time(); |
| |
| IOHIDDigitizerEventMask eventMask = [self eventMaskFromEventInfo:info]; |
| |
| CFIndex range = 0; |
| // touch is 1 if a finger is down. |
| CFIndex touch = [self touchFromEventInfo:info]; |
| |
| IOHIDEventRef eventRef = IOHIDEventCreateDigitizerEvent(kCFAllocatorDefault, machTime, |
| transducerTypeFromString(info[HIDEventInputType]), // transducerType |
| 0, // index |
| 0, // identifier |
| eventMask, // event mask |
| 0, // button event |
| 0, // x |
| 0, // y |
| 0, // z |
| 0, // presure |
| 0, // twist |
| range, // range |
| touch, // touch |
| kIOHIDEventOptionNone); |
| |
| IOHIDEventSetIntegerValue(eventRef, kIOHIDEventFieldDigitizerIsDisplayIntegrated, 1); |
| |
| NSArray *childEvents = info[HIDEventTouchesKey]; |
| for (NSDictionary *touchInfo in childEvents) { |
| |
| [[GeneratedTouchesDebugWindow sharedGeneratedTouchesDebugWindow] updateDebugIndicatorForTouch:[touchInfo[HIDEventTouchIDKey] intValue] withPointInWindowCoordinates:CGPointMake([touchInfo[HIDEventXKey] floatValue], [touchInfo[HIDEventYKey] floatValue]) isTouching:(BOOL)touch]; |
| |
| IOHIDDigitizerEventMask childEventMask = 0; |
| |
| UITouchPhase phase = phaseFromString(touchInfo[HIDEventPhaseKey]); |
| if (phase != UITouchPhaseCancelled && phase != UITouchPhaseBegan && phase != UITouchPhaseEnded && phase != UITouchPhaseStationary) |
| childEventMask |= kIOHIDDigitizerEventPosition; |
| |
| if (phase == UITouchPhaseBegan || phase == UITouchPhaseEnded || phase == UITouchPhaseCancelled) |
| childEventMask |= (kIOHIDDigitizerEventTouch | kIOHIDDigitizerEventRange); |
| |
| if (phase == UITouchPhaseCancelled) |
| childEventMask |= kIOHIDDigitizerEventCancel; |
| |
| if ([touchInfo[HIDEventPressureKey] floatValue]) |
| childEventMask |= kIOHIDDigitizerEventAttribute; |
| |
| IOHIDEventRef subEvent = IOHIDEventCreateDigitizerFingerEvent(kCFAllocatorDefault, machTime, |
| [touchInfo[HIDEventTouchIDKey] intValue], // index |
| 2, // identifier (which finger we think it is). FIXME: this should come from the data. |
| childEventMask, |
| [touchInfo[HIDEventXKey] floatValue], |
| [touchInfo[HIDEventYKey] floatValue], |
| 0, // z |
| [touchInfo[HIDEventPressureKey] floatValue], |
| [touchInfo[HIDEventTwistKey] floatValue], |
| touch, // range |
| touch, // touch |
| kIOHIDEventOptionNone); |
| |
| IOHIDEventSetFloatValue(subEvent, kIOHIDEventFieldDigitizerMajorRadius, [touchInfo[HIDEventMajorRadiusKey] floatValue]); |
| IOHIDEventSetFloatValue(subEvent, kIOHIDEventFieldDigitizerMinorRadius, [touchInfo[HIDEventMinorRadiusKey] floatValue]); |
| |
| IOHIDEventAppendEvent(eventRef, subEvent, 0); |
| CFRelease(subEvent); |
| } |
| |
| return eventRef; |
| } |
| |
| - (IOHIDEventRef)_createIOHIDEventType:(HandEventType)eventType |
| { |
| BOOL isTouching = (eventType == HandEventTouched || eventType == HandEventMoved || eventType == HandEventChordChanged || eventType == StylusEventTouched || eventType == StylusEventMoved); |
| |
| IOHIDDigitizerEventMask eventMask = kIOHIDDigitizerEventTouch; |
| if (eventType == HandEventMoved) { |
| eventMask &= ~kIOHIDDigitizerEventTouch; |
| eventMask |= kIOHIDDigitizerEventPosition; |
| eventMask |= kIOHIDDigitizerEventAttribute; |
| } else if (eventType == HandEventChordChanged) { |
| eventMask |= kIOHIDDigitizerEventPosition; |
| eventMask |= kIOHIDDigitizerEventAttribute; |
| } else if (eventType == HandEventTouched || eventType == HandEventCanceled || eventType == HandEventLifted) |
| eventMask |= kIOHIDDigitizerEventIdentity; |
| |
| uint64_t machTime = mach_absolute_time(); |
| RetainPtr<IOHIDEventRef> eventRef = adoptCF(IOHIDEventCreateDigitizerEvent(kCFAllocatorDefault, machTime, |
| kIOHIDDigitizerTransducerTypeHand, |
| 0, |
| 0, |
| eventMask, |
| 0, |
| 0, 0, 0, |
| 0, |
| 0, |
| 0, |
| isTouching, |
| kIOHIDEventOptionNone)); |
| |
| IOHIDEventSetIntegerValue(eventRef.get(), kIOHIDEventFieldDigitizerIsDisplayIntegrated, 1); |
| |
| for (NSUInteger i = 0; i < _activePointCount; ++i) { |
| SyntheticEventDigitizerInfo* pointInfo = &_activePoints[i]; |
| if (eventType == HandEventTouched) { |
| if (!pointInfo->pathMajorRadius) |
| pointInfo->pathMajorRadius = defaultMajorRadius; |
| if (!pointInfo->pathPressure) |
| pointInfo->pathPressure = defaultPathPressure; |
| if (!pointInfo->pathProximity) |
| pointInfo->pathProximity = kGSEventPathInfoInTouch | kGSEventPathInfoInRange; |
| } else if (eventType == HandEventLifted || eventType == HandEventCanceled || eventType == StylusEventLifted) { |
| pointInfo->pathMajorRadius = 0; |
| pointInfo->pathPressure = 0; |
| pointInfo->pathProximity = 0; |
| } |
| |
| CGPoint point = pointInfo->point; |
| point = CGPointMake(roundf(point.x), roundf(point.y)); |
| |
| [[GeneratedTouchesDebugWindow sharedGeneratedTouchesDebugWindow] updateDebugIndicatorForTouch:i withPointInWindowCoordinates:point isTouching:isTouching]; |
| |
| RetainPtr<IOHIDEventRef> subEvent; |
| if (pointInfo->isStylus) { |
| if (eventType == StylusEventTouched) { |
| eventMask |= kIOHIDDigitizerEventEstimatedAltitude; |
| eventMask |= kIOHIDDigitizerEventEstimatedAzimuth; |
| eventMask |= kIOHIDDigitizerEventEstimatedPressure; |
| } else if (eventType == StylusEventMoved) |
| eventMask = kIOHIDDigitizerEventPosition; |
| |
| subEvent = adoptCF(IOHIDEventCreateDigitizerStylusEventWithPolarOrientation(kCFAllocatorDefault, machTime, |
| pointInfo->identifier, |
| pointInfo->identifier, |
| eventMask, |
| 0, |
| point.x, point.y, 0, |
| pointInfo->pathPressure, |
| pointInfo->pathPressure, |
| 0, |
| pointInfo->altitudeAngle, |
| pointInfo->azimuthAngle, |
| 1, |
| 0, |
| isTouching ? kIOHIDTransducerTouch : 0)); |
| |
| if (eventType == StylusEventTouched) |
| IOHIDEventSetIntegerValue(subEvent.get(), kIOHIDEventFieldDigitizerWillUpdateMask, 0x0400); |
| else if (eventType == StylusEventMoved) |
| IOHIDEventSetIntegerValue(subEvent.get(), kIOHIDEventFieldDigitizerDidUpdateMask, 0x0400); |
| |
| } else { |
| subEvent = adoptCF(IOHIDEventCreateDigitizerFingerEvent(kCFAllocatorDefault, machTime, |
| pointInfo->identifier, |
| pointInfo->identifier, |
| eventMask, |
| point.x, point.y, 0, |
| pointInfo->pathPressure, |
| 0, |
| pointInfo->pathProximity & kGSEventPathInfoInRange, |
| pointInfo->pathProximity & kGSEventPathInfoInTouch, |
| kIOHIDEventOptionNone)); |
| } |
| |
| IOHIDEventSetFloatValue(subEvent.get(), kIOHIDEventFieldDigitizerMajorRadius, pointInfo->pathMajorRadius); |
| IOHIDEventSetFloatValue(subEvent.get(), kIOHIDEventFieldDigitizerMinorRadius, pointInfo->pathMajorRadius); |
| |
| IOHIDEventAppendEvent(eventRef.get(), subEvent.get(), 0); |
| } |
| |
| return eventRef.leakRef(); |
| } |
| |
| - (BOOL)_sendHIDEvent:(IOHIDEventRef)eventRef |
| { |
| if (!_ioSystemClient) |
| _ioSystemClient = IOHIDEventSystemClientCreate(kCFAllocatorDefault); |
| |
| if (eventRef) { |
| RetainPtr<IOHIDEventRef> strongEvent = eventRef; |
| dispatch_async(dispatch_get_main_queue(), ^{ |
| uint32_t contextID = [UIApplication sharedApplication].keyWindow._contextId; |
| ASSERT(contextID); |
| BKSHIDEventSetDigitizerInfo(strongEvent.get(), contextID, false, false, NULL, 0, 0); |
| [[UIApplication sharedApplication] _enqueueHIDEvent:strongEvent.get()]; |
| }); |
| } |
| return YES; |
| } |
| |
| - (BOOL)_sendMarkerHIDEventWithCompletionBlock:(void (^)(void))completionBlock |
| { |
| unsigned callbackID = [HIDEventGenerator nextEventCallbackID]; |
| void (^completionBlockCopy)() = Block_copy(completionBlock); |
| [_eventCallbacks setObject:completionBlockCopy forKey:@(callbackID)]; |
| |
| uint64_t machTime = mach_absolute_time(); |
| RetainPtr<IOHIDEventRef> markerEvent = adoptCF(IOHIDEventCreateVendorDefinedEvent(kCFAllocatorDefault, |
| machTime, |
| kHIDPage_VendorDefinedStart + 100, |
| 0, |
| 1, |
| (uint8_t*)&callbackID, |
| sizeof(unsigned), |
| kIOHIDEventOptionNone)); |
| |
| if (markerEvent) { |
| markerEvent.get(); |
| dispatch_async(dispatch_get_main_queue(), ^{ |
| uint32_t contextID = [UIApplication sharedApplication].keyWindow._contextId; |
| ASSERT(contextID); |
| BKSHIDEventSetDigitizerInfo(markerEvent.get(), contextID, false, false, NULL, 0, 0); |
| [[UIApplication sharedApplication] _enqueueHIDEvent:markerEvent.get()]; |
| }); |
| } |
| return YES; |
| } |
| |
| - (void)_updateTouchPoints:(CGPoint*)points count:(NSUInteger)count |
| { |
| HandEventType handEventType; |
| |
| // The hand event type is based on previous state. |
| if (!_activePointCount) |
| handEventType = HandEventTouched; |
| else if (!count) |
| handEventType = HandEventLifted; |
| else if (count == _activePointCount) |
| handEventType = HandEventMoved; |
| else |
| handEventType = HandEventChordChanged; |
| |
| // Update previous count for next event. |
| _activePointCount = count; |
| |
| // Update point locations. |
| for (NSUInteger i = 0; i < count; ++i) { |
| _activePoints[i].point = points[i]; |
| [[GeneratedTouchesDebugWindow sharedGeneratedTouchesDebugWindow] updateDebugIndicatorForTouch:i withPointInWindowCoordinates:points[i] isTouching:YES]; |
| } |
| |
| RetainPtr<IOHIDEventRef> eventRef = adoptCF([self _createIOHIDEventType:handEventType]); |
| [self _sendHIDEvent:eventRef.get()]; |
| } |
| |
| - (void)touchDownAtPoints:(CGPoint*)locations touchCount:(NSUInteger)touchCount |
| { |
| touchCount = std::min(touchCount, HIDMaxTouchCount); |
| |
| _activePointCount = touchCount; |
| |
| for (NSUInteger index = 0; index < touchCount; ++index) { |
| _activePoints[index].point = locations[index]; |
| _activePoints[index].isStylus = NO; |
| |
| [[GeneratedTouchesDebugWindow sharedGeneratedTouchesDebugWindow] updateDebugIndicatorForTouch:index withPointInWindowCoordinates:locations[index] isTouching:YES]; |
| } |
| |
| RetainPtr<IOHIDEventRef> eventRef = adoptCF([self _createIOHIDEventType:HandEventTouched]); |
| [self _sendHIDEvent:eventRef.get()]; |
| } |
| |
| - (void)touchDown:(CGPoint)location touchCount:(NSUInteger)touchCount |
| { |
| touchCount = std::min(touchCount, HIDMaxTouchCount); |
| |
| CGPoint locations[touchCount]; |
| |
| for (NSUInteger index = 0; index < touchCount; ++index) |
| locations[index] = location; |
| |
| [self touchDownAtPoints:locations touchCount:touchCount]; |
| } |
| |
| - (void)touchDown:(CGPoint)location |
| { |
| [self touchDownAtPoints:&location touchCount:1]; |
| } |
| |
| - (void)liftUpAtPoints:(CGPoint*)locations touchCount:(NSUInteger)touchCount |
| { |
| touchCount = std::min(touchCount, HIDMaxTouchCount); |
| touchCount = std::min(touchCount, _activePointCount); |
| |
| NSUInteger newPointCount = _activePointCount - touchCount; |
| |
| for (NSUInteger index = 0; index < touchCount; ++index) { |
| _activePoints[newPointCount + index].point = locations[index]; |
| |
| [[GeneratedTouchesDebugWindow sharedGeneratedTouchesDebugWindow] updateDebugIndicatorForTouch:index withPointInWindowCoordinates:CGPointZero isTouching:NO]; |
| } |
| |
| RetainPtr<IOHIDEventRef> eventRef = adoptCF([self _createIOHIDEventType:HandEventLifted]); |
| [self _sendHIDEvent:eventRef.get()]; |
| |
| _activePointCount = newPointCount; |
| } |
| |
| - (void)liftUp:(CGPoint)location touchCount:(NSUInteger)touchCount |
| { |
| touchCount = std::min(touchCount, HIDMaxTouchCount); |
| |
| CGPoint locations[touchCount]; |
| |
| for (NSUInteger index = 0; index < touchCount; ++index) |
| locations[index] = location; |
| |
| [self liftUpAtPoints:locations touchCount:touchCount]; |
| } |
| |
| - (void)liftUp:(CGPoint)location |
| { |
| [self liftUp:location touchCount:1]; |
| } |
| |
| - (void)moveToPoints:(CGPoint*)newLocations touchCount:(NSUInteger)touchCount duration:(NSTimeInterval)seconds |
| { |
| touchCount = std::min(touchCount, HIDMaxTouchCount); |
| |
| CGPoint startLocations[touchCount]; |
| CGPoint nextLocations[touchCount]; |
| |
| CFAbsoluteTime startTime = CFAbsoluteTimeGetCurrent(); |
| CFTimeInterval elapsed = 0; |
| |
| int eventIndex = 0; |
| while (elapsed < (seconds - fingerMoveInterval)) { |
| elapsed = secondsSinceAbsoluteTime(startTime); |
| CFTimeInterval interval = elapsed / seconds; |
| |
| for (NSUInteger i = 0; i < touchCount; ++i) { |
| if (!eventIndex) |
| startLocations[i] = _activePoints[i].point; |
| |
| nextLocations[i] = calculateNextCurveLocation(startLocations[i], newLocations[i], interval); |
| } |
| [self _updateTouchPoints:nextLocations count:touchCount]; |
| |
| delayBetweenMove(eventIndex++, elapsed); |
| } |
| |
| [self _updateTouchPoints:newLocations count:touchCount]; |
| } |
| |
| - (void)touchDown:(CGPoint)location touchCount:(NSUInteger)count completionBlock:(void (^)(void))completionBlock |
| { |
| [self touchDown:location touchCount:count]; |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlock]; |
| } |
| |
| - (void)liftUp:(CGPoint)location touchCount:(NSUInteger)count completionBlock:(void (^)(void))completionBlock |
| { |
| [self liftUp:location touchCount:count]; |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlock]; |
| } |
| |
| - (void)stylusDownAtPoint:(CGPoint)location azimuthAngle:(CGFloat)azimuthAngle altitudeAngle:(CGFloat)altitudeAngle pressure:(CGFloat)pressure |
| { |
| _activePointCount = 1; |
| _activePoints[0].point = location; |
| _activePoints[0].isStylus = YES; |
| |
| // At the time of writing, the IOKit documentation isn't always correct. For example |
| // it says that pressure is a value [0,1], but in practice it is [0,500] for stylus |
| // data. It does not mention that the azimuth angle is offset from a full rotation. |
| // Also, UIKit and IOHID interpret the altitude as different adjacent angles. |
| _activePoints[0].pathPressure = pressure * 500; |
| _activePoints[0].azimuthAngle = M_PI * 2 - azimuthAngle; |
| _activePoints[0].altitudeAngle = M_PI_2 - altitudeAngle; |
| |
| RetainPtr<IOHIDEventRef> eventRef = adoptCF([self _createIOHIDEventType:StylusEventTouched]); |
| [self _sendHIDEvent:eventRef.get()]; |
| } |
| |
| - (void)stylusMoveToPoint:(CGPoint)location azimuthAngle:(CGFloat)azimuthAngle altitudeAngle:(CGFloat)altitudeAngle pressure:(CGFloat)pressure |
| { |
| _activePointCount = 1; |
| _activePoints[0].point = location; |
| _activePoints[0].isStylus = YES; |
| // See notes above for details on these calculations. |
| _activePoints[0].pathPressure = pressure * 500; |
| _activePoints[0].azimuthAngle = M_PI * 2 - azimuthAngle; |
| _activePoints[0].altitudeAngle = M_PI_2 - altitudeAngle; |
| |
| RetainPtr<IOHIDEventRef> eventRef = adoptCF([self _createIOHIDEventType:StylusEventMoved]); |
| [self _sendHIDEvent:eventRef.get()]; |
| } |
| |
| - (void)stylusUpAtPoint:(CGPoint)location |
| { |
| _activePointCount = 1; |
| _activePoints[0].point = location; |
| _activePoints[0].isStylus = YES; |
| _activePoints[0].pathPressure = 0; |
| _activePoints[0].azimuthAngle = 0; |
| _activePoints[0].altitudeAngle = 0; |
| |
| RetainPtr<IOHIDEventRef> eventRef = adoptCF([self _createIOHIDEventType:StylusEventLifted]); |
| [self _sendHIDEvent:eventRef.get()]; |
| } |
| |
| - (void)stylusDownAtPoint:(CGPoint)location azimuthAngle:(CGFloat)azimuthAngle altitudeAngle:(CGFloat)altitudeAngle pressure:(CGFloat)pressure completionBlock:(void (^)(void))completionBlock |
| { |
| [self stylusDownAtPoint:location azimuthAngle:azimuthAngle altitudeAngle:altitudeAngle pressure:pressure]; |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlock]; |
| } |
| |
| - (void)stylusMoveToPoint:(CGPoint)location azimuthAngle:(CGFloat)azimuthAngle altitudeAngle:(CGFloat)altitudeAngle pressure:(CGFloat)pressure completionBlock:(void (^)(void))completionBlock |
| { |
| [self stylusMoveToPoint:location azimuthAngle:azimuthAngle altitudeAngle:altitudeAngle pressure:pressure]; |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlock]; |
| } |
| |
| - (void)stylusUpAtPoint:(CGPoint)location completionBlock:(void (^)(void))completionBlock |
| { |
| [self stylusUpAtPoint:location]; |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlock]; |
| } |
| |
| - (void)stylusTapAtPoint:(CGPoint)location azimuthAngle:(CGFloat)azimuthAngle altitudeAngle:(CGFloat)altitudeAngle pressure:(CGFloat)pressure completionBlock:(void (^)(void))completionBlock |
| { |
| struct timespec pressDelay = { 0, static_cast<long>(fingerLiftDelay * nanosecondsPerSecond) }; |
| |
| [self stylusDownAtPoint:location azimuthAngle:azimuthAngle altitudeAngle:altitudeAngle pressure:pressure]; |
| nanosleep(&pressDelay, 0); |
| [self stylusUpAtPoint:location]; |
| |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlock]; |
| } |
| |
| - (void)sendTaps:(int)tapCount location:(CGPoint)location withNumberOfTouches:(int)touchCount completionBlock:(void (^)(void))completionBlock |
| { |
| struct timespec doubleDelay = { 0, static_cast<long>(multiTapInterval * nanosecondsPerSecond) }; |
| struct timespec pressDelay = { 0, static_cast<long>(fingerLiftDelay * nanosecondsPerSecond) }; |
| |
| for (int i = 0; i < tapCount; i++) { |
| [self touchDown:location touchCount:touchCount]; |
| nanosleep(&pressDelay, 0); |
| [self liftUp:location touchCount:touchCount]; |
| if (i + 1 != tapCount) |
| nanosleep(&doubleDelay, 0); |
| } |
| |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlock]; |
| } |
| |
| - (void)tap:(CGPoint)location completionBlock:(void (^)(void))completionBlock |
| { |
| [self sendTaps:1 location:location withNumberOfTouches:1 completionBlock:completionBlock]; |
| } |
| |
| - (void)doubleTap:(CGPoint)location completionBlock:(void (^)(void))completionBlock |
| { |
| [self sendTaps:2 location:location withNumberOfTouches:1 completionBlock:completionBlock]; |
| } |
| |
| - (void)twoFingerTap:(CGPoint)location completionBlock:(void (^)(void))completionBlock |
| { |
| [self sendTaps:1 location:location withNumberOfTouches:2 completionBlock:completionBlock]; |
| } |
| |
| - (void)longPress:(CGPoint)location completionBlock:(void (^)(void))completionBlock |
| { |
| [self touchDown:location touchCount:1]; |
| auto completionBlockCopy = makeBlockPtr(completionBlock); |
| |
| dispatch_after(dispatch_time(DISPATCH_TIME_NOW, longPressHoldDelay * nanosecondsPerSecond), dispatch_get_main_queue(), ^ { |
| [self liftUp:location]; |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlockCopy.get()]; |
| }); |
| } |
| |
| - (void)dragWithStartPoint:(CGPoint)startLocation endPoint:(CGPoint)endLocation duration:(double)seconds completionBlock:(void (^)(void))completionBlock |
| { |
| [self touchDown:startLocation touchCount:1]; |
| [self moveToPoints:&endLocation touchCount:1 duration:seconds]; |
| [self liftUp:endLocation]; |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlock]; |
| } |
| |
| - (void)pinchCloseWithStartPoint:(CGPoint)startLocation endPoint:(CGPoint)endLocation duration:(double)seconds completionBlock:(void (^)(void))completionBlock |
| { |
| } |
| |
| - (void)pinchOpenWithStartPoint:(CGPoint)startLocation endPoint:(CGPoint)endLocation duration:(double)seconds completionBlock:(void (^)(void))completionBlock |
| { |
| } |
| |
| - (void)markerEventReceived:(IOHIDEventRef)event |
| { |
| if (IOHIDEventGetType(event) != kIOHIDEventTypeVendorDefined) |
| return; |
| |
| CFIndex callbackID = IOHIDEventGetIntegerValue(event, kIOHIDEventFieldVendorDefinedData); |
| void (^completionBlock)() = [_eventCallbacks objectForKey:@(callbackID)]; |
| if (completionBlock) { |
| [_eventCallbacks removeObjectForKey:@(callbackID)]; |
| completionBlock(); |
| Block_release(completionBlock); |
| } |
| } |
| |
| - (BOOL)checkForOutstandingCallbacks |
| { |
| return !([_eventCallbacks count] > 0); |
| } |
| |
| static inline bool shouldWrapWithShiftKeyEventForCharacter(NSString *key) |
| { |
| if (key.length != 1) |
| return false; |
| int keyCode = [key characterAtIndex:0]; |
| if (65 <= keyCode && keyCode <= 90) |
| return true; |
| switch (keyCode) { |
| case '`': |
| case '!': |
| case '@': |
| case '#': |
| case '$': |
| case '%': |
| case '^': |
| case '&': |
| case '*': |
| case '(': |
| case ')': |
| case '_': |
| case '+': |
| case '{': |
| case '}': |
| case '|': |
| case ':': |
| case '"': |
| case '<': |
| case '>': |
| case '?': |
| case '~': |
| return true; |
| } |
| return false; |
| } |
| |
| static inline uint32_t hidUsageCodeForCharacter(NSString *key) |
| { |
| const int uppercaseAlphabeticOffset = 'A' - kHIDUsage_KeyboardA; |
| const int lowercaseAlphabeticOffset = 'a' - kHIDUsage_KeyboardA; |
| const int numericNonZeroOffset = '1' - kHIDUsage_Keyboard1; |
| if (key.length == 1) { |
| // Handle alphanumeric characters and basic symbols. |
| int keyCode = [key characterAtIndex:0]; |
| if (97 <= keyCode && keyCode <= 122) // Handle a-z. |
| return keyCode - lowercaseAlphabeticOffset; |
| |
| if (65 <= keyCode && keyCode <= 90) // Handle A-Z. |
| return keyCode - uppercaseAlphabeticOffset; |
| |
| if (49 <= keyCode && keyCode <= 57) // Handle 1-9. |
| return keyCode - numericNonZeroOffset; |
| |
| // Handle all other cases. |
| switch (keyCode) { |
| case '`': |
| case '~': |
| return kHIDUsage_KeyboardGraveAccentAndTilde; |
| case '!': |
| return kHIDUsage_Keyboard1; |
| case '@': |
| return kHIDUsage_Keyboard2; |
| case '#': |
| return kHIDUsage_Keyboard3; |
| case '$': |
| return kHIDUsage_Keyboard4; |
| case '%': |
| return kHIDUsage_Keyboard5; |
| case '^': |
| return kHIDUsage_Keyboard6; |
| case '&': |
| return kHIDUsage_Keyboard7; |
| case '*': |
| return kHIDUsage_Keyboard8; |
| case '(': |
| return kHIDUsage_Keyboard9; |
| case ')': |
| case '0': |
| return kHIDUsage_Keyboard0; |
| case '-': |
| case '_': |
| return kHIDUsage_KeyboardHyphen; |
| case '=': |
| case '+': |
| return kHIDUsage_KeyboardEqualSign; |
| case '\t': |
| return kHIDUsage_KeyboardTab; |
| case '[': |
| case '{': |
| return kHIDUsage_KeyboardOpenBracket; |
| case ']': |
| case '}': |
| return kHIDUsage_KeyboardCloseBracket; |
| case '\\': |
| case '|': |
| return kHIDUsage_KeyboardBackslash; |
| case ';': |
| case ':': |
| return kHIDUsage_KeyboardSemicolon; |
| case '\'': |
| case '"': |
| return kHIDUsage_KeyboardQuote; |
| case '\r': |
| case '\n': |
| return kHIDUsage_KeyboardReturnOrEnter; |
| case ',': |
| case '<': |
| return kHIDUsage_KeyboardComma; |
| case '.': |
| case '>': |
| return kHIDUsage_KeyboardPeriod; |
| case '/': |
| case '?': |
| return kHIDUsage_KeyboardSlash; |
| case ' ': |
| return kHIDUsage_KeyboardSpacebar; |
| } |
| } |
| const int functionKeyOffset = kHIDUsage_KeyboardF1; |
| for (int functionKeyIndex = 1; functionKeyIndex <= 12; ++functionKeyIndex) { |
| if ([key isEqualToString:[NSString stringWithFormat:@"F%d", functionKeyIndex]]) |
| return functionKeyOffset + functionKeyIndex - 1; |
| } |
| if ([key isEqualToString:@"escape"]) |
| return kHIDUsage_KeyboardEscape; |
| if ([key isEqualToString:@"return"] || [key isEqualToString:@"enter"]) |
| return kHIDUsage_KeyboardReturnOrEnter; |
| if ([key isEqualToString:@"leftArrow"]) |
| return kHIDUsage_KeyboardLeftArrow; |
| if ([key isEqualToString:@"rightArrow"]) |
| return kHIDUsage_KeyboardRightArrow; |
| if ([key isEqualToString:@"upArrow"]) |
| return kHIDUsage_KeyboardUpArrow; |
| if ([key isEqualToString:@"downArrow"]) |
| return kHIDUsage_KeyboardDownArrow; |
| if ([key isEqualToString:@"delete"]) |
| return kHIDUsage_KeyboardDeleteOrBackspace; |
| // The simulator keyboard interprets both left and right modifier keys using the left version of the usage code. |
| if ([key isEqualToString:@"leftControl"] || [key isEqualToString:@"rightControl"]) |
| return kHIDUsage_KeyboardLeftControl; |
| if ([key isEqualToString:@"leftShift"] || [key isEqualToString:@"rightShift"]) |
| return kHIDUsage_KeyboardLeftShift; |
| if ([key isEqualToString:@"leftAlt"] || [key isEqualToString:@"rightAlt"]) |
| return kHIDUsage_KeyboardLeftAlt; |
| |
| return 0; |
| } |
| |
| - (void)keyPress:(NSString *)character completionBlock:(void (^)(void))completionBlock |
| { |
| bool shouldWrapWithShift = shouldWrapWithShiftKeyEventForCharacter(character); |
| uint32_t usage = hidUsageCodeForCharacter(character); |
| uint64_t absoluteMachTime = mach_absolute_time(); |
| |
| if (shouldWrapWithShift) |
| [self _sendIOHIDKeyboardEvent:absoluteMachTime usage:kHIDUsage_KeyboardLeftShift isKeyDown:true]; |
| |
| [self _sendIOHIDKeyboardEvent:absoluteMachTime usage:usage isKeyDown:true]; |
| [self _sendIOHIDKeyboardEvent:absoluteMachTime usage:usage isKeyDown:false]; |
| |
| if (shouldWrapWithShift) |
| [self _sendIOHIDKeyboardEvent:absoluteMachTime usage:kHIDUsage_KeyboardLeftShift isKeyDown:false]; |
| |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlock]; |
| } |
| |
| - (void)keyDown:(NSString *)character completionBlock:(void (^)(void))completionBlock |
| { |
| bool shouldWrapWithShift = shouldWrapWithShiftKeyEventForCharacter(character); |
| uint32_t usage = hidUsageCodeForCharacter(character); |
| uint64_t absoluteMachTime = mach_absolute_time(); |
| |
| if (shouldWrapWithShift) |
| [self _sendIOHIDKeyboardEvent:absoluteMachTime usage:kHIDUsage_KeyboardLeftShift isKeyDown:true]; |
| |
| [self _sendIOHIDKeyboardEvent:absoluteMachTime usage:usage isKeyDown:true]; |
| |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlock]; |
| } |
| |
| - (void)keyUp:(NSString *)character completionBlock:(void (^)(void))completionBlock |
| { |
| bool shouldWrapWithShift = shouldWrapWithShiftKeyEventForCharacter(character); |
| uint32_t usage = hidUsageCodeForCharacter(character); |
| uint64_t absoluteMachTime = mach_absolute_time(); |
| |
| [self _sendIOHIDKeyboardEvent:absoluteMachTime usage:usage isKeyDown:false]; |
| |
| if (shouldWrapWithShift) |
| [self _sendIOHIDKeyboardEvent:absoluteMachTime usage:kHIDUsage_KeyboardLeftShift isKeyDown:false]; |
| |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlock]; |
| } |
| |
| - (void)dispatchEventWithInfo:(NSDictionary *)eventInfo |
| { |
| ASSERT([NSThread isMainThread]); |
| |
| RetainPtr<IOHIDEventRef> eventRef = adoptCF([self _createIOHIDEventWithInfo:eventInfo]); |
| [self _sendHIDEvent:eventRef.get()]; |
| } |
| |
| - (NSArray *)interpolatedEvents:(NSDictionary *)interpolationsDictionary |
| { |
| NSDictionary *startEvent = interpolationsDictionary[HIDEventStartEventKey]; |
| NSDictionary *endEvent = interpolationsDictionary[HIDEventEndEventKey]; |
| NSTimeInterval timeStep = [interpolationsDictionary[HIDEventTimestepKey] doubleValue]; |
| InterpolationType interpolationType = interpolationFromString(interpolationsDictionary[HIDEventInterpolateKey]); |
| |
| NSMutableArray *interpolatedEvents = [NSMutableArray arrayWithObject:startEvent]; |
| |
| NSTimeInterval startTime = [startEvent[HIDEventTimeOffsetKey] doubleValue]; |
| NSTimeInterval endTime = [endEvent[HIDEventTimeOffsetKey] doubleValue]; |
| NSTimeInterval time = startTime + timeStep; |
| |
| NSArray *startTouches = startEvent[HIDEventTouchesKey]; |
| NSArray *endTouches = endEvent[HIDEventTouchesKey]; |
| |
| while (time < endTime) { |
| NSMutableDictionary *newEvent = [endEvent mutableCopy]; |
| double timeRatio = (time - startTime) / (endTime - startTime); |
| newEvent[HIDEventTimeOffsetKey] = [NSNumber numberWithDouble:(time)]; |
| |
| NSEnumerator *startEnumerator = [startTouches objectEnumerator]; |
| NSDictionary *startTouch; |
| NSMutableArray *newTouches = [NSMutableArray arrayWithCapacity:[endTouches count]]; |
| while (startTouch = [startEnumerator nextObject]) { |
| NSEnumerator *endEnumerator = [endTouches objectEnumerator]; |
| NSDictionary *endTouch = [endEnumerator nextObject]; |
| NSInteger startTouchID = [startTouch[HIDEventTouchIDKey] integerValue]; |
| |
| while (endTouch && ([endTouch[HIDEventTouchIDKey] integerValue] != startTouchID)) |
| endTouch = [endEnumerator nextObject]; |
| |
| if (endTouch) { |
| NSMutableDictionary *newTouch = [endTouch mutableCopy]; |
| |
| if (newTouch[HIDEventXKey] != startTouch[HIDEventXKey]) |
| newTouch[HIDEventXKey] = @(interpolations[interpolationType]([startTouch[HIDEventXKey] doubleValue], [endTouch[HIDEventXKey] doubleValue], timeRatio)); |
| |
| if (newTouch[HIDEventYKey] != startTouch[HIDEventYKey]) |
| newTouch[HIDEventYKey] = @(interpolations[interpolationType]([startTouch[HIDEventYKey] doubleValue], [endTouch[HIDEventYKey] doubleValue], timeRatio)); |
| |
| if (newTouch[HIDEventPressureKey] != startTouch[HIDEventPressureKey]) |
| newTouch[HIDEventPressureKey] = @(interpolations[interpolationType]([startTouch[HIDEventPressureKey] doubleValue], [endTouch[HIDEventPressureKey] doubleValue], timeRatio)); |
| |
| [newTouches addObject:newTouch]; |
| [newTouch release]; |
| } else |
| NSLog(@"Missing End Touch with ID: %ld", (long)startTouchID); |
| } |
| |
| newEvent[HIDEventTouchesKey] = newTouches; |
| |
| [interpolatedEvents addObject:newEvent]; |
| [newEvent release]; |
| time += timeStep; |
| } |
| |
| [interpolatedEvents addObject:endEvent]; |
| |
| return interpolatedEvents; |
| } |
| |
| - (NSArray *)expandEvents:(NSArray *)events withStartTime:(CFAbsoluteTime)startTime |
| { |
| NSMutableArray *expandedEvents = [NSMutableArray array]; |
| for (NSDictionary *event in events) { |
| NSString *interpolate = event[HIDEventInterpolateKey]; |
| // we have key events that we need to generate |
| if (interpolate) { |
| NSArray *newEvents = [self interpolatedEvents:event]; |
| [expandedEvents addObjectsFromArray:[self expandEvents:newEvents withStartTime:startTime]]; |
| } else |
| [expandedEvents addObject:event]; |
| } |
| return expandedEvents; |
| } |
| |
| - (void)eventDispatchThreadEntry:(NSDictionary *)threadData |
| { |
| NSDictionary *eventStream = threadData[@"eventInfo"]; |
| void (^completionBlock)() = threadData[@"completionBlock"]; |
| |
| NSArray *events = eventStream[TopLevelEventInfoKey]; |
| if (!events.count) { |
| NSLog(@"No events found in event stream"); |
| return; |
| } |
| |
| CFAbsoluteTime startTime = CFAbsoluteTimeGetCurrent(); |
| |
| NSArray *expandedEvents = [self expandEvents:events withStartTime:startTime]; |
| |
| for (NSDictionary *eventInfo in expandedEvents) { |
| NSTimeInterval eventRelativeTime = [eventInfo[HIDEventTimeOffsetKey] doubleValue]; |
| CFAbsoluteTime targetTime = startTime + eventRelativeTime; |
| |
| CFTimeInterval waitTime = targetTime - CFAbsoluteTimeGetCurrent(); |
| if (waitTime > 0) |
| [NSThread sleepForTimeInterval:waitTime]; |
| |
| dispatch_async(dispatch_get_main_queue(), ^ { |
| [self dispatchEventWithInfo:eventInfo]; |
| }); |
| } |
| |
| dispatch_async(dispatch_get_main_queue(), ^ { |
| [self _sendMarkerHIDEventWithCompletionBlock:completionBlock]; |
| }); |
| } |
| |
| - (void)sendEventStream:(NSDictionary *)eventInfo completionBlock:(void (^)(void))completionBlock |
| { |
| if (!eventInfo) { |
| NSLog(@"eventInfo is nil"); |
| if (completionBlock) |
| completionBlock(); |
| return; |
| } |
| |
| NSDictionary* threadData = @{ |
| @"eventInfo": [eventInfo copy], |
| @"completionBlock": [[completionBlock copy] autorelease] |
| }; |
| |
| NSThread *eventDispatchThread = [[[NSThread alloc] initWithTarget:self selector:@selector(eventDispatchThreadEntry:) object:threadData] autorelease]; |
| eventDispatchThread.qualityOfService = NSQualityOfServiceUserInteractive; |
| [eventDispatchThread start]; |
| } |
| |
| @end |
