@4players/odin-plugin-web 1.0.0-alpha.2 → 1.0.0-alpha.20

package/lib/common/msgpack.d.ts

@@ -0,0 +1,2 @@
+export declare function getByteSize(buffer: Uint8Array, offset: number): number | undefined;
+export declare function getNextOffset(buffer: Uint8Array, offset: number): number | undefined;

package/lib/common/msgpack.js

@@ -0,0 +1,117 @@
+export function getByteSize(buffer, offset) {
+    const nextOffset = getNextOffset(buffer, offset);
+    return nextOffset !== undefined ? nextOffset - offset : undefined;
+}
+export function getNextOffset(buffer, offset) {
+    if (offset >= buffer.length)
+        return undefined;
+    const tag = buffer[offset++];
+    switch (tag) {
+        case 0xc0:
+        case 0xc2:
+        case 0xc3:
+            return offset;
+        case 0xc4:
+            return skipBytes(buffer, offset + 1, read8bit(buffer, offset));
+        case 0xc5:
+            return skipBytes(buffer, offset + 2, read16bit(buffer, offset));
+        case 0xc6:
+            return skipBytes(buffer, offset + 4, read32bit(buffer, offset));
+        case 0xc7:
+            return skipBytes(buffer, offset + 2, read8bit(buffer, offset));
+        case 0xc8:
+            return skipBytes(buffer, offset + 3, read16bit(buffer, offset));
+        case 0xc9:
+            return skipBytes(buffer, offset + 5, read32bit(buffer, offset));
+        case 0xca:
+            return skipBytes(buffer, offset, 4);
+        case 0xcb:
+            return skipBytes(buffer, offset, 8);
+        case 0xcc:
+            return skipBytes(buffer, offset, 1);
+        case 0xcd:
+            return skipBytes(buffer, offset, 2);
+        case 0xce:
+            return skipBytes(buffer, offset, 4);
+        case 0xcf:
+            return skipBytes(buffer, offset, 8);
+        case 0xd0:
+            return skipBytes(buffer, offset, 1);
+        case 0xd1:
+            return skipBytes(buffer, offset, 2);
+        case 0xd2:
+            return skipBytes(buffer, offset, 4);
+        case 0xd3:
+            return skipBytes(buffer, offset, 8);
+        case 0xd4:
+            return skipBytes(buffer, offset, 2);
+        case 0xd5:
+            return skipBytes(buffer, offset, 3);
+        case 0xd6:
+            return skipBytes(buffer, offset, 5);
+        case 0xd7:
+            return skipBytes(buffer, offset, 9);
+        case 0xd8:
+            return skipBytes(buffer, offset, 17);
+        case 0xd9:
+            return skipBytes(buffer, offset + 1, read8bit(buffer, offset));
+        case 0xda:
+            return skipBytes(buffer, offset + 2, read16bit(buffer, offset));
+        case 0xdb:
+            return skipBytes(buffer, offset + 4, read32bit(buffer, offset));
+        case 0xdc:
+            return skipObjects(buffer, offset + 2, read16bit(buffer, offset));
+        case 0xdd:
+            return skipObjects(buffer, offset + 4, read32bit(buffer, offset));
+        case 0xde:
+            return skipObjects(buffer, offset + 2, read16bit(buffer, offset) * 2);
+        case 0xdf:
+            return skipObjects(buffer, offset + 4, read32bit(buffer, offset) * 2);
+        default:
+            if ((tag & 0x80) === 0x00)
+                return offset;
+            if ((tag & 0xf0) === 0x80) {
+                return skipObjects(buffer, offset, (tag & 0x0f) * 2);
+            }
+            if ((tag & 0xf0) === 0x90)
+                return skipObjects(buffer, offset, tag & 0x0f);
+            if ((tag & 0xe0) === 0xa0)
+                return skipBytes(buffer, offset, tag & 0x1f);
+            if ((tag & 0xe0) === 0xe0)
+                return offset;
+            throw new Error('invalid msgpack');
+    }
+}
+function skipBytes(buffer, offset, bytes) {
+    const newOffset = offset + bytes;
+    return isFinite(newOffset) ? newOffset : undefined;
+}
+function skipObjects(buffer, offset, objects) {
+    if (!isFinite(objects))
+        return undefined;
+    for (let i = 0; i < objects; i++) {
+        const newOffset = getNextOffset(buffer, offset);
+        if (newOffset === undefined)
+            return undefined;
+        offset = newOffset;
+    }
+    return offset;
+}
+function read8bit(bytes, offset) {
+    if (offset > bytes.length)
+        return NaN;
+    return bytes[offset];
+}
+function read16bit(bytes, offset) {
+    if (offset + 2 > bytes.length)
+        return NaN;
+    return (bytes[offset] << 8) | bytes[offset + 1];
+}
+function read32bit(bytes, offset) {
+    if (offset + 4 > bytes.length)
+        return NaN;
+    return ((bytes[offset] << 24) |
+        (bytes[offset + 1] << 16) |
+        (bytes[offset + 2] << 8) |
+        bytes[offset + 3]);
+}

