Roll forward to cl/314747126

Change-Id: I858d3227b44ca6d727b39fae95358df58fce9c1b

cpp/platform_v2/api/BUILD

@@ -52,7 +52,7 @@ cc_library(
         "//platform_v2/base",
         "//absl/strings",
         "//absl/types:optional",
-        "//webrtc/api:libjingle_peerconnection_api",
+        "//webrtc/files/stable/webrtc/api:libjingle_peerconnection_api",
     ],
 )
 

cpp/platform_v2/api/platform.h

@@ -65,9 +65,11 @@ class ImplementationPlatform {
 
   // Protocol implementations, domain-specific support
   static std::unique_ptr<BluetoothAdapter> CreateBluetoothAdapter();
-  static std::unique_ptr<BluetoothClassicMedium> CreateBluetoothClassicMedium();
-  static std::unique_ptr<BleMedium> CreateBleMedium();
-  static std::unique_ptr<ble_v2::BleMedium> CreateBleV2Medium();
+  static std::unique_ptr<BluetoothClassicMedium> CreateBluetoothClassicMedium(
+      BluetoothAdapter&);
+  static std::unique_ptr<BleMedium> CreateBleMedium(BluetoothAdapter&);
+  static std::unique_ptr<ble_v2::BleMedium> CreateBleV2Medium(
+      BluetoothAdapter&);
   static std::unique_ptr<ServerSyncMedium> CreateServerSyncMedium();
   static std::unique_ptr<WifiMedium> CreateWifiMedium();
   static std::unique_ptr<WifiLanMedium> CreateWifiLanMedium();

cpp/platform_v2/api/webrtc.h

@@ -5,7 +5,7 @@
 
 #include "platform_v2/base/byte_array.h"
 #include "absl/strings/string_view.h"
-#include "webrtc/api/peer_connection_interface.h"
+#include "webrtc/files/stable/webrtc/api/peer_connection_interface.h"
 
 namespace location {
 namespace nearby {

cpp/platform_v2/base/medium_environment.cc

@@ -21,8 +21,23 @@ MediumEnvironment& MediumEnvironment::Instance() {
   return *env;
 }
 
+void MediumEnvironment::Start() {
+  if (!enabled_.exchange(true)) {
+    NEARBY_LOG(INFO, "MediumEnvironment::Start()");
+    Reset();
+  }
+}
+
+void MediumEnvironment::Stop() {
+  if (enabled_.exchange(false)) {
+    NEARBY_LOG(INFO, "MediumEnvironment::Stop()");
+    Sync(false);
+  }
+}
+
 void MediumEnvironment::Reset() {
   RunOnMediumEnvironmentThread([this]() {
+    NEARBY_LOG(INFO, "MediumEnvironment::Reset()");
     bluetooth_adapters_.clear();
     bluetooth_mediums_.clear();
   });
@@ -31,6 +46,7 @@ void MediumEnvironment::Reset() {
 
 void MediumEnvironment::Sync(bool enable_notifications) {
   enable_notifications_ = enable_notifications;
+  NEARBY_LOG(INFO, "MediumEnvironment::sync(%d)", enable_notifications);
   int count = 0;
   do {
     CountDownLatch latch(1);
@@ -50,6 +66,7 @@ void MediumEnvironment::Sync(bool enable_notifications) {
 void MediumEnvironment::OnBluetoothAdapterChangedState(
     api::BluetoothAdapter& adapter, api::BluetoothDevice& adapter_device,
     std::string name, bool enabled, api::BluetoothAdapter::ScanMode mode) {
+  if (!enabled_) return;
   RunOnMediumEnvironmentThread([this, &adapter, &adapter_device,
                                 name = std::move(name), enabled, mode]() {
     NEARBY_LOG(INFO,
@@ -74,6 +91,7 @@ void MediumEnvironment::OnDeviceStateChanged(
     BluetoothMediumContext& info, api::BluetoothDevice& device,
     const std::string& name, api::BluetoothAdapter::ScanMode mode,
     bool enabled) {
+  if (!enabled_) return;
   auto item = info.devices.find(&device);
   if (item == info.devices.end()) {
     NEARBY_LOG(
@@ -136,6 +154,7 @@ void MediumEnvironment::RunOnMediumEnvironmentThread(
 void MediumEnvironment::RegisterBluetoothMedium(
     api::BluetoothClassicMedium& medium,
     api::BluetoothAdapter& medium_adapter) {
+  if (!enabled_) return;
   RunOnMediumEnvironmentThread([this, &medium, &medium_adapter]() {
     auto& context = bluetooth_mediums_
                         .insert({&medium,
@@ -156,6 +175,7 @@ void MediumEnvironment::RegisterBluetoothMedium(
 
 void MediumEnvironment::UpdateBluetoothMedium(
     api::BluetoothClassicMedium& medium, BluetoothDiscoveryCallback callback) {
+  if (!enabled_) return;
   RunOnMediumEnvironmentThread([this, &medium,
                                 callback = std::move(callback)]() {
     auto item = bluetooth_mediums_.find(&medium);
@@ -178,6 +198,7 @@ void MediumEnvironment::UpdateBluetoothMedium(
 
 void MediumEnvironment::UnregisterBluetoothMedium(
     api::BluetoothClassicMedium& medium) {
+  if (!enabled_) return;
   RunOnMediumEnvironmentThread([this, &medium]() {
     auto item = bluetooth_mediums_.extract(&medium);
     if (item.empty()) return;

cpp/platform_v2/base/medium_environment.h

@@ -27,6 +27,16 @@ class MediumEnvironment {
   // Creates and returns a reference to the global test environment instance.
   static MediumEnvironment& Instance();
 
+  // Global ON/OFF switch for medium environment.
+  // Start & Stop work as On/Off switch for this object.
+  // Default state (after creation) is ON, to make it compatible with early
+  // tests that are already using it and relying on it being ON.
+
+  // Enables Medium environment.
+  void Start();
+  // Disables Medium environment.
+  void Stop();
+
   // Clears state. No notifications are sent.
   void Reset();
 
@@ -95,6 +105,7 @@ class MediumEnvironment {
                             api::BluetoothAdapter::ScanMode mode, bool enabled);
   void RunOnMediumEnvironmentThread(std::function<void()> runnable);
 
+  std::atomic_bool enabled_ = true;
   std::atomic_int job_count_ = 0;
   std::atomic_bool enable_notifications_ = false;
   SingleThreadExecutor executor_;

cpp/platform_v2/impl/g3/BUILD

@@ -39,10 +39,12 @@ cc_library(
     testonly = True,
     srcs = [
         "bluetooth_adapter.cc",
+        "bluetooth_classic.cc",
         "webrtc.cc",
     ],
     hdrs = [
         "bluetooth_adapter.h",
+        "bluetooth_classic.h",
         "webrtc.h",
     ],
     visibility = [
@@ -51,13 +53,17 @@ cc_library(
     deps = [
         ":types",
         "//platform_v2/api:comm",
+        "//platform_v2/base",
+        "//platform_v2/base:logging",
         "//platform_v2/base:test_util",
         "//absl/base:core_headers",
+        "//absl/container:flat_hash_map",
+        "//absl/container:flat_hash_set",
         "//absl/strings",
         "//absl/synchronization",
-        "//webrtc/api:create_peerconnection_factory",  #buildcleaner: keep
-        "//webrtc/api:libjingle_peerconnection_api",
-        "//webrtc/api/task_queue:default_task_queue_factory",
+        "//webrtc/files/stable/webrtc/api:create_peerconnection_factory",  #buildcleaner: keep
+        "//webrtc/files/stable/webrtc/api:libjingle_peerconnection_api",
+        "//webrtc/files/stable/webrtc/api/task_queue:default_task_queue_factory",
     ],
 )
 

cpp/platform_v2/impl/g3/bluetooth_adapter.cc

@@ -3,6 +3,7 @@
 #include <string>
 
 #include "platform_v2/base/medium_environment.h"
+#include "platform_v2/impl/g3/bluetooth_classic.h"
 
 namespace location {
 namespace nearby {
@@ -11,9 +12,13 @@ namespace g3 {
 BluetoothDevice::BluetoothDevice(BluetoothAdapter* adapter)
     : adapter_(*adapter) {}
 
+std::string BluetoothDevice::GetName() const { return adapter_.GetName(); }
+
 BluetoothAdapter::~BluetoothAdapter() { SetStatus(Status::kDisabled); }
 
-std::string BluetoothDevice::GetName() const { return adapter_.GetName(); }
+void BluetoothAdapter::SetMedium(api::BluetoothClassicMedium* medium) {
+  medium_ = medium;
+}
 
 bool BluetoothAdapter::SetStatus(Status status) {
   BluetoothAdapter::ScanMode mode;

cpp/platform_v2/impl/g3/bluetooth_adapter.h

@@ -70,9 +70,13 @@ class BluetoothAdapter : public api::BluetoothAdapter {
 
   BluetoothDevice& GetDevice() { return device_; }
 
+  void SetMedium(api::BluetoothClassicMedium* medium);
+  api::BluetoothClassicMedium* GetMedium() { return medium_; }
+
  private:
   mutable absl::Mutex mutex_;
   BluetoothDevice device_{this};
+  api::BluetoothClassicMedium* medium_ = nullptr;
   ScanMode mode_ ABSL_GUARDED_BY(mutex_) = ScanMode::kNone;
   std::string name_ ABSL_GUARDED_BY(mutex_) = "unknown G3 BT device";
   bool enabled_ ABSL_GUARDED_BY(mutex_) = false;

cpp/platform_v2/impl/g3/bluetooth_classic.cc

@@ -0,0 +1,240 @@
+#include "platform_v2/impl/g3/bluetooth_classic.h"
+
+#include <memory>
+#include <string>
+
+#include "platform_v2/api/bluetooth_classic.h"
+#include "platform_v2/base/logging.h"
+#include "platform_v2/base/medium_environment.h"
+#include "platform_v2/impl/g3/bluetooth_adapter.h"
+#include "absl/synchronization/mutex.h"
+
+namespace location {
+namespace nearby {
+namespace g3 {
+
+void BluetoothSocket::Connect(BluetoothSocket& other) {
+  absl::MutexLock lock(&mutex_);
+  remote_socket_ = &other;
+}
+
+bool BluetoothSocket::IsConnected() const {
+  absl::MutexLock lock(&mutex_);
+  return IsConnectedLocked();
+}
+
+bool BluetoothSocket::IsClosed() const {
+  absl::MutexLock lock(&mutex_);
+  return closed_;
+}
+
+bool BluetoothSocket::IsConnectedLocked() const {
+  return remote_socket_ != nullptr;
+}
+
+InputStream& BluetoothSocket::GetInputStream() {
+  auto* remote_socket = GetRemoteSocket();
+  CHECK(remote_socket != nullptr);
+  return remote_socket->GetLocalInputStream();
+}
+
+OutputStream& BluetoothSocket::GetOutputStream() {
+  return GetLocalOutputStream();
+}
+
+InputStream& BluetoothSocket::GetLocalInputStream() {
+  absl::MutexLock lock(&mutex_);
+  return output_.GetInputStream();
+}
+
+OutputStream& BluetoothSocket::GetLocalOutputStream() {
+  absl::MutexLock lock(&mutex_);
+  return output_.GetOutputStream();
+}
+
+Exception BluetoothSocket::Close() {
+  BluetoothSocket* remote_socket = nullptr;
+  {
+    absl::MutexLock lock(&mutex_);
+    if (!closed_) {
+      remote_socket = remote_socket_;
+      output_.GetOutputStream().Close();
+      output_.GetInputStream().Close();
+      closed_ = true;
+    }
+  }
+  if (remote_socket != nullptr) {
+    remote_socket->Close();
+  }
+  return {Exception::kSuccess};
+}
+
+BluetoothSocket* BluetoothSocket::GetRemoteSocket() {
+  absl::MutexLock lock(&mutex_);
+  return remote_socket_;
+}
+
+BluetoothDevice* BluetoothSocket::GetRemoteDevice() {
+  BluetoothAdapter* remote_adapter = nullptr;
+  {
+    absl::MutexLock lock(&mutex_);
+    if (remote_socket_ == nullptr || remote_socket_->adapter_ == nullptr) {
+      return nullptr;
+    }
+    remote_adapter = remote_socket_->adapter_;
+  }
+  return remote_adapter ? &remote_adapter->GetDevice() : nullptr;
+}
+
+std::unique_ptr<api::BluetoothSocket> BluetoothServerSocket::Accept() {
+  absl::MutexLock lock(&mutex_);
+  while (pending_sockets_.empty()) {
+    cond_.Wait(&mutex_);
+    if (closed_) break;
+  }
+  // whether or not we were running in the wait loop, return early if closed.
+  if (closed_) return {};
+  auto* remote_socket =
+      pending_sockets_.extract(pending_sockets_.begin()).value();
+  CHECK(remote_socket);
+  auto local_socket = std::make_unique<BluetoothSocket>(adapter_);
+  local_socket->Connect(*remote_socket);
+  remote_socket->Connect(*local_socket);
+  cond_.SignalAll();
+  return local_socket;
+}
+
+bool BluetoothServerSocket::Connect(BluetoothSocket& socket) {
+  absl::MutexLock lock(&mutex_);
+  if (closed_) return false;
+  if (socket.IsConnected()) {
+    NEARBY_LOG(ERROR,
+               "Failed to connect to BT server socket: already connected");
+    return true;  // already connected.
+  }
+  // add client socket to the pending list
+  pending_sockets_.emplace(&socket);
+  cond_.SignalAll();
+  while (!socket.IsConnected()) {
+    cond_.Wait(&mutex_);
+    if (closed_) return false;
+  }
+  return true;
+}
+
+void BluetoothServerSocket::SetCloseNotifier(std::function<void()> notifier) {
+  absl::MutexLock lock(&mutex_);
+  close_notifier_ = std::move(notifier);
+}
+
+BluetoothServerSocket::~BluetoothServerSocket() {
+  absl::MutexLock lock(&mutex_);
+  DoClose();
+}
+
+Exception BluetoothServerSocket::Close() {
+  absl::MutexLock lock(&mutex_);
+  return DoClose();
+}
+
+Exception BluetoothServerSocket::DoClose() {
+  bool should_notify = !closed_;
+  closed_ = true;
+  if (should_notify) {
+    cond_.SignalAll();
+    if (close_notifier_) {
+      auto notifier = std::move(close_notifier_);
+      mutex_.Unlock();
+      // Notifier may contain calls to public API, and may cause deadlock, if
+      // mutex_ is held during the call.
+      notifier();
+      mutex_.Lock();
+    }
+  }
+  return {Exception::kSuccess};
+}
+
+BluetoothClassicMedium::BluetoothClassicMedium(api::BluetoothAdapter& adapter)
+    // TODO(apolyudov): implement and use downcast<> with static assertions.
+    : adapter_(static_cast<BluetoothAdapter*>(&adapter)) {
+  adapter_->SetMedium(this);
+  auto& env = MediumEnvironment::Instance();
+  env.RegisterBluetoothMedium(*this, GetAdapter());
+}
+
+BluetoothClassicMedium::~BluetoothClassicMedium() {
+  adapter_->SetMedium(nullptr);
+  auto& env = MediumEnvironment::Instance();
+  env.UnregisterBluetoothMedium(*this);
+}
+
+bool BluetoothClassicMedium::StartDiscovery(DiscoveryCallback callback) {
+  auto& env = MediumEnvironment::Instance();
+  env.UpdateBluetoothMedium(*this, std::move(callback));
+  return true;
+}
+
+bool BluetoothClassicMedium::StopDiscovery() {
+  auto& env = MediumEnvironment::Instance();
+  env.UpdateBluetoothMedium(*this, {});
+  return true;
+}
+
+std::unique_ptr<api::BluetoothSocket> BluetoothClassicMedium::ConnectToService(
+    api::BluetoothDevice& remote_device, const std::string& service_uuid) {
+  NEARBY_LOG(INFO,
+             "G3 ConnectToService [self]: medium=%p, adapter=%p, device=%p",
+             this, &GetAdapter(), &GetAdapter().GetDevice());
+  // First, find an instance of remote medium, that exposed this device.
+  auto& adapter = static_cast<BluetoothDevice&>(remote_device).GetAdapter();
+  auto* medium = static_cast<BluetoothClassicMedium*>(adapter.GetMedium());
+
+  if (!medium) return {};  // Adapter is not bound to medium. Bail out.
+
+  BluetoothServerSocket* server_socket = nullptr;
+  NEARBY_LOG(
+      INFO,
+      "G3 ConnectToService [peer]: medium=%p, adapter=%p, device=%p, uuid=%s",
+      medium, &adapter, &remote_device, service_uuid.c_str());
+  // Then, find our server socket context in this medium.
+  {
+    absl::MutexLock medium_lock(&medium->mutex_);
+    auto item = medium->sockets_.find(service_uuid);
+    server_socket = item != sockets_.end() ? item->second : nullptr;
+    if (server_socket == nullptr) {
+      NEARBY_LOG(ERROR, "Failed to find BT Server socket: uuid=%s",
+                 service_uuid.c_str());
+      return {};
+    }
+  }
+
+  auto socket = std::make_unique<BluetoothSocket>(&GetAdapter());
+  // Finally, Request to connect to this socket.
+  if (!server_socket->Connect(*socket)) {
+    NEARBY_LOG(ERROR, "Failed to connect to existing BT Server socket: uuid=%s",
+               service_uuid.c_str());
+    return {};
+  }
+
+  NEARBY_LOG(INFO, "G3 ConnectToService: connected: socket=%p", socket.get());
+  return socket;
+}
+
+std::unique_ptr<api::BluetoothServerSocket>
+BluetoothClassicMedium::ListenForService(const std::string& service_name,
+                                         const std::string& service_uuid) {
+  auto socket = std::make_unique<BluetoothServerSocket>(GetAdapter());
+  socket->SetCloseNotifier([this, uuid = service_uuid]() {
+    absl::MutexLock lock(&mutex_);
+    sockets_.erase(uuid);
+  });
+  NEARBY_LOG(INFO, "Adding service: medium=%p, uuid=%s", this,
+             service_uuid.c_str());
+  absl::MutexLock lock(&mutex_);
+  sockets_.emplace(service_uuid, socket.get());
+  return socket;
+}
+
+}  // namespace g3
+}  // namespace nearby
+}  // namespace location

cpp/platform_v2/impl/g3/bluetooth_classic.h

@@ -0,0 +1,218 @@
+#ifndef PLATFORM_V2_IMPL_G3_BLUETOOTH_CLASSIC_H_
+#define PLATFORM_V2_IMPL_G3_BLUETOOTH_CLASSIC_H_
+
+#include <memory>
+#include <string>
+
+#include "platform_v2/api/bluetooth_classic.h"
+#include "platform_v2/base/byte_array.h"
+#include "platform_v2/base/exception.h"
+#include "platform_v2/base/input_stream.h"
+#include "platform_v2/base/listeners.h"
+#include "platform_v2/base/output_stream.h"
+#include "platform_v2/impl/g3/bluetooth_adapter.h"
+#include "platform_v2/impl/g3/pipe.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/synchronization/mutex.h"
+
+namespace location {
+namespace nearby {
+namespace g3 {
+
+// https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html.
+class BluetoothSocket : public api::BluetoothSocket {
+ public:
+  BluetoothSocket() = default;
+  explicit BluetoothSocket(BluetoothAdapter* adapter) : adapter_(adapter) {}
+  ~BluetoothSocket() override = default;
+
+  // Connects to another BluetoothSocket, to form a functional low-level
+  // channel. From this point on, and until Close is called, connection exists.
+  void Connect(BluetoothSocket& other);
+
+  // NOTE:
+  // It is an undefined behavior if GetInputStream() or GetOutputStream() is
+  // called for a not-connected BluetoothSocket, i.e. any object that is not
+  // returned by BluetoothClassicMedium::ConnectToService() for client side or
+  // BluetoothServerSocket::Accept() for server side of connection.
+
+  // Returns the InputStream of this connected BluetoothSocket.
+  InputStream& GetInputStream() override;
+
+  // Returns the OutputStream of this connected BluetoothSocket.
+  // This stream is for local side to write.
+  OutputStream& GetOutputStream() override;
+
+  // Returns address of a remote BluetoothSocket or nullptr.
+  BluetoothSocket* GetRemoteSocket() ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns true if connection exists to the (possibly closed) remote socket.
+  bool IsConnected() const ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns true if socket is closed.
+  bool IsClosed() const ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Closes both input and output streams, marks Socket as closed.
+  // After this call object should be treated as not connected.
+  // Returns Exception::kIo on error, Exception::kSuccess otherwise.
+  Exception Close() override ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html#getRemoteDevice()
+  // Returns valid BluetoothDevice pointer if there is a connection, and
+  // nullptr otherwise.
+  BluetoothDevice* GetRemoteDevice() override ABSL_LOCKS_EXCLUDED(mutex_);
+
+ private:
+  // Returns true if connection exists to the (possibly closed) remote socket.
+  bool IsConnectedLocked() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Returns InputStream of our side of a connection.
+  // This is what the remote side is supposed to read from.
+  // This is a helper for GetInputStream() method.
+  InputStream& GetLocalInputStream() ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns OutputStream of our side of a connection.
+  // This is what the local size is supposed to write to.
+  // This is a helper for GetOutputStream() method.
+  OutputStream& GetLocalOutputStream() ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Output pipe is initialized by constructor, it remains always valid, until
+  // it is closed. it represents output part of a local socket. Input part of a
+  // local socket comes from the peer socket, after connection.
+  Pipe output_;
+  mutable absl::Mutex mutex_;
+  BluetoothAdapter* adapter_ = nullptr;  // Our Adapter. Read only.
+  BluetoothSocket* remote_socket_ ABSL_GUARDED_BY(mutex_) = nullptr;
+  bool closed_ ABSL_GUARDED_BY(mutex_) = false;
+};
+
+// https://developer.android.com/reference/android/bluetooth/BluetoothServerSocket.html.
+class BluetoothServerSocket : public api::BluetoothServerSocket {
+ public:
+  explicit BluetoothServerSocket(BluetoothAdapter& adapter)
+      : adapter_(&adapter) {}
+  ~BluetoothServerSocket() override;
+
+  // Blocks until either:
+  // - at least one incoming connection request is available, or
+  // - ServerSocket is closed.
+  // On success, returns connected socket, ready to exchange data.
+  // Returns nullptr on error.
+  // Once error is reported, it is permanent, and ServerSocket has to be closed.
+  //
+  // Called by the server side of a connection.
+  // Returns BluetoothSocket to the server side.
+  // If not null, returned socket is connected to its remote (client-side) peer.
+  std::unique_ptr<api::BluetoothSocket> Accept() override
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Blocks until either:
+  // - connection is available, or
+  // - server socket is closed, or
+  // - error happens.
+  //
+  // Called by the client side of a connection.
+  // socket is an initialized BluetoothSocket, associated with a client
+  // BluetoothAdapter.
+  // Returns true, if socket is successfully connected.
+  bool Connect(BluetoothSocket& socket) ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Called by the server side of a connection before passing ownership of
+  // BluetoothServerSocker to user, to track validity of a pointer to this
+  // server socket,
+  void SetCloseNotifier(std::function<void()> notifier)
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Returns Exception::kIo on error, Exception::kSuccess otherwise.
+  // Calls close_notifier if it was previously set, and marks socket as closed.
+  Exception Close() override ABSL_LOCKS_EXCLUDED(mutex_);
+
+ private:
+  Exception DoClose() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  absl::Mutex mutex_;
+  absl::CondVar cond_;
+  BluetoothAdapter* adapter_ = nullptr;  // Our Adapter. Read only.
+  absl::flat_hash_set<BluetoothSocket*> pending_sockets_
+      ABSL_GUARDED_BY(mutex_);
+  std::function<void()> close_notifier_ ABSL_GUARDED_BY(mutex_);
+  bool closed_ ABSL_GUARDED_BY(mutex_) = false;
+};
+
+// Container of operations that can be performed over the Bluetooth Classic
+// medium.
+class BluetoothClassicMedium : public api::BluetoothClassicMedium {
+ public:
+  explicit BluetoothClassicMedium(api::BluetoothAdapter& adapter);
+  ~BluetoothClassicMedium() override;
+
+  // NOTE(DiscoveryCallback):
+  // BluetoothDevice is a proxy object created as a result of BT discovery.
+  // Its lifetime spans between calls to device_discovered_cb and
+  // device_lost_cb.
+  // It is safe to use BluetoothDevice in device_discovered_cb() callback
+  // and at any time afterwards, until device_lost_cb() is called.
+  // It is not safe to use BluetoothDevice after returning from
+  // device_lost_cb() callback.
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#startDiscovery()
+  //
+  // Returns true once the process of discovery has been initiated.
+  bool StartDiscovery(DiscoveryCallback callback) override
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#cancelDiscovery()
+  //
+  // Returns true once discovery is well and truly stopped; after this returns,
+  // there must be no more invocations of the DiscoveryCallback passed in to
+  // StartDiscovery().
+  bool StopDiscovery() override ABSL_LOCKS_EXCLUDED(mutex_);
+
+  // Connects to existing remote BT service.
+  //
+  // A combination of
+  // https://developer.android.com/reference/android/bluetooth/BluetoothDevice.html#createInsecureRfcommSocketToServiceRecord
+  // followed by
+  // https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html#connect().
+  //
+  // service_uuid is the canonical textual representation
+  // (https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) of a
+  // type 3 name-based
+  // (https://en.wikipedia.org/wiki/Universally_unique_identifier#Versions_3_and_5_(namespace_name-based))
+  // UUID.
+  //
+  // On success, returns a new BluetoothSocket.
+  // On error, returns nullptr.
+  std::unique_ptr<api::BluetoothSocket> ConnectToService(
+      api::BluetoothDevice& remote_device,
+      const std::string& service_uuid) override ABSL_LOCKS_EXCLUDED(mutex_);
+
+  BluetoothAdapter& GetAdapter() { return *adapter_; }
+
+  // Creates BT service, and begins listening for remote attempts to connect.
+  //
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#listenUsingInsecureRfcommWithServiceRecord
+  //
+  // service_uuid is the canonical textual representation
+  // (https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) of a
+  // type 3 name-based
+  // (https://en.wikipedia.org/wiki/Universally_unique_identifier#Versions_3_and_5_(namespace_name-based))
+  // UUID.
+  //
+  //  Returns nullptr on error.
+  std::unique_ptr<api::BluetoothServerSocket> ListenForService(
+      const std::string& service_name, const std::string& service_uuid) override
+      ABSL_LOCKS_EXCLUDED(mutex_);
+
+ private:
+  absl::Mutex mutex_;
+  BluetoothAdapter* adapter_;  // Our device adapter; read-only.
+  absl::flat_hash_map<std::string, BluetoothServerSocket*> sockets_
+      ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace g3
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_IMPL_G3_BLUETOOTH_CLASSIC_H_

cpp/platform_v2/impl/g3/platform.cc

@@ -21,6 +21,7 @@
 #include "platform_v2/impl/g3/atomic_boolean.h"
 #include "platform_v2/impl/g3/atomic_reference_any.h"
 #include "platform_v2/impl/g3/bluetooth_adapter.h"
+#include "platform_v2/impl/g3/bluetooth_classic.h"
 #include "platform_v2/impl/g3/condition_variable.h"
 #include "platform_v2/impl/g3/count_down_latch.h"
 #include "platform_v2/impl/g3/multi_thread_executor.h"
@@ -96,15 +97,18 @@ std::unique_ptr<OutputFile> ImplementationPlatform::CreateOutputFile(
 }
 
 std::unique_ptr<BluetoothClassicMedium>
-ImplementationPlatform::CreateBluetoothClassicMedium() {
-  return std::unique_ptr<BluetoothClassicMedium>();
+ImplementationPlatform::CreateBluetoothClassicMedium(
+    api::BluetoothAdapter& adapter) {
+  return absl::make_unique<g3::BluetoothClassicMedium>(adapter);
 }
 
-std::unique_ptr<BleMedium> ImplementationPlatform::CreateBleMedium() {
+std::unique_ptr<BleMedium> ImplementationPlatform::CreateBleMedium(
+    api::BluetoothAdapter& adapter) {
   return std::unique_ptr<BleMedium>();
 }
 
-std::unique_ptr<ble_v2::BleMedium> ImplementationPlatform::CreateBleV2Medium() {
+std::unique_ptr<ble_v2::BleMedium> ImplementationPlatform::CreateBleV2Medium(
+    api::BluetoothAdapter& adapter) {
   return std::unique_ptr<ble_v2::BleMedium>();
 }
 

cpp/platform_v2/impl/g3/webrtc.cc

@@ -1,6 +1,6 @@
 #include "platform_v2/impl/g3/webrtc.h"
 
-#include "webrtc/api/task_queue/default_task_queue_factory.h"
+#include "webrtc/files/stable/webrtc/api/task_queue/default_task_queue_factory.h"
 
 namespace location {
 namespace nearby {

cpp/platform_v2/impl/g3/webrtc.h

@@ -5,7 +5,7 @@
 
 #include "platform_v2/api/webrtc.h"
 #include "absl/strings/string_view.h"
-#include "webrtc/api/peer_connection_interface.h"
+#include "webrtc/files/stable/webrtc/api/peer_connection_interface.h"
 
 namespace location {
 namespace nearby {

cpp/platform_v2/public/BUILD

@@ -28,11 +28,13 @@ cc_library(
         "//platform_v2/public:__pkg__",
     ],
     deps = [
+        ":logging",
         "//platform_v2/api:platform",
         "//platform_v2/api:types",
         "//platform_v2/base",
         "//platform_v2/base:util",
         "//absl/base:core_headers",
+        "//absl/container:flat_hash_map",
         "//absl/time",
         "//absl/types:any",
     ],
@@ -40,8 +42,12 @@ cc_library(
 
 cc_library(
     name = "comm",
+    srcs = [
+        "bluetooth_classic.cc",
+    ],
     hdrs = [
         "bluetooth_adapter.h",
+        "bluetooth_classic.h",
         "webrtc.h",
     ],
     visibility = [
@@ -49,10 +55,14 @@ cc_library(
         "//platform_v2/public:__pkg__",
     ],
     deps = [
+        ":logging",
+        ":types",
         "//platform_v2/api:comm",
         "//platform_v2/api:platform",
+        "//platform_v2/base",
+        "//absl/container:flat_hash_map",
         "//absl/strings",
-        "//webrtc/api:libjingle_peerconnection_api",
+        "//webrtc/files/stable/webrtc/api:libjingle_peerconnection_api",
     ],
 )
 
@@ -73,10 +83,12 @@ cc_library(
 
 cc_test(
     name = "public_test",
+    size = "small",
     srcs = [
         "atomic_boolean_test.cc",
         "atomic_reference_test.cc",
         "bluetooth_adapter_test.cc",
+        "bluetooth_classic_test.cc",
         "count_down_latch_test.cc",
         "crypto_test.cc",
         "future_test.cc",
@@ -93,6 +105,7 @@ cc_test(
         ":logging",
         ":types",
         "//platform_v2/base",
+        "//platform_v2/base:test_util",
         "//platform_v2/impl/g3",  # build_cleaner: keep
         "//testing/base/public:gunit_main",
         "//absl/synchronization",

cpp/platform_v2/public/bluetooth_adapter.h

@@ -4,55 +4,81 @@
 #include <string>
 
 #include "platform_v2/api/bluetooth_adapter.h"
+#include "platform_v2/api/bluetooth_classic.h"
 #include "platform_v2/api/platform.h"
 #include "absl/strings/string_view.h"
 
 namespace location {
 namespace nearby {
 
+// https://developer.android.com/reference/android/bluetooth/BluetoothDevice.html.
+class BluetoothDevice final {
+ public:
+  BluetoothDevice() = default;
+  BluetoothDevice(const BluetoothDevice&) = default;
+  BluetoothDevice& operator=(const BluetoothDevice&) = default;
+  explicit BluetoothDevice(api::BluetoothDevice* device) : impl_(device) {}
+  ~BluetoothDevice() = default;
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothDevice.html#getName()
+  std::string GetName() const { return impl_->GetName(); }
+
+  api::BluetoothDevice& GetImpl() { return *impl_; }
+  bool IsValid() const { return impl_ != nullptr; }
+
+ private:
+  api::BluetoothDevice* impl_;
+};
+
 // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html
-class BluetoothAdapter : public api::BluetoothAdapter {
+class BluetoothAdapter final {
  public:
   using Status = api::BluetoothAdapter::Status;
   using ScanMode = api::BluetoothAdapter::ScanMode;
 
   BluetoothAdapter()
       : impl_(api::ImplementationPlatform::CreateBluetoothAdapter()) {}
-  ~BluetoothAdapter() override = default;
+  ~BluetoothAdapter() = default;
   BluetoothAdapter(BluetoothAdapter&&) = default;
   BluetoothAdapter& operator=(BluetoothAdapter&&) = default;
 
   // Synchronously sets the status of the BluetoothAdapter to 'status', and
   // returns true if the operation was a success.
-  bool SetStatus(Status status) override { return impl_->SetStatus(status); }
+  bool SetStatus(Status status) { return impl_->SetStatus(status); }
   Status GetStatus() const {
     return IsEnabled() ? Status::kEnabled : Status::kDisabled;
   }
 
   // Returns true if the BluetoothAdapter's current status is
   // Status::Value::kEnabled.
-  bool IsEnabled() const override { return impl_->IsEnabled(); }
+  bool IsEnabled() const { return impl_->IsEnabled(); }
 
   // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#getScanMode()
   //
   // Returns ScanMode::kUnknown on error.
-  ScanMode GetScanMode() const override { return impl_->GetScanMode(); }
+  ScanMode GetScanMode() const { return impl_->GetScanMode(); }
 
   // Synchronously sets the scan mode of the adapter, and returns true if the
   // operation was a success.
-  bool SetScanMode(ScanMode scan_mode) override {
+  bool SetScanMode(ScanMode scan_mode) {
     return impl_->SetScanMode(scan_mode);
   }
 
   // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#getName()
   // Returns an empty string on error
-  std::string GetName() const override { return impl_->GetName(); }
+  std::string GetName() const { return impl_->GetName(); }
 
   // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#setName(java.lang.String)
-  bool SetName(absl::string_view name) override { return impl_->SetName(name); }
+  bool SetName(absl::string_view name) { return impl_->SetName(name); }
 
   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 BluetoothAdapter object is
+  // itself valid. It matches Core() object lifetime.
+  api::BluetoothAdapter& GetImpl() { return *impl_; }
+
  private:
   std::unique_ptr<api::BluetoothAdapter> impl_;
 };

cpp/platform_v2/public/bluetooth_classic.cc

@@ -0,0 +1,85 @@
+#include "platform_v2/public/bluetooth_classic.h"
+
+#include "platform_v2/public/logging.h"
+#include "platform_v2/public/mutex_lock.h"
+
+namespace location {
+namespace nearby {
+
+BluetoothClassicMedium::~BluetoothClassicMedium() { StopDiscovery(); }
+
+BluetoothSocket BluetoothClassicMedium::ConnectToService(
+    BluetoothDevice& remote_device, const std::string& service_uuid) {
+  NEARBY_LOG(INFO,
+             "BluetoothClassicMedium::ConnectToService: device=%p [impl=%p]",
+             &remote_device, &remote_device.GetImpl());
+  return BluetoothSocket(
+      impl_->ConnectToService(remote_device.GetImpl(), service_uuid));
+}
+
+bool BluetoothClassicMedium::StartDiscovery(DiscoveryCallback callback) {
+  {
+    MutexLock lock(&mutex_);
+    if (discovery_enabled_) {
+      NEARBY_LOG(INFO, "BT Discovery already enabled; impl=%p", &GetImpl());
+      return false;
+    }
+    discovery_callback_ = std::move(callback);
+    devices_.clear();
+    discovery_enabled_ = true;
+    NEARBY_LOG(INFO, "BT Discovery enabled; impl=%p", &GetImpl());
+  }
+  return impl_->StartDiscovery({
+      .device_discovered_cb =
+          [this](api::BluetoothDevice& device) {
+            MutexLock lock(&mutex_);
+            auto pair = devices_.emplace(
+                &device, absl::make_unique<DeviceDiscoveryInfo>());
+            auto& context = *pair.first->second;
+            if (!pair.second) {
+              NEARBY_LOG(INFO, "Adding (again) device=%p, impl=%p",
+                         &context.device, &device);
+              return;
+            }
+            context.device = BluetoothDevice(&device);
+            NEARBY_LOG(INFO, "Adding device=%p, impl=%p", &context.device,
+                       &device);
+            if (!discovery_enabled_) return;
+            discovery_callback_.device_discovered_cb(context.device);
+          },
+      .device_name_changed_cb =
+          [this](api::BluetoothDevice& device) {
+            MutexLock lock(&mutex_);
+            auto& context = *devices_[&device];
+            NEARBY_LOG(INFO, "Renaming device=%p, impl=%p", &context.device,
+                       &device);
+            if (!discovery_enabled_) return;
+            discovery_callback_.device_name_changed_cb(context.device);
+          },
+      .device_lost_cb =
+          [this](api::BluetoothDevice& device) {
+            MutexLock lock(&mutex_);
+            auto item = devices_.extract(&device);
+            auto& context = *item.mapped();
+            NEARBY_LOG(INFO, "Removing device=%p, impl=%p", &context.device,
+                       &device);
+            if (!discovery_enabled_) return;
+            discovery_callback_.device_lost_cb(context.device);
+          },
+  });
+}
+
+bool BluetoothClassicMedium::StopDiscovery() {
+  {
+    MutexLock lock(&mutex_);
+    if (!discovery_enabled_) return true;
+    discovery_enabled_ = false;
+    discovery_callback_ = {};
+    devices_.clear();
+    NEARBY_LOG(INFO, "BT Discovery disabled: impl=%p", &GetImpl());
+  }
+  return impl_->StopDiscovery();
+}
+
+}  // namespace nearby
+}  // namespace location

cpp/platform_v2/public/bluetooth_classic.h

@@ -0,0 +1,205 @@
+#ifndef PLATFORM_V2_PUBLIC_BLUETOOTH_CLASSIC_H_
+#define PLATFORM_V2_PUBLIC_BLUETOOTH_CLASSIC_H_
+
+#include <memory>
+#include <string>
+
+#include "platform_v2/api/bluetooth_classic.h"
+#include "platform_v2/api/platform.h"
+#include "platform_v2/base/byte_array.h"
+#include "platform_v2/base/exception.h"
+#include "platform_v2/base/input_stream.h"
+#include "platform_v2/base/listeners.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 {
+
+// https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html.
+class BluetoothSocket final {
+ public:
+  BluetoothSocket() = default;
+  BluetoothSocket(const BluetoothSocket&) = default;
+  BluetoothSocket& operator=(const BluetoothSocket&) = default;
+  explicit BluetoothSocket(std::unique_ptr<api::BluetoothSocket> socket)
+      : impl_(socket.release()) {}
+  ~BluetoothSocket() = default;
+
+  // Returns the InputStream of this connected BluetoothSocket.
+  InputStream& GetInputStream() { return impl_->GetInputStream(); }
+
+  // Returns the OutputStream of this connected BluetoothSocket.
+  OutputStream& GetOutputStream() { return impl_->GetOutputStream(); }
+
+  // Closes both input and output streams, marks Socket as closed.
+  // After this call object should be treated as not connected.
+  // Returns Exception::kIo on error, Exception::kSuccess otherwise.
+  Exception Close() { return impl_->Close(); }
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html#getRemoteDevice()
+  BluetoothDevice GetRemoteDevice() {
+    return BluetoothDevice(impl_->GetRemoteDevice());
+  }
+
+  // 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 either BluetoothClassicMedium::ConnectTotService or
+  // BluetoothServerSocket::Accept().
+  // 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 BluetoothSocket object is
+  // itself valid. Typically BluetoothSocket lifetime matches duration of the
+  // connection, and is controlled by end user, since they hold the instance.
+  api::BluetoothSocket& GetImpl() { return *impl_; }
+
+ private:
+  std::shared_ptr<api::BluetoothSocket> impl_;
+};
+
+// https://developer.android.com/reference/android/bluetooth/BluetoothServerSocket.html.
+class BluetoothServerSocket final {
+ public:
+  BluetoothServerSocket() = default;
+  BluetoothServerSocket(const BluetoothServerSocket&) = default;
+  BluetoothServerSocket& operator=(const BluetoothServerSocket&) = default;
+  ~BluetoothServerSocket() = default;
+  explicit BluetoothServerSocket(
+      std::unique_ptr<api::BluetoothServerSocket> socket)
+      : impl_(std::move(socket)) {}
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothServerSocket.html#accept()
+  //
+  // Blocks until either:
+  // - at least one incoming connection request is available, or
+  // - ServerSocket is closed.
+  // On success, returns connected socket, ready to exchange data.
+  // Returns nullptr on error.
+  // Once error is reported, it is permanent, and ServerSocket has to be closed.
+  BluetoothSocket Accept() { return BluetoothSocket(impl_->Accept()); }
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothServerSocket.html#close()
+  //
+  // Returns Exception::kIo on error, Exception::kSuccess otherwise.
+  Exception Close() { return impl_->Close(); }
+
+  bool IsValid() const { return impl_ != nullptr; }
+  api::BluetoothServerSocket& GetImpl() { return *impl_; }
+
+ private:
+  std::shared_ptr<api::BluetoothServerSocket> impl_;
+};
+
+// Container of operations that can be performed over the Bluetooth Classic
+// medium.
+class BluetoothClassicMedium final {
+ public:
+  using Platform = api::ImplementationPlatform;
+  struct DiscoveryCallback {
+    // BluetoothDevice is a proxy object created as a result of BT discovery.
+    // Its lifetime spans between calls to device_discovered_cb and
+    // device_lost_cb.
+    // It is safe to use BluetoothDevice in device_discovered_cb() callback
+    // and at any time afterwards, until device_lost_cb() is called.
+    // It is not safe to use BluetoothDevice after returning from
+    // device_lost_cb() callback.
+    std::function<void(BluetoothDevice& device)> device_discovered_cb =
+        DefaultCallback<BluetoothDevice&>();
+    std::function<void(BluetoothDevice& device)> device_name_changed_cb =
+        DefaultCallback<BluetoothDevice&>();
+    std::function<void(BluetoothDevice& device)> device_lost_cb =
+        DefaultCallback<BluetoothDevice&>();
+  };
+  struct DeviceDiscoveryInfo {
+    BluetoothDevice device;
+  };
+
+  explicit BluetoothClassicMedium(BluetoothAdapter& adapter)
+      : impl_(Platform::CreateBluetoothClassicMedium(adapter.GetImpl())),
+        adapter_(adapter) {}
+
+  ~BluetoothClassicMedium();
+
+  // NOTE(DiscoveryCallback):
+  // BluetoothDevice is a proxy object created as a result of BT discovery.
+  // Its lifetime spans between calls to device_discovered_cb and
+  // device_lost_cb.
+  // It is safe to use BluetoothDevice in device_discovered_cb() callback
+  // and at any time afterwards, until device_lost_cb() is called.
+  // It is not safe to use BluetoothDevice after returning from
+  // device_lost_cb() callback.
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#startDiscovery()
+  //
+  // Returns true once the process of discovery has been initiated.
+  bool StartDiscovery(DiscoveryCallback callback);
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#cancelDiscovery()
+  //
+  // Returns true once discovery is well and truly stopped; after this returns,
+  // there must be no more invocations of the DiscoveryCallback passed in to
+  // StartDiscovery().
+  bool StopDiscovery();
+
+  // A combination of
+  // https://developer.android.com/reference/android/bluetooth/BluetoothDevice.html#createInsecureRfcommSocketToServiceRecord
+  // followed by
+  // https://developer.android.com/reference/android/bluetooth/BluetoothSocket.html#connect().
+  //
+  // service_uuid is the canonical textual representation
+  // (https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) of a
+  // type 3 name-based
+  // (https://en.wikipedia.org/wiki/Universally_unique_identifier#Versions_3_and_5_(namespace_name-based))
+  // UUID.
+  //
+  // Returns a new BluetoothSocket. On Success, BluetoothSocket::IsValid()
+  // returns true.
+  BluetoothSocket ConnectToService(BluetoothDevice& remote_device,
+                                   const std::string& service_uuid);
+
+  // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter.html#listenUsingInsecureRfcommWithServiceRecord
+  //
+  // service_uuid is the canonical textual representation
+  // (https://en.wikipedia.org/wiki/Universally_unique_identifier#Format) of a
+  // type 3 name-based
+  // (https://en.wikipedia.org/wiki/Universally_unique_identifier#Versions_3_and_5_(namespace_name-based))
+  // UUID.
+  //
+  // Returns a new BluetoothServerSocket.
+  // On Success, BluetoothServerSocket::IsValid() returns true.
+  BluetoothServerSocket ListenForService(const std::string& service_name,
+                                         const std::string& service_uuid) {
+    return BluetoothServerSocket(
+        impl_->ListenForService(service_name, service_uuid));
+  }
+
+  bool IsValid() const { return impl_ != nullptr; }
+
+  api::BluetoothClassicMedium& GetImpl() { return *impl_; }
+  BluetoothAdapter& GetAdapter() { return adapter_; }
+
+ private:
+  Mutex mutex_;
+  std::unique_ptr<api::BluetoothClassicMedium> impl_;
+  BluetoothAdapter& adapter_;
+  absl::flat_hash_map<api::BluetoothDevice*,
+                      std::unique_ptr<DeviceDiscoveryInfo>>
+      devices_ ABSL_GUARDED_BY(mutex_);
+  DiscoveryCallback discovery_callback_ ABSL_GUARDED_BY(mutex_);
+  bool discovery_enabled_ ABSL_GUARDED_BY(mutex_) = false;
+};
+
+}  // namespace nearby
+}  // namespace location
+
+#endif  // PLATFORM_V2_PUBLIC_BLUETOOTH_CLASSIC_H_

cpp/platform_v2/public/bluetooth_classic_test.cc

@@ -0,0 +1,197 @@
+#include "platform_v2/public/bluetooth_classic.h"
+
+#include <memory>
+
+#include "platform_v2/base/medium_environment.h"
+#include "platform_v2/public/bluetooth_adapter.h"
+#include "platform_v2/public/count_down_latch.h"
+#include "platform_v2/public/logging.h"
+#include "platform_v2/public/single_thread_executor.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/time/time.h"
+
+namespace location {
+namespace nearby {
+namespace {
+
+class BluetoothClassicMediumTest : public ::testing::Test {
+ protected:
+  using DiscoveryCallback = BluetoothClassicMedium::DiscoveryCallback;
+  BluetoothClassicMediumTest() {
+    env_.Reset();
+    adapter_a_ = std::make_unique<BluetoothAdapter>();
+    adapter_b_ = std::make_unique<BluetoothAdapter>();
+    bt_a_ = std::make_unique<BluetoothClassicMedium>(*adapter_a_);
+    bt_b_ = std::make_unique<BluetoothClassicMedium>(*adapter_b_);
+    adapter_a_->SetName("Device-A");
+    adapter_b_->SetName("Device-B");
+    adapter_a_->SetStatus(BluetoothAdapter::Status::kEnabled);
+    adapter_b_->SetStatus(BluetoothAdapter::Status::kEnabled);
+    env_.Sync();
+  }
+  ~BluetoothClassicMediumTest() override {
+    env_.Sync(false);
+    adapter_a_->SetStatus(BluetoothAdapter::Status::kDisabled);
+    adapter_b_->SetStatus(BluetoothAdapter::Status::kDisabled);
+    bt_a_.reset();
+    bt_b_.reset();
+    env_.Sync(false);
+    adapter_a_.reset();
+    adapter_b_.reset();
+    env_.Reset();
+  }
+
+  MediumEnvironment& env_{MediumEnvironment::Instance()};
+
+  std::unique_ptr<BluetoothAdapter> adapter_a_;
+  std::unique_ptr<BluetoothAdapter> adapter_b_;
+  std::unique_ptr<BluetoothClassicMedium> bt_a_;
+  std::unique_ptr<BluetoothClassicMedium> bt_b_;
+};
+
+TEST_F(BluetoothClassicMediumTest, ConstructorDestructorWorks) {
+  // Make sure we can create functional adapters.
+  ASSERT_TRUE(adapter_a_->IsValid());
+  ASSERT_TRUE(adapter_b_->IsValid());
+
+  // Make sure we can create 2 distinct adapters.
+  // NOTE: multiple adapters are supported on a test platform, but not
+  // necessarily on every available HW platform.
+  // Often, HW platform supports only one BT adapter.
+  EXPECT_NE(&adapter_a_->GetImpl(), &adapter_b_->GetImpl());
+
+  // Make sure we can create functional mediums.
+  ASSERT_TRUE(bt_a_->IsValid());
+  ASSERT_TRUE(bt_b_->IsValid());
+
+  // Make sure we can create 2 distinct mediums.
+  EXPECT_NE(&bt_a_->GetImpl(), &bt_b_->GetImpl());
+}
+
+TEST_F(BluetoothClassicMediumTest, CanStartDiscovery) {
+  adapter_a_->SetScanMode(BluetoothAdapter::ScanMode::kConnectable);
+  CountDownLatch found_latch(1);
+  CountDownLatch lost_latch(1);
+  bt_a_->StartDiscovery(DiscoveryCallback{
+      .device_discovered_cb =
+          [this, &found_latch](BluetoothDevice& device) {
+            NEARBY_LOG(INFO, "Device discovered: %s", device.GetName().c_str());
+            EXPECT_EQ(device.GetName(), adapter_b_->GetName());
+            found_latch.CountDown();
+          },
+      .device_lost_cb =
+          [this, &lost_latch](BluetoothDevice& device) {
+            NEARBY_LOG(INFO, "Device lost: %s", device.GetName().c_str());
+            EXPECT_EQ(device.GetName(), adapter_b_->GetName());
+            lost_latch.CountDown();
+          },
+  });
+  adapter_b_->SetScanMode(BluetoothAdapter::ScanMode::kConnectableDiscoverable);
+  EXPECT_EQ(adapter_b_->GetScanMode(),
+            BluetoothAdapter::ScanMode::kConnectableDiscoverable);
+  EXPECT_TRUE(found_latch.Await(absl::Milliseconds(1000)).result());
+  adapter_b_->SetStatus(BluetoothAdapter::Status::kDisabled);
+  EXPECT_FALSE(adapter_b_->IsEnabled());
+  EXPECT_TRUE(lost_latch.Await(absl::Milliseconds(1000)).result());
+}
+
+TEST_F(BluetoothClassicMediumTest, CanStopDiscovery) {
+  adapter_a_->SetScanMode(BluetoothAdapter::ScanMode::kConnectable);
+  CountDownLatch found_latch(1);
+  CountDownLatch lost_latch(1);
+  bt_a_->StartDiscovery(DiscoveryCallback{
+      .device_discovered_cb =
+          [this, &found_latch](BluetoothDevice& device) {
+            NEARBY_LOG(INFO, "Device discovered: %s", device.GetName().c_str());
+            EXPECT_EQ(device.GetName(), adapter_b_->GetName());
+            found_latch.CountDown();
+          },
+      .device_lost_cb =
+          [this, &lost_latch](BluetoothDevice& device) {
+            NEARBY_LOG(INFO, "Device lost: %s", device.GetName().c_str());
+            EXPECT_EQ(device.GetName(), adapter_b_->GetName());
+            lost_latch.CountDown();
+          },
+  });
+  adapter_b_->SetScanMode(BluetoothAdapter::ScanMode::kConnectableDiscoverable);
+  EXPECT_EQ(adapter_b_->GetScanMode(),
+            BluetoothAdapter::ScanMode::kConnectableDiscoverable);
+  EXPECT_TRUE(found_latch.Await(absl::Milliseconds(1000)).result());
+  bt_a_->StopDiscovery();
+  adapter_b_->SetStatus(BluetoothAdapter::Status::kDisabled);
+  EXPECT_FALSE(adapter_b_->IsEnabled());
+  EXPECT_FALSE(lost_latch.Await(absl::Milliseconds(1000)).result());
+}
+
+TEST_F(BluetoothClassicMediumTest, CanListenForService) {
+  adapter_a_->SetScanMode(BluetoothAdapter::ScanMode::kConnectable);
+  CountDownLatch found_latch(1);
+  bt_a_->StartDiscovery(DiscoveryCallback{
+      .device_discovered_cb =
+          [this, &found_latch](BluetoothDevice& device) {
+            NEARBY_LOG(INFO, "Device discovered: %s", device.GetName().c_str());
+            EXPECT_EQ(device.GetName(), adapter_b_->GetName());
+            found_latch.CountDown();
+          },
+  });
+  adapter_b_->SetScanMode(BluetoothAdapter::ScanMode::kConnectableDiscoverable);
+  EXPECT_EQ(adapter_b_->GetScanMode(),
+            BluetoothAdapter::ScanMode::kConnectableDiscoverable);
+  EXPECT_TRUE(found_latch.Await(absl::Milliseconds(1000)).result());
+  std::string service_name{"service"};
+  std::string service_uuid("service-uuid");
+  BluetoothServerSocket server_socket =
+      bt_b_->ListenForService(service_name, service_uuid);
+  EXPECT_TRUE(server_socket.IsValid());
+  server_socket.Close();
+}
+
+TEST_F(BluetoothClassicMediumTest, CanConnectToService) {
+  adapter_a_->SetScanMode(BluetoothAdapter::ScanMode::kConnectable);
+  CountDownLatch found_latch(1);
+  BluetoothDevice* discovered_device = nullptr;
+  bt_a_->StartDiscovery(DiscoveryCallback{
+      .device_discovered_cb =
+          [this, &found_latch, &discovered_device](BluetoothDevice& device) {
+            NEARBY_LOG(INFO, "Device discovered: %s", device.GetName().c_str());
+            EXPECT_EQ(device.GetName(), adapter_b_->GetName());
+            discovered_device = &device;
+            found_latch.CountDown();
+          },
+  });
+  adapter_b_->SetScanMode(BluetoothAdapter::ScanMode::kConnectableDiscoverable);
+  EXPECT_EQ(adapter_b_->GetScanMode(),
+            BluetoothAdapter::ScanMode::kConnectableDiscoverable);
+  EXPECT_TRUE(found_latch.Await(absl::Milliseconds(1000)).result());
+  std::string service_name{"service"};
+  std::string service_uuid("service-uuid");
+  BluetoothServerSocket server_socket =
+      bt_b_->ListenForService(service_name, service_uuid);
+  EXPECT_TRUE(server_socket.IsValid());
+  BluetoothSocket socket_a;
+  BluetoothSocket socket_b;
+  EXPECT_FALSE(socket_a.IsValid());
+  EXPECT_FALSE(socket_b.IsValid());
+  {
+    SingleThreadExecutor server_executor;
+    SingleThreadExecutor client_executor;
+    client_executor.Execute(
+        [this, &socket_a, discovered_device, &service_uuid, &server_socket]() {
+          socket_a = bt_a_->ConnectToService(*discovered_device, service_uuid);
+          if (!socket_a.IsValid()) server_socket.Close();
+        });
+    server_executor.Execute(
+        [&socket_b, &server_socket]() {
+          socket_b = server_socket.Accept();
+          if (!socket_b.IsValid()) server_socket.Close();
+        });
+  }
+  EXPECT_TRUE(socket_a.IsValid());
+  EXPECT_TRUE(socket_b.IsValid());
+  server_socket.Close();
+}
+
+}  // namespace
+}  // namespace nearby
+}  // namespace location

cpp/platform_v2/public/webrtc.h

@@ -5,7 +5,7 @@
 
 #include "platform_v2/api/platform.h"
 #include "platform_v2/api/webrtc.h"
-#include "webrtc/api/peer_connection_interface.h"
+#include "webrtc/files/stable/webrtc/api/peer_connection_interface.h"
 
 namespace location {
 namespace nearby {