arc: bluetooth: Add Gatt server mojo API

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 <bluetooth/bluetooth.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/socket.h>
 
 #include <iomanip>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/bluetooth/bluetooth_type_converters.h"
-#include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_gatt_connection.h"
 #include "device/bluetooth/bluetooth_gatt_notify_session.h"
-#include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
-#include "device/bluetooth/bluetooth_remote_gatt_descriptor.h"
-#include "device/bluetooth/bluetooth_remote_gatt_service.h"
+#include "device/bluetooth/bluetooth_local_gatt_characteristic.h"
+#include "device/bluetooth/bluetooth_local_gatt_descriptor.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
 using device::BluetoothAdvertisement;
 using device::BluetoothDevice;
 using device::BluetoothDiscoveryFilter;
 using device::BluetoothDiscoverySession;
 using device::BluetoothGattConnection;
 using device::BluetoothGattNotifySession;
 using device::BluetoothGattCharacteristic;
 using device::BluetoothGattDescriptor;
 using device::BluetoothGattService;
+using device::BluetoothLocalGattCharacteristic;
+using device::BluetoothLocalGattDescriptor;
+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 uint32_t kGattReadPermission =
     BluetoothGattCharacteristic::Permission::PERMISSION_READ |
     BluetoothGattCharacteristic::Permission::PERMISSION_READ_ENCRYPTED |
     BluetoothGattCharacteristic::Permission::
         PERMISSION_READ_ENCRYPTED_AUTHENTICATED;
@@ skipping 226 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
 }
 
+void ArcBluetoothBridge::OnCharacteristicReadRequest(
+    const BluetoothDevice* device,
+    const BluetoothLocalGattCharacteristic* characteristic,
+    int offset,
+    const ValueCallback& callback,
+    const ErrorCallback& 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) {}
+
+void ArcBluetoothBridge::OnDescriptorReadRequest(
+    const BluetoothDevice* device,
+    const BluetoothLocalGattDescriptor* descriptor,
+    int offset,
+    const ValueCallback& callback,
+    const ErrorCallback& 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) {}
+
+void ArcBluetoothBridge::OnNotificationsStart(
+    const BluetoothDevice* device,
+    const BluetoothLocalGattCharacteristic* characteristic) {}
+
+void ArcBluetoothBridge::OnNotificationsStop(
+    const BluetoothDevice* device,
+    const BluetoothLocalGattCharacteristic* characteristic) {}
+
 void ArcBluetoothBridge::EnableAdapter(const EnableAdapterCallback& callback) {
   DCHECK(bluetooth_adapter_);
   if (!bluetooth_adapter_->IsPowered()) {
     bluetooth_adapter_->SetPowered(
         true, base::Bind(&ArcBluetoothBridge::OnPoweredOn,
                          weak_factory_.GetWeakPtr(), callback),
         base::Bind(&ArcBluetoothBridge::OnPoweredError,
                    weak_factory_.GetWeakPtr(), callback));
     return;
   }
@@ skipping 737 matching lines @@
   if (wrap_result != MOJO_RESULT_OK) {
     LOG(ERROR) << "Failed to wrap handles. Closing: " << wrap_result;
     callback.Run(mojo::ScopedHandle());
     return;
   }
   mojo::ScopedHandle scoped_handle{mojo::Handle(wrapped_handle)};
 
   callback.Run(std::move(scoped_handle));
 }
 
+void ArcBluetoothBridge::AddService(mojom::BluetoothGattServiceIDPtr service_id,
+                                    int32_t num_handles,
+                                    const AddServiceCallback& callback) {}
+
+void ArcBluetoothBridge::AddCharacteristic(
+    int32_t service_handle,
+    mojom::BluetoothUUIDPtr uuid,
+    int32_t properties,
+    int32_t permissions,
+    const AddCharacteristicCallback& callback) {}
+
+void ArcBluetoothBridge::AddDescriptor(int32_t service_handle,
+                                       mojom::BluetoothUUIDPtr uuid,
+                                       int32_t permissions,
+                                       const AddDescriptorCallback& callback) {}
+
+void ArcBluetoothBridge::StartService(int32_t service_handle,
+                                      const StartServiceCallback& callback) {}
+
+void ArcBluetoothBridge::StopService(int32_t service_handle,
+                                     const StopServiceCallback& callback) {}
+
+void ArcBluetoothBridge::DeleteService(int32_t service_handle,
+                                       const DeleteServiceCallback& callback) {}
+
+void ArcBluetoothBridge::SendIndication(
+    int32_t attribute_handle,
+    mojom::BluetoothAddressPtr address,
+    bool confirm,
+    mojo::Array<uint8_t> value,
+    const SendIndicationCallback& 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(
       mojom::BluetoothStatus::SUCCESS, std::move(addr),
@@ skipping 318 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