Adding 0.3.2 OSX files

1 files changed, 924 insertions, 0 deletions

diff --git a/LibOVR/Src/OVR_OSX_HIDDevice.cpp b/LibOVR/Src/OVR_OSX_HIDDevice.cpp
new file mode 100644
index 0000000..af840e0
--- /dev/null
+++ b/LibOVR/Src/OVR_OSX_HIDDevice.cpp
@@ -0,0 +1,924 @@
+/************************************************************************************
+Filename    :   OVR_OSX_HIDDevice.cpp
+Content     :   OSX HID device implementation.
+Created     :   February 26, 2013
+Authors     :   Lee Cooper
+ 
+Copyright   :   Copyright 2014 Oculus VR, Inc. All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.1 (the "License"); 
+you may not use the Oculus VR Rift SDK except in compliance with the License, 
+which is provided at the time of installation or download, or which 
+otherwise accompanies this software in either electronic or hard copy form.
+
+You may obtain a copy of the License at
+
+http://www.oculusvr.com/licenses/LICENSE-3.1 
+
+Unless required by applicable law or agreed to in writing, the Oculus VR SDK 
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+*************************************************************************************/
+
+#include "OVR_OSX_HIDDevice.h"
+
+#include <IOKit/usb/IOUSBLib.h>
+
+namespace OVR { namespace OSX {
+
+    
+//-------------------------------------------------------------------------------------
+// **** OSX::DeviceManager
+
+HIDDeviceManager::HIDDeviceManager(DeviceManager* manager)
+ :  DevManager(manager)
+{
+    HIDManager = NULL;
+}
+
+HIDDeviceManager::~HIDDeviceManager()
+{
+}
+
+CFRunLoopRef HIDDeviceManager::getRunLoop()
+{
+    if (DevManager != NULL)
+    {
+        return DevManager->pThread->GetRunLoop();
+    }
+
+    return CFRunLoopGetCurrent();
+}
+
+bool HIDDeviceManager::initializeManager()
+{
+    if (HIDManager != NULL)
+    {
+        return true;
+    }
+    
+	HIDManager = IOHIDManagerCreate(kCFAllocatorDefault, kIOHIDOptionsTypeNone);
+    
+    if (!HIDManager)
+    {
+        return false;
+    }
+    
+    // Create a Matching Dictionary
+    CFMutableDictionaryRef matchDict =
+        CFDictionaryCreateMutable(kCFAllocatorDefault,
+                                  2,
+                                  &kCFTypeDictionaryKeyCallBacks,
+                                  &kCFTypeDictionaryValueCallBacks);
+    
+    // Specify a device manufacturer in the Matching Dictionary
+    UInt32 vendorId = Oculus_VendorId;
+    CFNumberRef vendorIdRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &vendorId);
+    CFDictionarySetValue(matchDict,
+                         CFSTR(kIOHIDVendorIDKey),
+                         vendorIdRef);
+    // Register the Matching Dictionary to the HID Manager
+    IOHIDManagerSetDeviceMatching(HIDManager, matchDict);
+    CFRelease(vendorIdRef);
+    CFRelease(matchDict);
+    
+    // Register a callback for USB device detection with the HID Manager
+    IOHIDManagerRegisterDeviceMatchingCallback(HIDManager, &staticDeviceMatchingCallback, this);
+    
+    IOHIDManagerScheduleWithRunLoop(HIDManager, getRunLoop(), kCFRunLoopDefaultMode);
+
+    return true;
+}
+    
+bool HIDDeviceManager::Initialize()
+{
+    return initializeManager();
+}
+
+void HIDDeviceManager::Shutdown()
+{
+    OVR_ASSERT_LOG(HIDManager, ("Should have called 'Initialize' before 'Shutdown'."));
+    CFRelease(HIDManager);
+    
+    LogText("OVR::OSX::HIDDeviceManager - shutting down.\n");
+}
+    
+bool HIDDeviceManager::getIntProperty(IOHIDDeviceRef device, CFStringRef propertyName, SInt32* pResult)
+{
+    
+    CFTypeRef ref = IOHIDDeviceGetProperty(device, propertyName);
+
+    if (!ref)
+    {
+        return false;
+    }
+    
+    if (CFGetTypeID(ref) != CFNumberGetTypeID())
+    {
+        return false;
+    }
+    
+    CFNumberGetValue((CFNumberRef) ref, kCFNumberSInt32Type, pResult);
+
+    return true;
+}
+    
+bool HIDDeviceManager::initVendorProductVersion(IOHIDDeviceRef device, HIDDeviceDesc* pDevDesc)
+{
+    
+    if (!getVendorId(device, &(pDevDesc->VendorId)))
+    {
+        return false;
+    }
+    
+    if (!getProductId(device, &(pDevDesc->ProductId)))
+    {
+        return false;
+    }
+
+    SInt32 result;
+    if (!getIntProperty(device, CFSTR(kIOHIDVersionNumberKey), &result))
+    {
+        return false;
+    }
+    pDevDesc->VersionNumber = result;
+    
+    return true;
+}
+
+bool HIDDeviceManager::initUsage(IOHIDDeviceRef device, HIDDeviceDesc* pDevDesc)
+{
+    
+    SInt32 result;
+    
+    if (!getIntProperty(device, CFSTR(kIOHIDPrimaryUsagePageKey), &result))
+    {
+        return false;
+    }
+    
+    pDevDesc->UsagePage = result;
+
+    
+    if (!getIntProperty(device, CFSTR(kIOHIDPrimaryUsageKey), &result))
+    {
+        return false;
+    }
+    
+    pDevDesc->Usage = result;
+    
+    return true;
+}
+
+bool HIDDeviceManager::initSerialNumber(IOHIDDeviceRef device, HIDDeviceDesc* pDevDesc)
+{
+    return getSerialNumberString(device, &(pDevDesc->SerialNumber));
+}
+    
+bool HIDDeviceManager::initStrings(IOHIDDeviceRef device, HIDDeviceDesc* pDevDesc)
+{
+
+    // Regardless of whether they fail we'll try and get the remaining.
+    getStringProperty(device, CFSTR(kIOHIDManufacturerKey), &(pDevDesc->Manufacturer));
+    getStringProperty(device, CFSTR(kIOHIDProductKey), &(pDevDesc->Product));
+    
+    return true;
+}
+
+bool HIDDeviceManager::getStringProperty(IOHIDDeviceRef device,
+                                         CFStringRef propertyName,
+                                         String* pResult)
+{
+    
+    CFStringRef str = (CFStringRef) IOHIDDeviceGetProperty(device, propertyName);
+    
+    if (!str)
+    {
+        return false;
+    }
+
+    CFIndex length = CFStringGetLength(str);
+    CFRange range = CFRangeMake(0, length);
+    
+    // Test the conversion first to get required buffer size.
+    CFIndex bufferLength;
+    CFIndex numberOfChars = CFStringGetBytes(str,
+                                             range,
+                                             kCFStringEncodingUTF8,
+                                             (char) '?',
+                                             FALSE,
+                                             NULL,
+                                             0,
+                                             &bufferLength);
+    
+    if (numberOfChars == 0)
+    {
+        return false;
+    }
+    
+    // Now allocate buffer.
+    char* buffer = new char[bufferLength+1];
+    
+    numberOfChars = CFStringGetBytes(str,
+                                     range,
+                                     kCFStringEncodingUTF8,
+                                     (char) '?',
+                                     FALSE,
+                                     (UInt8*) buffer,
+                                     bufferLength,
+                                     NULL);
+    OVR_ASSERT_LOG(numberOfChars != 0, ("CFStringGetBytes failed."));
+
+    buffer[bufferLength] = '\0';
+    *pResult = String(buffer);
+    
+    return true;
+}
+    
+bool HIDDeviceManager::getVendorId(IOHIDDeviceRef device, UInt16* pResult)
+{
+    SInt32 result;
+    
+    if (!getIntProperty(device, CFSTR(kIOHIDVendorIDKey), &result))
+    {
+        return false;
+    }
+    
+    *pResult = result;
+
+    return true;
+}
+    
+bool HIDDeviceManager::getProductId(IOHIDDeviceRef device, UInt16* pResult)
+{
+    SInt32 result;
+    
+    if (!getIntProperty(device, CFSTR(kIOHIDProductIDKey), &result))
+    {
+        return false;
+    }
+    
+    *pResult = result;
+    
+    return true;
+}
+ 
+bool HIDDeviceManager::getLocationId(IOHIDDeviceRef device, SInt32* pResult)
+{
+    SInt32 result;
+    
+    if (!getIntProperty(device, CFSTR(kIOHIDLocationIDKey), &result))
+    {
+        return false;
+    }
+        
+    *pResult = result;
+        
+    return true;
+}
+    
+bool HIDDeviceManager::getSerialNumberString(IOHIDDeviceRef device, String* pResult)
+{
+ 
+    if (!getStringProperty(device, CFSTR(kIOHIDSerialNumberKey), pResult))
+    {
+        return false;
+    }
+
+    return true;
+}
+    
+bool HIDDeviceManager::getPath(IOHIDDeviceRef device, String* pPath)
+{
+
+    String transport;
+    if (!getStringProperty(device, CFSTR(kIOHIDTransportKey), &transport))
+    {
+        return false;
+    }
+    
+    UInt16 vendorId;
+    if (!getVendorId(device, &vendorId))
+    {
+        return false;
+    }
+
+    UInt16 productId;
+    if (!getProductId(device, &productId))
+    {
+        return false;
+    }
+    
+    String serialNumber;
+	if (!getSerialNumberString(device, &serialNumber))
+    {
+        return false;
+    }
+    
+
+    StringBuffer buffer;
+    buffer.AppendFormat("%s:vid=%04hx:pid=%04hx:ser=%s",
+                            transport.ToCStr(),
+                            vendorId,
+                            productId,
+                            serialNumber.ToCStr());
+    
+    *pPath = String(buffer);
+    
+    return true;
+}
+
+bool HIDDeviceManager::Enumerate(HIDEnumerateVisitor* enumVisitor)
+{
+    if (!initializeManager())
+    {
+        return false;
+    }
+    
+
+	CFSetRef deviceSet = IOHIDManagerCopyDevices(HIDManager);
+    if (!deviceSet)
+        return false;
+    
+	CFIndex deviceCount = CFSetGetCount(deviceSet);
+    
+    // Allocate a block of memory and read the set into it.
+    IOHIDDeviceRef* devices = (IOHIDDeviceRef*) OVR_ALLOC(sizeof(IOHIDDeviceRef) * deviceCount);
+    CFSetGetValues(deviceSet, (const void **) devices);
+    
+
+    // Iterate over devices.
+    for (CFIndex deviceIndex = 0; deviceIndex < deviceCount; deviceIndex++)
+    {
+        IOHIDDeviceRef hidDev = devices[deviceIndex];
+        
+        if (!hidDev)
+        {
+            continue;
+        }
+        
+        HIDDeviceDesc devDesc;
+                
+        if (getPath(hidDev, &(devDesc.Path)) &&
+            initVendorProductVersion(hidDev, &devDesc) &&
+            enumVisitor->MatchVendorProduct(devDesc.VendorId, devDesc.ProductId) &&
+            initUsage(hidDev, &devDesc))
+        {
+            initStrings(hidDev, &devDesc);
+            initSerialNumber(hidDev, &devDesc);
+
+            // Look for the device to check if it is already opened.
+            Ptr<DeviceCreateDesc> existingDevice = DevManager->FindHIDDevice(devDesc, true);
+            // if device exists and it is opened then most likely the CreateHIDFile
+            // will fail; therefore, we just set Enumerated to 'true' and continue.
+            if (existingDevice && existingDevice->pDevice)
+            {
+                existingDevice->Enumerated = true;
+                continue;
+            }
+            
+            // Construct minimal device that the visitor callback can get feature reports from.
+            OSX::HIDDevice device(this, hidDev);
+            
+            enumVisitor->Visit(device, devDesc);
+        }
+    }
+    
+    OVR_FREE(devices);
+    CFRelease(deviceSet);
+    
+    return true;
+}
+
+OVR::HIDDevice* HIDDeviceManager::Open(const String& path)
+{
+
+    Ptr<OSX::HIDDevice> device = *new OSX::HIDDevice(this);
+
+    if (!device->HIDInitialize(path))
+    {
+        return NULL;
+    }
+
+    device->AddRef();
+    
+    return device;
+}
+    
+bool HIDDeviceManager::getFullDesc(IOHIDDeviceRef device, HIDDeviceDesc* desc)
+{
+        
+    if (!initVendorProductVersion(device, desc))
+    {
+        return false;
+    }
+        
+    if (!initUsage(device, desc))
+    {
+        return false;
+    }
+    
+    if (!initSerialNumber(device, desc))
+    {
+        return false;
+    }
+    
+    initStrings(device, desc);
+        
+    return true;
+}
+
+// New USB device specified in the matching dictionary has been added (callback function)
+void HIDDeviceManager::staticDeviceMatchingCallback(void *inContext,
+                                                    IOReturn inResult,
+                                                    void *inSender,
+                                                    IOHIDDeviceRef inIOHIDDeviceRef)
+{
+    OVR_UNUSED(inResult);
+    OVR_UNUSED(inSender);
+    HIDDeviceManager* hidMgr = static_cast<HIDDeviceManager*>(inContext);
+    HIDDeviceDesc hidDevDesc;
+    hidMgr->getPath(inIOHIDDeviceRef, &hidDevDesc.Path);
+    hidMgr->getFullDesc(inIOHIDDeviceRef, &hidDevDesc);
+    
+    hidMgr->DevManager->DetectHIDDevice(hidDevDesc);
+}
+
+//-------------------------------------------------------------------------------------
+// **** OSX::HIDDevice
+
+HIDDevice::HIDDevice(HIDDeviceManager* manager)
+ :  InMinimalMode(false), HIDManager(manager)
+{
+    Device = NULL;
+    RepluggedNotificationPort = 0;
+}
+    
+// This is a minimal constructor used during enumeration for us to pass
+// a HIDDevice to the visit function (so that it can query feature reports).
+HIDDevice::HIDDevice(HIDDeviceManager* manager, IOHIDDeviceRef device)
+:   InMinimalMode(true), HIDManager(manager), Device(device)
+{
+    RepluggedNotificationPort = 0;
+}
+
+HIDDevice::~HIDDevice()
+{
+    if (!InMinimalMode)
+    {
+        HIDShutdown();
+    }
+}
+
+bool HIDDevice::HIDInitialize(const String& path)
+{
+
+    DevDesc.Path = path;
+
+    if (!openDevice())
+    {
+        LogText("OVR::OSX::HIDDevice - Failed to open HIDDevice: %s", path.ToCStr());
+        return false;
+    }
+
+    // Setup notification for when a device is unplugged and plugged back in.
+    if (!setupDevicePluggedInNotification())
+    {
+        LogText("OVR::OSX::HIDDevice - Failed to setup notification for when device plugged back in.");
+        closeDevice(false);
+        return false;
+    }
+    
+    HIDManager->DevManager->pThread->AddTicksNotifier(this);
+
+    
+    LogText("OVR::OSX::HIDDevice - Opened '%s'\n"
+            "                    Manufacturer:'%s'  Product:'%s'  Serial#:'%s'\n",
+            DevDesc.Path.ToCStr(),
+            DevDesc.Manufacturer.ToCStr(), DevDesc.Product.ToCStr(),
+            DevDesc.SerialNumber.ToCStr());
+    
+    return true;
+}
+
+bool HIDDevice::initInfo()
+{
+    // Device must have been successfully opened.
+    OVR_ASSERT(Device);
+    
+    
+    // Get report lengths.
+    SInt32 bufferLength;
+    bool getResult = HIDManager->getIntProperty(Device, CFSTR(kIOHIDMaxInputReportSizeKey), &bufferLength);
+    OVR_ASSERT(getResult);
+    InputReportBufferLength = (UInt16) bufferLength;
+
+    getResult = HIDManager->getIntProperty(Device, CFSTR(kIOHIDMaxOutputReportSizeKey), &bufferLength);
+    OVR_ASSERT(getResult);
+    OutputReportBufferLength = (UInt16) bufferLength;
+
+    getResult = HIDManager->getIntProperty(Device, CFSTR(kIOHIDMaxFeatureReportSizeKey), &bufferLength);
+    OVR_ASSERT(getResult);
+    FeatureReportBufferLength = (UInt16) bufferLength;
+    
+    
+    if (ReadBufferSize < InputReportBufferLength)
+    {
+        OVR_ASSERT_LOG(false, ("Input report buffer length is bigger than read buffer."));
+        return false;
+    }
+    
+    // Get device desc.
+    if (!HIDManager->getFullDesc(Device, &DevDesc))
+    {
+        OVR_ASSERT_LOG(false, ("Failed to get device desc while initializing device."));
+        return false;
+    }
+    
+    return true;
+}
+
+void HIDDevice::staticDeviceAddedCallback(void* pContext, io_iterator_t iterator)
+{
+    HIDDevice* pDevice = (HIDDevice*) pContext;
+    pDevice->deviceAddedCallback(iterator);
+}
+
+void HIDDevice::deviceAddedCallback(io_iterator_t iterator)
+{
+
+    if (Device == NULL)
+    {
+        if (openDevice())
+        {
+            LogText("OVR::OSX::HIDDevice - Reopened device : %s", DevDesc.Path.ToCStr());
+
+            Ptr<DeviceCreateDesc> existingHIDDev = HIDManager->DevManager->FindHIDDevice(DevDesc, true);
+            if (existingHIDDev && existingHIDDev->pDevice)
+            {
+                HIDManager->DevManager->CallOnDeviceAdded(existingHIDDev);
+            }
+        }
+    }
+
+    // Reset callback.
+    while (IOIteratorNext(iterator))
+        ;
+}
+    
+bool HIDDevice::openDevice()
+{
+    
+    // Have to iterate through devices again to generate paths.
+	CFSetRef deviceSet = IOHIDManagerCopyDevices(HIDManager->HIDManager);
+	CFIndex deviceCount = CFSetGetCount(deviceSet);
+    
+    // Allocate a block of memory and read the set into it.
+    IOHIDDeviceRef* devices = (IOHIDDeviceRef*) OVR_ALLOC(sizeof(IOHIDDeviceRef) * deviceCount);
+    CFSetGetValues(deviceSet, (const void **) devices);
+    
+    
+    // Iterate over devices.
+    IOHIDDeviceRef device = NULL;
+
+    for (CFIndex deviceIndex = 0; deviceIndex < deviceCount; deviceIndex++)
+    {
+        IOHIDDeviceRef tmpDevice = devices[deviceIndex];
+        
+        if (!tmpDevice)
+        {
+            continue;
+        }
+        
+        String path;
+        if (!HIDManager->getPath(tmpDevice, &path))
+        {
+            continue;
+        }
+        
+        if (path == DevDesc.Path)
+        {
+            device = tmpDevice;
+            break;
+        }
+    }
+    
+    
+    OVR_FREE(devices);
+    
+    if (!device)
+    {
+        CFRelease(deviceSet);
+        return false;
+    }
+    
+    // Attempt to open device.
+    if (IOHIDDeviceOpen(device, kIOHIDOptionsTypeSeizeDevice)
+        != kIOReturnSuccess)
+    {
+        CFRelease(deviceSet);
+        return false;
+    }
+
+    // Retain the device before we release the set.
+    CFRetain(device);
+    CFRelease(deviceSet);
+    
+    
+    Device = device;
+
+    
+    if (!initInfo())
+    {
+        IOHIDDeviceClose(Device, kIOHIDOptionsTypeSeizeDevice);
+        CFRelease(Device);
+        Device = NULL;
+        return false;
+    }
+    
+    
+    // Setup the Run Loop and callbacks.
+    IOHIDDeviceScheduleWithRunLoop(Device,
+                                   HIDManager->getRunLoop(),
+                                   kCFRunLoopDefaultMode);
+    
+    IOHIDDeviceRegisterInputReportCallback(Device,
+                                           ReadBuffer,
+                                           ReadBufferSize,
+                                           staticHIDReportCallback,
+                                           this);
+
+    IOHIDDeviceRegisterRemovalCallback(Device,
+                                       staticDeviceRemovedCallback,
+                                       this);
+    
+    return true;
+}
+    
+void HIDDevice::HIDShutdown()
+{
+
+    HIDManager->DevManager->pThread->RemoveTicksNotifier(this);
+    
+    if (Device != NULL) // Device may already have been closed if unplugged.
+    {
+        closeDevice(false);
+    }
+
+    IOObjectRelease(RepluggedNotification);
+    if (RepluggedNotificationPort)
+        IONotificationPortDestroy(RepluggedNotificationPort);
+    
+    LogText("OVR::OSX::HIDDevice - HIDShutdown '%s'\n", DevDesc.Path.ToCStr());
+}
+
+bool HIDDevice::setupDevicePluggedInNotification()
+{
+    
+    // Setup notification when devices are plugged in.
+    RepluggedNotificationPort = IONotificationPortCreate(kIOMasterPortDefault);
+    
+    CFRunLoopSourceRef notificationRunLoopSource =
+        IONotificationPortGetRunLoopSource(RepluggedNotificationPort);
+    
+    CFRunLoopAddSource(HIDManager->getRunLoop(),
+                       notificationRunLoopSource,
+                       kCFRunLoopDefaultMode);
+    
+    CFMutableDictionaryRef matchingDict = IOServiceMatching(kIOUSBDeviceClassName);
+    
+    // Have to specify vendorId and productId. Doesn't seem to accept additional
+    // things like serial number.
+    SInt32 vendorId = DevDesc.VendorId;
+    CFNumberRef numberRef = CFNumberCreate(kCFAllocatorDefault,
+                                           kCFNumberSInt32Type,
+                                           &vendorId);
+    CFDictionarySetValue(matchingDict, CFSTR(kUSBVendorID), numberRef);
+    CFRelease(numberRef);
+    
+    SInt32 deviceProductId = DevDesc.ProductId;
+    numberRef = CFNumberCreate(kCFAllocatorDefault,
+                               kCFNumberSInt32Type,
+                               &deviceProductId);
+    CFDictionarySetValue(matchingDict, CFSTR(kUSBProductID), numberRef);
+    CFRelease(numberRef);
+    
+    kern_return_t result =
+            IOServiceAddMatchingNotification(RepluggedNotificationPort,
+                                             kIOMatchedNotification,
+                                             matchingDict,
+                                             staticDeviceAddedCallback,
+                                             this,
+                                             &RepluggedNotification);
+    
+    if (result != KERN_SUCCESS)
+    {
+        CFRelease(RepluggedNotificationPort);
+        RepluggedNotificationPort = 0;
+        return false;
+    }
+    
+    // Iterate through to arm.
+    while (IOIteratorNext(RepluggedNotification))
+    {
+	}
+    
+    return true;
+}
+
+void HIDDevice::closeDevice(bool wasUnplugged)
+{
+    OVR_ASSERT(Device != NULL);
+    
+    if (!wasUnplugged)
+    {
+        // Clear the registered callbacks.
+        IOHIDDeviceRegisterInputReportCallback(Device,
+                                               ReadBuffer,
+                                               InputReportBufferLength,
+                                               NULL,
+                                               this);
+        
+        IOHIDDeviceRegisterRemovalCallback(Device, NULL, this);
+        
+        IOHIDDeviceUnscheduleFromRunLoop(Device,
+                                         HIDManager->getRunLoop(),
+                                         kCFRunLoopDefaultMode);
+        IOHIDDeviceClose(Device, kIOHIDOptionsTypeNone);
+    }
+    
+	CFRelease(Device);
+    Device = NULL;
+        
+    LogText("OVR::OSX::HIDDevice - HID Device Closed '%s'\n", DevDesc.Path.ToCStr());
+}
+
+void HIDDevice::staticHIDReportCallback(void* pContext,
+                                        IOReturn result,
+                                        void* pSender,
+                                        IOHIDReportType reportType,
+                                        uint32_t reportId,
+                                        uint8_t* pReport,
+                                        CFIndex reportLength)
+{
+    OVR_UNUSED(result);
+    OVR_UNUSED(pSender);
+    OVR_UNUSED(reportType);
+    OVR_UNUSED(reportId);
+
+    HIDDevice* pDevice = (HIDDevice*) pContext;
+    return pDevice->hidReportCallback(pReport, (UInt32)reportLength);
+}
+
+void HIDDevice::hidReportCallback(UByte* pData, UInt32 length)
+{
+    
+    // We got data.
+    if (Handler)
+    {
+        Handler->OnInputReport(pData, length);
+    }
+}
+    
+void HIDDevice::staticDeviceRemovedCallback(void* pContext, IOReturn result, void* pSender)
+{
+    OVR_UNUSED(result);
+    OVR_UNUSED(pSender);
+    HIDDevice* pDevice = (HIDDevice*) pContext;
+    pDevice->deviceRemovedCallback();
+}
+    
+void HIDDevice::deviceRemovedCallback()
+{
+    Ptr<HIDDevice> _this(this); // prevent from release
+    
+    Ptr<DeviceCreateDesc> existingHIDDev = HIDManager->DevManager->FindHIDDevice(DevDesc, true);
+    if (existingHIDDev && existingHIDDev->pDevice)
+    {
+        HIDManager->DevManager->CallOnDeviceRemoved(existingHIDDev);
+    }
+    closeDevice(true);
+}
+
+CFStringRef HIDDevice::generateRunLoopModeString(IOHIDDeviceRef device)
+{
+    const UInt32 safeBuffSize = 256;
+    char nameBuff[safeBuffSize];
+    OVR_sprintf(nameBuff, safeBuffSize, "%016lX", device);
+  
+    return CFStringCreateWithCString(NULL, nameBuff, kCFStringEncodingASCII);
+}
+    
+bool HIDDevice::SetFeatureReport(UByte* data, UInt32 length)
+{
+    
+    if (!Device)
+        return false;
+    
+    UByte reportID = data[0];
+
+    if (reportID == 0)
+    {
+        // Not using reports so remove from data packet.
+        data++;
+        length--;
+    }
+    
+	IOReturn result = IOHIDDeviceSetReport( Device,
+                                            kIOHIDReportTypeFeature,
+                                            reportID,
+                                            data,
+                                            length);
+    
+    return (result == kIOReturnSuccess);
+}
+
+bool HIDDevice::GetFeatureReport(UByte* data, UInt32 length)
+{
+    if (!Device)
+        return false;
+    
+    CFIndex bufferLength = length;
+    
+    // Report id is in first byte of the buffer.
+	IOReturn result = IOHIDDeviceGetReport(Device, kIOHIDReportTypeFeature, data[0], data, &bufferLength);
+	
+    return (result == kIOReturnSuccess);
+}
+   
+double HIDDevice::OnTicks(double tickSeconds)
+{
+    
+    if (Handler)
+    {
+        return Handler->OnTicks(tickSeconds);
+    }
+    
+    return DeviceManagerThread::Notifier::OnTicks(tickSeconds);
+}
+
+HIDDeviceManager* HIDDeviceManager::CreateInternal(OSX::DeviceManager* devManager)
+{
+        
+    if (!System::IsInitialized())
+    {
+        // Use custom message, since Log is not yet installed.
+        OVR_DEBUG_STATEMENT(Log::GetDefaultLog()->
+                            LogMessage(Log_Debug, "HIDDeviceManager::Create failed - OVR::System not initialized"); );
+        return 0;
+    }
+
+    Ptr<OSX::HIDDeviceManager> manager = *new OSX::HIDDeviceManager(devManager);
+
+    if (manager)
+    {
+        if (manager->Initialize())
+        {
+            manager->AddRef();
+        }
+        else
+        {
+            manager.Clear();
+        }
+    }
+
+    return manager.GetPtr();
+}
+    
+} // namespace OSX
+
+//-------------------------------------------------------------------------------------
+// ***** Creation
+
+// Creates a new HIDDeviceManager and initializes OVR.
+HIDDeviceManager* HIDDeviceManager::Create(Ptr<OVR::DeviceManager>& deviceManager)
+{
+    
+    if (!System::IsInitialized())
+    {
+        // Use custom message, since Log is not yet installed.
+        OVR_DEBUG_STATEMENT(Log::GetDefaultLog()->
+            LogMessage(Log_Debug, "HIDDeviceManager::Create failed - OVR::System not initialized"); );
+        return 0;
+    }
+
+    Ptr<OSX::DeviceManager> deviceManagerOSX = *new OSX::DeviceManager;
+
+	if (!deviceManagerOSX)
+    {
+		return NULL;
+	}
+
+	if (!deviceManagerOSX->Initialize(NULL))
+    {         
+		return NULL;
+    }
+
+	deviceManager = deviceManagerOSX;
+
+	return deviceManagerOSX->GetHIDDeviceManager();
+}
+
+} // namespace OVR