| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "content/browser/gamepad/platform_data_fetcher_mac.h" | |
| 6 | |
| 7 #include "base/mac/foundation_util.h" | |
| 8 #include "base/memory/scoped_nsobject.h" | |
| 9 #include "base/string16.h" | |
| 10 #include "base/string_util.h" | |
| 11 #include "base/utf_string_conversions.h" | |
| 12 | |
| 13 #include <IOKit/hid/IOHIDKeys.h> | |
| 14 #import <Foundation/Foundation.h> | |
| 15 | |
| 16 namespace content { | |
| 17 | |
| 18 namespace { | |
| 19 | |
| 20 NSDictionary* DeviceMatching(uint32_t usage_page, uint32_t usage) { | |
| 21 return [NSDictionary dictionaryWithObjectsAndKeys: | |
| 22 [NSNumber numberWithUnsignedInt:usage_page], | |
| 23 base::mac::CFToNSCast(CFSTR(kIOHIDDeviceUsagePageKey)), | |
| 24 [NSNumber numberWithUnsignedInt:usage], | |
| 25 base::mac::CFToNSCast(CFSTR(kIOHIDDeviceUsageKey)), | |
| 26 nil]; | |
| 27 } | |
| 28 | |
| 29 float NormalizeAxis(CFIndex value, CFIndex min, CFIndex max) { | |
| 30 return (2.f * (value - min) / static_cast<float>(max - min)) - 1.f; | |
| 31 } | |
| 32 | |
| 33 // http://www.usb.org/developers/hidpage | |
| 34 const uint32_t kGenericDesktopUsagePage = 0x01; | |
| 35 const uint32_t kButtonUsagePage = 0x09; | |
| 36 const uint32_t kJoystickUsageNumber = 0x04; | |
| 37 const uint32_t kGameUsageNumber = 0x05; | |
| 38 const uint32_t kMultiAxisUsageNumber = 0x08; | |
| 39 const uint32_t kAxisMinimumUsageNumber = 0x30; | |
| 40 const uint32_t kAxisMaximumUsageNumber = 0x35; | |
| 41 | |
| 42 } // namespace | |
| 43 | |
| 44 GamepadPlatformDataFetcherMac::GamepadPlatformDataFetcherMac() | |
| 45 : enabled_(true) { | |
| 46 memset(associated_, 0, sizeof(associated_)); | |
| 47 hid_manager_ref_.reset(IOHIDManagerCreate(kCFAllocatorDefault, | |
| 48 kIOHIDOptionsTypeNone)); | |
| 49 if (CFGetTypeID(hid_manager_ref_) != IOHIDManagerGetTypeID()) { | |
| 50 enabled_ = false; | |
| 51 return; | |
| 52 } | |
| 53 | |
| 54 scoped_nsobject<NSArray> criteria([[NSArray alloc] initWithObjects: | |
| 55 DeviceMatching(kGenericDesktopUsagePage, kJoystickUsageNumber), | |
| 56 DeviceMatching(kGenericDesktopUsagePage, kGameUsageNumber), | |
| 57 DeviceMatching(kGenericDesktopUsagePage, kMultiAxisUsageNumber), | |
| 58 nil]); | |
| 59 IOHIDManagerSetDeviceMatchingMultiple( | |
| 60 hid_manager_ref_, | |
| 61 base::mac::NSToCFCast(criteria)); | |
| 62 | |
| 63 RegisterForNotifications(); | |
| 64 } | |
| 65 | |
| 66 void GamepadPlatformDataFetcherMac::RegisterForNotifications() { | |
| 67 // Register for plug/unplug notifications. | |
| 68 IOHIDManagerRegisterDeviceMatchingCallback( | |
| 69 hid_manager_ref_, | |
| 70 &DeviceAddCallback, | |
| 71 this); | |
| 72 IOHIDManagerRegisterDeviceRemovalCallback( | |
| 73 hid_manager_ref_, | |
| 74 DeviceRemoveCallback, | |
| 75 this); | |
| 76 | |
| 77 // Register for value change notifications. | |
| 78 IOHIDManagerRegisterInputValueCallback( | |
| 79 hid_manager_ref_, | |
| 80 ValueChangedCallback, | |
| 81 this); | |
| 82 | |
| 83 IOHIDManagerScheduleWithRunLoop( | |
| 84 hid_manager_ref_, | |
| 85 CFRunLoopGetMain(), | |
| 86 kCFRunLoopDefaultMode); | |
| 87 | |
| 88 enabled_ = IOHIDManagerOpen(hid_manager_ref_, | |
| 89 kIOHIDOptionsTypeNone) == kIOReturnSuccess; | |
| 90 } | |
| 91 | |
| 92 void GamepadPlatformDataFetcherMac::UnregisterFromNotifications() { | |
| 93 IOHIDManagerUnscheduleFromRunLoop( | |
| 94 hid_manager_ref_, | |
| 95 CFRunLoopGetCurrent(), | |
| 96 kCFRunLoopDefaultMode); | |
| 97 IOHIDManagerClose(hid_manager_ref_, kIOHIDOptionsTypeNone); | |
| 98 } | |
| 99 | |
| 100 void GamepadPlatformDataFetcherMac::PauseHint(bool pause) { | |
| 101 if (pause) | |
| 102 UnregisterFromNotifications(); | |
| 103 else | |
| 104 RegisterForNotifications(); | |
| 105 } | |
| 106 | |
| 107 GamepadPlatformDataFetcherMac::~GamepadPlatformDataFetcherMac() { | |
| 108 UnregisterFromNotifications(); | |
| 109 } | |
| 110 | |
| 111 GamepadPlatformDataFetcherMac* | |
| 112 GamepadPlatformDataFetcherMac::InstanceFromContext( | |
| 113 void* context) { | |
| 114 return reinterpret_cast<GamepadPlatformDataFetcherMac*>(context); | |
| 115 } | |
| 116 | |
| 117 void GamepadPlatformDataFetcherMac::DeviceAddCallback(void* context, | |
| 118 IOReturn result, | |
| 119 void* sender, | |
| 120 IOHIDDeviceRef ref) { | |
| 121 InstanceFromContext(context)->DeviceAdd(ref); | |
| 122 } | |
| 123 | |
| 124 void GamepadPlatformDataFetcherMac::DeviceRemoveCallback(void* context, | |
| 125 IOReturn result, | |
| 126 void* sender, | |
| 127 IOHIDDeviceRef ref) { | |
| 128 InstanceFromContext(context)->DeviceRemove(ref); | |
| 129 } | |
| 130 | |
| 131 void GamepadPlatformDataFetcherMac::ValueChangedCallback(void* context, | |
| 132 IOReturn result, | |
| 133 void* sender, | |
| 134 IOHIDValueRef ref) { | |
| 135 InstanceFromContext(context)->ValueChanged(ref); | |
| 136 } | |
| 137 | |
| 138 void GamepadPlatformDataFetcherMac::AddButtonsAndAxes(NSArray* elements, | |
| 139 size_t slot) { | |
| 140 WebKit::WebGamepad& pad = data_.items[slot]; | |
| 141 AssociatedData& associated = associated_[slot]; | |
| 142 | |
| 143 pad.axesLength = 0; | |
| 144 pad.buttonsLength = 0; | |
| 145 pad.timestamp = 0; | |
| 146 memset(pad.axes, 0, sizeof(pad.axes)); | |
| 147 memset(pad.buttons, 0, sizeof(pad.buttons)); | |
| 148 | |
| 149 for (id elem in elements) { | |
| 150 IOHIDElementRef element = reinterpret_cast<IOHIDElementRef>(elem); | |
| 151 uint32_t usagePage = IOHIDElementGetUsagePage(element); | |
| 152 uint32_t usage = IOHIDElementGetUsage(element); | |
| 153 if (IOHIDElementGetType(element) == kIOHIDElementTypeInput_Button && | |
| 154 usagePage == kButtonUsagePage) { | |
| 155 uint32_t button_index = usage - 1; | |
| 156 if (button_index < WebKit::WebGamepad::buttonsLengthCap) { | |
| 157 associated.button_elements[button_index] = element; | |
| 158 pad.buttonsLength = std::max(pad.buttonsLength, button_index + 1); | |
| 159 } | |
| 160 } | |
| 161 else if (IOHIDElementGetType(element) == kIOHIDElementTypeInput_Misc) { | |
| 162 uint32_t axis_index = usage - kAxisMinimumUsageNumber; | |
| 163 if (axis_index < WebKit::WebGamepad::axesLengthCap) { | |
| 164 associated.axis_minimums[axis_index] = | |
| 165 IOHIDElementGetLogicalMin(element); | |
| 166 associated.axis_maximums[axis_index] = | |
| 167 IOHIDElementGetLogicalMax(element); | |
| 168 associated.axis_elements[axis_index] = element; | |
| 169 pad.axesLength = std::max(pad.axesLength, axis_index + 1); | |
| 170 } | |
| 171 } | |
| 172 } | |
| 173 } | |
| 174 | |
| 175 void GamepadPlatformDataFetcherMac::DeviceAdd(IOHIDDeviceRef device) { | |
| 176 using WebKit::WebGamepad; | |
| 177 using WebKit::WebGamepads; | |
| 178 using base::mac::CFToNSCast; | |
| 179 using base::mac::CFCastStrict; | |
| 180 size_t slot; | |
| 181 | |
| 182 if (!enabled_) | |
| 183 return; | |
| 184 | |
| 185 // Find an index for this device. | |
| 186 for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) { | |
| 187 // If we already have this device, and it's already connected, don't do | |
| 188 // anything now. | |
| 189 if (associated_[slot].device_ref == device && data_.items[slot].connected) | |
| 190 return; | |
| 191 if (!data_.items[slot].connected) | |
| 192 break; | |
| 193 } | |
| 194 | |
| 195 // We can't handle this many connected devices. | |
| 196 if (slot == WebGamepads::itemsLengthCap) | |
| 197 return; | |
| 198 | |
| 199 NSNumber* vendor_id = CFToNSCast(CFCastStrict<CFNumberRef>( | |
| 200 IOHIDDeviceGetProperty(device, CFSTR(kIOHIDVendorIDKey)))); | |
| 201 NSNumber* product_id = CFToNSCast(CFCastStrict<CFNumberRef>( | |
| 202 IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductIDKey)))); | |
| 203 NSString* product = CFToNSCast(CFCastStrict<CFStringRef>( | |
| 204 IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductKey)))); | |
| 205 int vendor_int = [vendor_id intValue]; | |
| 206 int product_int = [product_id intValue]; | |
| 207 | |
| 208 char vendor_as_str[5], product_as_str[5]; | |
| 209 snprintf(vendor_as_str, sizeof(vendor_as_str), "%04x", vendor_int); | |
| 210 snprintf(product_as_str, sizeof(product_as_str), "%04x", product_int); | |
| 211 associated_[slot].mapper = | |
| 212 GetGamepadStandardMappingFunction(vendor_as_str, product_as_str); | |
| 213 | |
| 214 NSString* ident = [NSString stringWithFormat: | |
| 215 @"%@ (%sVendor: %04x Product: %04x)", | |
| 216 product, | |
| 217 associated_[slot].mapper ? "STANDARD GAMEPAD " : "", | |
| 218 vendor_int, | |
| 219 product_int]; | |
| 220 NSData* as16 = [ident dataUsingEncoding:NSUTF16StringEncoding]; | |
| 221 | |
| 222 const size_t kOutputLengthBytes = sizeof(data_.items[slot].id); | |
| 223 memset(&data_.items[slot].id, 0, kOutputLengthBytes); | |
| 224 [as16 getBytes:data_.items[slot].id | |
| 225 length:kOutputLengthBytes - sizeof(WebKit::WebUChar)]; | |
| 226 | |
| 227 base::mac::ScopedCFTypeRef<CFArrayRef> elements( | |
| 228 IOHIDDeviceCopyMatchingElements(device, NULL, kIOHIDOptionsTypeNone)); | |
| 229 AddButtonsAndAxes(CFToNSCast(elements), slot); | |
| 230 | |
| 231 associated_[slot].device_ref = device; | |
| 232 data_.items[slot].connected = true; | |
| 233 if (slot >= data_.length) | |
| 234 data_.length = slot + 1; | |
| 235 } | |
| 236 | |
| 237 void GamepadPlatformDataFetcherMac::DeviceRemove(IOHIDDeviceRef device) { | |
| 238 using WebKit::WebGamepads; | |
| 239 size_t slot; | |
| 240 if (!enabled_) | |
| 241 return; | |
| 242 | |
| 243 // Find the index for this device. | |
| 244 for (slot = 0; slot < WebGamepads::itemsLengthCap; ++slot) { | |
| 245 if (associated_[slot].device_ref == device && data_.items[slot].connected) | |
| 246 break; | |
| 247 } | |
| 248 DCHECK(slot < WebGamepads::itemsLengthCap); | |
| 249 // Leave associated device_ref so that it will be reconnected in the same | |
| 250 // location. Simply mark it as disconnected. | |
| 251 data_.items[slot].connected = false; | |
| 252 } | |
| 253 | |
| 254 void GamepadPlatformDataFetcherMac::ValueChanged(IOHIDValueRef value) { | |
| 255 if (!enabled_) | |
| 256 return; | |
| 257 | |
| 258 IOHIDElementRef element = IOHIDValueGetElement(value); | |
| 259 IOHIDDeviceRef device = IOHIDElementGetDevice(element); | |
| 260 | |
| 261 // Find device slot. | |
| 262 size_t slot; | |
| 263 for (slot = 0; slot < data_.length; ++slot) { | |
| 264 if (data_.items[slot].connected && associated_[slot].device_ref == device) | |
| 265 break; | |
| 266 } | |
| 267 if (slot == data_.length) | |
| 268 return; | |
| 269 | |
| 270 WebKit::WebGamepad& pad = data_.items[slot]; | |
| 271 AssociatedData& associated = associated_[slot]; | |
| 272 | |
| 273 // Find and fill in the associated button event, if any. | |
| 274 for (size_t i = 0; i < pad.buttonsLength; ++i) { | |
| 275 if (associated.button_elements[i] == element) { | |
| 276 pad.buttons[i] = IOHIDValueGetIntegerValue(value) ? 1.f : 0.f; | |
| 277 pad.timestamp = std::max(pad.timestamp, IOHIDValueGetTimeStamp(value)); | |
| 278 return; | |
| 279 } | |
| 280 } | |
| 281 | |
| 282 // Find and fill in the associated axis event, if any. | |
| 283 for (size_t i = 0; i < pad.axesLength; ++i) { | |
| 284 if (associated.axis_elements[i] == element) { | |
| 285 pad.axes[i] = NormalizeAxis(IOHIDValueGetIntegerValue(value), | |
| 286 associated.axis_minimums[i], | |
| 287 associated.axis_maximums[i]); | |
| 288 pad.timestamp = std::max(pad.timestamp, IOHIDValueGetTimeStamp(value)); | |
| 289 return; | |
| 290 } | |
| 291 } | |
| 292 } | |
| 293 | |
| 294 void GamepadPlatformDataFetcherMac::GetGamepadData( | |
| 295 WebKit::WebGamepads* pads, | |
| 296 bool) { | |
| 297 if (!enabled_) { | |
| 298 pads->length = 0; | |
| 299 return; | |
| 300 } | |
| 301 | |
| 302 // Copy to the current state to the output buffer, using the mapping | |
| 303 // function, if there is one available. | |
| 304 pads->length = data_.length; | |
| 305 for (size_t i = 0; i < WebKit::WebGamepads::itemsLengthCap; ++i) { | |
| 306 if (associated_[i].mapper) | |
| 307 associated_[i].mapper(data_.items[i], &pads->items[i]); | |
| 308 else | |
| 309 pads->items[i] = data_.items[i]; | |
| 310 } | |
| 311 } | |
| 312 | |
| 313 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10912062:
Implement the gamepad API in the IPC proxy (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src