Init project

tests/peerconnection/answer.cpp

@@ -0,0 +1,10 @@
+#include <iostream>
+
+#include "rtc.h"
+
+int main(int argc, char **argv) {
+  CreatePeerConnectionWithID("ws://localhost:9002", "000000");
+
+  getchar();
+  return 0;
+}

tests/peerconnection/offer.cpp

@@ -0,0 +1,10 @@
+#include <iostream>
+
+#include "rtc.h"
+
+int main(int argc, char **argv) {
+  CreatePeerConnection("ws://localhost:9002");
+
+  getchar();
+  return 0;
+}

tests/signal_client/signal_client.cpp

@@ -0,0 +1,51 @@
+#include "ws_client.h"
+
+#include <cstdlib>
+#include <iostream>
+#include <string>
+#include <sstream>
+
+class WsReceiver:public WsCore
+{
+public:
+    WsReceiver(){}
+    ~WsReceiver(){}
+
+    void OnReceiveMessage(const std::string &msg)
+    {
+        LOG_INFO("Receive msg: {}", msg);
+    }
+};
+
+int main()
+{
+    bool done = false;
+    std::string input;
+    WsReceiver ws_client;
+
+    LOG_INFO("connect ws://localhost:9002");
+    ws_client.Connect("ws://localhost:9002");
+
+    std::string status1 = ws_client.GetStatus();
+
+    while("Open" != status1)
+    {
+        status1 = ws_client.GetStatus();
+    }
+    
+    LOG_INFO("Connect successfully!");
+
+    LOG_INFO("Send message [Hello]");
+    ws_client.Send("Hello");
+
+    LOG_INFO("Send ping");
+    ws_client.Ping();
+
+    LOG_INFO("Close conneciton");
+    int close_code = websocketpp::close::status::normal;
+    std::string reason = "User Close";
+    ws_client.Close(close_code, reason);
+
+    getchar();
+    return 0;
+}

tests/signal_server/main.cpp

@@ -0,0 +1,8 @@
+#include "signal_server.h"
+
+int main() {
+    SignalServer s;
+    // connect ws://localhost:9002
+    s.run();
+    return 0;
+}

tests/signal_server/signal_server.cpp

