Implement support for USB Xbox360 controllers without a driver on Mac.

content/browser/gamepad/gamepad_platform_data_fetcher_mac.mm

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/gamepad/gamepad_platform_data_fetcher_mac.h"
 
 #include "base/mac/foundation_util.h"
 #include "base/memory/scoped_nsobject.h"
 #include "base/string16.h"
 #include "base/string_util.h"
+#include "base/time.h"
 #include "base/utf_string_conversions.h"
 
 #include <IOKit/hid/IOHIDKeys.h>
 #import <Foundation/Foundation.h>
 
+using WebKit::WebGamepad;
+using WebKit::WebGamepads;
+
 namespace content {
 
 namespace {
 
 NSDictionary* DeviceMatching(uint32_t usage_page, uint32_t usage) {
   return [NSDictionary dictionaryWithObjectsAndKeys:
       [NSNumber numberWithUnsignedInt:usage_page],
           base::mac::CFToNSCast(CFSTR(kIOHIDDeviceUsagePageKey)),
       [NSNumber numberWithUnsignedInt:usage],
           base::mac::CFToNSCast(CFSTR(kIOHIDDeviceUsageKey)),
@@ skipping 27 matching lines @@
 
   scoped_nsobject<NSArray> criteria([[NSArray alloc] initWithObjects:
       DeviceMatching(kGenericDesktopUsagePage, kJoystickUsageNumber),
       DeviceMatching(kGenericDesktopUsagePage, kGameUsageNumber),
       DeviceMatching(kGenericDesktopUsagePage, kMultiAxisUsageNumber),
       nil]);
   IOHIDManagerSetDeviceMatchingMultiple(
       hid_manager_ref_,
       base::mac::NSToCFCast(criteria));
 
+  xbox_fetcher_.reset(new XboxDataFetcher(this));
+
   RegisterForNotifications();
 }
 
 void GamepadPlatformDataFetcherMac::RegisterForNotifications() {
   // Register for plug/unplug notifications.
   IOHIDManagerRegisterDeviceMatchingCallback(
       hid_manager_ref_,
       &DeviceAddCallback,
       this);
   IOHIDManagerRegisterDeviceRemovalCallback(
       hid_manager_ref_,
       DeviceRemoveCallback,
       this);
 
   // Register for value change notifications.
   IOHIDManagerRegisterInputValueCallback(
       hid_manager_ref_,
       ValueChangedCallback,
       this);
 
   IOHIDManagerScheduleWithRunLoop(
       hid_manager_ref_,
       CFRunLoopGetMain(),
       kCFRunLoopDefaultMode);
 
   enabled_ = IOHIDManagerOpen(hid_manager_ref_,
                               kIOHIDOptionsTypeNone) == kIOReturnSuccess;
+
+  xbox_fetcher_->RegisterForNotifications();
 }
 
 void GamepadPlatformDataFetcherMac::UnregisterFromNotifications() {
   IOHIDManagerUnscheduleFromRunLoop(
       hid_manager_ref_,
       CFRunLoopGetCurrent(),
       kCFRunLoopDefaultMode);
   IOHIDManagerClose(hid_manager_ref_, kIOHIDOptionsTypeNone);
+  xbox_fetcher_->UnregisterFromNotifications();
 }
 
 void GamepadPlatformDataFetcherMac::PauseHint(bool pause) {
   if (pause)
     UnregisterFromNotifications();
   else
     RegisterForNotifications();
 }
 
 GamepadPlatformDataFetcherMac::~GamepadPlatformDataFetcherMac() {
   UnregisterFromNotifications();
 }
 
 GamepadPlatformDataFetcherMac*
-GamepadPlatformDataFetcherMac::InstanceFromContext(
-    void* context) {
+GamepadPlatformDataFetcherMac::InstanceFromContext(void* context) {
   return reinterpret_cast<GamepadPlatformDataFetcherMac*>(context);
 }
 
 void GamepadPlatformDataFetcherMac::DeviceAddCallback(void* context,
-                                              IOReturn result,
-                                              void* sender,
-                                              IOHIDDeviceRef ref) {
+                                                      IOReturn result,
+                                                      void* sender,
+                                                      IOHIDDeviceRef ref) {
   InstanceFromContext(context)->DeviceAdd(ref);
 }
 
 void GamepadPlatformDataFetcherMac::DeviceRemoveCallback(void* context,
-                                                 IOReturn result,
-                                                 void* sender,
-                                                 IOHIDDeviceRef ref) {
+                                                         IOReturn result,
+                                                         void* sender,
+                                                         IOHIDDeviceRef ref) {
   InstanceFromContext(context)->DeviceRemove(ref);
 }
 
 void GamepadPlatformDataFetcherMac::ValueChangedCallback(void* context,
-                                                 IOReturn result,
-                                                 void* sender,
-                                                 IOHIDValueRef ref) {
+                                                         IOReturn result,
+                                                         void* sender,
+                                                         IOHIDValueRef ref) {
   InstanceFromContext(context)->ValueChanged(ref);
 }
 
 void GamepadPlatformDataFetcherMac::AddButtonsAndAxes(NSArray* elements,
-                                              size_t slot) {
-  WebKit::WebGamepad& pad = data_.items[slot];
+                                                      size_t slot) {
+  WebGamepad& pad = data_.items[slot];
   AssociatedData& associated = associated_[slot];
+  CHECK(!associated.is_xbox);
 
   pad.axesLength = 0;
   pad.buttonsLength = 0;
   pad.timestamp = 0;
   memset(pad.axes, 0, sizeof(pad.axes));
   memset(pad.buttons, 0, sizeof(pad.buttons));
 
   for (id elem in elements) {
     IOHIDElementRef element = reinterpret_cast<IOHIDElementRef>(elem);
     uint32_t usagePage = IOHIDElementGetUsagePage(element);
     uint32_t usage = IOHIDElementGetUsage(element);
     if (IOHIDElementGetType(element) == kIOHIDElementTypeInput_Button &&
         usagePage == kButtonUsagePage) {
       uint32_t button_index = usage - 1;
-      if (button_index < WebKit::WebGamepad::buttonsLengthCap) {
-        associated.button_elements[button_index] = element;
+      if (button_index < WebGamepad::buttonsLengthCap) {
+        associated.hid.button_elements[button_index] = element;
         pad.buttonsLength = std::max(pad.buttonsLength, button_index + 1);
       }
     }
     else if (IOHIDElementGetType(element) == kIOHIDElementTypeInput_Misc) {
       uint32_t axis_index = usage - kAxisMinimumUsageNumber;
-      if (axis_index < WebKit::WebGamepad::axesLengthCap) {
-        associated.axis_minimums[axis_index] =
+      if (axis_index < WebGamepad::axesLengthCap) {
+        associated.hid.axis_minimums[axis_index] =
             IOHIDElementGetLogicalMin(element);
-        associated.axis_maximums[axis_index] =
+        associated.hid.axis_maximums[axis_index] =
             IOHIDElementGetLogicalMax(element);
-        associated.axis_elements[axis_index] = element;
+        associated.hid.axis_elements[axis_index] = element;
         pad.axesLength = std::max(pad.axesLength, axis_index + 1);
       }
     }
   }
 }
 
 void GamepadPlatformDataFetcherMac::DeviceAdd(IOHIDDeviceRef device) {
-  using WebKit::WebGamepad;
-  using WebKit::WebGamepads;
   using base::mac::CFToNSCast;
   using base::mac::CFCastStrict;
-  size_t slot;
 
   if (!enabled_)
     return;
 
   // Find an index for this device.
+  size_t slot;
   for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
     // If we already have this device, and it's already connected, don't do
     // anything now.
-    if (associated_[slot].device_ref == device && data_.items[slot].connected)
+    if (data_.items[slot].connected &&
+        !associated_[slot].is_xbox &&
+        associated_[slot].hid.device_ref == device)
       return;
     if (!data_.items[slot].connected)
       break;
   }
 
   // We can't handle this many connected devices.
   if (slot == WebGamepads::itemsLengthCap)
     return;
 
   NSNumber* vendor_id = CFToNSCast(CFCastStrict<CFNumberRef>(
       IOHIDDeviceGetProperty(device, CFSTR(kIOHIDVendorIDKey))));
   NSNumber* product_id = CFToNSCast(CFCastStrict<CFNumberRef>(
       IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductIDKey))));
   NSString* product = CFToNSCast(CFCastStrict<CFStringRef>(
       IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductKey))));
   int vendor_int = [vendor_id intValue];
   int product_int = [product_id intValue];
 
   char vendor_as_str[5], product_as_str[5];
   snprintf(vendor_as_str, sizeof(vendor_as_str), "%04x", vendor_int);
   snprintf(product_as_str, sizeof(product_as_str), "%04x", product_int);
-  associated_[slot].mapper =
+  associated_[slot].hid.mapper =
       GetGamepadStandardMappingFunction(vendor_as_str, product_as_str);
 
   NSString* ident = [NSString stringWithFormat:
       @"%@ (%sVendor: %04x Product: %04x)",
       product,
-      associated_[slot].mapper ? "STANDARD GAMEPAD " : "",
+      associated_[slot].hid.mapper ? "STANDARD GAMEPAD " : "",
       vendor_int,
       product_int];
   NSData* as16 = [ident dataUsingEncoding:NSUTF16StringEncoding];
 
   const size_t kOutputLengthBytes = sizeof(data_.items[slot].id);
   memset(&data_.items[slot].id, 0, kOutputLengthBytes);
   [as16 getBytes:data_.items[slot].id
           length:kOutputLengthBytes - sizeof(WebKit::WebUChar)];
 
   base::mac::ScopedCFTypeRef<CFArrayRef> elements(
       IOHIDDeviceCopyMatchingElements(device, NULL, kIOHIDOptionsTypeNone));
   AddButtonsAndAxes(CFToNSCast(elements), slot);
 
-  associated_[slot].device_ref = device;
+  associated_[slot].hid.device_ref = device;
   data_.items[slot].connected = true;
   if (slot >= data_.length)
     data_.length = slot + 1;
 }
 
 void GamepadPlatformDataFetcherMac::DeviceRemove(IOHIDDeviceRef device) {
-  using WebKit::WebGamepads;
-  size_t slot;
   if (!enabled_)
     return;
 
   // Find the index for this device.
+  size_t slot;
   for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
-    if (associated_[slot].device_ref == device && data_.items[slot].connected)
+    if (data_.items[slot].connected &&
+        !associated_[slot].is_xbox &&
+        associated_[slot].hid.device_ref == device)
       break;
   }
   DCHECK(slot < WebGamepads::itemsLengthCap);
   // Leave associated device_ref so that it will be reconnected in the same
   // location. Simply mark it as disconnected.
   data_.items[slot].connected = false;
 }
 
 void GamepadPlatformDataFetcherMac::ValueChanged(IOHIDValueRef value) {
   if (!enabled_)
     return;
 
   IOHIDElementRef element = IOHIDValueGetElement(value);
   IOHIDDeviceRef device = IOHIDElementGetDevice(element);
 
   // Find device slot.
   size_t slot;
   for (slot = 0; slot < data_.length; ++slot) {
-    if (data_.items[slot].connected && associated_[slot].device_ref == device)
+    if (data_.items[slot].connected &&
+        !associated_[slot].is_xbox &&
+        associated_[slot].hid.device_ref == device)
       break;
   }
   if (slot == data_.length)
     return;
 
-  WebKit::WebGamepad& pad = data_.items[slot];
+  WebGamepad& pad = data_.items[slot];
   AssociatedData& associated = associated_[slot];
 
   // Find and fill in the associated button event, if any.
   for (size_t i = 0; i < pad.buttonsLength; ++i) {
-    if (associated.button_elements[i] == element) {
+    if (associated.hid.button_elements[i] == element) {
       pad.buttons[i] = IOHIDValueGetIntegerValue(value) ? 1.f : 0.f;
       pad.timestamp = std::max(pad.timestamp, IOHIDValueGetTimeStamp(value));
       return;
     }
   }
 
   // Find and fill in the associated axis event, if any.
   for (size_t i = 0; i < pad.axesLength; ++i) {
-    if (associated.axis_elements[i] == element) {
+    if (associated.hid.axis_elements[i] == element) {
       pad.axes[i] = NormalizeAxis(IOHIDValueGetIntegerValue(value),
-                                  associated.axis_minimums[i],
-                                  associated.axis_maximums[i]);
+                                  associated.hid.axis_minimums[i],
+                                  associated.hid.axis_maximums[i]);
       pad.timestamp = std::max(pad.timestamp, IOHIDValueGetTimeStamp(value));
       return;
     }
   }
 }
 
-void GamepadPlatformDataFetcherMac::GetGamepadData(
-    WebKit::WebGamepads* pads,
-    bool) {
+void GamepadPlatformDataFetcherMac::XboxDeviceAdd(XboxController* device) {
+  if (!enabled_)
+    return;
+
+  size_t slot;
+  for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
+    if (associated_[slot].is_xbox &&
+        !data_.items[slot].connected &&
+        associated_[slot].xbox.location_id == device->location_id()) {
+      break;
+    }
+  }
+
+  if (slot == WebGamepads::itemsLengthCap) {
+    // Find an index for this device.
+    for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
+      // If we already have this device, and it's already connected, don't do
+      // anything now.
+      if (associated_[slot].is_xbox &&
+          data_.items[slot].connected &&
+          associated_[slot].xbox.device == device)
+        return;
+      // XXX looks like there's a bug here? what if the first slot is empty,

[Mark Mentovai, 2013/04/24 16:57:20]

What’s the story here?

[jeremya, 2013/04/26 03:47:40]

I've refactored this code to hopefully remove the bug now :)

+      // but the device is connected in slot 3? hm. also in DeviceAdd.
+      if (!data_.items[slot].connected)
+        break;
+    }
+  }
+
+  // We can't handle this many connected devices.
+  if (slot == WebGamepads::itemsLengthCap)
+    return;
+
+  device->SetLEDPattern(
+      (XboxController::LEDPattern)(XboxController::LED_FLASH_1 + slot));
+
+  NSString* ident =
+      [NSString stringWithFormat:
+          @"Xbox 360 Controller (STANDARD GAMEPAD Vendor: %04x Product: %04x)",
+              device->GetProductId(), device->GetVendorId()];
+  NSData* as16 = [ident dataUsingEncoding:NSUTF16StringEncoding];
+  const size_t kOutputLengthBytes = sizeof(data_.items[slot].id);
+  memset(&data_.items[slot].id, 0, kOutputLengthBytes);
+  [as16 getBytes:data_.items[slot].id
+          length:kOutputLengthBytes - sizeof(WebKit::WebUChar)];
+
+  associated_[slot].is_xbox = true;
+  associated_[slot].xbox.device = device;
+  associated_[slot].xbox.location_id = device->location_id();
+  data_.items[slot].connected = true;
+  data_.items[slot].axesLength = 4;
+  data_.items[slot].buttonsLength = 17;
+  data_.items[slot].timestamp = 0;
+  if (slot >= data_.length)
+    data_.length = slot + 1;
+}
+
+void GamepadPlatformDataFetcherMac::XboxDeviceRemove(XboxController* device) {
+  if (!enabled_)
+    return;
+
+  // Find the index for this device.
+  size_t slot;
+  for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) {
+    if (data_.items[slot].connected &&
+        associated_[slot].is_xbox &&
+        associated_[slot].xbox.device == device)
+      break;
+  }
+  DCHECK(slot < WebGamepads::itemsLengthCap);
+  // Leave associated device_ref so that it will be reconnected in the same
+  // location. Simply mark it as disconnected.
+  // TODO(jeremya): use location id to match replugged controllers.
+  data_.items[slot].connected = false;
+}
+
+void GamepadPlatformDataFetcherMac::XboxValueChanged(
+    XboxController* device, const XboxController::Data& data) {
+  // XXX should have xbox_enabled_ too.

[Mark Mentovai, 2013/04/24 16:57:20]

And this?

[jeremya, 2013/04/26 03:47:40]

enabled_ only gates the HID stuff -- that can fail orthogonally to the Xbox
stuff. I've updated the code so that xbox_fetcher_ can be null if it fails to
register, and enabled_ doesn't gate the Xbox stuff.

+  if (!enabled_)
+    return;
+
+  // Find device slot.
+  size_t slot;
+  for (slot = 0; slot < data_.length; ++slot) {
+    if (data_.items[slot].connected &&
+        associated_[slot].is_xbox &&
+        associated_[slot].xbox.device == device)
+      break;
+  }
+  if (slot == data_.length)
+    return;
+
+  WebGamepad& pad = data_.items[slot];
+
+  // Find and fill in the associated button event, if any.
+  for (size_t i = 0; i < arraysize(data.buttons); i++) {
+    pad.buttons[i] = data.buttons[i];
+  }
+  for (size_t i = 0; i < arraysize(data.axes); i++) {
+    pad.axes[i] = data.axes[i];
+  }
+  pad.timestamp = base::TimeTicks::Now().ToInternalValue();
+}
+
+void GamepadPlatformDataFetcherMac::GetGamepadData(WebGamepads* pads, bool) {
   if (!enabled_) {
     pads->length = 0;
     return;
   }
 
   // Copy to the current state to the output buffer, using the mapping
   // function, if there is one available.
-  pads->length = WebKit::WebGamepads::itemsLengthCap;
-  for (size_t i = 0; i < WebKit::WebGamepads::itemsLengthCap; ++i) {
-    if (associated_[i].mapper)
-      associated_[i].mapper(data_.items[i], &pads->items[i]);
+  pads->length = WebGamepads::itemsLengthCap;
+  for (size_t i = 0; i < WebGamepads::itemsLengthCap; ++i) {
+    if (!associated_[i].is_xbox && associated_[i].hid.mapper)
+      associated_[i].hid.mapper(data_.items[i], &pads->items[i]);
     else
       pads->items[i] = data_.items[i];
   }
 }
 
 }  // namespace content