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

package/lib/plugin/rpcConnection.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { failure, success, msgpackEncode, msgpackDecode, MessagePackRpcSchema, } from '@4players/odin-common';
+import { getByteSize } from '../common/msgpack';
 export class RpcConnection {
     get closed() {
         return this._Close.signal.aborted;
@@ -16,17 +17,24 @@ export class RpcConnection {
     get closeSignal() {
         return this._Close.signal;
     }
-    constructor(webSocket) {
-        this.webSocket = webSocket;
+    constructor(stream) {
+        this.stream = stream;
         this._SendQueue = [];
         this._RecvQueue = [];
+        this._EventQueue = [];
         this._Requests = new Map();
         this._Close = new AbortController();
         this._NextId = 1;
-        this.webSocket.addEventListener('open', this._OnWebSocketOpen.bind(this));
-        this.webSocket.addEventListener('close', this.close.bind(this));
-        this.webSocket.addEventListener('message', this._OnWebSocketMessage.bind(this));
-        this.webSocket.binaryType = 'arraybuffer';
+        if (stream instanceof WebSocket) {
+            stream.addEventListener('open', this._OnWebSocketOpen.bind(this));
+            stream.addEventListener('close', this.close.bind(this));
+            stream.addEventListener('message', (event) => this._OnRpcMessage(event.data));
+            stream.binaryType = 'arraybuffer';
+        }
+        else {
+            readRpcFromStream(stream.readable.getReader(), this._OnRpcMessage.bind(this)).finally(this.close.bind(this));
+            this._Writer = stream.writable.getWriter();
+        }
         this._Close.signal.addEventListener('abort', this._Cleanup.bind(this), {
             once: true,
         });
@@ -48,16 +56,20 @@ export class RpcConnection {
         });
     }
     notify(name, properties) {
-        if (this.closed === false) {
+        if (!this.closed) {
             this._Send([2, name, properties]);
         }
     }
     recv() {
-        if (this.closed === false) {
-            return new Promise((accept) => this._RecvQueue.push(accept));
+        if (this.closed) {
+            return Promise.resolve('closed');
+        }
+        const event = this._EventQueue.shift();
+        if (event !== undefined) {
+            return Promise.resolve(event);
         }
         else {
-            return Promise.resolve('closed');
+            return new Promise((accept) => this._RecvQueue.push(accept));
         }
     }
     close() {
@@ -72,18 +84,26 @@ export class RpcConnection {
         request.accept('timeout');
     }
     _Send(message) {
-        this.webSocket.send(msgpackEncode(message));
+        const encoded = message instanceof Uint8Array
+            ? message
+            : new Uint8Array(msgpackEncode(message));
+        if (this.stream instanceof WebSocket) {
+            this.stream.send(encoded);
+        }
+        else {
+            this._Writer.write(encoded);
+        }
     }
     _OnWebSocketOpen(ev) {
-        for (const data in this._SendQueue) {
-            this.webSocket.send(data);
+        for (const data of this._SendQueue) {
+            this._Send(data);
         }
         this._SendQueue.length = 0;
     }
-    _OnWebSocketMessage(ev) {
-        const rpc = parseRpc(ev.data);
+    _OnRpcMessage(bytes) {
+        const rpc = parseRpc(bytes);
         if (rpc.type !== 'Success') {
-            this.webSocket.close();
+            this.close();
             return;
         }
         switch (rpc.value[0]) {
@@ -106,14 +126,16 @@ export class RpcConnection {
         request.accept(error === null ? success(result) : failure(error));
     }
     _OnEvent(name, properties) {
-        console.log('event', name, properties);
         const receiver = this._RecvQueue.shift();
         if (receiver !== undefined) {
             receiver({ name, properties });
         }
+        else {
+            this._EventQueue.push({ name, properties });
+        }
     }
     _Cleanup() {
-        console.log(`cleanup ${this.webSocket.url}`);
+        var _a;
         for (const request of this._Requests.values()) {
             clearTimeout(request.timeoutId);
             request.accept('closed');
@@ -124,24 +146,34 @@ export class RpcConnection {
         }
         this._RecvQueue.length = 0;
         this._SendQueue.length = 0;
-        this.webSocket.close();
+        if (this.stream instanceof WebSocket) {
+            this.stream.close();
+        }
+        else {
+            (_a = this._Writer) === null || _a === void 0 ? void 0 : _a.close().catch(() => {
+                /* drop silently */
+            });
+        }
     }
 }
-export class TypedRpcConnection extends RpcConnection {
-    constructor(webSocket, _Commands, _Events) {
-        super(webSocket);
+export class TypedRpcConnection {
+    get closed() {
+        return this.rpcConnection.closed;
+    }
+    get closeSignal() {
+        return this.rpcConnection.closeSignal;
+    }
+    constructor(rpcConnection, _Commands, _Events) {
+        this.rpcConnection = rpcConnection;
         this._Commands = _Commands;
         this._Events = _Events;
     }
     request(name, properties, timeout) {
-        const _super = Object.create(null, {
-            request: { get: () => super.request }
-        });
         return __awaiter(this, void 0, void 0, function* () {
             properties = this._Commands[name].request.parse(properties);
             const response = yield (timeout !== undefined
-                ? _super.request.call(this, name, properties, timeout)
-                : _super.request.call(this, name, properties));
+                ? this.rpcConnection.request(name, properties, timeout)
+                : this.rpcConnection.request(name, properties));
             if (response === 'closed' ||
                 response === 'timeout' ||
                 response.type === 'Failure') {
@@ -159,14 +191,11 @@ export class TypedRpcConnection extends RpcConnection {
     }
     notify(name, properties) {
         properties = this._Commands[name].request.parse(properties);
-        super.notify(name, properties);
+        this.rpcConnection.notify(name, properties);
     }
     recv() {
-        const _super = Object.create(null, {
-            recv: { get: () => super.recv }
-        });
         return __awaiter(this, void 0, void 0, function* () {
-            const event = yield _super.recv.call(this);
+            const event = yield this.rpcConnection.recv();
             if (event === 'closed')
                 return event;
             const parsed = parseRpcMessage(this._Events, event);
@@ -178,11 +207,14 @@ export class TypedRpcConnection extends RpcConnection {
             }
             else {
                 console.error(`schema validation for ${event.name} failed; closing connection`);
-                this.close();
+                this.rpcConnection.close();
             }
             return 'closed';
         });
     }
+    close() {
+        this.rpcConnection.close();
+    }
 }
 export function parseRpc(buffer) {
     try {
@@ -207,3 +239,41 @@ export function parseRpcMessage(events, rpc) {
 export function isKnownRpcMessage(events, name) {
     return name in events;
 }
+function readRpcFromStream(reader, onRpc) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let buffer = new Uint8Array();
+        for (;;) {
+            let read;
+            try {
+                read = yield reader.read();
+            }
+            catch (error) {
+                break;
+            }
+            if (read.done)
+                break;
+            buffer = mergeBuffer(buffer, read.value);
+            let offset = 0;
+            for (let size;; offset += size) {
+                size = getByteSize(buffer, offset);
+                if (!size)
+                    break;
+                onRpc(buffer.subarray(offset, offset + size));
+            }
+            buffer = buffer.subarray(offset);
+        }
+        if (buffer.length > 0) {
+            console.warn('unprocessed bytes left in rpc stream', buffer);
+        }
+    });
+}
+function mergeBuffer(a, b) {
+    if (a.length === 0)
+        return b;
+    if (b.length === 0)
+        return a;
+    const merged = new Uint8Array(a.length + b.length);
+    merged.set(a, 0);
+    merged.set(b, a.length);
+    return merged;
+}

package/lib/plugin/token.d.ts

@@ -3,11 +3,9 @@ export declare class Token {
     readonly text: string;
     readonly claims: TokenClaims;
     static parse(token: string): Result<Token>;
-    private readonly _Address;
     private readonly _Upstream;
     protected constructor(text: string, claims: TokenClaims);
     get timeLeft(): number;
-    get address(): URL | undefined;
     get upstream(): Token | undefined;
     get defaultRoomId(): string | undefined;
     hasAudience(audience: Infer<typeof TokenAudienceSchema>): boolean;

package/lib/plugin/token.js

@@ -24,14 +24,6 @@ export class Token {
     constructor(text, claims) {
         this.text = text;
         this.claims = claims;
-        if (claims.adr !== undefined) {
-            try {
-                this._Address = new URL(`wss://${claims.adr}`);
-            }
-            catch (error) {
-                console.error(`address in token(${claims.adr}) can not be parsed; ${error}`);
-            }
-        }
         if (claims.ups !== undefined) {
             const upstream = Token.parse(claims.ups);
             if (upstream.type === 'Success') {
@@ -47,9 +39,6 @@ export class Token {
             return Infinity;
         return this.claims.exp * 1000 - Date.now();
     }
-    get address() {
-        return this._Address;
-    }
     get upstream() {
         return this._Upstream;
     }

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

@@ -0,0 +1,52 @@
+import { MainCommands, MainNotifications, Result, Backend } from '@4players/odin-common';
+import { type MainConnection, type DatagramHandler, ConnectionStatus } from '../mainConnection';
+import { Token } from '../token';
+import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
+export declare class WebRtcMainConnection implements MainConnection {
+    readonly id: number;
+    readonly address: string;
+    readonly url: URL;
+    readonly onDatagram: DatagramHandler;
+    readonly connection: TypedRpcConnection<MainCommands, MainNotifications>;
+    readonly webRtc: RTCPeerConnection;
+    static create(id: number, address: string, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
+    private readonly _AudioChannel;
+    private readonly _PeerIdMap;
+    private _PeriodicHealthCheck;
+    private _WebRtcIceTimeout;
+    private _WebRtcTimeout;
+    private _ClosePromise;
+    private _LocalVideos;
+    private _RemoteVideos;
+    private _Negotiation;
+    private _ResolveOffer?;
+    private _awaitingRemoteTracks;
+    get transport(): Backend.Transport;
+    get closePromise(): Promise<"closed">;
+    get closeSignal(): AbortSignal;
+    get closed(): boolean;
+    get status(): ConnectionStatus;
+    waitForConnected(): Promise<void>;
+    private constructor();
+    close(): void;
+    joinRoom(token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]): Promise<Result<RpcConnection> | 'closed'>;
+    getReconnectToken(peerId: number): Promise<Result<Token>>;
+    sendDatagram(datagram: Uint8Array): void;
+    healthCheck(): Promise<boolean>;
+    private _Request;
+    private _readWebRtcUpdate;
+    private _SendOffer;
+    private _OnWebRtcStatusChanged;
+    private _OnWebRtcUpdate;
+    private _UpdateRemoteSdp;
+    private _AddIceCandidate;
+    private _OnIceCandidate;
+    private ensureTransceivers;
+    startLocalVideo(mediaId: number, track: MediaStreamTrack): Promise<void>;
+    stopLocalVideo(mediaId: number): void;
+    startRemoteVideo(mediaId: number): Promise<MediaStreamTrack>;
+    stopRemoteVideo(mediaId: number): void;
+    private onTrack;
+    requestNegotiation(waitForAnswer: boolean): void;
+    private _CleanUp;
+}