bluetooth: Add Device connection logic and accompanying user interface.

device/bluetooth/adapter.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 <string>
 #include <utility>
 #include <vector>
 
 #include "device/bluetooth/adapter.h"
 #include "device/bluetooth/device.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
 
 namespace bluetooth {
+namespace {
+mojom::ConnectResult BluetoothErrorCodeToMojomResult(
+    device::BluetoothDevice::ConnectErrorCode error_code) {
+  switch (error_code) {
+    case device::BluetoothDevice::ConnectErrorCode::
+        ERROR_ATTRIBUTE_LENGTH_INVALID:
+      return mojom::ConnectResult::ATTRIBUTE_LENGTH_INVALID;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_AUTH_CANCELED:
+      return mojom::ConnectResult::AUTH_CANCELED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_AUTH_FAILED:
+      return mojom::ConnectResult::AUTH_FAILED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_AUTH_REJECTED:
+      return mojom::ConnectResult::AUTH_REJECTED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_AUTH_TIMEOUT:
+      return mojom::ConnectResult::AUTH_TIMEOUT;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_CONNECTION_CONGESTED:
+      return mojom::ConnectResult::CONNECTION_CONGESTED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_FAILED:
+      return mojom::ConnectResult::FAILED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_INPROGRESS:
+      return mojom::ConnectResult::INPROGRESS;
+    case device::BluetoothDevice::ConnectErrorCode::
+        ERROR_INSUFFICIENT_ENCRYPTION:
+      return mojom::ConnectResult::INSUFFICIENT_ENCRYPTION;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_OFFSET_INVALID:
+      return mojom::ConnectResult::OFFSET_INVALID;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_READ_NOT_PERMITTED:
+      return mojom::ConnectResult::READ_NOT_PERMITTED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_REQUEST_NOT_SUPPORTED:
+      return mojom::ConnectResult::REQUEST_NOT_SUPPORTED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_UNKNOWN:
+      return mojom::ConnectResult::UNKNOWN;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_UNSUPPORTED_DEVICE:
+      return mojom::ConnectResult::UNSUPPORTED_DEVICE;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_WRITE_NOT_PERMITTED:
+      return mojom::ConnectResult::WRITE_NOT_PERMITTED;
+    case device::BluetoothDevice::ConnectErrorCode::NUM_CONNECT_ERROR_CODES:
+      NOTREACHED();
+      return mojom::ConnectResult::UNTRANSLATED_CONNECT_ERROR_CODE;
+  }
+  NOTREACHED();
+  return mojom::ConnectResult::UNTRANSLATED_CONNECT_ERROR_CODE;
+}
+}  // namespace
 
 Adapter::Adapter(scoped_refptr<device::BluetoothAdapter> adapter)
     : adapter_(std::move(adapter)), client_(nullptr), weak_ptr_factory_(this) {
   adapter_->AddObserver(this);
 }
 
 Adapter::~Adapter() {
   adapter_->RemoveObserver(this);
   adapter_ = nullptr;
 }
 
 void Adapter::GetInfo(const GetInfoCallback& callback) {
   mojom::AdapterInfoPtr adapter_info = mojom::AdapterInfo::New();
   adapter_info->address = adapter_->GetAddress();
   adapter_info->name = adapter_->GetName();
   adapter_info->initialized = adapter_->IsInitialized();
   adapter_info->present = adapter_->IsPresent();
   adapter_info->powered = adapter_->IsPowered();
   adapter_info->discoverable = adapter_->IsDiscoverable();
   adapter_info->discovering = adapter_->IsDiscovering();
   callback.Run(std::move(adapter_info));
 }
 
-void Adapter::GetDevice(const std::string& address,
-                        const GetDeviceCallback& callback) {
-  mojom::DevicePtr device_ptr;
-  mojo::MakeStrongBinding(base::MakeUnique<Device>(address, adapter_),
-                          mojo::GetProxy(&device_ptr));
-  callback.Run(std::move(device_ptr));
+void Adapter::ConnectToDevice(const std::string& address,
+                              const ConnectToDeviceCallback& callback) {
+  device::BluetoothDevice* device = adapter_->GetDevice(address);
+
+  if (!device) {
+    callback.Run(mojom::ConnectResult::DEVICE_NO_LONGER_IN_RANGE,
+                 nullptr /* device */);
+    return;
+  }
+
+  device->CreateGattConnection(
+      base::Bind(&Adapter::OnGattConnected, weak_ptr_factory_.GetWeakPtr(),
+                 callback),
+      base::Bind(&Adapter::OnConnectError, weak_ptr_factory_.GetWeakPtr(),
+                 callback));
 }
 
 void Adapter::GetDevices(const GetDevicesCallback& callback) {
   std::vector<mojom::DeviceInfoPtr> devices;
 
   for (const device::BluetoothDevice* device : adapter_->GetDevices()) {
     mojom::DeviceInfoPtr device_info =
         Device::ConstructDeviceInfoStruct(device);
     devices.push_back(std::move(device_info));
   }
@@ skipping 22 matching lines @@
 }
 
 void Adapter::DeviceChanged(device::BluetoothAdapter* adapter,
                             device::BluetoothDevice* device) {
   if (client_) {
     auto device_info = Device::ConstructDeviceInfoStruct(device);
     client_->DeviceChanged(std::move(device_info));
   }
 }
 
+void Adapter::OnGattConnected(
+    const ConnectToDeviceCallback& callback,
+    std::unique_ptr<device::BluetoothGattConnection> connection) {
+  mojom::DevicePtr device_ptr;
+
+  // Owns itself.
+  new Device(adapter_, std::move(connection), mojo::GetProxy(&device_ptr));
+
+  callback.Run(mojom::ConnectResult::SUCCESS, std::move(device_ptr));
+}
+
+void Adapter::OnConnectError(
+    const ConnectToDeviceCallback& callback,
+    device::BluetoothDevice::ConnectErrorCode error_code) {
+  mojom::ConnectResult code = BluetoothErrorCodeToMojomResult(error_code);
+  callback.Run(code, nullptr /* Device */);
+}
 }  // namespace bluetooth