package/{backend/lib → lib/plugin}/config.d.ts

@@ -1,11 +1,12 @@
+import { Logger } from '@4players/odin-common';
 export declare const HealthCheckTimeout = 1000;
 export declare const ClockJumpCheckInterval = 1000;
 export declare const ClockJumpThreshold = 10000;
-export declare const MainConnectionPingInterval = 10000;
-export declare const WebRTCIceTimeout = 3000;
-export declare const WebRTCTimeout = 10000;
+export declare const MainConnectionPingInterval: undefined;
+export declare const WebRtcIceTimeout = 3000;
+export declare const WebRtcTimeout = 10000;
 export declare const ConnectTimeout = 5000;
 export declare const MinTokenLifetime = 60000;
 export declare const MinTokenRefreshInterval = 5000;
 export declare const ConnectInterval: number[];
-//# sourceMappingURL=config.d.ts.map
+export declare const logger: Logger;

package/lib/plugin/config.js

@@ -0,0 +1,22 @@
+import { Logger } from '@4players/odin-common';
+export const HealthCheckTimeout = 1000; /* ms */
+export const ClockJumpCheckInterval = 1000; /* ms */
+export const ClockJumpThreshold = 10000; /* ms */
+export const MainConnectionPingInterval = undefined; /* disabled, was 10000 ms */
+export const WebRtcIceTimeout = 3000; /* ms */
+export const WebRtcTimeout = 10000; /* ms */
+export const ConnectTimeout = 5000; /* ms */
+export const MinTokenLifetime = 60000; /* 1min */
+export const MinTokenRefreshInterval = 5000; /* 5sec */
+export const ConnectInterval = [0, 100, 200, 200, 500, 1000, 2000]; /* ms */
+let loggerInstance;
+const projectName = 'odin-plugin-web';
+function createLogger() {
+    return new Logger(projectName, {
+        tags: [],
+    });
+}
+if (!loggerInstance) {
+    loggerInstance = createLogger();
+}
+export const logger = loggerInstance;

package/{backend/lib → lib/plugin}/connectionPool.d.ts

@@ -1,5 +1,6 @@
-import { DatagramHandler, MainConnection } from './mainConnection';
 import { Result } from '@4players/odin-common';
