Why use http instead of socket.io to implement a signaling server about unityrenderstreaming HOT 4 CLOSED

"use strict";

import https = require("https");
import fs = require("fs");
import socketIo = require("socket.io");
import express = require("express");

const app = express();
app.use(express.static("./public"));

let USER_COUNT: number = 3;

let options: https.ServerOptions = {
    key: fs.readFileSync("../cert/xxx.key"),
    cert: fs.readFileSync("../cert/xxx.pem")
};

const httpsServer = https.createServer(options, app);

const io = socketIo(httpsServer);
// connection event
io.sockets.on("connection", socket => {
    // join event
    socket.on("join", room => {
        socket.join(room);
        let myRoom = io.sockets.adapter.rooms[room];
        let users = myRoom ? Object.keys(myRoom.sockets).length : 0;

        if (users < USER_COUNT) {
            socket.emit("joined", room, socket.id);
            if (users > 1) {
                socket.to(room).emit("otherJoin", room);
            }
        } else {
            socket.leave(room);
            socket.emit("full", room, socket.id);
        }
    });
    // leave event
    socket.on("leave", room => {
        let myRoom = io.sockets.adapter.rooms[room];
        let users = myRoom ? Object.keys(myRoom.sockets).length : 0;
        socket.to(room).emit("bye", room, socket.id);
        socket.emit("leaved", room, socket.id);
    });

    socket.on("message", (room, data) => {
        socket.to(room).emit("message", room, data);
    });
});

httpsServer.listen(3001, "0.0.0.0");

part of client code
......

function conn(): void {
    socket = io.connect();

    socket.on("joined", (roomId: string, id: any) => {
        console.log("receive joined " + roomId + " " + id);

        state = "joined";
        createPeerConnection();

        btnConnectServer.disabled = true;
        btnLeave.disabled = false;
        console.log("receive joined state:" + state);
    });

    socket.on("otherJoin", (roomId: string, id: any) => {
        console.log("receive otherJoin " + roomId + " " + id);
        if (state == "joinedUnbind") {
            createPeerConnection();
        }
        state = "joinedConn";
        call();
        console.log("receive otherJoin state:" + state);
    });

    socket.on("full", (roomId: string, id: any) => {
        console.log("receive full " + roomId + " " + id);
        state = "leaved";
        socket.disconnect();
        btnConnectServer.disabled = false;
        btnLeave.disabled = true;
        console.log("receive full state:" + state);
    });

    socket.on("leaved", (roomId: string, id: any) => {
        console.log("receive leaved " + roomId + " " + id);
        state = "leaved";
        socket.disconnect();
        btnConnectServer.disabled = false;
        btnLeave.disabled = true;
        console.log("receive leaved state:" + state);
    });

    socket.on("bye", (roomId: string, id: any) => {
        console.log("receive bye " + roomId + " " + id);
        state = "joinedUnbind";
        closePeerConnection();
        remoteVideo.srcObject = null;
        console.log("receive bye state:" + state);
    });

    socket.on("message", (roomId: string, data: any) => {
        console.log("receive message " + roomId + " " + data);

        if (data) {
            let msg = data as CandidateData;
            if (msg.type == "offer") {
                pc.setRemoteDescription(new RTCSessionDescription(data));
                pc.createAnswer()
                    .then(getAnswer)
                    .catch(handleError);
            } else if (msg.type == "answer") {
                pc.setRemoteDescription(new RTCSessionDescription(data));
            } else if (msg.type == "candidate") {
                let candidate = new RTCIceCandidate({
                    sdpMLineIndex: msg.label,
                    candidate: msg.candidate
                });

                pc.addIceCandidate(candidate);
            } else {
                console.error("invalid message:", data);
            }
        }
    });

    socket.emit("join", room);
}

function createPeerConnection(): void {
    console.log("create peer connection");

    // create PeerConnection
    if (!pc) {
        let pcConfig: RTCConfiguration = {
            iceServers: [
                {
                    urls: "xxx:3478"
                },
                {
                    urls: "turn:xxx:3478",
                    credential: "xxx",
                    username: "xxx"
                }
            ]
        };
        pc = new RTCPeerConnection(pcConfig);
        pc.onicecandidate = e => {
            console.log("gather ICECandidate");

            if (e.candidate) {
                // send message
                let data: CandidateData = {
                    type: "candidate",
                    label: e.candidate.sdpMLineIndex,
                    id: e.candidate.sdpMid,
                    candidate: e.candidate.candidate
                };
                sendMessage(room, data);
            }
        };

        pc.ontrack = e => {
            remoteVideo.srcObject = e.streams[0];
        };
    }

    if (localStream) {
        localStream.getTracks().forEach(track => {
            pc.addTrack(track, localStream);
        });
    }
}

function call(): void {
    if (state === "joinedConn") {
        if (pc) {
            let options: RTCOfferOptions = {
                offerToReceiveAudio: true,
                offerToReceiveVideo: true
            };
            pc.createOffer(options)
                .then(getOffer)
                .catch(handleError);
        }
    }
}

function getOffer(desc: RTCSessionDescription): void {
    pc.setLocalDescription(desc);
    sendMessage(room, desc);
}

function getAnswer(desc: RTCSessionDescription): void {
    pc.setLocalDescription(desc);
    sendMessage(room, desc);
}

function sendMessage(roomId: string, data: any): void {
    console.log("send p2p message:" + roomId + " " + data);
    socket.emit("message", roomId, data);
}

function closeLocalMedia(): void {
    console.log("close local media");

    if (localStream && localStream.getTracks()) {
        localStream.getTracks().forEach(track => {
            track.stop();
        });
        localStream = null;
    }
}

function leave(): void {
    if (socket) {
        socket.emit("leave", room);
    }
    closePeerConnection();
    closeLocalMedia();
    btnConnectServer.disabled = false;
    btnLeave.disabled = true;
}

function closePeerConnection(): void {
    console.log("close peer connection");

    if (pc) {
        pc.close();
        pc = null;
    }
    console.log("close pc");
}