pw_bluetooth_sapphire: Implement Central2::Connect

Implement Central2::Connect and disconnect functionality for Sapphire.
This CL does not implement all of the Connection2 methods.

Rename Connection2::Disconnect to Release for consistency with other
pw_bluetooth classes and for clarity (the destructor will initiate the
disconnect).

Move UuidFrom() into its own header so it can be easily reused.

Bug: b/396449684
Change-Id: Id5309cca6089cdd12a6361939b93abdcf44f860d
Reviewed-on: https://pigweed-review.googlesource.com/c/pigweed/pigweed/+/267692
Commit-Queue: Ben Lawson <benlawson@google.com>
Lint: Lint 🤖 <android-build-ayeaye@system.gserviceaccount.com>
Docs-Not-Needed: Ben Lawson <benlawson@google.com>
Reviewed-by: Faraaz Sareshwala <fsareshwala@google.com>

Author: BenjaminLawson

pw_bluetooth/public/pw_bluetooth/low_energy/connection2.h

@@ -185,15 +185,15 @@ class Connection2 {
       ConnectL2capParameters parameters) = 0;
 
  private:
-  /// Request to disconnect this connection. This method is called by the
-  /// ~Connection::Ptr() when it goes out of scope, the API client should never
+  /// Request to destroy this connection. This method is called by the
+  /// ~Connection2::Ptr() when it goes out of scope, the API client should never
   /// call this method.
-  virtual void Disconnect() = 0;
+  virtual void Release() = 0;
 
  public:
   /// Movable `Connection2` smart pointer. When `Connection::Ptr` is destroyed
   /// the `Connection2` will disconnect automatically.
-  using Ptr = internal::RaiiPtr<Connection2, &Connection2::Disconnect>;
+  using Ptr = internal::RaiiPtr<Connection2, &Connection2::Release>;
 };
 
 }  // namespace pw::bluetooth::low_energy

pw_bluetooth_sapphire/BUILD.bazel

@@ -45,12 +45,48 @@ cc_library(
     strip_include_prefix = "public",
     tags = ["noclangtidy"],
     deps = [
+        ":connection",
+        ":uuid",
         "//pw_bluetooth:pw_bluetooth2",
         "//pw_bluetooth_sapphire/host/gap",
         "//pw_multibuf:allocator",
     ],
 )
 
