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 275 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
 }
 
+// We will use odd transaction_id for read and even id for write to make sure
+// that it does not overlap and make it easy to determine the transaction type.
+int32_t ArcBluetoothBridge::CreateGattReadTransaction(
+    const GattServerReadCallbacks& callbacks) {
+  static int32_t transaction_id = 1;
+  transaction_id += 2;
+  gatt_server_read_callbacks_[transaction_id] = callbacks;
+  return transaction_id;
+}
+
+int32_t ArcBluetoothBridge::CreateGattWriteTransaction(
+    const GattServerWriteCallbacks& callbacks) {
+  static int32_t transaction_id = 2;
+  transaction_id += 2;
+  gatt_server_write_callbacks_[transaction_id] = callbacks;
+  return transaction_id;
+}
+
+template <class LocalGattAttribute>
+void ArcBluetoothBridge::OnGattAttributeReadRequest(
+    const BluetoothDevice* device,
+    const LocalGattAttribute* gatt_obj,
+    int offset,
+    const GattServerReadCallbacks& callbacks) {
+  if (!HasBluetoothInstance() ||
+      !CheckBluetoothInstanceVersion(kMinBtleNotifyVersion) || offset < 0) {
+    callbacks.error_callback.Run();
+    return;
+  }
+
+  int32_t transaction_id = CreateGattReadTransaction(callbacks);
+
+  arc_bridge_service()->bluetooth()->instance()->RequestGattRead(
+      mojom::BluetoothAddress::From(device->GetAddress()), transaction_id,
+      gatt_handle_[gatt_obj->GetIdentifier()], offset, false /*is_long */);

[Luis Héctor Chávez, 2016/07/19 01:49:17]

What happens if |gatt_obj->GetIdentifier()| is invalid?

[puthik_chromium, 2016/07/19 22:21:47]

It should valid all the time because we are delegate only for the
LocalGattServer that we create. Added DCHECK.

+}
+
+template <class LocalGattAttribute>
+void ArcBluetoothBridge::OnGattAttributeWriteRequest(
+    const BluetoothDevice* device,
+    const LocalGattAttribute* gatt_obj,
+    const std::vector<uint8_t>& value,
+    int offset,
+    const GattServerWriteCallbacks& callbacks) {
+  if (!HasBluetoothInstance() ||
+      !CheckBluetoothInstanceVersion(kMinBtleNotifyVersion) || offset < 0) {
+    callbacks.error_callback.Run();
+    return;
+  }
+
+  int32_t transaction_id = CreateGattWriteTransaction(callbacks);
+
+  arc_bridge_service()->bluetooth()->instance()->RequestGattWrite(

[Luis Héctor Chávez, 2016/07/19 01:49:16]

Instead of doing this transaction magic, is it possible to make
RequestGatt{Read,Write} have a callback? That should simplify stuff
significantly.

[puthik_chromium, 2016/07/19 22:21:47]

This require 3 calls.
Chrome to Android: RequestGatt{Read,Write}
Android to Chrome: SendResponse
Chrome to Android: callback of SendResponse

If we make RequestGatt{Read,Write} have a callback, it will be more complicate
because 1) we still need to remember trannsaction_id in Android side, 2)
SendResponse will be the callback of mojo function and we still need to do
something for callback of that.

[Luis Héctor Chávez, 2016/07/19 22:38:00]

What do you need the callback of SendResponse for? You're unconditionally
returning success, so it's probably easier if you remove SendResponse
altogether.

[puthik_chromium, 2016/07/19 23:05:43]

Look like the response of SendResponse is optional in Android[1].
I thought it is mandatory. Will remove the SendResponse in the next patch after
make sure that it work on real machine.

[1] Android just debug print this.
https://android.googlesource.com/platform/packages/apps/Bluetooth/+/master/sr...

[puthik_chromium, 2016/07/20 01:42:09]

Done.
SendResponse removed

