@epicgames-ps/lib-pixelstreamingsignalling-ue5.8 0.1.0

package/src/PlayerConnection.ts

@@ -0,0 +1,257 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import type { IncomingMessage } from 'http';
+import WebSocket from 'ws';
+import {
+    ITransport,
+    WebSocketTransportNJS,
+    SignallingProtocol,
+    MessageHelpers,
+    Messages,
+    BaseMessage
+} from '@epicgames-ps/lib-pixelstreamingcommon-ue5.8';
+import { IPlayer, IPlayerInfo } from './PlayerRegistry';
+import { IStreamer } from './StreamerRegistry';
+import { Logger } from './Logger';
+import * as LogUtils from './LoggingUtils';
+import { SignallingServer } from './SignallingServer';
+
+/**
+ * A connection between the signalling server and a player connection.
+ * This is where messages expected to be handled by the player come in
+ * and where messages are sent to the player.
+ *
+ * Interesting internals:
+ * playerId: The unique id string of this player.
+ * transport: The ITransport where transport events can be subscribed to
+ * protocol: The SignallingProtocol where signalling messages can be
+ * subscribed to.
+ */
+export class PlayerConnection implements IPlayer, LogUtils.IMessageLogger {
+    // The unique id of this player connection.
+    playerId: string;
+    // The websocket transport used by this connection.
+    transport: ITransport;
+    // The protocol abstraction on this connection. Used for sending/receiving signalling messages.
+    protocol: SignallingProtocol;
+    // When the player is subscribed to a streamer this will be the streamer being subscribed to.
+    subscribedStreamer: IStreamer | null;
+    // A descriptive string describing the remote address of this connection.
+    remoteAddress?: string;
+    // The HTTP upgrade request that opened this connection, if available.
+    request?: IncomingMessage;
+
+    private server: SignallingServer;
+    private streamerIdChangeListener: (newId: string) => void;
+    private streamerDisconnectedListener: () => void;
+
+    /**
+     * Initializes a new connection with given and sane values. Adds listeners for the
+     * websocket close and error so it can react by unsubscribing and resetting itself.
+     * @param server - The signalling server object that spawned this player.
+     * @param ws - The websocket coupled to this player connection.
+     * @param remoteAddress - The remote address of this connection. Only used as display.
+     * @param request - The HTTP upgrade request that opened this connection, if available.
+     */
+    constructor(server: SignallingServer, ws: WebSocket, remoteAddress?: string, request?: IncomingMessage) {
+        this.server = server;
+        this.playerId = '';
+        this.subscribedStreamer = null;
+        this.transport = new WebSocketTransportNJS(ws);
+        this.protocol = new SignallingProtocol(this.transport);
+        this.remoteAddress = remoteAddress;
+        this.request = request;
+
+        this.transport.on('error', this.onTransportError.bind(this));
+        this.transport.on('close', this.onTransportClose.bind(this));
+
+        this.streamerIdChangeListener = this.onStreamerIdChanged.bind(this);
+        this.streamerDisconnectedListener = this.onStreamerDisconnected.bind(this);
+
+        this.registerMessageHandlers();
+    }
+
+    /**
+     * Returns an identifier that is displayed in logs.
+     * @returns A string describing this connection.
+     */
+    getReadableIdentifier(): string {
+        return this.playerId;
+    }
+
+    /**
+     * Sends a signalling message to the player.
+     * @param message - The message to send.
+     */
+    sendMessage(message: BaseMessage): void {
+        LogUtils.logOutgoing(this, message);
+        this.protocol.sendMessage(message);
+    }
+
+    /**
+     * Returns a descriptive object for the REST API inspection operations.
+     * @returns An IPlayerInfo object containing viewable information about this connection.
+     */
+    getPlayerInfo(): IPlayerInfo {
+        return {
+            playerId: this.playerId,
+            type: 'Player',
+            subscribedTo: this.subscribedStreamer?.streamerId,
+            remoteAddress: this.remoteAddress
+        };
+    }
+
+    private registerMessageHandlers(): void {
+        /* eslint-disable @typescript-eslint/unbound-method */
+        this.protocol.on(
+            Messages.subscribe.typeName,
+            LogUtils.createHandlerListener(this, this.onSubscribeMessage)
+        );
+        this.protocol.on(
+            Messages.unsubscribe.typeName,
+            LogUtils.createHandlerListener(this, this.onUnsubscribeMessage)
+        );
+        this.protocol.on(
+            Messages.listStreamers.typeName,
+            LogUtils.createHandlerListener(this, this.onListStreamers)
+        );
+        this.protocol.on(Messages.ping.typeName, LogUtils.createHandlerListener(this, this.onPingMessage));
+        /* eslint-enable @typescript-eslint/unbound-method */
+
+        this.protocol.on(Messages.offer.typeName, this.sendToStreamer.bind(this));
+        this.protocol.on(Messages.answer.typeName, this.sendToStreamer.bind(this));
+        this.protocol.on(Messages.iceCandidate.typeName, this.sendToStreamer.bind(this));
+        this.protocol.on(Messages.dataChannelRequest.typeName, this.sendToStreamer.bind(this));
+        this.protocol.on(Messages.peerDataChannelsReady.typeName, this.sendToStreamer.bind(this));
+        this.protocol.on(Messages.layerPreference.typeName, this.sendToStreamer.bind(this));
+
+        this.protocol.on('unhandled', (message: BaseMessage) => {
+            Logger.warn(`Unhandled player protocol message: ${JSON.stringify(message)}`);
+        });
+    }
+
+    private sendToStreamer(message: BaseMessage): void {
+        if (!this.subscribedStreamer) {
+            Logger.warn(
+                `Player ${this.playerId} tried to send to a streamer but they're not subscribed to any.`
+            );
+            const streamerId = this.server.streamerRegistry.getFirstStreamerId();
+            if (!streamerId) {
+                Logger.error('There are no streamers to force a subscription. Disconnecting.');
+                this.disconnect();
+                return;
+            } else {
+                Logger.warn(`Subscribing to ${streamerId}`);
+                this.subscribe(streamerId);
+            }
+        }
+
+        message.playerId = this.playerId;
+        LogUtils.logForward(this, this.subscribedStreamer!, message);
+        this.subscribedStreamer!.protocol.sendMessage(message);
+    }
+
+    private subscribe(streamerId: string) {
+        const streamer = this.server.streamerRegistry.find(streamerId);
+        if (!streamer) {
+            Logger.error(
+                `subscribe: Player ${this.playerId} tried to subscribe to a non-existent streamer ${streamerId}`
+            );
+            const failureMessage = MessageHelpers.createMessage(Messages.subscribeFailed, {
+                message: `Streamer ${streamerId} does not exist.`
+            });
+            this.protocol.sendMessage(failureMessage);
+            return;
+        }
+
+        if (this.subscribedStreamer) {
+            Logger.warn(
+                `subscribe: Player ${this.playerId} is resubscribing to a streamer but is already subscribed to ${this.subscribedStreamer.streamerId}`
+            );
+            this.unsubscribe();
+        }
+
+        if (streamer.maxSubscribers > 0 && streamer.subscribers.size >= streamer.maxSubscribers) {
+            Logger.error(
+                `subscribe: Player ${this.playerId} could not subscribe to ${streamerId}. Max players (${streamer.maxSubscribers}) reached.`
+            );
+            const failureMessage = MessageHelpers.createMessage(Messages.subscribeFailed, {
+                message: `Streamer ${streamerId} is full. Max players = ${streamer.maxSubscribers}.`
+            });
+            this.protocol.sendMessage(failureMessage);
+            return;
+        }
+
+        this.subscribedStreamer = streamer;
+        this.subscribedStreamer.subscribers.add(this.playerId);
+        this.subscribedStreamer.on('id_changed', this.streamerIdChangeListener);
+        this.subscribedStreamer.on('disconnect', this.streamerDisconnectedListener);
+
+        const connectedMessage = MessageHelpers.createMessage(Messages.playerConnected, {
+            playerId: this.playerId,
+            dataChannel: true,
+            sfu: false
+        });
+        this.sendToStreamer(connectedMessage);
+    }
+
+    private unsubscribe() {
+        if (!this.subscribedStreamer) {
+            return;
+        }
+
+        this.subscribedStreamer.subscribers.delete(this.playerId);
+
+        const disconnectedMessage = MessageHelpers.createMessage(Messages.playerDisconnected, {
+            playerId: this.playerId
+        });
+        this.sendToStreamer(disconnectedMessage);
+
+        this.subscribedStreamer.off('id_changed', this.streamerIdChangeListener);
+        this.subscribedStreamer.off('disconnect', this.streamerDisconnectedListener);
+        this.subscribedStreamer = null;
+    }
+
+    private disconnect() {
+        this.unsubscribe();
+        this.protocol.disconnect();
+    }
+
+    private onStreamerDisconnected(): void {
+        this.disconnect();
+    }
+
+    private onTransportError(error: ErrorEvent): void {
+        Logger.error(`Player (${this.playerId}) transport error ${error.message}`);
+    }
+
+    private onTransportClose(_event: CloseEvent): void {
+        Logger.debug('PlayerConnection transport close.');
+        this.disconnect();
+    }
+
+    private onSubscribeMessage(message: Messages.subscribe): void {
+        this.subscribe(message.streamerId);
+    }
+
+    private onUnsubscribeMessage(_message: Messages.unsubscribe): void {
+        this.unsubscribe();
+    }
+
+    private onListStreamers(_message: Messages.listStreamers): void {
+        const listMessage = MessageHelpers.createMessage(Messages.streamerList, {
+            ids: this.server.streamerRegistry.streamers
+                .filter((streamer) => streamer.streaming)
+                .map((streamer) => streamer.streamerId)
+        });
+        this.sendMessage(listMessage);
+    }
+
+    private onStreamerIdChanged(newId: string) {
+        const renameMessage = MessageHelpers.createMessage(Messages.streamerIdChanged, { newID: newId });
+        this.sendMessage(renameMessage);
+    }
+
+    private onPingMessage(message: Messages.ping): void {
+        this.sendMessage(MessageHelpers.createMessage(Messages.pong, { time: message.time }));
+    }
+}

