Merge branch 'google3'

Change-Id: Ib74e01d47d15deb01314cacd8f67815515d7a31a

cpp/core_v2/internal/mediums/BUILD

@@ -2,6 +2,7 @@ cc_library(
     name = "mediums",
     srcs = [
         "advertisement_read_result.cc",
+        "ble.cc",
         "ble_advertisement.cc",
         "ble_advertisement_header.cc",
         "ble_packet.cc",
@@ -15,6 +16,7 @@ cc_library(
     ],
     hdrs = [
         "advertisement_read_result.h",
+        "ble.h",
         "ble_advertisement.h",
         "ble_advertisement_header.h",
         "ble_packet.h",
@@ -56,6 +58,7 @@ cc_library(
     srcs = ["utils.cc"],
     hdrs = ["utils.h"],
     visibility = [
+        "//core_v2/internal:__pkg__",
         "//core_v2/internal/mediums/webrtc:__pkg__",
     ],
     deps = [
@@ -74,6 +77,7 @@ cc_test(
         "ble_advertisement_test.cc",
         "ble_packet_test.cc",
         "ble_peripheral_test.cc",
+        "ble_test.cc",
         "bloom_filter_test.cc",
         "bluetooth_classic_test.cc",
         "bluetooth_radio_test.cc",
@@ -93,6 +97,7 @@ cc_test(
         "//platform_v2/public:logging",
         "//platform_v2/public:types",
         "//testing/base/public:gunit_main",
+        "//absl/strings",
         "//absl/time",
     ],
 )

cpp/core_v2/internal/mediums/ble.cc

@@ -0,0 +1,269 @@
+#include "core_v2/internal/mediums/ble.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "platform_v2/public/logging.h"
+#include "platform_v2/public/mutex_lock.h"
+
+namespace location {
+namespace nearby {
+namespace connections {
+
+Ble::Ble(BluetoothRadio& radio) : radio_(radio) {}
+
+bool Ble::IsAvailable() const {
+  MutexLock lock(&mutex_);
+
+  return IsAvailableLocked();
+}
+
+bool Ble::IsAvailableLocked() const { return medium_.IsValid(); }
+
+bool Ble::StartAdvertising(const std::string& service_id,
+                           const ByteArray& advertisement_bytes) {
+  MutexLock lock(&mutex_);
+
+  if (advertisement_bytes.Empty()) {
+    NEARBY_LOGS(INFO)
+        << "Refusing to turn on BLE advertising. Empty advertisement data.";
+    return false;
+  }
+
+  if (advertisement_bytes.size() > kMaxAdvertisementLength) {
+    NEARBY_LOG(INFO,
+               "Refusing to start BLE advertising because the advertisement "
+               "was too long. Expected at most %d bytes but received %d.",
+               kMaxAdvertisementLength, advertisement_bytes.size());
+    return false;
+  }
+
+  if (IsAdvertisingLocked(service_id)) {
+    NEARBY_LOGS(INFO)
+        << "Failed to BLE advertise because we're already advertising.";
+    return false;
+  }
+
+  if (!radio_.IsEnabled()) {
+    NEARBY_LOGS(INFO)
+        << "Can't start BLE scanning because Bluetooth was never turned on";
+    return false;
+  }
+
+  if (!IsAvailableLocked()) {
+    NEARBY_LOGS(INFO) << "Can't turn on BLE advertising. BLE is not available.";
+    return false;
+  }
+
+  NEARBY_LOGS(INFO) << "Turning on BLE advertising with advertisement bytes="
+                    << advertisement_bytes.data() << "("
+                    << advertisement_bytes.size() << ")"
+                    << ", service id=" << service_id;
+  if (!medium_.StartAdvertising(service_id, advertisement_bytes)) {
+    NEARBY_LOGS(INFO)
+        << "Failed to turn on BLE advertising with advertisement bytes="
+        << advertisement_bytes.data() << "(" << advertisement_bytes.size()
+        << ")";
+    return false;
+  }
+
+  advertising_info_.Add(service_id);
+  return true;
+}
+
+bool Ble::StopAdvertising(const std::string& service_id) {
+  MutexLock lock(&mutex_);
+
+  if (!IsAdvertisingLocked(service_id)) {
+    NEARBY_LOGS(INFO) << "Can't turn off BLE advertising; it is already off";
+    return false;
+  }
+
+  NEARBY_LOGS(INFO) << "Turned off BLE advertising with service id="
+                    << service_id;
+  bool ret = medium_.StopAdvertising(service_id);
+  // Reset our bundle of advertising state to mark that we're no longer
+  // advertising.
+  advertising_info_.Remove(service_id);
+  return ret;
+}
+
+bool Ble::IsAdvertising(const std::string& service_id) {
+  MutexLock lock(&mutex_);
+
+  return IsAdvertisingLocked(service_id);
+}
+
+bool Ble::IsAdvertisingLocked(const std::string& service_id) {
+  return advertising_info_.Existed(service_id);
+}
+
+bool Ble::StartScanning(const std::string& service_id,
+                        DiscoveredPeripheralCallback callback) {
+  MutexLock lock(&mutex_);
+
+  if (service_id.empty()) {
+    NEARBY_LOGS(INFO)
+        << "Refusing to start BLE scanning with empty service id.";
+    return false;
+  }
+
+  if (IsScanningLocked(service_id)) {
+    NEARBY_LOGS(INFO) << "Refusing to start scan of BLE peripherals because "
+                         "another scanning is already in-progress.";
+    return false;
+  }
+
+  if (!radio_.IsEnabled()) {
+    NEARBY_LOGS(INFO)
+        << "Can't start BLE scanning because Bluetooth was never turned on";
+    return false;
+  }
+
+  if (!IsAvailableLocked()) {
+    NEARBY_LOGS(INFO)
+        << "Can't scan BLE peripherals because BLE isn't available.";
+    return false;
+  }
+
+  if (!medium_.StartScanning(service_id, callback)) {
+    NEARBY_LOGS(INFO) << "Failed to start scan of BLE services.";
+    return false;
+  }
+
+  NEARBY_LOGS(INFO) << "Turned on BLE scanning with service id=" << service_id;
+  // Mark the fact that we're currently performing a BLE discovering.
+  scanning_info_.Add(service_id);
+  return true;
+}
+
+bool Ble::StopScanning(const std::string& service_id) {
+  MutexLock lock(&mutex_);
+
+  if (!IsScanningLocked(service_id)) {
+    NEARBY_LOGS(INFO) << "Can't turn off BLE sacanning because we never "
+                         "started scanning.";
+    return false;
+  }
+
+  NEARBY_LOG(INFO, "Turned off BLE scanning with service id=%s",
+             service_id.c_str());
+  bool ret = medium_.StopScanning(service_id);
+  scanning_info_.Clear();
+  return ret;
+}
+
+bool Ble::IsScanning(const std::string& service_id) {
+  MutexLock lock(&mutex_);
+
+  return IsScanningLocked(service_id);
+}
+
+bool Ble::IsScanningLocked(const std::string& service_id) {
+  return scanning_info_.Existed(service_id);
+}
+
+bool Ble::StartAcceptingConnections(const std::string& service_id,
+                                    AcceptedConnectionCallback callback) {
+  MutexLock lock(&mutex_);
+
+  if (service_id.empty()) {
+    NEARBY_LOGS(INFO)
+        << "Refusing to start accepting BLE connections with empty service id.";
+    return false;
+  }
+
+  if (IsAcceptingConnectionsLocked(service_id)) {
+    NEARBY_LOGS(INFO)
+        << "Refusing to start accepting BLE connections for "
+        << service_id
+        << " because another BLE peripheral socket is already in-progress.";
+    return false;
+  }
+
+  if (!radio_.IsEnabled()) {
+    NEARBY_LOGS(INFO) << "Can't start accepting BLE connections for "
+                      << service_id
+                      << " because Bluetooth isn't enabled.";
+    return false;
+  }
+
+  if (!IsAvailableLocked()) {
+    NEARBY_LOGS(INFO) << "Can't start accepting BLE connections for "
+                      << service_id << " because BLE isn't available.";
+    return false;
+  }
+
+  if (!medium_.StartAcceptingConnections(service_id, callback)) {
+    NEARBY_LOGS(INFO) << "Failed to accept connections callback for "
+                      << service_id << " .";
+    return false;
+  }
+
+  accepting_connections_info_.Add(service_id);
+  return true;
+}
+
+bool Ble::StopAcceptingConnections(const std::string& service_id) {
+  MutexLock lock(&mutex_);
+
+  if (!IsAcceptingConnectionsLocked(service_id)) {
+    NEARBY_LOGS(INFO)
+        << "Can't stop accepting BLE connections because it was never started.";
+    return false;
+  }
+
+  bool ret = medium_.StopAcceptingConnections(service_id);
+  // Reset our bundle of accepting connections state to mark that we're no
+  // longer accepting connections.
+  accepting_connections_info_.Remove(service_id);
+  return ret;
+}
+
+bool Ble::IsAcceptingConnections(const std::string& service_id) {
+  MutexLock lock(&mutex_);
+
+  return IsAcceptingConnectionsLocked(service_id);
+}
+
+bool Ble::IsAcceptingConnectionsLocked(const std::string& service_id) {
+  return accepting_connections_info_.Existed(service_id);
+}
+
+BleSocket Ble::Connect(BlePeripheral& peripheral,
+                       const std::string& service_id) {
+  MutexLock lock(&mutex_);
+  NEARBY_LOGS(INFO) << "BLE::Connect: service=" << &peripheral;
+  // Socket to return. To allow for NRVO to work, it has to be a single object.
+  BleSocket socket;
+
+  if (service_id.empty()) {
+    NEARBY_LOGS(INFO) << "Refusing to create BLE socket with empty service_id.";
+    return socket;
+  }
+
+  if (!radio_.IsEnabled()) {
+    NEARBY_LOGS(INFO) << "Can't create client BLE socket to "
+                      << &peripheral << " because Bluetooth isn't enabled.";
+    return socket;
+  }
+
+  if (!IsAvailableLocked()) {
+    NEARBY_LOGS(INFO) << "Can't create client BLE socket [service_id="
+                      << service_id << "]; BLE isn't available.";
+    return socket;
+  }
+
+  socket = medium_.Connect(peripheral, service_id);
+  if (!socket.IsValid()) {
+    NEARBY_LOGS(INFO) << "Failed to Connect via BLE [service=" << service_id
+                      << "]";
+  }
+
+  return socket;
+}
+
+}  // namespace connections
+}  // namespace nearby
+}  // namespace location

cpp/core_v2/internal/mediums/ble.h

@@ -0,0 +1,162 @@
+#ifndef CORE_V2_INTERNAL_MEDIUMS_BLE_H_
+#define CORE_V2_INTERNAL_MEDIUMS_BLE_H_
+
+#include <cstdint>
+#include <string>
+
+#include "core_v2/internal/mediums/bluetooth_radio.h"
+#include "core_v2/listeners.h"
+#include "platform_v2/base/byte_array.h"
+#include "platform_v2/public/ble.h"
+#include "platform_v2/public/multi_thread_executor.h"
+#include "platform_v2/public/mutex.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+
+namespace location {
+namespace nearby {
+namespace connections {
+
+class Ble {
+ public:
+  using DiscoveredPeripheralCallback = BleMedium::DiscoveredPeripheralCallback;
+  using AcceptedConnectionCallback = BleMedium::AcceptedConnectionCallback;
+
+  explicit Ble(BluetoothRadio& bluetooth_radio);
+  ~Ble() = default;
+
+  // Returns true, if Ble communications are supported by a platform.
+  bool IsAvailable() const ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Sets custom advertisement data, and then enables Ble advertising.
+  // Returns true, if data is successfully set, and false otherwise.
+  bool StartAdvertising(const std::string& service_id,
+                        const ByteArray& advertisement_bytes)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Disables Ble advertising.
+  bool StopAdvertising(const std::string& service_id)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  bool IsAdvertising(const std::string& service_id) ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Enables Ble scanning mode. Will report any discoverable peripherals in
+  // range through a callback. Returns true, if scanning mode was enabled,
+  // false otherwise.
+  bool StartScanning(const std::string& service_id,
+                     DiscoveredPeripheralCallback callback)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Disables Ble discovery mode.
+  bool StopScanning(const std::string& service_id) ABSL_LOCKS_EXCLUDED(mutex_);
+
+  bool IsScanning(const std::string& service_id) ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Starts a worker thread, creates a Ble socket, associates it with a
+  // service id.
+  bool StartAcceptingConnections(const std::string& service_id,
+                                 AcceptedConnectionCallback callback)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Closes socket corresponding to a service id.
+  bool StopAcceptingConnections(const std::string& service_id)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  bool IsAcceptingConnections(const std::string& service_id)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns true if this object owns a valid platform implementation.
+  bool IsMediumValid() const ABSL_LOCKS_EXCLUDED(mutex_) {
+    MutexLock lock(&mutex_);
+    return medium_.IsValid();
+  }
+
+  // Returns true if this object has a valid BluetoothAdapter reference.
+  bool IsAdapterValid() const ABSL_LOCKS_EXCLUDED(mutex_) {
+    MutexLock lock(&mutex_);
+    return adapter_.IsValid();
+  }
+
+  // Establishes connection to Ble peripheral that was might be started on
+  // another peripheral with StartAcceptingConnections() using the same
+  // service_id. Blocks until connection is established, or server-side is
+  // terminated. Returns socket instance. On success, BleSocket.IsValid() return
+  // true.
+  BleSocket Connect(BlePeripheral& peripheral, const std::string& service_id)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+ private:
+  static constexpr int kMaxAdvertisementLength = 512;
+
+  struct AdvertisingInfo {
+    bool Empty() const { return service_ids.empty(); }
+    void Clear() { service_ids.clear(); }
+    void Add(const std::string& service_id) { service_ids.emplace(service_id); }
+    void Remove(const std::string& service_id) {
+      service_ids.erase(service_id);
+    }
+    bool Existed(const std::string& service_id) const {
+      return service_ids.contains(service_id);
+    }
+
+    absl::flat_hash_set<std::string> service_ids;
+  };
+
+  struct ScanningInfo {
+    bool Empty() const { return service_ids.empty(); }
+    void Clear() { service_ids.clear(); }
+    void Add(const std::string& service_id) { service_ids.emplace(service_id); }
+    void Remove(const std::string& service_id) {
+      service_ids.erase(service_id);
+    }
+    bool Existed(const std::string& service_id) const {
+      return service_ids.contains(service_id);
+    }
+
+    absl::flat_hash_set<std::string> service_ids;
+  };
+
+  struct AcceptingConnectionsInfo {
+    bool Empty() const { return service_ids.empty(); }
+    void Clear() { service_ids.clear(); }
+    void Add(const std::string& service_id) { service_ids.emplace(service_id); }
+    void Remove(const std::string& service_id) {
+      service_ids.erase(service_id);
+    }
+    bool Existed(const std::string& service_id) const {
+      return service_ids.contains(service_id);
+    }
+
+    absl::flat_hash_set<std::string> service_ids;
+  };
+
+  // Same as IsAvailable(), but must be called with mutex_ held.
+  bool IsAvailableLocked() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Same as IsAdvertising(), but must be called with mutex_ held.
+  bool IsAdvertisingLocked(const std::string& service_id)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Same as IsDiscovering(), but must be called with mutex_ held.
+  bool IsScanningLocked(const std::string& service_id)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Same as IsAcceptingConnections(), but must be called with mutex_ held.
+  bool IsAcceptingConnectionsLocked(const std::string& service_id)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  mutable Mutex mutex_;
+  BluetoothRadio& radio_ ABSL_GUARDED_BY(mutex_);
+  BluetoothAdapter& adapter_ ABSL_GUARDED_BY(mutex_){
+      radio_.GetBluetoothAdapter()};
+  BleMedium medium_ ABSL_GUARDED_BY(mutex_){adapter_};
+  AdvertisingInfo advertising_info_ ABSL_GUARDED_BY(mutex_);
+  ScanningInfo scanning_info_ ABSL_GUARDED_BY(mutex_);
+  AcceptingConnectionsInfo accepting_connections_info_ ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace connections
+}  // namespace nearby
+}  // namespace location
+
+#endif  // CORE_V2_INTERNAL_MEDIUMS_BLE_H_

cpp/core_v2/internal/mediums/ble_test.cc

@@ -0,0 +1,162 @@
+#include "core_v2/internal/mediums/ble.h"
+
+#include <string>
+
+#include "core_v2/internal/mediums/bluetooth_radio.h"
+#include "platform_v2/base/medium_environment.h"
+#include "platform_v2/public/ble.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 connections {
+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 BleTest : public ::testing::Test {
+ protected:
+  using DiscoveredPeripheralCallback = BleMedium::DiscoveredPeripheralCallback;
+
+  BleTest() { env_.Stop(); }
+
+  MediumEnvironment& env_{MediumEnvironment::Instance()};
+};
+
+TEST_F(BleTest, CanConstructValidObject) {
+  env_.Start();
+  BluetoothRadio radio_a;
+  BluetoothRadio radio_b;
+  Ble ble_a{radio_a};
+  Ble ble_b{radio_b};
+
+  EXPECT_TRUE(ble_a.IsMediumValid());
+  EXPECT_TRUE(ble_a.IsAdapterValid());
+  EXPECT_TRUE(ble_a.IsAvailable());
+  EXPECT_TRUE(ble_b.IsMediumValid());
+  EXPECT_TRUE(ble_b.IsAdapterValid());
+  EXPECT_TRUE(ble_b.IsAvailable());
+  EXPECT_NE(&radio_a.GetBluetoothAdapter(), &radio_b.GetBluetoothAdapter());
+  env_.Stop();
+}
+
+TEST_F(BleTest, CanStartAdvertising) {
+  env_.Start();
+  BluetoothRadio radio_a;
+  BluetoothRadio radio_b;
+  Ble ble_a{radio_a};
+  Ble ble_b{radio_b};
+  radio_a.Enable();
+  radio_b.Enable();
+  std::string service_id(kServiceID);
+  ByteArray advertisement_bytes{std::string(kAdvertisementString)};
+  CountDownLatch found_latch(1);
+
+  ble_b.StartScanning(service_id,
+                      DiscoveredPeripheralCallback{
+                          .peripheral_discovered_cb =
+                              [&found_latch](BlePeripheral& peripheral,
+                                             const std::string& service_id) {
+                                found_latch.CountDown();
+                              },
+                      });
+
+  EXPECT_TRUE(ble_a.StartAdvertising(service_id, advertisement_bytes));
+  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(BleTest, CanStartDiscovery) {
+  env_.Start();
+  BluetoothRadio radio_a;
+  BluetoothRadio radio_b;
+  Ble ble_a{radio_a};
+  Ble ble_b{radio_b};
+  radio_a.Enable();
+  radio_b.Enable();
+  std::string service_id(kServiceID);
+  ByteArray advertisement_bytes{std::string(kAdvertisementString)};
+  CountDownLatch accept_latch(1);
+  CountDownLatch lost_latch(1);
+
+  ble_b.StartAdvertising(service_id, advertisement_bytes);
+
+  EXPECT_TRUE(ble_a.StartScanning(
+      service_id, DiscoveredPeripheralCallback{
+                      .peripheral_discovered_cb =
+                          [&accept_latch](BlePeripheral& peripheral,
+                                          const std::string& service_id) {
+                            accept_latch.CountDown();
+                          },
+                      .peripheral_lost_cb =
+                          [&lost_latch](BlePeripheral& peripheral,
+                                        const std::string& service_id) {
+                            lost_latch.CountDown();
+                          },
+                  }));
+  EXPECT_TRUE(accept_latch.Await(kWaitDuration).result());
+  ble_b.StopAdvertising(service_id);
+  EXPECT_TRUE(lost_latch.Await(kWaitDuration).result());
+  EXPECT_TRUE(ble_a.StopScanning(service_id));
+  env_.Stop();
+}
+
+TEST_F(BleTest, CanStartAcceptingConnectionsAndConnect) {
+  env_.Start();
+  BluetoothRadio radio_a;
+  BluetoothRadio radio_b;
+  Ble ble_a{radio_a};
+  Ble ble_b{radio_b};
+  radio_a.Enable();
+  radio_b.Enable();
+  std::string service_id(kServiceID);
+  ByteArray advertisement_bytes{std::string(kAdvertisementString)};
+  CountDownLatch found_latch(1);
+  CountDownLatch accept_latch(1);
+
+  ble_a.StartAdvertising(service_id, advertisement_bytes);
+  ble_a.StartAcceptingConnections(
+      service_id,
+      {
+          .accepted_cb = [&accept_latch](
+                             BleSocket socket,
+                             const std::string&) { accept_latch.CountDown(); },
+      });
+  BlePeripheral discovered_peripheral;
+  ble_b.StartScanning(
+      service_id,
+      {
+          .peripheral_discovered_cb =
+              [&found_latch, &discovered_peripheral](
+                  BlePeripheral& peripheral, const std::string& service_id) {
+                discovered_peripheral = peripheral;
+                NEARBY_LOG(INFO, "Discovered peripheral=%p [impl=%p]",
+                           &peripheral, &peripheral.GetImpl());
+                found_latch.CountDown();
+              },
+      });
+
+  EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
+  ASSERT_TRUE(discovered_peripheral.IsValid());
+
+  BleSocket socket =
+      ble_b.Connect(discovered_peripheral, service_id);
+
+  EXPECT_TRUE(accept_latch.Await(kWaitDuration).result());
+  EXPECT_TRUE(socket.IsValid());
+  ble_b.StopScanning(service_id);
+  ble_a.StopAdvertising(service_id);
+  env_.Stop();
+}
+
+}  // namespace
+}  // namespace connections
+}  // namespace nearby
+}  // namespace location

cpp/core_v2/internal/mediums/bluetooth_classic.cc

@@ -368,6 +368,12 @@ BluetoothSocket BluetoothClassic::Connect(BluetoothDevice& bluetooth_device,
   return socket;
 }
 
+BluetoothDevice BluetoothClassic::FindRemoteDevice(
+    const std::string& mac_address) {
+  MutexLock lock(&mutex_);
+  return medium_.FindRemoteDevice(mac_address);
+}
+
 std::string BluetoothClassic::GenerateUuidFromString(const std::string& data) {
   return std::string(Uuid(data));
 }

cpp/core_v2/internal/mediums/bluetooth_classic.h

@@ -100,6 +100,9 @@ class BluetoothClassic {
                           const std::string& service_name)
       ABSL_LOCKS_EXCLUDED(mutex_);
 
+  BluetoothDevice FindRemoteDevice(const std::string& mac_address)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
  private:
   struct ScanInfo {
     bool valid = false;

cpp/core_v2/internal/mediums/mediums.cc

@@ -12,6 +12,8 @@ BluetoothClassic& Mediums::GetBluetoothClassic() {
   return bluetooth_classic_;
 }
 
+Ble& Mediums::GetBle() { return ble_; }
+
 WifiLan& Mediums::GetWifiLan() {
   return wifi_lan_;
 }

cpp/core_v2/internal/mediums/mediums.h

@@ -1,6 +1,7 @@
 #ifndef CORE_V2_INTERNAL_MEDIUMS_MEDIUMS_H_
 #define CORE_V2_INTERNAL_MEDIUMS_MEDIUMS_H_
 
+#include "core_v2/internal/mediums/ble.h"
 #include "core_v2/internal/mediums/bluetooth_classic.h"
 #include "core_v2/internal/mediums/bluetooth_radio.h"
 #include "core_v2/internal/mediums/webrtc.h"
@@ -22,6 +23,9 @@ class Mediums {
   // Returns a handle to the Bluetooth Classic medium.
   BluetoothClassic& GetBluetoothClassic();
 
+  // Returns a handle to the Ble medium.
+  Ble& GetBle();
+
   // Returns a handle to the Wifi-Lan medium.
   WifiLan& GetWifiLan();
 
@@ -39,6 +43,7 @@ class Mediums {
   // corresponding radio.
   BluetoothRadio bluetooth_radio_;
   BluetoothClassic bluetooth_classic_{bluetooth_radio_};
+  Ble ble_{bluetooth_radio_};
   WifiLan wifi_lan_;
   mediums::WebRtc webrtc_;
 };

cpp/core_v2/internal/mediums/wifi_lan.cc

@@ -44,8 +44,7 @@ bool WifiLan::StartAdvertising(const std::string& service_id,
   }
 
   NEARBY_LOGS(INFO) << "Turned on WifiLan advertising with service info name="
-                    << service_info_name
-                    << ", service id=" << service_id;
+                    << service_info_name << ", service id=" << service_id;
   advertising_info_.Add(service_id);
   return true;
 }
@@ -208,7 +207,8 @@ bool WifiLan::IsAcceptingConnectionsLocked(const std::string& service_id) {
 WifiLanSocket WifiLan::Connect(WifiLanService& wifi_lan_service,
                                const std::string& service_id) {
   MutexLock lock(&mutex_);
-  NEARBY_LOG(INFO, "WifiLan::Connect: service=%p", &wifi_lan_service);
+  NEARBY_LOG(INFO, "WifiLan::Connect: service=%p, service_info_name=%s",
+             &wifi_lan_service, wifi_lan_service.GetName().c_str());
   // Socket to return. To allow for NRVO to work, it has to be a single object.
   WifiLanSocket socket;
 
@@ -228,13 +228,19 @@ WifiLanSocket WifiLan::Connect(WifiLanService& wifi_lan_service,
 
   socket = medium_.Connect(wifi_lan_service, service_id);
   if (!socket.IsValid()) {
-    NEARBY_LOG(INFO, "Failed to Connect via WifiLan [service=%s]",
+    NEARBY_LOG(INFO, "Failed to Connect via WifiLan [service_id=%s]",
                service_id.c_str());
   }
 
   return socket;
 }
 
+WifiLanService WifiLan::GetRemoteWifiLanService(const std::string& ip_address,
+                                                int port) {
+  MutexLock lock(&mutex_);
+  return medium_.FindRemoteService(ip_address, port);
+}
+
 }  // namespace connections
 }  // namespace nearby
 }  // namespace location

cpp/core_v2/internal/mediums/wifi_lan.h

@@ -69,6 +69,9 @@ class WifiLan {
                         const std::string& service_id)
       ABSL_LOCKS_EXCLUDED(mutex_);
 
+  WifiLanService GetRemoteWifiLanService(const std::string& ip_address,
+                                         int port) ABSL_LOCKS_EXCLUDED(mutex_);
+
  private:
   struct AdvertisingInfo {
     bool Empty() const { return service_ids.empty(); }
@@ -115,7 +118,7 @@ class WifiLan {
   // Same as IsAvailable(), but must be called with mutex_ held.
   bool IsAvailableLocked() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
-    // Same as IsAdvertising(), but must be called with mutex_ held.
+  // Same as IsAdvertising(), but must be called with mutex_ held.
   bool IsAdvertisingLocked(const std::string& service_id)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 

cpp/core_v2/internal/mediums/wifi_lan_test.cc

@@ -8,6 +8,7 @@
 #include "platform_v2/public/wifi_lan.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include "absl/strings/string_view.h"
 
 namespace location {
 namespace nearby {
@@ -33,7 +34,6 @@ TEST_F(WifiLanTest, CanConstructValidObject) {
   WifiLan wifi_lan_a;
   WifiLan wifi_lan_b;
   std::string service_id(kServiceID);
-  std::string service_name{kServiceInfoName};
 
   EXPECT_TRUE(wifi_lan_a.IsAvailable());
   EXPECT_TRUE(wifi_lan_b.IsAvailable());
@@ -45,19 +45,19 @@ TEST_F(WifiLanTest, CanStartAdvertising) {
   WifiLan wifi_lan_a;
   WifiLan wifi_lan_b;
   std::string service_id(kServiceID);
-  std::string service_name{kServiceInfoName};
+  std::string service_info_name{kServiceInfoName};
   CountDownLatch found_latch(1);
 
   wifi_lan_b.StartDiscovery(
       service_id, DiscoveredServiceCallback{
                       .service_discovered_cb =
                           [&found_latch](WifiLanService& service,
-                                         const std::string& service_id) {
+                                         absl::string_view service_id) {
                             found_latch.CountDown();
                           },
                   });
 
-  EXPECT_TRUE(wifi_lan_a.StartAdvertising(service_id, service_name));
+  EXPECT_TRUE(wifi_lan_a.StartAdvertising(service_id, service_info_name));
   EXPECT_TRUE(found_latch.Await(kWaitDuration).result());
   EXPECT_TRUE(wifi_lan_a.StopAdvertising(service_id));
   EXPECT_TRUE(wifi_lan_b.StopDiscovery(service_id));
@@ -69,11 +69,11 @@ TEST_F(WifiLanTest, CanStartDiscovery) {
   WifiLan wifi_lan_a;
   WifiLan wifi_lan_b;
   std::string service_id(kServiceID);
-  std::string service_name{kServiceInfoName};
+  std::string service_info_name{kServiceInfoName};
   CountDownLatch accept_latch(1);
   CountDownLatch lost_latch(1);
 
-  wifi_lan_b.StartAdvertising(service_id, service_name);
+  wifi_lan_b.StartAdvertising(service_id, service_info_name);
 
   EXPECT_TRUE(wifi_lan_a.StartDiscovery(
       service_id, {
@@ -100,17 +100,17 @@ TEST_F(WifiLanTest, CanStartAcceptingConnectionsAndConnect) {
   WifiLan wifi_lan_a;
   WifiLan wifi_lan_b;
   std::string service_id(kServiceID);
-  std::string service_name{kServiceInfoName};
+  std::string service_info_name{kServiceInfoName};
   CountDownLatch found_latch(1);
   CountDownLatch accept_latch(1);
 
-  wifi_lan_a.StartAdvertising(service_id, service_name);
+  wifi_lan_a.StartAdvertising(service_id, service_info_name);
   wifi_lan_a.StartAcceptingConnections(
       service_id,
       {
           .accepted_cb = [&accept_latch](
                              WifiLanSocket socket,
-                             const std::string&) { accept_latch.CountDown(); },
+                             absl::string_view) { accept_latch.CountDown(); },
       });
   WifiLanService discovered_service;
   wifi_lan_b.StartDiscovery(
@@ -118,7 +118,7 @@ TEST_F(WifiLanTest, CanStartAcceptingConnectionsAndConnect) {
       {
           .service_discovered_cb =
               [&found_latch, &discovered_service](
-                  WifiLanService& service, const std::string& service_id) {
+                  WifiLanService& service, absl::string_view service_id) {
                 discovered_service = service;
                 NEARBY_LOG(INFO, "Discovered service=%p [impl=%p]", &service,
                            &service.GetImpl());
@@ -135,6 +135,7 @@ TEST_F(WifiLanTest, CanStartAcceptingConnectionsAndConnect) {
   EXPECT_TRUE(accept_latch.Await(kWaitDuration).result());
   EXPECT_TRUE(socket.IsValid());
   wifi_lan_b.StopDiscovery(service_id);
+  wifi_lan_a.StopAcceptingConnections(service_id);
   wifi_lan_a.StopAdvertising(service_id);
   env_.Stop();
 }