bluetooth_gatt_application_service_provider.cc 9.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195
  1. // Copyright 2016 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. #include "device/bluetooth/dbus/bluetooth_gatt_application_service_provider.h"
  5. #include <string>
  6. #include <utility>
  7. #include "base/logging.h"
  8. #include "base/memory/ptr_util.h"
  9. #include "device/bluetooth/bluetooth_gatt_characteristic.h"
  10. #include "device/bluetooth/bluez/bluetooth_gatt_service_bluez.h"
  11. #include "device/bluetooth/dbus/bluetooth_gatt_application_service_provider_impl.h"
  12. #include "device/bluetooth/dbus/bluetooth_gatt_characteristic_delegate_wrapper.h"
  13. #include "device/bluetooth/dbus/bluetooth_gatt_descriptor_delegate_wrapper.h"
  14. #include "device/bluetooth/dbus/bluez_dbus_manager.h"
  15. #include "device/bluetooth/dbus/fake_bluetooth_gatt_application_service_provider.h"
  16. #include "device/bluetooth/public/cpp/bluetooth_uuid.h"
  17. #include "third_party/cros_system_api/dbus/service_constants.h"
  18. namespace bluez {
  19. namespace {
  20. const std::vector<std::string> FlagsFromPropertiesAndPermissions(
  21. device::BluetoothGattCharacteristic::Properties properties,
  22. device::BluetoothGattCharacteristic::Permissions permissions) {
  23. static_assert(
  24. device::BluetoothGattCharacteristic::NUM_PROPERTY == 1 << 14,
  25. "Update required if the number of characteristic properties changes.");
  26. std::vector<std::string> flags;
  27. if (properties & device::BluetoothGattCharacteristic::PROPERTY_BROADCAST)
  28. flags.push_back(bluetooth_gatt_characteristic::kFlagBroadcast);
  29. if (properties & device::BluetoothGattCharacteristic::PROPERTY_READ)
  30. flags.push_back(bluetooth_gatt_characteristic::kFlagRead);
  31. if (properties &
  32. device::BluetoothGattCharacteristic::PROPERTY_WRITE_WITHOUT_RESPONSE)
  33. flags.push_back(bluetooth_gatt_characteristic::kFlagWriteWithoutResponse);
  34. if (properties & device::BluetoothGattCharacteristic::PROPERTY_WRITE)
  35. flags.push_back(bluetooth_gatt_characteristic::kFlagWrite);
  36. if (properties & device::BluetoothGattCharacteristic::PROPERTY_NOTIFY)
  37. flags.push_back(bluetooth_gatt_characteristic::kFlagNotify);
  38. if (properties & device::BluetoothGattCharacteristic::PROPERTY_INDICATE)
  39. flags.push_back(bluetooth_gatt_characteristic::kFlagIndicate);
  40. if (properties &
  41. device::BluetoothGattCharacteristic::PROPERTY_AUTHENTICATED_SIGNED_WRITES)
  42. flags.push_back(
  43. bluetooth_gatt_characteristic::kFlagAuthenticatedSignedWrites);
  44. if (properties &
  45. device::BluetoothGattCharacteristic::PROPERTY_EXTENDED_PROPERTIES)
  46. flags.push_back(bluetooth_gatt_characteristic::kFlagExtendedProperties);
  47. if (properties & device::BluetoothGattCharacteristic::PROPERTY_RELIABLE_WRITE)
  48. flags.push_back(bluetooth_gatt_characteristic::kFlagReliableWrite);
  49. if (properties &
  50. device::BluetoothGattCharacteristic::PROPERTY_WRITABLE_AUXILIARIES)
  51. flags.push_back(bluetooth_gatt_characteristic::kFlagWritableAuxiliaries);
  52. if (properties & device::BluetoothGattCharacteristic::PROPERTY_READ_ENCRYPTED)
  53. flags.push_back(bluetooth_gatt_characteristic::kFlagEncryptRead);
  54. if (properties &
  55. device::BluetoothGattCharacteristic::PROPERTY_WRITE_ENCRYPTED)
  56. flags.push_back(bluetooth_gatt_characteristic::kFlagEncryptWrite);
  57. if (properties & device::BluetoothGattCharacteristic::
  58. PROPERTY_READ_ENCRYPTED_AUTHENTICATED)
  59. flags.push_back(
  60. bluetooth_gatt_characteristic::kFlagEncryptAuthenticatedRead);
  61. if (properties & device::BluetoothGattCharacteristic::
  62. PROPERTY_WRITE_ENCRYPTED_AUTHENTICATED)
  63. flags.push_back(
  64. bluetooth_gatt_characteristic::kFlagEncryptAuthenticatedWrite);
  65. if (permissions & device::BluetoothGattCharacteristic::PERMISSION_READ)
  66. flags.push_back(bluetooth_gatt_characteristic::kFlagPermissionRead);
  67. if (permissions & device::BluetoothGattCharacteristic::PERMISSION_WRITE)
  68. flags.push_back(bluetooth_gatt_characteristic::kFlagPermissionWrite);
  69. if (permissions &
  70. device::BluetoothGattCharacteristic::PERMISSION_READ_ENCRYPTED)
  71. flags.push_back(bluetooth_gatt_characteristic::kFlagPermissionEncryptRead);
  72. if (permissions &
  73. device::BluetoothGattCharacteristic::PERMISSION_WRITE_ENCRYPTED)
  74. flags.push_back(bluetooth_gatt_characteristic::kFlagPermissionEncryptWrite);
  75. if (permissions & device::BluetoothGattCharacteristic::
  76. PERMISSION_READ_ENCRYPTED_AUTHENTICATED)
  77. flags.push_back(
  78. bluetooth_gatt_characteristic::kFlagPermissionAuthenticatedRead);
  79. if (permissions & device::BluetoothGattCharacteristic::
  80. PERMISSION_WRITE_ENCRYPTED_AUTHENTICATED)
  81. flags.push_back(
  82. bluetooth_gatt_characteristic::kFlagPermissionAuthenticatedWrite);
  83. return flags;
  84. }
  85. const std::vector<std::string> FlagsFromPermissions(
  86. device::BluetoothGattCharacteristic::Permissions permissions) {
  87. static_assert(
  88. device::BluetoothGattCharacteristic::NUM_PERMISSION == 1 << 6,
  89. "Update required if the number of attribute permissions changes.");
  90. std::vector<std::string> flags;
  91. if (permissions & device::BluetoothGattCharacteristic::PERMISSION_READ)
  92. flags.push_back(bluetooth_gatt_descriptor::kFlagRead);
  93. if (permissions & device::BluetoothGattCharacteristic::PERMISSION_WRITE)
  94. flags.push_back(bluetooth_gatt_descriptor::kFlagWrite);
  95. if (permissions &
  96. device::BluetoothGattCharacteristic::PERMISSION_READ_ENCRYPTED)
  97. flags.push_back(bluetooth_gatt_descriptor::kFlagEncryptRead);
  98. if (permissions &
  99. device::BluetoothGattCharacteristic::PERMISSION_WRITE_ENCRYPTED)
  100. flags.push_back(bluetooth_gatt_descriptor::kFlagEncryptWrite);
  101. if (permissions & device::BluetoothGattCharacteristic::
  102. PERMISSION_READ_ENCRYPTED_AUTHENTICATED)
  103. flags.push_back(bluetooth_gatt_descriptor::kFlagEncryptAuthenticatedRead);
  104. if (permissions & device::BluetoothGattCharacteristic::
  105. PERMISSION_WRITE_ENCRYPTED_AUTHENTICATED)
  106. flags.push_back(bluetooth_gatt_descriptor::kFlagEncryptAuthenticatedWrite);
  107. return flags;
  108. }
  109. } // namespace
  110. BluetoothGattApplicationServiceProvider::
  111. BluetoothGattApplicationServiceProvider() = default;
  112. BluetoothGattApplicationServiceProvider::
  113. ~BluetoothGattApplicationServiceProvider() = default;
  114. void BluetoothGattApplicationServiceProvider::CreateAttributeServiceProviders(
  115. dbus::Bus* bus,
  116. const std::map<dbus::ObjectPath, BluetoothLocalGattServiceBlueZ*>&
  117. services) {
  118. for (const auto& service : services) {
  119. service_providers_.push_back(
  120. base::WrapUnique(BluetoothGattServiceServiceProvider::Create(
  121. bus, service.second->object_path(),
  122. service.second->GetUUID().value(), service.second->IsPrimary(),
  123. std::vector<dbus::ObjectPath>())));
  124. for (const auto& characteristic : service.second->GetCharacteristics()) {
  125. characteristic_providers_.push_back(
  126. base::WrapUnique(BluetoothGattCharacteristicServiceProvider::Create(
  127. bus, characteristic.second->object_path(),
  128. std::make_unique<BluetoothGattCharacteristicDelegateWrapper>(
  129. service.second, characteristic.second.get()),
  130. characteristic.second->GetUUID().value(),
  131. FlagsFromPropertiesAndPermissions(
  132. characteristic.second->GetProperties(),
  133. characteristic.second->GetPermissions()),
  134. service.second->object_path())));
  135. for (const auto& descriptor : characteristic.second->GetDescriptors()) {
  136. descriptor_providers_.push_back(
  137. base::WrapUnique(BluetoothGattDescriptorServiceProvider::Create(
  138. bus, descriptor->object_path(),
  139. std::make_unique<BluetoothGattDescriptorDelegateWrapper>(
  140. service.second, descriptor.get()),
  141. descriptor->GetUUID().value(),
  142. FlagsFromPermissions(descriptor->GetPermissions()),
  143. characteristic.second->object_path())));
  144. }
  145. }
  146. }
  147. }
  148. void BluetoothGattApplicationServiceProvider::SendValueChanged(
  149. const dbus::ObjectPath& characteristic_path,
  150. const std::vector<uint8_t>& value) {
  151. auto characteristic = std::find_if(
  152. characteristic_providers_.begin(), characteristic_providers_.end(),
  153. [&](const std::unique_ptr<BluetoothGattCharacteristicServiceProvider>&
  154. p) { return p->object_path() == characteristic_path; });
  155. if (characteristic == characteristic_providers_.end()) {
  156. LOG(ERROR) << "Couldn't find characteristic provider for: "
  157. << characteristic_path.value();
  158. return;
  159. }
  160. characteristic->get()->SendValueChanged(value);
  161. }
  162. // static
  163. std::unique_ptr<BluetoothGattApplicationServiceProvider>
  164. BluetoothGattApplicationServiceProvider::Create(
  165. dbus::Bus* bus,
  166. const dbus::ObjectPath& object_path,
  167. const std::map<dbus::ObjectPath, BluetoothLocalGattServiceBlueZ*>&
  168. services) {
  169. if (!bluez::BluezDBusManager::Get()->IsUsingFakes()) {
  170. return base::WrapUnique(new BluetoothGattApplicationServiceProviderImpl(
  171. bus, object_path, services));
  172. }
  173. #if defined(USE_REAL_DBUS_CLIENTS)
  174. LOG(FATAL) << "Fake is unavailable if USE_REAL_DBUS_CLIENTS is defined.";
  175. return nullptr;
  176. #else
  177. return std::make_unique<FakeBluetoothGattApplicationServiceProvider>(
  178. object_path, services);
  179. #endif // defined(USE_REAL_DBUS_CLIENTS)
  180. }
  181. } // namespace bluez