arc: bluetooth: Implement Gatt notify

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 27 matching lines @@
 using device::BluetoothGattNotifySession;
 using device::BluetoothGattCharacteristic;
 using device::BluetoothGattDescriptor;
 using device::BluetoothGattService;
 using device::BluetoothRemoteGattCharacteristic;
 using device::BluetoothRemoteGattDescriptor;
 using device::BluetoothRemoteGattService;
 using device::BluetoothUUID;
 
 namespace {
-const int kMinBtleVersion = 1;
-const uint32_t kGattReadPermission =
+constexpr int32_t kMinBtleVersion = 1;
+constexpr int32_t kMinBtleNotifyVersion = 2;
+constexpr uint32_t kGattReadPermission =
     BluetoothGattCharacteristic::Permission::PERMISSION_READ |
     BluetoothGattCharacteristic::Permission::PERMISSION_READ_ENCRYPTED |
     BluetoothGattCharacteristic::Permission::
         PERMISSION_READ_ENCRYPTED_AUTHENTICATED;
-const uint32_t kGattWritePermission =
+constexpr uint32_t kGattWritePermission =
     BluetoothGattCharacteristic::Permission::PERMISSION_WRITE |
     BluetoothGattCharacteristic::Permission::PERMISSION_WRITE_ENCRYPTED |
     BluetoothGattCharacteristic::Permission::
         PERMISSION_WRITE_ENCRYPTED_AUTHENTICATED;
 }  // namespace
 
 namespace arc {
 
 ArcBluetoothBridge::ArcBluetoothBridge(ArcBridgeService* bridge_service)
     : ArcService(bridge_service), binding_(this), weak_factory_(this) {
@@ skipping 59 matching lines @@
 
   if (device->IsConnected())
     return;
 
   mojo::Array<mojom::BluetoothPropertyPtr> properties =
       GetDeviceProperties(mojom::BluetoothPropertyType::ALL, device);
 
   arc_bridge_service()->bluetooth_instance()->OnDeviceFound(
       std::move(properties));
 
-  if (arc_bridge_service()->bluetooth_version() < kMinBtleVersion) {
-    LOG(WARNING) << "Bluetooth instance is too old and does not support BTLE";
+  if (!CheckBluetoothInstanceVersion(kMinBtleVersion))
     return;
-  }
 
   mojom::BluetoothAddressPtr addr =
       mojom::BluetoothAddress::From(device->GetAddress());
   int rssi = device->GetInquiryRSSI();
   mojo::Array<mojom::BluetoothAdvertisingDataPtr> adv_data =
       GetAdvertisingData(device);
   arc_bridge_service()->bluetooth_instance()->OnLEDeviceFound(
       std::move(addr), rssi, std::move(adv_data));
 }
 
@@ skipping 50 matching lines @@
     BluetoothDevice* device,
     BluetoothRemoteGattService* service) {
   // Placeholder for GATT client functionality
 }
 
 void ArcBluetoothBridge::GattServicesDiscovered(BluetoothAdapter* adapter,
                                                 BluetoothDevice* device) {
   if (!HasBluetoothInstance())
     return;
 
-  if (arc_bridge_service()->bluetooth_version() < kMinBtleVersion) {
-    LOG(WARNING) << "Bluetooth instance is too old and does not support BTLE";
+  if (!CheckBluetoothInstanceVersion(kMinBtleVersion))
     return;
-  }
 
   mojom::BluetoothAddressPtr addr =
       mojom::BluetoothAddress::From(device->GetAddress());
 
   arc_bridge_service()->bluetooth_instance()->OnSearchComplete(
       std::move(addr), mojom::BluetoothGattStatus::GATT_SUCCESS);
 }
 
 void ArcBluetoothBridge::GattDiscoveryCompleteForService(
     BluetoothAdapter* adapter,
@@ skipping 28 matching lines @@
 void ArcBluetoothBridge::GattDescriptorRemoved(
     BluetoothAdapter* adapter,
     BluetoothRemoteGattDescriptor* descriptor) {
   // Placeholder for GATT client functionality
 }
 
 void ArcBluetoothBridge::GattCharacteristicValueChanged(
     BluetoothAdapter* adapter,
     BluetoothRemoteGattCharacteristic* characteristic,
     const std::vector<uint8_t>& value) {
-  // Placeholder for GATT client functionality
+  if (!HasBluetoothInstance())
+    return;
+
+  if (!CheckBluetoothInstanceVersion(kMinBtleNotifyVersion))
+    return;
+
+  BluetoothRemoteGattService* service = characteristic->GetService();
+  BluetoothDevice* device = service->GetDevice();
+  mojom::BluetoothAddressPtr address =
+      mojom::BluetoothAddress::From(device->GetAddress());
+  mojom::BluetoothGattServiceIDPtr service_id =
+      mojom::BluetoothGattServiceID::New();
+  service_id->is_primary = service->IsPrimary();
+  service_id->id = mojom::BluetoothGattID::New();
+  service_id->id->inst_id = ConvertGattIdentifierToId(service->GetIdentifier());
+  service_id->id->uuid = mojom::BluetoothUUID::From(service->GetUUID());
+
+  mojom::BluetoothGattIDPtr char_id = mojom::BluetoothGattID::New();
+  char_id->inst_id = ConvertGattIdentifierToId(characteristic->GetIdentifier());
+  char_id->uuid = mojom::BluetoothUUID::From(characteristic->GetUUID());
+
+  arc_bridge_service()->bluetooth_instance()->OnGattNotify(
+      std::move(address), std::move(service_id), std::move(char_id),
+      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
 }
 
 void ArcBluetoothBridge::EnableAdapter(const EnableAdapterCallback& callback) {
@@ skipping 259 matching lines @@
 void ArcBluetoothBridge::StopLEScan() {
   CancelDiscovery();
 }
 
 void ArcBluetoothBridge::OnGattConnectStateChanged(
     mojom::BluetoothAddressPtr addr,
     bool connected) const {
   if (!HasBluetoothInstance())
     return;
 
-  if (arc_bridge_service()->bluetooth_version() < kMinBtleVersion) {
-    LOG(WARNING) << "Bluetooth instance is too old and does not support BTLE";
+  if (!CheckBluetoothInstanceVersion(kMinBtleVersion))
     return;
-  }
 
   DCHECK(addr);
 
   arc_bridge_service()->bluetooth_instance()->OnLEConnectionStateChange(
       std::move(addr), connected);
 }
 
 void ArcBluetoothBridge::OnGattConnected(
     mojom::BluetoothAddressPtr addr,
     std::unique_ptr<BluetoothGattConnection> connection) const {
@@ skipping 341 matching lines @@
     mojom::BluetoothGattIDPtr char_id,
     mojom::BluetoothGattIDPtr desc_id,
     mojom::BluetoothGattValuePtr value,
     const WriteGattDescriptorCallback& callback) {
   BluetoothRemoteGattDescriptor* descriptor =
       FindGattDescriptor(std::move(remote_addr), std::move(service_id),
                          std::move(char_id), std::move(desc_id));
   DCHECK(descriptor);
   DCHECK(descriptor->GetPermissions() & kGattWritePermission);
 
+  // To register / deregister GATT notification, we need to
+  // 1) Write to CCC Descriptor to enable/disable the notification
+  // 2) Ask BT hw to register / deregister the notification
+  // The Chrome API groups both steps into one API, and does not support writing
+  // directly to the CCC Descriptor. Therefore, until we fix
+  // https://crbug.com/622832, we return successfully when we encounter this.
+  // TODO(http://crbug.com/622832)
+  if (descriptor->GetUUID() ==
+      BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid()) {
+    OnGattWriteDone(callback);
+    return;
+  }
+
   descriptor->WriteRemoteDescriptor(
       value->value.To<std::vector<uint8_t>>(),
       base::Bind(&ArcBluetoothBridge::OnGattWriteDone,
                  weak_factory_.GetWeakPtr(), callback),
       base::Bind(&ArcBluetoothBridge::OnGattWriteError,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void ArcBluetoothBridge::OnGattNotifyStartDone(
     const RegisterForGattNotificationCallback& callback,
@@ skipping 395 matching lines @@
     // OnBondStateChanged must be called with mojom::BluetoothBondState::BONDING
     // to
     // make sure the bond state machine on Android is ready to take the
     // pair-done event. Otherwise the pair-done event will be dropped as an
     // invalid change of paired status.
     OnPairing(addr->Clone());
     OnPairedDone(std::move(addr));
   }
 }
 
+bool ArcBluetoothBridge::CheckBluetoothInstanceVersion(
+    int32_t version_need) const {
+  int32_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