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   if (!matching_dict.get()) {
 146     HID_LOG(EVENT) << "Failed to create matching dictionary for ID: "
 147                    << device_id;
 148     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
 149     return;
 150   }
 151
 152   // IOServiceGetMatchingService consumes a reference to the matching dictionary
 153   // passed to it.
 154   base::mac::ScopedIOObject<io_service_t> service(IOServiceGetMatchingService(
 155       kIOMasterPortDefault, matching_dict.release()));
 156   if (!service.get()) {
 157     HID_LOG(EVENT) << "IOService not found for ID: " << device_id;
 158     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
 159     return;
 160   }
 161
 162   base::ScopedCFTypeRef<IOHIDDeviceRef> hid_device(
 163       IOHIDDeviceCreate(kCFAllocatorDefault, service));
 164   if (!hid_device) {
 165     HID_LOG(EVENT) << "Unable to create IOHIDDevice object.";
 166     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
 167     return;
 168   }
 169
 170   IOReturn result = IOHIDDeviceOpen(hid_device, kIOHIDOptionsTypeNone);
 171   if (result != kIOReturnSuccess) {
 172     HID_LOG(EVENT) << "Failed to open device: " << HexErrorCode(result);
 173     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
 174     return;
 175   }
 176
 177   task_runner_->PostTask(
 178       FROM_HERE, base::Bind(callback, make_scoped_refptr(new HidConnectionMac(
 179                                           hid_device.release(), device_info,
 180                                           file_task_runner_))));
 181 }
 182
 183 HidServiceMac::~HidServiceMac() {
 184 }
 185
 186 // static
 187 void HidServiceMac::FirstMatchCallback(void* context, io_iterator_t iterator) {
 188   DCHECK_EQ(CFRunLoopGetMain(), CFRunLoopGetCurrent());
 189   HidServiceMac* service = static_cast<HidServiceMac*>(context);
 190   DCHECK_EQ(service->devices_added_iterator_, iterator);
 191   service->AddDevices();
 192 }
 193
 194 // static
 195 void HidServiceMac::TerminatedCallback(void* context, io_iterator_t iterator) {
 196   DCHECK_EQ(CFRunLoopGetMain(), CFRunLoopGetCurrent());
 197   HidServiceMac* service = static_cast<HidServiceMac*>(context);
 198   DCHECK_EQ(service->devices_removed_iterator_, iterator);
 199   service->RemoveDevices();
 200 }
 201
 202 void HidServiceMac::AddDevices() {
 203   DCHECK(thread_checker_.CalledOnValidThread());
 204
 205   io_service_t device;
 206   while ((device = IOIteratorNext(devices_added_iterator_)) != IO_OBJECT_NULL) {
 207     scoped_refptr<HidDeviceInfo> device_info = CreateDeviceInfo(device);
 208     if (device_info) {
 209       AddDevice(device_info);
 210       // The reference retained by IOIteratorNext is released below in
 211       // RemoveDevices when the device is removed.
 212     } else {
 213       IOObjectRelease(device);
 214     }
 215   }
 216 }
 217
 218 void HidServiceMac::RemoveDevices() {
 219   DCHECK(thread_checker_.CalledOnValidThread());
 220
 221   io_service_t device;
 222   while ((device = IOIteratorNext(devices_removed_iterator_)) !=
 223          IO_OBJECT_NULL) {
 224     uint64_t entry_id;
 225     IOReturn result = IORegistryEntryGetRegistryEntryID(device, &entry_id);
 226     if (result == kIOReturnSuccess) {
 227       RemoveDevice(entry_id);
 228     }
 229
 230     // Release reference retained by AddDevices above.
 231     IOObjectRelease(device);
 232     // Release the reference retained by IOIteratorNext.
 233     IOObjectRelease(device);
 234   }
 235 }
 236
 237 // static
 238 scoped_refptr<HidDeviceInfo> HidServiceMac::CreateDeviceInfo(
 239     io_service_t service) {
 240   uint64_t entry_id;
 241   IOReturn result = IORegistryEntryGetRegistryEntryID(service, &entry_id);
 242   if (result != kIOReturnSuccess) {
 243     HID_LOG(EVENT) << "Failed to get IORegistryEntry ID: "
 244                    << HexErrorCode(result);
 245     return nullptr;
 246   }
 247
 248   base::ScopedCFTypeRef<IOHIDDeviceRef> hid_device(
 249       IOHIDDeviceCreate(kCFAllocatorDefault, service));
 250   if (!hid_device) {
 251     HID_LOG(EVENT) << "Unable to create IOHIDDevice object for new device.";
 252     return nullptr;
 253   }
 254
 255   std::vector<uint8> report_descriptor;
 256   if (!TryGetHidDataProperty(hid_device, CFSTR(kIOHIDReportDescriptorKey),
 257                              &report_descriptor)) {
 258     HID_LOG(EVENT) << "Unable to get report descriptor for new device.";
 259     return nullptr;
 260   }
 261
 262   return new HidDeviceInfo(
 263       entry_id, GetHidIntProperty(hid_device, CFSTR(kIOHIDVendorIDKey)),
 264       GetHidIntProperty(hid_device, CFSTR(kIOHIDProductIDKey)),
 265       GetHidStringProperty(hid_device, CFSTR(kIOHIDProductKey)),
 266       GetHidStringProperty(hid_device, CFSTR(kIOHIDSerialNumberKey)),
 267       kHIDBusTypeUSB,  // TODO(reillyg): Detect Bluetooth. crbug.com/443335
 268       report_descriptor);
 269 }
 270
 271 }  // namespace device