Home | History | Annotate | Download | only in dbus 
      1 // Copyright 2014 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_gatt_descriptor_service_provider.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/logging.h"
      9 #include "base/memory/weak_ptr.h"
     10 #include "base/strings/string_util.h"
     11 #include "base/sys_info.h"
     12 #include "base/threading/platform_thread.h"
     13 #include "chromeos/dbus/fake_bluetooth_gatt_descriptor_service_provider.h"
     14 #include "dbus/exported_object.h"
     15 #include "dbus/message.h"
     16 #include "third_party/cros_system_api/dbus/service_constants.h"
     17 
     18 namespace chromeos {
     19 namespace {
     20 const char kErrorInvalidArgs[] =
     21     "org.freedesktop.DBus.Error.InvalidArgs";
     22 const char kErrorPropertyReadOnly[] =
     23     "org.freedesktop.DBus.Error.PropertyReadOnly";
     24 const char kErrorFailed[] =
     25     "org.freedesktop.DBus.Error.Failed";
     26 }  // namespace
     27 
     28 // The BluetoothGattDescriptorServiceProvider implementation used in production.
     29 class BluetoothGattDescriptorServiceProviderImpl
     30     : public BluetoothGattDescriptorServiceProvider {
     31  public:
     32   BluetoothGattDescriptorServiceProviderImpl(
     33       dbus::Bus* bus,
     34       const dbus::ObjectPath& object_path,
     35       Delegate* delegate,
     36       const std::string& uuid,
     37       const std::vector<std::string>& permissions,
     38       const dbus::ObjectPath& characteristic_path)
     39       : origin_thread_id_(base::PlatformThread::CurrentId()),
     40         uuid_(uuid),
     41         bus_(bus),
     42         delegate_(delegate),
     43         object_path_(object_path),
     44         characteristic_path_(characteristic_path),
     45         weak_ptr_factory_(this) {
     46     VLOG(1) << "Created Bluetooth GATT characteristic descriptor: "
     47             << object_path.value() << " UUID: " << uuid;
     48     DCHECK(bus_);
     49     DCHECK(delegate_);
     50     DCHECK(!uuid_.empty());
     51     DCHECK(object_path_.IsValid());
     52     DCHECK(characteristic_path_.IsValid());
     53     DCHECK(StartsWithASCII(
     54         object_path_.value(), characteristic_path_.value() + "/", true));
     55 
     56     exported_object_ = bus_->GetExportedObject(object_path_);
     57 
     58     exported_object_->ExportMethod(
     59         dbus::kDBusPropertiesInterface,
     60         dbus::kDBusPropertiesGet,
     61         base::Bind(&BluetoothGattDescriptorServiceProviderImpl::Get,
     62                    weak_ptr_factory_.GetWeakPtr()),
     63         base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnExported,
     64                    weak_ptr_factory_.GetWeakPtr()));
     65 
     66     exported_object_->ExportMethod(
     67         dbus::kDBusPropertiesInterface,
     68         dbus::kDBusPropertiesSet,
     69         base::Bind(&BluetoothGattDescriptorServiceProviderImpl::Set,
     70                    weak_ptr_factory_.GetWeakPtr()),
     71         base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnExported,
     72                    weak_ptr_factory_.GetWeakPtr()));
     73 
     74     exported_object_->ExportMethod(
     75         dbus::kDBusPropertiesInterface,
     76         dbus::kDBusPropertiesGetAll,
     77         base::Bind(&BluetoothGattDescriptorServiceProviderImpl::GetAll,
     78                    weak_ptr_factory_.GetWeakPtr()),
     79         base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnExported,
     80                    weak_ptr_factory_.GetWeakPtr()));
     81   }
     82 
     83   virtual ~BluetoothGattDescriptorServiceProviderImpl() {
     84     VLOG(1) << "Cleaning up Bluetooth GATT characteristic descriptor: "
     85             << object_path_.value();
     86     bus_->UnregisterExportedObject(object_path_);
     87   }
     88 
     89   // BluetoothGattDescriptorServiceProvider override.
     90   virtual void SendValueChanged(const std::vector<uint8>& value) OVERRIDE {
     91     VLOG(2) << "Emitting a PropertiesChanged signal for descriptor value.";
     92     dbus::Signal signal(
     93         dbus::kDBusPropertiesInterface,
     94         dbus::kDBusPropertiesChangedSignal);
     95     dbus::MessageWriter writer(&signal);
     96     dbus::MessageWriter array_writer(NULL);
     97     dbus::MessageWriter dict_entry_writer(NULL);
     98     dbus::MessageWriter variant_writer(NULL);
     99 
    100     // interface_name
    101     writer.AppendString(
    102         bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface);
    103 
    104     // changed_properties
    105     writer.OpenArray("{sv}", &array_writer);
    106     array_writer.OpenDictEntry(&dict_entry_writer);
    107     dict_entry_writer.AppendString(bluetooth_gatt_descriptor::kValueProperty);
    108     dict_entry_writer.OpenVariant("ay", &variant_writer);
    109     variant_writer.AppendArrayOfBytes(value.data(), value.size());
    110     dict_entry_writer.CloseContainer(&variant_writer);
    111     array_writer.CloseContainer(&dict_entry_writer);
    112     writer.CloseContainer(&array_writer);
    113 
    114     // invalidated_properties.
    115     writer.OpenArray("s", &array_writer);
    116     writer.CloseContainer(&array_writer);
    117 
    118     exported_object_->SendSignal(&signal);
    119   }
    120 
    121  private:
    122   // Returns true if the current thread is on the origin thread.
    123   bool OnOriginThread() {
    124     return base::PlatformThread::CurrentId() == origin_thread_id_;
    125   }
    126 
    127   // Called by dbus:: when the Bluetooth daemon fetches a single property of
    128   // the descriptor.
    129   void Get(dbus::MethodCall* method_call,
    130            dbus::ExportedObject::ResponseSender response_sender) {
    131     VLOG(2) << "BluetoothGattDescriptorServiceProvider::Get: "
    132             << object_path_.value();
    133     DCHECK(OnOriginThread());
    134 
    135     dbus::MessageReader reader(method_call);
    136 
    137     std::string interface_name;
    138     std::string property_name;
    139     if (!reader.PopString(&interface_name) ||
    140         !reader.PopString(&property_name) ||
    141         reader.HasMoreData()) {
    142       scoped_ptr<dbus::ErrorResponse> error_response =
    143           dbus::ErrorResponse::FromMethodCall(
    144               method_call, kErrorInvalidArgs, "Expected 'ss'.");
    145       response_sender.Run(error_response.PassAs<dbus::Response>());
    146       return;
    147     }
    148 
    149     // Only the GATT descriptor interface is supported.
    150     if (interface_name !=
    151         bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface) {
    152       scoped_ptr<dbus::ErrorResponse> error_response =
    153           dbus::ErrorResponse::FromMethodCall(
    154               method_call, kErrorInvalidArgs,
    155               "No such interface: '" + interface_name + "'.");
    156       response_sender.Run(error_response.PassAs<dbus::Response>());
    157       return;
    158     }
    159 
    160     // If getting the "Value" property, obtain the value from the delegate.
    161     if (property_name == bluetooth_gatt_descriptor::kValueProperty) {
    162       DCHECK(delegate_);
    163       delegate_->GetDescriptorValue(
    164           base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnGet,
    165                      weak_ptr_factory_.GetWeakPtr(),
    166                      method_call, response_sender),
    167           base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnFailure,
    168                      weak_ptr_factory_.GetWeakPtr(),
    169                      method_call, response_sender));
    170       return;
    171     }
    172 
    173     scoped_ptr<dbus::Response> response =
    174         dbus::Response::FromMethodCall(method_call);
    175     dbus::MessageWriter writer(response.get());
    176     dbus::MessageWriter variant_writer(NULL);
    177 
    178     // TODO(armansito): Process the "Permissions" property below.
    179     if (property_name == bluetooth_gatt_descriptor::kUUIDProperty) {
    180       writer.OpenVariant("s", &variant_writer);
    181       variant_writer.AppendString(uuid_);
    182       writer.CloseContainer(&variant_writer);
    183     } else if (property_name ==
    184                bluetooth_gatt_descriptor::kCharacteristicProperty) {
    185       writer.OpenVariant("o", &variant_writer);
    186       variant_writer.AppendObjectPath(characteristic_path_);
    187       writer.CloseContainer(&variant_writer);
    188     } else {
    189       response = dbus::ErrorResponse::FromMethodCall(
    190           method_call, kErrorInvalidArgs,
    191           "No such property: '" + property_name + "'.")
    192           .PassAs<dbus::Response>();
    193     }
    194 
    195     response_sender.Run(response.Pass());
    196   }
    197 
    198   // Called by dbus:: when the Bluetooth daemon sets a single property of the
    199   // descriptor.
    200   void Set(dbus::MethodCall* method_call,
    201            dbus::ExportedObject::ResponseSender response_sender) {
    202     VLOG(2) << "BluetoothGattDescriptorServiceProvider::Set: "
    203             << object_path_.value();
    204     DCHECK(OnOriginThread());
    205 
    206     dbus::MessageReader reader(method_call);
    207 
    208     std::string interface_name;
    209     std::string property_name;
    210     dbus::MessageReader variant_reader(NULL);
    211     if (!reader.PopString(&interface_name) ||
    212         !reader.PopString(&property_name) ||
    213         !reader.PopVariant(&variant_reader) ||
    214         reader.HasMoreData()) {
    215       scoped_ptr<dbus::ErrorResponse> error_response =
    216           dbus::ErrorResponse::FromMethodCall(
    217               method_call, kErrorInvalidArgs, "Expected 'ssv'.");
    218       response_sender.Run(error_response.PassAs<dbus::Response>());
    219       return;
    220     }
    221 
    222     // Only the GATT descriptor interface is allowed.
    223     if (interface_name !=
    224         bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface) {
    225       scoped_ptr<dbus::ErrorResponse> error_response =
    226           dbus::ErrorResponse::FromMethodCall(
    227               method_call, kErrorInvalidArgs,
    228               "No such interface: '" + interface_name + "'.");
    229       response_sender.Run(error_response.PassAs<dbus::Response>());
    230       return;
    231     }
    232 
    233     // Only the "Value" property is writeable.
    234     if (property_name != bluetooth_gatt_descriptor::kValueProperty) {
    235       std::string error_name;
    236       std::string error_message;
    237       if (property_name == bluetooth_gatt_descriptor::kUUIDProperty ||
    238           property_name == bluetooth_gatt_descriptor::kCharacteristicProperty) {
    239         error_name = kErrorPropertyReadOnly;
    240         error_message = "Read-only property: '" + property_name + "'.";
    241       } else {
    242         error_name = kErrorInvalidArgs;
    243         error_message = "No such property: '" + property_name + "'.";
    244       }
    245       scoped_ptr<dbus::ErrorResponse> error_response =
    246           dbus::ErrorResponse::FromMethodCall(
    247               method_call, error_name, error_message);
    248       response_sender.Run(error_response.PassAs<dbus::Response>());
    249       return;
    250     }
    251 
    252     // Obtain the value.
    253     const uint8* bytes = NULL;
    254     size_t length = 0;
    255     if (!variant_reader.PopArrayOfBytes(&bytes, &length)) {
    256       scoped_ptr<dbus::ErrorResponse> error_response =
    257           dbus::ErrorResponse::FromMethodCall(
    258               method_call, kErrorInvalidArgs,
    259               "Property '" + property_name + "' has type 'ay'.");
    260       response_sender.Run(error_response.PassAs<dbus::Response>());
    261       return;
    262     }
    263 
    264     // Pass the set request onto the delegate.
    265     std::vector<uint8> value(bytes, bytes + length);
    266     DCHECK(delegate_);
    267     delegate_->SetDescriptorValue(
    268         value,
    269         base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnSet,
    270                    weak_ptr_factory_.GetWeakPtr(),
    271                    method_call, response_sender),
    272         base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnFailure,
    273                    weak_ptr_factory_.GetWeakPtr(),
    274                    method_call, response_sender));
    275   }
    276 
    277   // Called by dbus:: when the Bluetooth daemon fetches all properties of the
    278   // descriptor.
    279   void GetAll(dbus::MethodCall* method_call,
    280               dbus::ExportedObject::ResponseSender response_sender) {
    281     VLOG(2) << "BluetoothGattDescriptorServiceProvider::GetAll: "
    282             << object_path_.value();
    283     DCHECK(OnOriginThread());
    284 
    285     dbus::MessageReader reader(method_call);
    286 
    287     std::string interface_name;
    288     if (!reader.PopString(&interface_name) || reader.HasMoreData()) {
    289       scoped_ptr<dbus::ErrorResponse> error_response =
    290           dbus::ErrorResponse::FromMethodCall(
    291               method_call, kErrorInvalidArgs, "Expected 's'.");
    292       response_sender.Run(error_response.PassAs<dbus::Response>());
    293       return;
    294     }
    295 
    296     // Only the GATT descriptor interface is supported.
    297     if (interface_name !=
    298         bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface) {
    299       scoped_ptr<dbus::ErrorResponse> error_response =
    300           dbus::ErrorResponse::FromMethodCall(
    301               method_call, kErrorInvalidArgs,
    302               "No such interface: '" + interface_name + "'.");
    303       response_sender.Run(error_response.PassAs<dbus::Response>());
    304       return;
    305     }
    306 
    307     // Try to obtain the value from the delegate. We will construct the
    308     // response in the success callback.
    309     DCHECK(delegate_);
    310     delegate_->GetDescriptorValue(
    311         base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnGetAll,
    312                    weak_ptr_factory_.GetWeakPtr(),
    313                    method_call, response_sender),
    314         base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnFailure,
    315                    weak_ptr_factory_.GetWeakPtr(),
    316                    method_call, response_sender));
    317   }
    318 
    319   // Called by dbus:: when a method is exported.
    320   void OnExported(const std::string& interface_name,
    321                   const std::string& method_name,
    322                   bool success) {
    323     LOG_IF(WARNING, !success) << "Failed to export "
    324                               << interface_name << "." << method_name;
    325   }
    326 
    327   // Called by the Delegate in response to a method to call to get all
    328   // properties, in which the delegate has successfully returned the
    329   // descriptor value.
    330   void OnGetAll(dbus::MethodCall* method_call,
    331                 dbus::ExportedObject::ResponseSender response_sender,
    332                 const std::vector<uint8>& value) {
    333     VLOG(2) << "Descriptor value obtained from delegate. Responding to "
    334             << "GetAll.";
    335 
    336     scoped_ptr<dbus::Response> response =
    337         dbus::Response::FromMethodCall(method_call);
    338     dbus::MessageWriter writer(response.get());
    339     dbus::MessageWriter array_writer(NULL);
    340     dbus::MessageWriter dict_entry_writer(NULL);
    341     dbus::MessageWriter variant_writer(NULL);
    342 
    343     writer.OpenArray("{sv}", &array_writer);
    344 
    345     array_writer.OpenDictEntry(&dict_entry_writer);
    346     dict_entry_writer.AppendString(
    347         bluetooth_gatt_descriptor::kUUIDProperty);
    348     dict_entry_writer.AppendVariantOfString(uuid_);
    349     array_writer.CloseContainer(&dict_entry_writer);
    350 
    351     array_writer.OpenDictEntry(&dict_entry_writer);
    352     dict_entry_writer.AppendString(
    353         bluetooth_gatt_descriptor::kCharacteristicProperty);
    354     dict_entry_writer.AppendVariantOfObjectPath(characteristic_path_);
    355     array_writer.CloseContainer(&dict_entry_writer);
    356 
    357     array_writer.OpenDictEntry(&dict_entry_writer);
    358     dict_entry_writer.AppendString(
    359         bluetooth_gatt_descriptor::kValueProperty);
    360     dict_entry_writer.OpenVariant("ay", &variant_writer);
    361     variant_writer.AppendArrayOfBytes(value.data(), value.size());
    362     dict_entry_writer.CloseContainer(&variant_writer);
    363     array_writer.CloseContainer(&dict_entry_writer);
    364 
    365     // TODO(armansito): Process "Permissions" property.
    366 
    367     writer.CloseContainer(&array_writer);
    368 
    369     response_sender.Run(response.Pass());
    370   }
    371 
    372   // Called by the Delegate in response to a successful method call to get the
    373   // descriptor value.
    374   void OnGet(dbus::MethodCall* method_call,
    375              dbus::ExportedObject::ResponseSender response_sender,
    376              const std::vector<uint8>& value) {
    377     VLOG(2) << "Returning descriptor value obtained from delegate.";
    378     scoped_ptr<dbus::Response> response =
    379         dbus::Response::FromMethodCall(method_call);
    380     dbus::MessageWriter writer(response.get());
    381     dbus::MessageWriter variant_writer(NULL);
    382 
    383     writer.OpenVariant("ay", &variant_writer);
    384     variant_writer.AppendArrayOfBytes(value.data(), value.size());
    385     writer.CloseContainer(&variant_writer);
    386 
    387     response_sender.Run(response.Pass());
    388   }
    389 
    390   // Called by the Delegate in response to a successful method call to set the
    391   // descriptor value.
    392   void OnSet(dbus::MethodCall* method_call,
    393              dbus::ExportedObject::ResponseSender response_sender) {
    394     VLOG(2) << "Successfully set descriptor value. Return success.";
    395     response_sender.Run(dbus::Response::FromMethodCall(method_call));
    396   }
    397 
    398   // Called by the Delegate in response to a failed method call to get or set
    399   // the descriptor value.
    400   void OnFailure(dbus::MethodCall* method_call,
    401                  dbus::ExportedObject::ResponseSender response_sender) {
    402     VLOG(2) << "Failed to get/set descriptor value. Report error.";
    403     scoped_ptr<dbus::ErrorResponse> error_response =
    404         dbus::ErrorResponse::FromMethodCall(
    405             method_call, kErrorFailed,
    406             "Failed to get/set descriptor value.");
    407     response_sender.Run(error_response.PassAs<dbus::Response>());
    408   }
    409 
    410   // Origin thread (i.e. the UI thread in production).
    411   base::PlatformThreadId origin_thread_id_;
    412 
    413   // 128-bit descriptor UUID of this object.
    414   std::string uuid_;
    415 
    416   // D-Bus bus object is exported on, not owned by this object and must
    417   // outlive it.
    418   dbus::Bus* bus_;
    419 
    420   // Incoming methods to get and set the "Value" property are passed on to the
    421   // delegate and callbacks passed to generate a reply. |delegate_| is generally
    422   // the object that owns this one and must outlive it.
    423   Delegate* delegate_;
    424 
    425   // D-Bus object path of object we are exporting, kept so we can unregister
    426   // again in our destructor.
    427   dbus::ObjectPath object_path_;
    428 
    429   // Object path of the GATT characteristic that the exported descriptor belongs
    430   // to.
    431   dbus::ObjectPath characteristic_path_;
    432 
    433   // D-Bus object we are exporting, owned by this object.
    434   scoped_refptr<dbus::ExportedObject> exported_object_;
    435 
    436   // Weak pointer factory for generating 'this' pointers that might live longer
    437   // than we do.
    438   // Note: This should remain the last member so it'll be destroyed and
    439   // invalidate its weak pointers before any other members are destroyed.
    440   base::WeakPtrFactory<BluetoothGattDescriptorServiceProviderImpl>
    441       weak_ptr_factory_;
    442 
    443   DISALLOW_COPY_AND_ASSIGN(BluetoothGattDescriptorServiceProviderImpl);
    444 };
    445 
    446 BluetoothGattDescriptorServiceProvider::
    447     BluetoothGattDescriptorServiceProvider() {
    448 }
    449 
    450 BluetoothGattDescriptorServiceProvider::
    451     ~BluetoothGattDescriptorServiceProvider() {
    452 }
    453 
    454 // static
    455 BluetoothGattDescriptorServiceProvider*
    456 BluetoothGattDescriptorServiceProvider::Create(
    457     dbus::Bus* bus,
    458     const dbus::ObjectPath& object_path,
    459     Delegate* delegate,
    460     const std::string& uuid,
    461     const std::vector<std::string>& permissions,
    462     const dbus::ObjectPath& characteristic_path) {
    463   if (base::SysInfo::IsRunningOnChromeOS()) {
    464     return new BluetoothGattDescriptorServiceProviderImpl(
    465         bus, object_path, delegate, uuid, permissions, characteristic_path);
    466   }
    467   return new FakeBluetoothGattDescriptorServiceProvider(
    468       object_path, delegate, uuid, permissions, characteristic_path);
    469 }
    470 
    471 }  // namespace chromeos
    472