chromeos/dbus/bluetooth_manager_client.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 "chromeos/dbus/bluetooth_manager_client.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/logging.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "chromeos/dbus/bluetooth_property.h"
  13 #include "dbus/bus.h"
  14 #include "dbus/message.h"
  15 #include "dbus/object_path.h"
  16 #include "dbus/object_proxy.h"
  17 #include "third_party/cros_system_api/dbus/service_constants.h"
  18
  19 namespace chromeos {
  20
  21 BluetoothManagerClient::Properties::Properties(
  22     dbus::ObjectProxy* object_proxy,
  23     const PropertyChangedCallback& callback)
  24     : BluetoothPropertySet(object_proxy,
  25                            bluetooth_manager::kBluetoothManagerInterface,
  26                            callback) {
  27   RegisterProperty(bluetooth_manager::kAdaptersProperty, &adapters);
  28 }
  29
  30 BluetoothManagerClient::Properties::~Properties() {
  31 }
  32
  33
  34 // The BluetoothManagerClient implementation used in production.
  35 class BluetoothManagerClientImpl : public BluetoothManagerClient {
  36  public:
  37   explicit BluetoothManagerClientImpl(dbus::Bus* bus)
  38       : object_proxy_(NULL),
  39         weak_ptr_factory_(this) {
  40     DVLOG(1) << "Creating BluetoothManagerClientImpl";
  41
  42     // Create the object proxy.
  43     DCHECK(bus);
  44     object_proxy_ = bus->GetObjectProxy(
  45         bluetooth_manager::kBluetoothManagerServiceName,
  46         dbus::ObjectPath(bluetooth_manager::kBluetoothManagerServicePath));
  47
  48     object_proxy_->ConnectToSignal(
  49         bluetooth_manager::kBluetoothManagerInterface,
  50         bluetooth_manager::kAdapterAddedSignal,
  51         base::Bind(&BluetoothManagerClientImpl::AdapterAddedReceived,
  52                    weak_ptr_factory_.GetWeakPtr()),
  53         base::Bind(&BluetoothManagerClientImpl::AdapterAddedConnected,
  54                    weak_ptr_factory_.GetWeakPtr()));
  55
  56     object_proxy_->ConnectToSignal(
  57         bluetooth_manager::kBluetoothManagerInterface,
  58         bluetooth_manager::kAdapterRemovedSignal,
  59         base::Bind(&BluetoothManagerClientImpl::AdapterRemovedReceived,
  60                    weak_ptr_factory_.GetWeakPtr()),
  61         base::Bind(&BluetoothManagerClientImpl::AdapterRemovedConnected,
  62                    weak_ptr_factory_.GetWeakPtr()));
  63
  64     object_proxy_->ConnectToSignal(
  65         bluetooth_manager::kBluetoothManagerInterface,
  66         bluetooth_manager::kDefaultAdapterChangedSignal,
  67         base::Bind(&BluetoothManagerClientImpl::DefaultAdapterChangedReceived,
  68                    weak_ptr_factory_.GetWeakPtr()),
  69         base::Bind(&BluetoothManagerClientImpl::DefaultAdapterChangedConnected,
  70                    weak_ptr_factory_.GetWeakPtr()));
  71
  72     // Create the properties structure.
  73     properties_ = new Properties(
  74         object_proxy_,
  75         base::Bind(&BluetoothManagerClientImpl::OnPropertyChanged,
  76                    weak_ptr_factory_.GetWeakPtr()));
  77
  78     properties_->ConnectSignals();
  79     properties_->GetAll();
  80   }
  81
  82   virtual ~BluetoothManagerClientImpl() {
  83     // Clean up the Properties structure.
  84     delete properties_;
  85   }
  86
  87   // BluetoothManagerClient override.
  88   virtual void AddObserver(Observer* observer) OVERRIDE {
  89     DCHECK(observer);
  90     observers_.AddObserver(observer);
  91   }
  92
  93   // BluetoothManagerClient override.
  94   virtual void RemoveObserver(Observer* observer) OVERRIDE {
  95     DCHECK(observer);
  96     observers_.RemoveObserver(observer);
  97   }
  98
  99   // BluetoothManagerClient override.
 100   virtual Properties* GetProperties() OVERRIDE {
 101     return properties_;
 102   }
 103
 104   // BluetoothManagerClient override.
 105   virtual void DefaultAdapter(const AdapterCallback& callback) OVERRIDE {
 106     dbus::MethodCall method_call(
 107       bluetooth_manager::kBluetoothManagerInterface,
 108       bluetooth_manager::kDefaultAdapter);
 109
 110     DCHECK(object_proxy_);
 111     object_proxy_->CallMethod(
 112       &method_call,
 113       dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 114       base::Bind(&BluetoothManagerClientImpl::OnDefaultAdapter,
 115                  weak_ptr_factory_.GetWeakPtr(), callback));
 116   }
 117
 118   // BluetoothManagerClient override.
 119   virtual void FindAdapter(const std::string& address,
 120                            const AdapterCallback& callback) OVERRIDE {
 121     dbus::MethodCall method_call(
 122       bluetooth_manager::kBluetoothManagerInterface,
 123       bluetooth_manager::kFindAdapter);
 124
 125     dbus::MessageWriter writer(&method_call);
 126     writer.AppendString(address);
 127
 128     DCHECK(object_proxy_);
 129     object_proxy_->CallMethod(
 130       &method_call,
 131       dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 132       base::Bind(&BluetoothManagerClientImpl::OnFindAdapter,
 133                  weak_ptr_factory_.GetWeakPtr(), callback));
 134   }
 135
 136  private:
 137   // Called by BluetoothPropertySet when a property value is changed,
 138   // either by result of a signal or response to a GetAll() or Get()
 139   // call. Informs observers.
 140   void OnPropertyChanged(const std::string& property_name) {
 141     FOR_EACH_OBSERVER(BluetoothManagerClient::Observer, observers_,
 142                       ManagerPropertyChanged(property_name));
 143   }
 144
 145   // Called by dbus:: when an AdapterAdded signal is received.
 146   void AdapterAddedReceived(dbus::Signal* signal) {
 147     DCHECK(signal);
 148     dbus::MessageReader reader(signal);
 149     dbus::ObjectPath object_path;
 150     if (!reader.PopObjectPath(&object_path)) {
 151       LOG(WARNING) << "AdapterAdded signal has incorrect parameters: "
 152                    << signal->ToString();
 153       return;
 154     }
 155
 156     DVLOG(1) << "Adapter added: " << object_path.value();
 157     FOR_EACH_OBSERVER(Observer, observers_, AdapterAdded(object_path));
 158   }
 159
 160   // Called by dbus:: when the AdapterAdded signal is initially connected.
 161   void AdapterAddedConnected(const std::string& interface_name,
 162                              const std::string& signal_name,
 163                              bool success) {
 164     LOG_IF(WARNING, !success) << "Failed to connect to AdapterAdded signal.";
 165   }
 166
 167   // Called by dbus:: when an AdapterRemoved signal is received.
 168   void AdapterRemovedReceived(dbus::Signal* signal) {
 169     DCHECK(signal);
 170     dbus::MessageReader reader(signal);
 171     dbus::ObjectPath object_path;
 172     if (!reader.PopObjectPath(&object_path)) {
 173       LOG(WARNING) << "AdapterRemoved signal has incorrect parameters: "
 174                    << signal->ToString();
 175       return;
 176     }
 177
 178     DVLOG(1) << "Adapter removed: " << object_path.value();
 179     FOR_EACH_OBSERVER(Observer, observers_, AdapterRemoved(object_path));
 180   }
 181
 182   // Called by dbus:: when the AdapterRemoved signal is initially connected.
 183   void AdapterRemovedConnected(const std::string& interface_name,
 184                                const std::string& signal_name,
 185                                bool success) {
 186     LOG_IF(WARNING, !success) << "Failed to connect to AdapterRemoved signal.";
 187   }
 188
 189   // Called by dbus:: when a DefaultAdapterChanged signal is received.
 190   void DefaultAdapterChangedReceived(dbus::Signal* signal) {
 191     DCHECK(signal);
 192     dbus::MessageReader reader(signal);
 193     dbus::ObjectPath object_path;
 194     if (!reader.PopObjectPath(&object_path)) {
 195       LOG(WARNING) << "DefaultAdapterChanged signal has incorrect parameters: "
 196                    << signal->ToString();
 197       return;
 198     }
 199
 200     DVLOG(1) << "Default adapter changed: " << object_path.value();
 201     FOR_EACH_OBSERVER(Observer, observers_, DefaultAdapterChanged(object_path));
 202   }
 203
 204   // Called by dbus:: when the DefaultAdapterChanged signal is initially
 205   // connected.
 206   void DefaultAdapterChangedConnected(const std::string& interface_name,
 207                                       const std::string& signal_name,
 208                                       bool success) {
 209     LOG_IF(WARNING, !success)
 210         << "Failed to connect to DefaultAdapterChanged signal.";
 211   }
 212
 213   // Called when a response for DefaultAdapter() is received.
 214   void OnDefaultAdapter(const AdapterCallback& callback,
 215                         dbus::Response* response) {
 216     // Parse response.
 217     bool success = false;
 218     dbus::ObjectPath object_path;
 219     if (response != NULL) {
 220       dbus::MessageReader reader(response);
 221       if (!reader.PopObjectPath(&object_path)) {
 222         LOG(WARNING) << "DefaultAdapter response has incorrect parameters: "
 223                      << response->ToString();
 224       } else {
 225         success = true;
 226       }
 227     } else {
 228       LOG(WARNING) << "Failed to get default adapter.";
 229     }
 230
 231     // Notify client.
 232     callback.Run(object_path, success);
 233   }
 234
 235   // Called when a response for FindAdapter() is received.
 236   void OnFindAdapter(const AdapterCallback& callback,
 237                      dbus::Response* response) {
 238     // Parse response.
 239     bool success = false;
 240     dbus::ObjectPath object_path;
 241     if (response != NULL) {
 242       dbus::MessageReader reader(response);
 243       if (!reader.PopObjectPath(&object_path)) {
 244         LOG(WARNING) << "FindAdapter response has incorrect parameters: "
 245                      << response->ToString();
 246       } else {
 247         success = true;
 248       }
 249     } else {
 250       LOG(WARNING) << "Failed to find adapter.";
 251     }
 252
 253     // Notify client.
 254     callback.Run(object_path, success);
 255   }
 256
 257   // D-Bus proxy for BlueZ Manager interface.
 258   dbus::ObjectProxy* object_proxy_;
 259
 260   // Properties for BlueZ Manager interface.
 261   Properties* properties_;
 262
 263   // List of observers interested in event notifications from us.
 264   ObserverList<Observer> observers_;
 265
 266   // Weak pointer factory for generating 'this' pointers that might live longer
 267   // than we do.
 268   // Note: This should remain the last member so it'll be destroyed and
 269   // invalidate its weak pointers before any other members are destroyed.
 270   base::WeakPtrFactory<BluetoothManagerClientImpl> weak_ptr_factory_;
 271
 272   DISALLOW_COPY_AND_ASSIGN(BluetoothManagerClientImpl);
 273 };
 274
 275 // The BluetoothManagerClient implementation used on Linux desktop, which does
 276 // nothing.
 277 class BluetoothManagerClientStubImpl : public BluetoothManagerClient {
 278  public:
 279   struct Properties : public BluetoothManagerClient::Properties {
 280     explicit Properties(const PropertyChangedCallback& callback)
 281         : BluetoothManagerClient::Properties(NULL, callback) {
 282     }
 283
 284     virtual ~Properties() {
 285     }
 286
 287     virtual void Get(dbus::PropertyBase* property,
 288                      dbus::PropertySet::GetCallback callback) OVERRIDE {
 289       VLOG(1) << "Get " << property->name();
 290       callback.Run(false);
 291     }
 292
 293     virtual void GetAll() OVERRIDE {
 294       VLOG(1) << "GetAll";
 295     }
 296
 297     virtual void Set(dbus::PropertyBase* property,
 298                      dbus::PropertySet::SetCallback callback) OVERRIDE {
 299       VLOG(1) << "Set " << property->name();
 300       callback.Run(false);
 301     }
 302   };
 303
 304   BluetoothManagerClientStubImpl() {
 305     properties_.reset(new Properties(base::Bind(
 306         &BluetoothManagerClientStubImpl::OnPropertyChanged,
 307         base::Unretained(this))));
 308
 309     std::vector<dbus::ObjectPath> adapters;
 310     adapters.push_back(dbus::ObjectPath("/fake/hci0"));
 311     properties_->adapters.ReplaceValue(adapters);
 312   }
 313
 314   // BluetoothManagerClient override.
 315   virtual void AddObserver(Observer* observer) OVERRIDE {
 316     observers_.AddObserver(observer);
 317   }
 318
 319   // BluetoothManagerClient override.
 320   virtual void RemoveObserver(Observer* observer) OVERRIDE {
 321     observers_.RemoveObserver(observer);
 322   }
 323
 324   // BluetoothManagerClient override.
 325   virtual Properties* GetProperties() OVERRIDE {
 326     VLOG(1) << "GetProperties";
 327     return properties_.get();
 328   }
 329
 330   // BluetoothManagerClient override.
 331   virtual void DefaultAdapter(const AdapterCallback& callback) OVERRIDE {
 332     VLOG(1) << "DefaultAdapter.";
 333     callback.Run(dbus::ObjectPath("/fake/hci0"), true);
 334   }
 335
 336   // BluetoothManagerClient override.
 337   virtual void FindAdapter(const std::string& address,
 338                            const AdapterCallback& callback) OVERRIDE {
 339     VLOG(1) << "FindAdapter: " << address;
 340     if (address == "hci0")
 341       callback.Run(dbus::ObjectPath("/fake/hci0"), true);
 342     else
 343       callback.Run(dbus::ObjectPath(), false);
 344   }
 345
 346  private:
 347   void OnPropertyChanged(const std::string& property_name) {
 348     FOR_EACH_OBSERVER(BluetoothManagerClient::Observer, observers_,
 349                       ManagerPropertyChanged(property_name));
 350   }
 351
 352   // List of observers interested in event notifications from us.
 353   ObserverList<Observer> observers_;
 354
 355   // Static properties we return.
 356   scoped_ptr<Properties> properties_;
 357 };
 358
 359 BluetoothManagerClient::BluetoothManagerClient() {
 360 }
 361
 362 BluetoothManagerClient::~BluetoothManagerClient() {
 363 }
 364
 365 BluetoothManagerClient* BluetoothManagerClient::Create(
 366     DBusClientImplementationType type,
 367     dbus::Bus* bus) {
 368   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
 369     return new BluetoothManagerClientImpl(bus);
 370   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
 371   return new BluetoothManagerClientStubImpl();
 372 }
 373
 374 }  // namespace chromeos