+cc_library(
+    name = "connection",
+    srcs = [
+        "connection.cc",
+        "connection_options.cc",
+    ],
+    hdrs = [
+        "public/pw_bluetooth_sapphire/internal/connection.h",
+        "public/pw_bluetooth_sapphire/internal/connection_options.h",
+    ],
+    strip_include_prefix = "public",
+    tags = ["noclangtidy"],
+    visibility = ["//visibility:private"],
+    deps = [
+        ":uuid",
+        "//pw_bluetooth:pw_bluetooth2",
+        "//pw_bluetooth_sapphire/host/gap",
+    ],
+)
+
+cc_library(
+    name = "uuid",
+    hdrs = [
+        "public/pw_bluetooth_sapphire/internal/uuid.h",
+    ],
+    strip_include_prefix = "public",
+    visibility = ["//visibility:private"],
+    deps = [
+        "//pw_bluetooth:pw_bluetooth2",
+        "//pw_bluetooth_sapphire/host/common",
+        "//pw_span",
+    ],
+)
+
 pw_cc_test(
     name = "central_test",
     srcs = ["central_test.cc"],

pw_bluetooth_sapphire/BUILD.gn

@@ -49,13 +49,43 @@ pw_source_set("central") {
   public = [ "public/pw_bluetooth_sapphire/central.h" ]
   sources = [ "central.cc" ]
   public_deps = [
+    ":connection",
+    ":uuid",
     "$dir_pw_bluetooth:pw_bluetooth2",
     "$dir_pw_multibuf:allocator",
     "host/gap",
   ]
   public_configs = [ ":public_include_path" ]
 }
 
+pw_source_set("connection") {
+  visibility = [ ":*" ]
+  public = [
+    "public/pw_bluetooth_sapphire/internal/connection.h",
+    "public/pw_bluetooth_sapphire/internal/connection_options.h",
+  ]
+  sources = [
+    "connection.cc",
+    "connection_options.cc",
+  ]
+  public_deps = [
+    ":uuid",
+    "$dir_pw_bluetooth:pw_bluetooth2",
+    "host/gap",
+  ]
+  public_configs = [ ":public_include_path" ]
+}
+
+pw_source_set("uuid") {
+  visibility = [ ":*" ]
+  public = [ "public/pw_bluetooth_sapphire/internal/uuid.h" ]
+  public_configs = [ ":public_include_path" ]
+  deps = [
+    "//pw_bluetooth_sapphire/host/common",
+    "//pw_span",
+  ]
+}
+
 pw_test("central_test") {
   enable_if = pw_bluetooth_sapphire_ENABLED
   sources = [ "central_test.cc" ]

pw_bluetooth_sapphire/central.cc

@@ -14,23 +14,22 @@
 
 #include "pw_bluetooth_sapphire/central.h"
 
+#include "pw_bluetooth_sapphire/internal/connection_options.h"
+#include "pw_bluetooth_sapphire/internal/uuid.h"
+
 namespace pw::bluetooth_sapphire {
 namespace {
 
 pw::sync::Mutex g_peripheral_lock;
 
-bt::UUID UuidFrom(const pw::bluetooth::Uuid& uuid) {
-  return bt::UUID(bt::BufferView(pw::as_bytes(uuid.As128BitSpan())));
-}
-
 bt::gap::DiscoveryFilter DiscoveryFilterFrom(const Central::ScanFilter& in) {
   bt::gap::DiscoveryFilter out;
   if (in.service_uuid.has_value()) {
-    bt::UUID uuid = UuidFrom(in.service_uuid.value());
+    bt::UUID uuid = internal::UuidFrom(in.service_uuid.value());
     out.set_service_uuids(std::vector<bt::UUID>{std::move(uuid)});
   }
   if (in.service_data_uuid.has_value()) {
-    bt::UUID uuid = UuidFrom(in.service_data_uuid.value());
+    bt::UUID uuid = internal::UuidFrom(in.service_data_uuid.value());
     out.set_service_data_uuids(std::vector<bt::UUID>{std::move(uuid)});
   }
   if (in.manufacturer_id.has_value()) {
@@ -46,7 +45,7 @@ bt::gap::DiscoveryFilter DiscoveryFilterFrom(const Central::ScanFilter& in) {
     out.set_pathloss(in.max_path_loss.value());
   }
   if (in.solicitation_uuid.has_value()) {
-    bt::UUID uuid = UuidFrom(in.solicitation_uuid.value());
+    bt::UUID uuid = internal::UuidFrom(in.solicitation_uuid.value());
     out.set_solicitation_uuids(std::vector<bt::UUID>{std::move(uuid)});
   }
   return out;
@@ -108,6 +107,7 @@ Central::Central(bt::gap::Adapter::WeakPtr adapter,
                  pw::multibuf::MultiBufAllocator& allocator)
     : adapter_(std::move(adapter)),
       dispatcher_(dispatcher),
+      heap_dispatcher_(dispatcher),
       allocator_(allocator),
       weak_factory_(this),
       self_(weak_factory_.GetWeakPtr()) {}
@@ -118,11 +118,41 @@ Central::~Central() {
 }
 
 async2::OnceReceiver<Central::ConnectResult> Central::Connect(
-    pw::bluetooth::PeerId,
-    bluetooth::low_energy::Connection2::ConnectionOptions) {
-  // TODO: https://pwbug.dev/377301546 - Implement Connect
-  return async2::OnceReceiver<ConnectResult>(
-      pw::unexpected(ConnectError::kCouldNotBeEstablished));
+    pw::bluetooth::PeerId peer_id,
+    bluetooth::low_energy::Connection2::ConnectionOptions options) {
+  bt::PeerId internal_peer_id(peer_id);
+  bt::gap::LowEnergyConnectionOptions connection_options =
+      internal::ConnectionOptionsFrom(options);
+
+  auto [result_sender, result_receiver] =
+      async2::MakeOnceSenderAndReceiver<ConnectResult>();
+
+  bt::gap::Adapter::LowEnergy::ConnectionResultCallback result_cb =
+      [self = self_,
+       peer = internal_peer_id,
+       sender = std::move(result_sender)](
+          bt::gap::Adapter::LowEnergy::ConnectionResult result) mutable {
+        if (!self.is_alive()) {
+          return;
+        }
+        self->OnConnectionResult(peer, std::move(result), std::move(sender));
+      };
+
+  async::TaskFunction task_fn = [self = self_,
+                                 internal_peer_id,
+                                 connection_options,
+                                 cb = std::move(result_cb)](
+                                    async::Context&, Status status) mutable {
+    if (!status.ok() || !self.is_alive()) {
+      return;
+    }
+    self->adapter_->le()->Connect(
+        internal_peer_id, std::move(cb), connection_options);
+  };
+  Status post_status = heap_dispatcher_.Post(std::move(task_fn));
+  PW_CHECK_OK(post_status);
+
+  return std::move(result_receiver);
 }
 
 async2::OnceReceiver<Central::ScanStartResult> Central::Scan(
@@ -190,7 +220,7 @@ async2::OnceReceiver<Central::ScanStartResult> Central::Scan(
           self->adapter_->le()->StartDiscovery(active, std::move(cb));
         }
       };
-  Status post_status = dispatcher_.Post(std::move(task_fn));
+  Status post_status = heap_dispatcher_.Post(std::move(task_fn));
   PW_CHECK_OK(post_status);
 
   return std::move(result_receiver);
@@ -295,7 +325,7 @@ void Central::StopScanLocked(uint16_t scan_id) {
   }
   iter->second.OnScanHandleDestroyedLocked();
 
-  pw::Status post_status = dispatcher_.Post(
+  pw::Status post_status = heap_dispatcher_.Post(
       [self = self_, scan_id](pw::async::Context, pw::Status status) {
         if (!status.ok() || !self.is_alive()) {
           return;
@@ -306,4 +336,24 @@ void Central::StopScanLocked(uint16_t scan_id) {
   PW_CHECK(post_status.ok());
 }
 
+void Central::OnConnectionResult(
+    bt::PeerId peer_id,
+    bt::gap::Adapter::LowEnergy::ConnectionResult result,
+    async2::OnceSender<ConnectResult> result_sender) {
+  if (result.is_error()) {
+    if (result.error_value() == bt::HostError::kNotFound) {
+      result_sender.emplace(pw::unexpected(ConnectError::kUnknownPeer));
+    } else {
+      result_sender.emplace(
+          pw::unexpected(ConnectError::kCouldNotBeEstablished));
+    }
+    return;
+  }
+
+  pw::bluetooth::low_energy::Connection2::Ptr connection_ptr(
+      new internal::Connection(
+          peer_id, std::move(result.value()), dispatcher_));
+  result_sender.emplace(std::move(connection_ptr));
+}
+
 }  // namespace pw::bluetooth_sapphire

pw_bluetooth_sapphire/central_test.cc

@@ -36,6 +36,8 @@ using pw::async2::PendFuncTask;
 using pw::async2::Poll;
 using pw::chrono::SystemClock;
 using ScanFilter = Central::ScanFilter;
+using DisconnectReason =
+    pw::bluetooth::low_energy::Connection2::DisconnectReason;
 
 const bt::DeviceAddress kAddress0(bt::DeviceAddress::Type::kLEPublic, {0});
 const bt::StaticByteBuffer kAdvDataWithName(0x05,  // length
@@ -108,6 +110,8 @@ class CentralTest : public ::testing::Test {
 
   void DestroyCentral() { central_.reset(); }
 
+  auto connections() { return adapter().fake_le()->connections(); }
+
   bt::gap::testing::FakeAdapter& adapter() { return adapter_; }
   bt::gap::PeerCache& peer_cache() { return *adapter_.peer_cache(); }
   pw::bluetooth_sapphire::Central& central() { return central_.value(); }
@@ -480,4 +484,87 @@ TEST_F(CentralTest, CentralDestroyedBeforeScanHandle) {
   scan_handle.reset();
 }
 
+TEST_F(CentralTest, ConnectAndDisconnectSuccess) {
+  bt::gap::Peer* peer = peer_cache().NewPeer(kAddress0, /*connectable=*/true);
+  pw::bluetooth::low_energy::Connection2::ConnectionOptions options;
+  std::optional<pw::Result<Central::ConnectResult>> connect_result;
+  pw::async2::OnceReceiver<Central::ConnectResult> receiver =
+      central().Connect(peer->identifier().value(), options);
+  PendFuncTask connect_task =
+      PendFuncTask([&connect_result, &receiver](Context& cx) -> Poll<> {
+        Poll<pw::Result<Central::ConnectResult>> poll = receiver.Pend(cx);
+        if (poll.IsPending()) {
+          return Pending();
+        }
+        connect_result = std::move(poll->value());
+        return Ready();
+      });
+  async2_dispatcher().Post(connect_task);
+  EXPECT_TRUE(async2_dispatcher().RunUntilStalled().IsPending());
+  async_dispatcher().RunUntilIdle();
+  EXPECT_TRUE(async2_dispatcher().RunUntilStalled().IsReady());
+  ASSERT_TRUE(connect_result.has_value());
+  ASSERT_TRUE(connect_result->ok());
+  ASSERT_TRUE(connect_result->value());
+  ASSERT_EQ(adapter().fake_le()->connections().count(peer->identifier()), 1u);
+  pw::bluetooth::low_energy::Connection2::Ptr connection =
+      std::move(connect_result->value().value());
+
+  // Disconnect
+  connection.reset();
+  ASSERT_EQ(connections().count(peer->identifier()), 1u);
+  async_dispatcher().RunUntilIdle();
+  ASSERT_EQ(connections().count(peer->identifier()), 0u);
+}
+
+TEST_F(CentralTest, PendDisconnect) {
+  bt::gap::Peer* peer = peer_cache().NewPeer(kAddress0, /*connectable=*/true);
+  pw::bluetooth::low_energy::Connection2::ConnectionOptions options;
+  std::optional<pw::Result<Central::ConnectResult>> connect_result;
+  pw::async2::OnceReceiver<Central::ConnectResult> receiver =
+      central().Connect(peer->identifier().value(), options);
+  PendFuncTask connect_task =
+      PendFuncTask([&connect_result, &receiver](Context& cx) -> Poll<> {
+        Poll<pw::Result<Central::ConnectResult>> poll = receiver.Pend(cx);
+        if (poll.IsPending()) {
+          return Pending();
+        }
+        connect_result = std::move(poll->value());
+        return Ready();
+      });
+  async2_dispatcher().Post(connect_task);
+  EXPECT_TRUE(async2_dispatcher().RunUntilStalled().IsPending());
+  async_dispatcher().RunUntilIdle();
+  EXPECT_TRUE(async2_dispatcher().RunUntilStalled().IsReady());
+  ASSERT_TRUE(connect_result.has_value());
+  ASSERT_TRUE(connect_result->ok());
+  ASSERT_TRUE(connect_result->value());
+  ASSERT_EQ(adapter().fake_le()->connections().count(peer->identifier()), 1u);
+  pw::bluetooth::low_energy::Connection2::Ptr connection =
+      std::move(connect_result->value().value());
+
+  std::optional<DisconnectReason> disconnect_reason;
+  PendFuncTask disconnect_task =
+      PendFuncTask([&connection, &disconnect_reason](Context& cx) -> Poll<> {
+        Poll<DisconnectReason> poll = connection->PendDisconnect(cx);
+        if (poll.IsPending()) {
+          return Pending();
+        }
+        disconnect_reason = poll.value();
+        return Ready();
+      });
+  async2_dispatcher().Post(disconnect_task);
+  EXPECT_TRUE(async2_dispatcher().RunUntilStalled().IsPending());
+  ASSERT_FALSE(disconnect_reason.has_value());
+
+  ASSERT_TRUE(adapter().fake_le()->Disconnect(peer->identifier()));
+  ASSERT_EQ(adapter().fake_le()->connections().count(peer->identifier()), 0u);
+  EXPECT_TRUE(async2_dispatcher().RunUntilStalled().IsReady());
+  ASSERT_TRUE(disconnect_reason.has_value());
+  EXPECT_EQ(disconnect_reason.value(), DisconnectReason::kFailure);
+
+  connection.reset();
+  async_dispatcher().RunUntilIdle();
+}
+
 }  // namespace