+import { DatagramHandler, MainConnection } from './mainConnection';
+import { Transport } from './index';
 export declare class ConnectionPool {
     readonly onDatagram: DatagramHandler;
     private _LastConnectionId;
@@ -9,9 +10,8 @@ export declare class ConnectionPool {
     get closed(): boolean;
     constructor(onDatagram: DatagramHandler);
     sendDatagram(connectionId: number, packet: Uint8Array): void;
-    acquireConnection(url: URL, signal: AbortSignal): Promise<Result<MainConnection> | 'closed'>;
+    acquireConnection(transport: Transport, address: string, signal: AbortSignal): Promise<Result<MainConnection> | 'closed'>;
     releaseConnection(connection: MainConnection): void;
     checkHealth(): Promise<void>;
     close(): void;
 }
-//# sourceMappingURL=connectionPool.d.ts.map

package/{backend/lib → lib/plugin}/connectionPool.js

@@ -7,9 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { ClockJumpCheckInterval, ClockJumpThreshold } from './config';
-import { MainConnection } from './mainConnection';
 import { failure, nextTick, success } from '@4players/odin-common';
+import { ClockJumpCheckInterval, ClockJumpThreshold, logger } from './config';
+import { createMainConnection, } from './mainConnection';
 export class ConnectionPool {
     get closed() {
         return this._Close.signal.aborted;
@@ -47,55 +47,72 @@ export class ConnectionPool {
             connection.connection.sendDatagram(packet);
         }
     }
-    acquireConnection(url, signal) {
+    acquireConnection(transport, address, signal) {
         return __awaiter(this, void 0, void 0, function* () {
+            logger.log(['Connection'], 'ConnectionPool.acquireConnection(): transport, address', transport, address);
             yield nextTick(); // slow down acquireConnection
             if (this.closed)
                 return 'closed';
-            let entry = this._ConnectionsByUrl.get(url);
+            const key = create_connection_key(transport, address);
+            let entry = this._ConnectionsByUrl.get(key);
             if (entry === undefined ||
                 (entry.status === 'ready' && entry.connection.closed)) {
+                // Create a new Connection
                 const id = this._LastConnectionId++;
-                const promise = MainConnection.create(id, url, this.onDatagram, signal);
-                entry = { status: 'init', id, promise };
-                this._ConnectionsByUrl.set(url, entry);
+                const promise = createMainConnection(id, transport, address, this.onDatagram, signal);
+                entry = { status: 'init', id, promise, references: 1 };
+                this._ConnectionsByUrl.set(key, entry);
                 this._ConnectionsById.set(id, entry);
                 const connection = yield promise;
+                logger.log(['Connection'], 'ConnectionPool.acquireConnection(): MainConnection resolved.', connection);
                 if (connection.type !== 'Success') {
-                    this._ConnectionsByUrl.delete(url);
+                    this._ConnectionsByUrl.delete(key);
                     this._ConnectionsById.delete(id);
                     return connection;
                 }
-                entry = { status: 'ready', connection: connection.value, references: 1 };
-                this._ConnectionsByUrl.set(url, entry);
+                entry = {
+                    status: 'ready',
+                    connection: connection.value,
+                    references: entry.references,
+                };
+                this._ConnectionsByUrl.set(key, entry);
                 this._ConnectionsById.set(id, entry);
                 return success(entry.connection);
             }
             else if (entry.status === 'init') {
+                logger.log(['Connection'], 'ConnectionPool.acquireConnection(): Found a MainConnection but it is still in init state.');
+                // Wait for the connection to connect
+                entry.references += 1;
                 const onAbort = new Promise((accept) => signal.addEventListener('abort', () => accept(), { once: true }));
                 const result = yield Promise.race([entry.promise, onAbort]);
+                logger.log(['Connection'], 'ConnectionPool.acquireConnection(): MainConnection was in init state but is now resolved', result);
                 if (result === undefined)
                     return failure('aborted');
                 return result;
             }
             else {
+                // Return the connection
+                logger.log(['Connection'], 'ConnectionPool.acquireConnection(): Found a MainConnection and return it');
                 entry.references += 1;
                 return success(entry.connection);
             }
         });
     }
     releaseConnection(connection) {
+        logger.log(['Connection'], 'ConnectionPool.releaseConnection()');
         const entry = this._ConnectionsById.get(connection.id);
+        logger.log(['Connection'], 'ConnectionPool.releaseConnection() entry refs', entry === null || entry === void 0 ? void 0 : entry.references);
         if (entry === undefined)
             return;
         if (entry.status === 'init') {
-            console.error('released connection before it was acquired!');
+            logger.log(['Connection'], 'ConnectionPool.releaseConnection(): MainConnection state is init, return.');
             return;
         }
         entry.references -= 1;
         if (entry.references === 0) {
+            logger.log(['Connection'], 'ConnectionPool.releaseConnection(): References is 0, close the MainConnection.');
             entry.connection.close();
-            this._ConnectionsByUrl.delete(connection.url);
+            this._ConnectionsByUrl.delete(create_connection_key(connection.transport, connection.address));
             this._ConnectionsById.delete(connection.id);
         }
     }
@@ -108,4 +125,6 @@ export class ConnectionPool {
         this._Close.abort();
     }
 }
-//# sourceMappingURL=connectionPool.js.map
+function create_connection_key(transport, address) {
+    return `${transport} ${address}`;
+}

package/lib/plugin/deviceManager.d.ts

@@ -0,0 +1,12 @@
+import { MediaController, Device } from './mediaController';
+import { DeviceParameters } from './index';
+import { Backend, Result } from '@4players/odin-common';
+export declare function openCaptureDevice(controller: MediaController, parameters: DeviceParameters, apm: Backend.ApmConfig): Promise<Result<MediaStreamAudioSourceNode>>;
+export declare function stopMediaStream(ms: MediaStream): void;
+export declare function enumerateDevices(): Promise<Device[]>;
+/**
+ * Requests audio and video browser permissions. Optionally, requests either audio or video permissions.
+ * @private
+ * @throws
+ */
+export declare function requestMediaPermissions(): Promise<boolean>;

package/lib/plugin/deviceManager.js

@@ -0,0 +1,120 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Device } from './mediaController';
+import { logger } from './index';
+import { failure, sleep, success, } from '@4players/odin-common';
+let hasAudioPermissions = false;
+export function openCaptureDevice(controller, parameters, apm) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const deviceId = parameters.device
+            ? { exact: parameters.device.device.deviceId }
+            : undefined;
+        let stream;
+        try {
+            const result = yield Promise.race([
+                navigator.mediaDevices.getUserMedia({
+                    audio: {
+                        echoCancellation: apm.echoCanceller,
+                        noiseSuppression: apm.noiseSuppression !== 'None',
+                        autoGainControl: apm.gainController,
+                        // @ts-ignore chrome fix
+                        echoCancellationType: 'system',
+                        // sampleRate: 48000,
+                        deviceId,
+                    },
+                }),
+                sleep(30000, 'timeout'),
+            ]);
+            if (result === 'timeout')
+                return failure('getUserMedia; timeout');
+            hasAudioPermissions = true;
+            stream = result;
+        }
+        catch (reason) {
+            return failure(`getUserMedia; ${reason}`);
+        }
+        const sampleRate = stream.getAudioTracks()[0].getSettings().sampleRate;
+        const context = yield controller.audioContexts.acquire(sampleRate);
+        return success(context.createMediaStreamSource(stream));
+    });
+}
+export function stopMediaStream(ms) {
+    ms.getTracks().forEach((track) => {
+        track.stop();
+        ms.removeTrack(track);
+    });
+}
+export function enumerateDevices() {
+    return __awaiter(this, void 0, void 0, function* () {
+        hasAudioPermissions = yield requestMediaPermissions();
+        const mediaDeviceInfos = yield navigator.mediaDevices.enumerateDevices();
+        const devices = [];
+        let outputDeviceIndex = 0;
+        let inputDeviceIndex = 0;
+        for (const mediaDeviceInfo of mediaDeviceInfos) {
+            if (mediaDeviceInfo.kind === 'audioinput') {
+                if (inputDeviceIndex === 0) {
+                    devices.push(new Device(mediaDeviceInfo, true));
+                }
+                else {
+                    devices.push(new Device(mediaDeviceInfo, false));
+                }
+                inputDeviceIndex++;
+            }
+            if (mediaDeviceInfo.kind === 'audiooutput') {
+                if (outputDeviceIndex === 0) {
+                    devices.push(new Device(mediaDeviceInfo, true));
+                }
+                else {
+                    devices.push(new Device(mediaDeviceInfo, false));
+                }
+                outputDeviceIndex++;
+            }
+        }
+        return devices;
+    });
+}
+/**
+ * Requests audio and video browser permissions. Optionally, requests either audio or video permissions.
+ * @private
+ * @throws
+ */
+export function requestMediaPermissions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (hasAudioPermissions)
+            return true;
+        const constraints = {};
+        constraints.audio = {
+            sampleRate: undefined,
+            deviceId: '',
+            autoGainControl: false,
+            noiseSuppression: false,
+            advanced: undefined,
+            aspectRatio: undefined,
+            echoCancellation: false,
+            channelCount: 0,
+            facingMode: undefined,
+            frameRate: 0,
+        };
+        logger.debug(['Device'], 'requestMediaPermissions(): constraints', constraints);
+        try {
+            const ms = yield navigator.mediaDevices.getUserMedia(constraints);
+            ms === null || ms === void 0 ? void 0 : ms.getTracks().forEach((track) => {
+                track.stop();
+                ms.removeTrack(track);
+            });
+        }
+        catch (e) {
+            logger.error(['Device'], `requestMediaPermissions(): Requesting permissions for ${'audio'} failed.`, e);
+            return false;
+        }
+        return true;
+    });
+}

