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: ~Observer()61 virtual ~Observer() {} 62 AdapterStateChanged(const AdapterState & state)63 virtual void AdapterStateChanged(const AdapterState& state) {} DiscoveryStarted(bool success)64 virtual void DiscoveryStarted(bool success) {} DiscoveryStopped()65 virtual void DiscoveryStopped() {} DevicesUpdated(const ScopedVector<DeviceState> & devices)66 virtual void DevicesUpdated(const ScopedVector<DeviceState>& devices) {} DevicesDiscovered(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