shadowfacts/jinput-arm64
1
0
Fork 0
mirror of https://github.com/shadowfacts/jinput-arm64.git synced 2026-01-03 15:29:57 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

no message

Browse source
This commit is contained in:
gregorypierce 2003-08-05 18:32:27 +00:00
parent 6e8132cedf
commit c2688c3ae8
3 changed files with 0 additions and 674 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

130
plugins/OSX/src/java/net/java/games/input/HIDEnvironmentPlugin.java
View file

@ -1,130 +0,0 @@
/*
* %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
*
*****************************************************************************/
package net.java.games.input;
import java.security.AccessController;
import java.util.ArrayList;
import java.util.Iterator;
import net.java.games.input.Controller;
import net.java.games.input.ControllerEnvironment;
import net.java.games.util.plugins.Plugin;
/** OSX HIDManager implementation of controller environment
* @author gregorypierce
* @version 1.0
*/
public class HIDEnvironmentPlugin extends ControllerEnvironment implements Plugin
{
static
{
System.loadLibrary("hidinput");
}
private static final int HIDDEVTYPE_MOUSE = 0x02;
private static final int HIDDEVTYPE_JOYSTICK = 0x04;
private static final int HIDDEVTYPE_GAMEPAD = 0x05;
private static final int HIDDEVTYPE_KEYBOARD = 0x06;
// Permanent array of controllers
private Controller[] controllers;
/**
* Returns the direct input instance, or 0 if failed to initialize
*/
private native void hidInputCreate();
/**
* Enumerates all devices, calling createDevice for each one
*/
private native boolean enumDevices(ArrayList list);
/** Creates new DirectInputEnvironment */
public HIDEnvironmentPlugin()
{
hidInputCreate();
enumControllers();
}
/** Returns a list of all controllers available to this environment,
* or an empty array if there are no controllers in this environment.
* @return An array of controllers that may be empty.
*/
public Controller[] getControllers()
{
return controllers;
}
private void enumControllers()
{
controllers = new Controller[] {};
// Create temporary controller array
ArrayList tempDevices = new ArrayList();
// Eumerate devices
enumDevices(tempDevices);
// Set up permanent controller array
controllers = new Controller[tempDevices.size()];
Iterator it = tempDevices.iterator();
int i = 0;
while (it.hasNext()) {
controllers[i] = (Controller)it.next();
i++;
}
}
/**
* Creates a new device, adding it to the list supplied.
* @param lpDevice A pointer to the IDirectInputDevice for the device.
* @param type The type of device to create, as defined by the constants
* in dinput.h (see DI8DEVTYPE constants above).
* @param productName The product name for the device
* @param instanceName The name of the device
*/
private void addDevice(ArrayList list, long lpDevice,
int type, String productName, String instanceName, boolean polled)
{
Controller c;
}
}

117
plugins/OSX/src/native/JNIWrapper.java
View file

@ -1,117 +0,0 @@
/*
* %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
*
*****************************************************************************/
import java.util.*;
public class JNIWrapper
{
static
{
System.loadLibrary("hidinput");
}
public native void hidCreate();
public native void hidDispose();
public native void enumDevices( ArrayList list );
private static final int HID_DEVICE_MOUSE = 0x02;
private static final int HID_DEVICE_JOYSTICK = 0x04;
private static final int HID_DEVICE_GAMEPAD = 0x05;
private static final int HID_DEVICE_KEYBOARD = 0x06;
private ArrayList devices = new ArrayList();
public JNIWrapper()
{
System.out.println("JNIWrapper instance created");
}
public ArrayList getDevices()
{
return devices;
}
public void setDevices( ArrayList list )
{
devices = list;
}
private void addDevice( ArrayList list, long lpDevice, int type, String productName )
{
//System.out.println("Found device [" + productName + "] of type [" + type + "]");
switch (type)
{
case (HID_DEVICE_MOUSE):
System.out.println("Found mouse [" + productName + "]");
break;
case (HID_DEVICE_JOYSTICK):
System.out.println("Found joystick [" + productName + "]");
break;
case (HID_DEVICE_GAMEPAD):
System.out.println("Found gamepad [" + productName + "]");
break;
case (HID_DEVICE_KEYBOARD):
System.out.println("Found keyboard [" + productName + "]");
break;
default:
System.out.println("Found device of unknown type [" + type + "] - ignoring");
}
System.out.println("Address of device [" + lpDevice + "]");
}
public static void main (String args[])
{
System.out.println("Started JNIWrapper");
JNIWrapper newjni = new JNIWrapper();
System.out.println("Creating HID engine");
newjni.hidCreate();
System.out.println("Enumerating devices");
newjni.enumDevices( newjni.getDevices() );
System.out.println("Disposing HID engine");
newjni.hidDispose();
System.out.println("Done");
}
}

