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