Home | History | Annotate | Download | only in usb 
      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/usb/usb_service.h"
      6 
      7 #include <map>
      8 #include <set>
      9 
     10 #include "base/lazy_instance.h"
     11 #include "base/message_loop/message_loop.h"
     12 #include "base/single_thread_task_runner.h"
     13 #include "base/stl_util.h"
     14 #include "device/usb/usb_context.h"
     15 #include "device/usb/usb_device_impl.h"
     16 #include "device/usb/usb_error.h"
     17 #include "third_party/libusb/src/libusb/libusb.h"
     18 
     19 namespace device {
     20 
     21 namespace {
     22 
     23 base::LazyInstance<scoped_ptr<UsbService> >::Leaky g_usb_service_instance =
     24     LAZY_INSTANCE_INITIALIZER;
     25 
     26 }  // namespace
     27 
     28 typedef struct libusb_device* PlatformUsbDevice;
     29 typedef struct libusb_context* PlatformUsbContext;
     30 
     31 class UsbServiceImpl : public UsbService,
     32                        private base::MessageLoop::DestructionObserver {
     33  public:
     34   explicit UsbServiceImpl(
     35       PlatformUsbContext context,
     36       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
     37   virtual ~UsbServiceImpl();
     38 
     39  private:
     40   // device::UsbService implementation
     41   virtual scoped_refptr<UsbDevice> GetDeviceById(uint32 unique_id) OVERRIDE;
     42   virtual void GetDevices(
     43       std::vector<scoped_refptr<UsbDevice> >* devices) OVERRIDE;
     44 
     45   // base::MessageLoop::DestructionObserver implementation.
     46   virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
     47 
     48   // Enumerate USB devices from OS and update devices_ map.
     49   void RefreshDevices();
     50 
     51   scoped_refptr<UsbContext> context_;
     52   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
     53   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
     54 
     55   // TODO(reillyg): Figure out a better solution.
     56   uint32 next_unique_id_;
     57 
     58   // The map from unique IDs to UsbDevices.
     59   typedef std::map<uint32, scoped_refptr<UsbDeviceImpl> > DeviceMap;
     60   DeviceMap devices_;
     61 
     62   // The map from PlatformUsbDevices to UsbDevices.
     63   typedef std::map<PlatformUsbDevice, scoped_refptr<UsbDeviceImpl> >
     64       PlatformDeviceMap;
     65   PlatformDeviceMap platform_devices_;
     66 
     67   DISALLOW_COPY_AND_ASSIGN(UsbServiceImpl);
     68 };
     69 
     70 scoped_refptr<UsbDevice> UsbServiceImpl::GetDeviceById(uint32 unique_id) {
     71   DCHECK(CalledOnValidThread());
     72   RefreshDevices();
     73   DeviceMap::iterator it = devices_.find(unique_id);
     74   if (it != devices_.end()) {
     75     return it->second;
     76   }
     77   return NULL;
     78 }
     79 
     80 void UsbServiceImpl::GetDevices(
     81     std::vector<scoped_refptr<UsbDevice> >* devices) {
     82   DCHECK(CalledOnValidThread());
     83   STLClearObject(devices);
     84   RefreshDevices();
     85 
     86   for (DeviceMap::iterator it = devices_.begin(); it != devices_.end(); ++it) {
     87     devices->push_back(it->second);
     88   }
     89 }
     90 
     91 void UsbServiceImpl::WillDestroyCurrentMessageLoop() {
     92   DCHECK(CalledOnValidThread());
     93   g_usb_service_instance.Get().reset(NULL);
     94 }
     95 
     96 UsbServiceImpl::UsbServiceImpl(
     97     PlatformUsbContext context,
     98     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)
     99     : context_(new UsbContext(context)),
    100       ui_task_runner_(ui_task_runner),
    101       next_unique_id_(0) {
    102   base::MessageLoop::current()->AddDestructionObserver(this);
    103 }
    104 
    105 UsbServiceImpl::~UsbServiceImpl() {
    106   base::MessageLoop::current()->RemoveDestructionObserver(this);
    107   for (DeviceMap::iterator it = devices_.begin(); it != devices_.end(); ++it) {
    108     it->second->OnDisconnect();
    109   }
    110 }
    111 
    112 void UsbServiceImpl::RefreshDevices() {
    113   DCHECK(CalledOnValidThread());
    114 
    115   libusb_device** platform_devices = NULL;
    116   const ssize_t device_count =
    117       libusb_get_device_list(context_->context(), &platform_devices);
    118   if (device_count < 0) {
    119     VLOG(1) << "Failed to get device list: "
    120             << ConvertPlatformUsbErrorToString(device_count);
    121   }
    122 
    123   std::set<UsbDevice*> connected_devices;
    124   std::vector<PlatformUsbDevice> disconnected_devices;
    125 
    126   // Populates new devices.
    127   for (ssize_t i = 0; i < device_count; ++i) {
    128     if (!ContainsKey(platform_devices_, platform_devices[i])) {
    129       libusb_device_descriptor descriptor;
    130       const int rv =
    131           libusb_get_device_descriptor(platform_devices[i], &descriptor);
    132       // This test is needed. A valid vendor/produce pair is required.
    133       if (rv != LIBUSB_SUCCESS) {
    134         VLOG(1) << "Failed to get device descriptor: "
    135                 << ConvertPlatformUsbErrorToString(rv);
    136         continue;
    137       }
    138 
    139       uint32 unique_id;
    140       do {
    141         unique_id = ++next_unique_id_;
    142       } while (devices_.find(unique_id) != devices_.end());
    143 
    144       scoped_refptr<UsbDeviceImpl> new_device(
    145           new UsbDeviceImpl(context_,
    146                             ui_task_runner_,
    147                             platform_devices[i],
    148                             descriptor.idVendor,
    149                             descriptor.idProduct,
    150                             unique_id));
    151       platform_devices_[platform_devices[i]] = new_device;
    152       devices_[unique_id] = new_device;
    153       connected_devices.insert(new_device.get());
    154     } else {
    155       connected_devices.insert(platform_devices_[platform_devices[i]].get());
    156     }
    157   }
    158 
    159   // Find disconnected devices.
    160   for (PlatformDeviceMap::iterator it = platform_devices_.begin();
    161        it != platform_devices_.end();
    162        ++it) {
    163     if (!ContainsKey(connected_devices, it->second.get())) {
    164       disconnected_devices.push_back(it->first);
    165       devices_.erase(it->second->unique_id());
    166       it->second->OnDisconnect();
    167     }
    168   }
    169 
    170   // Remove disconnected devices from platform_devices_.
    171   for (size_t i = 0; i < disconnected_devices.size(); ++i) {
    172     // UsbDevice will be destroyed after this. The corresponding
    173     // PlatformUsbDevice will be unref'ed during this process.
    174     platform_devices_.erase(disconnected_devices[i]);
    175   }
    176 
    177   libusb_free_device_list(platform_devices, true);
    178 }
    179 
    180 // static
    181 UsbService* UsbService::GetInstance(
    182     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
    183   UsbService* instance = g_usb_service_instance.Get().get();
    184   if (!instance) {
    185     PlatformUsbContext context = NULL;
    186 
    187     const int rv = libusb_init(&context);
    188     if (rv != LIBUSB_SUCCESS) {
    189       VLOG(1) << "Failed to initialize libusb: "
    190               << ConvertPlatformUsbErrorToString(rv);
    191       return NULL;
    192     }
    193     if (!context)
    194       return NULL;
    195 
    196     instance = new UsbServiceImpl(context, ui_task_runner);
    197     g_usb_service_instance.Get().reset(instance);
    198   }
    199   return instance;
    200 }
    201 
    202 // static
    203 void UsbService::SetInstanceForTest(UsbService* instance) {
    204   g_usb_service_instance.Get().reset(instance);
    205 }
    206 
    207 }  // namespace device
    208