device/bluetooth/bluetooth_task_manager_win.h

   1 // Copyright (c) 2012 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_BLUETOOTH_BLUETOOTH_TASK_MANAGER_WIN_H_
   6 #define DEVICE_BLUETOOTH_BLUETOOTH_TASK_MANAGER_WIN_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_vector.h"
  13 #include "base/observer_list.h"
  14 #include "base/win/scoped_handle.h"
  15 #include "device/bluetooth/bluetooth_adapter.h"
  16
  17 namespace base {
  18
  19 class SequencedTaskRunner;
  20 class SequencedWorkerPool;
  21
  22 }  // namespace base
  23
  24 namespace device {
  25
  26 // Manages the blocking Bluetooth tasks using |SequencedWorkerPool|. It runs
  27 // bluetooth tasks using |SequencedWorkerPool| and informs its observers of
  28 // bluetooth adapter state changes and any other bluetooth device inquiry
  29 // result.
  30 //
  31 // It delegates the blocking Windows API calls to |bluetooth_task_runner_|'s
  32 // message loop, and receives responses via methods like OnAdapterStateChanged
  33 // posted to UI thread.
  34 class BluetoothTaskManagerWin
  35     : public base::RefCountedThreadSafe<BluetoothTaskManagerWin> {
  36  public:
  37   struct AdapterState {
  38     std::string name;
  39     std::string address;
  40     bool powered;
  41   };
  42
  43   struct ServiceRecordState {
  44     std::string name;
  45     std::string address;
  46     std::vector<uint8> sdp_bytes;
  47   };
  48
  49   struct DeviceState {
  50     std::string name;
  51     std::string address;
  52     uint32 bluetooth_class;
  53     bool visible;
  54     bool connected;
  55     bool authenticated;
  56     ScopedVector<ServiceRecordState> service_record_states;
  57   };
  58
  59   class Observer {
  60    public:
  61      virtual ~Observer() {}
  62
  63      virtual void AdapterStateChanged(const AdapterState& state) {}
  64      virtual void DiscoveryStarted(bool success) {}
  65      virtual void DiscoveryStopped() {}
  66      virtual void DevicesDiscovered(const ScopedVector<DeviceState>& devices) {}
  67   };
  68
  69   explicit BluetoothTaskManagerWin(
  70       scoped_refptr<base::SequencedTaskRunner> ui_task_runner);
  71
  72   void AddObserver(Observer* observer);
  73   void RemoveObserver(Observer* observer);
  74
  75   void Initialize();
  76   void InitializeWithBluetoothTaskRunner(
  77       scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner);
  78   void Shutdown();
  79
  80   void PostSetPoweredBluetoothTask(
  81       bool powered,
  82       const base::Closure& callback,
  83       const BluetoothAdapter::ErrorCallback& error_callback);
  84   void PostStartDiscoveryTask();
  85   void PostStopDiscoveryTask();
  86
  87  private:
  88   friend class base::RefCountedThreadSafe<BluetoothTaskManagerWin>;
  89   friend class BluetoothTaskManagerWinTest;
  90
  91   static const int kPollIntervalMs;
  92
  93   virtual ~BluetoothTaskManagerWin();
  94
  95   // Notify all Observers of updated AdapterState. Should only be called on the
  96   // UI thread.
  97   void OnAdapterStateChanged(const AdapterState* state);
  98   void OnDiscoveryStarted(bool success);
  99   void OnDiscoveryStopped();
 100   void OnDevicesDiscovered(const ScopedVector<DeviceState>* devices);
 101
 102   // Called on BluetoothTaskRunner.
 103   void StartPolling();
 104   void PollAdapter();
 105   void PostAdapterStateToUi();
 106   void SetPowered(bool powered,
 107                   const base::Closure& callback,
 108                   const BluetoothAdapter::ErrorCallback& error_callback);
 109
 110   // Starts discovery. Once the discovery starts, it issues a discovery inquiry
 111   // with a short timeout, then issues more inquiries with greater timeout
 112   // values. The discovery finishes when StopDiscovery() is called or timeout
 113   // has reached its maximum value.
 114   void StartDiscovery();
 115   void StopDiscovery();
 116
 117   // Issues a device inquiry that runs for |timeout| * 1.28 seconds.
 118   // This posts itself again with |timeout| + 1 until |timeout| reaches the
 119   // maximum value or stop discovery call is received.
 120   void DiscoverDevices(int timeout);
 121
 122   // Fetch already known device information. Similar to |StartDiscovery|, except
 123   // this function does not issue a discovery inquiry. Instead it gets the
 124   // device info cached in the adapter.
 125   void GetKnownDevices();
 126
 127   // Sends a device search API call to the adapter.
 128   void SearchDevices(int timeout,
 129                      bool search_cached_devices_only,
 130                      ScopedVector<DeviceState>* device_list);
 131
 132   // Discover services for the devices in |device_list|.
 133   void DiscoverServices(ScopedVector<DeviceState>* device_list);
 134
 135   // UI task runner reference.
 136   scoped_refptr<base::SequencedTaskRunner> ui_task_runner_;
 137
 138   scoped_refptr<base::SequencedWorkerPool> worker_pool_;
 139   scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner_;
 140
 141   // List of observers interested in event notifications.
 142   ObserverList<Observer> observers_;
 143
 144   // Adapter handle owned by bluetooth task runner.
 145   base::win::ScopedHandle adapter_handle_;
 146
 147   // indicates whether the adapter is in discovery mode or not.
 148   bool discovering_;
 149
 150   DISALLOW_COPY_AND_ASSIGN(BluetoothTaskManagerWin);
 151 };
 152
 153 }  // namespace device
 154
 155 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_TASK_MANAGER_WIN_H_