create*Track -> publish*Track()

Author: stephen-derosa

bridge/README.md

@@ -24,9 +24,9 @@ options.dynacast = false;
 bridge.connect("wss://my-server.livekit.cloud", token, options);
 
 // 2. Create outgoing tracks (RAII-managed)
-auto mic = bridge.createAudioTrack("mic", 48000, 2,
+auto mic = bridge.publishAudioTrack("mic", 48000, 2,
     livekit::TrackSource::SOURCE_MICROPHONE);  // name, sample_rate, channels, source
-auto cam = bridge.createVideoTrack("cam", 1280, 720,
+auto cam = bridge.publishVideoTrack("cam", 1280, 720,
     livekit::TrackSource::SOURCE_CAMERA);  // name, width, height, source
 
 // 3. Push frames to remote participants
@@ -96,7 +96,7 @@ Your Application
 
 **`LiveKitBridge`** -- The main entry point. Owns the full room lifecycle: SDK initialization, room connection, track publishing, and frame callback management.
 
-**`BridgeAudioTrack` / `BridgeVideoTrack`** -- RAII handles for published local tracks. Created via `createAudioTrack()` / `createVideoTrack()`. When the `shared_ptr` is dropped, the track is automatically unpublished and all underlying SDK resources are freed. Call `pushFrame()` to send audio/video data to remote participants.
+**`BridgeAudioTrack` / `BridgeVideoTrack`** -- RAII handles for published local tracks. Created via `publishAudioTrack()` / `publishVideoTrack()`. When the `shared_ptr` is dropped, the track is automatically unpublished and all underlying SDK resources are freed. Call `pushFrame()` to send audio/video data to remote participants.
 
 **`BridgeRoomDelegate`** -- Internal (not part of the public API; lives in `src/`). Listens for `onTrackSubscribed` / `onTrackUnsubscribed` events from the LiveKit SDK and wires up reader threads automatically.
 
@@ -146,8 +146,8 @@ bridge.connect(url, token, options);
 | `connect(url, token, options)` | Connect to a LiveKit room. Initializes the SDK, creates a Room, and connects with auto-subscribe enabled. |
 | `disconnect()` | Disconnect and release all resources. Joins all reader threads. Safe to call multiple times. |
 | `isConnected()` | Returns whether the bridge is currently connected. |
-| `createAudioTrack(name, sample_rate, num_channels, source)` | Create and publish a local audio track with the given `TrackSource` (e.g. `SOURCE_MICROPHONE`, `SOURCE_SCREENSHARE_AUDIO`). Returns an RAII `shared_ptr<BridgeAudioTrack>`. |
-| `createVideoTrack(name, width, height, source)` | Create and publish a local video track with the given `TrackSource` (e.g. `SOURCE_CAMERA`, `SOURCE_SCREENSHARE`). Returns an RAII `shared_ptr<BridgeVideoTrack>`. |
+| `publishAudioTrack(name, sample_rate, num_channels, source)` | Create and publish a local audio track with the given `TrackSource` (e.g. `SOURCE_MICROPHONE`, `SOURCE_SCREENSHARE_AUDIO`). Returns an RAII `shared_ptr<BridgeAudioTrack>`. |
+| `publishVideoTrack(name, width, height, source)` | Create and publish a local video track with the given `TrackSource` (e.g. `SOURCE_CAMERA`, `SOURCE_SCREENSHARE`). Returns an RAII `shared_ptr<BridgeVideoTrack>`. |
 | `setOnAudioFrameCallback(identity, source, callback)` | Register a callback for audio frames from a specific remote participant + track source. |
 | `setOnVideoFrameCallback(identity, source, callback)` | Register a callback for video frames from a specific remote participant + track source. |
 | `clearOnAudioFrameCallback(identity, source)` | Clear the audio callback for a specific remote participant + track source. Stops and joins the reader thread if active. |

bridge/include/livekit_bridge/bridge_audio_track.h

@@ -41,7 +41,7 @@ class BridgeAudioTrackTest;
 /**
  * Handle to a published local audio track.
  *
- * Created via LiveKitBridge::createAudioTrack(). The bridge retains a
+ * Created via LiveKitBridge::publishAudioTrack(). The bridge retains a
  * reference to every track it creates and will automatically release all
  * tracks when disconnect() is called. To unpublish a track mid-session,
  * call release() explicitly; dropping the shared_ptr alone is not
@@ -60,7 +60,7 @@ class BridgeAudioTrackTest;
  * pushFrame() concurrently from multiple threads.
  *
  * Usage:
- *   auto mic = bridge.createAudioTrack("mic", 48000, 2,
+ *   auto mic = bridge.publishAudioTrack("mic", 48000, 2,
  *       livekit::TrackSource::SOURCE_MICROPHONE);
  *   mic->pushFrame(pcm_data, samples_per_channel);
  *   mic->mute();

bridge/include/livekit_bridge/bridge_video_track.h

@@ -41,7 +41,7 @@ class BridgeVideoTrackTest;
 /**
  * Handle to a published local video track.
  *
- * Created via LiveKitBridge::createVideoTrack(). The bridge retains a
+ * Created via LiveKitBridge::publishVideoTrack(). The bridge retains a
  * reference to every track it creates and will automatically release all
  * tracks when disconnect() is called. To unpublish a track mid-session,
  * call release() explicitly; dropping the shared_ptr alone is not
@@ -60,7 +60,7 @@ class BridgeVideoTrackTest;
  * pushFrame() concurrently from multiple threads.
  *
  * Usage:
- *   auto cam = bridge.createVideoTrack("cam", 1280, 720,
+ *   auto cam = bridge.publishVideoTrack("cam", 1280, 720,
  *       livekit::TrackSource::SOURCE_CAMERA);
  *   cam->pushFrame(rgba_data, timestamp_us);
  *   cam->mute();

bridge/include/livekit_bridge/livekit_bridge.h

@@ -100,9 +100,9 @@ using DataFrameCallback =
  *   options.auto_subscribe = true;
  *   bridge.connect("wss://my-server.livekit.cloud", my_token, options);
  *
- *   auto mic = bridge.createAudioTrack("mic", 48000, 2,
+ *   auto mic = bridge.publishAudioTrack("mic", 48000, 2,
  *       livekit::TrackSource::SOURCE_MICROPHONE);
- *   auto cam = bridge.createVideoTrack("cam", 1280, 720,
+ *   auto cam = bridge.publishVideoTrack("cam", 1280, 720,
  *       livekit::TrackSource::SOURCE_CAMERA);
  *
  *   mic->pushFrame(pcm_data, samples_per_channel);
@@ -197,8 +197,8 @@ class LiveKitBridge {
    * @throws std::runtime_error if the bridge is not connected.
    */
   std::shared_ptr<BridgeAudioTrack>
-  createAudioTrack(const std::string &name, int sample_rate, int num_channels,
-                   livekit::TrackSource source);
+  publishAudioTrack(const std::string &name, int sample_rate, int num_channels,
+                    livekit::TrackSource source);
 
   /**
    * Create and publish a local video track.
@@ -224,8 +224,8 @@ class LiveKitBridge {
    * @throws std::runtime_error if the bridge is not connected.
    */
   std::shared_ptr<BridgeVideoTrack>
-  createVideoTrack(const std::string &name, int width, int height,
-                   livekit::TrackSource source);
+  publishVideoTrack(const std::string &name, int width, int height,
+                    livekit::TrackSource source);
 
   /**
    * Create and publish a local data track.
@@ -240,7 +240,7 @@ class LiveKitBridge {
    * @throws std::runtime_error if the bridge is not connected.
    */
   std::shared_ptr<livekit::LocalDataTrack>
-  createDataTrack(const std::string &name);
+  publishDataTrack(const std::string &name);
 
   // ---------------------------------------------------------------
   // Incoming frame callbacks

bridge/src/livekit_bridge.cpp

@@ -253,13 +253,14 @@ bool LiveKitBridge::isConnected() const {
 // ---------------------------------------------------------------
 
 std::shared_ptr<BridgeAudioTrack>
-LiveKitBridge::createAudioTrack(const std::string &name, int sample_rate,
-                                int num_channels, livekit::TrackSource source) {
+LiveKitBridge::publishAudioTrack(const std::string &name, int sample_rate,
+                                 int num_channels,
+                                 livekit::TrackSource source) {
   std::lock_guard<std::mutex> lock(mutex_);
 
   if (!connected_ || !room_) {
-    throw std::runtime_error(
-        "createAudioTrack requires an active connection; call connect() first");
+    throw std::runtime_error("publishAudioTrack requires an active connection; "
+                             "call connect() first");
   }
 
   // 1. Create audio source (real-time mode, queue_size_ms=0)
@@ -288,13 +289,13 @@ LiveKitBridge::createAudioTrack(const std::string &name, int sample_rate,
 }
 
 std::shared_ptr<BridgeVideoTrack>
-LiveKitBridge::createVideoTrack(const std::string &name, int width, int height,
-                                livekit::TrackSource source) {
+LiveKitBridge::publishVideoTrack(const std::string &name, int width, int height,
+                                 livekit::TrackSource source) {
   std::lock_guard<std::mutex> lock(mutex_);
 
   if (!connected_ || !room_) {
-    throw std::runtime_error(
-        "createVideoTrack requires an active connection; call connect() first");
+    throw std::runtime_error("publishVideoTrack requires an active connection; "
+                             "call connect() first");
   }
 
   // 1. Create video source
@@ -322,12 +323,12 @@ LiveKitBridge::createVideoTrack(const std::string &name, int width, int height,
 }
 
 std::shared_ptr<livekit::LocalDataTrack>
-LiveKitBridge::createDataTrack(const std::string &name) {
+LiveKitBridge::publishDataTrack(const std::string &name) {
   std::lock_guard<std::mutex> lock(mutex_);
 
   if (!connected_ || !room_) {
     throw std::runtime_error(
-        "LiveKitBridge::createDataTrack: not connected to a room");
+        "LiveKitBridge::publishDataTrack: not connected to a room");
   }
 
   LK_LOG_INFO("[LiveKitBridge] Publishing data track \"{}\"...", name);

bridge/tests/integration/test_bridge_audio_roundtrip.cpp

@@ -81,7 +81,7 @@ TEST_F(BridgeAudioRoundtripTest, AudioFrameRoundTrip) {
 
   std::cout << "Both bridges connected." << std::endl;
 
-  auto audio_track = caller.createAudioTrack(
+  auto audio_track = caller.publishAudioTrack(
       "roundtrip-mic", kAudioSampleRate, kAudioChannels,
       livekit::TrackSource::SOURCE_MICROPHONE);
   ASSERT_NE(audio_track, nullptr);
@@ -149,8 +149,8 @@ TEST_F(BridgeAudioRoundtripTest, AudioFrameRoundTrip) {
 
   // Clear callback before bridges go out of scope so the reader thread
   // is joined while the atomic counters above are still alive.
-  receiver.clearOnAudioFrameCallback(
-      caller_identity, livekit::TrackSource::SOURCE_MICROPHONE);
+  receiver.clearOnAudioFrameCallback(caller_identity,
+                                     livekit::TrackSource::SOURCE_MICROPHONE);
 }
 
 // ---------------------------------------------------------------------------
@@ -170,9 +170,9 @@ TEST_F(BridgeAudioRoundtripTest, AudioLatencyMeasurement) {
 
   ASSERT_TRUE(connectPair(caller, receiver));
 
-  auto audio_track = caller.createAudioTrack(
-      "latency-mic", kAudioSampleRate, kAudioChannels,
-      livekit::TrackSource::SOURCE_MICROPHONE);
+  auto audio_track =
+      caller.publishAudioTrack("latency-mic", kAudioSampleRate, kAudioChannels,
+                               livekit::TrackSource::SOURCE_MICROPHONE);
   ASSERT_NE(audio_track, nullptr);
 
   LatencyStats stats;
@@ -221,10 +221,9 @@ TEST_F(BridgeAudioRoundtripTest, AudioLatencyMeasurement) {
     next_frame_time += frame_duration;
 
     if (waiting_for_echo.load() && pulse_send_time > 0) {
-      uint64_t now_us =
-          std::chrono::duration_cast<std::chrono::microseconds>(
-              std::chrono::steady_clock::now().time_since_epoch())
-              .count();
+      uint64_t now_us = std::chrono::duration_cast<std::chrono::microseconds>(
+                            std::chrono::steady_clock::now().time_since_epoch())
+                            .count();
       if (now_us - pulse_send_time > kEchoTimeoutUs) {
         std::cout << "  Echo timeout for pulse " << pulses_sent << std::endl;
         waiting_for_echo.store(false);
@@ -239,16 +238,14 @@ TEST_F(BridgeAudioRoundtripTest, AudioLatencyMeasurement) {
     if (high_energy_remaining > 0) {
       frame_data = generateHighEnergyFrame(kSamplesPerFrame);
       high_energy_remaining--;
-    } else if (frame_count > 0 &&
-               frame_count % frames_between_pulses == 0 &&
+    } else if (frame_count > 0 && frame_count % frames_between_pulses == 0 &&
                !waiting_for_echo.load()) {
       frame_data = generateHighEnergyFrame(kSamplesPerFrame);
       high_energy_remaining = kHighEnergyFramesPerPulse - 1;
 
-      pulse_send_time =
-          std::chrono::duration_cast<std::chrono::microseconds>(
-              std::chrono::steady_clock::now().time_since_epoch())
-              .count();
+      pulse_send_time = std::chrono::duration_cast<std::chrono::microseconds>(
+                            std::chrono::steady_clock::now().time_since_epoch())
+                            .count();
       last_send_time_us.store(pulse_send_time);
       waiting_for_echo.store(true);
       pulses_sent++;
@@ -273,8 +270,8 @@ TEST_F(BridgeAudioRoundtripTest, AudioLatencyMeasurement) {
   EXPECT_GT(stats.count(), 0u)
       << "At least one audio latency measurement should be recorded";
 
-  receiver.clearOnAudioFrameCallback(
-      caller_identity, livekit::TrackSource::SOURCE_MICROPHONE);
+  receiver.clearOnAudioFrameCallback(caller_identity,
+                                     livekit::TrackSource::SOURCE_MICROPHONE);
 }
 
 // ---------------------------------------------------------------------------
@@ -301,7 +298,7 @@ TEST_F(BridgeAudioRoundtripTest, ConnectPublishDisconnectCycle) {
           bridge.connect(config_.url, config_.caller_token, options);
       ASSERT_TRUE(connected) << "Cycle " << i << ": connect failed";
 
-      auto track = bridge.createAudioTrack(
+      auto track = bridge.publishAudioTrack(
           "cycle-mic", kAudioSampleRate, kAudioChannels,
           livekit::TrackSource::SOURCE_MICROPHONE);
       ASSERT_NE(track, nullptr);

bridge/tests/integration/test_bridge_data_roundtrip.cpp

@@ -52,7 +52,7 @@ TEST_F(BridgeDataRoundtripTest, DataFrameRoundTrip) {
   const std::string track_name = "roundtrip-data";
   const std::string caller_identity = "rpc-caller";
 
-  auto data_track = caller.createDataTrack(track_name);
+  auto data_track = caller.publishDataTrack(track_name);
   ASSERT_NE(data_track, nullptr);
   ASSERT_TRUE(data_track->isPublished());
 
@@ -141,7 +141,7 @@ TEST_F(BridgeDataRoundtripTest, LateCallbackRegistration) {
   const std::string track_name = "late-callback-data";
   const std::string caller_identity = "rpc-caller";
 
-  auto data_track = caller.createDataTrack(track_name);
+  auto data_track = caller.publishDataTrack(track_name);
   ASSERT_NE(data_track, nullptr);
 
   std::cout << "Data track published, waiting before registering callback..."
@@ -155,8 +155,7 @@ TEST_F(BridgeDataRoundtripTest, LateCallbackRegistration) {
 
   receiver.setOnDataFrameCallback(
       caller_identity, track_name,
-      [&](const std::vector<std::uint8_t> &,
-          std::optional<std::uint64_t>) {
+      [&](const std::vector<std::uint8_t> &, std::optional<std::uint64_t>) {
         frames_received++;
         rx_cv.notify_all();
       });
@@ -174,9 +173,8 @@ TEST_F(BridgeDataRoundtripTest, LateCallbackRegistration) {
 
   {
     std::unique_lock<std::mutex> lock(rx_mutex);
-    rx_cv.wait_for(lock, 10s, [&] {
-      return frames_received.load() >= num_frames;
-    });
+    rx_cv.wait_for(lock, 10s,
+                   [&] { return frames_received.load() >= num_frames; });
   }
 
   std::cout << "Frames received: " << frames_received.load() << std::endl;
@@ -206,21 +204,20 @@ TEST_F(BridgeDataRoundtripTest, VaryingPayloadSizes) {
   const std::string track_name = "size-test-data";
   const std::string caller_identity = "rpc-caller";
 
-  auto data_track = caller.createDataTrack(track_name);
+  auto data_track = caller.publishDataTrack(track_name);
   ASSERT_NE(data_track, nullptr);
 
   std::mutex rx_mutex;
   std::condition_variable rx_cv;
   std::vector<size_t> received_sizes;
 
-  receiver.setOnDataFrameCallback(
-      caller_identity, track_name,
-      [&](const std::vector<std::uint8_t> &payload,
-          std::optional<std::uint64_t>) {
-        std::lock_guard<std::mutex> lock(rx_mutex);
-        received_sizes.push_back(payload.size());
-        rx_cv.notify_all();
-      });
+  receiver.setOnDataFrameCallback(caller_identity, track_name,
+                                  [&](const std::vector<std::uint8_t> &payload,
+                                      std::optional<std::uint64_t>) {
+                                    std::lock_guard<std::mutex> lock(rx_mutex);
+                                    received_sizes.push_back(payload.size());
+                                    rx_cv.notify_all();
+                                  });
 
   std::this_thread::sleep_for(3s);
 
@@ -238,18 +235,17 @@ TEST_F(BridgeDataRoundtripTest, VaryingPayloadSizes) {
 
   {
     std::unique_lock<std::mutex> lock(rx_mutex);
-    rx_cv.wait_for(lock, 15s, [&] {
-      return received_sizes.size() >= test_sizes.size();
-    });
+    rx_cv.wait_for(lock, 15s,
+                   [&] { return received_sizes.size() >= test_sizes.size(); });
   }
 
-  std::cout << "Received " << received_sizes.size() << "/"
-            << test_sizes.size() << " frames." << std::endl;
+  std::cout << "Received " << received_sizes.size() << "/" << test_sizes.size()
+            << " frames." << std::endl;
 
   EXPECT_EQ(received_sizes.size(), test_sizes.size());
 
-  for (size_t i = 0;
-       i < std::min(received_sizes.size(), test_sizes.size()); ++i) {
+  for (size_t i = 0; i < std::min(received_sizes.size(), test_sizes.size());
+       ++i) {
     EXPECT_EQ(received_sizes[i], test_sizes[i])
         << "Size mismatch at index " << i;
   }
@@ -277,7 +273,7 @@ TEST_F(BridgeDataRoundtripTest, ConnectPublishDisconnectCycle) {
           bridge.connect(config_.url, config_.caller_token, options);
       ASSERT_TRUE(connected) << "Cycle " << i << ": connect failed";
 
-      auto track = bridge.createDataTrack("cycle-data");
+      auto track = bridge.publishDataTrack("cycle-data");
       ASSERT_NE(track, nullptr);
 
       for (int f = 0; f < 5; ++f) {

bridge/tests/integration/test_bridge_rpc_roundtrip.cpp

@@ -175,7 +175,7 @@ TEST_F(BridgeRemoteTrackControlTest, RemoteMuteAudioTrack) {
 
   const std::string publisher_identity = "rpc-receiver";
 
-  auto audio_track = publisher.createAudioTrack(
+  auto audio_track = publisher.publishAudioTrack(
       "mic", 48000, 1, livekit::TrackSource::SOURCE_MICROPHONE);
   ASSERT_NE(audio_track, nullptr);
 
@@ -214,7 +214,7 @@ TEST_F(BridgeRemoteTrackControlTest, RemoteMuteVideoTrack) {
 
   const std::string publisher_identity = "rpc-receiver";
 
-  auto video_track = publisher.createVideoTrack(
+  auto video_track = publisher.publishVideoTrack(
       "cam", 320, 240, livekit::TrackSource::SOURCE_CAMERA);
   ASSERT_NE(video_track, nullptr);