chromeos/dbus/bluetooth_adapter_client.cc

   1 // Copyright 2013 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_adapter_client.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "dbus/bus.h"
  10 #include "dbus/message.h"
  11 #include "dbus/object_manager.h"
  12 #include "dbus/object_path.h"
  13 #include "dbus/object_proxy.h"
  14 #include "third_party/cros_system_api/dbus/service_constants.h"
  15
  16 namespace chromeos {
  17
  18 const char BluetoothAdapterClient::kNoResponseError[] =
  19     "org.chromium.Error.NoResponse";
  20 const char BluetoothAdapterClient::kUnknownAdapterError[] =
  21     "org.chromium.Error.UnknownAdapter";
  22
  23 BluetoothAdapterClient::Properties::Properties(
  24     dbus::ObjectProxy* object_proxy,
  25     const std::string& interface_name,
  26     const PropertyChangedCallback& callback)
  27     : dbus::PropertySet(object_proxy, interface_name, callback) {
  28   RegisterProperty(bluetooth_adapter::kAddressProperty, &address);
  29   RegisterProperty(bluetooth_adapter::kNameProperty, &name);
  30   RegisterProperty(bluetooth_adapter::kAliasProperty, &alias);
  31   RegisterProperty(bluetooth_adapter::kClassProperty, &bluetooth_class);
  32   RegisterProperty(bluetooth_adapter::kPoweredProperty, &powered);
  33   RegisterProperty(bluetooth_adapter::kDiscoverableProperty, &discoverable);
  34   RegisterProperty(bluetooth_adapter::kPairableProperty, &pairable);
  35   RegisterProperty(bluetooth_adapter::kPairableTimeoutProperty,
  36                    &pairable_timeout);
  37   RegisterProperty(bluetooth_adapter::kDiscoverableTimeoutProperty,
  38                    &discoverable_timeout);
  39   RegisterProperty(bluetooth_adapter::kDiscoveringProperty, &discovering);
  40   RegisterProperty(bluetooth_adapter::kUUIDsProperty, &uuids);
  41   RegisterProperty(bluetooth_adapter::kModaliasProperty, &modalias);
  42 }
  43
  44 BluetoothAdapterClient::Properties::~Properties() {
  45 }
  46
  47
  48 // The BluetoothAdapterClient implementation used in production.
  49 class BluetoothAdapterClientImpl
  50     : public BluetoothAdapterClient,
  51       public dbus::ObjectManager::Interface {
  52  public:
  53   BluetoothAdapterClientImpl() : weak_ptr_factory_(this) {}
  54
  55   virtual ~BluetoothAdapterClientImpl() {
  56     object_manager_->UnregisterInterface(
  57         bluetooth_adapter::kBluetoothAdapterInterface);
  58   }
  59
  60   // BluetoothAdapterClient override.
  61   virtual void AddObserver(BluetoothAdapterClient::Observer* observer)
  62       OVERRIDE {
  63     DCHECK(observer);
  64     observers_.AddObserver(observer);
  65   }
  66
  67   // BluetoothAdapterClient override.
  68   virtual void RemoveObserver(BluetoothAdapterClient::Observer* observer)
  69       OVERRIDE {
  70     DCHECK(observer);
  71     observers_.RemoveObserver(observer);
  72   }
  73
  74   // Returns the list of adapter object paths known to the system.
  75   virtual std::vector<dbus::ObjectPath> GetAdapters() OVERRIDE {
  76     return object_manager_->GetObjectsWithInterface(
  77         bluetooth_adapter::kBluetoothAdapterInterface);
  78   }
  79
  80   // dbus::ObjectManager::Interface override.
  81   virtual dbus::PropertySet* CreateProperties(
  82       dbus::ObjectProxy* object_proxy,
  83       const dbus::ObjectPath& object_path,
  84       const std::string& interface_name) OVERRIDE {
  85     Properties* properties = new Properties(
  86         object_proxy,
  87         interface_name,
  88         base::Bind(&BluetoothAdapterClientImpl::OnPropertyChanged,
  89                    weak_ptr_factory_.GetWeakPtr(),
  90                    object_path));
  91     return static_cast<dbus::PropertySet*>(properties);
  92   }
  93
  94   // BluetoothAdapterClient override.
  95   virtual Properties* GetProperties(const dbus::ObjectPath& object_path)
  96       OVERRIDE {
  97     return static_cast<Properties*>(
  98         object_manager_->GetProperties(
  99             object_path,
 100             bluetooth_adapter::kBluetoothAdapterInterface));
 101   }
 102
 103   // BluetoothAdapterClient override.
 104   virtual void StartDiscovery(const dbus::ObjectPath& object_path,
 105                               const base::Closure& callback,
 106                               const ErrorCallback& error_callback) OVERRIDE {
 107     dbus::MethodCall method_call(
 108         bluetooth_adapter::kBluetoothAdapterInterface,
 109         bluetooth_adapter::kStartDiscovery);
 110
 111     dbus::ObjectProxy* object_proxy =
 112         object_manager_->GetObjectProxy(object_path);
 113     if (!object_proxy) {
 114       error_callback.Run(kUnknownAdapterError, "");
 115       return;
 116     }
 117
 118     object_proxy->CallMethodWithErrorCallback(
 119         &method_call,
 120         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 121         base::Bind(&BluetoothAdapterClientImpl::OnSuccess,
 122                    weak_ptr_factory_.GetWeakPtr(), callback),
 123         base::Bind(&BluetoothAdapterClientImpl::OnError,
 124                    weak_ptr_factory_.GetWeakPtr(), error_callback));
 125   }
 126
 127   // BluetoothAdapterClient override.
 128   virtual void StopDiscovery(const dbus::ObjectPath& object_path,
 129                              const base::Closure& callback,
 130                              const ErrorCallback& error_callback) OVERRIDE {
 131     dbus::MethodCall method_call(
 132         bluetooth_adapter::kBluetoothAdapterInterface,
 133         bluetooth_adapter::kStopDiscovery);
 134
 135     dbus::ObjectProxy* object_proxy =
 136         object_manager_->GetObjectProxy(object_path);
 137     if (!object_proxy) {
 138       error_callback.Run(kUnknownAdapterError, "");
 139       return;
 140     }
 141
 142     object_proxy->CallMethodWithErrorCallback(
 143         &method_call,
 144         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 145         base::Bind(&BluetoothAdapterClientImpl::OnSuccess,
 146                    weak_ptr_factory_.GetWeakPtr(), callback),
 147         base::Bind(&BluetoothAdapterClientImpl::OnError,
 148                    weak_ptr_factory_.GetWeakPtr(), error_callback));
 149   }
 150
 151   // BluetoothAdapterClient override.
 152   virtual void RemoveDevice(const dbus::ObjectPath& object_path,
 153                             const dbus::ObjectPath& device_path,
 154                             const base::Closure& callback,
 155                             const ErrorCallback& error_callback) OVERRIDE {
 156     dbus::MethodCall method_call(
 157         bluetooth_adapter::kBluetoothAdapterInterface,
 158         bluetooth_adapter::kRemoveDevice);
 159
 160     dbus::MessageWriter writer(&method_call);
 161     writer.AppendObjectPath(device_path);
 162
 163     dbus::ObjectProxy* object_proxy =
 164         object_manager_->GetObjectProxy(object_path);
 165     if (!object_proxy) {
 166       error_callback.Run(kUnknownAdapterError, "");
 167       return;
 168     }
 169
 170     object_proxy->CallMethodWithErrorCallback(
 171         &method_call,
 172         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 173         base::Bind(&BluetoothAdapterClientImpl::OnSuccess,
 174                    weak_ptr_factory_.GetWeakPtr(), callback),
 175         base::Bind(&BluetoothAdapterClientImpl::OnError,
 176                    weak_ptr_factory_.GetWeakPtr(), error_callback));
 177   }
 178
 179  protected:
 180   virtual void Init(dbus::Bus* bus) OVERRIDE {
 181     object_manager_ = bus->GetObjectManager(
 182         bluetooth_object_manager::kBluetoothObjectManagerServiceName,
 183         dbus::ObjectPath(
 184             bluetooth_object_manager::kBluetoothObjectManagerServicePath));
 185     object_manager_->RegisterInterface(
 186         bluetooth_adapter::kBluetoothAdapterInterface, this);
 187   }
 188
 189  private:
 190   // Called by dbus::ObjectManager when an object with the adapter interface
 191   // is created. Informs observers.
 192   virtual void ObjectAdded(const dbus::ObjectPath& object_path,
 193                            const std::string& interface_name) OVERRIDE {
 194     FOR_EACH_OBSERVER(BluetoothAdapterClient::Observer, observers_,
 195                       AdapterAdded(object_path));
 196   }
 197
 198   // Called by dbus::ObjectManager when an object with the adapter interface
 199   // is removed. Informs observers.
 200   virtual void ObjectRemoved(const dbus::ObjectPath& object_path,
 201                              const std::string& interface_name) OVERRIDE {
 202     FOR_EACH_OBSERVER(BluetoothAdapterClient::Observer, observers_,
 203                       AdapterRemoved(object_path));
 204   }
 205
 206   // Called by dbus::PropertySet when a property value is changed,
 207   // either by result of a signal or response to a GetAll() or Get()
 208   // call. Informs observers.
 209   void OnPropertyChanged(const dbus::ObjectPath& object_path,
 210                          const std::string& property_name) {
 211     FOR_EACH_OBSERVER(BluetoothAdapterClient::Observer, observers_,
 212                       AdapterPropertyChanged(object_path, property_name));
 213   }
 214
 215   // Called when a response for successful method call is received.
 216   void OnSuccess(const base::Closure& callback,
 217                  dbus::Response* response) {
 218     DCHECK(response);
 219     callback.Run();
 220   }
 221
 222   // Called when a response for a failed method call is received.
 223   void OnError(const ErrorCallback& error_callback,
 224                dbus::ErrorResponse* response) {
 225     // Error response has optional error message argument.
 226     std::string error_name;
 227     std::string error_message;
 228     if (response) {
 229       dbus::MessageReader reader(response);
 230       error_name = response->GetErrorName();
 231       reader.PopString(&error_message);
 232     } else {
 233       error_name = kNoResponseError;
 234       error_message = "";
 235     }
 236     error_callback.Run(error_name, error_message);
 237   }
 238
 239   dbus::ObjectManager* object_manager_;
 240
 241   // List of observers interested in event notifications from us.
 242   ObserverList<BluetoothAdapterClient::Observer> observers_;
 243
 244   // Weak pointer factory for generating 'this' pointers that might live longer
 245   // than we do.
 246   // Note: This should remain the last member so it'll be destroyed and
 247   // invalidate its weak pointers before any other members are destroyed.
 248   base::WeakPtrFactory<BluetoothAdapterClientImpl>
 249       weak_ptr_factory_;
 250
 251   DISALLOW_COPY_AND_ASSIGN(BluetoothAdapterClientImpl);
 252 };
 253
 254 BluetoothAdapterClient::BluetoothAdapterClient() {
 255 }
 256
 257 BluetoothAdapterClient::~BluetoothAdapterClient() {
 258 }
 259
 260 BluetoothAdapterClient* BluetoothAdapterClient::Create() {
 261   return new BluetoothAdapterClientImpl;
 262 }
 263
 264 }  // namespace chromeos