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

src/cocoa/HID_Config_Utilities.c

@@ -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

src/cocoa/HID_Error_Handler.c

@@ -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

src/cocoa/HID_Queue_Utilities.c

@@ -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 */

src/cocoa/HID_Utilities_External.h

@@ -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_

src/cocoa/IOHIDDevice_.c

@@ -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
+
+//*****************************************************

src/cocoa/IOHIDDevice_.h

@@ -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__ //

src/cocoa/IOHIDElement_.c

@@ -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
+
+//*****************************************************

src/cocoa/IOHIDElement_.h

@@ -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___ //

src/cocoa/IOHIDLib_.h

@@ -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___

src/cocoa/ImmrHIDUtilAddOn.c

@@ -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

src/cocoa/ImmrHIDUtilAddOn.h

@@ -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);