void
osxHIDPointingDevice::hidQueueCallback(void *context, IOReturn /*result*/, void *sender) {
// std::cerr << "osxHIDPointingDevice::hidQueueCallback" << std::endl ;
osxHIDPointingDevice *self = (osxHIDPointingDevice*)context ;
IOHIDQueueRef queue = (IOHIDQueueRef)sender ;
while (true) {
IOHIDValueRef hidvalue = IOHIDQueueCopyNextValueWithTimeout(queue, 0.) ;
if (!hidvalue) break ;
#if 1
TimeStamp::inttime uptime = AbsoluteTimeInNanoseconds(IOHIDValueGetTimeStamp(hidvalue)) ;
TimeStamp::inttime timestamp = self->epoch + (uptime - self->epoch_mach)*TimeStamp::one_nanosecond ;
#else
TimeStamp::inttime timestamp = TimeStamp::createAsInt() ;
#endif
if (self->qreport.isOlderThan(timestamp)) {
// Flush the old qreport before creating a new one
self->report(self->qreport) ;
self->qreport.clear() ;
}
IOHIDElementRef element = IOHIDValueGetElement(hidvalue) ;
uint32_t usagepage = IOHIDElementGetUsagePage(element) ;
uint32_t usage = IOHIDElementGetUsage(element) ;
//std::cout << usagepage << std::endl;
//std::cout << usage << std::endl;
if (usagepage==kHIDPage_GenericDesktop) {
if (usage==kHIDUsage_GD_X || usage==kHIDUsage_GD_Y) {
// Could use IOHIDValueGetScaledValue(hidvalue, kIOHIDValueScaleTypePhysical)
CFIndex d = IOHIDValueGetIntegerValue(hidvalue) ;
//std::cout << IOHIDValueGetBytePtr(hidvalue) << std::endl;
//std::cout << IOHIDValueGetLength(hidvalue) << std::endl;
if (d) {
if (usage==kHIDUsage_GD_X) self->qreport.dx = (int32_t)d ; else self->qreport.dy = (int32_t)d ;
self->qreport.t = timestamp ;
}
}
// FIXME: GD_Z, GD_Wheel, etc.
} else if (usagepage==kHIDPage_Button) {
// kHIDUsage_Button_1 is 1
self->qreport.setButton(usage-1, (uint32_t)IOHIDValueGetIntegerValue(hidvalue)) ;
self->qreport.t = timestamp ;
}
CFRelease(hidvalue) ;
}
// Flush the qreport we were constructing, if any
if (self->qreport.t!=TimeStamp::undef)
self->report(self->qreport) ;
self->qreport.clear() ;
}
// ---------------------------------
// Get the next event in the queue for a device
// elements or entire device should be queued prior to calling this with HIDQueueElement or HIDQueueDevice
// returns true if an event is avialable for the element and fills out *pHIDEvent structure, returns false otherwise
// Note: kIOReturnUnderrun returned from getNextEvent indicates an empty queue not an error condition
// Note: application should pass in a pointer to a IOHIDEventStruct cast to a void (for CFM compatibility)
unsigned char HIDGetEvent(IOHIDDeviceRef inIOHIDDeviceRef, IOHIDValueRef *pIOHIDValueRef) {
if (inIOHIDDeviceRef) {
IOHIDQueueRef tIOHIDQueueRef = IOHIDDevice_GetQueue(inIOHIDDeviceRef);
if (tIOHIDQueueRef) {
if (pIOHIDValueRef) {
*pIOHIDValueRef = IOHIDQueueCopyNextValueWithTimeout(tIOHIDQueueRef, 0.0);
if (*pIOHIDValueRef) {
return (true);
}
}
} else {
HIDReportError( "Could not get HID event, hid queue reference does not exist.");
}
} else {
HIDReportError( "Could not get HID event, device does not exist.");
}
return (false); // did not get event
} /* HIDGetEvent */
static void PsychHIDKbQueueCallbackFunction(void *target, IOReturn result, void *sender)
{
// This routine is executed each time the queue transitions from empty to non-empty
// The CFRunLoop of the thread in KbQueueWorkerThreadMain() is the one that executes here:
IOHIDQueueRef queue = (IOHIDQueueRef) sender;
IOHIDValueRef valueRef = NULL;
int deviceIndex = (int) target;
double timestamp;
int eventValue;
long keysUsage = -1;
PsychHIDEventRecord evt;
result=kIOReturnError;
if (!queue) return; // Nothing we can do because we can't access queue, (shouldn't happen)
while (1) {
// This function only gets called when queue transitions from empty to non-empty
// Therefore, we must process all available events in this while loop before
// it will be possible for this function to be notified again.
if (valueRef) {
CFRelease(valueRef);
valueRef = NULL;
}
// Dequeue next event from queue in a polling non-blocking fashion:
valueRef = IOHIDQueueCopyNextValueWithTimeout(queue, 0.0);
// Done? Exit, if so:
if (!valueRef) break;
// Get event value, e.g., the key state of a key or button 1 = pressed, 0 = released:
eventValue = IOHIDValueGetIntegerValue(valueRef);
// Get usage value, ie., the identity of the key:
IOHIDElementRef element = IOHIDValueGetElement(valueRef);
keysUsage = IOHIDElementGetUsage(element);
// Get double GetSecs timestamp, computed from returned uint64 nanoseconds timestamp:
timestamp = convertTime(IOHIDValueGetTimeStamp(valueRef));
// Don't bother with keysUsage of 0 (meaningless) or 1 (ErrorRollOver) for keyboards:
if ((queueIsAKeyboard[deviceIndex]) && (keysUsage <= 1)) continue;
// Clear ringbuffer event:
memset(&evt, 0 , sizeof(evt));
// Cooked key code defaults to "unhandled", and stays that way for anything but keyboards:
evt.cookedEventCode = -1;
// For real keyboards we can compute cooked key codes: Requires OSX 10.5 or later.
if (queueIsAKeyboard[deviceIndex]) {
// Keyboard(ish) device. We can handle this under some conditions.
// Init to a default of handled, but unmappable/ignored keycode:
evt.cookedEventCode = 0;
// Keypress event code available in mapping table?
if (keysUsage < kHID2VKCSize) {
// Yes: We try to map this to a character code:
// Step 1: Map HID usage value to virtual keycode via LUT:
uint16_t vcKey = kHID2VKC[keysUsage];
// Keep track of SHIFT keys as modifier keys: Bits 0 == Command, 1 == Shift, 2 == CapsLock, 3 == Alt/Option, 4 == CTRL
if ((vcKey == kVKC_Shift || vcKey == kVKC_rShift) && (eventValue != 0)) modifierKeyState[deviceIndex] |= (1 << 1);
if ((vcKey == kVKC_Shift || vcKey == kVKC_rShift) && (eventValue == 0)) modifierKeyState[deviceIndex] &= ~(1 << 1);
// Keep track of ALT keys as modifier keys:
if ((vcKey == kVKC_Option || vcKey == kVKC_rOption) && (eventValue != 0)) modifierKeyState[deviceIndex] |= (1 << 3);
if ((vcKey == kVKC_Option || vcKey == kVKC_rOption) && (eventValue == 0)) modifierKeyState[deviceIndex] &= ~(1 << 3);
// Keep track of CTRL keys as modifier keys:
if ((vcKey == kVKC_Control || vcKey == kVKC_rControl) && (eventValue != 0)) modifierKeyState[deviceIndex] |= (1 << 4);
if ((vcKey == kVKC_Control || vcKey == kVKC_rControl) && (eventValue == 0)) modifierKeyState[deviceIndex] &= ~(1 << 4);
// Was this a CTRL + C interrupt request?
if ((eventValue != 0) && (vcKey == 0x08) && (modifierKeyState[deviceIndex] & (1 << 4))) {
// Yes: Tell the console input helper about it, so it can send interrupt
// signals to the runtime and reenable keyboard input if appropriate:
// Note: Not sure if the mutex exclusion is needed here, but better safe than sorry.
PsychLockMutex(&KbQueueMutex);
ConsoleInputHelper(-1);
PsychUnlockMutex(&KbQueueMutex);
}
// Key press?
if (eventValue != 0) {
// Step 2: Translate virtual key code into unicode char:
// Ok, this is the usual horrifying complexity of Apple's system. We use code
// snippets found on StackOverflow, modified to suit our needs, e.g., we track
// modifier keys manually, at least left and right ALT and SHIFT keys. We don't
// care about other modifiers.
TISInputSourceRef currentKeyboard = TISCopyCurrentKeyboardInputSource();
CFDataRef uchr = (CFDataRef) ((currentKeyboard) ? TISGetInputSourceProperty(currentKeyboard, kTISPropertyUnicodeKeyLayoutData) : NULL);
const UCKeyboardLayout *keyboardLayout = (const UCKeyboardLayout*) ((uchr) ? CFDataGetBytePtr(uchr) : NULL);
if (keyboardLayout) {
UInt32 deadKeyState = 0;
UniCharCount maxStringLength = 255;
UniCharCount actualStringLength = 0;
UniChar unicodeString[maxStringLength];
OSStatus status = UCKeyTranslate(keyboardLayout,
vcKey, kUCKeyActionDown, modifierKeyState[deviceIndex],
LMGetKbdType(), 0,
&deadKeyState,
maxStringLength,
&actualStringLength, unicodeString);
if ((actualStringLength == 0) && deadKeyState) {
status = UCKeyTranslate(keyboardLayout,
kVK_Space, kUCKeyActionDown, 0,
LMGetKbdType(), 0,
&deadKeyState,
maxStringLength,
&actualStringLength, unicodeString);
}
if((actualStringLength > 0) && (status == noErr)) {
// Assign final cooked / mapped keycode:
evt.cookedEventCode = (int) unicodeString[0];
// Send same keystroke character to console input helper.
// In kbqueue-based ListenChar(1) mode, the helper will
// inject/forward the character into the runtime:
// Note: ConsoleInputHelper() should be safe to call without
// mutex protection for >= 0 event codes.
ConsoleInputHelper(evt.cookedEventCode);
}
}
}
}
}
PsychLockMutex(&KbQueueMutex);
// Update records of first and latest key presses and releases
if (eventValue != 0) {
if (psychHIDKbQueueFirstPress[deviceIndex]) {
// First key press timestamp:
if (psychHIDKbQueueFirstPress[deviceIndex][keysUsage-1] == 0) {
psychHIDKbQueueFirstPress[deviceIndex][keysUsage-1] = timestamp;
}
}
if (psychHIDKbQueueLastPress[deviceIndex]) {
// Last key press timestamp:
psychHIDKbQueueLastPress[deviceIndex][keysUsage-1] = timestamp;
}
evt.status |= (1 << 0);
}
else {
if (psychHIDKbQueueFirstRelease[deviceIndex]) {
// First key release timestamp:
if (psychHIDKbQueueFirstRelease[deviceIndex][keysUsage-1] == 0) psychHIDKbQueueFirstRelease[deviceIndex][keysUsage-1] = timestamp;
}
if (psychHIDKbQueueLastRelease[deviceIndex]) {
// Last key release timestamp:
psychHIDKbQueueLastRelease[deviceIndex][keysUsage-1] = timestamp;
}
evt.status &= ~(1 << 0);
}
// Update event buffer:
evt.timestamp = timestamp;
evt.rawEventCode = keysUsage;
PsychHIDAddEventToEventBuffer(deviceIndex, &evt);
// Tell waiting userspace (under KbQueueMutxex protection for better scheduling) something interesting has changed:
PsychSignalCondition(&KbQueueCondition);
PsychUnlockMutex(&KbQueueMutex);
// Next while loop iteration to dequeue potentially more events:
}
// Done for this queue transition. Return to runloop.
}