package/lib/plugin/h3/mainConnection.d.ts

@@ -0,0 +1,31 @@
+import { ConnectionStatus, type DatagramHandler, type MainConnection } from '../mainConnection';
+import { MainCommands, MainNotifications, PeerId, Result } from '@4players/odin-common';
+import { Transport } from '..';
+import { Token } from '../token';
+import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
+export declare class H3MainConnection implements MainConnection {
+    readonly id: number;
+    readonly address: string;
+    readonly connection: WebTransport;
+    readonly rpc: TypedRpcConnection<MainCommands, MainNotifications>;
+    readonly closeController: AbortController;
+    status: ConnectionStatus;
+    readonly closePromise: Promise<'closed'>;
+    readonly datagramWriter: WritableStreamDefaultWriter<Uint8Array>;
+    get closeSignal(): AbortSignal;
+    get transport(): Transport;
+    get closed(): boolean;
+    static create(id: number, address: string, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
+    private constructor();
+    waitForConnected(): Promise<void>;
+    close(): void;
+    joinRoom(token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]): Promise<'closed' | Result<RpcConnection>>;
+    getReconnectToken(peerId: PeerId): Promise<Result<Token>>;
+    healthCheck(): Promise<boolean>;
+    sendDatagram(datagram: Uint8Array): void;
+    startLocalVideo(mediaId: number, track: MediaStreamTrack): void;
+    stopLocalVideo(mediaId: number): void;
+    startRemoteVideo(mediaId: number): Promise<MediaStreamTrack>;
+    stopRemoteVideo(mediaId: number): void;
+    private _Request;
+}

