mirror of https://github.com/ZDoom/gzdoom-gles.git
Added HID Utilities source code
https://developer.apple.com/library/mac/samplecode/HID_Utilities/Introduction/Intro.html https://developer.apple.com/library/mac/samplecode/HID_Utilities/HID_Utilities.zip
This commit is contained in:
alexey.lysiuk
parent
2efb62e8ef
commit
906102c3b6
|
|
@ -0,0 +1,919 @@
|
|||
// File: HID_Config_Utilities.c
|
||||
// Abstract: Implementation of the HID configuration utilities
|
||||
// Version: 2.0
|
||||
//
|
||||
// Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
|
||||
// Inc. ("Apple") in consideration of your agreement to the following
|
||||
// terms, and your use, installation, modification or redistribution of
|
||||
// this Apple software constitutes acceptance of these terms. If you do
|
||||
// not agree with these terms, please do not use, install, modify or
|
||||
// redistribute this Apple software.
|
||||
//
|
||||
// In consideration of your agreement to abide by the following terms, and
|
||||
// subject to these terms, Apple grants you a personal, non-exclusive
|
||||
// license, under Apple's copyrights in this original Apple software (the
|
||||
// "Apple Software"), to use, reproduce, modify and redistribute the Apple
|
||||
// Software, with or without modifications, in source and/or binary forms;
|
||||
// provided that if you redistribute the Apple Software in its entirety and
|
||||
// without modifications, you must retain this notice and the following
|
||||
// text and disclaimers in all such redistributions of the Apple Software.
|
||||
// Neither the name, trademarks, service marks or logos of Apple Inc. may
|
||||
// be used to endorse or promote products derived from the Apple Software
|
||||
// without specific prior written permission from Apple. Except as
|
||||
// expressly stated in this notice, no other rights or licenses, express or
|
||||
// implied, are granted by Apple herein, including but not limited to any
|
||||
// patent rights that may be infringed by your derivative works or by other
|
||||
// works in which the Apple Software may be incorporated.
|
||||
//
|
||||
// The Apple Software is provided by Apple on an "AS IS" basis. APPLE
|
||||
// MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
|
||||
// THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
|
||||
// OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
|
||||
//
|
||||
// IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
|
||||
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
|
||||
// MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
|
||||
// AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
|
||||
// STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (C) 2009 Apple Inc. All Rights Reserved.
|
||||
//
|
||||
//*****************************************************
|
||||
#define LOG_SCORING 0
|
||||
|
||||
#include <stdlib.h> // malloc
|
||||
#include <time.h> // clock
|
||||
|
||||
#include <AssertMacros.h>
|
||||
|
||||
#include "HID_Utilities_External.h"
|
||||
|
||||
// ---------------------------------
|
||||
|
||||
// polls single device's elements for a change greater than kPercentMove. Times out after given time
|
||||
// returns 1 and pointer to element if found
|
||||
// returns 0 and NULL for both parameters if not found
|
||||
|
||||
unsigned char HIDConfigureSingleDeviceAction(IOHIDDeviceRef inIOHIDDeviceRef, IOHIDElementRef *outIOHIDElementRef, float timeout) {
|
||||
if ( !inIOHIDDeviceRef ) {
|
||||
return (0);
|
||||
}
|
||||
if ( 0 == HIDHaveDeviceList() ) { // if we do not have a device list
|
||||
return (0); // return 0
|
||||
}
|
||||
|
||||
Boolean found = FALSE;
|
||||
|
||||
// build list of device and elements to save current values
|
||||
int maxElements = HIDCountDeviceElements(inIOHIDDeviceRef, kHIDElementTypeInput);
|
||||
int *saveValueArray = (int *) calloc( maxElements, sizeof(int) ); // 2D array to save values
|
||||
|
||||
// store initial values on first pass / compare to initial value on subsequent passes
|
||||
Boolean first = TRUE;
|
||||
|
||||
// get all the elements from this device
|
||||
CFArrayRef elementCFArrayRef = IOHIDDeviceCopyMatchingElements(inIOHIDDeviceRef, NULL, kIOHIDOptionsTypeNone);
|
||||
// if that worked...
|
||||
if ( elementCFArrayRef ) {
|
||||
clock_t start = clock(), end;
|
||||
|
||||
// poll all devices and elements
|
||||
while ( !found ) {
|
||||
int currElementIndex = 0;
|
||||
CFIndex idx, cnt = CFArrayGetCount(elementCFArrayRef);
|
||||
for ( idx = 0; idx < cnt; idx++ ) {
|
||||
*outIOHIDElementRef = (IOHIDElementRef) CFArrayGetValueAtIndex(elementCFArrayRef, idx);
|
||||
if ( !*outIOHIDElementRef ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// is this an input element?
|
||||
IOHIDElementType type = IOHIDElementGetType(*outIOHIDElementRef);
|
||||
|
||||
switch ( type ) {
|
||||
// these types are inputs
|
||||
case kIOHIDElementTypeInput_Misc:
|
||||
case kIOHIDElementTypeInput_Button:
|
||||
case kIOHIDElementTypeInput_Axis:
|
||||
case kIOHIDElementTypeInput_ScanCodes:
|
||||
default:
|
||||
{
|
||||
break;
|
||||
}
|
||||
case kIOHIDElementTypeOutput:
|
||||
case kIOHIDElementTypeFeature:
|
||||
case kIOHIDElementTypeCollection:
|
||||
{
|
||||
*outIOHIDElementRef = NULL; // these types are not ( Skip them )
|
||||
break;
|
||||
}
|
||||
} /* switch */
|
||||
if ( !*outIOHIDElementRef ) {
|
||||
continue; // skip this element
|
||||
}
|
||||
|
||||
// get this elements current value
|
||||
int value = 0; // default value is zero
|
||||
IOHIDValueRef tIOHIDValueRef;
|
||||
IOReturn ioReturn = IOHIDDeviceGetValue(inIOHIDDeviceRef, *outIOHIDElementRef, &tIOHIDValueRef);
|
||||
if ( kIOReturnSuccess == ioReturn ) {
|
||||
value = IOHIDValueGetScaledValue(tIOHIDValueRef, kIOHIDValueScaleTypePhysical);
|
||||
}
|
||||
if ( first ) {
|
||||
saveValueArray[currElementIndex] = value;
|
||||
} else {
|
||||
CFIndex min = IOHIDElementGetLogicalMin(*outIOHIDElementRef);
|
||||
CFIndex max = IOHIDElementGetLogicalMax(*outIOHIDElementRef);
|
||||
|
||||
int initialValue = saveValueArray[currElementIndex];
|
||||
int delta = (float)(max - min) * kPercentMove * 0.01;
|
||||
// is the new value within +/- delta of the initial value?
|
||||
if ( ( (initialValue + delta) < value ) || ( (initialValue - delta) > value ) ) {
|
||||
found = 1; // ( yes! ) mark as found
|
||||
break;
|
||||
}
|
||||
} // if ( first )
|
||||
|
||||
currElementIndex++; // bump element index
|
||||
} // next idx
|
||||
|
||||
first = FALSE; // no longer the first pass
|
||||
|
||||
// are we done?
|
||||
end = clock();
|
||||
double secs = (double)(end - start) / CLOCKS_PER_SEC;
|
||||
if ( secs > timeout ) {
|
||||
break; // ( yes ) timeout
|
||||
}
|
||||
} // while ( !found )
|
||||
|
||||
CFRelease(elementCFArrayRef);
|
||||
} // if ( elementCFArrayRef )
|
||||
// return device and element moved
|
||||
if ( found ) {
|
||||
return (1);
|
||||
} else {
|
||||
*outIOHIDElementRef = NULL;
|
||||
return (0);
|
||||
}
|
||||
} // HIDConfigureSingleDeviceAction
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDConfigureAction( outIOHIDDeviceRef, outIOHIDElementRef, inTimeout )
|
||||
//
|
||||
// Purpose: polls all devices and elements for a change greater than kPercentMove.
|
||||
// Times out after given time returns 1 and pointer to device and element
|
||||
// if found; returns 0 and NULL for both parameters if not found
|
||||
//
|
||||
// Inputs: outIOHIDDeviceRef - address where to store the device
|
||||
// outIOHIDElementRef - address where to store the element
|
||||
// inTimeout - the timeout
|
||||
// Returns: Boolean - if successful
|
||||
// outIOHIDDeviceRef - the device
|
||||
// outIOHIDElementRef - the element
|
||||
//
|
||||
|
||||
Boolean HIDConfigureAction(IOHIDDeviceRef *outIOHIDDeviceRef, IOHIDElementRef *outIOHIDElementRef, float inTimeout) {
|
||||
// param error?
|
||||
if ( !outIOHIDDeviceRef || !outIOHIDElementRef ) {
|
||||
return (0);
|
||||
}
|
||||
if ( !gDeviceCFArrayRef ) { // if we do not have a device list
|
||||
// and we can't build another list
|
||||
if ( !HIDBuildDeviceList(0, 0) || !gDeviceCFArrayRef ) {
|
||||
return (FALSE); // bail
|
||||
}
|
||||
}
|
||||
|
||||
IOHIDDeviceRef tIOHIDDeviceRef;
|
||||
IOHIDElementRef tIOHIDElementRef;
|
||||
|
||||
// remember when we start; used to calculate timeout
|
||||
clock_t start = clock(), end;
|
||||
|
||||
// determine the maximum number of elements
|
||||
CFIndex maxElements = 0;
|
||||
CFIndex devIndex, devCount = CFArrayGetCount(gDeviceCFArrayRef);
|
||||
for ( devIndex = 0; devIndex < devCount; devIndex++ ) {
|
||||
tIOHIDDeviceRef = (IOHIDDeviceRef) CFArrayGetValueAtIndex(gDeviceCFArrayRef, devIndex);
|
||||
if ( !tIOHIDDeviceRef ) {
|
||||
continue; // skip this one
|
||||
}
|
||||
|
||||
CFIndex count = HIDCountDeviceElements(tIOHIDDeviceRef, kHIDElementTypeInput);
|
||||
if ( count > maxElements ) {
|
||||
maxElements = count;
|
||||
}
|
||||
}
|
||||
|
||||
// allocate an array of int's in which to store devCount * maxElements values
|
||||
double *saveValueArray = (double *) calloc( devCount * maxElements, sizeof(double) ); // clear 2D array to save values
|
||||
|
||||
// on first pass store initial values / compare current values to initial values on subsequent passes
|
||||
Boolean found = FALSE, first = TRUE;
|
||||
|
||||
while ( !found ) {
|
||||
double maxDeltaPercent = 0; // we want to find the one that moves the most ( percentage wise )
|
||||
for ( devIndex = 0; devIndex < devCount; devIndex++ ) {
|
||||
tIOHIDDeviceRef = (IOHIDDeviceRef) CFArrayGetValueAtIndex(gDeviceCFArrayRef, devIndex);
|
||||
if ( !tIOHIDDeviceRef ) {
|
||||
continue; // skip this one
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
long vendorID = IOHIDDevice_GetVendorID(tIOHIDDeviceRef);
|
||||
long productID = IOHIDDevice_GetProductID(tIOHIDDeviceRef);
|
||||
#endif
|
||||
gElementCFArrayRef = IOHIDDeviceCopyMatchingElements(tIOHIDDeviceRef, NULL, kIOHIDOptionsTypeNone);
|
||||
if ( gElementCFArrayRef ) {
|
||||
CFIndex eleIndex, eleCount = CFArrayGetCount(gElementCFArrayRef);
|
||||
for ( eleIndex = 0; eleIndex < eleCount; eleIndex++ ) {
|
||||
tIOHIDElementRef = (IOHIDElementRef) CFArrayGetValueAtIndex(gElementCFArrayRef, eleIndex);
|
||||
if ( !tIOHIDElementRef ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
IOHIDElementType tIOHIDElementType = IOHIDElementGetType(tIOHIDElementRef);
|
||||
// only care about inputs (no outputs or features)
|
||||
if ( tIOHIDElementType <= kIOHIDElementTypeInput_ScanCodes ) {
|
||||
if ( IOHIDElementIsArray(tIOHIDElementRef) ) {
|
||||
//printf( "ARRAY!\n" );
|
||||
continue; // skip array elements
|
||||
}
|
||||
|
||||
uint32_t usagePage = IOHIDElementGetUsagePage(tIOHIDElementRef);
|
||||
uint32_t usage = IOHIDElementGetUsage(tIOHIDElementRef);
|
||||
uint32_t reportCount = IOHIDElementGetReportCount(tIOHIDElementRef);
|
||||
#ifdef DEBUG
|
||||
if ( first ) {
|
||||
IOHIDElementCookie cookie = IOHIDElementGetCookie(tIOHIDElementRef);
|
||||
printf("%s, dev: {ref:%p, ven: 0x%08lX, pro: 0x%08lX}, ele: {ref:%p, cookie: %p, usage:%04lX:%08lX}\n",
|
||||
__PRETTY_FUNCTION__,
|
||||
tIOHIDDeviceRef,
|
||||
vendorID,
|
||||
productID,
|
||||
tIOHIDElementRef,
|
||||
cookie,
|
||||
(long unsigned int) usagePage,
|
||||
(long unsigned int) usage);
|
||||
fflush(stdout);
|
||||
if ( (0x054C == vendorID) && (0x0268 == productID) && (0x001E == (UInt32) cookie) ) {
|
||||
//printf( "DING!\n" );
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
#if 1 // work-around for IOHIDValueGetScaledValue crash (when element report count > 1)
|
||||
if ( reportCount > 1 ) {
|
||||
//printf( "REPORT!\n" );
|
||||
continue; // skip reports
|
||||
}
|
||||
|
||||
#endif
|
||||
// ignore PID elements and arrays
|
||||
if ( (kHIDPage_PID != usagePage) && (((uint32_t)-1) != usage) ) {
|
||||
// get this elements current value
|
||||
double value = 0.0; // default value is zero
|
||||
IOHIDValueRef tIOHIDValueRef;
|
||||
IOReturn ioReturn = IOHIDDeviceGetValue(tIOHIDDeviceRef, tIOHIDElementRef, &tIOHIDValueRef);
|
||||
if ( kIOReturnSuccess == ioReturn ) {
|
||||
value = IOHIDValueGetScaledValue(tIOHIDValueRef, kIOHIDValueScaleTypePhysical);
|
||||
}
|
||||
if ( first ) {
|
||||
saveValueArray[(devIndex * maxElements) + eleIndex] = value;
|
||||
} else {
|
||||
double initialValue = saveValueArray[(devIndex * maxElements) + eleIndex];
|
||||
|
||||
CFIndex valueMin = IOHIDElementGetPhysicalMin(tIOHIDElementRef);
|
||||
CFIndex valueMax = IOHIDElementGetPhysicalMax(tIOHIDElementRef);
|
||||
|
||||
double deltaPercent = fabs( (initialValue - value) * 100.0 / (valueMax - valueMin) );
|
||||
#if 0 // debug code useful to dump out value info for specific (vendorID, productID, usagePage and usage) device
|
||||
if ( !first ) {
|
||||
// Device: 0x13b6a0 = { Logitech Inc. - WingMan Force 3D, vendorID: 0x046D, productID: 0xC283,
|
||||
// usage: 0x0001:0x0004, "Generic Desktop Joystick"
|
||||
if ( (vendorID == 0x046D) && (productID == 0xC283) ) {
|
||||
if ( (kHIDPage_GenericDesktop == usagePage) && (kHIDUsage_GD_Rz == usage) ) {
|
||||
printf("initial: %6.2f, value: %6.2f, diff: %6.2f, delta percent: %6.2f!\n",
|
||||
initialValue,
|
||||
value,
|
||||
fabs(initialValue - value),
|
||||
deltaPercent);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
deltaPercent = 0.0;
|
||||
#endif
|
||||
if ( deltaPercent >= kPercentMove ) {
|
||||
found = TRUE;
|
||||
if ( deltaPercent > maxDeltaPercent ) {
|
||||
maxDeltaPercent = deltaPercent;
|
||||
|
||||
*outIOHIDDeviceRef = tIOHIDDeviceRef;
|
||||
*outIOHIDElementRef = tIOHIDElementRef;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
} // if first
|
||||
|
||||
} // if usage
|
||||
|
||||
} // if type
|
||||
|
||||
} // for elements...
|
||||
|
||||
CFRelease(gElementCFArrayRef);
|
||||
gElementCFArrayRef = NULL;
|
||||
} // if ( gElementCFArrayRef )
|
||||
if ( found ) {
|
||||
// HIDDumpElementInfo( tIOHIDElementRef );
|
||||
break; // DONE!
|
||||
}
|
||||
} // for devices
|
||||
|
||||
first = FALSE; // no longer the first pass
|
||||
|
||||
// are we done?
|
||||
end = clock();
|
||||
double secs = (double)(end - start) / CLOCKS_PER_SEC;
|
||||
if ( secs > inTimeout ) {
|
||||
break; // ( yes ) timeout
|
||||
}
|
||||
} // while ( !found )
|
||||
// return device and element moved
|
||||
if ( !found ) {
|
||||
*outIOHIDDeviceRef = NULL;
|
||||
*outIOHIDElementRef = NULL;
|
||||
}
|
||||
|
||||
return (found);
|
||||
} // HIDConfigureAction
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDSaveElementPref( inKeyCFStringRef, inAppCFStringRef, inIOHIDDeviceRef, inIOHIDElementRef )
|
||||
//
|
||||
// Purpose: Save the device & element values into the specified key in the specified applications preferences
|
||||
//
|
||||
// Inputs: inKeyCFStringRef - the preference key
|
||||
// inAppCFStringRef - the application identifier
|
||||
// inIOHIDDeviceRef - the device
|
||||
// inIOHIDElementRef - the element
|
||||
// Returns: Boolean - if successful
|
||||
//
|
||||
|
||||
Boolean HIDSaveElementPref(const CFStringRef inKeyCFStringRef,
|
||||
CFStringRef inAppCFStringRef,
|
||||
IOHIDDeviceRef inIOHIDDeviceRef,
|
||||
IOHIDElementRef inIOHIDElementRef) {
|
||||
Boolean success = FALSE;
|
||||
if ( inKeyCFStringRef && inAppCFStringRef && inIOHIDDeviceRef && inIOHIDElementRef ) {
|
||||
long vendorID = IOHIDDevice_GetVendorID(inIOHIDDeviceRef);
|
||||
require(vendorID, Oops);
|
||||
|
||||
long productID = IOHIDDevice_GetProductID(inIOHIDDeviceRef);
|
||||
require(productID, Oops);
|
||||
|
||||
long locID = IOHIDDevice_GetLocationID(inIOHIDDeviceRef);
|
||||
require(locID, Oops);
|
||||
|
||||
uint32_t usagePage = IOHIDDevice_GetUsagePage(inIOHIDDeviceRef);
|
||||
uint32_t usage = IOHIDDevice_GetUsage(inIOHIDDeviceRef);
|
||||
if ( !usagePage || !usage ) {
|
||||
usagePage = IOHIDDevice_GetPrimaryUsagePage(inIOHIDDeviceRef);
|
||||
usage = IOHIDDevice_GetPrimaryUsage(inIOHIDDeviceRef);
|
||||
}
|
||||
|
||||
require(usagePage && usage, Oops);
|
||||
|
||||
uint32_t usagePageE = IOHIDElementGetUsagePage(inIOHIDElementRef);
|
||||
uint32_t usageE = IOHIDElementGetUsage(inIOHIDElementRef);
|
||||
IOHIDElementCookie eleCookie = IOHIDElementGetCookie(inIOHIDElementRef);
|
||||
|
||||
CFStringRef prefCFStringRef = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
|
||||
CFSTR("d:{v:%ld, p:%ld, l:%ld, p:%ld, u:%ld}, e:{p:%ld, u:%ld, c:%ld}"),
|
||||
vendorID, productID, locID, usagePage, usage,
|
||||
usagePageE, usageE, eleCookie);
|
||||
if ( prefCFStringRef ) {
|
||||
CFPreferencesSetAppValue(inKeyCFStringRef, prefCFStringRef, inAppCFStringRef);
|
||||
CFRelease(prefCFStringRef);
|
||||
success = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
Oops: ;
|
||||
return (success);
|
||||
} // HIDSaveElementPref
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDRestoreElementPref( inKeyCFStringRef, inAppCFStringRef, outIOHIDDeviceRef, outIOHIDElementRef )
|
||||
//
|
||||
// Purpose: Find the specified preference in the specified application
|
||||
//
|
||||
// Inputs: inKeyCFStringRef - the preference key
|
||||
// inAppCFStringRef - the application identifier
|
||||
// outIOHIDDeviceRef - address where to restore the device
|
||||
// outIOHIDElementRef - address where to restore the element
|
||||
// Returns: Boolean - if successful
|
||||
// outIOHIDDeviceRef - the device
|
||||
// outIOHIDElementRef - the element
|
||||
//
|
||||
|
||||
Boolean HIDRestoreElementPref(CFStringRef inKeyCFStringRef,
|
||||
CFStringRef inAppCFStringRef,
|
||||
IOHIDDeviceRef * outIOHIDDeviceRef,
|
||||
IOHIDElementRef *outIOHIDElementRef) {
|
||||
Boolean found = FALSE;
|
||||
if ( inKeyCFStringRef && inAppCFStringRef && outIOHIDDeviceRef && outIOHIDElementRef ) {
|
||||
CFPropertyListRef prefCFPropertyListRef = CFPreferencesCopyAppValue(inKeyCFStringRef, inAppCFStringRef);
|
||||
if ( prefCFPropertyListRef ) {
|
||||
if ( CFStringGetTypeID() == CFGetTypeID(prefCFPropertyListRef) ) {
|
||||
char buffer[256];
|
||||
if ( CFStringGetCString( (CFStringRef) prefCFPropertyListRef, buffer, sizeof(buffer),
|
||||
kCFStringEncodingUTF8 ) )
|
||||
{
|
||||
HID_info_rec searchHIDInfo;
|
||||
|
||||
int count = sscanf(buffer,
|
||||
"d:{v:%d, p:%d, l:%d, p:%d, u:%d}, e:{p:%d, u:%d, c:%ld}",
|
||||
&searchHIDInfo.device.vendorID,
|
||||
&searchHIDInfo.device.productID,
|
||||
&searchHIDInfo.device.locID,
|
||||
&searchHIDInfo.device.usagePage,
|
||||
&searchHIDInfo.device.usage,
|
||||
&searchHIDInfo.element.usagePage,
|
||||
&searchHIDInfo.element.usage,
|
||||
(long *) &searchHIDInfo.element.cookie);
|
||||
if ( 8 == count ) { // if we found all eight parameters…
|
||||
// and can find a device & element that matches these…
|
||||
if ( HIDFindDeviceAndElement(&searchHIDInfo, outIOHIDDeviceRef, outIOHIDElementRef) ) {
|
||||
found = TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// We found the entry with this key but it's the wrong type; delete it.
|
||||
CFPreferencesSetAppValue(inKeyCFStringRef, NULL, inAppCFStringRef);
|
||||
(void) CFPreferencesAppSynchronize(inAppCFStringRef);
|
||||
}
|
||||
|
||||
CFRelease(prefCFPropertyListRef);
|
||||
}
|
||||
}
|
||||
|
||||
return (found);
|
||||
} // HIDRestoreElementPref
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDFindDeviceAndElement( inSearchInfo, outFoundDevice, outFoundElement )
|
||||
//
|
||||
// Purpose: find the closest matching device and element for this action
|
||||
//
|
||||
// Notes: matches device: serial, vendorID, productID, location, inUsagePage, usage
|
||||
// matches element: cookie, inUsagePage, usage,
|
||||
//
|
||||
// Inputs: inSearchInfo - the device & element info we searching for
|
||||
// outFoundDevice - the address of the best matching device
|
||||
// outFoundElement - the address of the best matching element
|
||||
//
|
||||
// Returns: Boolean - TRUE if we find a match
|
||||
// outFoundDevice - the best matching device
|
||||
// outFoundElement - the best matching element
|
||||
//
|
||||
|
||||
Boolean HIDFindDeviceAndElement(const HID_info_rec *inSearchInfo, IOHIDDeviceRef *outFoundDevice, IOHIDElementRef *outFoundElement) {
|
||||
Boolean result = FALSE;
|
||||
|
||||
IOHIDDeviceRef bestIOHIDDeviceRef = NULL;
|
||||
IOHIDElementRef bestIOHIDElementRef = NULL;
|
||||
long bestScore = 0;
|
||||
|
||||
CFIndex devIndex, devCount = CFArrayGetCount(gDeviceCFArrayRef);
|
||||
for ( devIndex = 0; devIndex < devCount; devIndex++ ) {
|
||||
long deviceScore = 1;
|
||||
|
||||
IOHIDDeviceRef tIOHIDDeviceRef = (IOHIDDeviceRef) CFArrayGetValueAtIndex(gDeviceCFArrayRef, devIndex);
|
||||
if ( !tIOHIDDeviceRef ) {
|
||||
continue;
|
||||
}
|
||||
// match vendorID, productID (+10, +8)
|
||||
if ( inSearchInfo->device.vendorID ) {
|
||||
long vendorID = IOHIDDevice_GetVendorID(tIOHIDDeviceRef);
|
||||
if ( vendorID ) {
|
||||
if ( inSearchInfo->device.vendorID == vendorID ) {
|
||||
deviceScore += 10;
|
||||
if ( inSearchInfo->device.productID ) {
|
||||
long productID = IOHIDDevice_GetProductID(tIOHIDDeviceRef);
|
||||
if ( productID ) {
|
||||
if ( inSearchInfo->device.productID == productID ) {
|
||||
deviceScore += 8;
|
||||
} // if ( inSearchInfo->device.productID == productID )
|
||||
|
||||
} // if ( productID )
|
||||
|
||||
} // if ( inSearchInfo->device.productID )
|
||||
|
||||
} // if (inSearchInfo->device.vendorID == vendorID)
|
||||
|
||||
} // if vendorID
|
||||
|
||||
} // if search->device.vendorID
|
||||
// match usagePage & usage (+9)
|
||||
if ( inSearchInfo->device.usagePage && inSearchInfo->device.usage ) {
|
||||
uint32_t usagePage = IOHIDDevice_GetUsagePage(tIOHIDDeviceRef) ;
|
||||
uint32_t usage = IOHIDDevice_GetUsage(tIOHIDDeviceRef);
|
||||
if ( !usagePage || !usage ) {
|
||||
usagePage = IOHIDDevice_GetPrimaryUsagePage(tIOHIDDeviceRef);
|
||||
usage = IOHIDDevice_GetPrimaryUsage(tIOHIDDeviceRef);
|
||||
}
|
||||
if ( usagePage ) {
|
||||
if ( inSearchInfo->device.usagePage == usagePage ) {
|
||||
if ( usage ) {
|
||||
if ( inSearchInfo->device.usage == usage ) {
|
||||
deviceScore += 9;
|
||||
} // if ( inSearchInfo->usage == usage )
|
||||
|
||||
} // if ( usage )
|
||||
|
||||
} // if ( inSearchInfo->usagePage == usagePage )
|
||||
|
||||
} // if ( usagePage )
|
||||
|
||||
} // if ( inSearchInfo->usagePage && inSearchInfo->usage )
|
||||
// match location ID (+5)
|
||||
if ( inSearchInfo->device.locID ) {
|
||||
long locID = IOHIDDevice_GetLocationID(tIOHIDDeviceRef);
|
||||
if ( locID ) {
|
||||
if ( inSearchInfo->device.locID == locID ) {
|
||||
deviceScore += 5;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// iterate over all elements of this device
|
||||
gElementCFArrayRef = IOHIDDeviceCopyMatchingElements(tIOHIDDeviceRef, NULL, 0);
|
||||
if ( gElementCFArrayRef ) {
|
||||
CFIndex eleIndex, eleCount = CFArrayGetCount(gElementCFArrayRef);
|
||||
for ( eleIndex = 0; eleIndex < eleCount; eleIndex++ ) {
|
||||
IOHIDElementRef tIOHIDElementRef = (IOHIDElementRef) CFArrayGetValueAtIndex(gElementCFArrayRef, eleIndex);
|
||||
if ( !tIOHIDElementRef ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
long score = deviceScore;
|
||||
// match usage page, usage & cookie
|
||||
if ( inSearchInfo->element.usagePage && inSearchInfo->element.usage ) {
|
||||
uint32_t usagePage = IOHIDElementGetUsagePage(tIOHIDElementRef);
|
||||
if ( inSearchInfo->element.usagePage == usagePage ) {
|
||||
uint32_t usage = IOHIDElementGetUsage(tIOHIDElementRef);
|
||||
if ( inSearchInfo->element.usage == usage ) {
|
||||
score += 5;
|
||||
IOHIDElementCookie cookie = IOHIDElementGetCookie(tIOHIDElementRef);
|
||||
if ( inSearchInfo->element.cookie == cookie ) {
|
||||
score += 4;
|
||||
} // cookies match
|
||||
|
||||
} else {
|
||||
score = 0;
|
||||
} // usages match
|
||||
|
||||
} else {
|
||||
score = 0;
|
||||
} // usage pages match
|
||||
|
||||
} // if ( search usage page & usage )
|
||||
|
||||
#if LOG_SCORING
|
||||
if ( kHIDPage_KeyboardOrKeypad != tElementRef->usagePage ) { // skip keyboards here
|
||||
printf("%s: ( %ld:%ld )-I-Debug, score: %ld\t",
|
||||
__PRETTY_FUNCTION__,
|
||||
inSearchInfo->element.usagePage,
|
||||
inSearchInfo->element.usage,
|
||||
score);
|
||||
HIDPrintElement(tIOHIDElementRef);
|
||||
}
|
||||
|
||||
#endif // LOG_SCORING
|
||||
if ( score > bestScore ) {
|
||||
bestIOHIDDeviceRef = tIOHIDDeviceRef;
|
||||
bestIOHIDElementRef = tIOHIDElementRef;
|
||||
bestScore = score;
|
||||
#if LOG_SCORING
|
||||
printf("%s: ( %ld:%ld )-I-Debug, better score: %ld\t",
|
||||
__PRETTY_FUNCTION__,
|
||||
inSearchInfo->element.usagePage,
|
||||
inSearchInfo->element.usage,
|
||||
score);
|
||||
HIDPrintElement(bestIOHIDElementRef);
|
||||
#endif // LOG_SCORING
|
||||
}
|
||||
} // for elements...
|
||||
|
||||
CFRelease(gElementCFArrayRef);
|
||||
gElementCFArrayRef = NULL;
|
||||
} // if ( gElementCFArrayRef )
|
||||
|
||||
} // for ( devIndex = 0; devIndex < devCount; devIndex++ )
|
||||
if ( bestIOHIDDeviceRef || bestIOHIDElementRef ) {
|
||||
*outFoundDevice = bestIOHIDDeviceRef;
|
||||
*outFoundElement = bestIOHIDElementRef;
|
||||
#if LOG_SCORING
|
||||
printf("%s: ( %ld:%ld )-I-Debug, best score: %ld\t",
|
||||
__PRETTY_FUNCTION__,
|
||||
inSearchInfo->element.usagePage,
|
||||
inSearchInfo->element.usage,
|
||||
bestScore);
|
||||
HIDPrintElement(bestIOHIDElementRef);
|
||||
#endif // LOG_SCORING
|
||||
result = TRUE;
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // HIDFindDeviceAndElement
|
||||
|
||||
// ---------------------------------
|
||||
|
||||
// takes input records, save required info
|
||||
// assume file is open and at correct position.
|
||||
// will always write to file (if file exists) size of HID_info_rec, even if device and or element is bad
|
||||
|
||||
void HIDSaveElementConfig(FILE *fileRef, IOHIDDeviceRef inIOHIDDeviceRef, IOHIDElementRef inIOHIDElementRef, int actionCookie) {
|
||||
// must save:
|
||||
// actionCookie
|
||||
// Device: serial,vendorID, productID, location, usagePage, usage
|
||||
// Element: cookie, usagePage, usage,
|
||||
HID_info_rec hidInfoRec;
|
||||
HIDSetElementConfig(&hidInfoRec, inIOHIDDeviceRef, inIOHIDElementRef, actionCookie);
|
||||
// write to file
|
||||
if ( fileRef ) {
|
||||
fwrite( (void *)&hidInfoRec, sizeof(HID_info_rec), 1, fileRef );
|
||||
}
|
||||
} // HIDSaveElementConfig
|
||||
|
||||
// ---------------------------------
|
||||
|
||||
// take file, read one record (assume file position is correct and file is open)
|
||||
// search for matching device
|
||||
// return pDevice, pElement and cookie for action
|
||||
|
||||
int HIDRestoreElementConfig(FILE *fileRef, IOHIDDeviceRef *outIOHIDDeviceRef, IOHIDElementRef *outIOHIDElementRef) {
|
||||
// Device: serial,vendorID, productID, location, usagePage, usage
|
||||
// Element: cookie, usagePage, usage,
|
||||
|
||||
HID_info_rec hidInfoRec;
|
||||
fread( (void *) &hidInfoRec, 1, sizeof(HID_info_rec), fileRef );
|
||||
return ( HIDGetElementConfig(&hidInfoRec, outIOHIDDeviceRef, outIOHIDElementRef) );
|
||||
} // HIDRestoreElementConfig
|
||||
|
||||
// ---------------------------------
|
||||
|
||||
// Set up a config record for saving
|
||||
// takes an input records, returns record user can save as they want
|
||||
// Note: the save rec must be pre-allocated by the calling app and will be filled out
|
||||
void HIDSetElementConfig(HID_info_ptr inHIDInfoPtr,
|
||||
IOHIDDeviceRef inIOHIDDeviceRef,
|
||||
IOHIDElementRef inIOHIDElementRef,
|
||||
int actionCookie) {
|
||||
// must save:
|
||||
// actionCookie
|
||||
// Device: serial,vendorID, productID, location, usagePage, usage
|
||||
// Element: cookie, usagePage, usage,
|
||||
inHIDInfoPtr->actionCookie = actionCookie;
|
||||
// device
|
||||
// need to add serial number when I have a test case
|
||||
if ( inIOHIDDeviceRef && inIOHIDElementRef ) {
|
||||
inHIDInfoPtr->device.vendorID = IOHIDDevice_GetVendorID(inIOHIDDeviceRef);
|
||||
inHIDInfoPtr->device.productID = IOHIDDevice_GetProductID(inIOHIDDeviceRef);
|
||||
inHIDInfoPtr->device.locID = IOHIDDevice_GetLocationID(inIOHIDDeviceRef);
|
||||
inHIDInfoPtr->device.usage = IOHIDDevice_GetUsage(inIOHIDDeviceRef);
|
||||
inHIDInfoPtr->device.usagePage = IOHIDDevice_GetUsagePage(inIOHIDDeviceRef);
|
||||
|
||||
inHIDInfoPtr->element.usagePage = IOHIDElementGetUsagePage(inIOHIDElementRef);
|
||||
inHIDInfoPtr->element.usage = IOHIDElementGetUsage(inIOHIDElementRef);
|
||||
inHIDInfoPtr->element.minReport = IOHIDElement_GetCalibrationSaturationMin(inIOHIDElementRef);
|
||||
inHIDInfoPtr->element.maxReport = IOHIDElement_GetCalibrationSaturationMax(inIOHIDElementRef);
|
||||
inHIDInfoPtr->element.cookie = IOHIDElementGetCookie(inIOHIDElementRef);
|
||||
} else {
|
||||
inHIDInfoPtr->device.vendorID = 0;
|
||||
inHIDInfoPtr->device.productID = 0;
|
||||
inHIDInfoPtr->device.locID = 0;
|
||||
inHIDInfoPtr->device.usage = 0;
|
||||
inHIDInfoPtr->device.usagePage = 0;
|
||||
|
||||
inHIDInfoPtr->element.usagePage = 0;
|
||||
inHIDInfoPtr->element.usage = 0;
|
||||
inHIDInfoPtr->element.minReport = 0;
|
||||
inHIDInfoPtr->element.maxReport = 0;
|
||||
inHIDInfoPtr->element.cookie = 0;
|
||||
}
|
||||
} // HIDSetElementConfig
|
||||
|
||||
// ---------------------------------
|
||||
#if 0 // debug utility function to dump config record
|
||||
void HIDDumpConfig(HID_info_ptr inHIDInfoPtr) {
|
||||
printf(
|
||||
"Config Record for action: %d\n\t vendor: %d product: %d location: %d\n\t usage: %d usagePage: %d\n\t element.usagePage: %d element.usage: %d\n\t minReport: %d maxReport: %d\n\t cookie: %d\n",
|
||||
inHIDInfoPtr->actionCookie,
|
||||
inHIDInfoPtr->device.vendorID,
|
||||
inHIDInfoPtr->device.productID,
|
||||
inHIDInfoPtr->locID,
|
||||
inHIDInfoPtr->usage,
|
||||
inHIDInfoPtr->usagePage,
|
||||
inHIDInfoPtr->element.usagePage,
|
||||
inHIDInfoPtr->element.usage,
|
||||
inHIDInfoPtr->minReport,
|
||||
inHIDInfoPtr->maxReport,
|
||||
inHIDInfoPtr->cookie);
|
||||
} // HIDDumpConfig
|
||||
#endif // 0
|
||||
// ---------------------------------
|
||||
|
||||
// Get matching element from config record
|
||||
// takes a pre-allocated and filled out config record
|
||||
// search for matching device
|
||||
// return pDevice, pElement and cookie for action
|
||||
int HIDGetElementConfig(HID_info_ptr inHIDInfoPtr, IOHIDDeviceRef *outIOHIDDeviceRef, IOHIDElementRef *outIOHIDElementRef) {
|
||||
if ( !inHIDInfoPtr->device.locID && !inHIDInfoPtr->device.vendorID && !inHIDInfoPtr->device.productID && !inHIDInfoPtr->device.usage
|
||||
&& !inHIDInfoPtr->device.usagePage ) //
|
||||
{ //
|
||||
// early out
|
||||
*outIOHIDDeviceRef = NULL;
|
||||
*outIOHIDElementRef = NULL;
|
||||
return (inHIDInfoPtr->actionCookie);
|
||||
}
|
||||
|
||||
IOHIDDeviceRef tIOHIDDeviceRef, foundIOHIDDeviceRef = NULL;
|
||||
IOHIDElementRef tIOHIDElementRef, foundIOHIDElementRef = NULL;
|
||||
|
||||
CFIndex devIdx, devCnt, idx, cnt;
|
||||
// compare to current device list for matches
|
||||
// look for device
|
||||
if ( inHIDInfoPtr->device.locID && inHIDInfoPtr->device.vendorID && inHIDInfoPtr->device.productID ) { // look for specific device
|
||||
// type plug in to same port
|
||||
devCnt = CFArrayGetCount(gDeviceCFArrayRef);
|
||||
for ( devIdx = 0; devIdx < devCnt; devIdx++ ) {
|
||||
tIOHIDDeviceRef = (IOHIDDeviceRef) CFArrayGetValueAtIndex(gDeviceCFArrayRef, devIdx);
|
||||
if ( !tIOHIDDeviceRef ) {
|
||||
continue; // skip this device
|
||||
}
|
||||
|
||||
long locID = IOHIDDevice_GetLocationID(tIOHIDDeviceRef);
|
||||
long vendorID = IOHIDDevice_GetVendorID(tIOHIDDeviceRef);
|
||||
long productID = IOHIDDevice_GetProductID(tIOHIDDeviceRef);
|
||||
if ( (inHIDInfoPtr->device.locID == locID)
|
||||
&& (inHIDInfoPtr->device.vendorID == vendorID)
|
||||
&& (inHIDInfoPtr->device.productID == productID) )
|
||||
{
|
||||
foundIOHIDDeviceRef = tIOHIDDeviceRef;
|
||||
}
|
||||
if ( foundIOHIDDeviceRef ) {
|
||||
break;
|
||||
}
|
||||
} // next devIdx
|
||||
if ( foundIOHIDDeviceRef ) {
|
||||
CFArrayRef elementCFArrayRef = IOHIDDeviceCopyMatchingElements(foundIOHIDDeviceRef, NULL, kIOHIDOptionsTypeNone);
|
||||
if ( elementCFArrayRef ) {
|
||||
cnt = CFArrayGetCount(elementCFArrayRef);
|
||||
for ( idx = 0; idx < cnt; idx++ ) {
|
||||
tIOHIDElementRef = (IOHIDElementRef) CFArrayGetValueAtIndex(elementCFArrayRef, idx);
|
||||
if ( !tIOHIDElementRef ) {
|
||||
continue; // skip this element
|
||||
}
|
||||
|
||||
IOHIDElementCookie cookie = IOHIDElementGetCookie(tIOHIDElementRef);
|
||||
if ( inHIDInfoPtr->element.cookie == cookie ) {
|
||||
foundIOHIDElementRef = tIOHIDElementRef;
|
||||
}
|
||||
if ( foundIOHIDElementRef ) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ( !foundIOHIDElementRef ) {
|
||||
cnt = CFArrayGetCount(elementCFArrayRef);
|
||||
for ( idx = 0; idx < cnt; idx++ ) {
|
||||
tIOHIDElementRef = (IOHIDElementRef) CFArrayGetValueAtIndex(elementCFArrayRef, idx);
|
||||
if ( !tIOHIDElementRef ) {
|
||||
continue; // skip this element
|
||||
}
|
||||
|
||||
uint32_t usagePage = IOHIDElementGetUsagePage(tIOHIDElementRef);
|
||||
uint32_t usage = IOHIDElementGetUsage(tIOHIDElementRef);
|
||||
if ( (inHIDInfoPtr->element.usage == usage) && (inHIDInfoPtr->element.usagePage == usagePage) ) {
|
||||
foundIOHIDElementRef = tIOHIDElementRef;
|
||||
}
|
||||
if ( foundIOHIDElementRef ) {
|
||||
break;
|
||||
}
|
||||
} // next idx
|
||||
|
||||
} // if ( !foundIOHIDElementRef )
|
||||
if ( foundIOHIDElementRef ) { // if same device
|
||||
// setup the calibration
|
||||
IOHIDElement_SetupCalibration(tIOHIDElementRef);
|
||||
|
||||
IOHIDElement_SetCalibrationSaturationMin(tIOHIDElementRef, inHIDInfoPtr->element.minReport);
|
||||
IOHIDElement_SetCalibrationSaturationMax(tIOHIDElementRef, inHIDInfoPtr->element.maxReport);
|
||||
}
|
||||
|
||||
CFRelease(elementCFArrayRef);
|
||||
} // if ( elementCFArrayRef )
|
||||
|
||||
} // if ( foundIOHIDDeviceRef )
|
||||
// if we have not found a match, look at just vendor and product
|
||||
if ( (!foundIOHIDDeviceRef) && (inHIDInfoPtr->device.vendorID && inHIDInfoPtr->device.productID) ) {
|
||||
devCnt = CFArrayGetCount(gDeviceCFArrayRef);
|
||||
for ( devIdx = 0; devIdx < devCnt; devIdx++ ) {
|
||||
tIOHIDDeviceRef = (IOHIDDeviceRef) CFArrayGetValueAtIndex(gDeviceCFArrayRef, devIdx);
|
||||
if ( !tIOHIDDeviceRef ) {
|
||||
continue; // skip this device
|
||||
}
|
||||
|
||||
long vendorID = IOHIDDevice_GetVendorID(tIOHIDDeviceRef);
|
||||
long productID = IOHIDDevice_GetProductID(tIOHIDDeviceRef);
|
||||
if ( (inHIDInfoPtr->device.vendorID == vendorID)
|
||||
&& (inHIDInfoPtr->device.productID == productID) )
|
||||
{
|
||||
foundIOHIDDeviceRef = tIOHIDDeviceRef;
|
||||
}
|
||||
if ( foundIOHIDDeviceRef ) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// match elements by cookie since same device type
|
||||
if ( foundIOHIDDeviceRef ) {
|
||||
CFArrayRef elementCFArrayRef = IOHIDDeviceCopyMatchingElements(foundIOHIDDeviceRef, NULL, kIOHIDOptionsTypeNone);
|
||||
if ( elementCFArrayRef ) {
|
||||
cnt = CFArrayGetCount(elementCFArrayRef);
|
||||
for ( idx = 0; idx < cnt; idx++ ) {
|
||||
tIOHIDElementRef = (IOHIDElementRef) CFArrayGetValueAtIndex(elementCFArrayRef, idx);
|
||||
if ( !tIOHIDElementRef ) {
|
||||
continue; // skip this element
|
||||
}
|
||||
|
||||
IOHIDElementCookie cookie = IOHIDElementGetCookie(tIOHIDElementRef);
|
||||
if ( inHIDInfoPtr->element.cookie == cookie ) {
|
||||
foundIOHIDElementRef = tIOHIDElementRef;
|
||||
}
|
||||
if ( foundIOHIDElementRef ) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// if no cookie match (should NOT occur) match on usage
|
||||
if ( !foundIOHIDElementRef ) {
|
||||
cnt = CFArrayGetCount(elementCFArrayRef);
|
||||
for ( idx = 0; idx < cnt; idx++ ) {
|
||||
tIOHIDElementRef = (IOHIDElementRef) CFArrayGetValueAtIndex(elementCFArrayRef, idx);
|
||||
if ( !tIOHIDElementRef ) {
|
||||
continue; // skip this element
|
||||
}
|
||||
|
||||
uint32_t usagePage = IOHIDElementGetUsagePage(tIOHIDElementRef);
|
||||
uint32_t usage = IOHIDElementGetUsage(tIOHIDElementRef);
|
||||
if ( (inHIDInfoPtr->element.usage == usage)
|
||||
&& (inHIDInfoPtr->element.usagePage == usagePage) )
|
||||
{
|
||||
foundIOHIDElementRef = tIOHIDElementRef;
|
||||
}
|
||||
if ( foundIOHIDElementRef ) {
|
||||
break;
|
||||
}
|
||||
} // next idx
|
||||
|
||||
} // if ( !foundIOHIDElementRef )
|
||||
if ( foundIOHIDElementRef ) { // if same device
|
||||
// setup the calibration
|
||||
IOHIDElement_SetupCalibration(tIOHIDElementRef);
|
||||
IOHIDElement_SetCalibrationSaturationMin(tIOHIDElementRef, inHIDInfoPtr->element.minReport);
|
||||
IOHIDElement_SetCalibrationSaturationMax(tIOHIDElementRef, inHIDInfoPtr->element.maxReport);
|
||||
}
|
||||
|
||||
CFRelease(elementCFArrayRef);
|
||||
} // if ( elementCFArrayRef )
|
||||
|
||||
} // if ( foundIOHIDDeviceRef )
|
||||
|
||||
} // if ( device not found & vendorID & productID )
|
||||
|
||||
} // if ( inHIDInfoPtr->locID && inHIDInfoPtr->device.vendorID && inHIDInfoPtr->device.productID )
|
||||
// can't find matching device return NULL, do not return first device
|
||||
if ( (!foundIOHIDDeviceRef) || (!foundIOHIDElementRef) ) {
|
||||
// no HID device
|
||||
*outIOHIDDeviceRef = NULL;
|
||||
*outIOHIDElementRef = NULL;
|
||||
return (inHIDInfoPtr->actionCookie);
|
||||
} else {
|
||||
// HID device
|
||||
*outIOHIDDeviceRef = foundIOHIDDeviceRef;
|
||||
*outIOHIDElementRef = foundIOHIDElementRef;
|
||||
return (inHIDInfoPtr->actionCookie);
|
||||
}
|
||||
} // HIDGetElementConfig
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
// File: HID_Error_Handler.c
|
||||
// Abstract: Implementation of the HID utilities error handlers
|
||||
// Version: 2.0
|
||||
//
|
||||
// Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
|
||||
// Inc. ("Apple") in consideration of your agreement to the following
|
||||
// terms, and your use, installation, modification or redistribution of
|
||||
// this Apple software constitutes acceptance of these terms. If you do
|
||||
// not agree with these terms, please do not use, install, modify or
|
||||
// redistribute this Apple software.
|
||||
//
|
||||
// In consideration of your agreement to abide by the following terms, and
|
||||
// subject to these terms, Apple grants you a personal, non-exclusive
|
||||
// license, under Apple's copyrights in this original Apple software (the
|
||||
// "Apple Software"), to use, reproduce, modify and redistribute the Apple
|
||||
// Software, with or without modifications, in source and/or binary forms;
|
||||
// provided that if you redistribute the Apple Software in its entirety and
|
||||
// without modifications, you must retain this notice and the following
|
||||
// text and disclaimers in all such redistributions of the Apple Software.
|
||||
// Neither the name, trademarks, service marks or logos of Apple Inc. may
|
||||
// be used to endorse or promote products derived from the Apple Software
|
||||
// without specific prior written permission from Apple. Except as
|
||||
// expressly stated in this notice, no other rights or licenses, express or
|
||||
// implied, are granted by Apple herein, including but not limited to any
|
||||
// patent rights that may be infringed by your derivative works or by other
|
||||
// works in which the Apple Software may be incorporated.
|
||||
//
|
||||
// The Apple Software is provided by Apple on an "AS IS" basis. APPLE
|
||||
// MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
|
||||
// THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
|
||||
// OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
|
||||
//
|
||||
// IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
|
||||
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
|
||||
// MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
|
||||
// AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
|
||||
// STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (C) 2009 Apple Inc. All Rights Reserved.
|
||||
//
|
||||
//*****************************************************
|
||||
#ifdef DEBUG // not used in release
|
||||
#if !defined (kBuildingLibrary)
|
||||
#define kVerboseErrors
|
||||
|
||||
// system includes ----------------------------------------------------------
|
||||
|
||||
#ifdef kVerboseErrors
|
||||
//#include <Carbon/Carbon.h>
|
||||
#endif
|
||||
#endif // not kBuildingLibrary
|
||||
#endif // DEBUG
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
// project includes ---------------------------------------------------------
|
||||
|
||||
#include "HID_Utilities_External.h"
|
||||
|
||||
// globals (internal/private) -----------------------------------------------
|
||||
|
||||
// prototypes (internal/private) --------------------------------------------
|
||||
|
||||
// functions (internal/private) ---------------------------------------------
|
||||
|
||||
#pragma mark -
|
||||
// -------------------------------------
|
||||
|
||||
// central error reporting
|
||||
|
||||
void HIDReportErrorNum(const char *strError, int numError) {
|
||||
char errMsgCStr[256];
|
||||
|
||||
sprintf(errMsgCStr, "%s #%d (0x%x)", strError, numError, numError);
|
||||
|
||||
// out as debug string
|
||||
#ifdef kVerboseErrors
|
||||
{
|
||||
fputs(errMsgCStr, stderr);
|
||||
}
|
||||
#endif // kVerboseErrors
|
||||
} // HIDReportErrorNum
|
||||
|
||||
// -------------------------------------
|
||||
|
||||
void HIDReportError(const char *strError) {
|
||||
char errMsgCStr[256];
|
||||
|
||||
sprintf(errMsgCStr, "%s", strError);
|
||||
|
||||
// out as debug string
|
||||
#ifdef kVerboseErrors
|
||||
{
|
||||
fputs(errMsgCStr, stderr);
|
||||
}
|
||||
#endif // kVerboseErrors
|
||||
} // HIDReportError
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,354 @@
|
|||
// File: HID_Queue_Utilities.c
|
||||
// Abstract: HID Queue Utilities.
|
||||
// Version: 2.0
|
||||
//
|
||||
// Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
|
||||
// Inc. ("Apple") in consideration of your agreement to the following
|
||||
// terms, and your use, installation, modification or redistribution of
|
||||
// this Apple software constitutes acceptance of these terms. If you do
|
||||
// not agree with these terms, please do not use, install, modify or
|
||||
// redistribute this Apple software.
|
||||
//
|
||||
// In consideration of your agreement to abide by the following terms, and
|
||||
// subject to these terms, Apple grants you a personal, non-exclusive
|
||||
// license, under Apple's copyrights in this original Apple software (the
|
||||
// "Apple Software"), to use, reproduce, modify and redistribute the Apple
|
||||
// Software, with or without modifications, in source and/or binary forms;
|
||||
// provided that if you redistribute the Apple Software in its entirety and
|
||||
// without modifications, you must retain this notice and the following
|
||||
// text and disclaimers in all such redistributions of the Apple Software.
|
||||
// Neither the name, trademarks, service marks or logos of Apple Inc. may
|
||||
// be used to endorse or promote products derived from the Apple Software
|
||||
// without specific prior written permission from Apple. Except as
|
||||
// expressly stated in this notice, no other rights or licenses, express or
|
||||
// implied, are granted by Apple herein, including but not limited to any
|
||||
// patent rights that may be infringed by your derivative works or by other
|
||||
// works in which the Apple Software may be incorporated.
|
||||
//
|
||||
// The Apple Software is provided by Apple on an "AS IS" basis. APPLE
|
||||
// MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
|
||||
// THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
|
||||
// OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
|
||||
//
|
||||
// IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
|
||||
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
|
||||
// MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
|
||||
// AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
|
||||
// STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (C) 2009 Apple Inc. All Rights Reserved.
|
||||
//
|
||||
//*****************************************************
|
||||
#include "HID_Utilities_External.h"
|
||||
|
||||
// ==================================
|
||||
// private functions
|
||||
|
||||
// creates a queue for a device, creates and opens device interface if required
|
||||
static IOReturn HIDCreateQueue(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
IOReturn result = kIOReturnSuccess;
|
||||
if ( inIOHIDDeviceRef ) {
|
||||
assert( IOHIDDeviceGetTypeID() == CFGetTypeID(inIOHIDDeviceRef) );
|
||||
|
||||
// do we already have a queue?
|
||||
IOHIDQueueRef tIOHIDQueueRef = IOHIDDevice_GetQueue(inIOHIDDeviceRef);
|
||||
if ( tIOHIDQueueRef ) { // (yes)
|
||||
assert( IOHIDQueueGetTypeID() == CFGetTypeID(tIOHIDQueueRef) );
|
||||
} else {
|
||||
tIOHIDQueueRef = IOHIDQueueCreate(kCFAllocatorDefault, inIOHIDDeviceRef, kDeviceQueueSize, kIOHIDOptionsTypeNone);
|
||||
if ( tIOHIDQueueRef ) { // did that work
|
||||
IOHIDDevice_SetQueue(inIOHIDDeviceRef, tIOHIDQueueRef);
|
||||
result = kIOReturnSuccess;
|
||||
} else {
|
||||
HIDReportErrorNum("Failed to create queue via create", result);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
HIDReportErrorNum("HID device ref does not exist for queue creation", result);
|
||||
}
|
||||
|
||||
return (result);
|
||||
} /* HIDCreateQueue */
|
||||
|
||||
// ---------------------------------
|
||||
// returns true if queue is empty false otherwise
|
||||
// error if no device, empty if no queue
|
||||
static unsigned char HIDIsDeviceQueueEmpty(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
if ( inIOHIDDeviceRef ) { // need device and queue
|
||||
assert( IOHIDDeviceGetTypeID() == CFGetTypeID(inIOHIDDeviceRef) );
|
||||
IOHIDQueueRef tIOHIDQueueRef = IOHIDDevice_GetQueue(inIOHIDDeviceRef);
|
||||
if ( tIOHIDQueueRef ) {
|
||||
IOHIDElementRef tIOHIDElementRef = HIDGetFirstDeviceElement(inIOHIDDeviceRef, kHIDElementTypeIO);
|
||||
|
||||
while ( tIOHIDElementRef ) {
|
||||
if ( IOHIDQueueContainsElement(tIOHIDQueueRef, tIOHIDElementRef) ) {
|
||||
return (false);
|
||||
}
|
||||
|
||||
tIOHIDElementRef = HIDGetNextDeviceElement(tIOHIDElementRef, kHIDElementTypeIO);
|
||||
}
|
||||
} else {
|
||||
HIDReportError("NULL device passed to HIDIsDeviceQueueEmpty.");
|
||||
}
|
||||
} else {
|
||||
HIDReportError("NULL device passed to HIDIsDeviceQueueEmpty.");
|
||||
}
|
||||
|
||||
return (true);
|
||||
} /* HIDIsDeviceQueueEmpty */
|
||||
|
||||
// ---------------------------------
|
||||
|
||||
// disposes and releases queue, sets queue to NULL,.
|
||||
// Note: will have no effect if device or queue do not exist
|
||||
static IOReturn HIDDisposeReleaseQueue(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
IOReturn result = kIOReturnSuccess;
|
||||
if ( inIOHIDDeviceRef ) {
|
||||
IOHIDQueueRef tIOHIDQueueRef = IOHIDDevice_GetQueue(inIOHIDDeviceRef);
|
||||
if ( tIOHIDQueueRef ) {
|
||||
// stop queue
|
||||
IOHIDQueueStop(tIOHIDQueueRef);
|
||||
|
||||
// release the queue
|
||||
CFRelease(tIOHIDQueueRef);
|
||||
}
|
||||
} else {
|
||||
HIDReportError("NULL device passed to HIDDisposeReleaseQueue.");
|
||||
}
|
||||
|
||||
return (result);
|
||||
} /* HIDDisposeReleaseQueue */
|
||||
|
||||
// ==================================
|
||||
// public functions
|
||||
// ----------------------------------
|
||||
|
||||
// queues specific element, performing any device queue set up required
|
||||
// queue is started and ready to return events on exit from this function
|
||||
int HIDQueueElement(IOHIDDeviceRef inIOHIDDeviceRef, IOHIDElementRef inIOHIDElementRef) {
|
||||
IOReturn result = kIOReturnSuccess;
|
||||
if ( inIOHIDDeviceRef ) {
|
||||
assert( IOHIDDeviceGetTypeID() == CFGetTypeID(inIOHIDDeviceRef) );
|
||||
if ( inIOHIDElementRef ) {
|
||||
assert( IOHIDElementGetTypeID() == CFGetTypeID(inIOHIDElementRef) );
|
||||
IOHIDQueueRef tIOHIDQueueRef = IOHIDDevice_GetQueue(inIOHIDDeviceRef);
|
||||
if ( !tIOHIDQueueRef ) { // if no queue create queue
|
||||
result = HIDCreateQueue(inIOHIDDeviceRef);
|
||||
if ( kIOReturnSuccess == result ) {
|
||||
tIOHIDQueueRef = IOHIDDevice_GetQueue(inIOHIDDeviceRef);
|
||||
}
|
||||
}
|
||||
if ( tIOHIDQueueRef ) {
|
||||
// stop queue
|
||||
IOHIDQueueStop(tIOHIDQueueRef);
|
||||
// queue element
|
||||
if ( !IOHIDQueueContainsElement(tIOHIDQueueRef, inIOHIDElementRef) ) {
|
||||
IOHIDQueueAddElement(tIOHIDQueueRef, inIOHIDElementRef);
|
||||
}
|
||||
|
||||
// restart queue
|
||||
IOHIDQueueStart(tIOHIDQueueRef);
|
||||
} else {
|
||||
HIDReportError("No queue for device passed to HIDQueueElement.");
|
||||
if ( kIOReturnSuccess == result ) {
|
||||
result = kIOReturnError;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
HIDReportError("NULL element passed to HIDQueueElement.");
|
||||
result = kIOReturnBadArgument;
|
||||
}
|
||||
} else {
|
||||
HIDReportError("NULL device passed to HIDQueueElement.");
|
||||
result = kIOReturnBadArgument;
|
||||
}
|
||||
|
||||
return (result);
|
||||
} /* HIDQueueElement */
|
||||
// ---------------------------------
|
||||
|
||||
// adds all elements to queue, performing any device queue set up required
|
||||
// queue is started and ready to return events on exit from this function
|
||||
int HIDQueueDevice(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
IOReturn result = kIOReturnSuccess;
|
||||
// error checking
|
||||
if ( !inIOHIDDeviceRef ) {
|
||||
HIDReportError("Device does not exist, cannot queue device.");
|
||||
return (kIOReturnBadArgument);
|
||||
}
|
||||
if ( !inIOHIDDeviceRef ) { // must have interface
|
||||
HIDReportError("Device does not have hid device ref, cannot queue device.");
|
||||
return (kIOReturnError);
|
||||
}
|
||||
|
||||
IOHIDQueueRef tIOHIDQueueRef = IOHIDDevice_GetQueue(inIOHIDDeviceRef);
|
||||
if ( !tIOHIDQueueRef ) { // if no queue create queue
|
||||
result = HIDCreateQueue(inIOHIDDeviceRef);
|
||||
if ( kIOReturnSuccess == result ) {
|
||||
tIOHIDQueueRef = IOHIDDevice_GetQueue(inIOHIDDeviceRef);
|
||||
}
|
||||
}
|
||||
if ( (kIOReturnSuccess != result) || (!tIOHIDQueueRef) ) {
|
||||
HIDReportErrorNum("Could not queue device due to problem creating queue.", result);
|
||||
if ( kIOReturnSuccess != result ) {
|
||||
return (result);
|
||||
} else {
|
||||
return (kIOReturnError);
|
||||
}
|
||||
}
|
||||
|
||||
// stop queue
|
||||
IOHIDQueueStop(tIOHIDQueueRef);
|
||||
|
||||
// queue element
|
||||
IOHIDElementRef tIOHIDElementRef = HIDGetFirstDeviceElement(inIOHIDDeviceRef, kHIDElementTypeIO);
|
||||
|
||||
while ( tIOHIDElementRef ) {
|
||||
if ( !IOHIDQueueContainsElement(tIOHIDQueueRef, tIOHIDElementRef) ) {
|
||||
IOHIDQueueAddElement(tIOHIDQueueRef, tIOHIDElementRef);
|
||||
}
|
||||
|
||||
tIOHIDElementRef = HIDGetNextDeviceElement(tIOHIDElementRef, kHIDElementTypeIO);
|
||||
}
|
||||
|
||||
// restart queue
|
||||
IOHIDQueueStart(tIOHIDQueueRef);
|
||||
|
||||
return (result);
|
||||
} /* HIDQueueDevice */
|
||||
|
||||
// ---------------------------------
|
||||
// removes element for queue, if last element in queue will release queue and closes device interface
|
||||
int HIDDequeueElement(IOHIDDeviceRef inIOHIDDeviceRef, IOHIDElementRef inIOHIDElementRef) {
|
||||
IOReturn result = kIOReturnSuccess;
|
||||
if ( inIOHIDDeviceRef ) {
|
||||
assert( IOHIDDeviceGetTypeID() == CFGetTypeID(inIOHIDDeviceRef) );
|
||||
if ( inIOHIDElementRef ) {
|
||||
assert( IOHIDElementGetTypeID() == CFGetTypeID(inIOHIDElementRef) );
|
||||
IOHIDQueueRef tIOHIDQueueRef = IOHIDDevice_GetQueue(inIOHIDDeviceRef);
|
||||
if ( tIOHIDQueueRef ) {
|
||||
// stop queue
|
||||
IOHIDQueueStop(tIOHIDQueueRef);
|
||||
// de-queue element
|
||||
if ( IOHIDQueueContainsElement(tIOHIDQueueRef, inIOHIDElementRef) ) {
|
||||
IOHIDQueueRemoveElement(tIOHIDQueueRef, inIOHIDElementRef);
|
||||
}
|
||||
// release device queue and close interface if queue empty
|
||||
if ( HIDIsDeviceQueueEmpty(inIOHIDDeviceRef) ) {
|
||||
result = HIDDisposeReleaseQueue(inIOHIDDeviceRef);
|
||||
if ( kIOReturnSuccess != result ) {
|
||||
HIDReportErrorNum("Failed to dispose and release queue.", result);
|
||||
}
|
||||
} else { // not empty so restart queue
|
||||
IOHIDQueueStart(tIOHIDQueueRef);
|
||||
}
|
||||
} else {
|
||||
HIDReportError("No queue for device passed to HIDDequeueElement.");
|
||||
if ( kIOReturnSuccess == result ) {
|
||||
result = kIOReturnError;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
HIDReportError("NULL element passed to HIDDequeueElement.");
|
||||
result = kIOReturnBadArgument;
|
||||
}
|
||||
} else {
|
||||
HIDReportError("NULL device passed to HIDDequeueElement.");
|
||||
result = kIOReturnBadArgument;
|
||||
}
|
||||
|
||||
return (result);
|
||||
} /* HIDDequeueElement */
|
||||
|
||||
// ---------------------------------
|
||||
// completely removes all elements from queue and releases queue and closes device interface
|
||||
// does not release device interfaces, application must call ReleaseHIDDeviceList on exit
|
||||
int HIDDequeueDevice(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
IOReturn result = kIOReturnSuccess;
|
||||
// error checking
|
||||
if ( !inIOHIDDeviceRef ) {
|
||||
HIDReportError("Device does not exist, cannot queue device.");
|
||||
return (kIOReturnBadArgument);
|
||||
}
|
||||
if ( !inIOHIDDeviceRef ) { // must have interface
|
||||
HIDReportError("Device does not have hid device ref, cannot queue device.");
|
||||
return (kIOReturnError);
|
||||
}
|
||||
|
||||
IOHIDQueueRef tIOHIDQueueRef = IOHIDDevice_GetQueue(inIOHIDDeviceRef);
|
||||
if ( tIOHIDQueueRef ) {
|
||||
// iterate through elements and if queued, remove
|
||||
IOHIDElementRef tIOHIDElementRef = HIDGetFirstDeviceElement(inIOHIDDeviceRef, kHIDElementTypeIO);
|
||||
|
||||
while ( tIOHIDElementRef ) {
|
||||
// de-queue element
|
||||
if ( IOHIDQueueContainsElement(tIOHIDQueueRef, tIOHIDElementRef) ) {
|
||||
IOHIDQueueRemoveElement(tIOHIDQueueRef, tIOHIDElementRef);
|
||||
}
|
||||
|
||||
tIOHIDElementRef = HIDGetNextDeviceElement(tIOHIDElementRef, kHIDElementTypeIO);
|
||||
}
|
||||
|
||||
// ensure queue is disposed and released
|
||||
result = HIDDisposeReleaseQueue(inIOHIDDeviceRef);
|
||||
if ( kIOReturnSuccess != result ) {
|
||||
HIDReportErrorNum("Failed to dispose and release queue.", result);
|
||||
}
|
||||
} else {
|
||||
HIDReportError("No queue for device passed to HIDDequeueElement.");
|
||||
if ( kIOReturnSuccess == result ) {
|
||||
result = kIOReturnError;
|
||||
}
|
||||
}
|
||||
|
||||
return (result);
|
||||
} /* HIDDequeueDevice */
|
||||
// ---------------------------------
|
||||
|
||||
// releases all device queues for quit or rebuild (must be called)
|
||||
// does not release device interfaces, application must call ReleaseHIDDeviceList on exit
|
||||
IOReturn HIDReleaseAllDeviceQueues(void) {
|
||||
IOReturn result = kIOReturnSuccess;
|
||||
IOHIDDeviceRef tIOHIDDeviceRef = HIDGetFirstDevice();
|
||||
|
||||
while ( tIOHIDDeviceRef ) {
|
||||
result = HIDDequeueDevice(tIOHIDDeviceRef);
|
||||
if ( kIOReturnSuccess != result ) {
|
||||
HIDReportErrorNum("Could not dequeue device.", result);
|
||||
}
|
||||
|
||||
tIOHIDDeviceRef = HIDGetNextDevice(tIOHIDDeviceRef);
|
||||
}
|
||||
|
||||
return (result);
|
||||
} /* HIDReleaseAllDeviceQueues */
|
||||
|
||||
// ---------------------------------
|
||||
// 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 */
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,417 @@
|
|||
// File: HID_Utilities_External.h
|
||||
// Abstract: External interface for HID Utilities, can be used with either library or source.
|
||||
// Version: 2.0
|
||||
//
|
||||
// Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
|
||||
// Inc. ("Apple") in consideration of your agreement to the following
|
||||
// terms, and your use, installation, modification or redistribution of
|
||||
// this Apple software constitutes acceptance of these terms. If you do
|
||||
// not agree with these terms, please do not use, install, modify or
|
||||
// redistribute this Apple software.
|
||||
//
|
||||
// In consideration of your agreement to abide by the following terms, and
|
||||
// subject to these terms, Apple grants you a personal, non-exclusive
|
||||
// license, under Apple's copyrights in this original Apple software (the
|
||||
// "Apple Software"), to use, reproduce, modify and redistribute the Apple
|
||||
// Software, with or without modifications, in source and/or binary forms;
|
||||
// provided that if you redistribute the Apple Software in its entirety and
|
||||
// without modifications, you must retain this notice and the following
|
||||
// text and disclaimers in all such redistributions of the Apple Software.
|
||||
// Neither the name, trademarks, service marks or logos of Apple Inc. may
|
||||
// be used to endorse or promote products derived from the Apple Software
|
||||
// without specific prior written permission from Apple. Except as
|
||||
// expressly stated in this notice, no other rights or licenses, express or
|
||||
// implied, are granted by Apple herein, including but not limited to any
|
||||
// patent rights that may be infringed by your derivative works or by other
|
||||
// works in which the Apple Software may be incorporated.
|
||||
//
|
||||
// The Apple Software is provided by Apple on an "AS IS" basis. APPLE
|
||||
// MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
|
||||
// THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
|
||||
// OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
|
||||
//
|
||||
// IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
|
||||
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
|
||||
// MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
|
||||
// AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
|
||||
// STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (C) 2009 Apple Inc. All Rights Reserved.
|
||||
//
|
||||
//*****************************************************
|
||||
#ifndef _HID_Utilities_External_h_
|
||||
#define _HID_Utilities_External_h_
|
||||
|
||||
// ==================================
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ==================================
|
||||
|
||||
//includes
|
||||
|
||||
#include <stdio.h>
|
||||
#include "IOHIDLib_.h"
|
||||
|
||||
// ==================================
|
||||
|
||||
#ifndef _IOKIT_HID_IOHIDKEYS_H_
|
||||
/*!
|
||||
@typedef IOHIDElementCookie
|
||||
@abstract Abstract data type used as a unique identifier for an element.
|
||||
*/
|
||||
#ifdef __LP64__
|
||||
typedef uint32_t IOHIDElementCookie;
|
||||
#else
|
||||
typedef void *IOHIDElementCookie;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Device and Element Interfaces
|
||||
|
||||
enum HIDElementTypeMask {
|
||||
kHIDElementTypeInput = 1 << 1,
|
||||
kHIDElementTypeOutput = 1 << 2,
|
||||
kHIDElementTypeFeature = 1 << 3,
|
||||
kHIDElementTypeCollection = 1 << 4,
|
||||
kHIDElementTypeIO = kHIDElementTypeInput | kHIDElementTypeOutput | kHIDElementTypeFeature,
|
||||
kHIDElementTypeAll = kHIDElementTypeIO | kHIDElementTypeCollection
|
||||
};
|
||||
typedef enum HIDElementTypeMask HIDElementTypeMask;
|
||||
|
||||
// ==================================
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - exported globals
|
||||
//-----------------------------------------------------
|
||||
|
||||
extern IOHIDManagerRef gIOHIDManagerRef;
|
||||
extern CFMutableArrayRef gDeviceCFArrayRef;
|
||||
extern CFArrayRef gElementCFArrayRef;
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDBuildMultiDeviceList( inUsagePages, inUsages, inNumDeviceTypes )
|
||||
//
|
||||
// Purpose: builds list of devices with elements (allocates memory and captures devices) in which
|
||||
// the devices could be of different types/usages list is allocated internally within HID
|
||||
// Utilites and can be accessed via accessor functions structures within list are considered
|
||||
// flat and user accessable, but not user modifiable can be called again to rebuild list to
|
||||
// account for new devices (will do the right thing in case of disposing existing list)
|
||||
// usagePage, usage are each a numDeviceTypes sized array of matching usage and usage pages
|
||||
// returns true if succesful
|
||||
//
|
||||
// Inputs: inUsagePages - inNumDeviceTypes sized array of matching usage pages
|
||||
// inUsages - inNumDeviceTypes sized array of matching usages
|
||||
// inNumDeviceTypes - number of usage pages & usages
|
||||
//
|
||||
// Returns: Boolean - if successful
|
||||
//
|
||||
extern Boolean HIDBuildMultiDeviceList(const UInt32 *inUsagePages, const UInt32 *inUsages, int inNumDeviceTypes);
|
||||
|
||||
// same as above but this uses a single usagePage and usage
|
||||
extern Boolean HIDBuildDeviceList(UInt32 usagePage, UInt32 usage);
|
||||
|
||||
// updates the current device list for any new/removed devices
|
||||
// if this is called before HIDBuildDeviceList the it functions like HIDBuildMultiDeviceList
|
||||
// usagePage, usage are each a numDeviceTypes sized array of matching usage and usage pages
|
||||
// returns true if successful which means if any device were added or removed (the device config changed)
|
||||
extern Boolean HIDUpdateDeviceList(const UInt32 *inUsagePages, const UInt32 *inUsages, int inNumDeviceTypes);
|
||||
|
||||
// release list built by above function
|
||||
// MUST be called prior to application exit to properly release devices
|
||||
// if not called (or app crashes) devices can be recovered by pluging into different location in USB chain
|
||||
extern void HIDReleaseDeviceList(void);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDRebuildDevices( )
|
||||
//
|
||||
// Purpose: rebuilds the (internal) list of devices
|
||||
//
|
||||
// Inputs: none
|
||||
//
|
||||
// Returns: none
|
||||
//
|
||||
|
||||
extern void HIDRebuildDevices(void);
|
||||
|
||||
// does a device list exist
|
||||
extern unsigned char HIDHaveDeviceList(void);
|
||||
|
||||
// how many HID devices have been found
|
||||
// returns 0 if no device list exist
|
||||
extern UInt32 HIDCountDevices(void);
|
||||
|
||||
// how many elements does a specific device have
|
||||
// returns 0 if device is invalid or NULL
|
||||
// uses mask of HIDElementTypeMask to restrict element found
|
||||
// use kHIDElementTypeIO to get non-collection elements
|
||||
extern UInt32 HIDCountDeviceElements(IOHIDDeviceRef inIOHIDDeviceRef, HIDElementTypeMask typeMask);
|
||||
|
||||
// get the first device in the device list
|
||||
// returns NULL if no list exists
|
||||
extern IOHIDDeviceRef HIDGetFirstDevice(void);
|
||||
|
||||
// get next device in list given current device as parameter
|
||||
// returns NULL if end of list
|
||||
extern IOHIDDeviceRef HIDGetNextDevice(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
// get the first element of device passed in as parameter
|
||||
// returns NULL if no list exists or device does not exists or is NULL
|
||||
// uses mask of HIDElementTypeMask to restrict element found
|
||||
// use kHIDElementTypeIO to get previous HIDGetFirstDeviceElement functionality
|
||||
extern IOHIDElementRef HIDGetFirstDeviceElement(IOHIDDeviceRef inIOHIDDeviceRef, HIDElementTypeMask typeMask);
|
||||
|
||||
// get next element of given device in list given current element as parameter
|
||||
// will walk down each collection then to next element or collection (depthwise traverse)
|
||||
// returns NULL if end of list
|
||||
// uses mask of HIDElementTypeMask to restrict element found
|
||||
// use kHIDElementTypeIO to get previous HIDGetNextDeviceElement functionality
|
||||
extern IOHIDElementRef HIDGetNextDeviceElement(IOHIDElementRef inIOHidElementRef, HIDElementTypeMask typeMask);
|
||||
|
||||
// get previous element of given device in list given current element as parameter
|
||||
// this walks directly up the tree to the top element and does not search at each level
|
||||
// returns NULL if beginning of list
|
||||
// uses mask of HIDElementTypeMask to restrict element found
|
||||
// use kHIDElementTypeIO to get non-collection elements
|
||||
extern IOHIDElementRef HIDGetPreviousDeviceElement(IOHIDElementRef inIOHidElementRef, HIDElementTypeMask typeMask);
|
||||
|
||||
// returns C string type name given a type enumeration passed in as parameter( see IOHIDKeys.h )
|
||||
// returns empty string for invalid types
|
||||
extern void HIDGetTypeName(IOHIDElementType inIOHIDElementType, char *outCStrName);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDCopyUsageName( inUsagePage, inUsage )
|
||||
//
|
||||
// Purpose: return a CFStringRef string for a given usage page & usage( see IOUSBHIDParser.h )
|
||||
//
|
||||
// Notes: returns usage page and usage values in CFString form for unknown values
|
||||
//
|
||||
// Inputs: inUsagePage - the usage page
|
||||
// inUsage - the usage
|
||||
//
|
||||
// Returns: CFStringRef - the resultant string
|
||||
//
|
||||
|
||||
extern CFStringRef HIDCopyUsageName(long inUsagePage, long inUsage);
|
||||
|
||||
// ==================================
|
||||
|
||||
// Element Event Queue and Value Interfaces
|
||||
|
||||
enum {
|
||||
kDefaultUserMin = 0, // default user min and max used for scaling
|
||||
kDefaultUserMax = 255
|
||||
};
|
||||
|
||||
enum {
|
||||
kDeviceQueueSize = 50 // this is wired kernel memory so should be set to as small as possible
|
||||
// but should account for the maximum possible events in the queue
|
||||
// USB updates will likely occur at 100 Hz so one must account for this rate of
|
||||
// if states change quickly (updates are only posted on state changes)
|
||||
};
|
||||
|
||||
// ==================================
|
||||
|
||||
// queues specific element, performing any device queue set up required
|
||||
extern int HIDQueueElement(IOHIDDeviceRef inIOHIDDeviceRef, IOHIDElementRef inIOHidElementRef);
|
||||
|
||||
// adds all elements to queue, performing any device queue set up required
|
||||
extern int HIDQueueDevice(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
// removes element for queue, if last element in queue will release queue and device
|
||||
extern int HIDDequeueElement(IOHIDDeviceRef inIOHIDDeviceRef, IOHIDElementRef inIOHidElementRef);
|
||||
|
||||
// completely removes all elements from queue and releases queue and device
|
||||
extern int HIDDequeueDevice(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
// releases all device queues for quit or rebuild (must be called)
|
||||
extern int HIDReleaseAllDeviceQueues(void);
|
||||
|
||||
// returns true if an event is avialable for the element and fills out *pHIDEvent structure, returns false otherwise
|
||||
// pHIDEvent is a poiner to a IOHIDEventStruct, using void here for compatibility, users can cast a required
|
||||
extern unsigned char HIDGetEvent(IOHIDDeviceRef inIOHIDDeviceRef, IOHIDValueRef *pIOHIDValueRef);
|
||||
|
||||
// ==================================
|
||||
|
||||
// Conguration and Save Interfaces
|
||||
|
||||
enum {
|
||||
kPercentMove = 10 // precent of overall range a element must move to register
|
||||
};
|
||||
|
||||
typedef struct HID_info_struct {
|
||||
int actionCookie;
|
||||
// device
|
||||
// need to add serial number when I have a test case
|
||||
struct {
|
||||
int vendorID, productID;
|
||||
int locID;
|
||||
uint32_t usagePage, usage;
|
||||
} device;
|
||||
// elements
|
||||
struct {
|
||||
uint32_t usagePage, usage;
|
||||
int minReport, maxReport;
|
||||
IOHIDElementCookie cookie; // always 32 bits
|
||||
} element;
|
||||
}HID_info_rec, *HID_info_ptr;
|
||||
|
||||
// get vendor name from vendor ID
|
||||
extern Boolean HIDGetVendorNameFromVendorID(long inVendorID, char *outCStrName);
|
||||
|
||||
// get product name from vendor/product ID
|
||||
extern Boolean HIDGetProductNameFromVendorProductID(long inVendorID, long inProductID, char *outCStrName);
|
||||
|
||||
// get element name from vendor id/product id look up ( using element cookie )
|
||||
extern Boolean HIDGetElementNameFromVendorProductCookie(int inVendorID,
|
||||
int inProductID,
|
||||
IOHIDElementCookie inCookie,
|
||||
char * outCStrName);
|
||||
|
||||
// get element name from vendor id/product id look up ( using element usage page & usage )
|
||||
extern Boolean HIDGetElementNameFromVendorProductUsage(long inVendorID,
|
||||
long inProductID,
|
||||
long inUsagePage,
|
||||
long inUsage,
|
||||
char *inCStrName);
|
||||
|
||||
// utility routines to dump device or element info
|
||||
extern void HIDDumpDeviceInfo(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
extern void HIDDumpElementInfo(IOHIDElementRef inIOHIDElementRef);
|
||||
extern void HIDDumpElementCalibrationInfo(IOHIDElementRef inIOHIDElementRef);
|
||||
|
||||
// polls single device's elements for a change greater than kPercentMove. Times out after given time
|
||||
// returns 1 and pointer to element if found
|
||||
// returns 0 and NULL for both parameters if not found
|
||||
extern unsigned char HIDConfigureSingleDeviceAction(IOHIDDeviceRef inIOHIDDeviceRef,
|
||||
IOHIDElementRef *outIOHIDElementRef,
|
||||
float timeout);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDConfigureAction( outDeviceRef, outElementRef, inTimeout )
|
||||
//
|
||||
// Purpose: polls all devices and elements for a change greater than kPercentMove.
|
||||
// Times out after given time returns 1 and pointer to device and element
|
||||
// if found; returns 0 and NULL for both parameters if not found
|
||||
//
|
||||
// Inputs: outDeviceRef - address where to store the device
|
||||
// outElementRef - address where to store the element
|
||||
// inTimeout - the timeout
|
||||
// Returns: Boolean - TRUE if successful
|
||||
// outDeviceRef - the device
|
||||
// outElementRef - the element
|
||||
//
|
||||
|
||||
extern Boolean HIDConfigureAction(IOHIDDeviceRef *outDeviceRef, IOHIDElementRef *outElementRef, float inTimeout);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDSaveElementPref( inKeyCFStringRef, inAppCFStringRef, inDeviceRef, inElementRef )
|
||||
//
|
||||
// Purpose: Save the device & element values into the specified key in the specified applications preferences
|
||||
//
|
||||
// Inputs: inKeyCFStringRef - the preference key
|
||||
// inAppCFStringRef - the application identifier
|
||||
// inDeviceRef - the device
|
||||
// inElementRef - the element
|
||||
// Returns: Boolean - if successful
|
||||
//
|
||||
|
||||
extern Boolean HIDSaveElementPref(const CFStringRef inKeyCFStringRef,
|
||||
CFStringRef inAppCFStringRef,
|
||||
IOHIDDeviceRef inDeviceRef,
|
||||
IOHIDElementRef inElementRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDRestoreElementPref( inKeyCFStringRef, inAppCFStringRef, outDeviceRef, outElementRef )
|
||||
//
|
||||
// Purpose: Find the specified preference in the specified application
|
||||
//
|
||||
// Inputs: inKeyCFStringRef - the preference key
|
||||
// inAppCFStringRef - the application identifier
|
||||
// outDeviceRef - address where to restore the device
|
||||
// outElementRef - address where to restore the element
|
||||
// Returns: Boolean - if successful
|
||||
// outDeviceRef - the device
|
||||
// outElementRef - the element
|
||||
//
|
||||
|
||||
extern Boolean HIDRestoreElementPref(CFStringRef inKeyCFStringRef,
|
||||
CFStringRef inAppCFStringRef,
|
||||
IOHIDDeviceRef * outDeviceRef,
|
||||
IOHIDElementRef *outElementRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDFindDeviceAndElement( inSearchInfo, outFoundDevice, outFoundElement )
|
||||
//
|
||||
// Purpose: find the closest matching device and element for this action
|
||||
//
|
||||
// Notes: matches device: serial, vendorID, productID, location, inUsagePage, usage
|
||||
// matches element: cookie, inUsagePage, usage,
|
||||
//
|
||||
// Inputs: inSearchInfo - the device & element info we searching for
|
||||
// outFoundDevice - the address of the best matching device
|
||||
// outFoundElement - the address of the best matching element
|
||||
//
|
||||
// Returns: Boolean - TRUE if we find a match
|
||||
// outFoundDevice - the best matching device
|
||||
// outFoundElement - the best matching element
|
||||
//
|
||||
|
||||
extern Boolean HIDFindDeviceAndElement(const HID_info_rec *inSearchInfo,
|
||||
IOHIDDeviceRef * outFoundDevice,
|
||||
IOHIDElementRef * outFoundElement);
|
||||
|
||||
// -- These are routines to use if the applcationwants HID Utilities to do the file handling --
|
||||
// Note: the FILE * is a MachO posix FILE and will not likely work directly with MW MSL FILE * type.
|
||||
|
||||
// take input records, save required info
|
||||
// assume file is open and at correct position.
|
||||
void HIDSaveElementConfig(FILE *fileRef, IOHIDDeviceRef inIOHIDDeviceRef, IOHIDElementRef inIOHidElementRef, int actionCookie);
|
||||
|
||||
// takes a file, reads one record (assume file position is correct and file is open)
|
||||
// search for matching device
|
||||
// return tIOHIDDeviceRef, tIOHIDElementRef and cookie for action
|
||||
int HIDRestoreElementConfig(FILE *fileRef, IOHIDDeviceRef *outIOHIDDeviceRef, IOHIDElementRef *outIOHIDElementRef);
|
||||
|
||||
// -- These are routines to use if the client wants to use their own file handling --
|
||||
|
||||
// Set up a config record for saving
|
||||
// takes an input records, returns record user can save as they want
|
||||
// Note: the save rec must be pre-allocated by the calling app and will be filled out
|
||||
void HIDSetElementConfig(HID_info_ptr inHIDInfoPtr,
|
||||
IOHIDDeviceRef inIOHIDDeviceRef,
|
||||
IOHIDElementRef inIOHidElementRef,
|
||||
int actionCookie);
|
||||
|
||||
// Get matching element from config record
|
||||
// takes a pre-allocated and filled out config record
|
||||
// search for matching device
|
||||
// return tIOHIDDeviceRef, tIOHIDElementRef and cookie for action
|
||||
int HIDGetElementConfig(HID_info_ptr inHIDInfoPtr, IOHIDDeviceRef *outIOHIDDeviceRef, IOHIDElementRef *outIOHIDElementRef);
|
||||
|
||||
// ==================================
|
||||
|
||||
// Error reporter, can be set to report however the application desires
|
||||
extern void HIDReportError(const char *strError);
|
||||
|
||||
// Error with numeric code reporter, can be set to report however the application desires
|
||||
extern void HIDReportErrorNum(const char *strError, int numError);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // _HID_Utilities_External_h_
|
||||
|
|
@ -0,0 +1,544 @@
|
|||
// File: IOHIDDevice_.c
|
||||
// Abstract: convieance functions for IOHIDDeviceGetProperty
|
||||
// Version: 2.0
|
||||
//
|
||||
// Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
|
||||
// Inc. ("Apple") in consideration of your agreement to the following
|
||||
// terms, and your use, installation, modification or redistribution of
|
||||
// this Apple software constitutes acceptance of these terms. If you do
|
||||
// not agree with these terms, please do not use, install, modify or
|
||||
// redistribute this Apple software.
|
||||
//
|
||||
// In consideration of your agreement to abide by the following terms, and
|
||||
// subject to these terms, Apple grants you a personal, non-exclusive
|
||||
// license, under Apple's copyrights in this original Apple software (the
|
||||
// "Apple Software"), to use, reproduce, modify and redistribute the Apple
|
||||
// Software, with or without modifications, in source and/or binary forms;
|
||||
// provided that if you redistribute the Apple Software in its entirety and
|
||||
// without modifications, you must retain this notice and the following
|
||||
// text and disclaimers in all such redistributions of the Apple Software.
|
||||
// Neither the name, trademarks, service marks or logos of Apple Inc. may
|
||||
// be used to endorse or promote products derived from the Apple Software
|
||||
// without specific prior written permission from Apple. Except as
|
||||
// expressly stated in this notice, no other rights or licenses, express or
|
||||
// implied, are granted by Apple herein, including but not limited to any
|
||||
// patent rights that may be infringed by your derivative works or by other
|
||||
// works in which the Apple Software may be incorporated.
|
||||
//
|
||||
// The Apple Software is provided by Apple on an "AS IS" basis. APPLE
|
||||
// MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
|
||||
// THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
|
||||
// OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
|
||||
//
|
||||
// IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
|
||||
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
|
||||
// MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
|
||||
// AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
|
||||
// STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (C) 2009 Apple Inc. All Rights Reserved.
|
||||
//
|
||||
//*****************************************************
|
||||
#pragma mark - includes & imports
|
||||
//-----------------------------------------------------
|
||||
|
||||
#include "IOHIDDevice_.h"
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - typedef's, struct's, enums, defines, etc.
|
||||
//-----------------------------------------------------
|
||||
|
||||
#define kIOHIDDevice_TransactionKey "DeviceTransactionRef"
|
||||
#define kIOHIDDevice_QueueKey "DeviceQueueRef"
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - local (static) function prototypes
|
||||
//-----------------------------------------------------
|
||||
|
||||
static Boolean IOHIDDevice_GetLongProperty(IOHIDDeviceRef inIOHIDDeviceRef, CFStringRef inKey, long *outValue);
|
||||
static void IOHIDDevice_SetLongProperty(IOHIDDeviceRef inIOHIDDeviceRef, CFStringRef inKey, long inValue);
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - exported globals
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - local (static) globals
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - exported function implementations
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDIsValidDevice( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: validate this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: Boolean - TRUE if we find the device in our( internal ) device list
|
||||
//
|
||||
|
||||
Boolean HIDIsValidDevice(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
Boolean result = FALSE; // assume failure (pessimist!)
|
||||
if ( inIOHIDDeviceRef ) {
|
||||
if ( CFGetTypeID(inIOHIDDeviceRef) ==IOHIDDeviceGetTypeID() ) {
|
||||
result = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // HIDIsValidDevice
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetTransport( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the Transport CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the Transport for this device
|
||||
//
|
||||
|
||||
CFStringRef IOHIDDevice_GetTransport(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
assert( IOHIDDeviceGetTypeID() == CFGetTypeID(inIOHIDDeviceRef) );
|
||||
return ( IOHIDDeviceGetProperty( inIOHIDDeviceRef, CFSTR(kIOHIDTransportKey) ) );
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetVendorID( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the vendor ID for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the vendor ID for this device
|
||||
//
|
||||
|
||||
long IOHIDDevice_GetVendorID(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDVendorIDKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetVendorID
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetVendorIDSource( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the VendorIDSource for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the VendorIDSource for this device
|
||||
//
|
||||
|
||||
long IOHIDDevice_GetVendorIDSource(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDVendorIDSourceKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetVendorIDSource
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetProductID( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the product ID for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the product ID for this device
|
||||
//
|
||||
|
||||
long IOHIDDevice_GetProductID(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDProductIDKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetProductID
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetVersionNumber( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the VersionNumber CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the VersionNumber for this device
|
||||
//
|
||||
|
||||
long IOHIDDevice_GetVersionNumber(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDVersionNumberKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetVersionNumber
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetManufacturer( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the Manufacturer CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the Manufacturer for this device
|
||||
//
|
||||
|
||||
CFStringRef IOHIDDevice_GetManufacturer(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
assert( IOHIDDeviceGetTypeID() == CFGetTypeID(inIOHIDDeviceRef) );
|
||||
return ( IOHIDDeviceGetProperty( inIOHIDDeviceRef, CFSTR(kIOHIDManufacturerKey) ) );
|
||||
} // IOHIDDevice_GetManufacturer
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetProduct( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the Product CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the Product for this device
|
||||
//
|
||||
|
||||
CFStringRef IOHIDDevice_GetProduct(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
assert( IOHIDDeviceGetTypeID() == CFGetTypeID(inIOHIDDeviceRef) );
|
||||
return ( IOHIDDeviceGetProperty( inIOHIDDeviceRef, CFSTR(kIOHIDProductKey) ) );
|
||||
} // IOHIDDevice_GetProduct
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetSerialNumber( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the SerialNumber CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the SerialNumber for this device
|
||||
//
|
||||
|
||||
CFStringRef IOHIDDevice_GetSerialNumber(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
assert( IOHIDDeviceGetTypeID() == CFGetTypeID(inIOHIDDeviceRef) );
|
||||
return ( IOHIDDeviceGetProperty( inIOHIDDeviceRef, CFSTR(kIOHIDSerialNumberKey) ) );
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetCountryCode( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the CountryCode CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the CountryCode for this device
|
||||
//
|
||||
|
||||
long IOHIDDevice_GetCountryCode(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDCountryCodeKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetCountryCode
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetLocationID( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the location ID for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the location ID for this device
|
||||
//
|
||||
|
||||
long IOHIDDevice_GetLocationID(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDLocationIDKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetLocationID
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetUsage( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the usage for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: uint32_t - the usage for this device
|
||||
//
|
||||
|
||||
uint32_t IOHIDDevice_GetUsage(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
uint32_t result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDDeviceUsageKey), (long *) &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetUsage
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetUsagePage( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the usage page for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: uint32_t - the usage page for this device
|
||||
//
|
||||
|
||||
uint32_t IOHIDDevice_GetUsagePage(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDDeviceUsagePageKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetUsagePage
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetUsagePairs( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the UsagePairs CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFArrayRef - the UsagePairs for this device
|
||||
//
|
||||
|
||||
CFArrayRef IOHIDDevice_GetUsagePairs(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
assert( IOHIDDeviceGetTypeID() == CFGetTypeID(inIOHIDDeviceRef) );
|
||||
return ( IOHIDDeviceGetProperty( inIOHIDDeviceRef, CFSTR(kIOHIDDeviceUsagePairsKey) ) );
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetPrimaryUsage( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the PrimaryUsage CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the PrimaryUsage for this device
|
||||
//
|
||||
|
||||
uint32_t IOHIDDevice_GetPrimaryUsage(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDPrimaryUsageKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetPrimaryUsage
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetPrimaryUsagePage( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the PrimaryUsagePage CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the PrimaryUsagePage for this device
|
||||
//
|
||||
|
||||
uint32_t IOHIDDevice_GetPrimaryUsagePage(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDPrimaryUsagePageKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetPrimaryUsagePage
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetMaxInputReportSize( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the MaxInputReportSize CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the MaxInputReportSize for this device
|
||||
//
|
||||
|
||||
long IOHIDDevice_GetMaxInputReportSize(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDMaxInputReportSizeKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetMaxInputReportSize
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetMaxOutputReportSize( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the MaxOutputReportSize for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the MaxOutput for this device
|
||||
//
|
||||
|
||||
long IOHIDDevice_GetMaxOutputReportSize(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDMaxOutputReportSizeKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetMaxOutputReportSize
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetMaxFeatureReportSize( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the MaxFeatureReportSize for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the MaxFeatureReportSize for this device
|
||||
//
|
||||
|
||||
long IOHIDDevice_GetMaxFeatureReportSize(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDMaxFeatureReportSizeKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetMaxFeatureReportSize
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetReportInterval( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the ReportInterval for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the ReportInterval for this device
|
||||
//
|
||||
#ifndef kIOHIDReportIntervalKey
|
||||
#define kIOHIDReportIntervalKey "ReportInterval"
|
||||
#endif
|
||||
long IOHIDDevice_GetReportInterval(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
long result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDReportIntervalKey), &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetReportInterval
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetQueue( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the Queue for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: IOHIDQueueRef - the Queue for this device
|
||||
//
|
||||
|
||||
IOHIDQueueRef IOHIDDevice_GetQueue(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
IOHIDQueueRef result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDDevice_QueueKey), (long *) &result);
|
||||
if ( result ) {
|
||||
assert( IOHIDQueueGetTypeID() == CFGetTypeID(result) );
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // IOHIDDevice_GetQueue
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_SetQueue( inIOHIDDeviceRef, inQueueRef )
|
||||
//
|
||||
// Purpose: Set the Queue for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
// inQueueRef - the Queue reference
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
void IOHIDDevice_SetQueue(IOHIDDeviceRef inIOHIDDeviceRef, IOHIDQueueRef inQueueRef) {
|
||||
IOHIDDevice_SetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDDevice_QueueKey), (long) inQueueRef);
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetTransaction( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the Transaction for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: IOHIDTransactionRef - the Transaction for this device
|
||||
//
|
||||
|
||||
IOHIDTransactionRef IOHIDDevice_GetTransaction(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
IOHIDTransactionRef result = 0;
|
||||
(void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDDevice_TransactionKey), (long *) &result);
|
||||
return (result);
|
||||
} // IOHIDDevice_GetTransaction
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_SetTransaction( inIOHIDDeviceRef, inTransactionRef )
|
||||
//
|
||||
// Purpose: Set the Transaction for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
// inTransactionRef - the Transaction reference
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
void IOHIDDevice_SetTransaction(IOHIDDeviceRef inIOHIDDeviceRef, IOHIDTransactionRef inTransactionRef) {
|
||||
IOHIDDevice_SetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDDevice_TransactionKey), (long) inTransactionRef);
|
||||
}
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - local (static) function implementations
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetLongProperty( inIOHIDDeviceRef, inKey, outValue )
|
||||
//
|
||||
// Purpose: convieance function to return a long property of a device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the device
|
||||
// inKey - CFString for the
|
||||
// outValue - address where to restore the element
|
||||
// Returns: the action cookie
|
||||
// outValue - the device
|
||||
//
|
||||
|
||||
static Boolean IOHIDDevice_GetLongProperty(IOHIDDeviceRef inIOHIDDeviceRef, CFStringRef inKey, long *outValue) {
|
||||
Boolean result = FALSE;
|
||||
if ( inIOHIDDeviceRef ) {
|
||||
assert( IOHIDDeviceGetTypeID() == CFGetTypeID(inIOHIDDeviceRef) );
|
||||
|
||||
CFTypeRef tCFTypeRef = IOHIDDeviceGetProperty(inIOHIDDeviceRef, inKey);
|
||||
if ( tCFTypeRef ) {
|
||||
// if this is a number
|
||||
if ( CFNumberGetTypeID() == CFGetTypeID(tCFTypeRef) ) {
|
||||
// get it's value
|
||||
result = CFNumberGetValue( (CFNumberRef) tCFTypeRef, kCFNumberSInt32Type, outValue );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // IOHIDDevice_GetLongProperty
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_SetLongProperty( inIOHIDDeviceRef, inKey, inValue )
|
||||
//
|
||||
// Purpose: convieance function to set a long property of an Device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the Device
|
||||
// inKey - CFString for the key
|
||||
// inValue - the value to set it to
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
static void IOHIDDevice_SetLongProperty(IOHIDDeviceRef inIOHIDDeviceRef, CFStringRef inKey, long inValue) {
|
||||
CFNumberRef tCFNumberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &inValue);
|
||||
if ( tCFNumberRef ) {
|
||||
IOHIDDeviceSetProperty(inIOHIDDeviceRef, inKey, tCFNumberRef);
|
||||
CFRelease(tCFNumberRef);
|
||||
}
|
||||
} // IOHIDDevice_SetLongProperty
|
||||
|
||||
//*****************************************************
|
||||
|
|
@ -0,0 +1,422 @@
|
|||
// File: IOHIDDevice_.h
|
||||
// Abstract: convieance functions for IOHIDDeviceGetProperty
|
||||
// Version: 2.0
|
||||
//
|
||||
// Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
|
||||
// Inc. ("Apple") in consideration of your agreement to the following
|
||||
// terms, and your use, installation, modification or redistribution of
|
||||
// this Apple software constitutes acceptance of these terms. If you do
|
||||
// not agree with these terms, please do not use, install, modify or
|
||||
// redistribute this Apple software.
|
||||
//
|
||||
// In consideration of your agreement to abide by the following terms, and
|
||||
// subject to these terms, Apple grants you a personal, non-exclusive
|
||||
// license, under Apple's copyrights in this original Apple software (the
|
||||
// "Apple Software"), to use, reproduce, modify and redistribute the Apple
|
||||
// Software, with or without modifications, in source and/or binary forms;
|
||||
// provided that if you redistribute the Apple Software in its entirety and
|
||||
// without modifications, you must retain this notice and the following
|
||||
// text and disclaimers in all such redistributions of the Apple Software.
|
||||
// Neither the name, trademarks, service marks or logos of Apple Inc. may
|
||||
// be used to endorse or promote products derived from the Apple Software
|
||||
// without specific prior written permission from Apple. Except as
|
||||
// expressly stated in this notice, no other rights or licenses, express or
|
||||
// implied, are granted by Apple herein, including but not limited to any
|
||||
// patent rights that may be infringed by your derivative works or by other
|
||||
// works in which the Apple Software may be incorporated.
|
||||
//
|
||||
// The Apple Software is provided by Apple on an "AS IS" basis. APPLE
|
||||
// MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
|
||||
// THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
|
||||
// OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
|
||||
//
|
||||
// IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
|
||||
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
|
||||
// MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
|
||||
// AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
|
||||
// STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (C) 2009 Apple Inc. All Rights Reserved.
|
||||
//
|
||||
//*****************************************************
|
||||
#ifndef __IOHIDDevice__
|
||||
#define __IOHIDDevice__
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - includes & imports
|
||||
|
||||
#include <AvailabilityMacros.h>
|
||||
|
||||
#include "IOHIDLib_.h"
|
||||
|
||||
//*****************************************************
|
||||
#if PRAGMA_ONCE
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if PRAGMA_IMPORT
|
||||
#pragma import on
|
||||
#endif
|
||||
|
||||
#if PRAGMA_STRUCT_ALIGN
|
||||
#pragma options align=mac68k
|
||||
#elif PRAGMA_STRUCT_PACKPUSH
|
||||
#pragma pack(push, 2)
|
||||
#elif PRAGMA_STRUCT_PACK
|
||||
#pragma pack(2)
|
||||
#endif
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - typedef's, struct's, enums, defines, etc.
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - exported globals
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - exported function prototypes
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDIsValidDevice( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: validate this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: Boolean - TRUE if we find the device in our( internal ) device list
|
||||
//
|
||||
|
||||
extern Boolean HIDIsValidDevice(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetTransport( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the Transport CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the Transport CFString for this device
|
||||
//
|
||||
|
||||
extern CFStringRef IOHIDDevice_GetTransport(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetVendorID( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the vendor ID for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the vendor ID for this device
|
||||
//
|
||||
|
||||
extern long IOHIDDevice_GetVendorID(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetVendorIDSource( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the VendorIDSource for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the VendorIDSource for this device
|
||||
//
|
||||
|
||||
extern long IOHIDDevice_GetVendorIDSource(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetProductID( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the product ID for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the product ID for this device
|
||||
//
|
||||
|
||||
extern long IOHIDDevice_GetProductID(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetVersionNumber( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the VersionNumber CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the VersionNumber for this device
|
||||
//
|
||||
|
||||
extern long IOHIDDevice_GetVersionNumber(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetManufacturer( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the Manufacturer CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the Manufacturer CFString for this device
|
||||
//
|
||||
|
||||
extern CFStringRef IOHIDDevice_GetManufacturer(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetProduct( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the Product CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the Product CFString for this device
|
||||
//
|
||||
|
||||
extern CFStringRef IOHIDDevice_GetProduct(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetSerialNumber( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the SerialNumber CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the SerialNumber CFString for this device
|
||||
//
|
||||
|
||||
extern CFStringRef IOHIDDevice_GetSerialNumber(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetCountryCode( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the CountryCode CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the CountryCode for this device
|
||||
//
|
||||
|
||||
extern long IOHIDDevice_GetCountryCode(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetLocationID( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the location ID for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the location ID for this device
|
||||
//
|
||||
|
||||
extern long IOHIDDevice_GetLocationID(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetUsage( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the usage for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: uint32_t - the usage for this device
|
||||
//
|
||||
|
||||
extern uint32_t IOHIDDevice_GetUsage(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetUsagePage( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the usage page for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: uint32_t - the usage page for this device
|
||||
//
|
||||
|
||||
extern uint32_t IOHIDDevice_GetUsagePage(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetUsagePairs( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the UsagePairs CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFArrayRef - the UsagePairs for this device
|
||||
//
|
||||
|
||||
extern CFArrayRef IOHIDDevice_GetUsagePairs(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetPrimaryUsage( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the PrimaryUsage CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the PrimaryUsage CFString for this device
|
||||
//
|
||||
|
||||
extern uint32_t IOHIDDevice_GetPrimaryUsage(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetPrimaryUsagePage( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the PrimaryUsagePage CFString for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: CFStringRef - the PrimaryUsagePage CFString for this device
|
||||
//
|
||||
|
||||
extern uint32_t IOHIDDevice_GetPrimaryUsagePage(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetMaxInputReportSize( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the MaxInputReportSize for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the MaxInputReportSize for this device
|
||||
//
|
||||
|
||||
extern long IOHIDDevice_GetMaxInputReportSize(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetMaxOutputReportSize( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the MaxOutputReportSize for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the MaxOutputReportSize for this device
|
||||
//
|
||||
|
||||
extern long IOHIDDevice_GetMaxOutputReportSize(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetMaxFeatureReportSize( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the MaxFeatureReportSize for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the MaxFeatureReportSize for this device
|
||||
//
|
||||
|
||||
extern long IOHIDDevice_GetMaxFeatureReportSize(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetReportInterval( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the ReportInterval for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: long - the ReportInterval for this device
|
||||
//
|
||||
|
||||
extern long IOHIDDevice_GetReportInterval(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetQueue( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the Queue for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: IOHIDQueueRef - the Queue for this device
|
||||
//
|
||||
|
||||
extern IOHIDQueueRef IOHIDDevice_GetQueue(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_SetQueue( inIOHIDDeviceRef, inQueueRef )
|
||||
//
|
||||
// Purpose: Set the Queue for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
// inQueueRef - the Queue
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
extern void IOHIDDevice_SetQueue(IOHIDDeviceRef inIOHIDDeviceRef, IOHIDQueueRef inQueueRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_GetTransaction( inIOHIDDeviceRef )
|
||||
//
|
||||
// Purpose: get the Transaction for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
//
|
||||
// Returns: IOHIDTransactionRef - the Transaction for this device
|
||||
//
|
||||
|
||||
extern IOHIDTransactionRef IOHIDDevice_GetTransaction(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDDevice_SetTransaction( inIOHIDDeviceRef, inTransactionRef )
|
||||
//
|
||||
// Purpose: Set the Transaction for this device
|
||||
//
|
||||
// Inputs: inIOHIDDeviceRef - the IDHIDDeviceRef for this device
|
||||
// inTransactionRef - the Transaction
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
extern void IOHIDDevice_SetTransaction(IOHIDDeviceRef inIOHIDDeviceRef, IOHIDTransactionRef inTransactionRef);
|
||||
|
||||
//*****************************************************
|
||||
#if PRAGMA_STRUCT_ALIGN
|
||||
#pragma options align=reset
|
||||
#elif PRAGMA_STRUCT_PACKPUSH
|
||||
#pragma pack(pop)
|
||||
#elif PRAGMA_STRUCT_PACK
|
||||
#pragma pack()
|
||||
#endif
|
||||
|
||||
#ifdef PRAGMA_IMPORT_OFF
|
||||
#pragma import off
|
||||
#elif PRAGMA_IMPORT
|
||||
#pragma import reset
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // __IOHIDDevice__ //
|
||||
|
|
@ -0,0 +1,502 @@
|
|||
// File: IOHIDElement_.c
|
||||
// Abstract: convieance functions for IOHIDElementGetProperty
|
||||
// Version: 2.0
|
||||
//
|
||||
// Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
|
||||
// Inc. ("Apple") in consideration of your agreement to the following
|
||||
// terms, and your use, installation, modification or redistribution of
|
||||
// this Apple software constitutes acceptance of these terms. If you do
|
||||
// not agree with these terms, please do not use, install, modify or
|
||||
// redistribute this Apple software.
|
||||
//
|
||||
// In consideration of your agreement to abide by the following terms, and
|
||||
// subject to these terms, Apple grants you a personal, non-exclusive
|
||||
// license, under Apple's copyrights in this original Apple software (the
|
||||
// "Apple Software"), to use, reproduce, modify and redistribute the Apple
|
||||
// Software, with or without modifications, in source and/or binary forms;
|
||||
// provided that if you redistribute the Apple Software in its entirety and
|
||||
// without modifications, you must retain this notice and the following
|
||||
// text and disclaimers in all such redistributions of the Apple Software.
|
||||
// Neither the name, trademarks, service marks or logos of Apple Inc. may
|
||||
// be used to endorse or promote products derived from the Apple Software
|
||||
// without specific prior written permission from Apple. Except as
|
||||
// expressly stated in this notice, no other rights or licenses, express or
|
||||
// implied, are granted by Apple herein, including but not limited to any
|
||||
// patent rights that may be infringed by your derivative works or by other
|
||||
// works in which the Apple Software may be incorporated.
|
||||
//
|
||||
// The Apple Software is provided by Apple on an "AS IS" basis. APPLE
|
||||
// MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
|
||||
// THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
|
||||
// OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
|
||||
//
|
||||
// IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
|
||||
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
|
||||
// MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
|
||||
// AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
|
||||
// STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (C) 2009 Apple Inc. All Rights Reserved.
|
||||
//
|
||||
//*****************************************************
|
||||
#pragma mark - includes & imports
|
||||
//-----------------------------------------------------
|
||||
|
||||
#include "IOHIDElement_.h"
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - typedef's, struct's, enums, defines, etc.
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - local (static) function prototypes
|
||||
//-----------------------------------------------------
|
||||
|
||||
// static Boolean IOHIDElement_GetLongProperty( IOHIDElementRef inElementRef, CFStringRef inKey, long * outValue );
|
||||
// static void IOHIDElement_SetLongProperty( IOHIDElementRef inElementRef, CFStringRef inKey, long inValue );
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - exported globals
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - local (static) globals
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - exported function implementations
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDIsValidElement( inIOHIDElementRef )
|
||||
//
|
||||
// Purpose: validate this element
|
||||
//
|
||||
// Inputs: inIOHIDElementRef - the element
|
||||
//
|
||||
// Returns: Boolean - TRUE if this is a valid element ref
|
||||
//
|
||||
Boolean HIDIsValidElement(IOHIDElementRef inIOHIDElementRef) {
|
||||
Boolean result = FALSE; // assume failure (pessimist!)
|
||||
if ( inIOHIDElementRef ) {
|
||||
if ( CFGetTypeID(inIOHIDElementRef) ==IOHIDElementGetTypeID() ) {
|
||||
result = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // HIDIsValidElement
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetValue( inElementRef, inIOHIDValueScaleType )
|
||||
//
|
||||
// Purpose: returns the current value for an element( polling )
|
||||
//
|
||||
// Notes: will return 0 on error conditions which should be accounted for by application
|
||||
//
|
||||
// Inputs: inElementRef - the element
|
||||
// inIOHIDValueScaleType - scale type ( calibrated or physical )
|
||||
//
|
||||
// Returns: double - current value for element
|
||||
//
|
||||
double IOHIDElement_GetValue(IOHIDElementRef inElementRef, IOHIDValueScaleType inIOHIDValueScaleType) {
|
||||
long result = 0;
|
||||
IOHIDValueRef tIOHIDValueRef;
|
||||
if ( kIOReturnSuccess == IOHIDDeviceGetValue(IOHIDElementGetDevice(inElementRef), inElementRef, &tIOHIDValueRef) ) {
|
||||
result = IOHIDValueGetScaledValue(tIOHIDValueRef, inIOHIDValueScaleType);
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // IOHIDElement_GetValue
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationMin( inElementRef )
|
||||
//
|
||||
// Purpose: get the minimum bounds for a calibrated value for this element
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: CFIndex - the minimum Calibration value for this element
|
||||
//
|
||||
|
||||
CFIndex IOHIDElement_GetCalibrationMin(IOHIDElementRef inElementRef) {
|
||||
CFIndex result;
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationMinKey), &result) ) {
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementMaxKey), &result) ) {
|
||||
result = 0x7FFFFFFF;
|
||||
}
|
||||
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationMinKey), result);
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // IOHIDElement_GetCalibrationMin
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationMin( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the minimum bounds for a calibrated value for this element
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the minimum bounds for a calibrated value for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
void IOHIDElement_SetCalibrationMin(IOHIDElementRef inElementRef, CFIndex inValue) {
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationMinKey), inValue);
|
||||
} // IOHIDElement_SetCalibrationMin
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationMax( inElementRef )
|
||||
//
|
||||
// Purpose: get the maximum bounds for a calibrated value for this element
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: CFIndex - the maximum Calibration value for this element
|
||||
//
|
||||
|
||||
CFIndex IOHIDElement_GetCalibrationMax(IOHIDElementRef inElementRef) {
|
||||
CFIndex result;
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationMaxKey), &result) ) {
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementMinKey), &result) ) {
|
||||
result = -0x7FFFFFFF;
|
||||
}
|
||||
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationMaxKey), result);
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // IOHIDElement_GetCalibrationMax
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationMax( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the maximum bounds for a calibrated value for this element
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the maximum Calibration value for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
void IOHIDElement_SetCalibrationMax(IOHIDElementRef inElementRef, CFIndex inValue) {
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationMaxKey), inValue);
|
||||
} // IOHIDElement_SetCalibrationMax
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationSaturationMin( inElementRef )
|
||||
//
|
||||
// Purpose: get the mininum tolerance to be used when calibrating a logical element value
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: CFIndex - the maximum Calibration value for this element
|
||||
//
|
||||
|
||||
CFIndex IOHIDElement_GetCalibrationSaturationMin(IOHIDElementRef inElementRef) {
|
||||
CFIndex result;
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationSaturationMinKey), &result) ) {
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementMinKey), &result) ) {
|
||||
result = -0x7FFFFFFF;
|
||||
}
|
||||
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationSaturationMinKey), result);
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // IOHIDElement_GetCalibrationSaturationMin
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationSaturationMin( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the mininum tolerance to be used when calibrating a logical element value
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the maximum Calibration value for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
void IOHIDElement_SetCalibrationSaturationMin(IOHIDElementRef inElementRef, CFIndex inValue) {
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationSaturationMinKey), inValue);
|
||||
} // IOHIDElement_SetCalibrationSaturationMin
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationSaturationMax( inElementRef )
|
||||
//
|
||||
// Purpose: get the maximum tolerance to be used when calibrating a logical element value
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: CFIndex - the maximum Calibration value for this element
|
||||
//
|
||||
|
||||
CFIndex IOHIDElement_GetCalibrationSaturationMax(IOHIDElementRef inElementRef) {
|
||||
CFIndex result;
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationSaturationMaxKey), &result) ) {
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementMinKey), &result) ) {
|
||||
result = -0x7FFFFFFF;
|
||||
}
|
||||
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationSaturationMaxKey), result);
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // IOHIDElement_GetCalibrationSaturationMax
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationSaturationMax( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the maximum tolerance to be used when calibrating a logical element value
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the maximum Calibration value for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
void IOHIDElement_SetCalibrationSaturationMax(IOHIDElementRef inElementRef, CFIndex inValue) {
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationSaturationMaxKey), inValue);
|
||||
} // IOHIDElement_SetCalibrationSaturationMax
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationDeadZoneMin( inElementRef )
|
||||
//
|
||||
// Purpose: get the minimum bounds near the midpoint of a logical value in which the value is ignored
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: CFIndex - the maximum Calibration value for this element
|
||||
//
|
||||
|
||||
CFIndex IOHIDElement_GetCalibrationDeadZoneMin(IOHIDElementRef inElementRef) {
|
||||
CFIndex result;
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationDeadZoneMinKey), &result) ) {
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementMinKey), &result) ) {
|
||||
result = -0x7FFFFFFF;
|
||||
}
|
||||
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationDeadZoneMinKey), result);
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // IOHIDElement_GetCalibrationDeadZoneMin
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationDeadZoneMin( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the minimum bounds near the midpoint of a logical value in which the value is ignored
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the maximum Calibration value for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
void IOHIDElement_SetCalibrationDeadZoneMin(IOHIDElementRef inElementRef, CFIndex inValue) {
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationDeadZoneMinKey), inValue);
|
||||
} // IOHIDElement_SetCalibrationDeadZoneMin
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationDeadZoneMax( inElementRef )
|
||||
//
|
||||
// Purpose: get the maximum bounds near the midpoint of a logical value in which the value is ignored
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: CFIndex - the maximum Calibration value for this element
|
||||
//
|
||||
|
||||
CFIndex IOHIDElement_GetCalibrationDeadZoneMax(IOHIDElementRef inElementRef) {
|
||||
CFIndex result;
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationDeadZoneMaxKey), &result) ) {
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementMinKey), &result) ) {
|
||||
result = -0x7FFFFFFF;
|
||||
}
|
||||
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationDeadZoneMaxKey), result);
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // IOHIDElement_GetCalibrationDeadZoneMax
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationDeadZoneMax( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the maximum bounds near the midpoint of a logical value in which the value is ignored
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the maximum Calibration value for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
void IOHIDElement_SetCalibrationDeadZoneMax(IOHIDElementRef inElementRef, CFIndex inValue) {
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationDeadZoneMaxKey), inValue);
|
||||
} // IOHIDElement_SetCalibrationDeadZoneMax
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationGranularity( inElementRef )
|
||||
//
|
||||
// Purpose: get the level of detail returned for a calibrated element value
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: double_t - the maximum Calibration value for this element
|
||||
//
|
||||
|
||||
double_t IOHIDElement_GetCalibrationGranularity(IOHIDElementRef inElementRef) {
|
||||
CFIndex result;
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationGranularityKey), &result) ) {
|
||||
if ( !IOHIDElement_GetLongProperty(inElementRef, CFSTR(kIOHIDElementMinKey), &result) ) {
|
||||
result = -0x7FFFFFFF;
|
||||
}
|
||||
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationGranularityKey), result);
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // IOHIDElement_GetCalibrationGranularity
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationGranularity( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the level of detail returned for a calibrated element value
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the the level of detail for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
void IOHIDElement_SetCalibrationGranularity(IOHIDElementRef inElementRef, double_t inValue) {
|
||||
IOHIDElement_SetLongProperty(inElementRef, CFSTR(kIOHIDElementCalibrationGranularityKey), inValue);
|
||||
} // IOHIDElement_SetCalibrationGranularity
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetupCalibration( inElementRef )
|
||||
//
|
||||
// Purpose: set default values for the element calibration parameters
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
void IOHIDElement_SetupCalibration(IOHIDElementRef inIOHIDElementRef) {
|
||||
// these are the min/max values returned by IOHIDValueGetScaledValue( v, kIOHIDValueScaleTypeCalibrated );
|
||||
IOHIDElement_SetCalibrationMin( inIOHIDElementRef, IOHIDElementGetLogicalMin(inIOHIDElementRef) );
|
||||
IOHIDElement_SetCalibrationMax( inIOHIDElementRef, IOHIDElementGetLogicalMax(inIOHIDElementRef) );
|
||||
|
||||
// this is the granularity of the values returned by IOHIDValueGetScaledValue( v, kIOHIDValueScaleTypeCalibrated );
|
||||
// for example if set to 0.1 the values returned will be multiples of 0.1 ( 0.1, 0.2, 0.3, etc. )
|
||||
IOHIDElement_SetCalibrationGranularity(inIOHIDElementRef, 0.);
|
||||
|
||||
// these define the dead zone (like in the middel of joystick axis)
|
||||
IOHIDElement_SetCalibrationDeadZoneMin(inIOHIDElementRef, 0);
|
||||
IOHIDElement_SetCalibrationDeadZoneMax(inIOHIDElementRef, 0);
|
||||
#if 1
|
||||
// get the current value of this element
|
||||
double value = IOHIDElement_GetValue(inIOHIDElementRef, kIOHIDValueScaleTypePhysical);
|
||||
// use it as our min/mas saturation
|
||||
IOHIDElement_SetCalibrationSaturationMin(inIOHIDElementRef, value);
|
||||
IOHIDElement_SetCalibrationSaturationMax(inIOHIDElementRef, value);
|
||||
#else
|
||||
// calculate the middle physical value we would expect from this element
|
||||
CFIndex valueMin = IOHIDElementGetPhysicalMin(inIOHIDElementRef);
|
||||
CFIndex valueMax = IOHIDElementGetPhysicalMax(inIOHIDElementRef);
|
||||
CFIndex valueMid = (valueMin + valueMax) / 2;
|
||||
|
||||
// use it as our min/mas saturation
|
||||
// this value determines the min/max values that have been recieved from the device element
|
||||
IOHIDElement_SetCalibrationSaturationMin(inIOHIDElementRef, valueMid);
|
||||
IOHIDElement_SetCalibrationSaturationMax(inIOHIDElementRef, valueMid);
|
||||
|
||||
// get the current value of this element
|
||||
double value = IOHIDElement_GetValue(inIOHIDElementRef, kIOHIDValueScaleTypePhysical);
|
||||
// and use it to adjust the current saturation values if it's outside their range
|
||||
if ( value < IOHIDElement_GetCalibrationSaturationMin(inIOHIDElementRef) ) {
|
||||
IOHIDElement_SetCalibrationSaturationMin(inIOHIDElementRef, value);
|
||||
}
|
||||
if ( value > IOHIDElement_GetCalibrationSaturationMax(inIOHIDElementRef) ) {
|
||||
IOHIDElement_SetCalibrationSaturationMax(inIOHIDElementRef, value);
|
||||
}
|
||||
|
||||
#endif
|
||||
} // IOHIDElement_SetupCalibration
|
||||
//*****************************************************
|
||||
#pragma mark - local (static) function implementations
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetLongProperty( inElementRef, inKey, outValue )
|
||||
//
|
||||
// Purpose: convieance function to return a long property of an element
|
||||
//
|
||||
// Inputs: inElementRef - the element
|
||||
// inKey - CFString for the key
|
||||
// outValue - address where to store the value
|
||||
// Returns: Boolean - TRUE if successful
|
||||
// outValue - the long property's value
|
||||
//
|
||||
|
||||
Boolean IOHIDElement_GetLongProperty(IOHIDElementRef inElementRef, CFStringRef inKey, long *outValue) {
|
||||
Boolean result = FALSE;
|
||||
|
||||
CFTypeRef tCFTypeRef = IOHIDElementGetProperty(inElementRef, inKey);
|
||||
if ( tCFTypeRef ) {
|
||||
// if this is a number
|
||||
if ( CFNumberGetTypeID() == CFGetTypeID(tCFTypeRef) ) {
|
||||
// get it's value
|
||||
result = CFNumberGetValue( (CFNumberRef) tCFTypeRef, kCFNumberSInt32Type, outValue );
|
||||
}
|
||||
}
|
||||
|
||||
return (result);
|
||||
} /* IOHIDElement_GetLongProperty */
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetLongProperty( inElementRef, inKey, inValue )
|
||||
//
|
||||
// Purpose: convieance function to set a long property of an element
|
||||
//
|
||||
// Inputs: inElementRef - the element
|
||||
// inKey - CFString for the key
|
||||
// inValue - the value to set it to
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
void IOHIDElement_SetLongProperty(IOHIDElementRef inElementRef, CFStringRef inKey, long inValue) {
|
||||
CFNumberRef tCFNumberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &inValue);
|
||||
if ( tCFNumberRef ) {
|
||||
IOHIDElementSetProperty(inElementRef, inKey, tCFNumberRef);
|
||||
CFRelease(tCFNumberRef);
|
||||
}
|
||||
} // IOHIDElement_SetLongProperty
|
||||
|
||||
//*****************************************************
|
||||
|
|
@ -0,0 +1,339 @@
|
|||
// File: IOHIDElement_.h
|
||||
// Abstract: convieance functions for IOHIDElementGetProperty
|
||||
// Version: 2.0
|
||||
//
|
||||
// Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
|
||||
// Inc. ("Apple") in consideration of your agreement to the following
|
||||
// terms, and your use, installation, modification or redistribution of
|
||||
// this Apple software constitutes acceptance of these terms. If you do
|
||||
// not agree with these terms, please do not use, install, modify or
|
||||
// redistribute this Apple software.
|
||||
//
|
||||
// In consideration of your agreement to abide by the following terms, and
|
||||
// subject to these terms, Apple grants you a personal, non-exclusive
|
||||
// license, under Apple's copyrights in this original Apple software (the
|
||||
// "Apple Software"), to use, reproduce, modify and redistribute the Apple
|
||||
// Software, with or without modifications, in source and/or binary forms;
|
||||
// provided that if you redistribute the Apple Software in its entirety and
|
||||
// without modifications, you must retain this notice and the following
|
||||
// text and disclaimers in all such redistributions of the Apple Software.
|
||||
// Neither the name, trademarks, service marks or logos of Apple Inc. may
|
||||
// be used to endorse or promote products derived from the Apple Software
|
||||
// without specific prior written permission from Apple. Except as
|
||||
// expressly stated in this notice, no other rights or licenses, express or
|
||||
// implied, are granted by Apple herein, including but not limited to any
|
||||
// patent rights that may be infringed by your derivative works or by other
|
||||
// works in which the Apple Software may be incorporated.
|
||||
//
|
||||
// The Apple Software is provided by Apple on an "AS IS" basis. APPLE
|
||||
// MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
|
||||
// THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
|
||||
// OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
|
||||
//
|
||||
// IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
|
||||
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
|
||||
// MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
|
||||
// AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
|
||||
// STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (C) 2009 Apple Inc. All Rights Reserved.
|
||||
//
|
||||
//*****************************************************
|
||||
#ifndef __IOHIDElement___
|
||||
#define __IOHIDElement___
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - includes & imports
|
||||
|
||||
#include <AvailabilityMacros.h>
|
||||
|
||||
#include "IOHIDLib_.h"
|
||||
//*****************************************************
|
||||
#if PRAGMA_ONCE
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if PRAGMA_IMPORT
|
||||
#pragma import on
|
||||
#endif
|
||||
|
||||
#if PRAGMA_STRUCT_ALIGN
|
||||
#pragma options align=mac68k
|
||||
#elif PRAGMA_STRUCT_PACKPUSH
|
||||
#pragma pack(push, 2)
|
||||
#elif PRAGMA_STRUCT_PACK
|
||||
#pragma pack(2)
|
||||
#endif
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - typedef's, struct's, enums, defines, etc.
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - exported globals
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - exported function prototypes
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// HIDIsValidElement( inIOHIDElementRef )
|
||||
//
|
||||
// Purpose: validate this element
|
||||
//
|
||||
// Inputs: inIOHIDElementRef - the element
|
||||
//
|
||||
// Returns: Boolean - TRUE if this is a valid element ref
|
||||
//
|
||||
extern Boolean HIDIsValidElement(IOHIDElementRef inIOHIDElementRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetValue( inElementRef, inIOHIDValueScaleType )
|
||||
//
|
||||
// Purpose: returns the current value for an element( polling )
|
||||
//
|
||||
// Notes: will return 0 on error conditions which should be accounted for by application
|
||||
//
|
||||
// Inputs: inElementRef - the element
|
||||
// inIOHIDValueScaleType - scale type ( calibrated or physical )
|
||||
//
|
||||
// Returns: double - current value for element
|
||||
//
|
||||
extern double IOHIDElement_GetValue(IOHIDElementRef inElementRef, IOHIDValueScaleType inIOHIDValueScaleType);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationMin( inElementRef )
|
||||
//
|
||||
// Purpose: get the minimum bounds for a calibrated value for this element
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: CFIndex - the minimum Calibration value for this element
|
||||
//
|
||||
|
||||
extern CFIndex IOHIDElement_GetCalibrationMin(IOHIDElementRef inElementRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationMin( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the minimum bounds for a calibrated value for this element
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the minimum bounds for a calibrated value for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
extern void IOHIDElement_SetCalibrationMin(IOHIDElementRef inElementRef, CFIndex inValue);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationMax( inElementRef )
|
||||
//
|
||||
// Purpose: get the maximum bounds for a calibrated value for this element
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: CFIndex - the maximum Calibration value for this element
|
||||
//
|
||||
|
||||
extern CFIndex IOHIDElement_GetCalibrationMax(IOHIDElementRef inElementRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationMax( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the maximum bounds for a calibrated value for this element
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the maximum Calibration value for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
extern void IOHIDElement_SetCalibrationMax(IOHIDElementRef inElementRef, CFIndex inValue);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationSaturationMin( inElementRef )
|
||||
//
|
||||
// Purpose: get the mininum tolerance to be used when calibrating a logical element value
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: CFIndex - the maximum Calibration value for this element
|
||||
//
|
||||
|
||||
extern CFIndex IOHIDElement_GetCalibrationSaturationMin(IOHIDElementRef inElementRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationSaturationMin( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the mininum tolerance to be used when calibrating a logical element value
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the maximum Calibration value for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
extern void IOHIDElement_SetCalibrationSaturationMin(IOHIDElementRef inElementRef, CFIndex inValue);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationSaturationMax( inElementRef )
|
||||
//
|
||||
// Purpose: get the maximum tolerance to be used when calibrating a logical element value
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: CFIndex - the maximum Calibration value for this element
|
||||
//
|
||||
|
||||
extern CFIndex IOHIDElement_GetCalibrationSaturationMax(IOHIDElementRef inElementRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationSaturationMax( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the maximum tolerance to be used when calibrating a logical element value
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the maximum Calibration value for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
extern void IOHIDElement_SetCalibrationSaturationMax(IOHIDElementRef inElementRef, CFIndex inValue);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationDeadZoneMin( inElementRef )
|
||||
//
|
||||
// Purpose: get the minimum bounds near the midpoint of a logical value in which the value is ignored
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: CFIndex - the maximum Calibration value for this element
|
||||
//
|
||||
|
||||
extern CFIndex IOHIDElement_GetCalibrationDeadZoneMin(IOHIDElementRef inElementRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationDeadZoneMin( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the minimum bounds near the midpoint of a logical value in which the value is ignored
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the maximum Calibration value for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
extern void IOHIDElement_SetCalibrationDeadZoneMin(IOHIDElementRef inElementRef, CFIndex inValue);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationDeadZoneMax( inElementRef )
|
||||
//
|
||||
// Purpose: get the maximum bounds near the midpoint of a logical value in which the value is ignored
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: CFIndex - the maximum Calibration value for this element
|
||||
//
|
||||
|
||||
extern CFIndex IOHIDElement_GetCalibrationDeadZoneMax(IOHIDElementRef inElementRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationDeadZoneMax( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the maximum bounds near the midpoint of a logical value in which the value is ignored
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the maximum Calibration value for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
extern void IOHIDElement_SetCalibrationDeadZoneMax(IOHIDElementRef inElementRef, CFIndex inValue);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_GetCalibrationGranularity( inElementRef )
|
||||
//
|
||||
// Purpose: get the level of detail returned for a calibrated element value
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: double_t - the maximum Calibration value for this element
|
||||
//
|
||||
|
||||
extern double_t IOHIDElement_GetCalibrationGranularity(IOHIDElementRef inElementRef);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetCalibrationGranularity( inElementRef, inValue )
|
||||
//
|
||||
// Purpose: set the level of detail returned for a calibrated element value
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
// inValue - the the level of detail for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
extern void IOHIDElement_SetCalibrationGranularity(IOHIDElementRef inElementRef, double_t inValue);
|
||||
|
||||
//*************************************************************************
|
||||
//
|
||||
// IOHIDElement_SetupCalibration( inElementRef )
|
||||
//
|
||||
// Purpose: set default values for the element calibration parameters
|
||||
//
|
||||
// Inputs: inElementRef - the IOHIDElementRef for this element
|
||||
//
|
||||
// Returns: nothing
|
||||
//
|
||||
|
||||
extern void IOHIDElement_SetupCalibration(IOHIDElementRef inIOHIDElementRef);
|
||||
|
||||
extern Boolean IOHIDElement_GetLongProperty(IOHIDElementRef inElementRef, CFStringRef inKey, long *outValue);
|
||||
extern void IOHIDElement_SetLongProperty(IOHIDElementRef inElementRef, CFStringRef inKey, long inValue);
|
||||
|
||||
//*****************************************************
|
||||
#if PRAGMA_STRUCT_ALIGN
|
||||
#pragma options align=reset
|
||||
#elif PRAGMA_STRUCT_PACKPUSH
|
||||
#pragma pack(pop)
|
||||
#elif PRAGMA_STRUCT_PACK
|
||||
#pragma pack()
|
||||
#endif
|
||||
|
||||
#ifdef PRAGMA_IMPORT_OFF
|
||||
#pragma import off
|
||||
#elif PRAGMA_IMPORT
|
||||
#pragma import reset
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // __IOHIDElement___ //
|
||||
|
|
@ -0,0 +1,111 @@
|
|||
// File: IOHIDLib_.h
|
||||
// Abstract: Single include file for all header files of IOHIDLib
|
||||
// Version: 2.0
|
||||
//
|
||||
// Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
|
||||
// Inc. ("Apple") in consideration of your agreement to the following
|
||||
// terms, and your use, installation, modification or redistribution of
|
||||
// this Apple software constitutes acceptance of these terms. If you do
|
||||
// not agree with these terms, please do not use, install, modify or
|
||||
// redistribute this Apple software.
|
||||
//
|
||||
// In consideration of your agreement to abide by the following terms, and
|
||||
// subject to these terms, Apple grants you a personal, non-exclusive
|
||||
// license, under Apple's copyrights in this original Apple software (the
|
||||
// "Apple Software"), to use, reproduce, modify and redistribute the Apple
|
||||
// Software, with or without modifications, in source and/or binary forms;
|
||||
// provided that if you redistribute the Apple Software in its entirety and
|
||||
// without modifications, you must retain this notice and the following
|
||||
// text and disclaimers in all such redistributions of the Apple Software.
|
||||
// Neither the name, trademarks, service marks or logos of Apple Inc. may
|
||||
// be used to endorse or promote products derived from the Apple Software
|
||||
// without specific prior written permission from Apple. Except as
|
||||
// expressly stated in this notice, no other rights or licenses, express or
|
||||
// implied, are granted by Apple herein, including but not limited to any
|
||||
// patent rights that may be infringed by your derivative works or by other
|
||||
// works in which the Apple Software may be incorporated.
|
||||
//
|
||||
// The Apple Software is provided by Apple on an "AS IS" basis. APPLE
|
||||
// MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
|
||||
// THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
|
||||
// OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
|
||||
//
|
||||
// IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
|
||||
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
|
||||
// MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
|
||||
// AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
|
||||
// STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (C) 2009 Apple Inc. All Rights Reserved.
|
||||
//
|
||||
//*****************************************************
|
||||
#ifndef __IOHIDLib___
|
||||
#define __IOHIDLib___
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - includes & imports
|
||||
//-----------------------------------------------------
|
||||
#include <IOKit/hid/IOHIDLib.h>
|
||||
|
||||
#include "IOHIDDevice_.h"
|
||||
#include "IOHIDElement_.h"
|
||||
|
||||
#include "ImmrHIDUtilAddOn.h"
|
||||
|
||||
//*****************************************************
|
||||
#if PRAGMA_ONCE
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if PRAGMA_IMPORT
|
||||
#pragma import on
|
||||
#endif
|
||||
|
||||
#if PRAGMA_STRUCT_ALIGN
|
||||
#pragma options align=mac68k
|
||||
#elif PRAGMA_STRUCT_PACKPUSH
|
||||
#pragma pack(push, 2)
|
||||
#elif PRAGMA_STRUCT_PACK
|
||||
#pragma pack(2)
|
||||
#endif
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - typedef's, struct's, enums, defines, etc.
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - exported globals
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*****************************************************
|
||||
#pragma mark - exported function prototypes
|
||||
//-----------------------------------------------------
|
||||
|
||||
//*****************************************************
|
||||
#if PRAGMA_STRUCT_ALIGN
|
||||
#pragma options align=reset
|
||||
#elif PRAGMA_STRUCT_PACKPUSH
|
||||
#pragma pack(pop)
|
||||
#elif PRAGMA_STRUCT_PACK
|
||||
#pragma pack()
|
||||
#endif
|
||||
|
||||
#ifdef PRAGMA_IMPORT_OFF
|
||||
#pragma import off
|
||||
#elif PRAGMA_IMPORT
|
||||
#pragma import reset
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // __IOHIDLib___
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
// File: ImmrHIDUtilAddOn.c
|
||||
// Abstract: Glue code to convert IOHIDDeviceRef's to (FFB) io_object_t's
|
||||
// Version: 2.0
|
||||
//
|
||||
// Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
|
||||
// Inc. ("Apple") in consideration of your agreement to the following
|
||||
// terms, and your use, installation, modification or redistribution of
|
||||
// this Apple software constitutes acceptance of these terms. If you do
|
||||
// not agree with these terms, please do not use, install, modify or
|
||||
// redistribute this Apple software.
|
||||
//
|
||||
// In consideration of your agreement to abide by the following terms, and
|
||||
// subject to these terms, Apple grants you a personal, non-exclusive
|
||||
// license, under Apple's copyrights in this original Apple software (the
|
||||
// "Apple Software"), to use, reproduce, modify and redistribute the Apple
|
||||
// Software, with or without modifications, in source and/or binary forms;
|
||||
// provided that if you redistribute the Apple Software in its entirety and
|
||||
// without modifications, you must retain this notice and the following
|
||||
// text and disclaimers in all such redistributions of the Apple Software.
|
||||
// Neither the name, trademarks, service marks or logos of Apple Inc. may
|
||||
// be used to endorse or promote products derived from the Apple Software
|
||||
// without specific prior written permission from Apple. Except as
|
||||
// expressly stated in this notice, no other rights or licenses, express or
|
||||
// implied, are granted by Apple herein, including but not limited to any
|
||||
// patent rights that may be infringed by your derivative works or by other
|
||||
// works in which the Apple Software may be incorporated.
|
||||
//
|
||||
// The Apple Software is provided by Apple on an "AS IS" basis. APPLE
|
||||
// MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
|
||||
// THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
|
||||
// OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
|
||||
//
|
||||
// IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
|
||||
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
|
||||
// MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
|
||||
// AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
|
||||
// STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (C) 2009 Apple Inc. All Rights Reserved.
|
||||
//
|
||||
//*****************************************************
|
||||
#include <mach/mach.h>
|
||||
#include <mach/mach_error.h>
|
||||
|
||||
#include "ImmrHIDUtilAddOn.h"
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
//
|
||||
// AllocateHIDObjectFromIOHIDDeviceRef( )
|
||||
//
|
||||
// returns:
|
||||
// NULL, or acceptable io_object_t
|
||||
//
|
||||
//---------------------------------------------------------------------------------
|
||||
io_service_t AllocateHIDObjectFromIOHIDDeviceRef(IOHIDDeviceRef inIOHIDDeviceRef) {
|
||||
io_service_t result = 0L;
|
||||
if ( inIOHIDDeviceRef ) {
|
||||
// Set up the matching criteria for the devices we're interested in.
|
||||
// We are interested in instances of class IOHIDDevice.
|
||||
// matchingDict is consumed below( in IOServiceGetMatchingService )
|
||||
// so we have no leak here.
|
||||
CFMutableDictionaryRef matchingDict = IOServiceMatching(kIOHIDDeviceKey);
|
||||
if ( matchingDict ) {
|
||||
// Add a key for locationID to our matching dictionary. This works for matching to
|
||||
// IOHIDDevices, so we will only look for a device attached to that particular port
|
||||
// on the machine.
|
||||
CFTypeRef tCFTypeRef = IOHIDDeviceGetProperty( inIOHIDDeviceRef, CFSTR(kIOHIDLocationIDKey) );
|
||||
if ( tCFTypeRef ) {
|
||||
CFDictionaryAddValue(matchingDict, CFSTR(kIOHIDLocationIDKey), tCFTypeRef);
|
||||
// CFRelease( tCFTypeRef ); // don't release objects that we "Get".
|
||||
|
||||
// IOServiceGetMatchingService assumes that we already know that there is only one device
|
||||
// that matches. This way we don't have to do the whole iteration dance to look at each
|
||||
// device that matches. This is a new API in 10.2
|
||||
result = IOServiceGetMatchingService(kIOMasterPortDefault, matchingDict);
|
||||
}
|
||||
|
||||
// Note: We're not leaking the matchingDict.
|
||||
// One reference is consumed by IOServiceGetMatchingServices
|
||||
}
|
||||
}
|
||||
|
||||
return (result);
|
||||
} // AllocateHIDObjectFromIOHIDDeviceRef
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
//
|
||||
// FreeHIDObject( )
|
||||
//
|
||||
//---------------------------------------------------------------------------------
|
||||
bool FreeHIDObject(io_service_t inHIDObject) {
|
||||
kern_return_t kr;
|
||||
|
||||
kr = IOObjectRelease(inHIDObject);
|
||||
|
||||
return (kIOReturnSuccess == kr);
|
||||
} // FreeHIDObject
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
// File: ImmrHIDUtilAddOn.h
|
||||
// Abstract: Glue code to convert IOHIDDeviceRef's to (FFB) io_object_t's
|
||||
// Version: 2.0
|
||||
//
|
||||
// Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple
|
||||
// Inc. ("Apple") in consideration of your agreement to the following
|
||||
// terms, and your use, installation, modification or redistribution of
|
||||
// this Apple software constitutes acceptance of these terms. If you do
|
||||
// not agree with these terms, please do not use, install, modify or
|
||||
// redistribute this Apple software.
|
||||
//
|
||||
// In consideration of your agreement to abide by the following terms, and
|
||||
// subject to these terms, Apple grants you a personal, non-exclusive
|
||||
// license, under Apple's copyrights in this original Apple software (the
|
||||
// "Apple Software"), to use, reproduce, modify and redistribute the Apple
|
||||
// Software, with or without modifications, in source and/or binary forms;
|
||||
// provided that if you redistribute the Apple Software in its entirety and
|
||||
// without modifications, you must retain this notice and the following
|
||||
// text and disclaimers in all such redistributions of the Apple Software.
|
||||
// Neither the name, trademarks, service marks or logos of Apple Inc. may
|
||||
// be used to endorse or promote products derived from the Apple Software
|
||||
// without specific prior written permission from Apple. Except as
|
||||
// expressly stated in this notice, no other rights or licenses, express or
|
||||
// implied, are granted by Apple herein, including but not limited to any
|
||||
// patent rights that may be infringed by your derivative works or by other
|
||||
// works in which the Apple Software may be incorporated.
|
||||
//
|
||||
// The Apple Software is provided by Apple on an "AS IS" basis. APPLE
|
||||
// MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
|
||||
// THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
|
||||
// FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
|
||||
// OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
|
||||
//
|
||||
// IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
|
||||
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
|
||||
// MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
|
||||
// AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
|
||||
// STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (C) 2009 Apple Inc. All Rights Reserved.
|
||||
//
|
||||
//*****************************************************
|
||||
#include <IOKit/IOKitLib.h>
|
||||
#include <IOKit/hid/IOHIDLib.h>
|
||||
|
||||
extern io_service_t AllocateHIDObjectFromIOHIDDeviceRef(IOHIDDeviceRef inIOHIDDeviceRef);
|
||||
extern bool FreeHIDObject(io_object_t inHIDObject);
|
||||
Loading…
Reference in New Issue