aboutsummaryrefslogtreecommitdiffstats
path: root/plugins/OSX/src/native
diff options
context:
space:
mode:
authorgregorypierce <[email protected]>2003-08-05 18:33:07 +0000
committergregorypierce <[email protected]>2003-08-05 18:33:07 +0000
commit519026dcf05185042aa923b7931ef0606155673a (patch)
treeb9f6f8eb7c47c581442ebc60246ea33efaddb5a5 /plugins/OSX/src/native
parent490d2d4554a2eb2d34f34399b712c564326c47de (diff)
Initial release of native library
git-svn-id: file:///home/sven/projects/JOGL/git-svn/svn-server-sync/jinput/trunk@37 e343933a-64c8-49c5-92b1-88f2ce3e89e8
Diffstat (limited to 'plugins/OSX/src/native')
-rw-r--r--plugins/OSX/src/native/jinputjnilib.c716
1 files changed, 716 insertions, 0 deletions
diff --git a/plugins/OSX/src/native/jinputjnilib.c b/plugins/OSX/src/native/jinputjnilib.c
new file mode 100644
index 0000000..0d73db3
--- /dev/null
+++ b/plugins/OSX/src/native/jinputjnilib.c
@@ -0,0 +1,716 @@
+/*
+ * %W% %E%
+ *
+ * Copyright 2002 Sun Microsystems, Inc. All rights reserved.
+ * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ */
+/*****************************************************************************
+* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* - Redistribution of source code must retain the above copyright notice,
+* this list of conditions and the following disclaimer.
+*
+* - Redistribution in binary form must reproduce the above copyright notice,
+* this list of conditions and the following disclaimer in the documentation
+* and/or other materails provided with the distribution.
+*
+* Neither the name Sun Microsystems, Inc. or the names of the contributors
+* may be used to endorse or promote products derived from this software
+* without specific prior written permission.
+*
+* This software is provided "AS IS," without a warranty of any kind.
+* ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
+* ANY IMPLIED WARRANT OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+* NON-INFRINGEMEN, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND
+* ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS
+* A RESULT OF USING, MODIFYING OR DESTRIBUTING THIS SOFTWARE OR ITS
+* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
+* REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
+* INCIDENTAL OR PUNITIVE DAMAGES. HOWEVER CAUSED AND REGARDLESS OF THE THEORY
+* OF LIABILITY, ARISING OUT OF THE USE OF OUR INABILITY TO USE THIS SOFTWARE,
+* EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+*
+* You acknowledge that this software is not designed or intended for us in
+* the design, construction, operation or maintenance of any nuclear facility
+*
+*****************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <sys/errno.h>
+#include <sysexits.h>
+#include <mach/mach.h>
+#include <mach/mach_error.h>
+#include <IOKit/IOKitLib.h>
+#include <IOKit/IOCFPlugIn.h>
+#include <IOKit/hid/IOHIDLib.h>
+#include <IOKit/hid/IOHIDKeys.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include <Carbon/Carbon.h>
+#include "net_java_games_input_OSXEnvironmentPlugin.h"
+
+Boolean init( JNIEnv * env );
+void createMasterPort();
+void disposeMasterPort();
+
+
+void createHIDDevice(io_object_t hidDevice, IOHIDDeviceInterface ***hidDeviceInterface);
+IOReturn openDevice(IOHIDDeviceInterface ***hidDeviceInterface);
+IOReturn closeDevice(IOHIDDeviceInterface ***hidDeviceInterface);
+
+
+Boolean showDictionaryElement (CFDictionaryRef dictionary, CFStringRef key);
+void showProperty(const void * key, const void * value);
+void displayCFProperty(CFStringRef object, CFTypeRef value);
+void CFObjectShow( CFTypeRef value );
+void CFObjectSend( CFTypeRef value );
+
+jclass CLASS_JNIWrapper = NULL;
+jmethodID MID_AddDevice = NULL;
+jmethodID MID_AddControllerElement = NULL;
+mach_port_t masterPort = NULL;
+io_iterator_t hidObjectIterator;
+int gElementIndex;
+
+long elementCookie;
+long collectionType;
+long min;
+long max;
+long scaledMin;
+long scaledMax;
+long size;
+jboolean isRelative;
+jboolean isWrapping;
+jboolean isNonLinear;
+
+
+JNIEnv * lpEnv;
+jlong lpDevice;
+
+
+
+
+Boolean showDictionaryElement (CFDictionaryRef dictionary, CFStringRef key)
+{
+ CFTypeRef value = CFDictionaryGetValue (dictionary, key);
+ if (value)
+ {
+ const char * c = CFStringGetCStringPtr (key, CFStringGetSystemEncoding ());
+ if (c)
+ {
+ printf ("%s", c);
+ }
+ else
+ {
+ CFIndex bufferSize = CFStringGetLength (key) + 1;
+ char * buffer = (char *)malloc (bufferSize);
+ if (buffer)
+ {
+ if (CFStringGetCString (key, buffer, bufferSize, CFStringGetSystemEncoding ()))
+ printf ("%s", buffer);
+ free(buffer);
+ }
+ }
+
+ printf("=");
+
+ CFObjectShow( value );
+
+ printf("\n");
+ }
+ return (value != NULL);
+}
+
+static void showCFArray (const void * value, void * parameter)
+{
+ if (CFGetTypeID (value) != CFDictionaryGetTypeID ())
+ {
+ return;
+ }
+
+ CFObjectShow(value);
+}
+
+void CFObjectShow( CFTypeRef value )
+{
+ CFTypeID type = CFGetTypeID(value);
+ if (type == CFArrayGetTypeID())
+ {
+
+ printf("Array Type\n");
+ CFRange range = {0, CFArrayGetCount (value)};
+ CFIndex savedIndex = gElementIndex;
+
+ //Show an element array containing one or more element dictionaries
+ gElementIndex = 0; //Reset index to zero
+ CFArrayApplyFunction (value, range, showCFArray, 0);
+
+ gElementIndex = savedIndex;
+ }
+ else if (type == CFBooleanGetTypeID())
+ {
+ printf(CFBooleanGetValue(value) ? "true" : "false");
+ }
+ else if (type == CFDictionaryGetTypeID())
+ {
+ printf("Map\n");
+
+
+ showDictionaryElement (value, CFSTR(kIOHIDElementCookieKey));
+ showDictionaryElement (value, CFSTR(kIOHIDElementCollectionTypeKey));
+
+ showDictionaryElement (value, CFSTR(kIOHIDElementMinKey));
+ showDictionaryElement (value, CFSTR(kIOHIDElementMaxKey));
+ showDictionaryElement (value, CFSTR(kIOHIDElementScaledMinKey));
+ showDictionaryElement (value, CFSTR(kIOHIDElementScaledMaxKey));
+
+ showDictionaryElement (value, CFSTR(kIOHIDElementSizeKey));
+ showDictionaryElement (value, CFSTR(kIOHIDElementIsRelativeKey));
+ showDictionaryElement (value, CFSTR(kIOHIDElementIsWrappingKey));
+ showDictionaryElement (value, CFSTR(kIOHIDElementIsNonLinearKey));
+#ifdef kIOHIDElementHasPreferredStateKey
+ showDictionaryElement (value, CFSTR(kIOHIDElementHasPreferredStateKey));
+#else
+ showDictionaryElement (value, CFSTR(kIOHIDElementHasPreferedStateKey));
+#endif
+ showDictionaryElement (value, CFSTR(kIOHIDElementHasNullStateKey));
+ showDictionaryElement (value, CFSTR(kIOHIDElementVendorSpecificKey));
+ showDictionaryElement (value, CFSTR(kIOHIDElementUnitKey));
+ showDictionaryElement (value, CFSTR(kIOHIDElementUnitExponentKey));
+ showDictionaryElement (value, CFSTR(kIOHIDElementNameKey));
+ showDictionaryElement (value, CFSTR(kIOHIDElementKey));
+
+ printf("\n\n\n");
+ }
+ else if (type == CFNumberGetTypeID())
+ {
+ long number;
+ if (CFNumberGetValue (value, kCFNumberLongType, &number))
+ {
+ printf("0x%lx (%ld)", number, number);
+ }
+ }
+ else if (type == CFStringGetTypeID())
+ {
+ const char * c = CFStringGetCStringPtr (value, CFStringGetSystemEncoding ());
+ if (c)
+ {
+ printf ("%s", c);
+ }
+ else
+ {
+ CFIndex bufferSize = CFStringGetLength (value) + 1;
+ char * buffer = (char *)malloc (bufferSize);
+ if (buffer)
+ {
+ if (CFStringGetCString (value, buffer, bufferSize, CFStringGetSystemEncoding ()))
+ {
+ printf ("%s", buffer);
+ }
+
+ free(buffer);
+ }
+ }
+ }
+}
+
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////
+
+Boolean init(JNIEnv* env)
+{
+ CLASS_JNIWrapper = (*env)->FindClass(env,"net/java/games/input/OSXEnvironmentPlugin");
+ if ( CLASS_JNIWrapper == NULL )
+ {
+ printf("Class OSXEnvironmentPlugin not found... \n");
+ return FALSE;
+ }
+
+ MID_AddDevice = (*env)->GetMethodID(env, CLASS_JNIWrapper, "addController", "(JLjava/lang/String;I)V");
+ if (MID_AddDevice == NULL)
+ {
+ printf("Method addController not found... \n");
+ return FALSE;
+ }
+
+ MID_AddControllerElement = (*env)->GetMethodID(env, CLASS_JNIWrapper, "addControllerElement", "(JJILjava/lang/String;IIIIIZZZZZ)V");
+ if (MID_AddDeviceElement == NULL)
+ {
+ printf("Method addControllerElement not found... \n");
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+void createMasterPort()
+{
+ IOReturn ioReturnValue = kIOReturnSuccess;
+
+ //Get a Mach port to initiate communication with I/O Kit.
+ //
+ ioReturnValue = IOMasterPort(bootstrap_port, &masterPort);
+}
+
+void disposeMasterPort()
+{
+ //Free master port if we created one.
+ //
+ if (masterPort)
+ {
+ mach_port_deallocate(mach_task_self(), masterPort);
+ }
+}
+
+void createHIDDevice( io_object_t hidDevice, IOHIDDeviceInterface ***hidDeviceInterface )
+{
+ io_name_t className;
+ IOCFPlugInInterface **plugInInterface = NULL;
+ HRESULT plugInResult = S_OK;
+ SInt32 score = 0;
+ IOReturn ioReturnValue = kIOReturnSuccess;
+
+ ioReturnValue = IOObjectGetClass(hidDevice, className);
+ if ( ioReturnValue != kIOReturnSuccess )
+ {
+ printf("Failed to getIOObject class name.");
+ }
+
+ printf("Found device type %s\n", className);
+
+ ioReturnValue = IOCreatePlugInInterfaceForService(hidDevice,
+ kIOHIDDeviceUserClientTypeID,
+ kIOCFPlugInInterfaceID,
+ &plugInInterface,
+ &score);
+
+ if (ioReturnValue == kIOReturnSuccess)
+ {
+ //Call a method of the intermediate plug-in to create the device
+ //interface
+ plugInResult = (*plugInInterface)->QueryInterface(plugInInterface,
+ CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID),
+ (LPVOID) hidDeviceInterface);
+ if ( plugInResult != S_OK )
+ {
+ printf("Couldn't create HID class device interface");
+ }
+
+ (*plugInInterface)->Release(plugInInterface);
+ }
+}
+
+IOReturn openDevice(IOHIDDeviceInterface ***hidDeviceInterface)
+{
+ IOReturn ioReturnValue = kIOReturnSuccess;
+
+ //todo, change this to be controlled from the java layer at each device
+ //
+ ioReturnValue = (**hidDeviceInterface)->open(*hidDeviceInterface, 0 );
+ if ( ioReturnValue != kIOReturnSuccess )
+ {
+ printf("Unable to open device - return [%d]\n", ioReturnValue );
+ }
+ else
+ {
+ printf("Successfully opened device \n");
+ }
+
+ return ioReturnValue;
+}
+
+IOReturn closeDevice(IOHIDDeviceInterface ***hidDeviceInterface)
+{
+ IOReturn ioReturnValue = kIOReturnSuccess;
+
+ ioReturnValue = (**hidDeviceInterface)->close(*hidDeviceInterface);
+ if ( ioReturnValue != kIOReturnSuccess )
+ {
+ printf("Unable to close device - return [%d]\n", ioReturnValue );
+ }
+ else
+ {
+ printf("Successfully closed device \n");
+ }
+
+ // release the device interface
+ //
+ (**hidDeviceInterface)->Release(*hidDeviceInterface);
+
+ return ioReturnValue;
+}
+
+void addControllerElements( CFMutableDictionaryRef dictionary, CFStringRef key )
+{
+ printf("Adding controller elements\n");
+
+ CFTypeRef value = CFDictionaryGetValue (dictionary, key);
+ if (value)
+ {
+ CFTypeID type = CFGetTypeID(value);
+
+ CFRange range = {0, CFArrayGetCount (value)};
+ CFIndex savedIndex = gElementIndex;
+
+ //Show an element array containing one or more element dictionaries
+ gElementIndex = 0; //Reset index to zero
+ CFArrayApplyFunction (value, range, sendCFArray, 0);
+
+ gElementIndex = savedIndex;
+ }
+}
+
+static void sendCFArray(const void * value, void * parameter)
+{
+ if (CFGetTypeID (value) != CFDictionaryGetTypeID ())
+ {
+ return;
+ }
+
+ CFObjectSend(value);
+}
+
+void CFObjectSend( CFTypeRef value )
+{
+ CFTypeID type = CFGetTypeID(value);
+ if (type == CFArrayGetTypeID())
+ {
+
+ printf("Array Type\n");
+ CFRange range = {0, CFArrayGetCount (value)};
+ CFIndex savedIndex = gElementIndex;
+
+ //Show an element array containing one or more element dictionaries
+ gElementIndex = 0; //Reset index to zero
+ CFArrayApplyFunction (value, range, sendCFArray, 0);
+
+ gElementIndex = savedIndex;
+ }
+ else if (type == CFDictionaryGetTypeID())
+ {
+ printf("Sending Map\n");
+
+
+ CFTypeRef val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementCookieKey) );
+ if ( val )
+ {
+ CFNumberGetValue ( val , kCFNumberLongType, &elementCookie);
+ printf("ElementCookie - 0x%lx (%ld) \n", elementCookie, elementCookie);
+ }
+
+ val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementCollectionTypeKey) );
+ if ( val )
+ {
+ CFNumberGetValue ( val, kCFNumberLongType, &collectionType);
+ printf("collection Type - 0x%lx (%ld) \n", collectionType, collectionType);
+ }
+
+ val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementMinKey) );
+ if ( val )
+ {
+ CFNumberGetValue ( val, kCFNumberLongType, &min);
+ printf("min - 0x%lx (%ld) \n", min, min);
+ }
+
+ val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementMaxKey) );
+ if ( val )
+ {
+ CFNumberGetValue ( val, kCFNumberLongType, &max);
+ printf("max - 0x%lx (%ld) \n", max, max);
+ }
+
+ val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementScaledMinKey) );
+ if ( val )
+ {
+ CFNumberGetValue ( val, kCFNumberLongType, &scaledMin);
+ printf("scaledMin - 0x%lx (%ld) \n", scaledMin, scaledMin);
+ }
+
+ val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementScaledMaxKey) );
+ if ( val )
+ {
+ CFNumberGetValue ( val, kCFNumberLongType, &scaledMax);
+ printf("scaledMax - 0x%lx (%ld) \n", scaledMax, scaledMax);
+ }
+
+ val = CFDictionaryGetValue( value, CFSTR(kIOHIDElementSizeKey) );
+ if ( val )
+ {
+ CFNumberGetValue ( val, kCFNumberLongType, &size);
+ printf("Size - 0x%lx (%ld) \n", size, size);
+ }
+
+
+ printf("End of element definition \n");
+
+/*
+
+ jboolean isRelative;
+ isRelative = (CFBooleanGetValue(value) ? JNI_TRUE : JNI_FALSE);
+
+
+ jboolean isWrapping;
+ isWrapping = (CFBooleanGetValue(value) ? JNI_TRUE : JNI_FALSE);
+
+ jboolean isNonLinear;
+ isNonLinear = (CFBooleanGetValue(value) ? JNI_TRUE : JNI_FALSE);
+*/
+#ifdef kIOHIDElementHasPreferredStateKey
+ //showDictionaryElement (value, CFSTR(kIOHIDElementHasPreferredStateKey));
+#else
+ //showDictionaryElement (value, CFSTR(kIOHIDElementHasPreferedStateKey));
+#endif
+ //showDictionaryElement (value, CFSTR(kIOHIDElementHasNullStateKey));
+ //showDictionaryElement (value, CFSTR(kIOHIDElementVendorSpecificKey));
+
+ //showDictionaryElement (value, CFSTR(kIOHIDElementKey));
+
+ //showDictionaryElement (value, CFSTR(kIOHIDElementKey));
+
+ CFTypeRef object = CFDictionaryGetValue (value, CFSTR(kIOHIDElementKey));
+ if (object)
+ {
+ CFObjectSend( object );
+ }
+
+ printf("\n\n\n");
+ }
+}
+
+/*
+ * Class: net_java_games_input_OSXEnvironmentPlugin
+ * Method: hidCreate
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_hidCreate
+ (JNIEnv * env, jobject obj)
+{
+ if ( init( env ) )
+ {
+ createMasterPort();
+ }
+}
+/*
+ * Class: net_java_games_input_OSXEnvironmentPlugin
+ * Method: hidDispose
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_hidDispose
+ (JNIEnv * env, jobject obj)
+{
+ disposeMasterPort();
+}
+
+
+/*
+ * Class: net_java_games_input_OSXEnvironmentPlugin
+ * Method: enumDevices
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_enumDevices
+ (JNIEnv * env, jobject obj)
+{
+ CFMutableDictionaryRef hidMatchDictionary = NULL;
+ IOReturn ioReturnValue = kIOReturnSuccess;
+ Boolean noMatchingDevices = false;
+
+ // Set up a matching dictionary to search the I/O Registry by class
+ // name for all HID class devices
+ //
+ hidMatchDictionary = IOServiceMatching(kIOHIDDeviceKey);
+
+ // Now search I/O Registry for matching devices.
+ //
+ ioReturnValue = IOServiceGetMatchingServices(masterPort, hidMatchDictionary, &hidObjectIterator);
+
+ noMatchingDevices = ((ioReturnValue != kIOReturnSuccess) | (hidObjectIterator == NULL));
+
+ // If search is unsuccessful, print message and hang.
+ //
+ if (noMatchingDevices)
+ {
+ printf("No matching HID class devices found.");
+ }
+
+ // IOServiceGetMatchingServices consumes a reference to the
+ // dictionary, so we don't need to release the dictionary ref.
+ //
+ hidMatchDictionary = NULL;
+
+ io_object_t hidDevice = NULL;
+ IOHIDDeviceInterface **hidDeviceInterface = NULL;
+ CFMutableDictionaryRef properties = 0;
+ char path[512];
+ kern_return_t result;
+
+
+ while ((hidDevice = IOIteratorNext(hidObjectIterator)))
+ {
+ result = IORegistryEntryGetPath(hidDevice, kIOServicePlane, path);
+
+ if ( result == KERN_SUCCESS )
+ {
+ result = IORegistryEntryCreateCFProperties(hidDevice,
+ &properties,
+ kCFAllocatorDefault,
+ kNilOptions);
+ }
+
+ if ((result == KERN_SUCCESS) && properties)
+ {
+ //showDictionaryElement(properties, CFSTR(kIOHIDTransportKey));
+ //showDictionaryElement(properties, CFSTR(kIOHIDVendorKey));
+ //printf("ProductID: "); showDictionaryElement(properties, CFSTR(kIOHIDProductIDKey));
+ //printf("VersionNumber: "); showDictionaryElement(properties, CFSTR(kIOHIDVersionNumberKey));
+ //printf("Manufacturer: "); showDictionaryElement(properties, CFSTR(kIOHIDManufacturerKey));
+ //printf("ProductKey: "); showDictionaryElement(properties, CFSTR(kIOHIDProductKey));
+ //printf("SerialNumber: "); showDictionaryElement(properties, CFSTR(kIOHIDSerialNumberKey));
+ //showDictionaryElement(properties, CFSTR(kIOHIDLocationIDKey));
+ //printf("PrimaryUsage: "); showDictionaryElement(properties, CFSTR(kIOHIDPrimaryUsageKey));
+ //showDictionaryElement(properties, CFSTR(kIOHIDPrimaryUsagePageKey));
+ //showDictionaryElement(properties, CFSTR(kIOHIDElementKey));
+
+
+
+ // get the product name
+ //
+ CFTypeRef productName = CFDictionaryGetValue (properties, CFSTR(kIOHIDProductKey));
+
+ // get the usage for this product
+ //
+ long usage;
+ CFNumberGetValue ( CFDictionaryGetValue( properties, CFSTR(kIOHIDPrimaryUsageKey) ), kCFNumberLongType, &usage);
+
+
+ createHIDDevice( hidDevice, &hidDeviceInterface );
+
+ IOObjectRelease( hidDevice );
+
+ if ( hidDeviceInterface != NULL )
+ {
+ (*env)->CallVoidMethod(env, obj, MID_AddDevice,
+ (jlong)(long)hidDeviceInterface,
+ (*env)->NewStringUTF( env, CFStringGetCStringPtr( productName, CFStringGetSystemEncoding()) ),
+ (jint)usage );
+ lpEnv = env;
+ lpDevice = (jlong)(long)hidDeviceInterface;
+
+ addControllerElements( properties, CFSTR(kIOHIDElementKey) );
+
+
+ }
+
+ //Release the properties dictionary
+ CFRelease(properties);
+ }
+
+ }
+
+ IOObjectRelease(hidObjectIterator);
+}
+
+/*
+ * Class: net_java_games_input_OSXEnvironmentPlugin
+ * Method: openDevice
+ * Signature: (JI)J
+ */
+JNIEXPORT jlong JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_openDevice
+ (JNIEnv * env, jobject obj, jlong lpDevice, jint queueDepth)
+{
+ IOHIDDeviceInterface **hidDeviceInterface = NULL;
+ hidDeviceInterface = (IOHIDDeviceInterface **) (long)lpDevice;
+ openDevice( &hidDeviceInterface );
+
+
+ IOHIDQueueInterface **queue = NULL;
+ queue = (*hidDeviceInterface)->allocQueue(hidDeviceInterface);
+
+ if (queue)
+ {
+ // create a queue and specify how deep they want the input queue to be
+ //
+ (*queue)->create( queue, 0, (int)queueDepth );
+ printf("InputQueue created %lx with depth %d \n", queue, (int)queueDepth );
+
+ // todo - add the buttons/keys we want to receive from the queue
+
+
+ // start the input queue
+ //
+ (*queue)->start( queue );
+ }
+ else
+ {
+ printf("Unable to create queue for device! \n");
+ }
+
+ return (jlong)(long)queue;
+
+}
+
+/*
+ * Class: net_java_games_input_OSXEnvironmentPlugin
+ * Method: closeDevice
+ * Signature: (JJ)V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_closeDevice
+ (JNIEnv * env, jobject obj, jlong lpDevice, jlong lpQueue)
+{
+ IOHIDDeviceInterface **hidDeviceInterface = NULL;
+ hidDeviceInterface = (IOHIDDeviceInterface **) (long)lpDevice;
+
+ IOHIDQueueInterface **queue = NULL;
+ queue = (IOHIDQueueInterface **)(long)lpQueue;
+
+ // stop the queue
+ //
+ (*queue)->stop(queue);
+
+ // dispose of the queue
+ //
+ (*queue)->dispose(queue);
+
+ // release the queue
+ //
+ (*queue)->Release(queue);
+
+ // close the input device
+ //
+ closeDevice( &hidDeviceInterface );
+}
+
+/*
+ * Class: net_java_games_input_OSXEnvironmentPlugin
+ * Method: pollDevice
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_net_java_games_input_OSXEnvironmentPlugin_pollDevice
+ (JNIEnv * env, jobject obj, jlong lpQueue)
+{
+ IOHIDEventStruct event;
+
+ IOHIDQueueInterface **queue = NULL;
+ queue = (IOHIDQueueInterface **)(long)lpQueue;
+
+ AbsoluteTime zeroTime = {0,0};
+
+ HRESULT result = (*queue)->getNextEvent(queue, &event, zeroTime, 0);
+ if ( result )
+ {
+ printf("Queue getNextEvent result: %lx\n", result );
+ }
+ else
+ {
+ printf("Queue event[%lx] %ld\n", (unsigned long) event.elementCookie, event.value );
+ }
+
+
+}
+
+
+