extensions/browser/api/bluetooth/bluetooth_event_router.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 "extensions/browser/api/bluetooth/bluetooth_event_router.h"
   6
   7 #include <map>
   8 #include <string>
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/lazy_instance.h"
  13 #include "base/logging.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/scoped_vector.h"
  16 #include "base/stl_util.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "content/public/browser/notification_details.h"
  19 #include "content/public/browser/notification_source.h"
  20 #include "device/bluetooth/bluetooth_adapter.h"
  21 #include "device/bluetooth/bluetooth_adapter_factory.h"
  22 #include "device/bluetooth/bluetooth_device.h"
  23 #include "device/bluetooth/bluetooth_discovery_session.h"
  24 #include "extensions/browser/api/bluetooth/bluetooth_api_pairing_delegate.h"
  25 #include "extensions/browser/api/bluetooth/bluetooth_api_utils.h"
  26 #include "extensions/browser/api/bluetooth/bluetooth_private_api.h"
  27 #include "extensions/browser/event_router.h"
  28 #include "extensions/browser/extension_host.h"
  29 #include "extensions/browser/extension_registry.h"
  30 #include "extensions/browser/notification_types.h"
  31 #include "extensions/common/api/bluetooth.h"
  32 #include "extensions/common/api/bluetooth_private.h"
  33
  34 namespace extensions {
  35
  36 namespace bluetooth = core_api::bluetooth;
  37 namespace bt_private = core_api::bluetooth_private;
  38
  39 BluetoothEventRouter::BluetoothEventRouter(content::BrowserContext* context)
  40     : browser_context_(context),
  41       adapter_(NULL),
  42       num_event_listeners_(0),
  43       extension_registry_observer_(this),
  44       weak_ptr_factory_(this) {
  45   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  46   DCHECK(browser_context_);
  47   registrar_.Add(this,
  48                  extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
  49                  content::Source<content::BrowserContext>(browser_context_));
  50   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
  51 }
  52
  53 BluetoothEventRouter::~BluetoothEventRouter() {
  54   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  55   if (adapter_.get()) {
  56     adapter_->RemoveObserver(this);
  57     adapter_ = NULL;
  58   }
  59   CleanUpAllExtensions();
  60 }
  61
  62 bool BluetoothEventRouter::IsBluetoothSupported() const {
  63   return adapter_.get() ||
  64          device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable();
  65 }
  66
  67 void BluetoothEventRouter::GetAdapter(
  68     const device::BluetoothAdapterFactory::AdapterCallback& callback) {
  69   if (adapter_.get()) {
  70     callback.Run(scoped_refptr<device::BluetoothAdapter>(adapter_));
  71     return;
  72   }
  73
  74   device::BluetoothAdapterFactory::GetAdapter(callback);
  75 }
  76
  77 void BluetoothEventRouter::StartDiscoverySession(
  78     device::BluetoothAdapter* adapter,
  79     const std::string& extension_id,
  80     const base::Closure& callback,
  81     const base::Closure& error_callback) {
  82   if (adapter != adapter_.get()) {
  83     error_callback.Run();
  84     return;
  85   }
  86   DiscoverySessionMap::iterator iter =
  87       discovery_session_map_.find(extension_id);
  88   if (iter != discovery_session_map_.end() && iter->second->IsActive()) {
  89     DVLOG(1) << "An active discovery session exists for extension.";
  90     error_callback.Run();
  91     return;
  92   }
  93   adapter->StartDiscoverySession(
  94       base::Bind(&BluetoothEventRouter::OnStartDiscoverySession,
  95                  weak_ptr_factory_.GetWeakPtr(),
  96                  extension_id,
  97                  callback),
  98       error_callback);
  99 }
 100
 101 void BluetoothEventRouter::StopDiscoverySession(
 102     device::BluetoothAdapter* adapter,
 103     const std::string& extension_id,
 104     const base::Closure& callback,
 105     const base::Closure& error_callback) {
 106   if (adapter != adapter_.get()) {
 107     error_callback.Run();
 108     return;
 109   }
 110   DiscoverySessionMap::iterator iter =
 111       discovery_session_map_.find(extension_id);
 112   if (iter == discovery_session_map_.end() || !iter->second->IsActive()) {
 113     DVLOG(1) << "No active discovery session exists for extension.";
 114     error_callback.Run();
 115     return;
 116   }
 117   device::BluetoothDiscoverySession* session = iter->second;
 118   session->Stop(callback, error_callback);
 119 }
 120
 121 BluetoothApiPairingDelegate* BluetoothEventRouter::GetPairingDelegate(
 122     const std::string& extension_id) {
 123   return ContainsKey(pairing_delegate_map_, extension_id)
 124              ? pairing_delegate_map_[extension_id]
 125              : NULL;
 126 }
 127
 128 void BluetoothEventRouter::OnAdapterInitialized(
 129     const base::Closure& callback,
 130     scoped_refptr<device::BluetoothAdapter> adapter) {
 131   if (!adapter_.get()) {
 132     adapter_ = adapter;
 133     adapter_->AddObserver(this);
 134   }
 135
 136   callback.Run();
 137 }
 138
 139 void BluetoothEventRouter::MaybeReleaseAdapter() {
 140   if (adapter_.get() && num_event_listeners_ == 0 &&
 141       pairing_delegate_map_.empty()) {
 142     adapter_->RemoveObserver(this);
 143     adapter_ = NULL;
 144   }
 145 }
 146
 147 void BluetoothEventRouter::AddPairingDelegate(const std::string& extension_id) {
 148   if (!adapter_.get()) {
 149     base::Closure self_callback =
 150         base::Bind(&BluetoothEventRouter::AddPairingDelegate,
 151                    weak_ptr_factory_.GetWeakPtr(),
 152                    extension_id);
 153     GetAdapter(base::Bind(&BluetoothEventRouter::OnAdapterInitialized,
 154                           weak_ptr_factory_.GetWeakPtr(),
 155                           self_callback));
 156     return;
 157   }
 158
 159   if (!ContainsKey(pairing_delegate_map_, extension_id)) {
 160     BluetoothApiPairingDelegate* delegate =
 161         new BluetoothApiPairingDelegate(extension_id, browser_context_);
 162     DCHECK(adapter_.get());
 163     adapter_->AddPairingDelegate(
 164         delegate, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 165     pairing_delegate_map_[extension_id] = delegate;
 166   } else {
 167     LOG(ERROR) << "Pairing delegate already exists for extension. "
 168                << "There should be at most one onPairing listener.";
 169     NOTREACHED();
 170   }
 171 }
 172
 173 void BluetoothEventRouter::RemovePairingDelegate(
 174     const std::string& extension_id) {
 175   if (ContainsKey(pairing_delegate_map_, extension_id)) {
 176     BluetoothApiPairingDelegate* delegate = pairing_delegate_map_[extension_id];
 177     if (adapter_.get())
 178       adapter_->RemovePairingDelegate(delegate);
 179     pairing_delegate_map_.erase(extension_id);
 180     delete delegate;
 181     MaybeReleaseAdapter();
 182   }
 183 }
 184
 185 void BluetoothEventRouter::AdapterPresentChanged(
 186     device::BluetoothAdapter* adapter,
 187     bool present) {
 188   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 189   if (adapter != adapter_.get()) {
 190     DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
 191     return;
 192   }
 193   DispatchAdapterStateEvent();
 194 }
 195
 196 void BluetoothEventRouter::AdapterPoweredChanged(
 197     device::BluetoothAdapter* adapter,
 198     bool has_power) {
 199   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 200   if (adapter != adapter_.get()) {
 201     DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
 202     return;
 203   }
 204   DispatchAdapterStateEvent();
 205 }
 206
 207 void BluetoothEventRouter::AdapterDiscoveringChanged(
 208     device::BluetoothAdapter* adapter,
 209     bool discovering) {
 210   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 211   if (adapter != adapter_.get()) {
 212     DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
 213     return;
 214   }
 215
 216   if (!discovering) {
 217     // If any discovery sessions are inactive, clean them up.
 218     DiscoverySessionMap active_session_map;
 219     for (DiscoverySessionMap::iterator iter = discovery_session_map_.begin();
 220          iter != discovery_session_map_.end();
 221          ++iter) {
 222       device::BluetoothDiscoverySession* session = iter->second;
 223       if (session->IsActive()) {
 224         active_session_map[iter->first] = session;
 225         continue;
 226       }
 227       delete session;
 228     }
 229     discovery_session_map_.swap(active_session_map);
 230     MaybeReleaseAdapter();
 231   }
 232
 233   DispatchAdapterStateEvent();
 234 }
 235
 236 void BluetoothEventRouter::DeviceAdded(device::BluetoothAdapter* adapter,
 237                                        device::BluetoothDevice* device) {
 238   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 239   if (adapter != adapter_.get()) {
 240     DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
 241     return;
 242   }
 243
 244   DispatchDeviceEvent(bluetooth::OnDeviceAdded::kEventName, device);
 245 }
 246
 247 void BluetoothEventRouter::DeviceChanged(device::BluetoothAdapter* adapter,
 248                                          device::BluetoothDevice* device) {
 249   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 250   if (adapter != adapter_.get()) {
 251     DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
 252     return;
 253   }
 254
 255   DispatchDeviceEvent(bluetooth::OnDeviceChanged::kEventName, device);
 256 }
 257
 258 void BluetoothEventRouter::DeviceRemoved(device::BluetoothAdapter* adapter,
 259                                          device::BluetoothDevice* device) {
 260   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 261   if (adapter != adapter_.get()) {
 262     DVLOG(1) << "Ignoring event for adapter " << adapter->GetAddress();
 263     return;
 264   }
 265
 266   DispatchDeviceEvent(bluetooth::OnDeviceRemoved::kEventName, device);
 267 }
 268
 269 void BluetoothEventRouter::OnListenerAdded() {
 270   num_event_listeners_++;
 271   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 272   if (!adapter_.get()) {
 273     GetAdapter(base::Bind(&BluetoothEventRouter::OnAdapterInitialized,
 274                           weak_ptr_factory_.GetWeakPtr(),
 275                           base::Bind(&base::DoNothing)));
 276   }
 277 }
 278
 279 void BluetoothEventRouter::OnListenerRemoved() {
 280   if (num_event_listeners_ > 0)
 281     num_event_listeners_--;
 282   MaybeReleaseAdapter();
 283 }
 284
 285 void BluetoothEventRouter::DispatchAdapterStateEvent() {
 286   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 287   core_api::bluetooth::AdapterState state;
 288   PopulateAdapterState(*adapter_.get(), &state);
 289
 290   scoped_ptr<base::ListValue> args =
 291       bluetooth::OnAdapterStateChanged::Create(state);
 292   scoped_ptr<Event> event(new Event(
 293       bluetooth::OnAdapterStateChanged::kEventName,
 294       args.Pass()));
 295   EventRouter::Get(browser_context_)->BroadcastEvent(event.Pass());
 296 }
 297
 298 void BluetoothEventRouter::DispatchDeviceEvent(
 299     const std::string& event_name,
 300     device::BluetoothDevice* device) {
 301   bluetooth::Device extension_device;
 302   bluetooth::BluetoothDeviceToApiDevice(*device, &extension_device);
 303
 304   scoped_ptr<base::ListValue> args =
 305       bluetooth::OnDeviceAdded::Create(extension_device);
 306   scoped_ptr<Event> event(new Event(event_name, args.Pass()));
 307   EventRouter::Get(browser_context_)->BroadcastEvent(event.Pass());
 308 }
 309
 310 void BluetoothEventRouter::CleanUpForExtension(
 311     const std::string& extension_id) {
 312   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 313   RemovePairingDelegate(extension_id);
 314
 315   // Remove any discovery session initiated by the extension.
 316   DiscoverySessionMap::iterator session_iter =
 317       discovery_session_map_.find(extension_id);
 318   if (session_iter == discovery_session_map_.end())
 319     return;
 320   delete session_iter->second;
 321   discovery_session_map_.erase(session_iter);
 322 }
 323
 324 void BluetoothEventRouter::CleanUpAllExtensions() {
 325   for (DiscoverySessionMap::iterator it = discovery_session_map_.begin();
 326        it != discovery_session_map_.end();
 327        ++it) {
 328     delete it->second;
 329   }
 330   discovery_session_map_.clear();
 331
 332   PairingDelegateMap::iterator pairing_iter = pairing_delegate_map_.begin();
 333   while (pairing_iter != pairing_delegate_map_.end())
 334     RemovePairingDelegate(pairing_iter++->first);
 335 }
 336
 337 void BluetoothEventRouter::OnStartDiscoverySession(
 338     const std::string& extension_id,
 339     const base::Closure& callback,
 340     scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
 341   // Clean up any existing session instance for the extension.
 342   DiscoverySessionMap::iterator iter =
 343       discovery_session_map_.find(extension_id);
 344   if (iter != discovery_session_map_.end())
 345     delete iter->second;
 346   discovery_session_map_[extension_id] = discovery_session.release();
 347   callback.Run();
 348 }
 349
 350 void BluetoothEventRouter::Observe(
 351     int type,
 352     const content::NotificationSource& source,
 353     const content::NotificationDetails& details) {
 354   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 355   DCHECK_EQ(extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED, type);
 356   ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
 357   CleanUpForExtension(host->extension_id());
 358 }
 359
 360 void BluetoothEventRouter::OnExtensionUnloaded(
 361     content::BrowserContext* browser_context,
 362     const Extension* extension,
 363     UnloadedExtensionInfo::Reason reason) {
 364   CleanUpForExtension(extension->id());
 365 }
 366
 367 }  // namespace extensions