sdl

hid.cpp (31905B)

---

 //=================== Copyright Valve Corporation, All rights reserved. =======
 //
 // Purpose: A wrapper implementing "HID" API for Android
 //
 //          This layer glues the hidapi API to Android's USB and BLE stack.
 //
 //=============================================================================
 
 #include <jni.h>
 #include <android/log.h>
 #include <pthread.h>
 #include <errno.h>	// For ETIMEDOUT and ECONNRESET
 #include <stdlib.h> // For malloc() and free()
 #include <string.h>	// For memcpy()
 
 #define TAG "hidapi"
 
 // Have error log always available
 #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, TAG, __VA_ARGS__)
 
 #ifdef DEBUG
 #define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, TAG, __VA_ARGS__)
 #define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG, __VA_ARGS__)
 #else
 #define LOGV(...)
 #define LOGD(...)
 #endif
 
 #define SDL_JAVA_PREFIX                                 org_libsdl_app
 #define CONCAT1(prefix, class, function)                CONCAT2(prefix, class, function)
 #define CONCAT2(prefix, class, function)                Java_ ## prefix ## _ ## class ## _ ## function
 #define HID_DEVICE_MANAGER_JAVA_INTERFACE(function)     CONCAT1(SDL_JAVA_PREFIX, HIDDeviceManager, function)
 
 #include "../hidapi/hidapi.h"
 
 typedef uint32_t uint32;
 typedef uint64_t uint64;
 
 
 struct hid_device_
 {
 	int m_nId;
 	int m_nDeviceRefCount;
 };
 
 static JavaVM *g_JVM;
 static pthread_key_t g_ThreadKey;
 
 template<class T>
 class hid_device_ref
 {
 public:
 	hid_device_ref( T *pObject = nullptr ) : m_pObject( nullptr )
 	{
 		SetObject( pObject );
 	}
 
 	hid_device_ref( const hid_device_ref &rhs ) : m_pObject( nullptr )
 	{
 		SetObject( rhs.GetObject() );
 	}
 
 	~hid_device_ref()
 	{
 		SetObject( nullptr );
 	}
 
 	void SetObject( T *pObject )
 	{
 		if ( m_pObject && m_pObject->DecrementRefCount() == 0 )
 		{
 			delete m_pObject;
 		}
 
 		m_pObject = pObject;
 
 		if ( m_pObject )
 		{
 			m_pObject->IncrementRefCount();
 		}
 	}
 
 	hid_device_ref &operator =( T *pObject )
 	{
 		SetObject( pObject );
 		return *this;
 	}
 
 	hid_device_ref &operator =( const hid_device_ref &rhs )
 	{
 		SetObject( rhs.GetObject() );
 		return *this;
 	}
 
 	T *GetObject() const
 	{
 		return m_pObject;
 	}
 
 	T* operator->() const
 	{
 		return m_pObject;
 	}
 
 	operator bool() const
 	{
 		return ( m_pObject != nullptr );
 	}
 
 private:
 	T *m_pObject;
 };
 
 class hid_mutex_guard
 {
 public:
 	hid_mutex_guard( pthread_mutex_t *pMutex ) : m_pMutex( pMutex )
 	{
 		pthread_mutex_lock( m_pMutex );
 	}
 	~hid_mutex_guard()
 	{
 		pthread_mutex_unlock( m_pMutex );
 	}
 
 private:
 	pthread_mutex_t *m_pMutex;
 };
 
 class hid_buffer
 {
 public:
 	hid_buffer() : m_pData( nullptr ), m_nSize( 0 ), m_nAllocated( 0 )
 	{
 	}
 
 	hid_buffer( const uint8_t *pData, size_t nSize ) : m_pData( nullptr ), m_nSize( 0 ), m_nAllocated( 0 )
 	{
 		assign( pData, nSize );
 	}
 
 	~hid_buffer()
 	{
 		delete[] m_pData;
 	}
 
 	void assign( const uint8_t *pData, size_t nSize )
 	{
 		if ( nSize > m_nAllocated )
 		{
 			delete[] m_pData;
 			m_pData = new uint8_t[ nSize ];
 			m_nAllocated = nSize;
 		}
 
 		m_nSize = nSize;
 		memcpy( m_pData, pData, nSize );
 	}
 
 	void clear()
 	{
 		m_nSize = 0;
 	}
 
 	size_t size() const
 	{
 		return m_nSize;
 	}
 
 	const uint8_t *data() const
 	{
 		return m_pData;
 	}
 
 private:
 	uint8_t *m_pData;
 	size_t m_nSize;
 	size_t m_nAllocated;
 };
 
 class hid_buffer_pool
 {
 public:
 	hid_buffer_pool() : m_nSize( 0 ), m_pHead( nullptr ), m_pTail( nullptr ), m_pFree( nullptr )
 	{
 	}
 
 	~hid_buffer_pool()
 	{
 		clear();
 
 		while ( m_pFree )
 		{
 			hid_buffer_entry *pEntry = m_pFree;
 			m_pFree = m_pFree->m_pNext;
 			delete pEntry;
 		}
 	}
 
 	size_t size() const { return m_nSize; }
 
 	const hid_buffer &front() const { return m_pHead->m_buffer; }
 
 	void pop_front()
 	{
 		hid_buffer_entry *pEntry = m_pHead;
 		if ( pEntry )
 		{
 			m_pHead = pEntry->m_pNext;
 			if ( !m_pHead )
 			{
 				m_pTail = nullptr;
 			}
 			pEntry->m_pNext = m_pFree;
 			m_pFree = pEntry;
 			--m_nSize;
 		}
 	}
 
 	void emplace_back( const uint8_t *pData, size_t nSize )
 	{
 		hid_buffer_entry *pEntry;
 
 		if ( m_pFree )
 		{
 			pEntry = m_pFree;
 			m_pFree = m_pFree->m_pNext;
 		}
 		else
 		{
 			pEntry = new hid_buffer_entry;
 		}
 		pEntry->m_pNext = nullptr;
 
 		if ( m_pTail )
 		{
 			m_pTail->m_pNext = pEntry;
 		}
 		else
 		{
 			m_pHead = pEntry;
 		}
 		m_pTail = pEntry;
 
 		pEntry->m_buffer.assign( pData, nSize );
 		++m_nSize;
 	}
 
 	void clear()
 	{
 		while ( size() > 0 )
 		{
 			pop_front();
 		}
 	}
 
 private:
 	struct hid_buffer_entry
 	{
 		hid_buffer m_buffer;
 		hid_buffer_entry *m_pNext;
 	};
 
 	size_t m_nSize;
 	hid_buffer_entry *m_pHead;
 	hid_buffer_entry *m_pTail;
 	hid_buffer_entry *m_pFree;
 };
 
 static jbyteArray NewByteArray( JNIEnv* env, const uint8_t *pData, size_t nDataLen )
 {
 	jbyteArray array = env->NewByteArray( nDataLen );
 	jbyte *pBuf = env->GetByteArrayElements( array, NULL );
 	memcpy( pBuf, pData, nDataLen );
 	env->ReleaseByteArrayElements( array, pBuf, 0 );
 
 	return array;
 }
 
 static char *CreateStringFromJString( JNIEnv *env, const jstring &sString )
 {
 	size_t nLength = env->GetStringUTFLength( sString );
 	const char *pjChars = env->GetStringUTFChars( sString, NULL );
 	char *psString = (char*)malloc( nLength + 1 );
 	memcpy( psString, pjChars, nLength );
 	psString[ nLength ] = '\0';
 	env->ReleaseStringUTFChars( sString, pjChars );
 	return psString;
 }
 
 static wchar_t *CreateWStringFromJString( JNIEnv *env, const jstring &sString )
 {
 	size_t nLength = env->GetStringLength( sString );
 	const jchar *pjChars = env->GetStringChars( sString, NULL );
 	wchar_t *pwString = (wchar_t*)malloc( ( nLength + 1 ) * sizeof( wchar_t ) );
 	wchar_t *pwChars = pwString;
 	for ( size_t iIndex = 0; iIndex < nLength; ++iIndex )
 	{
 		pwChars[ iIndex ] = pjChars[ iIndex ];
 	}
 	pwString[ nLength ] = '\0';
 	env->ReleaseStringChars( sString, pjChars );
 	return pwString;
 }
 
 static wchar_t *CreateWStringFromWString( const wchar_t *pwSrc )
 {
 	size_t nLength = wcslen( pwSrc );
 	wchar_t *pwString = (wchar_t*)malloc( ( nLength + 1 ) * sizeof( wchar_t ) );
 	memcpy( pwString, pwSrc, nLength * sizeof( wchar_t ) );
 	pwString[ nLength ] = '\0';
 	return pwString;
 }
 
 static hid_device_info *CopyHIDDeviceInfo( const hid_device_info *pInfo )
 {
 	hid_device_info *pCopy = new hid_device_info;
 	*pCopy = *pInfo;
 	pCopy->path = strdup( pInfo->path );
 	pCopy->product_string = CreateWStringFromWString( pInfo->product_string );
 	pCopy->manufacturer_string = CreateWStringFromWString( pInfo->manufacturer_string );
 	pCopy->serial_number = CreateWStringFromWString( pInfo->serial_number );
 	return pCopy;
 }
 
 static void FreeHIDDeviceInfo( hid_device_info *pInfo )
 {
 	free( pInfo->path );
 	free( pInfo->serial_number );
 	free( pInfo->manufacturer_string );
 	free( pInfo->product_string );
 	delete pInfo;
 }
 
 static jclass  g_HIDDeviceManagerCallbackClass;
 static jobject g_HIDDeviceManagerCallbackHandler;
 static jmethodID g_midHIDDeviceManagerOpen;
 static jmethodID g_midHIDDeviceManagerSendOutputReport;
 static jmethodID g_midHIDDeviceManagerSendFeatureReport;
 static jmethodID g_midHIDDeviceManagerGetFeatureReport;
 static jmethodID g_midHIDDeviceManagerClose;
 
 static uint64_t get_timespec_ms( const struct timespec &ts )
 {
 	return (uint64_t)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
 }
 
 class CHIDDevice
 {
 public:
 	CHIDDevice( int nDeviceID, hid_device_info *pInfo )
 	{
 		m_nId = nDeviceID;
 		m_pInfo = pInfo;
 
 		// The Bluetooth Steam Controller needs special handling
 		const int VALVE_USB_VID	= 0x28DE;
 		const int D0G_BLE2_PID = 0x1106;
 		if ( pInfo->vendor_id == VALVE_USB_VID && pInfo->product_id == D0G_BLE2_PID )
 		{
 			m_bIsBLESteamController = true;
 		}
 	}
 
 	~CHIDDevice()
 	{
 		FreeHIDDeviceInfo( m_pInfo );
 
 		// Note that we don't delete m_pDevice, as the app may still have a reference to it
 	}
 
 	int IncrementRefCount()
 	{
 		int nValue;
 		pthread_mutex_lock( &m_refCountLock );
 		nValue = ++m_nRefCount;
 		pthread_mutex_unlock( &m_refCountLock );
 		return nValue;
 	}
 
 	int DecrementRefCount()
 	{
 		int nValue;
 		pthread_mutex_lock( &m_refCountLock );
 		nValue = --m_nRefCount;
 		pthread_mutex_unlock( &m_refCountLock );
 		return nValue;
 	}
 
 	int GetId()
 	{
 		return m_nId;
 	}
 
 	const hid_device_info *GetDeviceInfo()
 	{
 		return m_pInfo;
 	}
 
 	hid_device *GetDevice()
 	{
 		return m_pDevice;
 	}
 
 	void ExceptionCheck( JNIEnv *env, const char *pszMethodName )
 	{
 		if ( env->ExceptionCheck() )
 		{
 			// Get our exception
 			jthrowable jExcept = env->ExceptionOccurred();
 
 			// Clear the exception so we can call JNI again
 			env->ExceptionClear();
 
 			// Get our exception message
 			jclass jExceptClass = env->GetObjectClass( jExcept );
 			jmethodID jMessageMethod = env->GetMethodID( jExceptClass, "getMessage", "()Ljava/lang/String;" );
 			jstring jMessage = (jstring)( env->CallObjectMethod( jExcept, jMessageMethod ) );
 			const char *pszMessage = env->GetStringUTFChars( jMessage, NULL );
 
 			// ...and log it.
 			LOGE( "CHIDDevice::%s threw an exception: %s", pszMethodName, pszMessage );
 
 			// Cleanup
 			env->ReleaseStringUTFChars( jMessage, pszMessage );
 			env->DeleteLocalRef( jMessage );
 			env->DeleteLocalRef( jExceptClass );
 			env->DeleteLocalRef( jExcept );
 		}
 	}
 
 	bool BOpen()
 	{
 		// Make sure thread is attached to JVM/env
 		JNIEnv *env;
 		g_JVM->AttachCurrentThread( &env, NULL );
 		pthread_setspecific( g_ThreadKey, (void*)env );
 
 		if ( !g_HIDDeviceManagerCallbackHandler )
 		{
 			LOGV( "Device open without callback handler" );
 			return false;
 		}
 
 		m_bIsWaitingForOpen = false;
 		m_bOpenResult = env->CallBooleanMethod( g_HIDDeviceManagerCallbackHandler, g_midHIDDeviceManagerOpen, m_nId );
 		ExceptionCheck( env, "BOpen" );
 
 		if ( m_bIsWaitingForOpen )
 		{
 			hid_mutex_guard cvl( &m_cvLock );
 
 			const int OPEN_TIMEOUT_SECONDS = 60;
 			struct timespec ts, endtime;
 			clock_gettime( CLOCK_REALTIME, &ts );
 			endtime = ts;
 			endtime.tv_sec += OPEN_TIMEOUT_SECONDS;
 			do
 			{
 				if ( pthread_cond_timedwait( &m_cv, &m_cvLock, &endtime ) != 0 )
 				{
 					break;
 				}
 			}
 			while ( m_bIsWaitingForOpen && get_timespec_ms( ts ) < get_timespec_ms( endtime ) );
 		}
 
 		if ( !m_bOpenResult )
 		{
 			if ( m_bIsWaitingForOpen )
 			{
 				LOGV( "Device open failed - timed out waiting for device permission" );
 			}
 			else
 			{
 				LOGV( "Device open failed" );
 			}
 			return false;
 		}
 
 		m_pDevice = new hid_device;
 		m_pDevice->m_nId = m_nId;
 		m_pDevice->m_nDeviceRefCount = 1;
 		LOGD("Creating device %d (%p), refCount = 1\n", m_pDevice->m_nId, m_pDevice);
 		return true;
 	}
 
 	void SetOpenPending()
 	{
 		m_bIsWaitingForOpen = true;
 	}
 
 	void SetOpenResult( bool bResult )
 	{
 		if ( m_bIsWaitingForOpen )
 		{
 			m_bOpenResult = bResult;
 			m_bIsWaitingForOpen = false;
 			pthread_cond_signal( &m_cv );
 		}
 	}
 
 	void ProcessInput( const uint8_t *pBuf, size_t nBufSize )
 	{
 		hid_mutex_guard l( &m_dataLock );
 
 		size_t MAX_REPORT_QUEUE_SIZE = 16;
 		if ( m_vecData.size() >= MAX_REPORT_QUEUE_SIZE )
 		{
 			m_vecData.pop_front();
 		}
 		m_vecData.emplace_back( pBuf, nBufSize );
 	}
 
 	int GetInput( unsigned char *data, size_t length )
 	{
 		hid_mutex_guard l( &m_dataLock );
 
 		if ( m_vecData.size() == 0 )
 		{
 //			LOGV( "hid_read_timeout no data available" );
 			return 0;
 		}
 
 		const hid_buffer &buffer = m_vecData.front();
 		size_t nDataLen = buffer.size() > length ? length : buffer.size();
 		if ( m_bIsBLESteamController )
 		{
 			data[0] = 0x03;
 			memcpy( data + 1, buffer.data(), nDataLen );
 			++nDataLen;
 		}
 		else
 		{
 			memcpy( data, buffer.data(), nDataLen );
 		}
 		m_vecData.pop_front();
 
 //		LOGV("Read %u bytes", nDataLen);
 //		LOGV("%02x %02x %02x %02x %02x %02x %02x %02x ....",
 //			 data[0], data[1], data[2], data[3],
 //			 data[4], data[5], data[6], data[7]);
 
 		return nDataLen;
 	}
 
 	int SendOutputReport( const unsigned char *pData, size_t nDataLen )
 	{
 		// Make sure thread is attached to JVM/env
 		JNIEnv *env;
 		g_JVM->AttachCurrentThread( &env, NULL );
 		pthread_setspecific( g_ThreadKey, (void*)env );
 
 		int nRet = -1;
 		if ( g_HIDDeviceManagerCallbackHandler )
 		{
 			jbyteArray pBuf = NewByteArray( env, pData, nDataLen );
 			nRet = env->CallIntMethod( g_HIDDeviceManagerCallbackHandler, g_midHIDDeviceManagerSendOutputReport, m_nId, pBuf );
 			ExceptionCheck( env, "SendOutputReport" );
 			env->DeleteLocalRef( pBuf );
 		}
 		else
 		{
 			LOGV( "SendOutputReport without callback handler" );
 		}
 		return nRet;
 	}
 
 	int SendFeatureReport( const unsigned char *pData, size_t nDataLen )
 	{
 		// Make sure thread is attached to JVM/env
 		JNIEnv *env;
 		g_JVM->AttachCurrentThread( &env, NULL );
 		pthread_setspecific( g_ThreadKey, (void*)env );
 
 		int nRet = -1;
 		if ( g_HIDDeviceManagerCallbackHandler )
 		{
 			jbyteArray pBuf = NewByteArray( env, pData, nDataLen );
 			nRet = env->CallIntMethod( g_HIDDeviceManagerCallbackHandler, g_midHIDDeviceManagerSendFeatureReport, m_nId, pBuf );
 			ExceptionCheck( env, "SendFeatureReport" );
 			env->DeleteLocalRef( pBuf );
 		}
 		else
 		{
 			LOGV( "SendFeatureReport without callback handler" );
 		}
 		return nRet;
 	}
 
 	void ProcessFeatureReport( const uint8_t *pBuf, size_t nBufSize )
 	{
 		hid_mutex_guard cvl( &m_cvLock );
 		if ( m_bIsWaitingForFeatureReport )
 		{
 			m_featureReport.assign( pBuf, nBufSize );
 
 			m_bIsWaitingForFeatureReport = false;
 			m_nFeatureReportError = 0;
 			pthread_cond_signal( &m_cv );
 		}
 	}
 
 	int GetFeatureReport( unsigned char *pData, size_t nDataLen )
 	{
 		// Make sure thread is attached to JVM/env
 		JNIEnv *env;
 		g_JVM->AttachCurrentThread( &env, NULL );
 		pthread_setspecific( g_ThreadKey, (void*)env );
 
 		if ( !g_HIDDeviceManagerCallbackHandler )
 		{
 			LOGV( "GetFeatureReport without callback handler" );
 			return -1;
 		}
 
 		{
 			hid_mutex_guard cvl( &m_cvLock );
 			if ( m_bIsWaitingForFeatureReport )
 			{
 				LOGV( "Get feature report already ongoing... bail" );
 				return -1; // Read already ongoing, we currently do not serialize, TODO
 			}
 			m_bIsWaitingForFeatureReport = true;
 		}
 
 		jbyteArray pBuf = NewByteArray( env, pData, nDataLen );
 		int nRet = env->CallBooleanMethod( g_HIDDeviceManagerCallbackHandler, g_midHIDDeviceManagerGetFeatureReport, m_nId, pBuf ) ? 0 : -1;
 		ExceptionCheck( env, "GetFeatureReport" );
 		env->DeleteLocalRef( pBuf );
 		if ( nRet < 0 )
 		{
 			LOGV( "GetFeatureReport failed" );
 			m_bIsWaitingForFeatureReport = false;
 			return -1;
 		}
 
 		{
 			hid_mutex_guard cvl( &m_cvLock );
 			if ( m_bIsWaitingForFeatureReport )
 			{
 				LOGV("=== Going to sleep" );
 				// Wait in CV until we are no longer waiting for a feature report.
 				const int FEATURE_REPORT_TIMEOUT_SECONDS = 2;
 				struct timespec ts, endtime;
 				clock_gettime( CLOCK_REALTIME, &ts );
 				endtime = ts;
 				endtime.tv_sec += FEATURE_REPORT_TIMEOUT_SECONDS;
 				do
 				{
 					if ( pthread_cond_timedwait( &m_cv, &m_cvLock, &endtime ) != 0 )
 					{
 						break;
 					}
 				}
 				while ( m_bIsWaitingForFeatureReport && get_timespec_ms( ts ) < get_timespec_ms( endtime ) );
 
 				// We are back
 				if ( m_bIsWaitingForFeatureReport )
 				{
 					m_nFeatureReportError = -ETIMEDOUT;
 					m_bIsWaitingForFeatureReport = false;
 				}
 				LOGV( "=== Got feature report err=%d", m_nFeatureReportError );
 				if ( m_nFeatureReportError != 0 )
 				{
 					return m_nFeatureReportError;
 				}
 			}
 
 			size_t uBytesToCopy = m_featureReport.size() > nDataLen ? nDataLen : m_featureReport.size();
 			memcpy( pData, m_featureReport.data(), uBytesToCopy );
 			m_featureReport.clear();
 			LOGV( "=== Got %u bytes", uBytesToCopy );
 
 			return uBytesToCopy;
 		}
 	}
 
 	void Close( bool bDeleteDevice )
 	{
 		// Make sure thread is attached to JVM/env
 		JNIEnv *env;
 		g_JVM->AttachCurrentThread( &env, NULL );
 		pthread_setspecific( g_ThreadKey, (void*)env );
 
 		if ( g_HIDDeviceManagerCallbackHandler )
 		{
 			env->CallVoidMethod( g_HIDDeviceManagerCallbackHandler, g_midHIDDeviceManagerClose, m_nId );
 			ExceptionCheck( env, "Close" );
 		}
 	
 		hid_mutex_guard dataLock( &m_dataLock );
 		m_vecData.clear();
 
 		// Clean and release pending feature report reads
 		hid_mutex_guard cvLock( &m_cvLock );
 		m_featureReport.clear();
 		m_bIsWaitingForFeatureReport = false;
 		m_nFeatureReportError = -ECONNRESET;
 		pthread_cond_broadcast( &m_cv );
 
 		if ( bDeleteDevice )
 		{
 			delete m_pDevice;
 			m_pDevice = nullptr;
 		}
 	}
 
 private:
 	pthread_mutex_t m_refCountLock = PTHREAD_MUTEX_INITIALIZER;
 	int m_nRefCount = 0;
 	int m_nId = 0;
 	hid_device_info *m_pInfo = nullptr;
 	hid_device *m_pDevice = nullptr;
 	bool m_bIsBLESteamController = false;
 
 	pthread_mutex_t m_dataLock = PTHREAD_MUTEX_INITIALIZER; // This lock has to be held to access m_vecData
 	hid_buffer_pool m_vecData;
 
 	// For handling get_feature_report
 	pthread_mutex_t m_cvLock = PTHREAD_MUTEX_INITIALIZER; // This lock has to be held to access any variables below
 	pthread_cond_t m_cv = PTHREAD_COND_INITIALIZER;
 	bool m_bIsWaitingForOpen = false;
 	bool m_bOpenResult = false;
 	bool m_bIsWaitingForFeatureReport = false;
 	int m_nFeatureReportError = 0;
 	hid_buffer m_featureReport;
 
 public:
 	hid_device_ref<CHIDDevice> next;
 };
 
 class CHIDDevice;
 static pthread_mutex_t g_DevicesMutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_mutex_t g_DevicesRefCountMutex = PTHREAD_MUTEX_INITIALIZER;
 static hid_device_ref<CHIDDevice> g_Devices;
 
 static hid_device_ref<CHIDDevice> FindDevice( int nDeviceId )
 {
 	hid_device_ref<CHIDDevice> pDevice;
 
 	hid_mutex_guard l( &g_DevicesMutex );
 	for ( pDevice = g_Devices; pDevice; pDevice = pDevice->next )
 	{
 		if ( pDevice->GetId() == nDeviceId )
 		{
 			break;
 		}
 	}
 	return pDevice;
 }
 
 static void ThreadDestroyed(void* value)
 {
 	/* The thread is being destroyed, detach it from the Java VM and set the g_ThreadKey value to NULL as required */
 	JNIEnv *env = (JNIEnv*) value;
 	if (env != NULL) {
 		g_JVM->DetachCurrentThread();
 		pthread_setspecific(g_ThreadKey, NULL);
 	}
 }
 
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceRegisterCallback)(JNIEnv *env, jobject thiz);
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceReleaseCallback)(JNIEnv *env, jobject thiz);
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceConnected)(JNIEnv *env, jobject thiz, int nDeviceID, jstring sIdentifier, int nVendorId, int nProductId, jstring sSerialNumber, int nReleaseNumber, jstring sManufacturer, jstring sProduct, int nInterface, int nInterfaceClass, int nInterfaceSubclass, int nInterfaceProtocol );
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceOpenPending)(JNIEnv *env, jobject thiz, int nDeviceID);
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceOpenResult)(JNIEnv *env, jobject thiz, int nDeviceID, bool bOpened);
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceDisconnected)(JNIEnv *env, jobject thiz, int nDeviceID);
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceInputReport)(JNIEnv *env, jobject thiz, int nDeviceID, jbyteArray value);
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceFeatureReport)(JNIEnv *env, jobject thiz, int nDeviceID, jbyteArray value);
 
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceRegisterCallback)(JNIEnv *env, jobject thiz )
 {
 	LOGV( "HIDDeviceRegisterCallback()");
 
 	env->GetJavaVM( &g_JVM );
 
 	/*
 	 * Create mThreadKey so we can keep track of the JNIEnv assigned to each thread
 	 * Refer to http://developer.android.com/guide/practices/design/jni.html for the rationale behind this
 	 */
 	if (pthread_key_create(&g_ThreadKey, ThreadDestroyed) != 0) {
 		__android_log_print(ANDROID_LOG_ERROR, TAG, "Error initializing pthread key");
 	}
 
 	if ( g_HIDDeviceManagerCallbackHandler != NULL )
 	{
 		env->DeleteGlobalRef( g_HIDDeviceManagerCallbackClass );
 		g_HIDDeviceManagerCallbackClass = NULL;
 		env->DeleteGlobalRef( g_HIDDeviceManagerCallbackHandler );
 		g_HIDDeviceManagerCallbackHandler = NULL;
 	}
 
 	g_HIDDeviceManagerCallbackHandler = env->NewGlobalRef( thiz );
 	jclass objClass = env->GetObjectClass( thiz );
 	if ( objClass )
 	{
 		g_HIDDeviceManagerCallbackClass = reinterpret_cast< jclass >( env->NewGlobalRef( objClass ) );
 		g_midHIDDeviceManagerOpen = env->GetMethodID( g_HIDDeviceManagerCallbackClass, "openDevice", "(I)Z" );
 		if ( !g_midHIDDeviceManagerOpen )
 		{
 			__android_log_print(ANDROID_LOG_ERROR, TAG, "HIDDeviceRegisterCallback: callback class missing openDevice" );
 		}
 		g_midHIDDeviceManagerSendOutputReport = env->GetMethodID( g_HIDDeviceManagerCallbackClass, "sendOutputReport", "(I[B)I" );
 		if ( !g_midHIDDeviceManagerSendOutputReport )
 		{
 			__android_log_print(ANDROID_LOG_ERROR, TAG, "HIDDeviceRegisterCallback: callback class missing sendOutputReport" );
 		}
 		g_midHIDDeviceManagerSendFeatureReport = env->GetMethodID( g_HIDDeviceManagerCallbackClass, "sendFeatureReport", "(I[B)I" );
 		if ( !g_midHIDDeviceManagerSendFeatureReport )
 		{
 			__android_log_print(ANDROID_LOG_ERROR, TAG, "HIDDeviceRegisterCallback: callback class missing sendFeatureReport" );
 		}
 		g_midHIDDeviceManagerGetFeatureReport = env->GetMethodID( g_HIDDeviceManagerCallbackClass, "getFeatureReport", "(I[B)Z" );
 		if ( !g_midHIDDeviceManagerGetFeatureReport )
 		{
 			__android_log_print(ANDROID_LOG_ERROR, TAG, "HIDDeviceRegisterCallback: callback class missing getFeatureReport" );
 		}
 		g_midHIDDeviceManagerClose = env->GetMethodID( g_HIDDeviceManagerCallbackClass, "closeDevice", "(I)V" );
 		if ( !g_midHIDDeviceManagerClose )
 		{
 			__android_log_print(ANDROID_LOG_ERROR, TAG, "HIDDeviceRegisterCallback: callback class missing closeDevice" );
 		}
 		env->DeleteLocalRef( objClass );
 	}
 }
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceReleaseCallback)(JNIEnv *env, jobject thiz)
 {
 	LOGV("HIDDeviceReleaseCallback");
 	if ( env->IsSameObject( thiz, g_HIDDeviceManagerCallbackHandler ) )
 	{
 		env->DeleteGlobalRef( g_HIDDeviceManagerCallbackClass );
 		g_HIDDeviceManagerCallbackClass = NULL;
 		env->DeleteGlobalRef( g_HIDDeviceManagerCallbackHandler );
 		g_HIDDeviceManagerCallbackHandler = NULL;
 	}
 }
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceConnected)(JNIEnv *env, jobject thiz, int nDeviceID, jstring sIdentifier, int nVendorId, int nProductId, jstring sSerialNumber, int nReleaseNumber, jstring sManufacturer, jstring sProduct, int nInterface, int nInterfaceClass, int nInterfaceSubclass, int nInterfaceProtocol )
 {
 	LOGV( "HIDDeviceConnected() id=%d VID/PID = %.4x/%.4x, interface %d\n", nDeviceID, nVendorId, nProductId, nInterface );
 
 	hid_device_info *pInfo = new hid_device_info;
 	memset( pInfo, 0, sizeof( *pInfo ) );
 	pInfo->path = CreateStringFromJString( env, sIdentifier );
 	pInfo->vendor_id = nVendorId;
 	pInfo->product_id = nProductId;
 	pInfo->serial_number = CreateWStringFromJString( env, sSerialNumber );
 	pInfo->release_number = nReleaseNumber;
 	pInfo->manufacturer_string = CreateWStringFromJString( env, sManufacturer );
 	pInfo->product_string = CreateWStringFromJString( env, sProduct );
 	pInfo->interface_number = nInterface;
 	pInfo->interface_class = nInterfaceClass;
 	pInfo->interface_subclass = nInterfaceSubclass;
 	pInfo->interface_protocol = nInterfaceProtocol;
 
 	hid_device_ref<CHIDDevice> pDevice( new CHIDDevice( nDeviceID, pInfo ) );
 
 	hid_mutex_guard l( &g_DevicesMutex );
 	hid_device_ref<CHIDDevice> pLast, pCurr;
 	for ( pCurr = g_Devices; pCurr; pLast = pCurr, pCurr = pCurr->next )
 	{
 		continue;
 	}
 	if ( pLast )
 	{
 		pLast->next = pDevice;
 	}
 	else
 	{
 		g_Devices = pDevice;
 	}
 }
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceOpenPending)(JNIEnv *env, jobject thiz, int nDeviceID)
 {
 	LOGV( "HIDDeviceOpenPending() id=%d\n", nDeviceID );
 	hid_device_ref<CHIDDevice> pDevice = FindDevice( nDeviceID );
 	if ( pDevice )
 	{
 		pDevice->SetOpenPending();
 	}
 }
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceOpenResult)(JNIEnv *env, jobject thiz, int nDeviceID, bool bOpened)
 {
 	LOGV( "HIDDeviceOpenResult() id=%d, result=%s\n", nDeviceID, bOpened ? "true" : "false" );
 	hid_device_ref<CHIDDevice> pDevice = FindDevice( nDeviceID );
 	if ( pDevice )
 	{
 		pDevice->SetOpenResult( bOpened );
 	}
 }
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceDisconnected)(JNIEnv *env, jobject thiz, int nDeviceID)
 {
 	LOGV( "HIDDeviceDisconnected() id=%d\n", nDeviceID );
 	hid_device_ref<CHIDDevice> pDevice;
 	{
 		hid_mutex_guard l( &g_DevicesMutex );
 		hid_device_ref<CHIDDevice> pLast, pCurr;
 		for ( pCurr = g_Devices; pCurr; pLast = pCurr, pCurr = pCurr->next )
 		{
 			if ( pCurr->GetId() == nDeviceID )
 			{
 				pDevice = pCurr;
 
 				if ( pLast )
 				{
 					pLast->next = pCurr->next;
 				}
 				else
 				{
 					g_Devices = pCurr->next;
 				}
 			}
 		}
 	}
 	if ( pDevice )
 	{
 		pDevice->Close( false );
 	}
 }
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceInputReport)(JNIEnv *env, jobject thiz, int nDeviceID, jbyteArray value)
 {
 	jbyte *pBuf = env->GetByteArrayElements(value, NULL);
 	jsize nBufSize = env->GetArrayLength(value);
 
 //	LOGV( "HIDDeviceInput() id=%d len=%u\n", nDeviceID, nBufSize );
 	hid_device_ref<CHIDDevice> pDevice = FindDevice( nDeviceID );
 	if ( pDevice )
 	{
 		pDevice->ProcessInput( reinterpret_cast< const uint8_t* >( pBuf ), nBufSize );
 	}
 
 	env->ReleaseByteArrayElements(value, pBuf, 0);
 }
 
 extern "C"
 JNIEXPORT void JNICALL HID_DEVICE_MANAGER_JAVA_INTERFACE(HIDDeviceFeatureReport)(JNIEnv *env, jobject thiz, int nDeviceID, jbyteArray value)
 {
 	jbyte *pBuf = env->GetByteArrayElements(value, NULL);
 	jsize nBufSize = env->GetArrayLength(value);
 
 	LOGV( "HIDDeviceFeatureReport() id=%d len=%u\n", nDeviceID, nBufSize );
 	hid_device_ref<CHIDDevice> pDevice = FindDevice( nDeviceID );
 	if ( pDevice )
 	{
 		pDevice->ProcessFeatureReport( reinterpret_cast< const uint8_t* >( pBuf ), nBufSize );
 	}
 
 	env->ReleaseByteArrayElements(value, pBuf, 0);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 extern "C"
 {
 
 int hid_init(void)
 {
 	return 0;
 }
 
 struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id)
 {
 	struct hid_device_info *root = NULL;
 	hid_mutex_guard l( &g_DevicesMutex );
 	for ( hid_device_ref<CHIDDevice> pDevice = g_Devices; pDevice; pDevice = pDevice->next )
 	{
 		const hid_device_info *info = pDevice->GetDeviceInfo();
 		if ( ( vendor_id == 0 && product_id == 0 ) ||
 			 ( vendor_id == info->vendor_id && product_id == info->product_id ) )
 		{
 			hid_device_info *dev = CopyHIDDeviceInfo( info );
 			dev->next = root;
 			root = dev;
 		}
 	}
 	return root;
 }
 
 void  HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs)
 {
 	while ( devs )
 	{
 		struct hid_device_info *next = devs->next;
 		FreeHIDDeviceInfo( devs );
 		devs = next;
 	}
 }
 
 HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
 {
 	// TODO: Implement
 	return NULL;
 }
 
 HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path, int bExclusive)
 {
 	LOGV( "hid_open_path( %s )", path );
 
 	hid_device_ref< CHIDDevice > pDevice;
 	{
 		hid_mutex_guard r( &g_DevicesRefCountMutex );
 		hid_mutex_guard l( &g_DevicesMutex );
 		for ( hid_device_ref<CHIDDevice> pCurr = g_Devices; pCurr; pCurr = pCurr->next )
 		{
 			if ( strcmp( pCurr->GetDeviceInfo()->path, path ) == 0 ) 
 			{
 				hid_device *pValue = pCurr->GetDevice();
 				if ( pValue )
 				{
 					++pValue->m_nDeviceRefCount;
 					LOGD("Incrementing device %d (%p), refCount = %d\n", pValue->m_nId, pValue, pValue->m_nDeviceRefCount);
 					return pValue;
 				}
 
 				// Hold a shared pointer to the controller for the duration
 				pDevice = pCurr;
 				break;
 			}
 		}
 	}
 	if ( pDevice && pDevice->BOpen() )
 	{
 		return pDevice->GetDevice();
 	}
 	return NULL;
 }
 
 int  HID_API_EXPORT HID_API_CALL hid_write(hid_device *device, const unsigned char *data, size_t length)
 {
 	if ( device )
 	{
 		LOGV( "hid_write id=%d length=%u", device->m_nId, length );
 		hid_device_ref<CHIDDevice> pDevice = FindDevice( device->m_nId );
 		if ( pDevice )
 		{
 			return pDevice->SendOutputReport( data, length );
 		}
 	}
 	return -1; // Controller was disconnected
 }
 
 // TODO: Implement timeout?
 int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *device, unsigned char *data, size_t length, int milliseconds)
 {
 	if ( device )
 	{
 //		LOGV( "hid_read_timeout id=%d length=%u timeout=%d", device->m_nId, length, milliseconds );
 		hid_device_ref<CHIDDevice> pDevice = FindDevice( device->m_nId );
 		if ( pDevice )
 		{
 			return pDevice->GetInput( data, length );
 		}
 		LOGV( "controller was disconnected" );
 	}
 	return -1; // Controller was disconnected
 }
 
 // TODO: Implement blocking
 int  HID_API_EXPORT HID_API_CALL hid_read(hid_device *device, unsigned char *data, size_t length)
 {
 	LOGV( "hid_read id=%d length=%u", device->m_nId, length );
 	return hid_read_timeout( device, data, length, 0 );
 }
 
 // TODO: Implement?
 int  HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *device, int nonblock)
 {
 	return -1;
 }
 
 int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *device, const unsigned char *data, size_t length)
 {
 	if ( device )
 	{
 		LOGV( "hid_send_feature_report id=%d length=%u", device->m_nId, length );
 		hid_device_ref<CHIDDevice> pDevice = FindDevice( device->m_nId );
 		if ( pDevice )
 		{
 			return pDevice->SendFeatureReport( data, length );
 		}
 	}
 	return -1; // Controller was disconnected
 }
 
 
 // Synchronous operation. Will block until completed.
 int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *device, unsigned char *data, size_t length)
 {
 	if ( device )
 	{
 		LOGV( "hid_get_feature_report id=%d length=%u", device->m_nId, length );
 		hid_device_ref<CHIDDevice> pDevice = FindDevice( device->m_nId );
 		if ( pDevice )
 		{
 			return pDevice->GetFeatureReport( data, length );
 		}
 	}
 	return -1; // Controller was disconnected
 }
 
 
 void HID_API_EXPORT HID_API_CALL hid_close(hid_device *device)
 {
 	if ( device )
 	{
 		LOGV( "hid_close id=%d", device->m_nId );
 		hid_mutex_guard r( &g_DevicesRefCountMutex );
 		LOGD("Decrementing device %d (%p), refCount = %d\n", device->m_nId, device, device->m_nDeviceRefCount - 1);
 		if ( --device->m_nDeviceRefCount == 0 )
 		{
 			hid_device_ref<CHIDDevice> pDevice = FindDevice( device->m_nId );
 			if ( pDevice )
 			{
 				pDevice->Close( true );
 			}
 			else
 			{
 				delete device;
 			}
 			LOGD("Deleted device %p\n", device);
 		}
 	}
 }
 
 int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *device, wchar_t *string, size_t maxlen)
 {
 	if ( device )
 	{
 		hid_device_ref<CHIDDevice> pDevice = FindDevice( device->m_nId );
 		if ( pDevice )
 		{
 			wcsncpy( string, pDevice->GetDeviceInfo()->manufacturer_string, maxlen );
 			return 0;
 		}
 	}
 	return -1;
 }
 
 int HID_API_EXPORT_CALL hid_get_product_string(hid_device *device, wchar_t *string, size_t maxlen)
 {
 	if ( device )
 	{
 		hid_device_ref<CHIDDevice> pDevice = FindDevice( device->m_nId );
 		if ( pDevice )
 		{
 			wcsncpy( string, pDevice->GetDeviceInfo()->product_string, maxlen );
 			return 0;
 		}
 	}
 	return -1;
 }
 
 int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *device, wchar_t *string, size_t maxlen)
 {
 	if ( device )
 	{
 		hid_device_ref<CHIDDevice> pDevice = FindDevice( device->m_nId );
 		if ( pDevice )
 		{
 			wcsncpy( string, pDevice->GetDeviceInfo()->serial_number, maxlen );
 			return 0;
 		}
 	}
 	return -1;
 }
 
 int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *device, int string_index, wchar_t *string, size_t maxlen)
 {
 	return -1;
 }
 
 HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *device)
 {
 	return NULL;
 }
 
 int hid_exit(void)
 {
 	return 0;
 }
 
 }