Prototype for copresenceSockets.

components/copresence_sockets/copresence_peer.cc

+// Copyright 2014 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/copresence_sockets/public/copresence_peer.h"
+
+#include <cstdint>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/rand_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
+#include "components/copresence_sockets/transports/bluetooth/copresence_socket_bluetooth.h"
+#include "device/bluetooth/bluetooth_adapter.h"
+#include "device/bluetooth/bluetooth_adapter_factory.h"
+#include "device/bluetooth/bluetooth_device.h"
+#include "device/bluetooth/bluetooth_socket.h"
+#include "device/bluetooth/bluetooth_uuid.h"
+
+namespace {
+
+device::BluetoothUUID GenerateRandomUuid() {
+  // Random hex string of the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+  return device::BluetoothUUID(base::StringPrintf(
+      "%08lx-%04lx-%04lx-%04lx-%012lx",
+      base::RandGenerator(UINT32_MAX),
+      base::RandGenerator(UINT16_MAX),
+      base::RandGenerator(UINT16_MAX),
+      base::RandGenerator(UINT16_MAX),
+      base::RandGenerator(static_cast<uint64>(UINT16_MAX) + UINT32_MAX)));
+}
+
+// This class will confirm pairing for a device that is expecting a pairing
+// confirmation.
+class DefaultApprovalDelegate
+    : public device::BluetoothDevice::PairingDelegate {
+ public:
+  DefaultApprovalDelegate() {}
+  virtual ~DefaultApprovalDelegate() {}
+
+  // device::BluetoothDevice::PairingDelegate overrides:
+  virtual void RequestPinCode(device::BluetoothDevice* device) override {}
+  virtual void RequestPasskey(device::BluetoothDevice* device) override {}
+  virtual void DisplayPinCode(device::BluetoothDevice* device,
+                              const std::string& pincode) override {}
+  virtual void DisplayPasskey(device::BluetoothDevice* device,
+                              uint32 passkey) override {}
+  virtual void KeysEntered(device::BluetoothDevice* device,
+                           uint32 entered) override {}
+  virtual void ConfirmPasskey(device::BluetoothDevice* device,
+                              uint32 passkey) override {}
+  virtual void AuthorizePairing(device::BluetoothDevice* device) override {
+    if (device->ExpectingConfirmation())
+      device->ConfirmPairing();
+  }
+};
+
+}  // namespace
+
+namespace copresence_sockets {
+
+CopresencePeer::CopresencePeer(const CreatePeerCallback& create_callback,
+                               const AcceptCallback& accept_callback)
+    : create_callback_(create_callback),
+      accept_callback_(accept_callback),
+      delegate_(nullptr),
+      weak_ptr_factory_(this) {
+  DCHECK(!create_callback.is_null());
+  DCHECK(!accept_callback.is_null());
+
+  if (!device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {

[armansito, 2014/10/03 15:27:54]

This check may not be enough to determine if Bluetooth is available. This method
simply returns true if Bluetooth support is built on the current platform (Win,
OSX, CrOS), though this doesn't guarantee that a Bluetooth controller is
actually present.

For that, you can call adapter_->IsPresent() once you obtain the adapter. You
can observe when an adapter gets added or removed by implementing
BluetoothAdapter::Observer::AdapterPresentChanged.

Normally this doesn't really matter, though since copresence wants the ability
to determine the right transport best on availability, this may be important to
you. So experiment with the Bluetooth adapter not being present, manually
plug/unplug an adapter, and see if you're getting the behavior you want.

[rkc, 2014/10/03 21:57:39]

Added the check for IsAdapter() to OnGetAdapter.

If the Adapter is not available at that time, we are not going to attempt a
connection at all and will return an error. We expect the adapter to be present
and *enabled* for this code to work.

The adapter gets added later isn't a case we want to handle presently (we may
revisit this when we are building more fallbacks into the behavior).

[armansito, 2014/10/03 22:43:21]

In that case usually also check if the adapter is enabled by calling
IsPowered(). So, check for IsPresent() && IsPowered().

[rkc, 2014/10/03 22:46:18]

Done.

+    create_callback_.Run(std::string());
+    return;
+  }
+
+  device::BluetoothAdapterFactory::GetAdapter(base::Bind(
+      &CopresencePeer::OnGetAdapter, weak_ptr_factory_.GetWeakPtr()));
+}
+
+std::string CopresencePeer::GetLocatorData() {
+  // TODO(rkc): Fix the "1." once we have finalized the locator format with
+  // other platforms.

[Ryan Sleevi, 2014/10/01 23:38:32]

Is there a bug for this? Is there some way for someone to know if this is ever
met, beyond checking with you?

If there is a bug (always good to file one for TODOs), great to link it here.

[rkc, 2014/10/03 21:57:40]

Yep, added the link here.

+  return "1." + adapter_->GetAddress() + "." + service_uuid_.value();
+}
+
+CopresencePeer::~CopresencePeer() {
+  server_socket_->Disconnect(base::Bind(&base::DoNothing));
+  server_socket_->Close();
+  if (delegate_)
+    adapter_->RemovePairingDelegate(delegate_.get());
+}
+
+// Private methods.

[Ryan Sleevi, 2014/10/01 23:38:32]

Unnecessary

[rkc, 2014/10/03 21:57:40]

Done.

+
+void CopresencePeer::OnGetAdapter(
+    scoped_refptr<device::BluetoothAdapter> adapter) {
+  if (!adapter.get()) {
+    create_callback_.Run(std::string());
+    return;
+  }
+
+  adapter_ = adapter;
+  service_uuid_ = GenerateRandomUuid();
+
+  delegate_ = make_scoped_ptr(new DefaultApprovalDelegate());
+  VLOG(2) << "Creating service with UUID: " << service_uuid_.value();
+  adapter_->AddPairingDelegate(
+      delegate_.get(),
+      device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH);
+  adapter_->CreateRfcommService(
+      service_uuid_,
+      device::BluetoothAdapter::ServiceOptions(),
+      base::Bind(&CopresencePeer::OnCreateService,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&CopresencePeer::OnCreateServiceError,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void CopresencePeer::OnCreateService(
+    scoped_refptr<device::BluetoothSocket> socket) {
+  if (!socket.get()) {
+    create_callback_.Run(std::string());
+    return;
+  }
+
+  server_socket_ = socket;
+  create_callback_.Run(GetLocatorData());
+  server_socket_->Accept(
+      base::Bind(&CopresencePeer::OnAccept, weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&CopresencePeer::OnAcceptError,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void CopresencePeer::OnCreateServiceError(const std::string& message) {
+  LOG(WARNING) << "Couldn't create Bluetooth service: " << message;
+  create_callback_.Run(std::string());
+}
+
+void CopresencePeer::OnAccept(const device::BluetoothDevice* device,
+                              scoped_refptr<device::BluetoothSocket> socket) {
+  if (!socket.get())
+    return;
+  accept_callback_.Run(make_scoped_ptr(new CopresenceSocketBluetooth(socket)));
+}
+
+void CopresencePeer::OnAcceptError(const std::string& message) {
+  LOG(WARNING) << "Couldn't accept Bluetooth connection: " << message;
+}
+
+}  // namespace copresence_sockets