device/bluetooth/bluetooth_adapter_win.cc

   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_adapter_win.h"
   6
   7 #include <hash_set>
   8 #include <string>
   9 #include <utility>
  10
  11 #include "base/logging.h"
  12 #include "base/sequenced_task_runner.h"
  13 #include "base/single_thread_task_runner.h"
  14 #include "base/stl_util.h"
  15 #include "base/thread_task_runner_handle.h"
  16 #include "device/bluetooth/bluetooth_device_win.h"
  17 #include "device/bluetooth/bluetooth_socket_thread.h"
  18 #include "device/bluetooth/bluetooth_socket_win.h"
  19 #include "device/bluetooth/bluetooth_task_manager_win.h"
  20 #include "device/bluetooth/bluetooth_uuid.h"
  21
  22 namespace device {
  23
  24 // static
  25 base::WeakPtr<BluetoothAdapter> BluetoothAdapter::CreateAdapter(
  26     const InitCallback& init_callback) {
  27   return BluetoothAdapterWin::CreateAdapter(init_callback);
  28 }
  29
  30 // static
  31 base::WeakPtr<BluetoothAdapter> BluetoothAdapterWin::CreateAdapter(
  32     const InitCallback& init_callback) {
  33   BluetoothAdapterWin* adapter = new BluetoothAdapterWin(init_callback);
  34   adapter->Init();
  35   return adapter->weak_ptr_factory_.GetWeakPtr();
  36 }
  37
  38 BluetoothAdapterWin::BluetoothAdapterWin(const InitCallback& init_callback)
  39     : BluetoothAdapter(),
  40       init_callback_(init_callback),
  41       initialized_(false),
  42       powered_(false),
  43       discovery_status_(NOT_DISCOVERING),
  44       num_discovery_listeners_(0),
  45       weak_ptr_factory_(this) {
  46 }
  47
  48 BluetoothAdapterWin::~BluetoothAdapterWin() {
  49   if (task_manager_) {
  50     task_manager_->RemoveObserver(this);
  51     task_manager_->Shutdown();
  52   }
  53 }
  54
  55 void BluetoothAdapterWin::AddObserver(BluetoothAdapter::Observer* observer) {
  56   DCHECK(observer);
  57   observers_.AddObserver(observer);
  58 }
  59
  60 void BluetoothAdapterWin::RemoveObserver(BluetoothAdapter::Observer* observer) {
  61   DCHECK(observer);
  62   observers_.RemoveObserver(observer);
  63 }
  64
  65 std::string BluetoothAdapterWin::GetAddress() const {
  66   return address_;
  67 }
  68
  69 std::string BluetoothAdapterWin::GetName() const {
  70   return name_;
  71 }
  72
  73 void BluetoothAdapterWin::SetName(const std::string& name,
  74                                   const base::Closure& callback,
  75                                   const ErrorCallback& error_callback) {
  76   NOTIMPLEMENTED();
  77 }
  78
  79 // TODO(youngki): Return true when |task_manager_| initializes the adapter
  80 // state.
  81 bool BluetoothAdapterWin::IsInitialized() const {
  82   return initialized_;
  83 }
  84
  85 bool BluetoothAdapterWin::IsPresent() const {
  86   return !address_.empty();
  87 }
  88
  89 bool BluetoothAdapterWin::IsPowered() const {
  90   return powered_;
  91 }
  92
  93 void BluetoothAdapterWin::SetPowered(
  94     bool powered,
  95     const base::Closure& callback,
  96     const ErrorCallback& error_callback) {
  97   task_manager_->PostSetPoweredBluetoothTask(powered, callback, error_callback);
  98 }
  99
 100 bool BluetoothAdapterWin::IsDiscoverable() const {
 101   NOTIMPLEMENTED();
 102   return false;
 103 }
 104
 105 void BluetoothAdapterWin::SetDiscoverable(
 106     bool discoverable,
 107     const base::Closure& callback,
 108     const ErrorCallback& error_callback) {
 109   NOTIMPLEMENTED();
 110 }
 111
 112 bool BluetoothAdapterWin::IsDiscovering() const {
 113   return discovery_status_ == DISCOVERING ||
 114       discovery_status_ == DISCOVERY_STOPPING;
 115 }
 116
 117 void BluetoothAdapterWin::DiscoveryStarted(bool success) {
 118   discovery_status_ = success ? DISCOVERING : NOT_DISCOVERING;
 119   for (std::vector<std::pair<base::Closure, ErrorCallback> >::const_iterator
 120        iter = on_start_discovery_callbacks_.begin();
 121        iter != on_start_discovery_callbacks_.end();
 122        ++iter) {
 123     if (success)
 124       ui_task_runner_->PostTask(FROM_HERE, iter->first);
 125     else
 126       ui_task_runner_->PostTask(FROM_HERE, iter->second);
 127   }
 128   num_discovery_listeners_ = on_start_discovery_callbacks_.size();
 129   on_start_discovery_callbacks_.clear();
 130
 131   if (success) {
 132     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
 133                       AdapterDiscoveringChanged(this, true));
 134
 135     // If there are stop discovery requests, post the stop discovery again.
 136     MaybePostStopDiscoveryTask();
 137   } else if (!on_stop_discovery_callbacks_.empty()) {
 138     // If there are stop discovery requests but start discovery has failed,
 139     // notify that stop discovery has been complete.
 140     DiscoveryStopped();
 141   }
 142 }
 143
 144 void BluetoothAdapterWin::DiscoveryStopped() {
 145   discovered_devices_.clear();
 146   bool was_discovering = IsDiscovering();
 147   discovery_status_ = NOT_DISCOVERING;
 148   for (std::vector<base::Closure>::const_iterator iter =
 149            on_stop_discovery_callbacks_.begin();
 150        iter != on_stop_discovery_callbacks_.end();
 151        ++iter) {
 152     ui_task_runner_->PostTask(FROM_HERE, *iter);
 153   }
 154   num_discovery_listeners_ = 0;
 155   on_stop_discovery_callbacks_.clear();
 156   if (was_discovering)
 157     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
 158                       AdapterDiscoveringChanged(this, false));
 159
 160   // If there are start discovery requests, post the start discovery again.
 161   MaybePostStartDiscoveryTask();
 162 }
 163
 164 void BluetoothAdapterWin::CreateRfcommService(
 165     const BluetoothUUID& uuid,
 166     const ServiceOptions& options,
 167     const CreateServiceCallback& callback,
 168     const CreateServiceErrorCallback& error_callback) {
 169   scoped_refptr<BluetoothSocketWin> socket =
 170       BluetoothSocketWin::CreateBluetoothSocket(
 171           ui_task_runner_, socket_thread_);
 172   socket->Listen(this, uuid, options,
 173                  base::Bind(callback, socket),
 174                  error_callback);
 175 }
 176
 177 void BluetoothAdapterWin::CreateL2capService(
 178     const BluetoothUUID& uuid,
 179     const ServiceOptions& options,
 180     const CreateServiceCallback& callback,
 181     const CreateServiceErrorCallback& error_callback) {
 182   // TODO(keybuk): implement.
 183   NOTIMPLEMENTED();
 184 }
 185
 186 void BluetoothAdapterWin::RemovePairingDelegateInternal(
 187     BluetoothDevice::PairingDelegate* pairing_delegate) {
 188 }
 189
 190 void BluetoothAdapterWin::AdapterStateChanged(
 191     const BluetoothTaskManagerWin::AdapterState& state) {
 192   DCHECK(thread_checker_.CalledOnValidThread());
 193   name_ = state.name;
 194   bool was_present = IsPresent();
 195   bool is_present = !state.address.empty();
 196   address_ = BluetoothDevice::CanonicalizeAddress(state.address);
 197   if (was_present != is_present) {
 198     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
 199                       AdapterPresentChanged(this, is_present));
 200   }
 201   if (powered_ != state.powered) {
 202     powered_ = state.powered;
 203     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
 204                       AdapterPoweredChanged(this, powered_));
 205   }
 206   if (!initialized_) {
 207     initialized_ = true;
 208     init_callback_.Run();
 209   }
 210 }
 211
 212 void BluetoothAdapterWin::DevicesPolled(
 213     const ScopedVector<BluetoothTaskManagerWin::DeviceState>& devices) {
 214   DCHECK(thread_checker_.CalledOnValidThread());
 215
 216   // We are receiving a new list of all devices known to the system. Merge this
 217   // new list with the list we know of (|devices_|) and raise corresponding
 218   // DeviceAdded, DeviceRemoved and DeviceChanged events.
 219
 220   typedef std::set<std::string> DeviceAddressSet;
 221   DeviceAddressSet known_devices;
 222   for (DevicesMap::const_iterator iter = devices_.begin();
 223        iter != devices_.end();
 224        ++iter) {
 225     known_devices.insert((*iter).first);
 226   }
 227
 228   DeviceAddressSet new_devices;
 229   for (ScopedVector<BluetoothTaskManagerWin::DeviceState>::const_iterator iter =
 230            devices.begin();
 231        iter != devices.end();
 232        ++iter) {
 233     new_devices.insert((*iter)->address);
 234   }
 235
 236   // Process device removal first
 237   DeviceAddressSet removed_devices =
 238       base::STLSetDifference<DeviceAddressSet>(known_devices, new_devices);
 239   for (DeviceAddressSet::const_iterator iter = removed_devices.begin();
 240        iter != removed_devices.end();
 241        ++iter) {
 242     BluetoothDevice* device_win = devices_[(*iter)];
 243     devices_.erase(*iter);
 244     FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
 245                       observers_,
 246                       DeviceRemoved(this, device_win));
 247     delete device_win;
 248   }
 249
 250   // Process added and (maybe) changed devices in one pass
 251   DeviceAddressSet added_devices =
 252       base::STLSetDifference<DeviceAddressSet>(new_devices, known_devices);
 253   DeviceAddressSet changed_devices =
 254       base::STLSetIntersection<DeviceAddressSet>(known_devices, new_devices);
 255   for (ScopedVector<BluetoothTaskManagerWin::DeviceState>::const_iterator iter =
 256            devices.begin();
 257        iter != devices.end();
 258        ++iter) {
 259     BluetoothTaskManagerWin::DeviceState* device_state = (*iter);
 260     if (added_devices.find(device_state->address) != added_devices.end()) {
 261       BluetoothDeviceWin* device_win =
 262           new BluetoothDeviceWin(*device_state,
 263                                  ui_task_runner_,
 264                                  socket_thread_,
 265                                  NULL,
 266                                  net::NetLog::Source());
 267       devices_[device_state->address] = device_win;
 268       FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
 269                         observers_,
 270                         DeviceAdded(this, device_win));
 271     } else if (changed_devices.find(device_state->address) !=
 272                changed_devices.end()) {
 273       BluetoothDeviceWin* device_win =
 274           static_cast<BluetoothDeviceWin*>(devices_[device_state->address]);
 275       if (!device_win->IsEqual(*device_state)) {
 276         device_win->Update(*device_state);
 277         FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
 278                           observers_,
 279                           DeviceChanged(this, device_win));
 280       }
 281     }
 282   }
 283 }
 284
 285 // If the method is called when |discovery_status_| is DISCOVERY_STOPPING,
 286 // starting again is handled by BluetoothAdapterWin::DiscoveryStopped().
 287 void BluetoothAdapterWin::AddDiscoverySession(
 288     const base::Closure& callback,
 289     const ErrorCallback& error_callback) {
 290   if (discovery_status_ == DISCOVERING) {
 291     num_discovery_listeners_++;
 292     callback.Run();
 293     return;
 294   }
 295   on_start_discovery_callbacks_.push_back(
 296       std::make_pair(callback, error_callback));
 297   MaybePostStartDiscoveryTask();
 298 }
 299
 300 void BluetoothAdapterWin::RemoveDiscoverySession(
 301     const base::Closure& callback,
 302     const ErrorCallback& error_callback) {
 303   if (discovery_status_ == NOT_DISCOVERING) {
 304     error_callback.Run();
 305     return;
 306   }
 307   on_stop_discovery_callbacks_.push_back(callback);
 308   MaybePostStopDiscoveryTask();
 309 }
 310
 311 void BluetoothAdapterWin::Init() {
 312   ui_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 313   socket_thread_ = BluetoothSocketThread::Get();
 314   task_manager_ =
 315       new BluetoothTaskManagerWin(ui_task_runner_);
 316   task_manager_->AddObserver(this);
 317   task_manager_->Initialize();
 318 }
 319
 320 void BluetoothAdapterWin::InitForTest(
 321     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
 322     scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner) {
 323   ui_task_runner_ = ui_task_runner;
 324   task_manager_ =
 325       new BluetoothTaskManagerWin(ui_task_runner_);
 326   task_manager_->AddObserver(this);
 327   task_manager_->InitializeWithBluetoothTaskRunner(bluetooth_task_runner);
 328 }
 329
 330 void BluetoothAdapterWin::MaybePostStartDiscoveryTask() {
 331   if (discovery_status_ == NOT_DISCOVERING &&
 332       !on_start_discovery_callbacks_.empty()) {
 333     discovery_status_ = DISCOVERY_STARTING;
 334     task_manager_->PostStartDiscoveryTask();
 335   }
 336 }
 337
 338 void BluetoothAdapterWin::MaybePostStopDiscoveryTask() {
 339   if (discovery_status_ != DISCOVERING)
 340     return;
 341
 342   if (on_stop_discovery_callbacks_.size() < num_discovery_listeners_) {
 343     for (std::vector<base::Closure>::const_iterator iter =
 344              on_stop_discovery_callbacks_.begin();
 345          iter != on_stop_discovery_callbacks_.end();
 346          ++iter) {
 347       ui_task_runner_->PostTask(FROM_HERE, *iter);
 348     }
 349     num_discovery_listeners_ -= on_stop_discovery_callbacks_.size();
 350     on_stop_discovery_callbacks_.clear();
 351     return;
 352   }
 353
 354   discovery_status_ = DISCOVERY_STOPPING;
 355   task_manager_->PostStopDiscoveryTask();
 356 }
 357
 358 }  // namespace device