arc: bluetooth: Implement Gatt server request to read/write

components/arc/bluetooth/arc_bluetooth_bridge.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/arc/bluetooth/arc_bluetooth_bridge.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 
 #include <iomanip>
@@ skipping 32 matching lines @@
 using device::BluetoothLocalGattService;
 using device::BluetoothRemoteGattCharacteristic;
 using device::BluetoothRemoteGattDescriptor;
 using device::BluetoothRemoteGattService;
 using device::BluetoothTransport;
 using device::BluetoothUUID;
 
 namespace {
 constexpr int32_t kMinBtleVersion = 1;
 constexpr int32_t kMinBtleNotifyVersion = 2;
+constexpr int32_t kMinGattServerVersion = 3;
 constexpr uint32_t kGattReadPermission =
     BluetoothGattCharacteristic::Permission::PERMISSION_READ |
     BluetoothGattCharacteristic::Permission::PERMISSION_READ_ENCRYPTED |
     BluetoothGattCharacteristic::Permission::
         PERMISSION_READ_ENCRYPTED_AUTHENTICATED;
 constexpr uint32_t kGattWritePermission =
     BluetoothGattCharacteristic::Permission::PERMISSION_WRITE |
     BluetoothGattCharacteristic::Permission::PERMISSION_WRITE_ENCRYPTED |
     BluetoothGattCharacteristic::Permission::
         PERMISSION_WRITE_ENCRYPTED_AUTHENTICATED;
@@ skipping 67 matching lines @@
 void OnGattReadError(const GattReadCallback& callback,
                      BluetoothGattService::GattErrorCode error_code) {
   arc::mojom::BluetoothGattValuePtr gattValue =
       arc::mojom::BluetoothGattValue::New();
   gattValue->status =
       mojo::ConvertTo<arc::mojom::BluetoothGattStatus>(error_code);
   gattValue->value = nullptr;
   callback.Run(std::move(gattValue));
 }
 
+// Callback function for mojom::BluetoothInstance::RequestGattRead
+void OnGattServerRead(
+    const BluetoothLocalGattService::Delegate::ValueCallback& success_callback,
+    const BluetoothLocalGattService::Delegate::ErrorCallback& error_callback,
+    arc::mojom::BluetoothGattStatus status,
+    mojo::Array<uint8_t> value) {
+  if (status == arc::mojom::BluetoothGattStatus::GATT_SUCCESS)
+    success_callback.Run(value.To<std::vector<uint8_t>>());
+  else
+    error_callback.Run();
+}
+
+// Callback function for mojom::BluetoothInstance::RequestGattWrite
+void OnGattServerWrite(
+    const base::Closure& success_callback,
+    const BluetoothLocalGattService::Delegate::ErrorCallback& error_callback,
+    arc::mojom::BluetoothGattStatus status) {
+  if (status == arc::mojom::BluetoothGattStatus::GATT_SUCCESS)
+    success_callback.Run();
+  else
+    error_callback.Run();
+}
+
 }  // namespace
 
 namespace arc {
 
 ArcBluetoothBridge::ArcBluetoothBridge(ArcBridgeService* bridge_service)
     : ArcService(bridge_service), binding_(this), weak_factory_(this) {
   if (BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
     VLOG(1) << "registering bluetooth adapter";
     BluetoothAdapterFactory::GetAdapter(base::Bind(
         &ArcBluetoothBridge::OnAdapterInitialized, weak_factory_.GetWeakPtr()));
@@ skipping 217 matching lines @@
       true /* is_notify */, mojo::Array<uint8_t>::From(value));
 }
 
 void ArcBluetoothBridge::GattDescriptorValueChanged(
     BluetoothAdapter* adapter,
     BluetoothRemoteGattDescriptor* descriptor,
     const std::vector<uint8_t>& value) {
   // Placeholder for GATT client functionality
 }
 
+template <class LocalGattAttribute>
+void ArcBluetoothBridge::OnGattAttributeReadRequest(
+    const BluetoothDevice* device,
+    const LocalGattAttribute* gatt_obj,
+    int offset,
+    const ValueCallback& success_callback,
+    const ErrorCallback& error_callback) {
+  DCHECK(CalledOnValidThread());
+  if (!HasBluetoothInstance() ||
+      !CheckBluetoothInstanceVersion(kMinGattServerVersion) || offset < 0) {

[palmer, 2016/07/22 01:46:10]

Is there an upper bound for offset? Or, if sanity is checked inside
|arc_bridge_service()->bluetooth()->instance()->RequestGattRead|, is it
redundant to also check here?

[puthik_chromium, 2016/07/22 02:12:33]

The upper bound is the size of the Gatt Attribute which we don't know at this
time.

|arc_bridge_service()->bluetooth()->instance()->RequestGattRead| will propagate
to Android app that request GattServer. And it's up to app developer to do the
boundary check there. Thay why I think it is better to also do the sanity check
here.

[palmer, 2016/07/22 21:49:11]

I'm not sure I'm looking at the right thing, but this:

https://community.nxp.com/thread/332030

seems to say that the maximum size for a GATT attribute is 512 bytes.

[puthik_chromium, 2016/07/22 22:41:05]

Done. Found it in the spec.

+    error_callback.Run();
+    return;
+  }
+
+  DCHECK(gatt_handle_.find(gatt_obj->GetIdentifier()) != gatt_handle_.end());

[palmer, 2016/07/22 01:46:10]

This could only happen by programmer error? I ask because I'm not sure what all
callers this function has.

[puthik_chromium, 2016/07/22 02:12:33]

The caller of these function is On{Characteristic,Descriptor}ReadRequest
which is override from device::BluetoothLocalGattService::Delegate.
We are delegate to only GattAtrribute that we create. So this DCHECK will fail
only by programmer error.

[palmer, 2016/07/22 21:49:11]

Great, thanks.

+
+  arc_bridge_service()->bluetooth()->instance()->RequestGattRead(
+      mojom::BluetoothAddress::From(device->GetAddress()),
+      gatt_handle_[gatt_obj->GetIdentifier()], offset, false /* is_long */,
+      base::Bind(&OnGattServerRead, success_callback, error_callback));
+}
+
+template <class LocalGattAttribute>
+void ArcBluetoothBridge::OnGattAttributeWriteRequest(

[palmer, 2016/07/22 01:46:10]

Same questions as above for this function.

[puthik_chromium, 2016/07/22 02:12:33]

Same answer as above

+    const BluetoothDevice* device,
+    const LocalGattAttribute* gatt_obj,
+    const std::vector<uint8_t>& value,
+    int offset,
+    const base::Closure& success_callback,
+    const ErrorCallback& error_callback) {
+  DCHECK(CalledOnValidThread());
+  if (!HasBluetoothInstance() ||
+      !CheckBluetoothInstanceVersion(kMinGattServerVersion) || offset < 0) {
+    error_callback.Run();
+    return;
+  }
+
+  DCHECK(gatt_handle_.find(gatt_obj->GetIdentifier()) != gatt_handle_.end());
+
+  arc_bridge_service()->bluetooth()->instance()->RequestGattWrite(
+      mojom::BluetoothAddress::From(device->GetAddress()),
+      gatt_handle_[gatt_obj->GetIdentifier()], offset,
+      mojo::Array<uint8_t>::From(value),
+      base::Bind(&OnGattServerWrite, success_callback, error_callback));
+}
+
 void ArcBluetoothBridge::OnCharacteristicReadRequest(
     const BluetoothDevice* device,
     const BluetoothLocalGattCharacteristic* characteristic,
     int offset,
     const ValueCallback& callback,
-    const ErrorCallback& error_callback) {}
+    const ErrorCallback& error_callback) {
+  OnGattAttributeReadRequest(device, characteristic, offset, callback,
+                             error_callback);
+}
 
 void ArcBluetoothBridge::OnCharacteristicWriteRequest(
     const BluetoothDevice* device,
     const BluetoothLocalGattCharacteristic* characteristic,
     const std::vector<uint8_t>& value,
     int offset,
     const base::Closure& callback,
-    const ErrorCallback& error_callback) {}
+    const ErrorCallback& error_callback) {
+  OnGattAttributeWriteRequest(device, characteristic, value, offset, callback,
+                              error_callback);
+}
 
 void ArcBluetoothBridge::OnDescriptorReadRequest(
     const BluetoothDevice* device,
     const BluetoothLocalGattDescriptor* descriptor,
     int offset,
     const ValueCallback& callback,
-    const ErrorCallback& error_callback) {}
+    const ErrorCallback& error_callback) {
+  OnGattAttributeReadRequest(device, descriptor, offset, callback,
+                             error_callback);
+}
 
 void ArcBluetoothBridge::OnDescriptorWriteRequest(
     const BluetoothDevice* device,
     const BluetoothLocalGattDescriptor* descriptor,
     const std::vector<uint8_t>& value,
     int offset,
     const base::Closure& callback,
-    const ErrorCallback& error_callback) {}
+    const ErrorCallback& error_callback) {
+  OnGattAttributeWriteRequest(device, descriptor, value, offset, callback,
+                              error_callback);
+}
 
 void ArcBluetoothBridge::OnNotificationsStart(
     const BluetoothDevice* device,
     const BluetoothLocalGattCharacteristic* characteristic) {}
 
 void ArcBluetoothBridge::OnNotificationsStop(
     const BluetoothDevice* device,
     const BluetoothLocalGattCharacteristic* characteristic) {}
 
 void ArcBluetoothBridge::EnableAdapter(const EnableAdapterCallback& callback) {
@@ skipping 648 matching lines @@
 
 template <class LocalGattAttribute>
 int32_t ArcBluetoothBridge::CreateGattAttributeHandle(
     LocalGattAttribute* gatt_attr) {
   DCHECK(CalledOnValidThread());
   if (!gatt_attr)
     return kInvalidGattAttributeHandle;
   int32_t handle = next_gatt_server_attribute_handle();
   const std::string& identifier = gatt_attr->GetIdentifier();
   gatt_identifier_[handle] = identifier;
+  gatt_handle_[identifier] = handle;
   return handle;
 }
 
 void ArcBluetoothBridge::AddService(mojom::BluetoothGattServiceIDPtr service_id,
                                     int32_t num_handles,
                                     const AddServiceCallback& callback) {
   base::WeakPtr<BluetoothLocalGattService> service =
       BluetoothLocalGattService::Create(
           bluetooth_adapter_.get(), service_id->id->uuid.To<BluetoothUUID>(),
           service_id->is_primary, nullptr /* included_service */,
@@ skipping 80 matching lines @@
                       base::Bind(&OnGattOperationError, callback));
 }
 
 void ArcBluetoothBridge::DeleteService(int32_t service_handle,
                                        const DeleteServiceCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(gatt_identifier_.find(service_handle) != gatt_identifier_.end());
   BluetoothLocalGattService* service =
       bluetooth_adapter_->GetGattService(gatt_identifier_[service_handle]);
   DCHECK(service);
-
+  gatt_identifier_.erase(service_handle);
+  gatt_handle_.erase(service->GetIdentifier());
   service->Delete();
-  gatt_identifier_.erase(service_handle);
   OnGattOperationDone(callback);
 }
 
 void ArcBluetoothBridge::SendIndication(
     int32_t attribute_handle,
     mojom::BluetoothAddressPtr address,
     bool confirm,
     mojo::Array<uint8_t> value,
     const SendIndicationCallback& callback) {}
 
@@ skipping 332 matching lines @@
   LOG(WARNING) << "Bluetooth instance is too old (version " << version
                << ") need version " << version_need;
   return false;
 }
 
 bool ArcBluetoothBridge::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace arc