Dev version: Support multiple ice connections

tests/signal_server/main.cpp

@@ -5,7 +5,12 @@
 
 int main(int argc, char* argv[]) {
   SignalServer s;
-  std::string port = argv[1];
+  std::string port = "";
+  if (argc > 1) {
+    port = argv[1];
+  } else {
+    port = "9090";
+  }
   std::cout << "Port: " << port << std::endl;
   s.run(std::stoi(port));
   return 0;

tests/signal_server/signal_server.cpp

@@ -72,7 +72,6 @@ bool SignalServer::on_pong(websocketpp::connection_hdl hdl, std::string s) {
 }
 
 void SignalServer::run(uint16_t port) {
-  // Listen on port 9093
   server_.listen(port);
 
   // Queues a connection accept operation
@@ -133,32 +132,64 @@ void SignalServer::on_message(websocketpp::connection_hdl hdl,
     case "offer"_H: {
       std::string transmission_id = j["transmission_id"].get<std::string>();
       std::string sdp = j["sdp"].get<std::string>();
-      LOG_INFO("Receive transmission id [{}] with offer sdp [{}]",
-               transmission_id, sdp);
+      // LOG_INFO("Receive transmission id [{}] with offer sdp [{}]",
+      //          transmission_id, sdp);
       transmission_manager_.BindGuestToTransmission(hdl, transmission_id);
+      std::string guest_username = GetIceUsername(sdp);
+      transmission_manager_.BindGuestUsernameToWsHandle(guest_username, hdl);
 
       websocketpp::connection_hdl host_hdl =
           transmission_manager_.GetHostOfTransmission(transmission_id);
+      std::vector<websocketpp::connection_hdl> guest_hdl_list =
+          transmission_manager_.GetAllGuestsOfTransmission(transmission_id);
 
-      std::string ice_username = GetIceUsername(sdp);
-      transmission_manager_.BindGuestUsernameToWsHandle(ice_username, hdl);
+      // LOG_INFO("send offer sdp [{}]", sdp);
+      json message = {
+          {"type", "offer"}, {"sdp", sdp}, {"guest", guest_username}};
 
-      LOG_INFO("send offer sdp [{}]", sdp.c_str());
-      json message = {{"type", "offer"}, {"sdp", sdp}, {"guest", ice_username}};
+      LOG_INFO("[{}] send offer sdp to host", guest_username);
       send_msg(host_hdl, message);
+
+      LOG_INFO("Size of guest_hdl_list: {}", guest_hdl_list.size());
+      for (auto guest_hdl : guest_hdl_list) {
+        if (guest_hdl.lock().get() != hdl.lock().get()) {
+          LOG_INFO("[{}] send offer sdp to [{}]", guest_username,
+                   transmission_manager_.GetGuestUsername(guest_hdl));
+          send_msg(guest_hdl, message);
+        }
+      }
+      break;
+    }
+    case "query_members"_H: {
+      std::string transmission_id = j["transmission_id"].get<std::string>();
+      std::vector<std::string> member_list =
+          transmission_manager_.GetAllMembersOfTransmission(transmission_id);
+
+      json message = {{"type", "transmission_members"},
+                      {"transmission_id", transmission_id},
+                      {"transmission_members", member_list},
+                      {"status", "success"}};
+      send_msg(hdl, message);
       break;
     }
     case "answer"_H: {
       std::string transmission_id = j["transmission_id"].get<std::string>();
       std::string sdp = j["sdp"].get<std::string>();
       std::string guest_ice_username = j["guest"].get<std::string>();
-      LOG_INFO("Receive transmission id [{}] with answer sdp [{}]",
-               transmission_id, sdp);
+      std::string host_ice_username = GetIceUsername(sdp);
+      if (transmission_manager_.GetHostUsername(hdl).empty()) {
+        transmission_manager_.BindHostUsernameToWsHandle(host_ice_username,
+                                                         hdl);
+      }
+      // LOG_INFO("Receive transmission id [{}] with answer sdp [{}]",
+      //          transmission_id, sdp);
 
       websocketpp::connection_hdl guest_hdl =
           transmission_manager_.GetGuestWsHandle(guest_ice_username);
 
-      LOG_INFO("send answer sdp [{}]", sdp.c_str());
+      // LOG_INFO("send answer sdp [{}]", sdp);
+      LOG_INFO("[{}] send answer sdp to [{}]", host_ice_username,
+               guest_ice_username);
       json message = {{"type", "remote_sdp"}, {"sdp", sdp}};
       send_msg(guest_hdl, message);
       break;

tests/signal_server/transmission_manager.cpp

@@ -21,6 +21,14 @@ bool TransmissionManager::BindHostToTransmission(
 
 bool TransmissionManager::BindGuestToTransmission(
     websocketpp::connection_hdl hdl, const std::string& transmission_id) {
+  if (transmission_guest_list_.find(transmission_id) !=
+      transmission_guest_list_.end()) {
+    transmission_guest_list_[transmission_id].push_back(hdl);
+  } else {
+    std::vector<websocketpp::connection_hdl> guest_hdl_list;
+    guest_hdl_list.push_back(hdl);
+    transmission_guest_list_[transmission_id] = guest_hdl_list;
+  }
   return true;
 }
 
@@ -34,11 +42,23 @@ bool TransmissionManager::ReleaseGuestFromTransmission(
   return true;
 }
 
+bool TransmissionManager::BindHostUsernameToWsHandle(
+    const std::string& host_username, websocketpp::connection_hdl hdl) {
+  if (transmission_host_username_list_.find(host_username) !=
+      transmission_host_username_list_.end()) {
+    LOG_ERROR("Guest already bind to username [{}]", host_username.c_str());
+    return false;
+  } else {
+    transmission_host_username_list_[host_username] = hdl;
+  }
+  return true;
+}
+
 bool TransmissionManager::BindGuestUsernameToWsHandle(
     const std::string& guest_username, websocketpp::connection_hdl hdl) {
   if (transmission_guest_username_list_.find(guest_username) !=
       transmission_guest_username_list_.end()) {
-    LOG_WARN("Guest already bind to username [{}]", guest_username.c_str());
+    LOG_ERROR("Guest already bind to username [{}]", guest_username.c_str());
     return false;
   } else {
     transmission_guest_username_list_[guest_username] = hdl;
@@ -57,14 +77,32 @@ websocketpp::connection_hdl TransmissionManager::GetHostOfTransmission(
   }
 }
 
-std::set<websocketpp::connection_hdl>
-TransmissionManager::GetGuestOfTransmission(
+std::string TransmissionManager::GetHostUsername(
+    websocketpp::connection_hdl hdl) {
+  for (auto host : transmission_host_username_list_) {
+    if (host.second.lock().get() == hdl.lock().get()) return host.first;
+  }
+
+  return "";
+}
+
+std::string TransmissionManager::GetGuestUsername(
+    websocketpp::connection_hdl hdl) {
+  for (auto guest : transmission_guest_username_list_) {
+    if (guest.second.lock().get() == hdl.lock().get()) return guest.first;
+  }
+
+  return "";
+}
+
+std::vector<websocketpp::connection_hdl>
+TransmissionManager::GetAllGuestsOfTransmission(
     const std::string& transmission_id) {
   if (transmission_guest_list_.find(transmission_id) !=
       transmission_guest_list_.end()) {
     return transmission_guest_list_[transmission_id];
   } else {
-    return std::set<websocketpp::connection_hdl>();
+    return std::vector<websocketpp::connection_hdl>();
   }
 }
 
@@ -77,4 +115,18 @@ websocketpp::connection_hdl TransmissionManager::GetGuestWsHandle(
     websocketpp::connection_hdl hdl;
     return hdl;
   }
+}
+
+std::vector<std::string> TransmissionManager::GetAllMembersOfTransmission(
+    const std::string& transmission_id) {
+  std::vector<std::string> member_list;
+
+  member_list.push_back(
+      GetHostUsername(GetHostOfTransmission(transmission_id)));
+
+  for (auto guest_hdl : GetAllGuestsOfTransmission(transmission_id)) {
+    member_list.push_back(GetGuestUsername(guest_hdl));
+  }
+
+  return member_list;
 }

tests/signal_server/transmission_manager.h

@@ -20,21 +20,31 @@ class TransmissionManager {
   bool ReleaseGuestFromTransmission(websocketpp::connection_hdl hdl,
                                     const std::string& transmission_id);
 
+  bool BindHostUsernameToWsHandle(const std::string& host_username,
+                                  websocketpp::connection_hdl hdl);
   bool BindGuestUsernameToWsHandle(const std::string& guest_username,
                                    websocketpp::connection_hdl hdl);
 
+  std::string GetHostUsername(websocketpp::connection_hdl hdl);
+  std::string GetGuestUsername(websocketpp::connection_hdl hdl);
+
   websocketpp::connection_hdl GetHostOfTransmission(
       const std::string& transmission_id);
-  std::set<websocketpp::connection_hdl> GetGuestOfTransmission(
+  std::vector<websocketpp::connection_hdl> GetAllGuestsOfTransmission(
       const std::string& transmission_id);
   websocketpp::connection_hdl GetGuestWsHandle(
       const std::string& guest_username);
 
+  std::vector<std::string> GetAllMembersOfTransmission(
+      const std::string& transmission_id);
+
  private:
   std::map<std::string, websocketpp::connection_hdl> transmission_host_list_;
-  std::map<std::string, std::set<websocketpp::connection_hdl>>
+  std::map<std::string, std::vector<websocketpp::connection_hdl>>
       transmission_guest_list_;
 
+  std::map<std::string, websocketpp::connection_hdl>
+      transmission_host_username_list_;
   std::map<std::string, websocketpp::connection_hdl>
       transmission_guest_username_list_;
 };