@@ -0,0 +1,166 @@
+#include "signal_server.h"
+
+#include "log.h"
+
+static const std::map<std::string, unsigned int> siganl_types{
+    {"create_transport", 1}, {"offer", 2},           {"query_remote_sdp", 3},
+    {"answer", 4},           {"offer_candidate", 5}, {"answer_candidate", 6}};
+
+std::string gen_random_6() {
+  static const char alphanum[] = "0123456789";
+  std::string tmp_s;
+  tmp_s.reserve(6);
+
+  for (int i = 0; i < 6; ++i) {
+    tmp_s += alphanum[rand() % (sizeof(alphanum) - 1)];
+  }
+
+  //   return tmp_s;
+  return "000000";
+}
+
+SignalServer::SignalServer() {
+  // Set logging settings
+  server_.set_error_channels(websocketpp::log::elevel::all);
+  server_.set_access_channels(websocketpp::log::alevel::none);
+
+  // Initialize Asio
+  server_.init_asio();
+
+  server_.set_open_handler(
+      std::bind(&SignalServer::on_open, this, std::placeholders::_1));
+
+  server_.set_close_handler(
+      std::bind(&SignalServer::on_close, this, std::placeholders::_1));
+
+  server_.set_message_handler(std::bind(&SignalServer::on_message, this,
+                                        std::placeholders::_1,
+                                        std::placeholders::_2));
+
+  server_.set_ping_handler(bind(&SignalServer::on_ping, this,
+                                std::placeholders::_1, std::placeholders::_2));
+
+  server_.set_pong_handler(bind(&SignalServer::on_pong, this,
+                                std::placeholders::_1, std::placeholders::_2));
+}
+
+SignalServer::~SignalServer() {}
+
+bool SignalServer::on_open(websocketpp::connection_hdl hdl) {
+  connections_[hdl] = connection_id_;
+  LOG_INFO("New connection [{}] established", connection_id_++);
+
+  json message = {{"type", "connection_id"}, {"connection_id", connection_id_}};
+  server_.send(hdl, message.dump(), websocketpp::frame::opcode::text);
+
+  return true;
+}
+
+bool SignalServer::on_close(websocketpp::connection_hdl hdl) {
+  LOG_INFO("Connection [{}] closed", connection_id_++);
+  connections_.erase(hdl);
+  return true;
+}
+
+bool SignalServer::on_ping(websocketpp::connection_hdl hdl, std::string s) {
+  /* Do something */
+  LOG_INFO("Receive ping");
+  return true;
+}
+
+bool SignalServer::on_pong(websocketpp::connection_hdl hdl, std::string s) {
+  /* Do something */
+  LOG_INFO("pong");
+  return true;
+}
+
+void SignalServer::run() {
+  // Listen on port 9002
+  server_.listen(9002);
+
+  // Queues a connection accept operation
+  server_.start_accept();
+
+  // Start the Asio io_service run loop
+  server_.run();
+}
+
+void SignalServer::send_msg(websocketpp::connection_hdl hdl, json message) {
+  server_.send(hdl, message.dump(), websocketpp::frame::opcode::text);
+}
+
+void SignalServer::on_message(websocketpp::connection_hdl hdl,
+                              server::message_ptr msg) {
+  std::string payload = msg->get_payload();
+
+  auto j = json::parse(payload);
+
+  std::string type = j["type"];
+  auto itr = siganl_types.find(type);
+  if (itr != siganl_types.end()) {
+    LOG_INFO("msg type: {}", itr->first);
+    switch (itr->second) {
+      case 1: {
+        transport_id_ = gen_random_6();
+        LOG_INFO("Generate transport_id [{}]", transport_id_);
+        json message = {{"type", "transport_id"},
+                        {"transport_id", transport_id_}};
+        send_msg(hdl, message);
+        break;
+      }
+      case 2: {
+        std::string transport_id = j["transport_id"];
+        std::string sdp = j["sdp"];
+        LOG_INFO("Save transport_id[{}] with offer sdp[{}]", transport_id, sdp);
+        offer_sdp_map_[transport_id] = sdp;
+        offer_hdl_map_[transport_id] = hdl;
+        break;
+      }
+      case 3: {
+        std::string transport_id = j["transport_id"];
+        std::string sdp = offer_sdp_map_[transport_id_];
+        LOG_INFO("send offer sdp [{}]", sdp.c_str());
+        json message = {{"type", "remote_sdp"}, {"sdp", sdp}};
+        send_msg(hdl, message);
+        break;
+      }
+      case 4: {
+        std::string transport_id = j["transport_id"];
+        std::string sdp = j["sdp"];
+        LOG_INFO("Save transport_id[{}] with answer sdp[{}]", transport_id,
+                 sdp);
+        answer_sdp_map_[transport_id] = sdp;
+        answer_hdl_map_[transport_id] = hdl;
+        LOG_INFO("send answer sdp [{}]", sdp.c_str());
+        json message = {{"type", "remote_sdp"}, {"sdp", sdp}};
+        send_msg(offer_hdl_map_[transport_id], message);
+        break;
+      }
+      case 5: {
+        std::string transport_id = j["transport_id"];
+        std::string candidate = j["sdp"];
+        LOG_INFO("send candidate [{}]", candidate.c_str());
+        json message = {{"type", "candidate"}, {"sdp", candidate}};
+        send_msg(answer_hdl_map_[transport_id], message);
+        break;
+      }
+      case 6: {
+        std::string transport_id = j["transport_id"];
+        std::string candidate = j["sdp"];
+        LOG_INFO("send candidate [{}]", candidate.c_str());
+        json message = {{"type", "candidate"}, {"sdp", candidate}};
+        send_msg(offer_hdl_map_[transport_id], message);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  // std::string sdp = j["sdp"];
+
+  // LOG_INFO("Message type: {}", type);
+  // LOG_INFO("Message body: {}", sdp);
+
+  // server_.send(hdl, msg->get_payload(), msg->get_opcode());
+}

tests/signal_server/signal_server.h

@@ -0,0 +1,50 @@
+#ifndef _SIGNAL_SERVER_H_
+#define _SIGNAL_SERVER_H_
+
+#include <functional>
+#include <map>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <websocketpp/config/asio_no_tls.hpp>
+#include <websocketpp/server.hpp>
+
+using nlohmann::json;
+
+typedef websocketpp::server<websocketpp::config::asio> server;
+typedef unsigned int connection_id;
+typedef std::string room_id;
+
+class SignalServer {
+ public:
+  SignalServer();
+  ~SignalServer();
+
+  bool on_open(websocketpp::connection_hdl hdl);
+
+  bool on_close(websocketpp::connection_hdl hdl);
+
+  bool on_ping(websocketpp::connection_hdl hdl, std::string s);
+
+  bool on_pong(websocketpp::connection_hdl hdl, std::string s);
+
+  void run();
+
+  void on_message(websocketpp::connection_hdl hdl, server::message_ptr msg);
+
+  void send_msg(websocketpp::connection_hdl hdl, json message);
+
+ private:
+  server server_;
+  std::map<websocketpp::connection_hdl, connection_id,
+           std::owner_less<websocketpp::connection_hdl>>
+      connections_;
+  std::map<room_id, connection_id> rooms_;
+  unsigned int connection_id_ = 0;
+  std::string transport_id_ = "000000";
+  std::map<std::string, std::string> offer_sdp_map_;
+  std::map<std::string, std::string> answer_sdp_map_;
+  std::map<std::string, websocketpp::connection_hdl> offer_hdl_map_;
+  std::map<std::string, websocketpp::connection_hdl> answer_hdl_map_;
+};
+
+#endif