package/src/PlayerRegistry.ts

@@ -0,0 +1,116 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import type { IncomingMessage } from 'http';
+import { SignallingProtocol, BaseMessage, EventEmitter } from '@epicgames-ps/lib-pixelstreamingcommon-ue5.8';
+import { Logger } from './Logger';
+import { IMessageLogger } from './LoggingUtils';
+import { IStreamer } from './StreamerRegistry';
+
+/**
+ * An interface that describes a player that can be added to the
+ * player registry.
+ */
+export interface IPlayer extends IMessageLogger {
+    playerId: string;
+    protocol: SignallingProtocol;
+    subscribedStreamer: IStreamer | null;
+    // The HTTP upgrade request that opened this connection, if available. Lets a consumer-supplied
+    // verifyClient (or other front door) attach an authenticated identity to the request and
+    // recover it here. The signalling server itself does not read this.
+    request?: IncomingMessage;
+
+    sendMessage(message: BaseMessage): void;
+    getPlayerInfo(): IPlayerInfo;
+}
+
+/**
+ * Used by the API to describe the current state of the player.
+ */
+export interface IPlayerInfo {
+    playerId: string;
+    type: string;
+    subscribedTo: string | undefined;
+    remoteAddress: string | undefined;
+}
+
+/**
+ * Handles all the player connections of a signalling server and
+ * can be used to lookup connections by id etc.
+ * Fires events when players are added or removed.
+ * Events:
+ *   'added': (playerId: string) Player was added.
+ *   'removed': (playerId: string) Player was removed.
+ */
+export class PlayerRegistry extends EventEmitter {
+    private players: Map<string, IPlayer> = new Map();
+    private nextPlayerId: number;
+
+    constructor() {
+        super();
+        this.players = new Map();
+        this.nextPlayerId = 0;
+    }
+
+    /**
+     * Assigns a unique id to the player and adds it to the registry
+     */
+    add(player: IPlayer): void {
+        player.playerId = this.getUniquePlayerId();
+        this.players.set(player.playerId, player);
+        this.emit('added', player.playerId);
+        Logger.info(`Registered new player: ${player.playerId}`);
+    }
+
+    /**
+     * Removes a player from the registry. Does nothing if the id
+     * does not exist.
+     */
+    remove(player: IPlayer): void {
+        if (!this.players.has(player.playerId)) {
+            return;
+        }
+
+        this.emit('removed', player.playerId);
+        this.players.delete(player.playerId);
+
+        Logger.info(`Unregistered player: ${player.playerId}`);
+    }
+
+    /**
+     * Tests if a player id exists in the registry.
+     */
+    has(playerId: string): boolean {
+        return this.players.has(playerId);
+    }
+
+    /**
+     * Gets a player from the registry using the player id.
+     * Returns undefined if the player doesn't exist.
+     */
+    get(playerId: string): IPlayer | undefined {
+        return this.players.get(playerId);
+    }
+
+    listPlayers(): IPlayer[] {
+        return Array.from(this.players.values());
+    }
+
+    /**
+     * Returns true when the registry is empty.
+     */
+    empty(): boolean {
+        return this.players.size === 0;
+    }
+
+    /**
+     * Gets the total number of connected players.
+     */
+    count(): number {
+        return this.players.size;
+    }
+
+    private getUniquePlayerId(): string {
+        const newPlayerId = `Player${this.nextPlayerId}`;
+        this.nextPlayerId++;
+        return newPlayerId;
+    }
+}

