void ShutDown()
{
IOHIDManagerClose(g_hid_manager, kIOHIDOptionsTypeNone);
IOHIDManagerUnscheduleFromRunLoop(g_hid_manager, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
CFRelease(g_hid_manager);
}
void TeensyControls_usb_close(void)
{
teensy_t *t;
int wait=0;
for (t = TeensyControls_first_teensy; t; t = t->next) {
if (t->online) {
printf("close USB device\n");
IOHIDDeviceRegisterInputReportCallback(t->usb.dev,
t->usb.inbuf, 64, NULL, NULL);
// TODO: how to terminate input thread?
// TODO: how to terminate output thread?
pthread_cond_signal(&t->output_event);
IOHIDDeviceClose(t->usb.dev, 0);
t->online = 0;
}
}
if (hmgr) {
printf("closing hid manager\n");
IOHIDManagerRegisterDeviceMatchingCallback(hmgr, NULL, NULL);
IOHIDManagerRegisterDeviceRemovalCallback(hmgr, NULL, NULL);
IOHIDManagerClose(hmgr, 0);
hmgr = NULL;
}
while (++wait < 20 && num_thread_alive() > 0) {
usleep(10000);
printf("wait #%d for thread exit\n", wait);
}
}
Joystick::Private::~Private()
{
SYNC;
if(deviceId)
{
for(int i = 0; i < numOfAxes; ++i)
if(axisIds[i])
CFRelease((IOHIDElementRef) axisIds[i]);
for(int i = 0; i < numOfButtons; ++i)
if(buttonIds[i])
CFRelease((IOHIDElementRef) buttonIds[i]);
if(hatId)
CFRelease((IOHIDElementRef) hatId);
CFRelease((IOHIDDeviceRef) deviceId);
--usedJoysticks;
}
if(hidManager && !usedJoysticks)
{
IOHIDManagerClose((IOHIDManagerRef) hidManager, kIOHIDOptionsTypeNone);
CFRelease((IOHIDManagerRef) hidManager);
hidManager = nullptr;
}
}
void CInputProviderMacOsHid::InputDeviceListenerThread()
{
m_hidManager = IOHIDManagerCreate(kCFAllocatorDefault, 0);
{
CFDictionaryRef matchingDict[3];
matchingDict[0] = CreateDeviceMatchingDictionary(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick);
matchingDict[1] = CreateDeviceMatchingDictionary(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad);
matchingDict[2] = CreateDeviceMatchingDictionary(kHIDPage_GenericDesktop, kHIDUsage_GD_MultiAxisController);
CFArrayRef array = CFArrayCreate(kCFAllocatorDefault, (const void**)matchingDict, 3, &kCFTypeArrayCallBacks);
CFRelease(matchingDict[0]);
CFRelease(matchingDict[1]);
CFRelease(matchingDict[2]);
IOHIDManagerSetDeviceMatchingMultiple(m_hidManager, array);
}
IOHIDManagerRegisterDeviceMatchingCallback(m_hidManager, OnDeviceMatchedStub, this);
IOHIDManagerOpen(m_hidManager, kIOHIDOptionsTypeNone);
IOHIDManagerScheduleWithRunLoop(m_hidManager, CFRunLoopGetCurrent(), CFSTR("CustomLoop"));
while(CFRunLoopRunInMode(CFSTR("CustomLoop"), 1, true) != kCFRunLoopRunStopped && m_running)
{
}
IOHIDManagerClose(m_hidManager, 0);
}
void joy_hidlib_exit(void)
{
if(mgr) {
IOHIDManagerClose( mgr, 0 );
mgr = NULL;
}
}
static void stopHIDManager(OSX_HID_REF *hid)
{
if (hid->manager) {
IOHIDManagerClose(hid->manager, kIOHIDOptionsTypeNone );
CFRelease( hid->manager);
hid->manager=NULL;
yDeleteCriticalSection(&hid->hidMCS);
}
}
osxHIDInputDevice::~osxHIDInputDevice(void) {
delete theDevice ;
delete parser ;
if (device_match) CFRelease(device_match) ;
if (elements_match) CFRelease(elements_match) ;
if (manager) {
IOHIDManagerClose(manager, kIOHIDOptionsTypeNone) ;
CFRelease(manager) ;
}
}
Burger::Mouse::~Mouse()
{
m_pGameApp->RemoveRoutine(Poll,this);
if (m_pHIDManager) {
IOHIDManagerClose(m_pHIDManager,kIOHIDOptionsTypeNone);
CFRelease(m_pHIDManager);
m_pHIDManager = NULL;
}
m_uMiceCount = 0;
}
JoypadOSX::~JoypadOSX() {
for (int i = 0; i < device_list.size(); i++) {
device_list[i].free();
}
IOHIDManagerUnscheduleFromRunLoop(hid_manager, CFRunLoopGetCurrent(), GODOT_JOY_LOOP_RUN_MODE);
IOHIDManagerClose(hid_manager, kIOHIDOptionsTypeNone);
CFRelease(hid_manager);
hid_manager = NULL;
}
HIDJoystickManager::~HIDJoystickManager()
{
IOHIDManagerUnscheduleFromRunLoop(m_manager,
CFRunLoopGetCurrent(),
RunLoopMode);
IOHIDManagerRegisterDeviceMatchingCallback(m_manager, NULL, 0);
IOHIDManagerRegisterDeviceRemovalCallback(m_manager, NULL, 0);
IOHIDManagerClose(m_manager, kIOHIDOptionsTypeNone);
}
int HID_API_EXPORT hid_exit(void)
{
if (hid_mgr) {
/* Close the HID manager. */
IOHIDManagerClose(hid_mgr, kIOHIDOptionsTypeNone);
CFRelease(hid_mgr);
hid_mgr = NULL;
}
return 0;
}
void osx_pad_quit(void)
{
if (g_hid_manager)
{
IOHIDManagerClose(g_hid_manager, kIOHIDOptionsTypeNone);
IOHIDManagerUnscheduleFromRunLoop(g_hid_manager, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
CFRelease(g_hid_manager);
}
g_hid_manager = 0;
}
void HIDGamepadProvider::closeAndUnscheduleManager()
{
LOG(Gamepad, "HIDGamepadProvider closing/unscheduling HID manager");
IOHIDManagerUnscheduleFromRunLoop(m_manager.get(), CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
IOHIDManagerClose(m_manager.get(), kIOHIDOptionsTypeNone);
m_gamepadVector.clear();
m_gamepadMap.clear();
m_connectionDelayTimer.stop();
}
static int OSX_Mouse_Thread(void *ctx)
{
if (!ctx)
return 0;
struct osx_mouse_data *mdata = static_cast<struct osx_mouse_data *>(ctx);
IOHIDManagerRef hid_manager = IOHIDManagerCreate(kCFAllocatorSystemDefault, kIOHIDOptionsTypeNone);
if (!hid_manager) {
SDL_DestroyMutex(mdata->mouse_mutex);
delete mdata;
return 0;
}
if (IOHIDManagerOpen(hid_manager, kIOHIDOptionsTypeNone) != kIOReturnSuccess) {
CFRelease(hid_manager);
SDL_DestroyMutex(mdata->mouse_mutex);
delete mdata;
return 0;
}
IOHIDManagerRegisterInputValueCallback(hid_manager, input_callback, mdata);
IOHIDManagerScheduleWithRunLoop(hid_manager, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
uint32_t page = kHIDPage_GenericDesktop;
uint32_t usage = kHIDUsage_GD_Mouse;
CFDictionaryRef dict = NULL;
CFNumberRef pageNumRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &page);
CFNumberRef usageNumRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &usage);
const void *keys[2] = { CFSTR(kIOHIDDeviceUsagePageKey), CFSTR(kIOHIDDeviceUsageKey) };
const void *vals[2] = { pageNumRef, usageNumRef };
if (pageNumRef && usageNumRef)
dict = CFDictionaryCreate(kCFAllocatorDefault, keys, vals, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (pageNumRef)
CFRelease(pageNumRef);
if (usageNumRef)
CFRelease(usageNumRef);
IOHIDManagerSetDeviceMatching(hid_manager, dict);
if (dict)
CFRelease(dict);
while (!mdata->should_exit) {
CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1, false);
}
IOHIDManagerUnscheduleFromRunLoop(hid_manager, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
IOHIDManagerClose(hid_manager, kIOHIDOptionsTypeNone);
CFRelease(hid_manager);
SDL_DestroyMutex(mdata->mouse_mutex);
delete mdata;
return 0;
}
static void apple_hid_free(void)
{
if (!g_hid_manager)
return;
IOHIDManagerClose(g_hid_manager, kIOHIDOptionsTypeNone);
IOHIDManagerUnscheduleFromRunLoop(g_hid_manager,
CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
CFRelease(g_hid_manager);
g_hid_manager = NULL;
}
static int apple_hid_manager_free(apple_hid_t *hid)
{
if (!hid || !hid->ptr)
return -1;
IOHIDManagerUnscheduleFromRunLoop(hid->ptr,
CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
IOHIDManagerClose(hid->ptr, kIOHIDOptionsTypeNone);
CFRelease(hid->ptr);
hid->ptr = NULL;
return 0;
}
/* Function to perform any system-specific joystick related cleanup */
void
SDL_SYS_JoystickQuit(void)
{
while (FreeDevice(gpDeviceList)) {
/* spin */
}
if (hidman) {
IOHIDManagerUnscheduleFromRunLoop(hidman, CFRunLoopGetCurrent(), SDL_JOYSTICK_RUNLOOP_MODE);
IOHIDManagerClose(hidman, kIOHIDOptionsTypeNone);
CFRelease(hidman);
hidman = NULL;
}
}
/* Function to perform any system-specific joystick related cleanup */
void
SDL_SYS_JoystickQuit(void)
{
while (FreeDevice(gpDeviceList)) {
/* spin */
}
if (hidman) {
IOHIDManagerClose(hidman, kIOHIDOptionsTypeNone);
CFRelease(hidman);
hidman = NULL;
}
s_bDeviceAdded = s_bDeviceRemoved = SDL_FALSE;
}
void IOKitHIDEventPublisher::stop() {
// Stop the manager.
if (manager_ != nullptr) {
IOHIDManagerUnscheduleFromRunLoop(
manager_, run_loop_, kCFRunLoopDefaultMode);
IOHIDManagerClose(manager_, kIOHIDOptionsTypeNone);
manager_started_ = false;
manager_ = nullptr;
}
// Stop the run loop.
if (run_loop_ != nullptr) {
CFRunLoopStop(run_loop_);
}
}
void Gamepad_shutdown() {
if (hidManager != NULL) {
unsigned int deviceIndex;
IOHIDManagerUnscheduleFromRunLoop(hidManager, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
IOHIDManagerClose(hidManager, 0);
CFRelease(hidManager);
hidManager = NULL;
for (deviceIndex = 0; deviceIndex < numDevices; deviceIndex++) {
disposeDevice(devices[deviceIndex]);
}
free(devices);
devices = NULL;
numDevices = 0;
}
}
//! Close the HID device
void pjrc_rawhid::close(int)
{
// Make sure any pending locks are done
QMutexLocker lock(m_writeMutex);
if (device_open) {
device_open = false;
CFRunLoopStop(the_correct_runloop);
if (!unplugged) {
IOHIDDeviceUnscheduleFromRunLoop(dev, the_correct_runloop, kCFRunLoopDefaultMode);
IOHIDDeviceRegisterInputReportCallback(dev, buffer, sizeof(buffer), NULL, NULL);
IOHIDDeviceClose(dev, kIOHIDOptionsTypeNone);
}
IOHIDManagerRegisterDeviceRemovalCallback(hid_manager, NULL, NULL);
IOHIDManagerClose(hid_manager, 0);
dev = NULL;
hid_manager = NULL;
}
}
static void apple_joypad_destroy(void)
{
unsigned i;
for (i = 0; i < MAX_PLAYERS; i ++)
{
if (slots[i].used && slots[i].iface && slots[i].iface->set_rumble)
{
slots[i].iface->set_rumble(slots[i].data, RETRO_RUMBLE_STRONG, 0);
slots[i].iface->set_rumble(slots[i].data, RETRO_RUMBLE_WEAK, 0);
}
}
#ifdef OSX
if (g_hid_manager)
{
IOHIDManagerClose(g_hid_manager, kIOHIDOptionsTypeNone);
IOHIDManagerUnscheduleFromRunLoop(g_hid_manager, CFRunLoopGetCurrent(), kCFRunLoopCommonModes);
CFRelease(g_hid_manager);
}
g_hid_manager = NULL;
#endif
}
CPH_HidMacOSX::~CPH_HidMacOSX()
{
IOHIDManagerClose(m_hidManager, 0);
}
void usbdeinit(){
IOHIDManagerClose(usbmanager, kIOHIDOptionsTypeSeizeDevice);
}
void usbdeinit(){
IOHIDManagerClose(usbmanager, kIOHIDOptionsTypeNone);
}
UsbMonitor_mac::~UsbMonitor_mac()
{
IOHIDManagerClose(hidmanager, kIOHIDOptionsTypeNone);
CFRelease(hidmanager);
}
/**************************************************************************
* find_osx_devices
*/
static int find_osx_devices(void)
{
IOHIDManagerRef hid_manager;
int usages[] = { kHIDUsage_GD_Joystick, kHIDUsage_GD_GamePad };
int i;
CFDictionaryRef matching_dicts[sizeof(usages) / sizeof(usages[0])];
CFArrayRef matching;
CFSetRef devset;
TRACE("()\n");
hid_manager = IOHIDManagerCreate(kCFAllocatorDefault, 0L);
if (IOHIDManagerOpen(hid_manager, 0) != kIOReturnSuccess)
{
ERR("Couldn't open IOHIDManager.\n");
CFRelease(hid_manager);
return 0;
}
for (i = 0; i < sizeof(matching_dicts) / sizeof(matching_dicts[0]); i++)
{
matching_dicts[i] = create_osx_device_match(usages[i]);
if (!matching_dicts[i])
{
while (i > 0)
CFRelease(matching_dicts[--i]);
goto fail;
}
}
matching = CFArrayCreate(NULL, (const void**)matching_dicts, sizeof(matching_dicts) / sizeof(matching_dicts[0]),
&kCFTypeArrayCallBacks);
for (i = 0; i < sizeof(matching_dicts) / sizeof(matching_dicts[0]); i++)
CFRelease(matching_dicts[i]);
IOHIDManagerSetDeviceMatchingMultiple(hid_manager, matching);
CFRelease(matching);
devset = IOHIDManagerCopyDevices(hid_manager);
if (devset)
{
CFIndex num_devices, num_main_elements;
const void** refs;
CFArrayRef devices;
num_devices = CFSetGetCount(devset);
refs = HeapAlloc(GetProcessHeap(), 0, num_devices * sizeof(*refs));
if (!refs)
{
CFRelease(devset);
goto fail;
}
CFSetGetValues(devset, refs);
devices = CFArrayCreate(NULL, refs, num_devices, &kCFTypeArrayCallBacks);
HeapFree(GetProcessHeap(), 0, refs);
CFRelease(devset);
if (!devices)
goto fail;
device_main_elements = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
if (!device_main_elements)
{
CFRelease(devices);
goto fail;
}
num_main_elements = 0;
for (i = 0; i < num_devices; i++)
{
IOHIDDeviceRef hid_device = (IOHIDDeviceRef)CFArrayGetValueAtIndex(devices, i);
TRACE("hid_device %s\n", debugstr_device(hid_device));
num_main_elements += find_top_level(hid_device, device_main_elements);
}
CFRelease(devices);
TRACE("found %i device(s), %i collection(s)\n",(int)num_devices,(int)num_main_elements);
return (int)num_main_elements;
}
fail:
IOHIDManagerClose(hid_manager, 0);
CFRelease(hid_manager);
return 0;
}