427
plugins/OSX/src/native/hidinputjnilib.c
View file

@ -1,427 +0,0 @@
/*
* %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 "JNIWrapper.h"
Boolean init( JNIEnv * env );
void createMasterPort();
void disposeMasterPort();
void createHIDDevice(io_object_t hidDevice, 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 );
jclass CLASS_JNIWrapper = NULL;
jmethodID MID_AddDevice = NULL;
mach_port_t masterPort = NULL;
io_iterator_t hidObjectIterator;
int gElementIndex;
Boolean init(JNIEnv* env)
{
CLASS_JNIWrapper = (*env)->FindClass(env,"JNIWrapper");
if ( CLASS_JNIWrapper == NULL )
{
printf("Class JNIWrapper not found... \n");
return FALSE;
}
MID_AddDevice = (*env)->GetMethodID(env, CLASS_JNIWrapper, "addDevice", "(Ljava/util/ArrayList;JILjava/lang/String;)V");
if (MID_AddDevice == NULL)
{
printf("Method addDevice 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 get 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);
}
//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");
}
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);
}
Boolean showDictionaryElement (CFDictionaryRef dictionary, CFStringRef key)
{
CFTypeRef object = CFDictionaryGetValue (dictionary, key);
if (object)
{
displayCFProperty (key,object);
}
return (object != NULL);
}
static void showCFArray (const void * value, void * parameter)
{
if (CFGetTypeID (value) != CFDictionaryGetTypeID ())
{
return;
}
CFObjectShow(value);
}
void displayCFProperty(CFStringRef object, CFTypeRef value)
{
const char * c = CFStringGetCStringPtr (object, CFStringGetSystemEncoding ());
if (c)
{
printf ("%s", c);
}
else
{
CFIndex bufferSize = CFStringGetLength (object) + 1;
char * buffer = (char *)malloc (bufferSize);
if (buffer)
{
if (CFStringGetCString (object, buffer, bufferSize, CFStringGetSystemEncoding ()))
printf ("%s", buffer);
free(buffer);
}
}
printf("=");
CFObjectShow( value );
printf("\n");
}
void CFObjectShow( CFTypeRef value )
{
CFTypeID type = CFGetTypeID(value);
if (type == CFArrayGetTypeID())
{
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())
{
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);
}
}
}
}
/*
* Class: JNIWrapper
* Method: hidCreate
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_JNIWrapper_hidCreate
(JNIEnv * env, jobject obj)
{
if ( init( env ) )
{
createMasterPort();
}
}
/*
* Class: JNIWrapper
* Method: hidDispose
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_JNIWrapper_hidDispose
(JNIEnv * env, jobject obj)
{
disposeMasterPort();
}
/*
* Class: JNIWrapper
* Method: enumDevices
* Signature: (Ljava/util/ArrayList;)V
*/
JNIEXPORT void JNICALL Java_JNIWrapper_enumDevices
(JNIEnv * env, jobject obj , jobject list)
{
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));
//printf("\n\n");
CFTypeRef object = CFDictionaryGetValue (properties, CFSTR(kIOHIDProductKey));
long number;
CFNumberGetValue ( CFDictionaryGetValue( properties, CFSTR(kIOHIDPrimaryUsageKey) ), kCFNumberLongType, &number);
createHIDDevice( hidDevice, &hidDeviceInterface );
IOObjectRelease( hidDevice );
if ( hidDeviceInterface != NULL )
{
printf("Ready to use this device \n");
(*env)->CallVoidMethod(env, obj, MID_AddDevice,
list,
(jlong)(long)hidDeviceInterface,
(jint)number,
(*env)->NewStringUTF( env, CFStringGetCStringPtr ( object, CFStringGetSystemEncoding ()) ) );
}
//Release the properties dictionary
CFRelease(properties);
}
}
IOObjectRelease(hidObjectIterator);
}