device/hid/hid_service.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.h"
   6
   7 #include "base/at_exit.h"
   8 #include "base/bind.h"
   9 #include "base/logging.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/stl_util.h"
  12 #include "components/device_event_log/device_event_log.h"
  13
  14 #if defined(OS_LINUX) && defined(USE_UDEV)
  15 #include "device/hid/hid_service_linux.h"
  16 #elif defined(OS_MACOSX)
  17 #include "device/hid/hid_service_mac.h"
  18 #elif defined(OS_WIN)
  19 #include "device/hid/hid_service_win.h"
  20 #endif
  21
  22 namespace device {
  23
  24 void HidService::Observer::OnDeviceAdded(
  25     scoped_refptr<HidDeviceInfo> device_info) {
  26 }
  27
  28 void HidService::Observer::OnDeviceRemoved(
  29     scoped_refptr<HidDeviceInfo> device_info) {
  30 }
  31
  32 void HidService::Observer::OnDeviceRemovedCleanup(
  33     scoped_refptr<HidDeviceInfo> device_info) {
  34 }
  35
  36 scoped_ptr<HidService> HidService::Create(
  37     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner) {
  38 #if defined(OS_LINUX) && defined(USE_UDEV)
  39   return make_scoped_ptr(new HidServiceLinux(file_task_runner));
  40 #elif defined(OS_MACOSX)
  41   return make_scoped_ptr(new HidServiceMac(file_task_runner));
  42 #elif defined(OS_WIN)
  43   return make_scoped_ptr(new HidServiceWin(file_task_runner));
  44 #else
  45   return nullptr;
  46 #endif
  47 }
  48
  49 void HidService::GetDevices(const GetDevicesCallback& callback) {
  50   DCHECK(thread_checker_.CalledOnValidThread());
  51   if (enumeration_ready_) {
  52     std::vector<scoped_refptr<HidDeviceInfo>> devices;
  53     for (const auto& map_entry : devices_) {
  54       devices.push_back(map_entry.second);
  55     }
  56     base::MessageLoop::current()->PostTask(FROM_HERE,
  57                                            base::Bind(callback, devices));
  58   } else {
  59     pending_enumerations_.push_back(callback);
  60   }
  61 }
  62
  63 void HidService::AddObserver(HidService::Observer* observer) {
  64   observer_list_.AddObserver(observer);
  65 }
  66
  67 void HidService::RemoveObserver(HidService::Observer* observer) {
  68   observer_list_.RemoveObserver(observer);
  69 }
  70
  71 // Fills in the device info struct of the given device_id.
  72 scoped_refptr<HidDeviceInfo> HidService::GetDeviceInfo(
  73     const HidDeviceId& device_id) const {
  74   DCHECK(thread_checker_.CalledOnValidThread());
  75   DeviceMap::const_iterator it = devices_.find(device_id);
  76   if (it == devices_.end()) {
  77     return nullptr;
  78   }
  79   return it->second;
  80 }
  81
  82 HidService::HidService() : enumeration_ready_(false) {
  83 }
  84
  85 HidService::~HidService() {
  86   DCHECK(thread_checker_.CalledOnValidThread());
  87 }
  88
  89 void HidService::AddDevice(scoped_refptr<HidDeviceInfo> device_info) {
  90   DCHECK(thread_checker_.CalledOnValidThread());
  91   if (!ContainsKey(devices_, device_info->device_id())) {
  92     devices_[device_info->device_id()] = device_info;
  93
  94     HID_LOG(USER) << "HID device "
  95                   << (enumeration_ready_ ? "added" : "detected")
  96                   << ": vendorId=" << device_info->vendor_id()
  97                   << ", productId=" << device_info->product_id() << ", name='"
  98                   << device_info->product_name() << "', serial='"
  99                   << device_info->serial_number() << "', deviceId='"
 100                   << device_info->device_id() << "'";
 101
 102     if (enumeration_ready_) {
 103       FOR_EACH_OBSERVER(Observer, observer_list_, OnDeviceAdded(device_info));
 104     }
 105   }
 106 }
 107
 108 void HidService::RemoveDevice(const HidDeviceId& device_id) {
 109   DCHECK(thread_checker_.CalledOnValidThread());
 110   DeviceMap::iterator it = devices_.find(device_id);
 111   if (it != devices_.end()) {
 112     HID_LOG(USER) << "HID device removed: deviceId='" << device_id << "'";
 113
 114     scoped_refptr<HidDeviceInfo> device = it->second;
 115     if (enumeration_ready_) {
 116       FOR_EACH_OBSERVER(Observer, observer_list_, OnDeviceRemoved(device));
 117     }
 118     devices_.erase(it);
 119     if (enumeration_ready_) {
 120       FOR_EACH_OBSERVER(Observer, observer_list_,
 121                         OnDeviceRemovedCleanup(device));
 122     }
 123   }
 124 }
 125
 126 void HidService::FirstEnumerationComplete() {
 127   enumeration_ready_ = true;
 128
 129   if (!pending_enumerations_.empty()) {
 130     std::vector<scoped_refptr<HidDeviceInfo>> devices;
 131     for (const auto& map_entry : devices_) {
 132       devices.push_back(map_entry.second);
 133     }
 134
 135     for (const GetDevicesCallback& callback : pending_enumerations_) {
 136       callback.Run(devices);
 137     }
 138     pending_enumerations_.clear();
 139   }
 140 }
 141
 142 }  // namespace device