+      mojom::BluetoothAddress::From(device->GetAddress()), transaction_id,
+      gatt_handle_[gatt_obj->GetIdentifier()], offset,
+      mojo::Array<uint8_t>::From(value));
+}
+
 void ArcBluetoothBridge::OnCharacteristicReadRequest(
     const BluetoothDevice* device,
     const BluetoothLocalGattCharacteristic* characteristic,
     int offset,
     const ValueCallback& callback,
-    const ErrorCallback& error_callback) {}
+    const ErrorCallback& error_callback) {
+  OnGattAttributeReadRequest<BluetoothLocalGattCharacteristic>(
+      device, characteristic, offset,
+      GattServerReadCallbacks(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<BluetoothLocalGattCharacteristic>(
+      device, characteristic, value, offset,
+      GattServerWriteCallbacks(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<BluetoothLocalGattDescriptor>(
+      device, descriptor, offset,
+      GattServerReadCallbacks(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<BluetoothLocalGattDescriptor>(
+      device, descriptor, value, offset,
+      GattServerWriteCallbacks(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 722 matching lines @@
 }
 
 template <class LocalGattAttribute>
 int32_t ArcBluetoothBridge::CreateGattAttributeHandle(
     LocalGattAttribute* gatt_attr) {
   if (!gatt_attr)
     return kInvalidGattAttributeHandle;
   gatt_server_attr_handle++;
   std::string identifier = gatt_attr->GetIdentifier();
   gatt_identifier_[gatt_server_attr_handle] = identifier;
+  gatt_handle_[identifier] = gatt_server_attr_handle;
   return gatt_server_attr_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 66 matching lines @@
   service->Unregister(base::Bind(&ArcBluetoothBridge::OnGattOperationDone,
                                  weak_factory_.GetWeakPtr(), callback),
                       base::Bind(&ArcBluetoothBridge::OnGattOperationError,
                                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void ArcBluetoothBridge::DeleteService(int32_t service_handle,
                                        const DeleteServiceCallback& callback) {
   BluetoothLocalGattService* service =
       bluetooth_adapter_->GetGattService(gatt_identifier_[service_handle]);
+  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) {}
 
 void ArcBluetoothBridge::SendResponse(int32_t trans_id,
                                       int32_t status,
                                       mojo::Array<uint8_t> value,
-                                      const SendResponseCallback& callback) {}
+                                      const SendResponseCallback& callback) {
+  // We used odd transaction_id for read and even id for write.
+  if (trans_id & 1) {  // read
+    DCHECK(gatt_server_read_callbacks_.find(trans_id) !=
+           gatt_server_read_callbacks_.end());
+    if (status) {
+      gatt_server_read_callbacks_[trans_id].error_callback.Run();
+    } else {
+      gatt_server_read_callbacks_[trans_id].success_callback.Run(
+          value.To<std::vector<uint8_t>>());
+    }
+  } else {  // write
+    DCHECK(gatt_server_write_callbacks_.find(trans_id) !=
+           gatt_server_write_callbacks_.end());
+    if (status)
+      gatt_server_write_callbacks_[trans_id].error_callback.Run();
+    else
+      gatt_server_write_callbacks_[trans_id].success_callback.Run();
+  }
+  OnGattOperationDone(callback);
+}
 
 void ArcBluetoothBridge::OnDiscoveryError() {
   LOG(WARNING) << "failed to change discovery state";
 }
 
 void ArcBluetoothBridge::OnPairing(mojom::BluetoothAddressPtr addr) const {
   if (!HasBluetoothInstance())
     return;
 
   arc_bridge_service()->bluetooth()->instance()->OnBondStateChanged(
@@ skipping 319 matching lines @@
     uint32_t version_need) const {
   uint32_t version = arc_bridge_service()->bluetooth()->version();
   if (version >= version_need)
     return true;
   LOG(WARNING) << "Bluetooth instance is too old (version " << version
                << ") need version " << version_need;
   return false;
 }
 
 }  // namespace arc