device/hid/hid_service_mac.cc

   1 // Copyright 2014 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 "device/hid/hid_service_mac.h"
   6
   7 #include <CoreFoundation/CoreFoundation.h>
   8 #include <IOKit/hid/IOHIDDevice.h>
   9
  10 #include <set>
  11 #include <string>
  12 #include <vector>
  13
  14 #include "base/bind.h"
  15 #include "base/location.h"
  16 #include "base/logging.h"
  17 #include "base/mac/foundation_util.h"
  18 #include "base/single_thread_task_runner.h"
  19 #include "base/stl_util.h"
  20 #include "base/strings/stringprintf.h"
  21 #include "base/strings/sys_string_conversions.h"
  22 #include "base/thread_task_runner_handle.h"
  23 #include "base/threading/thread_restrictions.h"
  24 #include "components/device_event_log/device_event_log.h"
  25 #include "device/hid/hid_connection_mac.h"
  26
  27 namespace device {
  28
  29 namespace {
  30
  31 std::string HexErrorCode(IOReturn error_code) {
  32   return base::StringPrintf("0x%04x", error_code);
  33 }
  34
  35 bool TryGetHidIntProperty(IOHIDDeviceRef device,
  36                           CFStringRef key,
  37                           int32_t* result) {
  38   CFNumberRef ref =
  39       base::mac::CFCast<CFNumberRef>(IOHIDDeviceGetProperty(device, key));
  40   return ref && CFNumberGetValue(ref, kCFNumberSInt32Type, result);
  41 }
  42
  43 int32_t GetHidIntProperty(IOHIDDeviceRef device, CFStringRef key) {
  44   int32_t value;
  45   if (TryGetHidIntProperty(device, key, &value))
  46     return value;
  47   return 0;
  48 }
  49
  50 bool TryGetHidStringProperty(IOHIDDeviceRef device,
  51                              CFStringRef key,
  52                              std::string* result) {
  53   CFStringRef ref =
  54       base::mac::CFCast<CFStringRef>(IOHIDDeviceGetProperty(device, key));
  55   if (!ref) {
  56     return false;
  57   }
  58   *result = base::SysCFStringRefToUTF8(ref);
  59   return true;
  60 }
  61
  62 std::string GetHidStringProperty(IOHIDDeviceRef device, CFStringRef key) {
  63   std::string value;
  64   TryGetHidStringProperty(device, key, &value);
  65   return value;
  66 }
  67
  68 bool TryGetHidDataProperty(IOHIDDeviceRef device,
  69                            CFStringRef key,
  70                            std::vector<uint8>* result) {
  71   CFDataRef ref =
  72       base::mac::CFCast<CFDataRef>(IOHIDDeviceGetProperty(device, key));
  73   if (!ref) {
  74     return false;
  75   }
  76   STLClearObject(result);
  77   const uint8* bytes = CFDataGetBytePtr(ref);
  78   result->insert(result->begin(), bytes, bytes + CFDataGetLength(ref));
  79   return true;
  80 }
  81
  82 }  // namespace
  83
  84 HidServiceMac::HidServiceMac(
  85     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
  86     : file_task_runner_(file_task_runner) {
  87   task_runner_ = base::ThreadTaskRunnerHandle::Get();
  88   DCHECK(task_runner_.get());
  89
  90   notify_port_ = IONotificationPortCreate(kIOMasterPortDefault);
  91   CFRunLoopAddSource(CFRunLoopGetMain(),
  92                      IONotificationPortGetRunLoopSource(notify_port_),
  93                      kCFRunLoopDefaultMode);
  94
  95   io_iterator_t iterator;
  96   IOReturn result =
  97       IOServiceAddMatchingNotification(notify_port_,
  98                                        kIOFirstMatchNotification,
  99                                        IOServiceMatching(kIOHIDDeviceKey),
 100                                        FirstMatchCallback,
 101                                        this,
 102                                        &iterator);
 103   if (result != kIOReturnSuccess) {
 104     HID_LOG(ERROR) << "Failed to listen for device arrival: "
 105                    << HexErrorCode(result);
 106     return;
 107   }
 108
 109   // Drain the iterator to arm the notification.
 110   devices_added_iterator_.reset(iterator);
 111   AddDevices();
 112   iterator = IO_OBJECT_NULL;
 113
 114   result = IOServiceAddMatchingNotification(notify_port_,
 115                                             kIOTerminatedNotification,
 116                                             IOServiceMatching(kIOHIDDeviceKey),
 117                                             TerminatedCallback,
 118                                             this,
 119                                             &iterator);
 120   if (result != kIOReturnSuccess) {
 121     HID_LOG(ERROR) << "Failed to listen for device removal: "
 122                    << HexErrorCode(result);
 123     return;
 124   }
 125
 126   // Drain devices_added_iterator_ to arm the notification.
 127   devices_removed_iterator_.reset(iterator);
 128   RemoveDevices();
 129   FirstEnumerationComplete();
 130 }
 131
 132 void HidServiceMac::Connect(const HidDeviceId& device_id,
 133                             const ConnectCallback& callback) {
 134   DCHECK(thread_checker_.CalledOnValidThread());
 135
 136   const auto& map_entry = devices().find(device_id);
 137   if (map_entry == devices().end()) {
 138     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
 139     return;
 140   }
 141   scoped_refptr<HidDeviceInfo> device_info = map_entry->second;
 142
 143   base::ScopedCFTypeRef<CFDictionaryRef> matching_dict(
 144       IORegistryEntryIDMatching(device_id));
 145
 146   base::mac::ScopedIOObject<io_service_t> service(
 147       IOServiceGetMatchingService(kIOMasterPortDefault, matching_dict.get()));
 148   if (!service.get()) {
 149     HID_LOG(EVENT) << "IOService not found for ID: " << device_id;
 150     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
 151     return;
 152   }
 153
 154   base::ScopedCFTypeRef<IOHIDDeviceRef> hid_device(
 155       IOHIDDeviceCreate(kCFAllocatorDefault, service));
 156   if (!hid_device) {
 157     HID_LOG(EVENT) << "Unable to create IOHIDDevice object.";
 158     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
 159     return;
 160   }
 161
 162   IOReturn result = IOHIDDeviceOpen(hid_device, kIOHIDOptionsTypeNone);
 163   if (result != kIOReturnSuccess) {
 164     HID_LOG(EVENT) << "Failed to open device: " << HexErrorCode(result);
 165     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
 166     return;
 167   }
 168
 169   task_runner_->PostTask(
 170       FROM_HERE, base::Bind(callback, make_scoped_refptr(new HidConnectionMac(
 171                                           hid_device.release(), device_info,
 172                                           file_task_runner_))));
 173 }
 174
 175 HidServiceMac::~HidServiceMac() {
 176 }
 177
 178 // static
 179 void HidServiceMac::FirstMatchCallback(void* context, io_iterator_t iterator) {
 180   DCHECK_EQ(CFRunLoopGetMain(), CFRunLoopGetCurrent());
 181   HidServiceMac* service = static_cast<HidServiceMac*>(context);
 182   DCHECK_EQ(service->devices_added_iterator_, iterator);
 183   service->AddDevices();
 184 }
 185
 186 // static
 187 void HidServiceMac::TerminatedCallback(void* context, io_iterator_t iterator) {
 188   DCHECK_EQ(CFRunLoopGetMain(), CFRunLoopGetCurrent());
 189   HidServiceMac* service = static_cast<HidServiceMac*>(context);
 190   DCHECK_EQ(service->devices_removed_iterator_, iterator);
 191   service->RemoveDevices();
 192 }
 193
 194 void HidServiceMac::AddDevices() {
 195   DCHECK(thread_checker_.CalledOnValidThread());
 196
 197   io_service_t device;
 198   while ((device = IOIteratorNext(devices_added_iterator_)) != IO_OBJECT_NULL) {
 199     scoped_refptr<HidDeviceInfo> device_info = CreateDeviceInfo(device);
 200     if (device_info) {
 201       AddDevice(device_info);
 202       // The reference retained by IOIteratorNext is released below in
 203       // RemoveDevices when the device is removed.
 204     } else {
 205       IOObjectRelease(device);
 206     }
 207   }
 208 }
 209
 210 void HidServiceMac::RemoveDevices() {
 211   DCHECK(thread_checker_.CalledOnValidThread());
 212
 213   io_service_t device;
 214   while ((device = IOIteratorNext(devices_removed_iterator_)) !=
 215          IO_OBJECT_NULL) {
 216     uint64_t entry_id;
 217     IOReturn result = IORegistryEntryGetRegistryEntryID(device, &entry_id);
 218     if (result == kIOReturnSuccess) {
 219       RemoveDevice(entry_id);
 220     }
 221
 222     // Release reference retained by AddDevices above.
 223     IOObjectRelease(device);
 224     // Release the reference retained by IOIteratorNext.
 225     IOObjectRelease(device);
 226   }
 227 }
 228
 229 // static
 230 scoped_refptr<HidDeviceInfo> HidServiceMac::CreateDeviceInfo(
 231     io_service_t service) {
 232   uint64_t entry_id;
 233   IOReturn result = IORegistryEntryGetRegistryEntryID(service, &entry_id);
 234   if (result != kIOReturnSuccess) {
 235     HID_LOG(EVENT) << "Failed to get IORegistryEntry ID: "
 236                    << HexErrorCode(result);
 237     return nullptr;
 238   }
 239
 240   base::ScopedCFTypeRef<IOHIDDeviceRef> hid_device(
 241       IOHIDDeviceCreate(kCFAllocatorDefault, service));
 242   if (!hid_device) {
 243     HID_LOG(EVENT) << "Unable to create IOHIDDevice object for new device.";
 244     return nullptr;
 245   }
 246
 247   std::vector<uint8> report_descriptor;
 248   if (!TryGetHidDataProperty(hid_device, CFSTR(kIOHIDReportDescriptorKey),
 249                              &report_descriptor)) {
 250     HID_LOG(EVENT) << "Unable to get report descriptor for new device.";
 251     return nullptr;
 252   }
 253
 254   return new HidDeviceInfo(
 255       entry_id, GetHidIntProperty(hid_device, CFSTR(kIOHIDVendorIDKey)),
 256       GetHidIntProperty(hid_device, CFSTR(kIOHIDProductIDKey)),
 257       GetHidStringProperty(hid_device, CFSTR(kIOHIDProductKey)),
 258       GetHidStringProperty(hid_device, CFSTR(kIOHIDSerialNumberKey)),
 259       kHIDBusTypeUSB,  // TODO(reillyg): Detect Bluetooth. crbug.com/443335
 260       report_descriptor);
 261 }
 262
 263 }  // namespace device