Roll forward to cl/328359974

Change-Id: If2b57ecc852aecf7dea454648f485fd7c08e72a9

cpp/platform_v2/public/BUILD

@@ -45,10 +45,12 @@ cc_library(
 cc_library(
     name = "comm",
     srcs = [
+        "ble.cc",
         "bluetooth_classic.cc",
         "wifi_lan.cc",
     ],
     hdrs = [
+        "ble.h",
         "bluetooth_adapter.h",
         "bluetooth_classic.h",
         "webrtc.h",
@@ -91,6 +93,7 @@ cc_test(
     srcs = [
         "atomic_boolean_test.cc",
         "atomic_reference_test.cc",
+        "ble_test.cc",
         "bluetooth_adapter_test.cc",
         "bluetooth_classic_test.cc",
         "cancelable_alarm_test.cc",
@@ -115,6 +118,7 @@ cc_test(
         "//platform_v2/base:test_util",
         "//platform_v2/impl/g3",  # build_cleaner: keep
         "//testing/base/public:gunit_main",
+        "//absl/strings",
         "//absl/synchronization",
         "//absl/time",
     ],

cpp/platform_v2/public/ble.cc

@@ -0,0 +1,127 @@
+#include "platform_v2/public/ble.h"
+
+#include "platform_v2/public/logging.h"
+#include "platform_v2/public/mutex_lock.h"
+
+namespace location {
+namespace nearby {
+
+bool BleMedium::StartAdvertising(const std::string& service_id,
+                                 const ByteArray& advertisement_bytes) {
+  return impl_->StartAdvertising(service_id, advertisement_bytes);
+}
+
+bool BleMedium::StopAdvertising(const std::string& service_id) {
+  return impl_->StopAdvertising(service_id);
+}
+
+bool BleMedium::StartScanning(const std::string& service_id,
+                              DiscoveredPeripheralCallback callback) {
+  {
+    MutexLock lock(&mutex_);
+    discovered_peripheral_callback_ = std::move(callback);
+    peripherals_.clear();
+  }
+  return impl_->StartScanning(
+      service_id,
+      {
+          .peripheral_discovered_cb =
+              [this](api::BlePeripheral& peripheral,
+                     const std::string& service_id) {
+                MutexLock lock(&mutex_);
+                auto pair = peripherals_.emplace(
+                    &peripheral, absl::make_unique<ScanningInfo>());
+                auto& context = *pair.first->second;
+                if (!pair.second) {
+                  NEARBY_LOG(INFO,
+                             "Discovering (again) peripheral=%p, impl=%p, "
+                             "peripheral name=%s",
+                             &context.peripheral, &peripheral,
+                             peripheral.GetName().c_str());
+                } else {
+                  context.peripheral = BlePeripheral(&peripheral);
+                  NEARBY_LOG(INFO,
+                             "Discovering peripheral=%p, impl=%p, "
+                             "peripheral name=%s",
+                             &context.peripheral, &peripheral,
+                             peripheral.GetName().c_str());
+                  discovered_peripheral_callback_.peripheral_discovered_cb(
+                      context.peripheral, service_id);
+                }
+              },
+          .peripheral_lost_cb =
+              [this](api::BlePeripheral& peripheral,
+                     const std::string& service_id) {
+                MutexLock lock(&mutex_);
+                if (peripherals_.empty()) return;
+                auto context = peripherals_.find(&peripheral);
+                if (context == peripherals_.end()) return;
+                NEARBY_LOG(INFO, "Removing peripheral=%p, impl=%p",
+                           &(context->second->peripheral), &peripheral);
+                discovered_peripheral_callback_.peripheral_lost_cb(
+                    context->second->peripheral, service_id);
+              },
+      });
+}
+
+bool BleMedium::StopScanning(const std::string& service_id) {
+  {
+    MutexLock lock(&mutex_);
+    discovered_peripheral_callback_ = {};
+    peripherals_.clear();
+    NEARBY_LOG(INFO, "Ble Scanning disabled: impl=%p", &GetImpl());
+  }
+  return impl_->StopScanning(service_id);
+}
+
+bool BleMedium::StartAcceptingConnections(const std::string& service_id,
+                                          AcceptedConnectionCallback callback) {
+  {
+    MutexLock lock(&mutex_);
+    accepted_connection_callback_ = std::move(callback);
+  }
+  return impl_->StartAcceptingConnections(
+      service_id,
+      {
+          .accepted_cb =
+              [this](api::BleSocket& socket, const std::string& service_id) {
+                MutexLock lock(&mutex_);
+                auto pair = sockets_.emplace(
+                    &socket, absl::make_unique<AcceptedConnectionInfo>());
+                auto& context = *pair.first->second;
+                if (!pair.second) {
+                  NEARBY_LOG(INFO, "Accepting (again) socket=%p, impl=%p",
+                             &context.socket, &socket);
+                } else {
+                  context.socket = BleSocket(&socket);
+                  NEARBY_LOG(INFO, "Accepting socket=%p, impl=%p",
+                             &context.socket, &socket);
+                }
+                accepted_connection_callback_.accepted_cb(context.socket,
+                                                          service_id);
+              },
+      });
+}
+
+bool BleMedium::StopAcceptingConnections(const std::string& service_id) {
+  {
+    MutexLock lock(&mutex_);
+    accepted_connection_callback_ = {};
+    sockets_.clear();
+    NEARBY_LOG(INFO, "Ble accepted connection disabled: impl=%p", &GetImpl());
+  }
+  return impl_->StopAcceptingConnections(service_id);
+}
+
+BleSocket BleMedium::Connect(BlePeripheral& peripheral,
+                             const std::string& service_id) {
+  {
+    MutexLock lock(&mutex_);
+    NEARBY_LOG(INFO, "BleMedium::Connect: peripheral=%p [impl=%p]", &peripheral,
+               &peripheral.GetImpl());
+  }
+  return BleSocket(impl_->Connect(peripheral.GetImpl(), service_id));
+}
+
+}  // namespace nearby
+}  // namespace location

cpp/platform_v2/public/ble.h

@@ -0,0 +1,146 @@
+#ifndef PLATFORM_V2_PUBLIC_BLE_H_
+#define PLATFORM_V2_PUBLIC_BLE_H_
+
+#include "platform_v2/api/ble.h"
+#include "platform_v2/api/platform.h"
+#include "platform_v2/base/byte_array.h"
+#include "platform_v2/base/input_stream.h"
+#include "platform_v2/base/output_stream.h"
+#include "platform_v2/public/bluetooth_adapter.h"
+#include "platform_v2/public/mutex.h"
+#include "absl/container/flat_hash_map.h"
+
+namespace location {
+namespace nearby {
+
+class BleSocket final {
+ public:
+  BleSocket() = default;
+  BleSocket(const BleSocket&) = default;
+  BleSocket& operator=(const BleSocket&) = default;
+  explicit BleSocket(api::BleSocket* socket) : impl_(socket) {}
+  explicit BleSocket(std::unique_ptr<api::BleSocket> socket)
+      : impl_(socket.release()) {}
+  ~BleSocket() = default;
+
+  // Returns the InputStream of the BleSocket.
+  // On error, returned stream will report Exception::kIo on any operation.
+  //
+  // The returned object is not owned by the caller, and can be invalidated once
+  // the BleSocket object is destroyed.
+  InputStream& GetInputStream() { return impl_->GetInputStream(); }
+
+  // Returns the OutputStream of the BleSocket.
+  // On error, returned stream will report Exception::kIo on any operation.
+  //
+  // The returned object is not owned by the caller, and can be invalidated once
+  // the BleSocket object is destroyed.
+  OutputStream& GetOutputStream() { return impl_->GetOutputStream(); }
+
+  // Returns Exception::kIo on error, Exception::kSuccess otherwise.
+  Exception Close() { return impl_->Close(); }
+
+  BlePeripheral GetRemotePeripheral() {
+    return BlePeripheral(impl_->GetRemotePeripheral());
+  }
+
+  // Returns true if a socket is usable. If this method returns false,
+  // it is not safe to call any other method.
+  // NOTE(socket validity):
+  // Socket created by a default public constructor is not valid, because
+  // it is missing platform implementation.
+  // The only way to obtain a valid socket is through connection, such as
+  // an object returned by BleMedium::Connect
+  // These methods may also return an invalid socket if connection failed for
+  // any reason.
+  bool IsValid() const { return impl_ != nullptr; }
+
+  // Returns reference to platform implementation.
+  // This is used to communicate with platform code, and for debugging purposes.
+  // Returned reference will remain valid for while BleSocket object is
+  // itself valid. Typically BleSocket lifetime matches duration of the
+  // connection, and is controlled by end user, since they hold the instance.
+  api::BleSocket& GetImpl() { return *impl_; }
+
+ private:
+  std::shared_ptr<api::BleSocket> impl_;
+};
+
+// Container of operations that can be performed over the BLE medium.
+class BleMedium final {
+ public:
+  using Platform = api::ImplementationPlatform;
+  struct DiscoveredPeripheralCallback {
+    std::function<void(BlePeripheral& peripheral,
+                       const std::string& service_id)>
+        peripheral_discovered_cb =
+            DefaultCallback<BlePeripheral&, const std::string&>();
+    std::function<void(BlePeripheral& peripheral,
+                       const std::string& service_id)>
+        peripheral_lost_cb =
+            DefaultCallback<BlePeripheral&, const std::string&>();
+  };
+  struct ScanningInfo {
+    BlePeripheral peripheral;
+  };
+
+  struct AcceptedConnectionCallback {
+    std::function<void(BleSocket& socket, const std::string& service_id)>
+        accepted_cb = DefaultCallback<BleSocket&, const std::string&>();
+  };
+  struct AcceptedConnectionInfo {
+    BleSocket socket;
+  };
+
+  explicit BleMedium(BluetoothAdapter& adapter)
+      : impl_(Platform::CreateBleMedium(adapter.GetImpl())),
+        adapter_(adapter) {}
+  ~BleMedium() = default;
+
+  // Returns true once the BLE advertising has been initiated.
+  bool StartAdvertising(const std::string& service_id,
+                        const ByteArray& advertisement_bytes);
+  bool StopAdvertising(const std::string& service_id);
+
+  // Returns true once the BLE scan has been initiated.
+  bool StartScanning(const std::string& service_id,
+                     DiscoveredPeripheralCallback callback);
+
+  // Returns true once BLE scanning for service_id is well and truly stopped;
+  // after this returns, there must be no more invocations of the
+  // DiscoveredPeripheralCallback passed in to StartScanning() for service_id.
+  bool StopScanning(const std::string& service_id);
+
+  // Returns true once BLE socket connection requests to service_id can be
+  // accepted.
+  bool StartAcceptingConnections(const std::string& service_id,
+                                 AcceptedConnectionCallback callback);
+  bool StopAcceptingConnections(const std::string& service_id);
+
+  // Returns a new BleSocket. On Success, BleSocket::IsValid()
+  // returns true.
+  BleSocket Connect(BlePeripheral& peripheral, const std::string& service_id);
+
+  bool IsValid() const { return impl_ != nullptr; }
+
+  api::BleMedium& GetImpl() { return *impl_; }
+  BluetoothAdapter& GetAdapter() { return adapter_; }
+
+ private:
+  Mutex mutex_;
+  std::unique_ptr<api::BleMedium> impl_;
+  BluetoothAdapter& adapter_;
+  absl::flat_hash_map<api::BlePeripheral*, std::unique_ptr<ScanningInfo>>
+      peripherals_ ABSL_GUARDED_BY(mutex_);
+  absl::flat_hash_map<api::BleSocket*, std::unique_ptr<AcceptedConnectionInfo>>
+      sockets_ ABSL_GUARDED_BY(mutex_);
+  DiscoveredPeripheralCallback discovered_peripheral_callback_
+      ABSL_GUARDED_BY(mutex_);
+  AcceptedConnectionCallback accepted_connection_callback_
+      ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_PUBLIC_BLE_H_

cpp/platform_v2/public/ble_test.cc

@@ -0,0 +1,189 @@
+#include "platform_v2/public/ble.h"
+
+#include <memory>
+
+#include "platform_v2/base/medium_environment.h"
+#include "platform_v2/public/count_down_latch.h"
+#include "platform_v2/public/logging.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace location {
+namespace nearby {
+namespace {
+
+constexpr absl::Duration kWaitDuration = absl::Milliseconds(1000);
+constexpr absl::string_view kServiceID{"com.google.location.nearby.apps.test"};
+constexpr absl::string_view kAdvertisementString{"\x0a\x0b\x0c\x0d"};
+
+class BleMediumTest : public ::testing::Test {
+ protected:
+  using DiscoveredPeripheralCallback = BleMedium::DiscoveredPeripheralCallback;
+  using AcceptedConnectionCallback = BleMedium::AcceptedConnectionCallback;
+
+  BleMediumTest() { env_.Stop(); }
+
+  MediumEnvironment& env_{MediumEnvironment::Instance()};
+};
+
+TEST_F(BleMediumTest, ConstructorDestructorWorks) {
+  env_.Start();
+  BluetoothAdapter adapter_a_;
+  BluetoothAdapter adapter_b_;
+  BleMedium ble_a{adapter_a_};
+  BleMedium ble_b{adapter_b_};
+
+  // Make sure we can create functional mediums.
+  ASSERT_TRUE(ble_a.IsValid());
+  ASSERT_TRUE(ble_b.IsValid());
+
+  // Make sure we can create 2 distinct mediums.
+  EXPECT_NE(&ble_a.GetImpl(), &ble_b.GetImpl());
+  env_.Stop();
+}
+
+TEST_F(BleMediumTest, CanStartAdvertising) {
+  env_.Start();
+  BluetoothAdapter adapter_a_;
+  BluetoothAdapter adapter_b_;
+  BleMedium ble_a{adapter_a_};
+  BleMedium ble_b{adapter_b_};
+  std::string service_id(kServiceID);
+  ByteArray advertisement_bytes{std::string(kAdvertisementString)};
+  CountDownLatch found_latch(1);
+
+  ble_a.StartAdvertising(service_id, advertisement_bytes);
+
+  EXPECT_TRUE(ble_b.StartScanning(
+      service_id, DiscoveredPeripheralCallback{
+                      .peripheral_discovered_cb =
+                          [&found_latch](BlePeripheral& peripheral,
+                                         const std::string& service_id) {
+                            found_latch.CountDown();
+                          },
+                  }));
+  EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
+  EXPECT_TRUE(ble_a.StopAdvertising(service_id));
+  EXPECT_TRUE(ble_b.StopScanning(service_id));
+  env_.Stop();
+}
+
+TEST_F(BleMediumTest, CanStartScanning) {
+  env_.Start();
+  BluetoothAdapter adapter_a_;
+  BluetoothAdapter adapter_b_;
+  BleMedium ble_a{adapter_a_};
+  BleMedium ble_b{adapter_b_};
+  std::string service_id(kServiceID);
+  ByteArray advertisement_bytes{std::string(kAdvertisementString)};
+  CountDownLatch found_latch(1);
+  CountDownLatch lost_latch(1);
+
+  ble_a.StartScanning(service_id,
+                      DiscoveredPeripheralCallback{
+                          .peripheral_discovered_cb =
+                              [&found_latch](BlePeripheral& peripheral,
+                                             const std::string& service_id) {
+                                found_latch.CountDown();
+                              },
+                          .peripheral_lost_cb =
+                              [&lost_latch](BlePeripheral& peripheral,
+                                            const std::string& service_id) {
+                                lost_latch.CountDown();
+                              },
+                      });
+  EXPECT_TRUE(ble_b.StartAdvertising(service_id, advertisement_bytes));
+  EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
+  EXPECT_TRUE(ble_b.StopAdvertising(service_id));
+  EXPECT_TRUE(lost_latch.Await(kWaitDuration).result());
+  EXPECT_TRUE(ble_a.StopScanning(service_id));
+  env_.Stop();
+}
+
+TEST_F(BleMediumTest, CanStopDiscovery) {
+  env_.Start();
+  BluetoothAdapter adapter_a_;
+  BluetoothAdapter adapter_b_;
+  BleMedium ble_a{adapter_a_};
+  BleMedium ble_b{adapter_b_};
+  std::string service_id(kServiceID);
+  ByteArray advertisement_bytes{std::string(kAdvertisementString)};
+  CountDownLatch found_latch(1);
+  CountDownLatch lost_latch(1);
+
+  ble_a.StartScanning(service_id,
+                      DiscoveredPeripheralCallback{
+                          .peripheral_discovered_cb =
+                              [&found_latch](BlePeripheral& peripheral,
+                                             const std::string& service_id) {
+                                found_latch.CountDown();
+                              },
+                          .peripheral_lost_cb =
+                              [&lost_latch](BlePeripheral& peripheral,
+                                            const std::string& service_id) {
+                                lost_latch.CountDown();
+                              },
+                      });
+  EXPECT_TRUE(ble_b.StartAdvertising(service_id, advertisement_bytes));
+  EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
+  EXPECT_TRUE(ble_a.StopScanning(service_id));
+  EXPECT_TRUE(ble_b.StopAdvertising(service_id));
+  EXPECT_FALSE(lost_latch.Await(kWaitDuration).result());
+  env_.Stop();
+}
+
+TEST_F(BleMediumTest, CanStartAcceptingConnectionsAndConnect) {
+  env_.Start();
+  BluetoothAdapter adapter_a_;
+  BluetoothAdapter adapter_b_;
+  BleMedium ble_a{adapter_a_};
+  BleMedium ble_b{adapter_b_};
+  std::string service_id(kServiceID);
+  ByteArray advertisement_bytes{std::string(kAdvertisementString)};
+  CountDownLatch found_latch(1);
+  CountDownLatch accepted_latch(1);
+
+  BlePeripheral* discovered_peripheral = nullptr;
+  ble_a.StartScanning(
+      service_id,
+      DiscoveredPeripheralCallback{
+          .peripheral_discovered_cb =
+              [&found_latch, &discovered_peripheral](
+                  BlePeripheral& peripheral, const std::string& service_id) {
+                NEARBY_LOG(INFO, "Peripheral discovered: %s, %p",
+                           peripheral.GetName().c_str(), &peripheral);
+                discovered_peripheral = &peripheral;
+                found_latch.CountDown();
+              },
+      });
+  ble_b.StartAdvertising(service_id, advertisement_bytes);
+  ble_b.StartAcceptingConnections(
+      service_id,
+      AcceptedConnectionCallback{
+          .accepted_cb = [&accepted_latch](BleSocket socket,
+                                           const std::string& service_id) {
+            NEARBY_LOG(INFO, "Connection accepted: socket=%p, service_id=%s",
+                       &socket, service_id.c_str());
+            accepted_latch.CountDown();
+          }});
+  EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
+
+  BleSocket socket_a;
+  EXPECT_FALSE(socket_a.IsValid());
+  {
+    SingleThreadExecutor client_executor;
+    client_executor.Execute(
+        [&ble_a, &socket_a, discovered_peripheral, &service_id]() {
+          socket_a = ble_a.Connect(*discovered_peripheral, service_id);
+        });
+  }
+  EXPECT_TRUE(accepted_latch.Await(kWaitDuration).result());
+  EXPECT_TRUE(socket_a.IsValid());
+  ble_b.StopAdvertising(service_id);
+  ble_a.StopScanning(service_id);
+  env_.Stop();
+}
+
+}  // namespace
+}  // namespace nearby
+}  // namespace location

cpp/platform_v2/public/bluetooth_adapter.h

@@ -11,6 +11,29 @@
 namespace location {
 namespace nearby {
 
+// Opaque wrapper over a BLE peripheral. Must contain enough data about a
+// particular BLE peripheral to connect to its GATT server.
+class BlePeripheral final {
+ public:
+  BlePeripheral() = default;
+  BlePeripheral(const BlePeripheral&) = default;
+  BlePeripheral& operator=(const BlePeripheral&) = default;
+  explicit BlePeripheral(api::BlePeripheral* peripheral) : impl_(peripheral) {}
+  ~BlePeripheral() = default;
+
+  std::string GetName() const { return impl_->GetName(); }
+
+  ByteArray GetAdvertisementBytes(const std::string& service_id) const {
+    return impl_->GetAdvertisementBytes(service_id);
+  }
+
+  api::BlePeripheral& GetImpl() { return *impl_; }
+  bool IsValid() const { return impl_ != nullptr; }
+
+ private:
+  api::BlePeripheral* impl_;
+};
+
 // https://developer.android.com/reference/android/bluetooth/BluetoothDevice.html.
 class BluetoothDevice final {
  public:

cpp/platform_v2/public/bluetooth_classic.h

@@ -187,6 +187,9 @@ class BluetoothClassicMedium final {
 
   api::BluetoothClassicMedium& GetImpl() { return *impl_; }
   BluetoothAdapter& GetAdapter() { return adapter_; }
+  BluetoothDevice FindRemoteDevice(const std::string& mac_address) {
+    return BluetoothDevice(impl_->FindRemoteDevice(mac_address));
+  }
 
  private:
   Mutex mutex_;

cpp/platform_v2/public/wifi_lan.cc

@@ -6,9 +6,8 @@
 namespace location {
 namespace nearby {
 
-bool WifiLanMedium::StartAdvertising(
-    const std::string& service_id,
-    const std::string& service_info_name) {
+bool WifiLanMedium::StartAdvertising(const std::string& service_id,
+                                     const std::string& service_info_name) {
   return impl_->StartAdvertising(service_id, service_info_name);
 }
 
@@ -39,13 +38,13 @@ bool WifiLanMedium::StartDiscovery(const std::string& service_id,
                              "service_info_name=%s",
                              &context.service, &service,
                              service.GetName().c_str());
-                  return;
+                } else {
+                  context.service = WifiLanService(&service);
+                  NEARBY_LOG(
+                      INFO,
+                      "Discovering service=%p, impl=%p, service_info_name=%s",
+                      &context.service, &service, service.GetName().c_str());
                 }
-                context.service = WifiLanService(&service);
-                NEARBY_LOG(
-                    INFO,
-                    "Discovering service=%p, impl=%p, service_info_name=%s",
-                    &context.service, &service, service.GetName().c_str());
                 discovered_service_callback_.service_discovered_cb(
                     context.service, service_id);
               },
@@ -54,12 +53,12 @@ bool WifiLanMedium::StartDiscovery(const std::string& service_id,
                      const std::string& service_id) {
                 MutexLock lock(&mutex_);
                 if (services_.empty()) return;
-                auto item = services_.extract(&service);
-                auto& context = *item.mapped();
+                auto context = services_.find(&service);
+                if (context == services_.end()) return;
                 NEARBY_LOG(INFO, "Removing service=%p, impl=%p",
-                           &context.service, &service);
-                discovered_service_callback_.service_lost_cb(context.service,
-                                                             service_id);
+                           &(context->second->service), &service);
+                discovered_service_callback_.service_lost_cb(
+                    context->second->service, service_id);
               },
       });
 }
@@ -93,8 +92,8 @@ bool WifiLanMedium::StartAcceptingConnections(
                 if (!pair.second) {
                   NEARBY_LOG(INFO, "Accepting (again) socket=%p, impl=%p",
                              &context.socket, &socket);
-                  context.socket = WifiLanSocket(&socket);
                 } else {
+                  context.socket = WifiLanSocket(&socket);
                   NEARBY_LOG(INFO, "Accepting socket=%p, impl=%p",
                              &context.socket, &socket);
                 }
@@ -117,10 +116,17 @@ bool WifiLanMedium::StopAcceptingConnections(const std::string& service_id) {
 
 WifiLanSocket WifiLanMedium::Connect(WifiLanService& service,
                                      const std::string& service_id) {
-  NEARBY_LOG(INFO, "WifiLanMedium::Connect: service=%p [impl=%p]", &service,
-             &service.GetImpl());
+  NEARBY_LOG(
+      INFO,
+      "WifiLanMedium::Connect: service=%p [impl=%p, service_info_name=%s]",
+      &service, &service.GetImpl(), service.GetName().c_str());
   return WifiLanSocket(impl_->Connect(service.GetImpl(), service_id));
 }
 
+WifiLanService WifiLanMedium::FindRemoteService(const std::string& ip_address,
+                                                int port) {
+  return WifiLanService(impl_->FindRemoteService(ip_address, port));
+}
+
 }  // namespace nearby
 }  // namespace location

cpp/platform_v2/public/wifi_lan.h

@@ -140,6 +140,8 @@ class WifiLanMedium final {
 
   api::WifiLanMedium& GetImpl() { return *impl_; }
 
+  WifiLanService FindRemoteService(const std::string& ip_address, int port);
+
  private:
   Mutex mutex_;
   std::unique_ptr<api::WifiLanMedium> impl_;

cpp/platform_v2/public/wifi_lan_test.cc

@@ -7,13 +7,14 @@
 #include "platform_v2/public/logging.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include "absl/strings/string_view.h"
 
 namespace location {
 namespace nearby {
 namespace {
 
 constexpr absl::string_view kServiceID{"com.google.location.nearby.apps.test"};
-constexpr absl::string_view kServiceName{"service name"};
+constexpr absl::string_view kServiceInfoName{"Simulated service info name"};
 
 class WifiLanMediumTest : public ::testing::Test {
  protected:
@@ -44,10 +45,10 @@ TEST_F(WifiLanMediumTest, CanStartAdvertising) {
   WifiLanMedium wifi_a;
   WifiLanMedium wifi_b;
   std::string service_id(kServiceID);
-  std::string service_name{kServiceName};
+  std::string service_info_name{kServiceInfoName};
   CountDownLatch found_latch(1);
 
-  wifi_a.StartAdvertising(service_id, service_name);
+  wifi_a.StartAdvertising(service_id, service_info_name);
 
   EXPECT_TRUE(wifi_b.StartDiscovery(
       service_id, DiscoveredServiceCallback{
@@ -68,7 +69,7 @@ TEST_F(WifiLanMediumTest, CanStartDiscovery) {
   WifiLanMedium wifi_a;
   WifiLanMedium wifi_b;
   std::string service_id(kServiceID);
-  std::string service_name{kServiceName};
+  std::string service_info_name{kServiceInfoName};
   CountDownLatch found_latch(1);
   CountDownLatch lost_latch(1);
 
@@ -76,16 +77,16 @@ TEST_F(WifiLanMediumTest, CanStartDiscovery) {
                         DiscoveredServiceCallback{
                             .service_discovered_cb =
                                 [&found_latch](WifiLanService& service,
-                                               const std::string& service_id) {
+                                               absl::string_view service_id) {
                                   found_latch.CountDown();
                                 },
                             .service_lost_cb =
                                 [&lost_latch](WifiLanService& service,
-                                              const std::string& service_id) {
+                                              absl::string_view service_id) {
                                   lost_latch.CountDown();
                                 },
                         });
-  EXPECT_TRUE(wifi_b.StartAdvertising(service_id, service_name));
+  EXPECT_TRUE(wifi_b.StartAdvertising(service_id, service_info_name));
   EXPECT_TRUE(found_latch.Await(absl::Milliseconds(1000)).result());
   EXPECT_TRUE(wifi_b.StopAdvertising(service_id));
   EXPECT_TRUE(lost_latch.Await(absl::Milliseconds(1000)).result());
@@ -98,7 +99,7 @@ TEST_F(WifiLanMediumTest, CanStopDiscovery) {
   WifiLanMedium wifi_a;
   WifiLanMedium wifi_b;
   std::string service_id(kServiceID);
-  std::string service_name{kServiceName};
+  std::string service_info_name{kServiceInfoName};
   CountDownLatch found_latch(1);
   CountDownLatch lost_latch(1);
 
@@ -106,16 +107,16 @@ TEST_F(WifiLanMediumTest, CanStopDiscovery) {
                         DiscoveredServiceCallback{
                             .service_discovered_cb =
                                 [&found_latch](WifiLanService& service,
-                                               const std::string& service_id) {
+                                               absl::string_view service_id) {
                                   found_latch.CountDown();
                                 },
                             .service_lost_cb =
                                 [&lost_latch](WifiLanService& service,
-                                              const std::string& service_id) {
+                                              absl::string_view service_id) {
                                   lost_latch.CountDown();
                                 },
                         });
-  EXPECT_TRUE(wifi_b.StartAdvertising(service_id, service_name));
+  EXPECT_TRUE(wifi_b.StartAdvertising(service_id, service_info_name));
   EXPECT_TRUE(found_latch.Await(absl::Milliseconds(1000)).result());
   EXPECT_TRUE(wifi_a.StopDiscovery(service_id));
   EXPECT_TRUE(wifi_b.StopAdvertising(service_id));
@@ -128,7 +129,7 @@ TEST_F(WifiLanMediumTest, CanStartAcceptingConnectionsAndConnect) {
   WifiLanMedium wifi_a;
   WifiLanMedium wifi_b;
   std::string service_id(kServiceID);
-  std::string service_name{kServiceName};
+  std::string service_info_name{kServiceInfoName};
   CountDownLatch found_latch(1);
   CountDownLatch accepted_latch(1);
 
@@ -145,7 +146,7 @@ TEST_F(WifiLanMediumTest, CanStartAcceptingConnectionsAndConnect) {
                 found_latch.CountDown();
               },
       });
-  wifi_b.StartAdvertising(service_id, service_name);
+  wifi_b.StartAdvertising(service_id, service_info_name);
   wifi_b.StartAcceptingConnections(
       service_id,
       AcceptedConnectionCallback{
@@ -168,6 +169,7 @@ TEST_F(WifiLanMediumTest, CanStartAcceptingConnectionsAndConnect) {
   }
   EXPECT_TRUE(accepted_latch.Await(absl::Milliseconds(1000)).result());
   EXPECT_TRUE(socket_a.IsValid());
+  wifi_b.StopAcceptingConnections(service_id);
   wifi_b.StopAdvertising(service_id);
   wifi_a.StopDiscovery(service_id);
   env_.Stop();