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 #include "device/bluetooth/bluetooth_task_manager_win.h" 6 7 #include <winsock2.h> 8 9 #include <string> 10 11 #include "base/basictypes.h" 12 #include "base/bind.h" 13 #include "base/memory/ref_counted.h" 14 #include "base/memory/scoped_vector.h" 15 #include "base/message_loop/message_loop.h" 16 #include "base/sequenced_task_runner.h" 17 #include "base/strings/stringprintf.h" 18 #include "base/strings/sys_string_conversions.h" 19 #include "base/threading/sequenced_worker_pool.h" 20 #include "base/win/scoped_handle.h" 21 #include "device/bluetooth/bluetooth_init_win.h" 22 #include "device/bluetooth/bluetooth_service_record_win.h" 23 #include "net/base/winsock_init.h" 24 25 namespace { 26 27 const int kNumThreadsInWorkerPool = 3; 28 const char kBluetoothThreadName[] = "BluetoothPollingThreadWin"; 29 const int kMaxNumDeviceAddressChar = 127; 30 const int kServiceDiscoveryResultBufferSize = 5000; 31 const int kMaxDeviceDiscoveryTimeout = 48; 32 33 // Populates bluetooth adapter state using adapter_handle. 34 void GetAdapterState(HANDLE adapter_handle, 35 device::BluetoothTaskManagerWin::AdapterState* state) { 36 std::string name; 37 std::string address; 38 bool powered = false; 39 BLUETOOTH_RADIO_INFO adapter_info = { sizeof(BLUETOOTH_RADIO_INFO), 0 }; 40 if (adapter_handle && 41 ERROR_SUCCESS == BluetoothGetRadioInfo(adapter_handle, 42 &adapter_info)) { 43 name = base::SysWideToUTF8(adapter_info.szName); 44 address = base::StringPrintf("%02X:%02X:%02X:%02X:%02X:%02X", 45 adapter_info.address.rgBytes[5], 46 adapter_info.address.rgBytes[4], 47 adapter_info.address.rgBytes[3], 48 adapter_info.address.rgBytes[2], 49 adapter_info.address.rgBytes[1], 50 adapter_info.address.rgBytes[0]); 51 powered = !!BluetoothIsConnectable(adapter_handle); 52 } 53 state->name = name; 54 state->address = address; 55 state->powered = powered; 56 } 57 58 void GetDeviceState(const BLUETOOTH_DEVICE_INFO& device_info, 59 device::BluetoothTaskManagerWin::DeviceState* state) { 60 state->name = base::SysWideToUTF8(device_info.szName); 61 state->address = base::StringPrintf("%02X:%02X:%02X:%02X:%02X:%02X", 62 device_info.Address.rgBytes[5], 63 device_info.Address.rgBytes[4], 64 device_info.Address.rgBytes[3], 65 device_info.Address.rgBytes[2], 66 device_info.Address.rgBytes[1], 67 device_info.Address.rgBytes[0]); 68 state->bluetooth_class = device_info.ulClassofDevice; 69 state->visible = true; 70 state->connected = !!device_info.fConnected; 71 state->authenticated = !!device_info.fAuthenticated; 72 } 73 74 } // namespace 75 76 namespace device { 77 78 // static 79 const int BluetoothTaskManagerWin::kPollIntervalMs = 500; 80 81 BluetoothTaskManagerWin::BluetoothTaskManagerWin( 82 scoped_refptr<base::SequencedTaskRunner> ui_task_runner) 83 : ui_task_runner_(ui_task_runner), 84 discovering_(false) { 85 } 86 87 BluetoothTaskManagerWin::~BluetoothTaskManagerWin() { 88 } 89 90 void BluetoothTaskManagerWin::AddObserver(Observer* observer) { 91 DCHECK(observer); 92 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 93 observers_.AddObserver(observer); 94 } 95 96 void BluetoothTaskManagerWin::RemoveObserver(Observer* observer) { 97 DCHECK(observer); 98 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 99 observers_.RemoveObserver(observer); 100 } 101 102 void BluetoothTaskManagerWin::Initialize() { 103 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 104 worker_pool_ = new base::SequencedWorkerPool(kNumThreadsInWorkerPool, 105 kBluetoothThreadName); 106 InitializeWithBluetoothTaskRunner( 107 worker_pool_->GetSequencedTaskRunnerWithShutdownBehavior( 108 worker_pool_->GetSequenceToken(), 109 base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)); 110 } 111 112 void BluetoothTaskManagerWin::InitializeWithBluetoothTaskRunner( 113 scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner) { 114 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 115 bluetooth_task_runner_ = bluetooth_task_runner; 116 bluetooth_task_runner_->PostTask( 117 FROM_HERE, 118 base::Bind(&BluetoothTaskManagerWin::StartPolling, this)); 119 } 120 121 void BluetoothTaskManagerWin::StartPolling() { 122 DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread()); 123 124 if (device::bluetooth_init_win::HasBluetoothStack()) { 125 PollAdapter(); 126 } else { 127 // IF the bluetooth stack is not available, we still send an empty state 128 // to BluetoothAdapter so that it is marked initialized, but the adapter 129 // will not be present. 130 AdapterState* state = new AdapterState(); 131 ui_task_runner_->PostTask( 132 FROM_HERE, 133 base::Bind(&BluetoothTaskManagerWin::OnAdapterStateChanged, 134 this, 135 base::Owned(state))); 136 } 137 } 138 139 void BluetoothTaskManagerWin::Shutdown() { 140 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 141 if (worker_pool_) 142 worker_pool_->Shutdown(); 143 } 144 145 void BluetoothTaskManagerWin::PostSetPoweredBluetoothTask( 146 bool powered, 147 const base::Closure& callback, 148 const BluetoothAdapter::ErrorCallback& error_callback) { 149 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 150 bluetooth_task_runner_->PostTask( 151 FROM_HERE, 152 base::Bind(&BluetoothTaskManagerWin::SetPowered, 153 this, 154 powered, 155 callback, 156 error_callback)); 157 } 158 159 void BluetoothTaskManagerWin::PostStartDiscoveryTask() { 160 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 161 bluetooth_task_runner_->PostTask( 162 FROM_HERE, 163 base::Bind(&BluetoothTaskManagerWin::StartDiscovery, this)); 164 } 165 166 void BluetoothTaskManagerWin::PostStopDiscoveryTask() { 167 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 168 bluetooth_task_runner_->PostTask( 169 FROM_HERE, 170 base::Bind(&BluetoothTaskManagerWin::StopDiscovery, this)); 171 } 172 173 void BluetoothTaskManagerWin::OnAdapterStateChanged(const AdapterState* state) { 174 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 175 FOR_EACH_OBSERVER(BluetoothTaskManagerWin::Observer, observers_, 176 AdapterStateChanged(*state)); 177 } 178 179 void BluetoothTaskManagerWin::OnDiscoveryStarted(bool success) { 180 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 181 FOR_EACH_OBSERVER(BluetoothTaskManagerWin::Observer, observers_, 182 DiscoveryStarted(success)); 183 } 184 185 void BluetoothTaskManagerWin::OnDiscoveryStopped() { 186 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 187 FOR_EACH_OBSERVER(BluetoothTaskManagerWin::Observer, observers_, 188 DiscoveryStopped()); 189 } 190 191 void BluetoothTaskManagerWin::OnDevicesUpdated( 192 const ScopedVector<DeviceState>* devices) { 193 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 194 FOR_EACH_OBSERVER(BluetoothTaskManagerWin::Observer, observers_, 195 DevicesUpdated(*devices)); 196 } 197 198 void BluetoothTaskManagerWin::OnDevicesDiscovered( 199 const ScopedVector<DeviceState>* devices) { 200 DCHECK(ui_task_runner_->RunsTasksOnCurrentThread()); 201 FOR_EACH_OBSERVER(BluetoothTaskManagerWin::Observer, observers_, 202 DevicesDiscovered(*devices)); 203 } 204 205 void BluetoothTaskManagerWin::PollAdapter() { 206 DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread()); 207 208 // Skips updating the adapter info if the adapter is in discovery mode. 209 if (!discovering_) { 210 const BLUETOOTH_FIND_RADIO_PARAMS adapter_param = 211 { sizeof(BLUETOOTH_FIND_RADIO_PARAMS) }; 212 if (adapter_handle_) 213 adapter_handle_.Close(); 214 HANDLE temp_adapter_handle; 215 HBLUETOOTH_RADIO_FIND handle = BluetoothFindFirstRadio( 216 &adapter_param, &temp_adapter_handle); 217 218 if (handle) { 219 adapter_handle_.Set(temp_adapter_handle); 220 GetKnownDevices(); 221 BluetoothFindRadioClose(handle); 222 } 223 PostAdapterStateToUi(); 224 } 225 226 // Re-poll. 227 bluetooth_task_runner_->PostDelayedTask( 228 FROM_HERE, 229 base::Bind(&BluetoothTaskManagerWin::PollAdapter, 230 this), 231 base::TimeDelta::FromMilliseconds(kPollIntervalMs)); 232 } 233 234 void BluetoothTaskManagerWin::PostAdapterStateToUi() { 235 DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread()); 236 AdapterState* state = new AdapterState(); 237 GetAdapterState(adapter_handle_, state); 238 ui_task_runner_->PostTask( 239 FROM_HERE, 240 base::Bind(&BluetoothTaskManagerWin::OnAdapterStateChanged, 241 this, 242 base::Owned(state))); 243 } 244 245 void BluetoothTaskManagerWin::SetPowered( 246 bool powered, 247 const base::Closure& callback, 248 const BluetoothAdapter::ErrorCallback& error_callback) { 249 DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread()); 250 bool success = false; 251 if (adapter_handle_) { 252 if (!powered) 253 BluetoothEnableDiscovery(adapter_handle_, false); 254 success = !!BluetoothEnableIncomingConnections(adapter_handle_, powered); 255 } 256 257 if (success) { 258 PostAdapterStateToUi(); 259 ui_task_runner_->PostTask(FROM_HERE, callback); 260 } else { 261 ui_task_runner_->PostTask(FROM_HERE, error_callback); 262 } 263 } 264 265 void BluetoothTaskManagerWin::StartDiscovery() { 266 DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread()); 267 ui_task_runner_->PostTask( 268 FROM_HERE, 269 base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStarted, 270 this, 271 !!adapter_handle_)); 272 if (!adapter_handle_) 273 return; 274 discovering_ = true; 275 276 DiscoverDevices(1); 277 } 278 279 void BluetoothTaskManagerWin::StopDiscovery() { 280 DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread()); 281 discovering_ = false; 282 ui_task_runner_->PostTask( 283 FROM_HERE, 284 base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStopped, this)); 285 } 286 287 void BluetoothTaskManagerWin::DiscoverDevices(int timeout) { 288 DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread()); 289 if (!discovering_ || !adapter_handle_) { 290 ui_task_runner_->PostTask( 291 FROM_HERE, 292 base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStopped, this)); 293 return; 294 } 295 296 ScopedVector<DeviceState>* device_list = new ScopedVector<DeviceState>(); 297 SearchDevices(timeout, false, device_list); 298 if (device_list->empty()) { 299 delete device_list; 300 } else { 301 DiscoverServices(device_list); 302 ui_task_runner_->PostTask( 303 FROM_HERE, 304 base::Bind(&BluetoothTaskManagerWin::OnDevicesDiscovered, 305 this, 306 base::Owned(device_list))); 307 } 308 309 if (timeout < kMaxDeviceDiscoveryTimeout) { 310 bluetooth_task_runner_->PostTask( 311 FROM_HERE, 312 base::Bind(&BluetoothTaskManagerWin::DiscoverDevices, 313 this, 314 timeout + 1)); 315 } else { 316 ui_task_runner_->PostTask( 317 FROM_HERE, 318 base::Bind(&BluetoothTaskManagerWin::OnDiscoveryStopped, this)); 319 discovering_ = false; 320 } 321 } 322 323 void BluetoothTaskManagerWin::GetKnownDevices() { 324 ScopedVector<DeviceState>* device_list = new ScopedVector<DeviceState>(); 325 SearchDevices(1, true, device_list); 326 if (device_list->empty()) { 327 delete device_list; 328 return; 329 } 330 DiscoverServices(device_list); 331 ui_task_runner_->PostTask( 332 FROM_HERE, 333 base::Bind(&BluetoothTaskManagerWin::OnDevicesUpdated, 334 this, 335 base::Owned(device_list))); 336 } 337 338 void BluetoothTaskManagerWin::SearchDevices( 339 int timeout, 340 bool search_cached_devices_only, 341 ScopedVector<DeviceState>* device_list) { 342 BLUETOOTH_DEVICE_SEARCH_PARAMS device_search_params = { 343 sizeof(BLUETOOTH_DEVICE_SEARCH_PARAMS), 344 1, // return authenticated devices 345 1, // return remembered devicess 346 search_cached_devices_only ? 0 : 1, // return unknown devices 347 1, // return connected devices 348 search_cached_devices_only ? 0 : 1, // issue a new inquiry 349 timeout, // timeout for the inquiry in increments of 1.28 seconds 350 adapter_handle_ 351 }; 352 353 BLUETOOTH_DEVICE_INFO device_info = { sizeof(BLUETOOTH_DEVICE_INFO), 0 }; 354 // Issues a device inquiry and waits for |timeout| * 1.28 seconds. 355 HBLUETOOTH_DEVICE_FIND handle = 356 BluetoothFindFirstDevice(&device_search_params, &device_info); 357 if (handle) { 358 do { 359 DeviceState* device_state = new DeviceState(); 360 GetDeviceState(device_info, device_state); 361 device_list->push_back(device_state); 362 } while (BluetoothFindNextDevice(handle, &device_info)); 363 364 BluetoothFindDeviceClose(handle); 365 } 366 } 367 368 void BluetoothTaskManagerWin::DiscoverServices( 369 ScopedVector<DeviceState>* device_list) { 370 DCHECK(bluetooth_task_runner_->RunsTasksOnCurrentThread()); 371 net::EnsureWinsockInit(); 372 for (ScopedVector<DeviceState>::iterator iter = device_list->begin(); 373 iter != device_list->end(); 374 ++iter) { 375 const std::string device_address = (*iter)->address; 376 ScopedVector<ServiceRecordState>* service_record_states = 377 &(*iter)->service_record_states; 378 WSAQUERYSET sdp_query; 379 ZeroMemory(&sdp_query, sizeof(sdp_query)); 380 sdp_query.dwSize = sizeof(sdp_query); 381 GUID protocol = L2CAP_PROTOCOL_UUID; 382 sdp_query.lpServiceClassId = &protocol; 383 sdp_query.dwNameSpace = NS_BTH; 384 wchar_t device_address_context[kMaxNumDeviceAddressChar]; 385 std::size_t length = 386 base::SysUTF8ToWide("(" + device_address + ")").copy( 387 device_address_context, kMaxNumDeviceAddressChar); 388 device_address_context[length] = NULL; 389 sdp_query.lpszContext = device_address_context; 390 HANDLE sdp_handle; 391 if (ERROR_SUCCESS != 392 WSALookupServiceBegin(&sdp_query, LUP_RETURN_ALL, &sdp_handle)) { 393 return; 394 } 395 char sdp_buffer[kServiceDiscoveryResultBufferSize]; 396 LPWSAQUERYSET sdp_result_data = reinterpret_cast<LPWSAQUERYSET>(sdp_buffer); 397 DWORD sdp_buffer_size = sizeof(sdp_buffer); 398 while (ERROR_SUCCESS == WSALookupServiceNext(sdp_handle, 399 LUP_RETURN_ALL, 400 &sdp_buffer_size, 401 sdp_result_data)) { 402 ServiceRecordState* service_record_state = new ServiceRecordState(); 403 service_record_state->name = 404 base::SysWideToUTF8(sdp_result_data->lpszServiceInstanceName); 405 service_record_state->address = device_address; 406 for (uint64 i = 0; i < sdp_result_data->lpBlob->cbSize; i++) { 407 service_record_state->sdp_bytes.push_back( 408 sdp_result_data->lpBlob->pBlobData[i]); 409 } 410 service_record_states->push_back(service_record_state); 411 } 412 WSALookupServiceEnd(sdp_handle); 413 } 414 } 415 416 } // namespace device 417