package/lib/plugin/h3/mainConnection.js

@@ -0,0 +1,195 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ConnectionStatus, } from '../mainConnection';
+import { MainCommandsRpc, MainNotificationsRpc, RoomCommandsRpc, RoomNotificationsRpc, failure, success, } from '@4players/odin-common';
+import { logger, Transport } from '..';
+import { Token } from '../token';
+import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
+import { HealthCheckTimeout } from '../config';
+import * as pkg from '../../../package.json';
+export class H3MainConnection {
+    get closeSignal() {
+        return this.closeController.signal;
+    }
+    get transport() {
+        return Transport.H3;
+    }
+    get closed() {
+        return this.closeSignal.aborted;
+    }
+    static create(id, address, onDatagram, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = new URL(`https://${address}?version=${pkg.version}`);
+                const closeController = new AbortController();
+                signal.addEventListener('abort', () => closeController.abort(), {
+                    once: true,
+                });
+                const connection = new WebTransport(url);
+                closeController.signal.addEventListener('abort', () => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        yield connection.close();
+                    }
+                    catch (_a) {
+                        /* drop silently */
+                    }
+                }), { once: true });
+                yield connection.ready;
+                const stream = yield connection.createBidirectionalStream();
+                const rpc = new TypedRpcConnection(new RpcConnection(stream), MainCommandsRpc, MainNotificationsRpc);
+                closeController.signal.addEventListener('abort', () => rpc.close(), {
+                    once: true,
+                });
+                rpc.notify('Hello', { stream: 'main' });
+                return success(new H3MainConnection(id, address, onDatagram, connection, rpc, closeController));
+            }
+            catch (error) {
+                return failure(`connecting to ${address} failed with ${error}`);
+            }
+        });
+    }
+    constructor(id, address, onDatagram, connection, rpc, closeController) {
+        this.id = id;
+        this.address = address;
+        this.connection = connection;
+        this.rpc = rpc;
+        this.closeController = closeController;
+        this.status = ConnectionStatus.Connecting;
+        logger.info(['Connection', 'H3'], 'H3MainConnection.constructor()');
+        this.closePromise = (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.connection.closed;
+            }
+            catch (_a) {
+                /* drop silently */
+            }
+            return 'closed';
+        }))();
+        this.datagramWriter = connection.datagrams.writable.getWriter();
+        this.connection.closed
+            .then(() => {
+            this.status = ConnectionStatus.Closed;
+        })
+            .catch(() => {
+            /* drop silently */
+        });
+        this.connection.ready
+            .then(() => {
+            this.status = ConnectionStatus.Connected;
+        })
+            .catch(() => {
+            /* drop silently */
+        });
+        readDatagrams(this.connection, this.id, onDatagram);
+    }
+    waitForConnected() {
+        return Promise.race([
+            this.connection.ready,
+            this.connection.closed.then(() => {
+                throw new Error('connection closed');
+            }),
+        ]);
+    }
+    close() {
+        this.closeController.abort('request');
+    }
+    joinRoom(token, roomId, userData, position) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.closed)
+                    return 'closed';
+                const stream = yield this.connection
+                    .createBidirectionalStream()
+                    .catch(() => 'closed');
+                if (stream === 'closed')
+                    return 'closed';
+                const rpc = new TypedRpcConnection(new RpcConnection(stream), RoomCommandsRpc, RoomNotificationsRpc);
+                const response = yield rpc.request('Hello', {
+                    stream: 'room',
+                    token: String(token),
+                    room_id: roomId,
+                    user_data: userData,
+                    position,
+                });
+                if (response === 'closed' || response.type === 'Failure')
+                    return response;
+                return success(rpc.rpcConnection);
+            }
+            catch (error) {
+                return failure(`JoinRoom failed; ${error}`);
+            }
+        });
+    }
+    getReconnectToken(peerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._Request('RequestReconnectToken', {
+                peer_id: peerId,
+            });
+            if (response.type === 'Failure')
+                return response;
+            return Token.parse(response.value);
+        });
+    }
+    healthCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._Request('Ping', {}, HealthCheckTimeout);
+            const success = response !== 'timeout' && response.type === 'Success';
+            if (!success)
+                this.close();
+            return success;
+        });
+    }
+    sendDatagram(datagram) {
+        try {
+            this.datagramWriter.write(datagram);
+        }
+        catch (_a) {
+            /* drop silently */
+        }
+    }
+    startLocalVideo(mediaId, track) {
+        throw new Error('not supported.');
+    }
+    stopLocalVideo(mediaId) {
+        throw new Error('not supported.');
+    }
+    startRemoteVideo(mediaId) {
+        throw new Error('not supported.');
+    }
+    stopRemoteVideo(mediaId) {
+        throw new Error('not supported.');
+    }
+    _Request(name, properties, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield (timeout === undefined
+                ? this.rpc.request(name, properties)
+                : this.rpc.request(name, properties, timeout));
+            if (result === 'closed')
+                return failure('connection lost');
+            return result;
+        });
+    }
+}
+function readDatagrams(connection, connectionId, onDatagram) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const reader = connection.datagrams.readable.getReader();
+            for (;;) {
+                const read = yield reader.read();
+                if (read.done)
+                    break;
+                onDatagram(connectionId, read.value);
+            }
+        }
+        catch (_a) {
+            /* drop silently */
+        }
+    });
+}