arc: bluetooth: Implement Gatt Server add/delete/start/stop service

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 31 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;
+constexpr int32_t kInvalidGattAttributeHandle = -1;
 }  // 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 782 matching lines @@
     mojom::BluetoothGattIDPtr desc_id) const {
   BluetoothRemoteGattCharacteristic* characteristic = FindGattCharacteristic(
       std::move(remote_addr), std::move(service_id), std::move(char_id));
   if (!characteristic)
     return nullptr;
 
   return FindGattObjectFromUuid<BluetoothRemoteGattDescriptor>(
       characteristic->GetDescriptors(), desc_id->uuid.To<BluetoothUUID>());
 }
 
+// Common callback function for Gatt operation that only need to report
+// Gatt status back to Android.
+void ArcBluetoothBridge::OnGattOperationDone(
+    const GattStatusCallback& callback) const {
+  callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
+}
+
+void ArcBluetoothBridge::OnGattOperationError(
+    const GattStatusCallback& callback,
+    BluetoothGattService::GattErrorCode error_code) const {
+  callback.Run(mojo::ConvertTo<mojom::BluetoothGattStatus>(error_code));
+}
+
 // Same callback for both ReadGattCharacteristic and ReadGattDescriptor
 void ArcBluetoothBridge::OnGattReadDone(
     const GattReadCallback& callback,
     const std::vector<uint8_t>& result) const {
   mojom::BluetoothGattValuePtr gattValue = mojom::BluetoothGattValue::New();
   gattValue->status = mojom::BluetoothGattStatus::GATT_SUCCESS;
   gattValue->value = mojo::Array<uint8_t>::From(result);
   callback.Run(std::move(gattValue));
 }
 
 void ArcBluetoothBridge::OnGattReadError(
     const GattReadCallback& callback,
     BluetoothGattService::GattErrorCode error_code) const {
   mojom::BluetoothGattValuePtr gattValue = mojom::BluetoothGattValue::New();
   gattValue->status = mojo::ConvertTo<mojom::BluetoothGattStatus>(error_code);
   gattValue->value = nullptr;
 
   callback.Run(std::move(gattValue));
 }
 
