@yang__yj/pixelstreaming-core 1.0.0 → 1.0.2

package/src/WebSockets/MessageReceive.ts

@@ -0,0 +1,89 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+/**
+ * 将接收到的消息类型
+ */
+export enum MessageRecvTypes {
+    CONFIG = 'config',
+    STREAMER_LIST = 'streamerList',
+    PLAYER_COUNT = 'playerCount',
+    OFFER = 'offer',
+    ANSWER = 'answer',
+    ICE_CANDIDATE = 'iceCandidate',
+    PEER_DATA_CHANNELS = 'peerDataChannels',
+    PING = 'ping',
+    WARNING = 'warning'
+}
+
+/**
+ * 具体的接收消息包装器
+ */
+export class MessageRecv {
+    type: string;
+    id: string;
+}
+
+/**
+ * 身份验证所需的消息包装器
+ */
+export class MessageAuthRequired extends MessageRecv { }
+
+/**
+ * 配置消息包装器
+ */
+export class MessageConfig extends MessageRecv {
+    peerConnectionOptions: RTCConfiguration;
+}
+
+/**
+ * Streamer列表消息包装器
+ */
+export class MessageStreamerList extends MessageRecv {
+    ids: string[];
+}
+
+/**
+ * 玩家计数消息包装器
+ */
+export class MessagePlayerCount extends MessageRecv {
+    count: number;
+}
+
+/**
+ * Web RTC提供应答消息包装器
+ */
+export class MessageAnswer extends MessageRecv {
+    sdp: string;
+}
+
+/**
+ * WebRTC sdp提供了消息包装器。
+ */
+export class MessageOffer extends MessageRecv {
+    sdp: string;
+    sfu?: boolean;
+    defaultToHover?: string;
+}
+
+/**
+ * Ice候选消息包装器
+ */
+export class MessageIceCandidate extends MessageRecv {
+    candidate: RTCIceCandidateInit;
+}
+
+/**
+ * 对等数据通道消息包装器
+ */
+export class MessagePeerDataChannels extends MessageRecv {
+    recvStreamId: number;
+    sendStreamId: number;
+    type: string;
+}
+
+export class MessageOnScreenKeyboard {
+    command: string;
+    showOnScreenKeyboard: boolean;
+    x: number;
+    y: number;
+}

package/src/WebSockets/MessageSend.ts

