components/copresence_endpoints/copresence_endpoint.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/copresence_endpoints/public/copresence_endpoint.h"
   6
   7 #include <stdint.h>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/format_macros.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/strings/string_number_conversions.h"
  14 #include "components/copresence_endpoints/transports/bluetooth/copresence_socket_bluetooth.h"
  15 #include "device/bluetooth/bluetooth_adapter.h"
  16 #include "device/bluetooth/bluetooth_adapter_factory.h"
  17 #include "device/bluetooth/bluetooth_device.h"
  18 #include "device/bluetooth/bluetooth_socket.h"
  19 #include "device/bluetooth/bluetooth_uuid.h"
  20
  21 namespace {
  22
  23 const char kAdapterError[] = "NOADAPTER";
  24 const char kSocketServiceUuid[] = "2491fb14-0077-4d4d-bd41-b18e9a570f56";
  25
  26 // This class will confirm pairing for a device that is expecting a pairing
  27 // confirmation.
  28 class DefaultApprovalDelegate
  29     : public device::BluetoothDevice::PairingDelegate {
  30  public:
  31   DefaultApprovalDelegate() {}
  32   ~DefaultApprovalDelegate() override {}
  33
  34   // device::BluetoothDevice::PairingDelegate overrides:
  35   void RequestPinCode(device::BluetoothDevice* device) override {}
  36   void RequestPasskey(device::BluetoothDevice* device) override {}
  37   void DisplayPinCode(device::BluetoothDevice* device,
  38                       const std::string& pincode) override {}
  39   void DisplayPasskey(device::BluetoothDevice* device,
  40                       uint32 passkey) override {}
  41   void KeysEntered(device::BluetoothDevice* device, uint32 entered) override {}
  42   void ConfirmPasskey(device::BluetoothDevice* device,
  43                       uint32 passkey) override {}
  44   void AuthorizePairing(device::BluetoothDevice* device) override {
  45     if (device->ExpectingConfirmation())
  46       device->ConfirmPairing();
  47   }
  48 };
  49
  50 }  // namespace
  51
  52 namespace copresence_endpoints {
  53
  54 CopresenceEndpoint::CopresenceEndpoint(
  55     int endpoint_id,
  56     const CreateEndpointCallback& create_callback,
  57     const base::Closure& accept_callback,
  58     const CopresenceSocket::ReceiveCallback& receive_callback)
  59     : endpoint_id_(endpoint_id),
  60       create_callback_(create_callback),
  61       accept_callback_(accept_callback),
  62       receive_callback_(receive_callback),
  63       delegate_(nullptr),
  64       weak_ptr_factory_(this) {
  65   CHECK(!create_callback.is_null());
  66   CHECK(!accept_callback.is_null());
  67   CHECK(!receive_callback.is_null());
  68
  69   if (!device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
  70     create_callback_.Run(std::string());
  71     return;
  72   }
  73
  74   device::BluetoothAdapterFactory::GetAdapter(base::Bind(
  75       &CopresenceEndpoint::OnGetAdapter, weak_ptr_factory_.GetWeakPtr()));
  76 }
  77
  78 CopresenceEndpoint::~CopresenceEndpoint() {
  79   server_socket_->Disconnect(base::Bind(&base::DoNothing));
  80   server_socket_->Close();
  81   if (delegate_)
  82     adapter_->RemovePairingDelegate(delegate_.get());
  83 }
  84
  85 std::string CopresenceEndpoint::GetLocator() {
  86   if (!adapter_.get())
  87     return kAdapterError;
  88   return base::IntToString(endpoint_id_) + "." + adapter_->GetAddress() + "." +
  89          kSocketServiceUuid;
  90 }
  91
  92 bool CopresenceEndpoint::Send(const scoped_refptr<net::IOBuffer>& buffer,
  93                               int buffer_size) {
  94   if (!client_socket_)
  95     return false;
  96
  97   return client_socket_->Send(buffer, buffer_size);
  98 }
  99
 100 // Private methods.
 101
 102 void CopresenceEndpoint::OnGetAdapter(
 103     scoped_refptr<device::BluetoothAdapter> adapter) {
 104   if (!adapter.get() || !adapter->IsPresent() || !adapter->IsPowered()) {
 105     LOG(WARNING) << "Unable to use BT adapter";
 106     create_callback_.Run(std::string());
 107     return;
 108   }
 109
 110   adapter_ = adapter;
 111   delegate_ = make_scoped_ptr(new DefaultApprovalDelegate());
 112   VLOG(2) << "Got Adapter, creating service with UUID: " << kSocketServiceUuid;
 113   adapter_->AddPairingDelegate(
 114       delegate_.get(),
 115       device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
 116   adapter_->CreateRfcommService(
 117       device::BluetoothUUID(kSocketServiceUuid),
 118       device::BluetoothAdapter::ServiceOptions(),
 119       base::Bind(&CopresenceEndpoint::OnCreateService,
 120                  weak_ptr_factory_.GetWeakPtr()),
 121       base::Bind(&CopresenceEndpoint::OnCreateServiceError,
 122                  weak_ptr_factory_.GetWeakPtr()));
 123 }
 124
 125 void CopresenceEndpoint::OnCreateService(
 126     scoped_refptr<device::BluetoothSocket> socket) {
 127   if (!socket.get()) {
 128     LOG(WARNING) << "Couldn't create service!";
 129     create_callback_.Run(std::string());
 130     return;
 131   }
 132
 133   VLOG(3) << "Starting Accept Socket.";
 134   server_socket_ = socket;
 135   create_callback_.Run(GetLocator());
 136   server_socket_->Accept(
 137       base::Bind(&CopresenceEndpoint::OnAccept, weak_ptr_factory_.GetWeakPtr()),
 138       base::Bind(&CopresenceEndpoint::OnAcceptError,
 139                  weak_ptr_factory_.GetWeakPtr()));
 140 }
 141
 142 void CopresenceEndpoint::OnCreateServiceError(const std::string& message) {
 143   LOG(WARNING) << "Couldn't create Bluetooth service: " << message;
 144   create_callback_.Run(std::string());
 145 }
 146
 147 void CopresenceEndpoint::OnAccept(
 148     const device::BluetoothDevice* device,
 149     scoped_refptr<device::BluetoothSocket> socket) {
 150   if (!socket.get())
 151     return;
 152   VLOG(3) << "Accepted Socket.";
 153   client_socket_.reset(new CopresenceSocketBluetooth(socket));
 154   accept_callback_.Run();
 155   client_socket_->Receive(receive_callback_);
 156 }
 157
 158 void CopresenceEndpoint::OnAcceptError(const std::string& message) {
 159   LOG(WARNING) << "Couldn't accept Bluetooth connection: " << message;
 160 }
 161
 162 }  // namespace copresence_endpoints