Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(112)

Side by Side Diff: device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider_impl.cc

Issue 1914893002: DBus changes for implementing local GATT attributes. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@bluetooth_classes
Patch Set: test leak fix Created 4 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
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
5 #include "device/bluetooth/dbus/bluetooth_gatt_descriptor_service_provider_impl. h"
6
7 #include <stddef.h>
8
9 #include "base/bind.h"
10 #include "base/logging.h"
11 #include "base/strings/string_util.h"
12 #include "third_party/cros_system_api/dbus/service_constants.h"
13
14 namespace bluez {
15
16 namespace {
17
18 const char kErrorInvalidArgs[] = "org.freedesktop.DBus.Error.InvalidArgs";
19 const char kErrorPropertyReadOnly[] =
20 "org.freedesktop.DBus.Error.PropertyReadOnly";
21 const char kErrorFailed[] = "org.freedesktop.DBus.Error.Failed";
22
23 } // namespace
24
25 // The BluetoothGattDescriptorServiceProvider implementation used in production.
26 BluetoothGattDescriptorServiceProviderImpl::
27 BluetoothGattDescriptorServiceProviderImpl(
28 dbus::Bus* bus,
29 const dbus::ObjectPath& object_path,
30 std::unique_ptr<BluetoothGattAttributeValueDelegate> delegate,
31 const std::string& uuid,
32 const std::vector<std::string>& permissions,
33 const dbus::ObjectPath& characteristic_path)
34 : origin_thread_id_(base::PlatformThread::CurrentId()),
35 uuid_(uuid),
36 bus_(bus),
37 delegate_(std::move(delegate)),
38 object_path_(object_path),
39 characteristic_path_(characteristic_path),
40 weak_ptr_factory_(this) {
41 VLOG(1) << "Created Bluetooth GATT characteristic descriptor: "
42 << object_path.value() << " UUID: " << uuid;
43 DCHECK(bus_);
44 DCHECK(delegate_);
45 DCHECK(!uuid_.empty());
46 DCHECK(object_path_.IsValid());
47 DCHECK(characteristic_path_.IsValid());
48 DCHECK(base::StartsWith(object_path_.value(),
49 characteristic_path_.value() + "/",
50 base::CompareCase::SENSITIVE));
51
52 exported_object_ = bus_->GetExportedObject(object_path_);
53
54 exported_object_->ExportMethod(
55 dbus::kDBusPropertiesInterface, dbus::kDBusPropertiesGet,
56 base::Bind(&BluetoothGattDescriptorServiceProviderImpl::Get,
57 weak_ptr_factory_.GetWeakPtr()),
58 base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnExported,
59 weak_ptr_factory_.GetWeakPtr()));
60
61 exported_object_->ExportMethod(
62 dbus::kDBusPropertiesInterface, dbus::kDBusPropertiesSet,
63 base::Bind(&BluetoothGattDescriptorServiceProviderImpl::Set,
64 weak_ptr_factory_.GetWeakPtr()),
65 base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnExported,
66 weak_ptr_factory_.GetWeakPtr()));
67
68 exported_object_->ExportMethod(
69 dbus::kDBusPropertiesInterface, dbus::kDBusPropertiesGetAll,
70 base::Bind(&BluetoothGattDescriptorServiceProviderImpl::GetAll,
71 weak_ptr_factory_.GetWeakPtr()),
72 base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnExported,
73 weak_ptr_factory_.GetWeakPtr()));
74 }
75
76 BluetoothGattDescriptorServiceProviderImpl::
77 ~BluetoothGattDescriptorServiceProviderImpl() {
78 VLOG(1) << "Cleaning up Bluetooth GATT characteristic descriptor: "
79 << object_path_.value();
80 if (bus_)
81 bus_->UnregisterExportedObject(object_path_);
82 }
83
84 BluetoothGattDescriptorServiceProviderImpl::
85 BluetoothGattDescriptorServiceProviderImpl(
86 const dbus::ObjectPath& object_path,
87 const std::string& uuid,
88 const dbus::ObjectPath& characteristic_path)
89 : origin_thread_id_(base::PlatformThread::CurrentId()),
90 uuid_(uuid),
91 bus_(nullptr),
92 delegate_(nullptr),
93 object_path_(object_path),
94 characteristic_path_(characteristic_path),
95 weak_ptr_factory_(this) {}
96
97 void BluetoothGattDescriptorServiceProviderImpl::SendValueChanged(
98 const std::vector<uint8_t>& value) {
99 VLOG(2) << "Emitting a PropertiesChanged signal for descriptor value.";
100 dbus::Signal signal(dbus::kDBusPropertiesInterface,
101 dbus::kDBusPropertiesChangedSignal);
102 dbus::MessageWriter writer(&signal);
103 dbus::MessageWriter array_writer(NULL);
104 dbus::MessageWriter dict_entry_writer(NULL);
105 dbus::MessageWriter variant_writer(NULL);
106
107 // interface_name
108 writer.AppendString(
109 bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface);
110
111 // changed_properties
112 writer.OpenArray("{sv}", &array_writer);
113 array_writer.OpenDictEntry(&dict_entry_writer);
114 dict_entry_writer.AppendString(bluetooth_gatt_descriptor::kValueProperty);
115 dict_entry_writer.OpenVariant("ay", &variant_writer);
116 variant_writer.AppendArrayOfBytes(value.data(), value.size());
117 dict_entry_writer.CloseContainer(&variant_writer);
118 array_writer.CloseContainer(&dict_entry_writer);
119 writer.CloseContainer(&array_writer);
120
121 // invalidated_properties.
122 writer.OpenArray("s", &array_writer);
123 writer.CloseContainer(&array_writer);
124
125 exported_object_->SendSignal(&signal);
126 }
127
128 bool BluetoothGattDescriptorServiceProviderImpl::OnOriginThread() {
129 return base::PlatformThread::CurrentId() == origin_thread_id_;
130 }
131
132 void BluetoothGattDescriptorServiceProviderImpl::Get(
133 dbus::MethodCall* method_call,
134 dbus::ExportedObject::ResponseSender response_sender) {
135 VLOG(2) << "BluetoothGattDescriptorServiceProvider::Get: "
136 << object_path_.value();
137 DCHECK(OnOriginThread());
138
139 dbus::MessageReader reader(method_call);
140
141 std::string interface_name;
142 std::string property_name;
143 if (!reader.PopString(&interface_name) || !reader.PopString(&property_name) ||
144 reader.HasMoreData()) {
145 std::unique_ptr<dbus::ErrorResponse> error_response =
146 dbus::ErrorResponse::FromMethodCall(method_call, kErrorInvalidArgs,
147 "Expected 'ss'.");
148 response_sender.Run(std::move(error_response));
149 return;
150 }
151
152 // Only the GATT descriptor interface is supported.
153 if (interface_name !=
154 bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface) {
155 std::unique_ptr<dbus::ErrorResponse> error_response =
156 dbus::ErrorResponse::FromMethodCall(
157 method_call, kErrorInvalidArgs,
158 "No such interface: '" + interface_name + "'.");
159 response_sender.Run(std::move(error_response));
160 return;
161 }
162
163 // If getting the "Value" property, obtain the value from the delegate.
164 if (property_name == bluetooth_gatt_descriptor::kValueProperty) {
165 DCHECK(delegate_);
166 delegate_->GetValue(
167 base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnGet,
168 weak_ptr_factory_.GetWeakPtr(), method_call,
169 response_sender),
170 base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnFailure,
171 weak_ptr_factory_.GetWeakPtr(), method_call,
172 response_sender));
173 return;
174 }
175
176 std::unique_ptr<dbus::Response> response =
177 dbus::Response::FromMethodCall(method_call);
178 dbus::MessageWriter writer(response.get());
179 dbus::MessageWriter variant_writer(NULL);
180
181 // TODO(armansito): Process the "Permissions" property below.
182 if (property_name == bluetooth_gatt_descriptor::kUUIDProperty) {
183 writer.OpenVariant("s", &variant_writer);
184 variant_writer.AppendString(uuid_);
185 writer.CloseContainer(&variant_writer);
186 } else if (property_name ==
187 bluetooth_gatt_descriptor::kCharacteristicProperty) {
188 writer.OpenVariant("o", &variant_writer);
189 variant_writer.AppendObjectPath(characteristic_path_);
190 writer.CloseContainer(&variant_writer);
191 } else {
192 response = dbus::ErrorResponse::FromMethodCall(
193 method_call, kErrorInvalidArgs,
194 "No such property: '" + property_name + "'.");
195 }
196
197 response_sender.Run(std::move(response));
198 }
199
200 void BluetoothGattDescriptorServiceProviderImpl::Set(
201 dbus::MethodCall* method_call,
202 dbus::ExportedObject::ResponseSender response_sender) {
203 VLOG(2) << "BluetoothGattDescriptorServiceProvider::Set: "
204 << object_path_.value();
205 DCHECK(OnOriginThread());
206
207 dbus::MessageReader reader(method_call);
208
209 std::string interface_name;
210 std::string property_name;
211 dbus::MessageReader variant_reader(NULL);
212 if (!reader.PopString(&interface_name) || !reader.PopString(&property_name) ||
213 !reader.PopVariant(&variant_reader) || reader.HasMoreData()) {
214 std::unique_ptr<dbus::ErrorResponse> error_response =
215 dbus::ErrorResponse::FromMethodCall(method_call, kErrorInvalidArgs,
216 "Expected 'ssv'.");
217 response_sender.Run(std::move(error_response));
218 return;
219 }
220
221 // Only the GATT descriptor interface is allowed.
222 if (interface_name !=
223 bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface) {
224 std::unique_ptr<dbus::ErrorResponse> error_response =
225 dbus::ErrorResponse::FromMethodCall(
226 method_call, kErrorInvalidArgs,
227 "No such interface: '" + interface_name + "'.");
228 response_sender.Run(std::move(error_response));
229 return;
230 }
231
232 // Only the "Value" property is writeable.
233 if (property_name != bluetooth_gatt_descriptor::kValueProperty) {
234 std::string error_name;
235 std::string error_message;
236 if (property_name == bluetooth_gatt_descriptor::kUUIDProperty ||
237 property_name == bluetooth_gatt_descriptor::kCharacteristicProperty) {
238 error_name = kErrorPropertyReadOnly;
239 error_message = "Read-only property: '" + property_name + "'.";
240 } else {
241 error_name = kErrorInvalidArgs;
242 error_message = "No such property: '" + property_name + "'.";
243 }
244 std::unique_ptr<dbus::ErrorResponse> error_response =
245 dbus::ErrorResponse::FromMethodCall(method_call, error_name,
246 error_message);
247 response_sender.Run(std::move(error_response));
248 return;
249 }
250
251 // Obtain the value.
252 const uint8_t* bytes = NULL;
253 size_t length = 0;
254 if (!variant_reader.PopArrayOfBytes(&bytes, &length)) {
255 std::unique_ptr<dbus::ErrorResponse> error_response =
256 dbus::ErrorResponse::FromMethodCall(
257 method_call, kErrorInvalidArgs,
258 "Property '" + property_name + "' has type 'ay'.");
259 response_sender.Run(std::move(error_response));
260 return;
261 }
262
263 // Pass the set request onto the delegate.
264 std::vector<uint8_t> value(bytes, bytes + length);
265 DCHECK(delegate_);
266 delegate_->SetValue(
267 value,
268 base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnSet,
269 weak_ptr_factory_.GetWeakPtr(), method_call, response_sender),
270 base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnFailure,
271 weak_ptr_factory_.GetWeakPtr(), method_call, response_sender));
272 }
273
274 void BluetoothGattDescriptorServiceProviderImpl::GetAll(
275 dbus::MethodCall* method_call,
276 dbus::ExportedObject::ResponseSender response_sender) {
277 VLOG(2) << "BluetoothGattDescriptorServiceProvider::GetAll: "
278 << object_path_.value();
279 DCHECK(OnOriginThread());
280
281 dbus::MessageReader reader(method_call);
282
283 std::string interface_name;
284 if (!reader.PopString(&interface_name) || reader.HasMoreData()) {
285 std::unique_ptr<dbus::ErrorResponse> error_response =
286 dbus::ErrorResponse::FromMethodCall(method_call, kErrorInvalidArgs,
287 "Expected 's'.");
288 response_sender.Run(std::move(error_response));
289 return;
290 }
291
292 // Only the GATT descriptor interface is supported.
293 if (interface_name !=
294 bluetooth_gatt_descriptor::kBluetoothGattDescriptorInterface) {
295 std::unique_ptr<dbus::ErrorResponse> error_response =
296 dbus::ErrorResponse::FromMethodCall(
297 method_call, kErrorInvalidArgs,
298 "No such interface: '" + interface_name + "'.");
299 response_sender.Run(std::move(error_response));
300 return;
301 }
302
303 // Try to obtain the value from the delegate. We will construct the
304 // response in the success callback.
305 DCHECK(delegate_);
306 delegate_->GetValue(
307 base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnGetAll,
308 weak_ptr_factory_.GetWeakPtr(), method_call, response_sender),
309 base::Bind(&BluetoothGattDescriptorServiceProviderImpl::OnFailure,
310 weak_ptr_factory_.GetWeakPtr(), method_call, response_sender));
311 }
312
313 void BluetoothGattDescriptorServiceProviderImpl::OnExported(
314 const std::string& interface_name,
315 const std::string& method_name,
316 bool success) {
317 LOG_IF(WARNING, !success) << "Failed to export " << interface_name << "."
318 << method_name;
319 }
320
321 void BluetoothGattDescriptorServiceProviderImpl::OnGetAll(
322 dbus::MethodCall* method_call,
323 dbus::ExportedObject::ResponseSender response_sender,
324 const std::vector<uint8_t>& value) {
325 VLOG(2) << "Descriptor value obtained from delegate. Responding to "
326 << "GetAll.";
327
328 std::unique_ptr<dbus::Response> response =
329 dbus::Response::FromMethodCall(method_call);
330 dbus::MessageWriter writer(response.get());
331 WriteProperties(&writer, &value);
332 response_sender.Run(std::move(response));
333 }
334
335 void BluetoothGattDescriptorServiceProviderImpl::WriteProperties(
336 dbus::MessageWriter* writer,
337 const std::vector<uint8_t>* value) {
338 dbus::MessageWriter array_writer(NULL);
339 dbus::MessageWriter dict_entry_writer(NULL);
340 dbus::MessageWriter variant_writer(NULL);
341
342 writer->OpenArray("{sv}", &array_writer);
343
344 array_writer.OpenDictEntry(&dict_entry_writer);
345 dict_entry_writer.AppendString(bluetooth_gatt_descriptor::kUUIDProperty);
346 dict_entry_writer.AppendVariantOfString(uuid_);
347 array_writer.CloseContainer(&dict_entry_writer);
348
349 array_writer.OpenDictEntry(&dict_entry_writer);
350 dict_entry_writer.AppendString(
351 bluetooth_gatt_descriptor::kCharacteristicProperty);
352 dict_entry_writer.AppendVariantOfObjectPath(characteristic_path_);
353 array_writer.CloseContainer(&dict_entry_writer);
354
355 if (value) {
356 array_writer.OpenDictEntry(&dict_entry_writer);
357 dict_entry_writer.AppendString(bluetooth_gatt_descriptor::kValueProperty);
358 dict_entry_writer.OpenVariant("ay", &variant_writer);
359 variant_writer.AppendArrayOfBytes(value->data(), value->size());
360 dict_entry_writer.CloseContainer(&variant_writer);
361 array_writer.CloseContainer(&dict_entry_writer);
362 }
363
364 // TODO(armansito): Process "Permissions" property.
365 writer->CloseContainer(&array_writer);
366 }
367
368 // Called by the Delegate in response to a successful method call to get the
369 // descriptor value.
370 void BluetoothGattDescriptorServiceProviderImpl::OnGet(
371 dbus::MethodCall* method_call,
372 dbus::ExportedObject::ResponseSender response_sender,
373 const std::vector<uint8_t>& value) {
374 VLOG(2) << "Returning descriptor value obtained from delegate.";
375 std::unique_ptr<dbus::Response> response =
376 dbus::Response::FromMethodCall(method_call);
377 dbus::MessageWriter writer(response.get());
378 dbus::MessageWriter variant_writer(NULL);
379
380 writer.OpenVariant("ay", &variant_writer);
381 variant_writer.AppendArrayOfBytes(value.data(), value.size());
382 writer.CloseContainer(&variant_writer);
383
384 response_sender.Run(std::move(response));
385 }
386
387 void BluetoothGattDescriptorServiceProviderImpl::OnSet(
388 dbus::MethodCall* method_call,
389 dbus::ExportedObject::ResponseSender response_sender) {
390 VLOG(2) << "Successfully set descriptor value. Return success.";
391 response_sender.Run(dbus::Response::FromMethodCall(method_call));
392 }
393
394 void BluetoothGattDescriptorServiceProviderImpl::OnFailure(
395 dbus::MethodCall* method_call,
396 dbus::ExportedObject::ResponseSender response_sender) {
397 VLOG(2) << "Failed to get/set descriptor value. Report error.";
398 std::unique_ptr<dbus::ErrorResponse> error_response =
399 dbus::ErrorResponse::FromMethodCall(
400 method_call, kErrorFailed, "Failed to get/set descriptor value.");
401 response_sender.Run(std::move(error_response));
402 }
403
404 const dbus::ObjectPath&
405 BluetoothGattDescriptorServiceProviderImpl::object_path() const {
406 return object_path_;
407 }
408
409 } // namespace bluez
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698