simple_robot -> simple_joystick

Author: stephen-derosa

examples/CMakeLists.txt

@@ -117,46 +117,46 @@ target_link_libraries(SimpleRpc
     spdlog::spdlog
 )
 
-# --- SimpleRobot example (robot + human executables with shared json_utils) ---
+# --- SimpleJoystick example (sender + receiver executables with shared json_utils) ---
 
-add_library(simple_robot_json_utils STATIC
-  simple_robot/json_utils.cpp
-  simple_robot/json_utils.h
-  simple_robot/utils.cpp
-  simple_robot/utils.h
+add_library(simple_joystick_json_utils STATIC
+  simple_joystick/json_utils.cpp
+  simple_joystick/json_utils.h
+  simple_joystick/utils.cpp
+  simple_joystick/utils.h
 )
 
-target_include_directories(simple_robot_json_utils PUBLIC
-  ${CMAKE_CURRENT_SOURCE_DIR}/simple_robot
+target_include_directories(simple_joystick_json_utils PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR}/simple_joystick
 )
 
-target_link_libraries(simple_robot_json_utils
+target_link_libraries(simple_joystick_json_utils
   PUBLIC
     nlohmann_json::nlohmann_json
 )
 
-add_executable(SimpleRobot
-  simple_robot/robot.cpp
+add_executable(SimpleJoystickReceiver
+  simple_joystick/receiver.cpp
 )
 
-target_include_directories(SimpleRobot PRIVATE ${EXAMPLES_PRIVATE_INCLUDE_DIRS})
+target_include_directories(SimpleJoystickReceiver PRIVATE ${EXAMPLES_PRIVATE_INCLUDE_DIRS})
 
-target_link_libraries(SimpleRobot
+target_link_libraries(SimpleJoystickReceiver
   PRIVATE
-    simple_robot_json_utils
+    simple_joystick_json_utils
     livekit
     spdlog::spdlog
 )
 
-add_executable(SimpleHuman
-  simple_robot/human.cpp
+add_executable(SimpleJoystickSender
+  simple_joystick/sender.cpp
 )
 
-target_include_directories(SimpleHuman PRIVATE ${EXAMPLES_PRIVATE_INCLUDE_DIRS})
+target_include_directories(SimpleJoystickSender PRIVATE ${EXAMPLES_PRIVATE_INCLUDE_DIRS})
 
-target_link_libraries(SimpleHuman
+target_link_libraries(SimpleJoystickSender
   PRIVATE
-    simple_robot_json_utils
+    simple_joystick_json_utils
     livekit
     spdlog::spdlog
 )
@@ -269,7 +269,7 @@ if(WIN32)
   )
 
   # Copy DLLs to each example's output directory
-  foreach(EXAMPLE SimpleRoom SimpleRpc SimpleRobot SimpleHuman SimpleDataStream LoggingLevelsBasicUsage LoggingLevelsCustomSinks BridgeRobot BridgeHuman)
+  foreach(EXAMPLE SimpleRoom SimpleRpc SimpleJoystickSender SimpleJoystickReceiver SimpleDataStream LoggingLevelsBasicUsage LoggingLevelsCustomSinks BridgeRobot BridgeHuman)
     foreach(DLL ${REQUIRED_DLLS})
       add_custom_command(TARGET ${EXAMPLE} POST_BUILD
         COMMAND ${CMAKE_COMMAND} -E copy_if_different
@@ -304,7 +304,7 @@ if(UNIX)
   endif()
 
   # Copy shared library to each example's output directory
-  foreach(EXAMPLE SimpleRoom SimpleRpc SimpleRobot SimpleHuman SimpleDataStream LoggingLevelsBasicUsage LoggingLevelsCustomSinks BridgeRobot BridgeHuman)
+  foreach(EXAMPLE SimpleRoom SimpleRpc SimpleJoystickSender SimpleJoystickReceiver SimpleDataStream LoggingLevelsBasicUsage LoggingLevelsCustomSinks BridgeRobot BridgeHuman)
     add_custom_command(TARGET ${EXAMPLE} POST_BUILD
       COMMAND ${CMAKE_COMMAND} -E copy_if_different
               "${LIVEKIT_LIB_DIR}/${FFI_SHARED_LIB}"

examples/bridge_human_robot/human.cpp

@@ -43,11 +43,11 @@
  * Run alongside the "robot" example (which publishes with identity "robot").
  */
 
-#include "lk_log.h"
 #include "livekit/audio_frame.h"
 #include "livekit/track.h"
 #include "livekit/video_frame.h"
 #include "livekit_bridge/livekit_bridge.h"
+#include "lk_log.h"
 #include "sdl_media.h"
 
 #include <SDL3/SDL.h>

examples/bridge_human_robot/robot.cpp

@@ -374,9 +374,10 @@ int main(int argc, char *argv[]) {
   auto sim_cam =
       bridge.createVideoTrack("robot-sim-frame", kSimWidth, kSimHeight,
                               livekit::TrackSource::SOURCE_SCREENSHARE);
-  LK_LOG_INFO("[robot] Publishing {} sim audio ({} Hz, {} ch), cam + sim frame ({}x{} / {}x{}).",
-              use_mic ? "mic + " : "(no mic) ", kSampleRate, kChannels,
-              kWidth, kHeight, kSimWidth, kSimHeight);
+  LK_LOG_INFO("[robot] Publishing {} sim audio ({} Hz, {} ch), cam + sim frame "
+              "({}x{} / {}x{}).",
+              use_mic ? "mic + " : "(no mic) ", kSampleRate, kChannels, kWidth,
+              kHeight, kSimWidth, kSimHeight);
 
   // ----- SDL Mic capture (only when use_mic) -----
   // SDLMicSource pulls 10ms frames from the default recording device and

examples/simple_robot/json_utils.cpp examples/simple_joystick/json_utils.cppexamples/simple_robot/json_utils.cpp renamed to examples/simple_joystick/json_utils.cpp

@@ -19,7 +19,7 @@
 #include <nlohmann/json.hpp>
 #include <stdexcept>
 
-namespace simple_robot {
+namespace simple_joystick {
 
 std::string joystick_to_json(const JoystickCommand &cmd) {
   nlohmann::json j;
@@ -43,4 +43,4 @@ JoystickCommand json_to_joystick(const std::string &json) {
   }
 }
 
-} // namespace simple_robot
+} // namespace simple_joystick

examples/simple_robot/json_utils.h examples/simple_joystick/json_utils.hexamples/simple_robot/json_utils.h renamed to examples/simple_joystick/json_utils.h

@@ -18,7 +18,7 @@
 
 #include <string>
 
-namespace simple_robot {
+namespace simple_joystick {
 
 /// Represents a joystick command with three axes.
 struct JoystickCommand {
@@ -35,4 +35,4 @@ std::string joystick_to_json(const JoystickCommand &cmd);
 /// Throws std::runtime_error if the JSON is invalid or missing fields.
 JoystickCommand json_to_joystick(const std::string &json);
 
-} // namespace simple_robot
+} // namespace simple_joystick

examples/simple_robot/robot.cpp examples/simple_joystick/receiver.cppexamples/simple_robot/robot.cpp renamed to examples/simple_joystick/receiver.cpp

@@ -31,7 +31,7 @@ using namespace std::chrono_literals;
 namespace {
 
 std::atomic<bool> g_running{true};
-std::atomic<bool> g_human_connected{false};
+std::atomic<bool> g_sender_connected{false};
 
 void handleSignal(int) { g_running.store(false); }
 
@@ -42,7 +42,7 @@ void printUsage(const char *prog) {
             << "  " << prog << " --url=<ws-url> --token=<token>\n\n"
             << "Env fallbacks:\n"
             << "  LIVEKIT_URL, LIVEKIT_TOKEN\n\n"
-            << "This is the 'robot' role. It waits for a 'human' peer to\n"
+            << "This is the receiver. It waits for a sender peer to\n"
             << "connect and send joystick commands via RPC.\n"
             << "Exits after 2 minutes if no commands are received.\n";
 }
@@ -51,12 +51,12 @@ void printUsage(const char *prog) {
 
 int main(int argc, char *argv[]) {
   std::string url, token;
-  if (!simple_robot::parseArgs(argc, argv, url, token)) {
+  if (!simple_joystick::parseArgs(argc, argv, url, token)) {
     printUsage(argv[0]);
     return 1;
   }
 
-  std::cout << "[Robot] Connecting to: " << url << "\n";
+  std::cout << "[Receiver] Connecting to: " << url << "\n";
   std::signal(SIGINT, handleSignal);
 
   livekit::initialize(livekit::LogLevel::Info, livekit::LogSink::kConsole);
@@ -66,36 +66,36 @@ int main(int argc, char *argv[]) {
   options.dynacast = false;
 
   bool res = room->Connect(url, token, options);
-  std::cout << "[Robot] Connect result: " << std::boolalpha << res << "\n";
+  std::cout << "[Receiver] Connect result: " << std::boolalpha << res << "\n";
   if (!res) {
-    std::cerr << "[Robot] Failed to connect to room\n";
+    std::cerr << "[Receiver] Failed to connect to room\n";
     livekit::shutdown();
     return 1;
   }
 
   auto info = room->room_info();
-  std::cout << "[Robot] Connected to room: " << info.name << "\n";
-  std::cout << "[Robot] Waiting for 'human' peer (up to 2 minutes)...\n";
+  std::cout << "[Receiver] Connected to room: " << info.name << "\n";
+  std::cout << "[Receiver] Waiting for sender peer (up to 2 minutes)...\n";
 
   // Register RPC handler for joystick commands
   LocalParticipant *lp = room->localParticipant();
   lp->registerRpcMethod(
       "joystick_command",
       [](const RpcInvocationData &data) -> std::optional<std::string> {
         try {
-          auto cmd = simple_robot::json_to_joystick(data.payload);
-          g_human_connected.store(true);
-          std::cout << "[Robot] Joystick from '" << data.caller_identity
+          auto cmd = simple_joystick::json_to_joystick(data.payload);
+          g_sender_connected.store(true);
+          std::cout << "[Receiver] Joystick from '" << data.caller_identity
                     << "': x=" << cmd.x << " y=" << cmd.y << " z=" << cmd.z
                     << "\n";
           return std::optional<std::string>{"ok"};
         } catch (const std::exception &e) {
-          std::cerr << "[Robot] Bad joystick payload: " << e.what() << "\n";
+          std::cerr << "[Receiver] Bad joystick payload: " << e.what() << "\n";
           throw;
         }
       });
 
-  std::cout << "[Robot] RPC handler 'joystick_command' registered. "
+  std::cout << "[Receiver] RPC handler 'joystick_command' registered. "
             << "Listening for commands...\n";
 
   // Wait up to 2 minutes for activity, then exit as failure
@@ -106,16 +106,16 @@ int main(int argc, char *argv[]) {
   }
 
   if (!g_running.load()) {
-    std::cout << "[Robot] Interrupted by signal. Shutting down.\n";
-  } else if (!g_human_connected.load()) {
-    std::cerr << "[Robot] Timed out after 2 minutes with no human connection. "
+    std::cout << "[Receiver] Interrupted by signal. Shutting down.\n";
+  } else if (!g_sender_connected.load()) {
+    std::cerr << "[Receiver] Timed out after 2 minutes with no sender connection. "
               << "Exiting as failure.\n";
     room->setDelegate(nullptr);
     room.reset();
     livekit::shutdown();
     return 1;
   } else {
-    std::cout << "[Robot] Session complete.\n";
+    std::cout << "[Receiver] Session complete.\n";
   }
 
   room->setDelegate(nullptr);

examples/simple_robot/human.cpp examples/simple_joystick/sender.cppexamples/simple_robot/human.cpp renamed to examples/simple_joystick/sender.cpp

@@ -98,14 +98,14 @@ void printUsage(const char *prog) {
             << "  " << prog << " --url=<ws-url> --token=<token>\n\n"
             << "Env fallbacks:\n"
             << "  LIVEKIT_URL, LIVEKIT_TOKEN\n\n"
-            << "This is the 'human' role. It connects to the room and\n"
-            << "continuously checks for a 'robot' peer every 2 seconds.\n"
+            << "This is the sender. It connects to the room and\n"
+            << "continuously checks for a receiver peer every 2 seconds.\n"
             << "Once connected, use keyboard to send joystick commands:\n"
             << "  w / s  = +x / -x\n"
             << "  d / a  = +y / -y\n"
             << "  z / c  = +z / -z\n"
             << "  q      = quit\n"
-            << "Automatically reconnects if robot leaves.\n";
+            << "Automatically reconnects if receiver leaves.\n";
 }
 
 void printControls() {
@@ -121,12 +121,12 @@ void printControls() {
 
 int main(int argc, char *argv[]) {
   std::string url, token;
-  if (!simple_robot::parseArgs(argc, argv, url, token)) {
+  if (!simple_joystick::parseArgs(argc, argv, url, token)) {
     printUsage(argv[0]);
     return 1;
   }
 
-  std::cout << "[Human] Connecting to: " << url << "\n";
+  std::cout << "[Sender] Connecting to: " << url << "\n";
   std::signal(SIGINT, handleSignal);
 
   livekit::initialize(livekit::LogLevel::Info, livekit::LogSink::kConsole);
@@ -136,40 +136,40 @@ int main(int argc, char *argv[]) {
   options.dynacast = false;
 
   bool res = room->Connect(url, token, options);
-  std::cout << "[Human] Connect result: " << std::boolalpha << res << "\n";
+  std::cout << "[Sender] Connect result: " << std::boolalpha << res << "\n";
   if (!res) {
-    std::cerr << "[Human] Failed to connect to room\n";
+    std::cerr << "[Sender] Failed to connect to room\n";
     livekit::shutdown();
     return 1;
   }
 
   auto info = room->room_info();
-  std::cout << "[Human] Connected to room: " << info.name << "\n";
+  std::cout << "[Sender] Connected to room: " << info.name << "\n";
 
   // Enable raw terminal mode for immediate keypress detection
   enableRawMode();
 
-  std::cout << "[Human] Waiting for 'robot' to join (checking every 2s)...\n";
+  std::cout << "[Sender] Waiting for 'robot' to join (checking every 2s)...\n";
   printControls();
 
   LocalParticipant *lp = room->localParticipant();
   double x = 0.0, y = 0.0, z = 0.0;
-  bool robot_connected = false;
-  auto last_robot_check = std::chrono::steady_clock::now();
+  bool receiver_connected = false;
+  auto last_receiver_check = std::chrono::steady_clock::now();
 
   while (g_running.load()) {
-    // Periodically check robot presence every 2 seconds
+    // Periodically check receiver presence every 2 seconds
     auto now = std::chrono::steady_clock::now();
-    if (now - last_robot_check >= 2s) {
-      last_robot_check = now;
-      bool robot_present = (room->remoteParticipant("robot") != nullptr);
-
-      if (robot_present && !robot_connected) {
-        std::cout << "[Human] 'robot' connected! Use keys to send commands.\n";
-        robot_connected = true;
-      } else if (!robot_present && robot_connected) {
-        std::cout << "[Human] 'robot' disconnected. Waiting for reconnect...\n";
-        robot_connected = false;
+    if (now - last_receiver_check >= 2s) {
+      last_receiver_check = now;
+      bool receiver_present = (room->remoteParticipant("robot") != nullptr);
+
+      if (receiver_present && !receiver_connected) {
+        std::cout << "[Sender] Receiver connected! Use keys to send commands.\n";
+        receiver_connected = true;
+      } else if (!receiver_present && receiver_connected) {
+        std::cout << "[Sender] Receiver disconnected. Waiting for reconnect...\n";
+        receiver_connected = false;
       }
     }
 
@@ -182,7 +182,7 @@ int main(int argc, char *argv[]) {
 
     // Handle quit
     if (key == 'q' || key == 'Q') {
-      std::cout << "\n[Human] Quit requested.\n";
+      std::cout << "\n[Sender] Quit requested.\n";
       break;
     }
 
@@ -226,37 +226,37 @@ int main(int argc, char *argv[]) {
     if (!changed)
       continue;
 
-    if (!robot_connected) {
-      std::cout << "[Human] (no robot connected) x=" << x << " y=" << y
+    if (!receiver_connected) {
+      std::cout << "[Sender] (no receiver connected) x=" << x << " y=" << y
                 << " z=" << z << "\n";
       continue;
     }
 
     // Send joystick command via RPC
-    simple_robot::JoystickCommand cmd{x, y, z};
-    std::string payload = simple_robot::joystick_to_json(cmd);
+    simple_joystick::JoystickCommand cmd{x, y, z};
+    std::string payload = simple_joystick::joystick_to_json(cmd);
 
-    std::cout << "[Human] Sending: x=" << x << " y=" << y << " z=" << z << "\n";
+    std::cout << "[Sender] Sending: x=" << x << " y=" << y << " z=" << z << "\n";
 
     try {
       std::string response =
           lp->performRpc("robot", "joystick_command", payload, 5.0);
-      std::cout << "[Human] Robot acknowledged: " << response << "\n";
+      std::cout << "[Sender] Receiver acknowledged: " << response << "\n";
     } catch (const RpcError &e) {
-      std::cerr << "[Human] RPC error: " << e.message() << "\n";
+      std::cerr << "[Sender] RPC error: " << e.message() << "\n";
       if (static_cast<RpcError::ErrorCode>(e.code()) ==
           RpcError::ErrorCode::RECIPIENT_DISCONNECTED) {
-        std::cout << "[Human] Robot disconnected. Waiting for reconnect...\n";
-        robot_connected = false;
+        std::cout << "[Sender] Receiver disconnected. Waiting for reconnect...\n";
+        receiver_connected = false;
       }
     } catch (const std::exception &e) {
-      std::cerr << "[Human] Error sending command: " << e.what() << "\n";
+      std::cerr << "[Sender] Error sending command: " << e.what() << "\n";
     }
   }
 
   disableRawMode();
 
-  std::cout << "[Human] Done. Shutting down.\n";
+  std::cout << "[Sender] Done. Shutting down.\n";
   room->setDelegate(nullptr);
   room.reset();
   livekit::shutdown();