std::cout/cerr to LK_LOG

fix rebase issue

Author: stephen-derosa

bridge/src/bridge_data_track.cpp

@@ -20,8 +20,6 @@
 #include "livekit/local_data_track.h"
 #include "livekit/local_participant.h"
 
-#include <iostream>
-
 namespace livekit_bridge {
 
 BridgeDataTrack::BridgeDataTrack(std::string name,
@@ -46,7 +44,7 @@ bool BridgeDataTrack::pushFrame(const std::vector<std::uint8_t> &payload,
   try {
     return track_->tryPush(frame);
   } catch (const std::exception &e) {
-    std::cerr << "[BridgeDataTrack] tryPush error: " << e.what() << "\n";
+    LK_LOG_ERROR("[BridgeDataTrack] tryPush error: " << e.what());
     return false;
   }
 }
@@ -65,7 +63,7 @@ bool BridgeDataTrack::pushFrame(const std::uint8_t *data, std::size_t size,
   try {
     return track_->tryPush(frame);
   } catch (const std::exception &e) {
-    std::cerr << "[BridgeDataTrack] tryPush error: " << e.what() << "\n";
+    LK_LOG_ERROR("[BridgeDataTrack] tryPush error: " << e.what());
     return false;
   }
 }
@@ -94,8 +92,8 @@ void BridgeDataTrack::release() {
     try {
       participant_->unpublishDataTrack(track_);
     } catch (...) {
-      std::cerr << "[BridgeDataTrack] unpublishDataTrack error, continuing "
-                   "with cleanup\n";
+      LK_LOG_ERROR("[BridgeDataTrack] unpublishDataTrack error, continuing "
+                   "with cleanup");
     }
   }
 

bridge/src/bridge_room_delegate.cpp

@@ -57,14 +57,14 @@ void BridgeRoomDelegate::onRemoteDataTrackPublished(
     livekit::Room & /*room*/,
     const livekit::RemoteDataTrackPublishedEvent &ev) {
   if (!ev.track) {
-    std::cerr << "[BridgeRoomDelegate] onRemoteDataTrackPublished called "
-                 "with null track.\n";
+    LK_LOG_ERROR("[BridgeRoomDelegate] onRemoteDataTrackPublished called "
+                 "with null track.");
     return;
   }
 
-  std::cout << "[BridgeRoomDelegate] onRemoteDataTrackPublished: \""
-            << ev.track->info().name << "\" from \""
-            << ev.track->publisherIdentity() << "\"\n";
+  LK_LOG_INFO("[BridgeRoomDelegate] onRemoteDataTrackPublished: \""
+              << ev.track->info().name << "\" from \""
+              << ev.track->publisherIdentity() << "\"");
   bridge_.onRemoteDataTrackPublished(ev.track);
 }
 

bridge/src/livekit_bridge.cpp

@@ -307,10 +307,11 @@ LiveKitBridge::createDataTrack(const std::string &name) {
         "LiveKitBridge::createDataTrack: not connected to a room");
   }
 
-  std::cout << "[LiveKitBridge] Publishing data track \"" << name << "\"...\n";
+  LK_LOG_INFO("[LiveKitBridge] Publishing data track \"" << name << "\"...");
   auto track = room_->localParticipant()->publishDataTrack(name);
-  std::cout << "[LiveKitBridge] Data track \"" << name << "\" published "
-            << "(sid=" << track->info().sid << ").\n";
+  LK_LOG_INFO("[LiveKitBridge] Data track \"" << name << "\" published "
+                                              << "(sid=" << track->info().sid
+                                              << ").");
 
   auto bridge_track = std::shared_ptr<BridgeDataTrack>(
       new BridgeDataTrack(name, std::move(track), room_->localParticipant()));
@@ -357,8 +358,8 @@ void LiveKitBridge::setOnDataFrameCallback(
   std::thread old_thread;
   {
     std::lock_guard<std::mutex> lock(mutex_);
-    std::cout << "[LiveKitBridge] Registered data callback for (\""
-              << participant_identity << "\", \"" << track_name << "\").\n";
+    LK_LOG_INFO("[LiveKitBridge] Registered data callback for (\""
+                << participant_identity << "\", \"" << track_name << "\").");
     DataCallbackKey key{participant_identity, track_name};
     data_callbacks_[key] = std::move(callback);
 
@@ -445,9 +446,9 @@ void LiveKitBridge::onTrackSubscribed(
         old_thread = startVideoReader(key, track, it->second);
       }
     } else {
-      std::cout << "[LiveKitBridge] Track subscribed: \"" << track->name()
-                << "\" from \"" << participant_identity
-                << "\" (sid=" << track->sid() << ")\n";
+      LK_LOG_INFO("[LiveKitBridge] Track subscribed: \""
+                  << track->name() << "\" from \"" << participant_identity
+                  << "\" (sid=" << track->sid() << ")");
     }
   }
   // If this key already had a reader (e.g. track was re-subscribed), the old
@@ -474,9 +475,10 @@ void LiveKitBridge::onTrackUnsubscribed(const std::string &participant_identity,
 
 void LiveKitBridge::onRemoteDataTrackPublished(
     std::shared_ptr<livekit::RemoteDataTrack> track) {
-  std::cout << "[LiveKitBridge] Remote data track published: \""
-            << track->info().name << "\" from \"" << track->publisherIdentity()
-            << "\" (sid=" << track->info().sid << ")\n";
+  LK_LOG_INFO("[LiveKitBridge] Remote data track published: \""
+              << track->info().name << "\" from \""
+              << track->publisherIdentity() << "\" (sid=" << track->info().sid
+              << ")");
 
   std::thread old_thread;
   std::string identity;
@@ -491,14 +493,15 @@ void LiveKitBridge::onRemoteDataTrackPublished(
 
     auto it = data_callbacks_.find(key);
     if (it != data_callbacks_.end()) {
-      std::cout << "[LiveKitBridge] Found matching callback for ("
-                << key.identity << ", " << key.track_name
-                << "), starting data reader.\n";
+      LK_LOG_INFO("[LiveKitBridge] Found matching callback for ("
+                  << key.identity << ", " << key.track_name
+                  << "), starting data reader.");
       old_thread = startDataReader(key, track, it->second);
     } else {
-      std::cout << "[LiveKitBridge] No callback registered yet for ("
-                << key.identity << ", " << key.track_name
-                << "); storing as pending (will start when callback is set).\n";
+      LK_LOG_INFO(
+          "[LiveKitBridge] No callback registered yet for ("
+          << key.identity << ", " << key.track_name
+          << "); storing as pending (will start when callback is set).");
       pending_remote_data_tracks_[key] = track;
     }
   }
@@ -569,9 +572,8 @@ LiveKitBridge::startAudioReader(const CallbackKey &key,
 
   active_av_readers_[key] = std::move(reader);
   if (active_av_readers_.size() > kMaxActiveReaders) {
-    std::cerr << "[LiveKitBridge] More than expected active readers. Need to "
-                 "evaluate how much to expect/support.";
-    "solution";
+    LK_LOG_ERROR("[LiveKitBridge] More than expected active readers. Need to "
+                 "evaluate how much to expect/support.");
   }
   return old_thread;
 }
@@ -611,8 +613,8 @@ LiveKitBridge::startVideoReader(const CallbackKey &key,
 
   active_av_readers_[key] = std::move(reader);
   if (active_av_readers_.size() > kMaxActiveReaders) {
-    std::cerr << "[LiveKitBridge] More than expected active readers. Need to "
-                 "evaluate how much to expect/support.";
+    LK_LOG_ERROR("[LiveKitBridge] More than expected active readers. Need to "
+                 "evaluate how much to expect/support.");
   }
   return old_thread;
 }
@@ -623,21 +625,21 @@ std::thread LiveKitBridge::startDataReader(
     DataFrameCallback cb) {
   auto old_thread = extractDataReaderThread(key);
 
-  std::cout << "[LiveKitBridge] Subscribing to data track \"" << key.track_name
-            << "\" from \"" << key.identity << "\"...\n";
+  LK_LOG_INFO("[LiveKitBridge] Subscribing to data track \""
+              << key.track_name << "\" from \"" << key.identity << "\"...");
 
   std::shared_ptr<livekit::DataTrackSubscription> subscription;
   try {
     subscription = track->subscribe();
   } catch (const std::exception &e) {
-    std::cerr << "[LiveKitBridge] Failed to subscribe to data track \""
-              << key.track_name << "\" from \"" << key.identity
-              << "\": " << e.what() << "\n";
+    LK_LOG_ERROR("[LiveKitBridge] Failed to subscribe to data track \""
+                 << key.track_name << "\" from \"" << key.identity
+                 << "\": " << e.what());
     return old_thread;
   }
 
-  std::cout << "[LiveKitBridge] Subscribed to data track \"" << key.track_name
-            << "\"; starting reader thread.\n";
+  LK_LOG_INFO("[LiveKitBridge] Subscribed to data track \""
+              << key.track_name << "\"; starting reader thread.");
 
   auto sub_copy = subscription;
   auto track_name = key.track_name;
@@ -647,19 +649,19 @@ std::thread LiveKitBridge::startDataReader(
   reader.remote_track = track;
   reader.subscription = std::move(subscription);
   reader.thread = std::thread([sub_copy, cb, track_name, identity]() {
-    std::cout << "[LiveKitBridge] Data reader thread running for \""
-              << track_name << "\" from \"" << identity << "\".\n";
+    LK_LOG_INFO("[LiveKitBridge] Data reader thread running for \""
+                << track_name << "\" from \"" << identity << "\".");
     livekit::DataFrame frame;
     while (sub_copy->read(frame)) {
       try {
         cb(frame.payload, frame.user_timestamp);
       } catch (const std::exception &e) {
-        std::cerr << "[LiveKitBridge] Data callback exception: " << e.what()
-                  << "\n";
+        LK_LOG_ERROR("[LiveKitBridge] Data callback exception: " << e.what()
+                  << ");
       }
     }
-    std::cout << "[LiveKitBridge] Data reader thread exiting for \""
-              << track_name << "\" from \"" << identity << "\".\n";
+    LK_LOG_INFO("[LiveKitBridge] Data reader thread exiting for \""
+                << track_name << "\" from \"" << identity << "\".");
   });
 
   active_data_readers_[key] = std::move(reader);

examples/bridge_human_robot/human.cpp

@@ -56,8 +56,8 @@
 
 #include <atomic>
 #include <chrono>
-#include <cstdint>
 #include <csignal>
+#include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>

include/livekit/room_delegate.h

@@ -297,9 +297,8 @@ class RoomDelegate {
    * Data tracks are independent of the audio/video track hierarchy and
    * require an explicit subscribe() call to start receiving frames.
    */
-  virtual void onRemoteDataTrackPublished(Room &,
-                                          const RemoteDataTrackPublishedEvent &) {
-  }
+  virtual void
+  onRemoteDataTrackPublished(Room &, const RemoteDataTrackPublishedEvent &) {}
 
   // ------------------------------------------------------------------
   // Participants snapshot

src/ffi_client.cpp

@@ -324,6 +324,11 @@ FfiClient::connectAsync(const std::string &url, const std::string &token,
   auto *opts = connect->mutable_options();
   opts->set_auto_subscribe(options.auto_subscribe);
   opts->set_dynacast(options.dynacast);
+  opts->set_single_peer_connection(options.single_peer_connection);
+  LK_LOG_INFO("[FfiClient] connectAsync: auto_subscribe={}, dynacast={}, "
+              "single_peer_connection={}",
+              options.auto_subscribe, options.dynacast,
+              options.single_peer_connection);
 
   // --- E2EE / encryption (optional) ---
   if (options.encryption.has_value()) {

src/room.cpp

@@ -604,17 +604,17 @@ void Room::OnEvent(const FfiEvent &event) {
       const auto &rdtp = re.remote_data_track_published();
       auto remote_track =
           std::shared_ptr<RemoteDataTrack>(new RemoteDataTrack(rdtp.track()));
-      std::cout << "[Room] RoomEvent::kRemoteDataTrackPublished: \""
-                << remote_track->info().name << "\" from \""
-                << remote_track->publisherIdentity()
-                << "\" (sid=" << remote_track->info().sid << ")\n";
+      LK_LOG_INFO("[Room] RoomEvent::kRemoteDataTrackPublished: \""
+                  << remote_track->info().name << "\" from \""
+                  << remote_track->publisherIdentity()
+                  << "\" (sid=" << remote_track->info().sid << ")");
       RemoteDataTrackPublishedEvent ev;
       ev.track = remote_track;
       if (delegate_snapshot) {
         delegate_snapshot->onRemoteDataTrackPublished(*this, ev);
       } else {
-        std::cerr << "[Room] No delegate set; RemoteDataTrackPublished "
-                     "event dropped.\n";
+        LK_LOG_ERROR("[Room] No delegate set; RemoteDataTrackPublished "
+                     "event dropped.");
       }
       break;
     }