@@ -0,0 +1,185 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+import { Logger } from '../Logger/Logger';
+
+/**
+ * 从发信服务器推送的发送类型
+ */
+export enum MessageSendTypes {
+    LIST_STREAMERS = 'listStreamers',
+    SUBSCRIBE = 'subscribe',
+    UNSUBSCRIBE = 'unsubscribe',
+    ICE_CANDIDATE = 'iceCandidate',
+    OFFER = 'offer',
+    ANSWER = 'answer',
+    DATACHANNELREQUEST = 'dataChannelRequest',
+    SFURECVDATACHANNELREADY = 'peerDataChannelsReady',
+    PONG = 'pong'
+}
+
+/**
+ * 要发送到发信服务器的消息的包装器
+ */
+export class MessageSend implements Send {
+    type: string;
+    peerConnectionOptions: object;
+
+    /**
+     * 将包装器转换为JSON字符串
+     * @returns——要发送的消息的JSON字符串
+     */
+    payload() {
+        Logger.Log(
+            Logger.GetStackTrace(),
+            'Sending => \n' + JSON.stringify(this, undefined, 4),
+            6
+        );
+        return JSON.stringify(this);
+    }
+}
+
+export interface Send {
+    /**
+    *将包装器转换为JSON字符串
+    * @returns——要发送的消息的JSON字符串
+     */
+    payload: () => string;
+}
+
+export class MessageListStreamers extends MessageSend {
+    // streamerName: string;
+    constructor() {
+        super();
+        this.type = MessageSendTypes.LIST_STREAMERS;
+        // this.streamerName = 'ProjTestBP52';
+    }
+}
+
+export class requestStreamerObject extends MessageSend {
+    streamerName: string;
+
+    constructor(streamerid: string) {
+        super();
+        this.type = MessageSendTypes.LIST_STREAMERS;
+        this.streamerName = streamerid;
+    }
+}
+
+export class MessageSubscribe extends MessageSend {
+    streamerId: string;
+
+    constructor(streamerid: string) {
+        super();
+        this.type = MessageSendTypes.SUBSCRIBE;
+        this.streamerId = streamerid;
+    }
+}
+
+export class MessageUnsubscribe extends MessageSend {
+    constructor() {
+        super();
+        this.type = MessageSendTypes.UNSUBSCRIBE;
+    }
+}
+
+/**
+ * 实例请求消息包装器
+ */
+export class MessagePong extends MessageSend {
+    time: number;
+
+    constructor(time: number) {
+        super();
+        this.type = MessageSendTypes.PONG;
+        this.time = time;
+    }
+}
+
+/**
+ *  Web RTC提供消息包装器
+ */
+export class MessageWebRTCOffer extends MessageSend {
+    sdp: string;
+
+    /**
+     * @param offer - Generated Web RTC Offer
+     */
+    constructor(offer?: RTCSessionDescriptionInit) {
+        super();
+        this.type = MessageSendTypes.OFFER;
+
+        if (offer) {
+            this.type = offer.type as MessageSendTypes;
+            this.sdp = offer.sdp;
+        }
+    }
+}
+
+/**
+ *  Web RTC应答消息包装器
+ */
+export class MessageWebRTCAnswer extends MessageSend {
+    sdp: string;
+
+    /**
+     * @param answer - Generated Web RTC Offer
+     */
+    constructor(answer?: RTCSessionDescriptionInit) {
+        super();
+        this.type = MessageSendTypes.ANSWER;
+
+        if (answer) {
+            this.type = answer.type as MessageSendTypes;
+            this.sdp = answer.sdp;
+        }
+    }
+}
+
+/**
+ *  Web RTC Data channel request message wrapper
+ */
+export class MessageWebRTCDatachannelRequest extends MessageSend {
+    constructor() {
+        super();
+        this.type = MessageSendTypes.DATACHANNELREQUEST;
+    }
+}
+
+/**
+ *  Web RTC SFU Data channel ready message wrapper
+ */
+export class MessageSFURecvDataChannelReady extends MessageSend {
+    constructor() {
+        super();
+        this.type = MessageSendTypes.SFURECVDATACHANNELREADY;
+    }
+}
+
+/**
+ * RTC Ice Candidate Wrapper
+ */
+export class MessageIceCandidate implements Send {
+    candidate: RTCIceCandidate;
+    type: MessageSendTypes;
+
+    /**
+     * @param candidate - RTC Ice Candidate
+     */
+    constructor(candidate: RTCIceCandidate) {
+        this.type = MessageSendTypes.ICE_CANDIDATE;
+        this.candidate = candidate;
+    }
+
+    /**
+     * Turns the wrapper into a JSON String
+     * @returns - JSON String of the Message to send
+     */
+    payload() {
+        Logger.Log(
+            Logger.GetStackTrace(),
+            'Sending => \n' + JSON.stringify(this, undefined, 4),
+            6
+        );
+        return JSON.stringify(this);
+    }
+}

package/src/WebSockets/SignallingProtocol.ts

