Home | History | Annotate | Download | only in bluetooth 
      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 DevicesUpdated(const ScopedVector<DeviceState>& devices) {}
     67      virtual void DevicesDiscovered(const ScopedVector<DeviceState>& devices) {}
     68   };
     69 
     70   explicit BluetoothTaskManagerWin(
     71       scoped_refptr<base::SequencedTaskRunner> ui_task_runner);
     72 
     73   void AddObserver(Observer* observer);
     74   void RemoveObserver(Observer* observer);
     75 
     76   void Initialize();
     77   void InitializeWithBluetoothTaskRunner(
     78       scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner);
     79   void Shutdown();
     80 
     81   void PostSetPoweredBluetoothTask(
     82       bool powered,
     83       const base::Closure& callback,
     84       const BluetoothAdapter::ErrorCallback& error_callback);
     85   void PostStartDiscoveryTask();
     86   void PostStopDiscoveryTask();
     87 
     88  private:
     89   friend class base::RefCountedThreadSafe<BluetoothTaskManagerWin>;
     90   friend class BluetoothTaskManagerWinTest;
     91 
     92   static const int kPollIntervalMs;
     93 
     94   virtual ~BluetoothTaskManagerWin();
     95 
     96   // Notify all Observers of updated AdapterState. Should only be called on the
     97   // UI thread.
     98   void OnAdapterStateChanged(const AdapterState* state);
     99   void OnDiscoveryStarted(bool success);
    100   void OnDiscoveryStopped();
    101   void OnDevicesUpdated(const ScopedVector<DeviceState>* devices);
    102   void OnDevicesDiscovered(const ScopedVector<DeviceState>* devices);
    103 
    104   // Called on BluetoothTaskRunner.
    105   void StartPolling();
    106   void PollAdapter();
    107   void PostAdapterStateToUi();
    108   void SetPowered(bool powered,
    109                   const base::Closure& callback,
    110                   const BluetoothAdapter::ErrorCallback& error_callback);
    111 
    112   // Starts discovery. Once the discovery starts, it issues a discovery inquiry
    113   // with a short timeout, then issues more inquiries with greater timeout
    114   // values. The discovery finishes when StopDiscovery() is called or timeout
    115   // has reached its maximum value.
    116   void StartDiscovery();
    117   void StopDiscovery();
    118 
    119   // Issues a device inquiry that runs for |timeout| * 1.28 seconds.
    120   // This posts itself again with |timeout| + 1 until |timeout| reaches the
    121   // maximum value or stop discovery call is received.
    122   void DiscoverDevices(int timeout);
    123 
    124   // Fetch already known device information. Similar to |StartDiscovery|, except
    125   // this function does not issue a discovery inquiry. Instead it gets the
    126   // device info cached in the adapter.
    127   void GetKnownDevices();
    128 
    129   // Sends a device search API call to the adapter.
    130   void SearchDevices(int timeout,
    131                      bool search_cached_devices_only,
    132                      ScopedVector<DeviceState>* device_list);
    133 
    134   // Discover services for the devices in |device_list|.
    135   void DiscoverServices(ScopedVector<DeviceState>* device_list);
    136 
    137   // UI task runner reference.
    138   scoped_refptr<base::SequencedTaskRunner> ui_task_runner_;
    139 
    140   scoped_refptr<base::SequencedWorkerPool> worker_pool_;
    141   scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner_;
    142 
    143   // List of observers interested in event notifications.
    144   ObserverList<Observer> observers_;
    145 
    146   // Adapter handle owned by bluetooth task runner.
    147   base::win::ScopedHandle adapter_handle_;
    148 
    149   // indicates whether the adapter is in discovery mode or not.
    150   bool discovering_;
    151 
    152   DISALLOW_COPY_AND_ASSIGN(BluetoothTaskManagerWin);
    153 };
    154 
    155 }  // namespace device
    156 
    157 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_TASK_MANAGER_WIN_H_
    158