@4players/odin-plugin-web 1.0.0-alpha.13 → 1.0.0-alpha.15

package/lib/plugin/webrtc/mainConnection.js

@@ -0,0 +1,455 @@
+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 { MainCommandsRpc, MainNotificationsRpc, assert, extendUrl, failure, success, fail, Backend, } from '@4players/odin-common';
+import { ConnectionStatus, } from '../mainConnection';
+import { Token } from '../token';
+import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
+import { connect } from './websocket';
+import { HealthCheckTimeout, logger, MainConnectionPingInterval, WebRtcIceTimeout, WebRtcTimeout, } from '../config';
+var Transport = Backend.Transport;
+export class WebRtcMainConnection {
+    static create(id, address, onDatagram, signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (signal.aborted)
+                return failure('aborted');
+            let url;
+            try {
+                url = new URL(`wss://${address}`);
+            }
+            catch (error) {
+                return fail(`address in token(${address}) can not be parsed; ${error}`);
+            }
+            const webSocketUrl = extendUrl(url, 'main');
+            if (webSocketUrl.type !== 'Success')
+                return webSocketUrl;
+            const webSocket = yield connect(webSocketUrl.value, signal);
+            if (webSocket.type !== 'Success')
+                return webSocket;
+            const connection = new TypedRpcConnection(new RpcConnection(webSocket.value), MainCommandsRpc, MainNotificationsRpc);
+            try {
+                return success(new WebRtcMainConnection(id, address, url, onDatagram, connection, new RTCPeerConnection()));
+            }
+            catch (reason) {
+                connection.close();
+                return failure(`unable to create webrtc connection; ${reason}`);
+            }
+        });
+    }
+    get transport() {
+        return Transport.H3;
+    }
+    get closePromise() {
+        return this._ClosePromise;
+    }
+    get closeSignal() {
+        return this.connection.closeSignal;
+    }
+    get closed() {
+        return this.connection.closed;
+    }
+    get status() {
+        switch (this.webRtc.connectionState) {
+            case 'connected':
+                return ConnectionStatus.Connected;
+            case 'failed':
+            case 'closed':
+                return ConnectionStatus.Closed;
+            default:
+                return ConnectionStatus.Connecting;
+        }
+    }
+    waitForConnected() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const onConnectionStateChanged = () => {
+                    const status = this.status;
+                    if (status === ConnectionStatus.Connecting)
+                        return;
+                    this.webRtc.removeEventListener('connectionstatechange', onConnectionStateChanged);
+                    if (status === ConnectionStatus.Connected) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error('connection closed'));
+                    }
+                };
+                this.webRtc.addEventListener('connectionstatechange', onConnectionStateChanged);
+                onConnectionStateChanged();
+            });
+        });
+    }
+    constructor(id, address, url, onDatagram, connection, webRtc) {
+        this.id = id;
+        this.address = address;
+        this.url = url;
+        this.onDatagram = onDatagram;
+        this.connection = connection;
+        this.webRtc = webRtc;
+        this._PeerIdMap = new WeakMap();
+        this._LocalVideos = new Map();
+        this._RemoteVideos = new Map();
+        this._Negotiation = { requested: false, running: false };
+        this._awaitingRemoteTracks = new Map();
+        logger.info(['Connection', 'WebRTC'], 'WebRtcMainConnection.constructor()');
+        this.closeSignal.addEventListener('abort', () => this._CleanUp(), {
+            once: true,
+        });
+        this._ClosePromise = new Promise((accept) => {
+            this.closeSignal.addEventListener('abort', () => {
+                logger.debug(['Connection', 'WebRTC'], 'WebRtcMainConnection.constructor(): _ClosePromise aborted');
+                accept('closed');
+            }, {
+                once: true,
+            });
+        });
+        this._AudioChannel = this.webRtc.createDataChannel('audio', {
+            id: 2,
+            negotiated: true,
+            ordered: false,
+            maxRetransmits: 0,
+        });
+        this._AudioChannel.binaryType = 'arraybuffer';
+        this._AudioChannel.onmessage = (event) => onDatagram(this.id, new Uint8Array(event.data));
+        this.webRtc.onicecandidate = this._OnIceCandidate.bind(this);
+        this.webRtc.onconnectionstatechange = () => this._OnWebRtcStatusChanged();
+        this.webRtc.ontrack = this.onTrack.bind(this);
+        this._SendOffer();
+        if (MainConnectionPingInterval !== undefined) {
+            this._PeriodicHealthCheck = setInterval(() => this.healthCheck(), MainConnectionPingInterval);
+        }
+        this._readWebRtcUpdate();
+    }
+    close() {
+        console.debug('MainConnection close(): ', this._PeerIdMap);
+        logger.log(['WebRTC', 'Connection'], 'MainConnection close(): ', this._PeerIdMap);
+        this.connection.close();
+    }
+    joinRoom(token, roomId, userData, position) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.info(['Connection', 'WebRTC'], 'WebRtcMainConnection.joinRoom()');
+            const response = yield this.connection.request('JoinRoom', {
+                token: String(token),
+                room_id: roomId,
+                user_data: userData,
+                position,
+            });
+            if (response === 'closed' || response.type === 'Failure')
+                return response;
+            const responseValue = response.value;
+            if (!('token' in responseValue)) {
+                return failure('JoinRoom responded without token');
+            }
+            const url = extendUrl(this.url, `room?token=${responseValue.token}`);
+            if (url.type === 'Failure')
+                return url;
+            const webSocket = yield connect(url.value, this.closeSignal);
+            if (webSocket.type === 'Success') {
+                this._PeerIdMap.set(webSocket.value, responseValue.peer_id);
+                return success(new RpcConnection(webSocket.value));
+            }
+            else {
+                return webSocket;
+            }
+        });
+    }
+    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);
+        });
+    }
+    sendDatagram(datagram) {
+        if (this._AudioChannel.readyState === 'open') {
+            this._AudioChannel.send(datagram);
+        }
+    }
+    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;
+        });
+    }
+    _Request(name, properties, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield (timeout === undefined
+                ? this.connection.request(name, properties)
+                : this.connection.request(name, properties, timeout));
+            if (result === 'closed')
+                return failure('connection lost');
+            return result;
+        });
+    }
+    _readWebRtcUpdate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (true) {
+                const event = yield this.connection.recv();
+                if (event === 'closed')
+                    break;
+                if (event.name === 'WebRtcUpdate') {
+                    this._OnWebRtcUpdate(event.properties);
+                }
+            }
+            this.close();
+        });
+    }
+    _SendOffer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.ensureTransceivers();
+            try {
+                const offer = yield this.webRtc.createOffer();
+                assert(offer.type === 'offer' && offer.sdp, 'Generated broken webrtc offer');
+                yield this.webRtc.setLocalDescription(offer);
+                const sdp = (_a = offer.sdp) !== null && _a !== void 0 ? _a : '';
+                const media_map = [];
+                for (const [media_id, { transceiver }] of this._LocalVideos) {
+                    media_map.push([media_id, transceiver.mid]);
+                }
+                logger.info(['Connection', 'WebRTC'], 'WebRtcMainConnection._sendOffer(): media_map', media_map);
+                yield this._Request('WebRtcUpdate', {
+                    kind: 'Sdp',
+                    type: 'Offer',
+                    sdp,
+                    media_map,
+                });
+            }
+            catch (_b) {
+                logger.error(['Connection', 'WebRTC'], 'WebRtcMainConnection._sendOffer(): Failed creating an offer');
+            }
+        });
+    }
+    _OnWebRtcStatusChanged() {
+        logger.info(['WebRTC', 'Connection'], `WebRtcMainConnection._OnWebRtcStatusChanged(): ${this.webRtc.connectionState}`);
+        switch (this.webRtc.connectionState) {
+            case 'closed':
+            case 'failed':
+                this.close();
+                break;
+            case 'connected':
+                clearTimeout(this._WebRtcIceTimeout);
+                this._WebRtcIceTimeout = undefined;
+                clearTimeout(this._WebRtcTimeout);
+                this._WebRtcTimeout = undefined;
+                break;
+            case 'disconnected':
+                if (typeof MainConnectionPingInterval !== 'undefined') {
+                    this.healthCheck().then();
+                }
+            // falls through
+            default:
+                if (this._WebRtcIceTimeout === undefined) {
+                    // Gets removed after successfully connected
+                    this._WebRtcIceTimeout = setTimeout(() => {
+                        logger.info(['WebRTC', 'Connection'], 'WebRtcMainConnection._OnWebRtcStatusChanged(): _WebRtcIceTimeout was reached');
+                        this.webRtc.restartIce();
+                        this._WebRtcIceTimeout = undefined;
+                    }, WebRtcIceTimeout);
+                }
+                // Gets removed after successfully connected
+                if (this._WebRtcTimeout === undefined) {
+                    this._WebRtcTimeout = setTimeout(() => {
+                        logger.info(['WebRTC', 'Connection'], 'WebRtcMainConnection._OnWebRtcStatusChanged(): _WebRtcTimeout was reached');
+                        this.close();
+                    }, WebRtcTimeout);
+                }
+                break;
+        }
+    }
+    _OnWebRtcUpdate(update) {
+        switch (update.kind) {
+            case 'Sdp':
+                this._UpdateRemoteSdp(update);
+                break;
+            case 'Trickle':
+                this._AddIceCandidate(update);
+                break;
+            case 'TrickleFinished':
+                this.webRtc.addIceCandidate(undefined);
+                break;
+        }
+    }
+    _UpdateRemoteSdp(update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger.info(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection._UpdateRemoteSdp(): update.media_map, this._RemoteVideos', update.media_map, this._RemoteVideos);
+            let remoteChanged = false;
+            for (const [media_id, mid] of update.media_map) {
+                const entry = this._RemoteVideos.get(media_id);
+                if ((entry === null || entry === void 0 ? void 0 : entry.state) === 'Requested') {
+                    remoteChanged = true;
+                    this._RemoteVideos.set(media_id, {
+                        state: 'Mapped',
+                        mid,
+                        promise: entry.promise,
+                    });
+                }
+            }
+            const type = update.type === 'Answer' ? 'answer' : 'offer';
+            // Set runnig to false
+            logger.info(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection._UpdateRemoteSdp(): remoteChanged: ', remoteChanged);
+            (_a = this._ResolveOffer) === null || _a === void 0 ? void 0 : _a.call(this, true);
+            yield this.webRtc.setRemoteDescription({ type, sdp: update.sdp });
+        });
+    }
+    _AddIceCandidate(candidate) {
+        var _a, _b, _c;
+        const candidateInit = {
+            candidate: candidate.candidate,
+            sdpMid: (_a = candidate.spd_mid) !== null && _a !== void 0 ? _a : undefined,
+            sdpMLineIndex: (_b = candidate.spd_mline_index) !== null && _b !== void 0 ? _b : undefined,
+            usernameFragment: (_c = candidate.username_fragment) !== null && _c !== void 0 ? _c : undefined,
+        };
+        // HACK/TODO(max): find out why the server is not sending sdpMid or sdpMLineIndex
+        if (candidateInit.sdpMid === undefined &&
+            candidateInit.sdpMLineIndex === undefined) {
+            candidateInit.sdpMid = '0';
+        }
+        this.webRtc.addIceCandidate(candidateInit);
+    }
+    _OnIceCandidate(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (event.candidate) {
+                const { candidate, sdpMid, sdpMLineIndex, usernameFragment } = event.candidate;
+                this._Request('WebRtcUpdate', {
+                    kind: 'Trickle',
+                    candidate,
+                    spd_mid: sdpMid !== null && sdpMid !== void 0 ? sdpMid : undefined,
+                    spd_mline_index: sdpMLineIndex !== null && sdpMLineIndex !== void 0 ? sdpMLineIndex : undefined,
+                    username_fragment: usernameFragment !== null && usernameFragment !== void 0 ? usernameFragment : undefined,
+                });
+            }
+            else {
+                this._Request('WebRtcUpdate', { kind: 'TrickleFinished' });
+            }
+        });
+    }
+    ensureTransceivers() {
+        const needed = this._LocalVideos.size + this._RemoteVideos.size;
+        const available = this.webRtc.getTransceivers().length;
+        for (let i = available; i < needed; i++) {
+            this.webRtc.addTransceiver('video');
+        }
+    }
+    startLocalVideo(mediaId, track) {
+        return __awaiter(this, void 0, void 0, function* () {
+            assert(!this._LocalVideos.has(mediaId), `No LocalVideo with mediaID ${mediaId}`);
+            logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.startLocalVideo(): ', mediaId);
+            let transceiver = this.webRtc
+                .getTransceivers()
+                .find((transceiver) => transceiver.sender.track === track);
+            if (transceiver) {
+                logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.startLocalVideo(): Transceiver found -> replaceTrack.');
+                yield transceiver.sender.replaceTrack(track);
+            }
+            else {
+                const sender = this.webRtc.addTrack(track);
+                transceiver = this.webRtc
+                    .getTransceivers()
+                    .find((transceiver) => transceiver.sender === sender);
+                assert(transceiver, '');
+            }
+            this._LocalVideos.set(mediaId, { transceiver });
+            this.requestNegotiation(false);
+        });
+    }
+    stopLocalVideo(mediaId) {
+        const localVideo = this._LocalVideos.get(mediaId);
+        if (!localVideo)
+            return;
+        localVideo.transceiver.sender.track.enabled = false;
+        this._LocalVideos.delete(mediaId);
+        this.requestNegotiation(false);
+    }
+    startRemoteVideo(mediaId) {
+        logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.startRemoteVideo()');
+        this.requestNegotiation(true);
+        return new Promise((resolve, reject) => {
+            this._RemoteVideos.set(mediaId, {
+                state: 'Requested',
+                promise: { resolve, reject },
+            });
+        });
+    }
+    stopRemoteVideo(mediaId) {
+        const video = this._RemoteVideos.get(mediaId);
+        if (!video)
+            return;
+        this._RemoteVideos.delete(mediaId);
+        if (video.state !== 'Active') {
+            video.promise.reject(new Error('video stopped'));
+        }
+        this.requestNegotiation(false);
+    }
+    onTrack(event) {
+        // If there was no entry found, store the track until a remote Video was started.
+        // When starting a remote Video, check if there is already a track available.
+        logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.onTrack(): RemoteVideos: ', this._RemoteVideos);
+        const entry = Array.from(this._RemoteVideos).find((video) => {
+            return (video[1].state === 'Mapped' && video[1].mid === event.transceiver.mid);
+        });
+        logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.onTrack(): Found the RemoteVideo', entry);
+        if (entry === undefined) {
+            logger.warn(['WebRTC', 'Connection', 'Video'], `WebRtcMainConnection.onTrack(): Unexpected track(mid: ${event.transceiver.mid})`);
+            return;
+        }
+        const [media_id, video] = entry;
+        assert(video.state === 'Mapped', '');
+        this._RemoteVideos.set(media_id, {
+            state: 'Active',
+            transceiver: event.transceiver,
+        });
+        event.track.onended = () => logger.debug(['WebRTC', 'Connection', 'Video'], `WebRtcMainConnection.onTrack(): Track ended ${event.transceiver.mid}`, entry);
+        video.promise.resolve(event.track);
+    }
+    requestNegotiation(waitForAnswer) {
+        logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.requestNegotiation():');
+        this._Negotiation.requested = true;
+        if (this._Negotiation.running)
+            return;
+        this._Negotiation.running = true;
+        setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+            this._Negotiation.requested = false;
+            try {
+                yield this._SendOffer();
+                if (waitForAnswer) {
+                    yield new Promise((resolve) => {
+                        this._ResolveOffer = resolve;
+                    });
+                }
+            }
+            finally {
+                logger.debug(['WebRTC', 'Connection', 'Video'], 'WebRtcMainConnection.requestNegotiation(): Finally');
+                this._Negotiation.running = false;
+                // @TODO Check if the retry is still needed.
+                const retry = Array.from(this._RemoteVideos).find((video) => {
+                    return video[1].state === 'Requested';
+                });
+                if (this._Negotiation.requested) {
+                    this.requestNegotiation(waitForAnswer);
+                }
+            }
+        }));
+    }
+    _CleanUp() {
+        console.debug(`${this.url} closed`);
+        this.connection.close();
+        this.webRtc.close();
+        clearInterval(this._PeriodicHealthCheck);
+        clearTimeout(this._WebRtcIceTimeout);
+        clearTimeout(this._WebRtcTimeout);
+    }
+}

package/lib/plugin/{websocket.js → webrtc/websocket.js}

@@ -7,13 +7,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { ConnectInterval } from './config';
+import { ConnectInterval } from '../config';
 import { abortableSleep, failure, success, } from '@4players/odin-common';
 export function connect(url, signal) {
     return __awaiter(this, void 0, void 0, function* () {
         const start = performance.now();
         let connection = failure('no connection was attempted');
-        for (let failures = 0; failures < ConnectInterval.length && signal.aborted === false; failures++) {
+        for (let failures = 0; failures < ConnectInterval.length && !signal.aborted; failures++) {
             const nextReconnectAt = start + whenToConnect(failures);
             if ((yield abortableSleep(nextReconnectAt - performance.now(), signal)) ===
                 'aborted') {

package/lib/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "1.0.0-alpha.15";

package/lib/version.js

@@ -0,0 +1,2 @@
+// Generated by genversion.
+export const version = '1.0.0-alpha.15';