fix

Author: stephen-derosa

bridge/CMakeLists.txt

@@ -11,8 +11,8 @@ add_library(livekit_bridge SHARED
   src/bridge_video_track.cpp
   src/bridge_room_delegate.cpp
   src/bridge_room_delegate.h
-  src/rpc_manager.cpp
-  src/rpc_manager.h
+  src/rpc_controller.cpp
+  src/rpc_controller.h
 )
 
 if(WIN32)

bridge/include/livekit_bridge/livekit_bridge.h

@@ -49,7 +49,7 @@ enum class TrackSource;
 namespace livekit_bridge {
 
 class BridgeRoomDelegate;
-class RpcManager;
+class RpcController;
 
 namespace test {
 class CallbackKeyTest;
@@ -403,7 +403,7 @@ class LiveKitBridge {
                                VideoFrameCallback cb);
 
   /// Execute a track action (mute/unmute/release) by track name.
-  /// Used as the TrackActionFn callback for RpcManager.
+  /// Used as the TrackActionFn callback for RpcController.
   /// Throws livekit::RpcError if the track is not found.
   /// @pre Caller does NOT hold mutex_ (acquires it internally).
   void executeTrackAction(const rpc::track_control::Action &action,
@@ -418,7 +418,7 @@ class LiveKitBridge {
 
   std::unique_ptr<livekit::Room> room_;
   std::unique_ptr<BridgeRoomDelegate> delegate_;
-  std::unique_ptr<RpcManager> rpc_manager_;
+  std::unique_ptr<RpcController> rpc_controller_;
 
   /// Registered callbacks (may be registered before tracks are subscribed).
   std::unordered_map<CallbackKey, AudioFrameCallback, CallbackKeyHash>

bridge/src/livekit_bridge.cpp

@@ -20,7 +20,7 @@
 #include "livekit_bridge/livekit_bridge.h"
 #include "bridge_room_delegate.h"
 #include "livekit_bridge/rpc_constants.h"
-#include "rpc_manager.h"
+#include "rpc_controller.h"
 
 #include "livekit/audio_frame.h"
 #include "livekit/audio_source.h"
@@ -64,7 +64,7 @@ LiveKitBridge::CallbackKeyHash::operator()(const CallbackKey &k) const {
 
 LiveKitBridge::LiveKitBridge()
     : connected_(false), connecting_(false), sdk_initialized_(false),
-      rpc_manager_(std::make_unique<RpcManager>(
+      rpc_controller_(std::make_unique<RpcController>(
           [this](const rpc::track_control::Action &action,
                  const std::string &track_name) {
             executeTrackAction(action, track_name);
@@ -133,15 +133,15 @@ bool LiveKitBridge::connect(const std::string &url, const std::string &token,
     assert(lp != nullptr);
   }
 
-  rpc_manager_->enable(lp);
+  rpc_controller_->enable(lp);
   return true;
 }
 
 void LiveKitBridge::disconnect() {
-  // Disable the RPC manager before tearing down the room. This unregisters
+  // Disable the RPC controller before tearing down the room. This unregisters
   // built-in handlers while the LocalParticipant is still alive.
-  if (rpc_manager_->isEnabled()) {
-    rpc_manager_->disable();
+  if (rpc_controller_ && rpc_controller_->isEnabled()) {
+    rpc_controller_->disable();
   }
 
   // Collect threads to join outside the lock to avoid deadlock.
@@ -228,7 +228,10 @@ LiveKitBridge::createAudioTrack(const std::string &name, int sample_rate,
                                 int num_channels, livekit::TrackSource source) {
   std::lock_guard<std::mutex> lock(mutex_);
 
-  assert(connected_ && room_);
+  if (!connected_ || !room_) {
+    throw std::runtime_error(
+        "createAudioTrack requires an active connection; call connect() first");
+  }
 
   // 1. Create audio source (real-time mode, queue_size_ms=0)
   auto audio_source =
@@ -260,7 +263,10 @@ LiveKitBridge::createVideoTrack(const std::string &name, int width, int height,
                                 livekit::TrackSource source) {
   std::lock_guard<std::mutex> lock(mutex_);
 
-  assert(connected_ && room_);
+  if (!connected_ || !room_) {
+    throw std::runtime_error(
+        "createVideoTrack requires an active connection; call connect() first");
+  }
 
   // 1. Create video source
   auto video_source = std::make_shared<livekit::VideoSource>(width, height);
@@ -348,7 +354,7 @@ void LiveKitBridge::clearOnVideoFrameCallback(
 }
 
 // ---------------------------------------------------------------
-// RPC (delegates to RpcManager)
+// RPC (delegates to RpcController)
 // ---------------------------------------------------------------
 
 std::optional<std::string>
@@ -361,8 +367,8 @@ LiveKitBridge::performRpc(const std::string &destination_identity,
   }
 
   try {
-    return rpc_manager_->performRpc(destination_identity, method, payload,
-                                    response_timeout);
+    return rpc_controller_->performRpc(destination_identity, method, payload,
+                                       response_timeout);
   } catch (const std::exception &e) {
     std::cerr << "[LiveKitBridge] Exception: " << e.what() << "\n";
     return std::nullopt;
@@ -383,7 +389,7 @@ bool LiveKitBridge::registerRpcMethod(
     return false;
   }
   try {
-    rpc_manager_->registerRpcMethod(method_name, std::move(handler));
+    rpc_controller_->registerRpcMethod(method_name, std::move(handler));
     return true;
   } catch (const std::exception &e) {
     std::cerr << "[LiveKitBridge] Exception: " << e.what() << "\n";
@@ -402,7 +408,7 @@ bool LiveKitBridge::unregisterRpcMethod(const std::string &method_name) {
     return false;
   }
   try {
-    rpc_manager_->unregisterRpcMethod(method_name);
+    rpc_controller_->unregisterRpcMethod(method_name);
     return true;
   } catch (const std::exception &e) {
     std::cerr << "[LiveKitBridge] Exception: " << e.what() << "\n";
@@ -422,7 +428,7 @@ bool LiveKitBridge::requestRemoteTrackMute(
     return false;
   }
   try {
-    rpc_manager_->requestRemoteTrackMute(destination_identity, track_name);
+    rpc_controller_->requestRemoteTrackMute(destination_identity, track_name);
     return true;
   } catch (const std::exception &e) {
     std::cerr << "[LiveKitBridge] Exception: " << e.what() << "\n";
@@ -442,7 +448,7 @@ bool LiveKitBridge::requestRemoteTrackUnmute(
     return false;
   }
   try {
-    rpc_manager_->requestRemoteTrackUnmute(destination_identity, track_name);
+    rpc_controller_->requestRemoteTrackUnmute(destination_identity, track_name);
     return true;
   } catch (const std::exception &e) {
     std::cerr << "[LiveKitBridge] Exception: " << e.what() << "\n";
@@ -457,7 +463,7 @@ bool LiveKitBridge::requestRemoteTrackUnmute(
 }
 
 // ---------------------------------------------------------------
-// Track action callback for RpcManager
+// Track action callback for RpcController
 // ---------------------------------------------------------------
 
 void LiveKitBridge::executeTrackAction(const rpc::track_control::Action &action,

bridge/src/rpc_manager.cpp bridge/src/rpc_controller.cppbridge/src/rpc_manager.cpp renamed to bridge/src/rpc_controller.cpp

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-/// @file rpc_manager.cpp
-/// @brief Implementation of RpcManager.
+/// @file rpc_controller.cpp
+/// @brief Implementation of RpcController.
 
-#include "rpc_manager.h"
+#include "rpc_controller.h"
 #include "livekit_bridge/rpc_constants.h"
 
 #include "livekit/local_participant.h"
@@ -28,16 +28,16 @@
 
 namespace livekit_bridge {
 
-RpcManager::RpcManager(TrackActionFn track_action_fn)
+RpcController::RpcController(TrackActionFn track_action_fn)
     : track_action_fn_(std::move(track_action_fn)), lp_(nullptr) {}
 
-void RpcManager::enable(livekit::LocalParticipant *lp) {
+void RpcController::enable(livekit::LocalParticipant *lp) {
   assert(lp != nullptr);
   lp_ = lp;
   enableBuiltInHandlers();
 }
 
-void RpcManager::disable() {
+void RpcController::disable() {
   if (lp_) {
     disableBuiltInHandlers();
   }
@@ -49,7 +49,7 @@ void RpcManager::disable() {
 // ---------------------------------------------------------------
 
 std::string
-RpcManager::performRpc(const std::string &destination_identity,
+RpcController::performRpc(const std::string &destination_identity,
                        const std::string &method, const std::string &payload,
                        const std::optional<double> &response_timeout) {
   assert(lp_ != nullptr);
@@ -61,14 +61,14 @@ RpcManager::performRpc(const std::string &destination_identity,
 // User-registered handlers
 // ---------------------------------------------------------------
 
-void RpcManager::registerRpcMethod(
+void RpcController::registerRpcMethod(
     const std::string &method_name,
     livekit::LocalParticipant::RpcHandler handler) {
   assert(lp_ != nullptr);
   lp_->registerRpcMethod(method_name, std::move(handler));
 }
 
-void RpcManager::unregisterRpcMethod(const std::string &method_name) {
+void RpcController::unregisterRpcMethod(const std::string &method_name) {
   assert(lp_ != nullptr);
   lp_->unregisterRpcMethod(method_name);
 }
@@ -77,14 +77,14 @@ void RpcManager::unregisterRpcMethod(const std::string &method_name) {
 // Built-in outgoing convenience (track control)
 // ---------------------------------------------------------------
 
-void RpcManager::requestRemoteTrackMute(const std::string &destination_identity,
+void RpcController::requestRemoteTrackMute(const std::string &destination_identity,
                                         const std::string &track_name) {
   namespace tc = rpc::track_control;
   performRpc(destination_identity, tc::kMethod,
              tc::formatPayload(tc::kActionMute, track_name), std::nullopt);
 }
 
-void RpcManager::requestRemoteTrackUnmute(
+void RpcController::requestRemoteTrackUnmute(
     const std::string &destination_identity, const std::string &track_name) {
   namespace tc = rpc::track_control;
   performRpc(destination_identity, tc::kMethod,
@@ -95,7 +95,7 @@ void RpcManager::requestRemoteTrackUnmute(
 // Built-in handler registration
 // ---------------------------------------------------------------
 
-void RpcManager::enableBuiltInHandlers() {
+void RpcController::enableBuiltInHandlers() {
   assert(lp_ != nullptr);
   lp_->registerRpcMethod(rpc::track_control::kMethod,
                          [this](const livekit::RpcInvocationData &data)
@@ -104,7 +104,7 @@ void RpcManager::enableBuiltInHandlers() {
                          });
 }
 
-void RpcManager::disableBuiltInHandlers() {
+void RpcController::disableBuiltInHandlers() {
   assert(lp_ != nullptr);
   lp_->unregisterRpcMethod(rpc::track_control::kMethod);
 }
@@ -114,10 +114,10 @@ void RpcManager::disableBuiltInHandlers() {
 // ---------------------------------------------------------------
 
 std::optional<std::string>
-RpcManager::handleTrackControlRpc(const livekit::RpcInvocationData &data) {
+RpcController::handleTrackControlRpc(const livekit::RpcInvocationData &data) {
   namespace tc = rpc::track_control;
 
-  std::cout << "[RpcManager] Handling track control RPC: " << data.payload
+  std::cout << "[RpcController] Handling track control RPC: " << data.payload
             << "\n";
   auto delim = data.payload.find(tc::kDelimiter);
   if (delim == std::string::npos || delim == 0) {

bridge/src/rpc_manager.h bridge/src/rpc_controller.hbridge/src/rpc_manager.h renamed to bridge/src/rpc_controller.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-/// @file rpc_manager.h
-/// @brief Internal RPC manager that owns all RPC concerns for the bridge.
+/// @file rpc_controller.h
+/// @brief Internal RPC controller that owns all RPC concerns for the bridge.
 
 #pragma once
 
@@ -34,15 +34,15 @@ struct RpcInvocationData;
 namespace livekit_bridge {
 
 namespace test {
-class RpcManagerTest;
+class RpcControllerTest;
 } // namespace test
 
 /**
  * Owns all RPC concerns for the LiveKitBridge: built-in handler registration
  * and dispatch, user-registered custom handlers, and outgoing RPC calls.
  *
- * The manager is bound to a LocalParticipant via enable() and unbound via
- * disable(). All public methods require the manager to be enabled (i.e.,
+ * The controller is bound to a LocalParticipant via enable() and unbound via
+ * disable(). All public methods require the controller to be enabled (i.e.,
  * enable() has been called and disable() has not).
  *
  * Built-in handlers (e.g., track-control) are automatically registered on
@@ -51,15 +51,15 @@ class RpcManagerTest;
  *
  * Not part of the public API; lives in bridge/src/.
  */
-class RpcManager {
+class RpcController {
 public:
   /// Callback the bridge provides to execute a track action
   /// (mute/unmute/release). Throws livekit::RpcError if the track is not found
   /// or the action is invalid.
   using TrackActionFn = std::function<void(
       const rpc::track_control::Action &action, const std::string &track_name)>;
 
-  explicit RpcManager(TrackActionFn track_action_fn);
+  explicit RpcController(TrackActionFn track_action_fn);
 
   /// Bind to a LocalParticipant and register all built-in RPC handlers.
   /// @pre @p lp must be non-null and remain valid until disable() is called.
@@ -68,7 +68,7 @@ class RpcManager {
   /// Unregister built-in handlers and unbind from the LocalParticipant.
   void disable();
 
-  /// Whether the manager is currently bound to a LocalParticipant.
+  /// Whether the controller is currently bound to a LocalParticipant.
   bool isEnabled() const { return lp_ != nullptr; }
 
   // -- Generic RPC --
@@ -118,7 +118,7 @@ class RpcManager {
                                 const std::string &track_name);
 
 private:
-  friend class test::RpcManagerTest;
+  friend class test::RpcControllerTest;
 
   /// @brief Enable built-in handlers.
   /// @throws if the LocalParticipant registerRpcMethod fails.
@@ -138,7 +138,7 @@ class RpcManager {
   /// Callback to execute a track action RPC
   TrackActionFn track_action_fn_;
 
-  /// The LocalParticipant bound to the manager.
+  /// The LocalParticipant bound to the controller.
   livekit::LocalParticipant *lp_;
 };