// File: main.c |
// Abstract: source code for HID LED test tool |
// Version: 1.3 |
// |
// 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) 2015 Apple Inc. All Rights Reserved. |
// |
// **************************************************** |
#pragma mark - |
#pragma mark * complation directives * |
// ---------------------------------------------------- |
|
#ifndef FALSE |
#define FALSE 0 |
#define TRUE !FALSE |
#endif |
|
// **************************************************** |
#pragma mark - |
#pragma mark * includes & imports * |
// ---------------------------------------------------- |
|
#include <CoreFoundation/CoreFoundation.h> |
#include <Carbon/Carbon.h> |
#include <IOKit/hid/IOHIDLib.h> |
|
// **************************************************** |
#pragma mark - |
#pragma mark * typedef's, struct's, enums, defines, etc. * |
// ---------------------------------------------------- |
// function to create a matching dictionary for usage page & usage |
static CFMutableDictionaryRef hu_CreateMatchingDictionaryUsagePageUsage( Boolean isDeviceNotElement, |
UInt32 inUsagePage, |
UInt32 inUsage ) |
{ |
// create a dictionary to add usage page / usages to |
CFMutableDictionaryRef result = CFDictionaryCreateMutable( kCFAllocatorDefault, |
0, |
&kCFTypeDictionaryKeyCallBacks, |
&kCFTypeDictionaryValueCallBacks ); |
|
if ( result ) { |
if ( inUsagePage ) { |
// Add key for device type to refine the matching dictionary. |
CFNumberRef pageCFNumberRef = CFNumberCreate( kCFAllocatorDefault, kCFNumberIntType, &inUsagePage ); |
|
if ( pageCFNumberRef ) { |
if ( isDeviceNotElement ) { |
CFDictionarySetValue( result, CFSTR( kIOHIDDeviceUsagePageKey ), pageCFNumberRef ); |
} else { |
CFDictionarySetValue( result, CFSTR( kIOHIDElementUsagePageKey ), pageCFNumberRef ); |
} |
CFRelease( pageCFNumberRef ); |
|
// note: the usage is only valid if the usage page is also defined |
if ( inUsage ) { |
CFNumberRef usageCFNumberRef = CFNumberCreate( kCFAllocatorDefault, kCFNumberIntType, &inUsage ); |
|
if ( usageCFNumberRef ) { |
if ( isDeviceNotElement ) { |
CFDictionarySetValue( result, CFSTR( kIOHIDDeviceUsageKey ), usageCFNumberRef ); |
} else { |
CFDictionarySetValue( result, CFSTR( kIOHIDElementUsageKey ), usageCFNumberRef ); |
} |
CFRelease( usageCFNumberRef ); |
} else { |
fprintf( stderr, "%s: CFNumberCreate( usage ) failed.", __PRETTY_FUNCTION__ ); |
} |
} |
} else { |
fprintf( stderr, "%s: CFNumberCreate( usage page ) failed.", __PRETTY_FUNCTION__ ); |
} |
} |
} else { |
fprintf( stderr, "%s: CFDictionaryCreateMutable failed.", __PRETTY_FUNCTION__ ); |
} |
return result; |
} // hu_CreateMatchingDictionaryUsagePageUsage |
|
int main( int argc, const char * argv[] ) |
{ |
#pragma unused ( argc, argv ) |
IOHIDDeviceRef * tIOHIDDeviceRefs = nil; |
|
// create a IO HID Manager reference |
IOHIDManagerRef tIOHIDManagerRef = IOHIDManagerCreate( kCFAllocatorDefault, kIOHIDOptionsTypeNone ); |
require( tIOHIDManagerRef, Oops ); |
|
// Create a device matching dictionary |
CFDictionaryRef matchingCFDictRef = hu_CreateMatchingDictionaryUsagePageUsage( TRUE, |
kHIDPage_GenericDesktop, |
kHIDUsage_GD_Keyboard ); |
require( matchingCFDictRef, Oops ); |
|
// set the HID device matching dictionary |
IOHIDManagerSetDeviceMatching( tIOHIDManagerRef, matchingCFDictRef ); |
|
if ( matchingCFDictRef ) { |
CFRelease( matchingCFDictRef ); |
} |
|
// Now open the IO HID Manager reference |
IOReturn tIOReturn = IOHIDManagerOpen( tIOHIDManagerRef, kIOHIDOptionsTypeNone ); |
require_noerr( tIOReturn, Oops ); |
|
// and copy out its devices |
CFSetRef deviceCFSetRef = IOHIDManagerCopyDevices( tIOHIDManagerRef ); |
require( deviceCFSetRef, Oops ); |
|
// how many devices in the set? |
CFIndex deviceIndex, deviceCount = CFSetGetCount( deviceCFSetRef ); |
|
// allocate a block of memory to extact the device ref's from the set into |
tIOHIDDeviceRefs = malloc( sizeof( IOHIDDeviceRef ) * deviceCount ); |
if (!tIOHIDDeviceRefs) { |
CFRelease(deviceCFSetRef); |
deviceCFSetRef = NULL; |
goto Oops; |
} |
|
// now extract the device ref's from the set |
CFSetGetValues( deviceCFSetRef, (const void **) tIOHIDDeviceRefs ); |
CFRelease(deviceCFSetRef); |
deviceCFSetRef = NULL; |
|
// before we get into the device loop we'll setup our element matching dictionary |
matchingCFDictRef = hu_CreateMatchingDictionaryUsagePageUsage( FALSE, kHIDPage_LEDs, 0 ); |
require( matchingCFDictRef, Oops ); |
|
int pass; // do 256 passes |
for ( pass = 0; pass < 256; pass++ ) { |
Boolean delayFlag = FALSE; // if we find an LED element we'll set this to TRUE |
|
printf( "pass = %d.\n", pass ); |
for ( deviceIndex = 0; deviceIndex < deviceCount; deviceIndex++ ) { |
|
// if this isn't a keyboard device... |
if ( !IOHIDDeviceConformsTo( tIOHIDDeviceRefs[deviceIndex], kHIDPage_GenericDesktop, kHIDUsage_GD_Keyboard ) ) { |
continue; // ...skip it |
} |
|
printf( " device = %p.\n", tIOHIDDeviceRefs[deviceIndex] ); |
|
// copy all the elements |
CFArrayRef elementCFArrayRef = IOHIDDeviceCopyMatchingElements( tIOHIDDeviceRefs[deviceIndex], |
matchingCFDictRef, |
kIOHIDOptionsTypeNone ); |
require( elementCFArrayRef, next_device ); |
|
// for each device on the system these values are divided by the value ranges of all LED elements found |
// for example, if the first four LED element have a range of 0-1 then the four least significant bits of |
// this value will be sent to these first four LED elements, etc. |
int device_value = pass; |
|
// iterate over all the elements |
CFIndex elementIndex, elementCount = CFArrayGetCount( elementCFArrayRef ); |
for ( elementIndex = 0; elementIndex < elementCount; elementIndex++ ) { |
IOHIDElementRef tIOHIDElementRef = ( IOHIDElementRef ) CFArrayGetValueAtIndex( elementCFArrayRef, elementIndex ); |
require( tIOHIDElementRef, next_element ); |
|
uint32_t usagePage = IOHIDElementGetUsagePage( tIOHIDElementRef ); |
|
// if this isn't an LED element... |
if ( kHIDPage_LEDs != usagePage ) { |
continue; // ...skip it |
} |
|
uint32_t usage = IOHIDElementGetUsage( tIOHIDElementRef ); |
IOHIDElementType tIOHIDElementType = IOHIDElementGetType( tIOHIDElementRef ); |
|
printf( " element = %p (page: %d, usage: %d, type: %d ).\n", |
tIOHIDElementRef, usagePage, usage, tIOHIDElementType ); |
|
// get the logical mix/max for this LED element |
CFIndex minCFIndex = IOHIDElementGetLogicalMin( tIOHIDElementRef ); |
CFIndex maxCFIndex = IOHIDElementGetLogicalMax( tIOHIDElementRef ); |
|
// calculate the range |
CFIndex modCFIndex = maxCFIndex - minCFIndex + 1; |
|
// compute the value for this LED element |
CFIndex tCFIndex = minCFIndex + ( device_value % modCFIndex ); |
device_value /= modCFIndex; |
|
printf( " value = 0x%08lX.\n", tCFIndex ); |
|
uint64_t timestamp = 0; // create the IO HID Value to be sent to this LED element |
IOHIDValueRef tIOHIDValueRef = IOHIDValueCreateWithIntegerValue( kCFAllocatorDefault, tIOHIDElementRef, timestamp, tCFIndex ); |
if ( tIOHIDValueRef ) { |
// now set it on the device |
tIOReturn = IOHIDDeviceSetValue( tIOHIDDeviceRefs[deviceIndex], tIOHIDElementRef, tIOHIDValueRef ); |
CFRelease( tIOHIDValueRef ); |
require_noerr( tIOReturn, next_element ); |
delayFlag = TRUE; // set this TRUE so we'll delay before changing our LED values again |
} |
next_element: ; |
continue; |
} |
CFRelease( elementCFArrayRef ); |
next_device: ; |
continue; |
} |
|
// if we found an LED we'll delay before continuing |
if ( delayFlag ) { |
usleep( 500000 ); // sleep one half second |
} |
|
// if the mouse is down… |
if (GetCurrentButtonState()) { |
break; // abort pass loop |
} |
} // next pass |
|
if ( matchingCFDictRef ) { |
CFRelease( matchingCFDictRef ); |
} |
Oops: ; |
if ( tIOHIDDeviceRefs ) { |
free(tIOHIDDeviceRefs); |
} |
|
if ( tIOHIDManagerRef ) { |
CFRelease( tIOHIDManagerRef ); |
} |
return 0; |
} /* main */ |
