@4players/odin-plugin-web 1.0.0-alpha.16 → 1.0.0-alpha.18

package/lib/plugin/connectionPool.d.ts

@@ -1,6 +1,6 @@
-import { Result, Backend } from '@4players/odin-common';
+import { Result } from '@4players/odin-common';
 import { DatagramHandler, MainConnection } from './mainConnection';
-import Transport = Backend.Transport;
+import { Transport } from './index';
 export declare class ConnectionPool {
     readonly onDatagram: DatagramHandler;
     private _LastConnectionId;

package/lib/plugin/connectionPool.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { failure, nextTick, success, } from '@4players/odin-common';
+import { failure, nextTick, success } from '@4players/odin-common';
 import { ClockJumpCheckInterval, ClockJumpThreshold, logger } from './config';
 import { createMainConnection, } from './mainConnection';
 export class ConnectionPool {
@@ -99,7 +99,9 @@ export class ConnectionPool {
         });
     }
     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') {

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

@@ -1,15 +1,8 @@
 import { ConnectionStatus, type DatagramHandler, type MainConnection } from '../mainConnection';
-import { MainCommands, MainNotifications, PeerId, Result, Backend } from '@4players/odin-common';
+import { MainCommands, MainNotifications, PeerId, Result } from '@4players/odin-common';
+import { Transport } from '..';
 import { Token } from '../token';
 import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