package/src/SFUConnection.ts

@@ -0,0 +1,329 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import type { IncomingMessage } from 'http';
+import WebSocket from 'ws';
+import {
+    ITransport,
+    WebSocketTransportNJS,
+    SignallingProtocol,
+    MessageHelpers,
+    Messages,
+    BaseMessage,
+    EventEmitter
+} from '@epicgames-ps/lib-pixelstreamingcommon-ue5.8';
+import { IPlayer, IPlayerInfo } from './PlayerRegistry';
+import { IStreamer, IStreamerInfo } from './StreamerRegistry';
+import { Logger } from './Logger';
+import * as LogUtils from './LoggingUtils';
+import { SignallingServer } from './SignallingServer';
+
+/**
+ * A SFU connection to the signalling server.
+ * An SFU can act as both a streamer and a player. It can subscribe to
+ * streamers like a player, and other players can subscribe to the sfu.
+ * Therefore the SFU will have a streamer id and a player id and be
+ * registered in both streamer registries and player registries.
+ *
+ * Interesting internals:
+ * playerId: The player id of this connectiom.
+ * streamerId: The streamer id of this connection.
+ * transport: The ITransport where transport events can be subscribed to
+ * protocol: The SignallingProtocol where signalling messages can be
+ * subscribed to.
+ * streaming: True when the streamer is ready to accept subscriptions.
+ */
+export class SFUConnection extends EventEmitter implements IPlayer, IStreamer, LogUtils.IMessageLogger {
+    // The player id related to this SFU connection.
+    playerId: string;
+    // The streamer id related to this SFU connection.
+    streamerId: string;
+    // The websocket transport used by this connection.
+    transport: ITransport;
+    // The protocol abstraction on this connection. Used for sending/receiving signalling messages.
+    protocol: SignallingProtocol;
+    // True when this SFU is subscribed to another streamer and is ready to be subscribed to itself.
+    streaming: boolean;
+    // When the player is subscribed to a streamer this will be the streamer being subscribed to.
+    subscribedStreamer: IStreamer | null;
+    // A descriptive string describing the remote address of this connection.
+    remoteAddress?: string;
+    // The HTTP upgrade request that opened this connection, if available.
+    request?: IncomingMessage;
+    // The max number of subscribed players at a time. A value of 0 means there is no limit (this the default).
+    maxSubscribers: number;
+    // A list of all the current subscribed players.
+    subscribers: Set<string>;
+
+    private server: SignallingServer;
+    private layerPreferenceListener: (message: Messages.layerPreference) => void;
+    private streamerIdChangeListener: (newId: string) => void;
+    private streamerDisconnectedListener: () => void;
+
+    /**
+     * Construct a new SFU connection.
+     * @param server - The signalling server object that spawned this sfu.
+     * @param ws - The websocket coupled to this sfu connection.
+     * @param remoteAddress - The remote address of this connection. Only used as display.
+     * @param request - The HTTP upgrade request that opened this connection, if available.
+     */
+    constructor(server: SignallingServer, ws: WebSocket, remoteAddress?: string, request?: IncomingMessage) {
+        super();
+
+        this.server = server;
+        this.transport = new WebSocketTransportNJS(ws);
+        this.protocol = new SignallingProtocol(this.transport);
+        this.playerId = '';
+        this.streamerId = '';
+        this.streaming = false;
+        this.remoteAddress = remoteAddress;
+        this.request = request;
+        this.subscribedStreamer = null;
+        this.maxSubscribers = 0;
+        this.subscribers = new Set();
+
+        this.transport.on('error', this.onTransportError.bind(this));
+        this.transport.on('close', this.onTransportClose.bind(this));
+
+        this.layerPreferenceListener = this.onLayerPreference.bind(this);
+        this.streamerIdChangeListener = this.onStreamerIdChanged.bind(this);
+        this.streamerDisconnectedListener = this.onStreamerDisconnected.bind(this);
+
+        this.registerMessageHandlers();
+    }
+
+    /**
+     * Returns an identifier that is displayed in logs.
+     * @returns A string describing this connection.
+     */
+    getReadableIdentifier(): string {
+        return `(${this.streamerId}:${this.playerId})`;
+    }
+
+    /**
+     * Sends a signalling message to the SFU.
+     * @param message - The message to send.
+     */
+    sendMessage(message: BaseMessage): void {
+        LogUtils.logOutgoing(this, message);
+        this.protocol.sendMessage(message);
+    }
+
+    /**
+     * Returns a descriptive object for the REST API inspection operations.
+     * @returns An IStreamerInfo object containing viewable information about this connection.
+     */
+    getStreamerInfo(): IStreamerInfo {
+        return {
+            streamerId: this.streamerId,
+            type: 'SFU',
+            streaming: this.streaming,
+            remoteAddress: this.remoteAddress,
+            subscribers: this.server.playerRegistry
+                .listPlayers()
+                .filter((player) => player.subscribedStreamer == this)
+                .map((player) => player.getPlayerInfo())
+        };
+    }
+
+    /**
+     * Returns a descriptive object for the REST API inspection operations.
+     * @returns An IPlayerInfo object containing viewable information about this connection.
+     */
+    getPlayerInfo(): IPlayerInfo {
+        return {
+            playerId: this.playerId,
+            type: 'SFU',
+            remoteAddress: this.remoteAddress,
+            subscribedTo: this.subscribedStreamer?.streamerId
+        };
+    }
+
+    private registerMessageHandlers(): void {
+        /* eslint-disable @typescript-eslint/unbound-method */
+        this.protocol.on(
+            Messages.subscribe.typeName,
+            LogUtils.createHandlerListener(this, this.onSubscribeMessage)
+        );
+        this.protocol.on(
+            Messages.unsubscribe.typeName,
+            LogUtils.createHandlerListener(this, this.onUnsubscribeMessage)
+        );
+        this.protocol.on(
+            Messages.listStreamers.typeName,
+            LogUtils.createHandlerListener(this, this.onListStreamers)
+        );
+        this.protocol.on(
+            Messages.endpointId.typeName,
+            LogUtils.createHandlerListener(this, this.onEndpointId)
+        );
+        this.protocol.on(
+            Messages.streamerDataChannels.typeName,
+            LogUtils.createHandlerListener(this, this.onStreamerDataChannels)
+        );
+        this.protocol.on(
+            Messages.startStreaming.typeName,
+            LogUtils.createHandlerListener(this, this.onStartStreaming)
+        );
+        this.protocol.on(
+            Messages.stopStreaming.typeName,
+            LogUtils.createHandlerListener(this, this.onStopStreaming)
+        );
+        this.protocol.on(Messages.ping.typeName, LogUtils.createHandlerListener(this, this.onPingMessage));
+        /* eslint-enable @typescript-eslint/unbound-method */
+
+        this.protocol.on(Messages.offer.typeName, this.sendToPlayer.bind(this));
+        this.protocol.on(Messages.answer.typeName, this.sendToStreamer.bind(this));
+        this.protocol.on(Messages.peerDataChannels.typeName, this.sendToPlayer.bind(this));
+    }
+
+    private subscribe(streamerId: string) {
+        const streamer = this.server.streamerRegistry.find(streamerId);
+        if (!streamer) {
+            Logger.error(
+                `subscribe: SFU ${this.playerId} tried to subscribe to a non-existent streamer ${streamerId}`
+            );
+            return;
+        }
+
+        this.subscribedStreamer = streamer;
+        // Register as a subscriber of the upstream streamer so it will forward signalling messages
+        // back to this SFU (the streamer's forwardMessage only sends to subscribed players).
+        this.subscribedStreamer.subscribers.add(this.playerId);
+        this.subscribedStreamer.on('layer_preference', this.layerPreferenceListener);
+        this.subscribedStreamer.on('id_changed', this.streamerIdChangeListener);
+        this.subscribedStreamer.on('disconnect', this.streamerDisconnectedListener);
+
+        const connectedMessage = MessageHelpers.createMessage(Messages.playerConnected, {
+            playerId: this.playerId,
+            dataChannel: true,
+            sfu: true
+        });
+        this.sendToStreamer(connectedMessage);
+    }
+
+    private unsubscribe() {
+        if (!this.subscribedStreamer) {
+            return;
+        }
+
+        const disconnectedMessage = MessageHelpers.createMessage(Messages.playerDisconnected, {
+            playerId: this.playerId
+        });
+        this.sendToStreamer(disconnectedMessage);
+
+        this.subscribedStreamer.subscribers.delete(this.playerId);
+        this.subscribedStreamer.off('layer_preference', this.layerPreferenceListener);
+        this.subscribedStreamer.off('id_changed', this.streamerIdChangeListener);
+        this.subscribedStreamer.off('disconnect', this.streamerDisconnectedListener);
+        this.subscribedStreamer = null;
+    }
+
+    private sendToStreamer(message: BaseMessage): void {
+        if (!this.subscribedStreamer) {
+            Logger.error(
+                `SFU ${this.playerId} tried to send to a streamer but they're not subscribed to any.`
+            );
+            return;
+        }
+
+        LogUtils.logForward(this, this.subscribedStreamer, message);
+
+        // normally we want to indicate what player this message came from
+        // but in some instances we might already have set this (streamerDataChannels) due to poor choices
+        message.playerId = message.playerId || this.playerId;
+
+        this.subscribedStreamer.protocol.sendMessage(message);
+    }
+
+    private sendToPlayer(message: BaseMessage): void {
+        if (!message.playerId) {
+            Logger.error(
+                `SFU ${this.streamerId} trying to send a message to a player with no playerId. Ignored.`
+            );
+            return;
+        }
+        if (!this.subscribers.has(message.playerId)) {
+            // Only send to players subscribed to this SFU, otherwise the SFU could target any player
+            // on the server via the global player registry (cross-tenant signalling).
+            Logger.error(
+                `SFU ${this.streamerId} tried to send a message to player ${message.playerId} which is not subscribed to it. Ignored.`
+            );
+            return;
+        }
+        const player = this.server.playerRegistry.get(message.playerId);
+        if (player) {
+            delete message.playerId;
+            LogUtils.logForward(this, player, message);
+            player.protocol.sendMessage(message);
+        } else {
+            Logger.error(`SFU attempted to forward to player ${message.playerId} which does not exist.`);
+        }
+    }
+
+    private disconnect() {
+        this.unsubscribe();
+        this.protocol.disconnect();
+        this.emit('disconnect');
+    }
+
+    private onLayerPreference(message: Messages.layerPreference): void {
+        this.sendMessage(message);
+    }
+
+    private onStreamerIdChanged(newId: string): void {
+        const renameMessage = MessageHelpers.createMessage(Messages.streamerIdChanged, { newID: newId });
+        this.sendMessage(renameMessage);
+    }
+
+    private onStreamerDisconnected(): void {
+        this.unsubscribe();
+        this.sendMessage(MessageHelpers.createMessage(Messages.streamerDisconnected));
+        this.streaming = false;
+        this.emit('disconnect');
+    }
+
+    private onTransportError(error: ErrorEvent): void {
+        Logger.error(`SFU (${this.playerId}) transport error ${error.message}`);
+    }
+
+    private onTransportClose(_event: CloseEvent): void {
+        Logger.debug('SFUConnection transport close.');
+        this.disconnect();
+    }
+
+    private onSubscribeMessage(message: Messages.subscribe): void {
+        this.subscribe(message.streamerId);
+    }
+
+    private onUnsubscribeMessage(_message: Messages.unsubscribe): void {
+        this.unsubscribe();
+    }
+
+    private onListStreamers(_message: Messages.listStreamers): void {
+        const listMessage = MessageHelpers.createMessage(Messages.streamerList, {
+            ids: this.server.streamerRegistry.streamers.map((streamer) => streamer.streamerId)
+        });
+        this.sendMessage(listMessage);
+    }
+
+    private onStreamerDataChannels(message: Messages.streamerDataChannels): void {
+        message.sfuId = this.playerId!;
+        this.sendToStreamer(message);
+    }
+
+    private onEndpointId(_message: Messages.endpointId): void {
+        this.streaming = true;
+    }
+
+    private onStartStreaming(_message: Messages.startStreaming): void {
+        this.streaming = true;
+    }
+
+    private onStopStreaming(_message: Messages.stopStreaming): void {
+        this.streaming = false;
+        this.emit('disconnect');
+    }
+
+    private onPingMessage(message: Messages.ping): void {
+        this.sendMessage(MessageHelpers.createMessage(Messages.pong, { time: message.time }));
+    }
+}