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

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 {

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;

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

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { success } from '@4players/odin-common';
 import { Silence } from '../../worker/common';
+import { logger } from '../index';
 import { createCaptureWorker } from '../../worker';
 import { openCaptureDevice, stopMediaStream, enumerateDevices, } from '../deviceManager';
 const defaultVad = {
@@ -71,7 +72,6 @@ export class AudioCapture {
                 navigator.mediaDevices.removeEventListener('devicechange', this._DeviceCb);
             }
         });
-        console.log('Eyvor AudioCapture constructor');
         if (parameters.apm) {
             this.setApm(parameters.apm);
         }
@@ -130,7 +130,7 @@ export class AudioCapture {
     setDevice(parameters) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            console.log('Eyvor AudioCapture setDevice() parameters: ', parameters);
+            logger.debug(['Device'], 'AudioCapture.setDevice() parameters: ', parameters);
             const rollbackParams = this._DeviceParameters;
             this._DeviceParameters = parameters;
             if (this._Volume === 'muted') {
@@ -138,7 +138,10 @@ export class AudioCapture {
             }
             const device = yield openCaptureDevice(this.controller, parameters, this._Apm);
             if (device.type !== 'Success') {
-                console.error(`unable to open capture device; ${device.reason}`);
+                logger.error([
+                    'Device',
+                    `AudioCapture.setDevice() Unable to open capture device; ${device.reason}`,
+                ]);
                 this._DeviceParameters = rollbackParams;
                 return;
             }

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/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.15";
+export declare const version = "1.0.0-alpha.17";

package/lib/version.js

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