-type IncomingStream = {
-    type: 'waiting';
-    resolve: (stream: WebTransportBidirectionalStream) => void;
-} | {
-    type: 'received';
-    stream: WebTransportBidirectionalStream;
-    timeout: ReturnType<typeof setTimeout>;
-};
 export declare class H3MainConnection implements MainConnection {
     readonly id: number;
     readonly address: string;
@@ -17,11 +10,10 @@ export declare class H3MainConnection implements MainConnection {
     readonly rpc: TypedRpcConnection<MainCommands, MainNotifications>;
     readonly closeController: AbortController;
     status: ConnectionStatus;
-    readonly incomingStreams: Map<number, IncomingStream>;
     readonly closePromise: Promise<'closed'>;
     readonly datagramWriter: WritableStreamDefaultWriter<Uint8Array>;
     get closeSignal(): AbortSignal;
-    get transport(): Backend.Transport;
+    get transport(): Transport;
     get closed(): boolean;
     static create(id: number, address: string, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
     private constructor();
@@ -37,4 +29,3 @@ export declare class H3MainConnection implements MainConnection {
     stopRemoteVideo(mediaId: number): void;
     private _Request;
 }
-export {};

package/lib/plugin/h3/mainConnection.js

@@ -8,13 +8,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { ConnectionStatus, } from '../mainConnection';
-import { MainCommandsRpc, MainNotificationsRpc, RoomCommandsRpc, RoomNotificationsRpc, failure, success, Backend, } from '@4players/odin-common';
-import { logger } from '..';
+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 { version } from '../../version';
-var Transport = Backend.Transport;
 export class H3MainConnection {
     get closeSignal() {
         return this.closeController.signal;
@@ -63,7 +62,6 @@ export class H3MainConnection {
         this.rpc = rpc;
         this.closeController = closeController;
         this.status = ConnectionStatus.Connecting;
-        this.incomingStreams = new Map();
         logger.info(['Connection', 'H3'], 'H3MainConnection.constructor()');
         this.closePromise = (() => __awaiter(this, void 0, void 0, function* () {
             try {

package/lib/plugin/index.d.ts

@@ -14,14 +14,22 @@ export interface DeviceParameters {
     readonly device?: Device;
     onStatusChanged?: Backend.OnStatusChanged;
 }
+export declare enum Transport {
+    H3 = "h3",
+    WebRTC = "webrtc"
+}
+export interface WebPluginOptions {
+    transport: Transport;
+}
 export declare class WebPlugin implements Plugin {
+    readonly options: WebPluginOptions;
     readonly version = "1";
     private _NextRoomId;
     private _PlaybackVolume;
     private readonly _ConnectionPool;
     private readonly _MediaController;
     get playbackVolume(): Backend.Volume;
-    static create(audioContextFactory: AudioContextFactory): Promise<WebPlugin>;
+    static create(audioContextFactory: AudioContextFactory, options?: WebPluginOptions): Promise<WebPlugin>;
     private constructor();
     joinRoom(parameters: JoinRoomParameters): Room;
     createAudioPlayback(parameters: CreateAudioPlaybackParameters): Promise<AudioPlayback>;
@@ -42,7 +50,7 @@ export declare class Room implements Backend.Room {
     private readonly _Peers;
     private readonly _AvailableMediaIds;
     get mainConnection(): MainConnection | undefined;
-    constructor(id: number, connectionPool: ConnectionPool, parameters: JoinRoomParameters);
+    constructor(id: number, connectionPool: ConnectionPool, parameters: JoinRoomParameters, options: WebPluginOptions);
     get token(): string;
     request(method: string, properties: unknown): Promise<unknown>;
     link(media: Backend.Media): Promise<void>;

package/lib/plugin/index.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Backend, assert, unwrap, RoomNotificationsRpc, generateUUID, OdinError, } from '@4players/odin-common';
+import { assert, generateUUID, OdinError, RoomNotificationsRpc, unwrap, } from '@4players/odin-common';
 import { AudioContextCollection, MediaController, } from './mediaController';
 import { ConnectionPool } from './connectionPool';
 import { RoomConnection } from './roomConnection';
@@ -19,13 +19,17 @@ import { VideoCapture } from './medias/video-capture';
 import { VideoPlayback } from './medias/video-playback';
 import { AudioPlayback } from './medias/audio-playback';
 import { logger } from './config';
-var Transport = Backend.Transport;
 export { logger } from './config';
+export var Transport;
+(function (Transport) {
+    Transport["H3"] = "h3";
+    Transport["WebRTC"] = "webrtc";
+})(Transport || (Transport = {}));
 export class WebPlugin {
     get playbackVolume() {
         return this._PlaybackVolume;
     }
-    static create(audioContextFactory) {
+    static create(audioContextFactory, options) {
         return __awaiter(this, void 0, void 0, function* () {
             logger.info(['Other'], 'Using ODIN Plugin Web!');
             // eslint-disable-next-line prefer-const
@@ -33,10 +37,11 @@ export class WebPlugin {
             const pool = new ConnectionPool((connectionId, packet) => audioController.receivePacket(connectionId, packet));
             const audioContexts = new AudioContextCollection(audioContextFactory);
             audioController = new MediaController(audioContexts, pool.sendDatagram.bind(pool));
-            return new WebPlugin(pool, audioController);
+            return new WebPlugin(pool, audioController, options);
         });
     }
-    constructor(connectionPool, audioController) {
+    constructor(connectionPool, audioController, options = { transport: Transport.H3 }) {
+        this.options = options;
         this.version = '1';
         this._NextRoomId = 0;
         this._PlaybackVolume = 1;
@@ -44,7 +49,7 @@ export class WebPlugin {
         this._MediaController = audioController;
     }
     joinRoom(parameters) {
-        return new Room(this._NextRoomId++, this._ConnectionPool, parameters);
+        return new Room(this._NextRoomId++, this._ConnectionPool, parameters, this.options);
     }
     createAudioPlayback(parameters) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -87,8 +92,8 @@ export class Room {
     get mainConnection() {
         return this._Connection.mainConnection;
     }
-    constructor(id, connectionPool, parameters) {
-        var _a, _b, _c, _d;
+    constructor(id, connectionPool, parameters, options) {
+        var _a, _b, _c;
         this._Captures = new Map();
         this._Playbacks = new Map();
         this._Peers = new Map();
@@ -101,7 +106,7 @@ export class Room {
         assert(roomId !== undefined, 'room id required for multi-room-tokens');
         this._Id = id;
         this._OnEvent = onEvent;
-        this._Connection = new RoomConnection(connectionPool, (_d = parameters.transport) !== null && _d !== void 0 ? _d : Transport.H3, this._HandleEvent.bind(this), gateway ? new URL(gateway) : undefined, token, roomId, userData, position);
+        this._Connection = new RoomConnection(connectionPool, options.transport, this._HandleEvent.bind(this), gateway ? new URL(gateway) : undefined, token, roomId, userData, position);
     }
     get token() {
         return this._Connection.token.text;
@@ -112,6 +117,7 @@ export class Room {
     link(media) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d;
+            logger.debug(['Audio'], 'Room.link() media', media);
             if (media instanceof AudioPlayback) {
                 const entry = (_a = this._Playbacks.get(media.uid)) !== null && _a !== void 0 ? _a : {
                     media: undefined,
@@ -194,6 +200,7 @@ export class Room {
     }
     unlink(media) {
         var _a, _b;
+        logger.debug(['Audio'], 'Room.unlink() media', media);
         if (media instanceof AudioPlayback || media instanceof VideoPlayback) {
             const entry = this._Playbacks.get(media.uid);
             if ((entry === null || entry === void 0 ? void 0 : entry.playback) !== media)

package/lib/plugin/mainConnection.d.ts

@@ -1,7 +1,7 @@
-import { Backend, Result } from '@4players/odin-common';
+import { Result } from '@4players/odin-common';
 import { Token } from './token';
+import { Transport } from './index';
 import { RpcConnection } from './rpcConnection';
-import Transport = Backend.Transport;
 export type DatagramHandler = (connectionId: number, datagram: Uint8Array) => void;
 export declare function createMainConnection(id: number, transport: Transport, address: string, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
 export declare enum ConnectionStatus {

package/lib/plugin/mainConnection.js

@@ -1,9 +1,7 @@
 /* eslint-disable no-dupe-class-members */
-import { Backend } from '@4players/odin-common';
-import { logger } from './index';
+import { logger, Transport } from './index';
 import { WebRtcMainConnection } from './webrtc/mainConnection';
 import { H3MainConnection } from './h3/mainConnection';
-var Transport = Backend.Transport;
 export function createMainConnection(id, transport, address, onDatagram, signal) {
     logger.log(['Connection'], 'createMainConnection() ', transport, address);
     switch (transport) {

package/lib/plugin/medias/audio-capture.js

@@ -61,6 +61,7 @@ export class AudioCapture {
         this._Volume = 1;
         this._DeviceCb = () => __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
+            logger.debug(['Audio'], 'AudioCapture._DeviceCb()');
             const devices = yield enumerateDevices();
             const isListed = devices.some((device) => {
                 var _a, _b;
@@ -84,6 +85,7 @@ export class AudioCapture {
     }
     start(room, media, uid) {
         var _a;
+        logger.debug(['Audio'], 'AudioCapture.start()', media);
         let entry = this._Medias.get(media.connectionId);
         if (entry === undefined) {
             this._Medias.set(media.connectionId, (entry = new Set()));
@@ -103,6 +105,7 @@ export class AudioCapture {
     }
     stop(room, media) {
         var _a;
+        logger.debug(['Audio'], 'AudioCapture.stop()', media);
         const entry = this._Medias.get(media.connectionId);
         if (!(entry === null || entry === void 0 ? void 0 : entry.delete(media.mediaId)))
             return;
@@ -114,6 +117,7 @@ export class AudioCapture {
         this._UpdateMedias();
     }
     setVad(value) {
+        logger.debug(['Audio'], 'AudioCapture.setVad() config', value);
         this._Vad = value;
         if (this._Capture) {
             this._Capture.worker.setVad(value);
@@ -121,6 +125,7 @@ export class AudioCapture {
     }
     setApm(config) {
         return __awaiter(this, void 0, void 0, function* () {
+            logger.debug(['Audio'], 'AudioCapture.setApm() config', config);
             this._Apm = config;
             if (this._DeviceParameters) {
                 yield this.setDevice(this._DeviceParameters);
@@ -172,6 +177,7 @@ export class AudioCapture {
     }
     setVolume(value) {
         var _a;
+        logger.debug(['Audio'], 'AudioCapture.setVolume()', value);
         this._Volume = value;
         if (value === 'muted') {
             this.close();
@@ -184,6 +190,7 @@ export class AudioCapture {
         }
     }
     close() {
+        logger.debug(['Audio'], 'AudioCapture.close()');
         if (this._Capture !== undefined) {
             this._Capture.worker.close();
             stopMediaStream(this._Capture.source.mediaStream);
@@ -195,6 +202,7 @@ export class AudioCapture {
     }
     _UpdateMedias() {
         return __awaiter(this, void 0, void 0, function* () {
+            logger.debug(['Audio'], 'AudioCapture._UpdateMedias()');
             if (this._Capture !== undefined) {
                 const connections = Array.from(this._Medias).map(([key, value]) => {
                     return { id: key, mediaIds: Array.from(value) };

package/lib/plugin/medias/audio-playback.js

@@ -1,3 +1,4 @@
+import { logger } from '../config';
 export class AudioPlayback {
     get volume() {
         return this.controller.playbackGetVolume(this.uid);
@@ -10,15 +11,19 @@ export class AudioPlayback {
         this.uid = uid;
     }
     start(id) {
+        logger.debug(['Audio'], 'AudioPlayback.start()', id);
         this.controller.playbackStart(this.uid, id);
     }
     stop(id) {
+        logger.debug(['Audio'], 'AudioPlayback.stop()', id);
         this.controller.playbackStop(this.uid, id);
     }
     setVolume(value) {
+        logger.debug(['Audio'], 'AudioPlayback.setVolume()', value);
         this.controller.playbackSetVolume(this.uid, value);
     }
     close() {
+        logger.debug(['Audio'], 'AudioPlayback.close()');
         this.controller.closePlayback(this.uid);
     }
 }

package/lib/plugin/roomConnection.d.ts

@@ -2,7 +2,7 @@ import { Backend, RoomCommands, Result, Infer } from '@4players/odin-common';
 import { ConnectionPool } from './connectionPool';
 import { MainConnection } from './mainConnection';
 import { Token } from './token';
-import Transport = Backend.Transport;
+import { Transport } from './index';
 export declare class RoomConnection implements RoomConnection {
     readonly connectionPool: ConnectionPool;
     readonly transport: Transport;

package/lib/plugin/roomConnection.js

@@ -215,6 +215,7 @@ export class RoomConnection {
                     case 'closed':
                         logger.debug(['Connection'], 'RoomConnection._HandleConnection: closed');
                         (_a = this._RoomConnection) === null || _a === void 0 ? void 0 : _a.close();
+                        this.connectionPool.releaseConnection(main);
                         return;
                     case 'renewToken':
                         this._RenewToken();

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

@@ -1,7 +1,8 @@
-import { MainCommands, MainNotifications, Result, Backend } from '@4players/odin-common';
+import { MainCommands, MainNotifications, Result } from '@4players/odin-common';
 import { type MainConnection, type DatagramHandler, ConnectionStatus } from '../mainConnection';
 import { Token } from '../token';
 import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
+import { Transport } from '../index';
 export declare class WebRtcMainConnection implements MainConnection {
     readonly id: number;
     readonly address: string;
@@ -21,7 +22,7 @@ export declare class WebRtcMainConnection implements MainConnection {
     private _Negotiation;
     private _ResolveOffer?;
     private _awaitingRemoteTracks;
-    get transport(): Backend.Transport;
+    get transport(): Transport;
     get closePromise(): Promise<"closed">;
     get closeSignal(): AbortSignal;
     get closed(): boolean;

package/lib/plugin/webrtc/mainConnection.js

@@ -7,13 +7,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { MainCommandsRpc, MainNotificationsRpc, assert, extendUrl, failure, success, fail, Backend, } from '@4players/odin-common';
+import { MainCommandsRpc, MainNotificationsRpc, assert, extendUrl, failure, success, fail, } 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;
+import { Transport } from '../index';
 export class WebRtcMainConnection {
     static create(id, address, onDatagram, signal) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/version.d.ts

@@ -1 +1 @@
-export declare const version = "1.0.0-alpha.16";
+export declare const version = "1.0.0-alpha.18";

package/lib/version.js

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