Internal change

PiperOrigin-RevId: 359631402

cpp/platform/api/webrtc.h

@@ -30,13 +30,16 @@ namespace api {
 class WebRtcSignalingMessenger {
  public:
   using OnSignalingMessageCallback = std::function<void(const ByteArray&)>;
+  using OnSignalingCompleteCallback = std::function<void(bool)>;
 
   virtual ~WebRtcSignalingMessenger() = default;
 
   virtual bool SendMessage(absl::string_view peer_id,
                            const ByteArray& message) = 0;
 
-  virtual bool StartReceivingMessages(OnSignalingMessageCallback listener) = 0;
+  virtual bool StartReceivingMessages(
+      OnSignalingMessageCallback on_message_callback,
+      OnSignalingCompleteCallback on_complete_callback) = 0;
   virtual void StopReceivingMessages() = 0;
 };
 

cpp/platform/base/medium_environment.cc

@@ -59,6 +59,8 @@ void MediumEnvironment::Reset() {
     bluetooth_adapters_.clear();
     bluetooth_mediums_.clear();
     ble_mediums_.clear();
+    webrtc_signaling_message_callback_.clear();
+    webrtc_signaling_complete_callback_.clear();
     wifi_lan_mediums_.clear();
   });
   Sync();
@@ -439,11 +441,17 @@ void MediumEnvironment::CallBleAcceptedConnectionCallback(
 }
 
 void MediumEnvironment::RegisterWebRtcSignalingMessenger(
-    absl::string_view self_id, OnSignalingMessageCallback callback) {
+    absl::string_view self_id, OnSignalingMessageCallback message_callback,
+    OnSignalingCompleteCallback complete_callback) {
   if (!enabled_) return;
   RunOnMediumEnvironmentThread(
-      [this, self_id{std::string(self_id)}, callback{std::move(callback)}]() {
-        webrtc_signaling_callback_[self_id] = std::move(callback);
+      [this, self_id{std::string(self_id)},
+       message_callback{std::move(message_callback)},
+       complete_callback{std::move(complete_callback)}]() {
+        webrtc_signaling_message_callback_[self_id] =
+            std::move(message_callback);
+        webrtc_signaling_complete_callback_[self_id] =
+            std::move(complete_callback);
         NEARBY_LOG(INFO, "Registered signaling message callback for id = %s",
                    self_id.c_str());
       });
@@ -453,9 +461,11 @@ void MediumEnvironment::UnregisterWebRtcSignalingMessenger(
     absl::string_view self_id) {
   if (!enabled_) return;
   RunOnMediumEnvironmentThread([this, self_id{std::string(self_id)}]() {
-    auto item = webrtc_signaling_callback_.extract(self_id);
-    if (item.empty()) return;
-    NEARBY_LOG(INFO, "Unregistered signaling message callback for id = %s",
+    auto message_callback_item =
+        webrtc_signaling_message_callback_.extract(self_id);
+    auto complete_callback_item =
+        webrtc_signaling_complete_callback_.extract(self_id);
+    NEARBY_LOG(INFO, "Unregistered signaling callbacks for id = %s",
                self_id.c_str());
   });
 }
@@ -465,8 +475,8 @@ void MediumEnvironment::SendWebRtcSignalingMessage(absl::string_view peer_id,
   if (!enabled_) return;
   RunOnMediumEnvironmentThread(
       [this, peer_id{std::string(peer_id)}, message]() {
-        auto item = webrtc_signaling_callback_.find(peer_id);
-        if (item == webrtc_signaling_callback_.end()) {
+        auto item = webrtc_signaling_message_callback_.find(peer_id);
+        if (item == webrtc_signaling_message_callback_.end()) {
           NEARBY_LOG(WARNING, "No callback registered for peer id = %s",
                      peer_id.c_str());
           return;
@@ -476,6 +486,22 @@ void MediumEnvironment::SendWebRtcSignalingMessage(absl::string_view peer_id,
       });
 }
 
+void MediumEnvironment::SendWebRtcSignalingComplete(absl::string_view peer_id,
+                                                    bool success) {
+  if (!enabled_) return;
+  RunOnMediumEnvironmentThread(
+      [this, peer_id{std::string(peer_id)}, success]() {
+        auto item = webrtc_signaling_complete_callback_.find(peer_id);
+        if (item == webrtc_signaling_complete_callback_.end()) {
+          NEARBY_LOG(WARNING, "No callback registered for peer id = %s",
+                     peer_id.c_str());
+          return;
+        }
+
+        item->second(success);
+      });
+}
+
 void MediumEnvironment::SetUseValidPeerConnection(
     bool use_valid_peer_connection) {
   use_valid_peer_connection_ = use_valid_peer_connection;

cpp/platform/base/medium_environment.h

@@ -55,6 +55,8 @@ class MediumEnvironment {
       api::BleMedium::AcceptedConnectionCallback;
   using OnSignalingMessageCallback =
       api::WebRtcSignalingMessenger::OnSignalingMessageCallback;
+  using OnSignalingCompleteCallback =
+      api::WebRtcSignalingMessenger::OnSignalingCompleteCallback;
   using WifiLanDiscoveredServiceCallback =
       api::WifiLanMedium::DiscoveredServiceCallback;
   using WifiLanAcceptedConnectionCallback =
@@ -128,9 +130,11 @@ class MediumEnvironment {
 
   const EnvironmentConfig& GetEnvironmentConfig();
 
-  // Registers |callback| to receive messages sent to device with id |self_id|.
-  void RegisterWebRtcSignalingMessenger(absl::string_view self_id,
-                                        OnSignalingMessageCallback callback);
+  // Registers |message_callback| to receive messages sent to device with id
+  // |self_id|, and |complete_callback| to notify when signaling is complete.
+  void RegisterWebRtcSignalingMessenger(
+      absl::string_view self_id, OnSignalingMessageCallback message_callback,
+      OnSignalingCompleteCallback complete_callback);
 
   // Unregisters the callback listening to incoming messages for |self_id|.
   void UnregisterWebRtcSignalingMessenger(absl::string_view self_id);
@@ -140,6 +144,9 @@ class MediumEnvironment {
   void SendWebRtcSignalingMessage(absl::string_view peer_id,
                                   const ByteArray& message);
 
+  // Simulates sending an "signaling complete" signal to the WebRTC medium.
+  void SendWebRtcSignalingComplete(absl::string_view peer_id, bool success);
+
   // Used to set if WebRtcMedium should use a valid peer connection or nullptr
   // in tests.
   void SetUseValidPeerConnection(bool use_valid_peer_connection);
@@ -302,7 +309,11 @@ class MediumEnvironment {
 
   // Maps peer id to callback for receiving signaling messages.
   absl::flat_hash_map<std::string, OnSignalingMessageCallback>
-      webrtc_signaling_callback_;
+      webrtc_signaling_message_callback_;
+
+  // Maps peer id to callback for signaling complete events.
+  absl::flat_hash_map<std::string, OnSignalingCompleteCallback>
+      webrtc_signaling_complete_callback_;
 
   absl::flat_hash_map<api::WifiLanMedium*, WifiLanMediumContext>
       wifi_lan_mediums_;

cpp/platform/impl/g3/webrtc.cc

@@ -35,9 +35,11 @@ bool WebRtcSignalingMessenger::SendMessage(absl::string_view peer_id,
 }
 
 bool WebRtcSignalingMessenger::StartReceivingMessages(
-    OnSignalingMessageCallback listener) {
+    OnSignalingMessageCallback on_message_callback,
+    OnSignalingCompleteCallback on_complete_callback) {
   auto& env = MediumEnvironment::Instance();
-  env.RegisterWebRtcSignalingMessenger(self_id_, listener);
+  env.RegisterWebRtcSignalingMessenger(self_id_, on_message_callback,
+                                       on_complete_callback);
   return true;
 }
 

cpp/platform/impl/g3/webrtc.h

@@ -29,6 +29,8 @@ class WebRtcSignalingMessenger : public api::WebRtcSignalingMessenger {
  public:
   using OnSignalingMessageCallback =
       api::WebRtcSignalingMessenger::OnSignalingMessageCallback;
+  using OnSignalingCompleteCallback =
+      api::WebRtcSignalingMessenger::OnSignalingCompleteCallback;
 
   explicit WebRtcSignalingMessenger(
       absl::string_view self_id,
@@ -37,7 +39,9 @@ class WebRtcSignalingMessenger : public api::WebRtcSignalingMessenger {
 
   bool SendMessage(absl::string_view peer_id,
                    const ByteArray& message) override;
-  bool StartReceivingMessages(OnSignalingMessageCallback listener) override;
+  bool StartReceivingMessages(
+      OnSignalingMessageCallback on_message_callback,
+      OnSignalingCompleteCallback on_complete_callback) override;
   void StopReceivingMessages() override;
 
  private:

cpp/platform/public/webrtc.h

@@ -28,6 +28,8 @@ class WebRtcSignalingMessenger final {
  public:
   using OnSignalingMessageCallback =
       api::WebRtcSignalingMessenger::OnSignalingMessageCallback;
+  using OnSignalingCompleteCallback =
+      api::WebRtcSignalingMessenger::OnSignalingCompleteCallback;
 
   explicit WebRtcSignalingMessenger(
       std::unique_ptr<api::WebRtcSignalingMessenger> messenger)
@@ -40,8 +42,11 @@ class WebRtcSignalingMessenger final {
     return impl_->SendMessage(peer_id, message);
   }
 
-  bool StartReceivingMessages(OnSignalingMessageCallback listener) {
-    return impl_->StartReceivingMessages(listener);
+  bool StartReceivingMessages(
+      OnSignalingMessageCallback on_message_callback,
+      OnSignalingCompleteCallback on_complete_callback) {
+    return impl_->StartReceivingMessages(on_message_callback,
+                                         on_complete_callback);
   }
 
   void StopReceivingMessages() { impl_->StopReceivingMessages(); }