@@ -0,0 +1,180 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+import { Logger } from '../Logger/Logger';
+import { WebSocketController } from './WebSocketController';
+import {
+    MessageRecvTypes,
+    MessageConfig,
+    MessageStreamerList,
+    MessagePlayerCount,
+    MessageAnswer,
+    MessageOffer,
+    MessageIceCandidate,
+    MessagePeerDataChannels
+} from './MessageReceive';
+import { MessagePong } from './MessageSend';
+
+/**
+ * 信令协议，用于处理来自信令服务器的消息。
+ */
+export class SignallingProtocol {
+    private FromUEMessageHandlers: Map<string, (payload: string) => void>;
+
+    constructor() {
+        this.FromUEMessageHandlers = new Map<
+            string,
+            (payload: string) => void
+        >();
+    }
+
+    addMessageHandler(
+        messageId: string,
+        messageHandler: (payload: string) => void
+    ) {
+        this.FromUEMessageHandlers.set(messageId, messageHandler);
+    }
+
+    handleMessage(messageId: string, messageData: string) {
+        if (this.FromUEMessageHandlers.has(messageId)) {
+            this.FromUEMessageHandlers.get(messageId)(messageData);
+        } else {
+            Logger.Error(
+                Logger.GetStackTrace(),
+                `Message type of ${messageId} does not have a message handler registered on the frontend - ignoring message.`
+            );
+        }
+    }
+
+    /**
+     * 设置任何默认的信号消息处理，这些可以被覆盖或使用`addMessageHandler`添加额外的处理程序。
+     * @param websocketController 设置这些处理程序的控制器。
+     */
+    static setupDefaultHandlers(websocketController: WebSocketController) {
+        // PING
+        websocketController.signallingProtocol.addMessageHandler(
+            MessageRecvTypes.PING,
+            (pingPayload: string) => {
+                // send our pong payload back to the signalling server
+                const pongPayload = new MessagePong(
+                    new Date().getTime()
+                ).payload();
+                Logger.Log(
+                    Logger.GetStackTrace(),
+                    MessageRecvTypes.PING + ': ' + pingPayload,
+                    6
+                );
+                websocketController.webSocket.send(pongPayload);
+            }
+        );
+
+        // CONFIG
+        websocketController.signallingProtocol.addMessageHandler(
+            MessageRecvTypes.CONFIG,
+            (configPayload: string) => {
+                Logger.Log(Logger.GetStackTrace(), MessageRecvTypes.CONFIG, 6);
+                const config: MessageConfig = JSON.parse(configPayload);
+                websocketController.onConfig(config);
+            }
+        );
+
+        // STREAMER_LIST
+        websocketController.signallingProtocol.addMessageHandler(
+            MessageRecvTypes.STREAMER_LIST,
+            (listPayload: string) => {
+                Logger.Log(
+                    Logger.GetStackTrace(),
+                    MessageRecvTypes.STREAMER_LIST,
+                    6
+                );
+                const streamerList: MessageStreamerList =
+                    JSON.parse(listPayload);
+                websocketController.onStreamerList(streamerList);
+            }
+        );
+
+        // PLAYER_COUNT
+        websocketController.signallingProtocol.addMessageHandler(
+            MessageRecvTypes.PLAYER_COUNT,
+            (playerCountPayload: string) => {
+                Logger.Log(
+                    Logger.GetStackTrace(),
+                    MessageRecvTypes.PLAYER_COUNT,
+                    6
+                );
+                const playerCount: MessagePlayerCount =
+                    JSON.parse(playerCountPayload);
+                Logger.Log(
+                    Logger.GetStackTrace(),
+                    'Player Count: ' + playerCount.count,
+                    6
+                );
+                websocketController.onPlayerCount(playerCount)
+            }
+        );
+
+        // ANSWER
+        websocketController.signallingProtocol.addMessageHandler(
+            MessageRecvTypes.ANSWER,
+            (answerPayload: string) => {
+                // send our pong payload back to the signalling server
+                Logger.Log(Logger.GetStackTrace(), MessageRecvTypes.ANSWER, 6);
+                const answer: MessageAnswer = JSON.parse(answerPayload);
+                websocketController.onWebRtcAnswer(answer);
+            }
+        );
+
+        // OFFER
+        websocketController.signallingProtocol.addMessageHandler(
+            MessageRecvTypes.OFFER,
+            (offerPayload: string) => {
+                // send our pong payload back to the signalling server
+                Logger.Log(Logger.GetStackTrace(), MessageRecvTypes.OFFER, 6);
+                const offer: MessageOffer = JSON.parse(offerPayload);
+                websocketController.onWebRtcOffer(offer);
+            }
+        );
+
+        // ICE CANDIDATE
+        websocketController.signallingProtocol.addMessageHandler(
+            MessageRecvTypes.ICE_CANDIDATE,
+            (iceCandidatePayload: string) => {
+                // send our pong payload back to the signalling server
+                Logger.Log(
+                    Logger.GetStackTrace(),
+                    MessageRecvTypes.ICE_CANDIDATE,
+                    6
+                );
+                const iceCandidate: MessageIceCandidate =
+                    JSON.parse(iceCandidatePayload);
+                websocketController.onIceCandidate(iceCandidate.candidate);
+            }
+        );
+
+        // WARNING
+        websocketController.signallingProtocol.addMessageHandler(
+            MessageRecvTypes.WARNING,
+            (warningPayload: string) => {
+                Logger.Warning(
+                    Logger.GetStackTrace(),
+                    `Warning received: ${warningPayload}`
+                );
+            }
+        );
+
+        // PEER DATA CHANNELS
+        websocketController.signallingProtocol.addMessageHandler(
+            MessageRecvTypes.PEER_DATA_CHANNELS,
+            (peerDataChannelsPayload: string) => {
+                Logger.Log(
+                    Logger.GetStackTrace(),
+                    MessageRecvTypes.PEER_DATA_CHANNELS,
+                    6
+                );
+                const peerDataChannels: MessagePeerDataChannels = JSON.parse(
+                    peerDataChannelsPayload
+                );
+                websocketController.onWebRtcPeerDataChannels(peerDataChannels);
+            }
+        );
+    }
+}