device/hid/hid_service.h

   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 #ifndef DEVICE_HID_HID_SERVICE_H_
   6 #define DEVICE_HID_HID_SERVICE_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/bind_helpers.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/observer_list.h"
  15 #include "base/single_thread_task_runner.h"
  16 #include "base/threading/thread_checker.h"
  17 #include "device/hid/hid_device_info.h"
  18
  19 namespace device {
  20
  21 class HidConnection;
  22
  23 // The HidService keeps track of human interface devices connected to the
  24 // system. Call HidService::GetInstance to get the singleton instance.
  25 class HidService {
  26  public:
  27   class Observer {
  28    public:
  29     virtual void OnDeviceAdded(scoped_refptr<HidDeviceInfo> info);
  30     // Notifies all observers that a device is being removed, called before
  31     // removing the device from HidService. Observers should not depend on the
  32     // order in which they are notified of the OnDeviceRemove event.
  33     virtual void OnDeviceRemoved(scoped_refptr<HidDeviceInfo> info);
  34     // Notifies all observers again, after having first notified all observers
  35     // with OnDeviceRemoved and removed the device from internal structures.
  36     // Each observer must not depend on any other observers' awareness of the
  37     // device as they could be cleaned up in any order.
  38     virtual void OnDeviceRemovedCleanup(scoped_refptr<HidDeviceInfo> info);
  39   };
  40
  41   typedef base::Callback<void(const std::vector<scoped_refptr<HidDeviceInfo>>&)>
  42       GetDevicesCallback;
  43   typedef base::Callback<void(scoped_refptr<HidConnection> connection)>
  44       ConnectCallback;
  45
  46   // Gets a pointer to the HidService singleton. This function should be called
  47   // on a thread with a MessageLoopForUI and be passed the task runner for a
  48   // thread with a MessageLoopForIO.
  49   static HidService* GetInstance(
  50       scoped_refptr<base::SingleThreadTaskRunner> file_task_runner);
  51
  52   static void SetInstanceForTest(HidService* instance);
  53
  54   // Enumerates available devices. The provided callback will always be posted
  55   // to the calling thread's task runner.
  56   virtual void GetDevices(const GetDevicesCallback& callback);
  57
  58   void AddObserver(Observer* observer);
  59   void RemoveObserver(Observer* observer);
  60
  61   // Fills in a DeviceInfo struct with info for the given device_id.
  62   // Returns |nullptr| if |device_id| is invalid.
  63   scoped_refptr<HidDeviceInfo> GetDeviceInfo(
  64       const HidDeviceId& device_id) const;
  65
  66   // Opens a connection to a device. The callback will be run with null on
  67   // failure.
  68   virtual void Connect(const HidDeviceId& device_id,
  69                        const ConnectCallback& callback) = 0;
  70
  71  protected:
  72   friend void base::DeletePointer<HidService>(HidService* service);
  73   friend class HidConnectionTest;
  74
  75   typedef std::map<HidDeviceId, scoped_refptr<HidDeviceInfo>> DeviceMap;
  76
  77   HidService();
  78   virtual ~HidService();
  79
  80   void AddDevice(scoped_refptr<HidDeviceInfo> info);
  81   void RemoveDevice(const HidDeviceId& device_id);
  82   void FirstEnumerationComplete();
  83
  84   const DeviceMap& devices() const { return devices_; }
  85
  86   base::ThreadChecker thread_checker_;
  87
  88  private:
  89   DeviceMap devices_;
  90   bool enumeration_ready_;
  91   std::vector<GetDevicesCallback> pending_enumerations_;
  92   base::ObserverList<Observer> observer_list_;
  93
  94   DISALLOW_COPY_AND_ASSIGN(HidService);
  95 };
  96
  97 }  // namespace device
  98
  99 #endif  // DEVICE_HID_HID_SERVICE_H_