-// Same callback for both WriteGattCharacteristic and WriteGattDescriptor
-void ArcBluetoothBridge::OnGattWriteDone(
-    const GattWriteCallback& callback) const {
-  callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
-}
-
-void ArcBluetoothBridge::OnGattWriteError(
-    const GattWriteCallback& callback,
-    BluetoothGattService::GattErrorCode error_code) const {
-  callback.Run(mojo::ConvertTo<mojom::BluetoothGattStatus>(error_code));
-}
-
 void ArcBluetoothBridge::ReadGattCharacteristic(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     const ReadGattCharacteristicCallback& callback) {
   BluetoothRemoteGattCharacteristic* characteristic = FindGattCharacteristic(
       std::move(remote_addr), std::move(service_id), std::move(char_id));
   DCHECK(characteristic);
   DCHECK(characteristic->GetPermissions() & kGattReadPermission);
 
@@ skipping 10 matching lines @@
     mojom::BluetoothGattIDPtr char_id,
     mojom::BluetoothGattValuePtr value,
     const WriteGattCharacteristicCallback& callback) {
   BluetoothRemoteGattCharacteristic* characteristic = FindGattCharacteristic(
       std::move(remote_addr), std::move(service_id), std::move(char_id));
   DCHECK(characteristic);
   DCHECK(characteristic->GetPermissions() & kGattWritePermission);
 
   characteristic->WriteRemoteCharacteristic(
       value->value.To<std::vector<uint8_t>>(),
-      base::Bind(&ArcBluetoothBridge::OnGattWriteDone,
+      base::Bind(&ArcBluetoothBridge::OnGattOperationDone,
                  weak_factory_.GetWeakPtr(), callback),
-      base::Bind(&ArcBluetoothBridge::OnGattWriteError,
+      base::Bind(&ArcBluetoothBridge::OnGattOperationError,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void ArcBluetoothBridge::ReadGattDescriptor(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     mojom::BluetoothGattIDPtr desc_id,
     const ReadGattDescriptorCallback& callback) {
   BluetoothRemoteGattDescriptor* descriptor =
@@ skipping 24 matching lines @@
 
   // 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);
+    OnGattOperationDone(callback);
     return;
   }
 
   descriptor->WriteRemoteDescriptor(
       value->value.To<std::vector<uint8_t>>(),
-      base::Bind(&ArcBluetoothBridge::OnGattWriteDone,
+      base::Bind(&ArcBluetoothBridge::OnGattOperationDone,
                  weak_factory_.GetWeakPtr(), callback),
-      base::Bind(&ArcBluetoothBridge::OnGattWriteError,
+      base::Bind(&ArcBluetoothBridge::OnGattOperationError,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void ArcBluetoothBridge::OnGattNotifyStartDone(
     const RegisterForGattNotificationCallback& callback,
     const std::string char_string_id,
     std::unique_ptr<BluetoothGattNotifySession> notify_session) {
   notification_session_[char_string_id] = std::move(notify_session);
   callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
 }
 
-void ArcBluetoothBridge::OnGattNotifyStartError(
-    const RegisterForGattNotificationCallback& callback,
-    BluetoothGattService::GattErrorCode error_code) const {
-  callback.Run(mojo::ConvertTo<mojom::BluetoothGattStatus>(error_code));
-}
-
-void ArcBluetoothBridge::OnGattNotifyStopDone(
-    const DeregisterForGattNotificationCallback& callback) const {
-  callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
-}
-
 void ArcBluetoothBridge::RegisterForGattNotification(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     const RegisterForGattNotificationCallback& callback) {
   BluetoothRemoteGattCharacteristic* characteristic = FindGattCharacteristic(
       std::move(remote_addr), std::move(service_id), std::move(char_id));
 
   if (!characteristic) {
     LOG(WARNING) << __func__ << " Characteristic is not existed.";
     return;
   }
 
   if (characteristic->IsNotifying()) {
     callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
     return;
   }
 
   characteristic->StartNotifySession(
       base::Bind(&ArcBluetoothBridge::OnGattNotifyStartDone,
                  weak_factory_.GetWeakPtr(), callback,
                  characteristic->GetIdentifier()),
-      base::Bind(&ArcBluetoothBridge::OnGattNotifyStartError,
+      base::Bind(&ArcBluetoothBridge::OnGattOperationError,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void ArcBluetoothBridge::DeregisterForGattNotification(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothGattServiceIDPtr service_id,
     mojom::BluetoothGattIDPtr char_id,
     const DeregisterForGattNotificationCallback& callback) {
   BluetoothRemoteGattCharacteristic* characteristic = FindGattCharacteristic(
       std::move(remote_addr), std::move(service_id), std::move(char_id));
 
   if (!characteristic) {
     LOG(WARNING) << __func__ << " Characteristic is not existed.";
     return;
   }
 
   if (!characteristic->IsNotifying()) {
     callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
     return;
   }
 
   std::string char_id_str = characteristic->GetIdentifier();
   std::unique_ptr<BluetoothGattNotifySession> notify =
       std::move(notification_session_[char_id_str]);
   notification_session_.erase(char_id_str);
-  notify->Stop(base::Bind(&ArcBluetoothBridge::OnGattNotifyStopDone,
+  notify->Stop(base::Bind(&ArcBluetoothBridge::OnGattOperationDone,
                           weak_factory_.GetWeakPtr(), callback));
 }
 
 void ArcBluetoothBridge::ReadRemoteRssi(
     mojom::BluetoothAddressPtr remote_addr,
     const ReadRemoteRssiCallback& callback) {
   BluetoothDevice* device =
       bluetooth_adapter_->GetDevice(remote_addr->To<std::string>());
   int rssi = device->GetInquiryRSSI();
   callback.Run(rssi);
 }
 
+template <class T>

[rkc, 2016/07/14 23:15:25]

template <class Attribute>

[puthik_chromium, 2016/07/15 21:49:33]

Done. I think LocalGattObjectT sound better as we use it for
LocalGatt[service/characteristic/descriptor]

+int32_t ArcBluetoothBridge::CreateGattAttributeHandle(T* gatt_obj) {
+  if (!gatt_obj)
+    return kInvalidGattAttributeHandle;
+  gatt_server_obj_handle++;
+  std::string identifier = gatt_obj->GetIdentifier();
+  gatt_identifier_[gatt_server_obj_handle] = identifier;
+  return gatt_server_obj_handle;
+}
+
 void ArcBluetoothBridge::AddService(mojom::BluetoothGattServiceIDPtr service_id,
                                     int32_t num_handles,
-                                    const AddServiceCallback& callback) {}
+                                    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 */,
+          this /* delegate*/);
+  callback.Run(
+      CreateGattAttributeHandle<BluetoothLocalGattService>(service.get()));
+}
 
 void ArcBluetoothBridge::AddCharacteristic(
     int32_t service_handle,
     mojom::BluetoothUUIDPtr uuid,
     int32_t properties,
     int32_t permissions,
-    const AddCharacteristicCallback& callback) {}
+    const AddCharacteristicCallback& callback) {
+  base::WeakPtr<BluetoothLocalGattCharacteristic> characteristic =
+      BluetoothLocalGattCharacteristic::Create(
+          uuid.To<BluetoothUUID>(), properties, permissions,
+          bluetooth_adapter_->GetGattService(gatt_identifier_[service_handle]));
+  int32_t characteristic_handle =
+      CreateGattAttributeHandle<BluetoothLocalGattCharacteristic>(
+          characteristic.get());
+  last_characteristic_[service_handle] = characteristic_handle;
+  callback.Run(characteristic_handle);
+}
 
 void ArcBluetoothBridge::AddDescriptor(int32_t service_handle,
                                        mojom::BluetoothUUIDPtr uuid,
                                        int32_t permissions,
-                                       const AddDescriptorCallback& callback) {}
+                                       const AddDescriptorCallback& callback) {
+  // Chrome automatically add CCC Descriptor to a characteristic when needed.
+  // So we will just generate bogus handle for android.
+  if (uuid.To<BluetoothUUID>() ==
+      BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid()) {
+    gatt_server_obj_handle++;
+    callback.Run(gatt_server_obj_handle);
+    return;
+  }
+
+  BluetoothLocalGattService* service =
+      bluetooth_adapter_->GetGattService(gatt_identifier_[service_handle]);
+  // Since Android API does not give information which characteristic is the
+  // parent of the new descriptor. We will just assume that it would be the
+  // last characteristic that was added to the given service. This matches the
+  BluetoothLocalGattCharacteristic* characteristic = service->GetCharacteristic(
+      gatt_identifier_[last_characteristic_[service_handle]]);
+
+  base::WeakPtr<BluetoothLocalGattDescriptor> descriptor =
+      BluetoothLocalGattDescriptor::Create(uuid.To<BluetoothUUID>(),
+                                           permissions, characteristic);
+  callback.Run(CreateGattAttributeHandle<BluetoothLocalGattDescriptor>(
+      descriptor.get()));
+}
 
 void ArcBluetoothBridge::StartService(int32_t service_handle,
-                                      const StartServiceCallback& callback) {}
+                                      const StartServiceCallback& callback) {
+  BluetoothLocalGattService* service =
+      bluetooth_adapter_->GetGattService(gatt_identifier_[service_handle]);
+  service->Register(base::Bind(&ArcBluetoothBridge::OnGattOperationDone,
+                               weak_factory_.GetWeakPtr(), callback),
+                    base::Bind(&ArcBluetoothBridge::OnGattOperationError,
+                               weak_factory_.GetWeakPtr(), callback));
+}
 
 void ArcBluetoothBridge::StopService(int32_t service_handle,
-                                     const StopServiceCallback& callback) {}
+                                     const StopServiceCallback& callback) {
+  BluetoothLocalGattService* service =
+      bluetooth_adapter_->GetGattService(gatt_identifier_[service_handle]);
+  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) {}
+                                       const DeleteServiceCallback& callback) {
+  BluetoothLocalGattService* service =
+      bluetooth_adapter_->GetGattService(gatt_identifier_[service_handle]);
+  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,
@@ skipping 331 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