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

package/lib/plugin/index.d.ts

@@ -1,23 +1,33 @@
 import { Backend } from '@4players/odin-common';
-import { AudioCapture, AudioContextFactory, AudioPlayback, CreateAudioCaptureParameters, CreateAudioPlaybackParameters, Device } from './audioController';
+import { AudioContextFactory, CreateAudioCaptureParameters, CreateAudioPlaybackParameters, Device } from './mediaController';
 import { ConnectionPool } from './connectionPool';
 import { MainConnection } from './mainConnection';
+import { AudioCapture } from './medias/audio-capture';
+import { VideoCapture } from './medias/video-capture';
+import { VideoPlayback } from './medias/video-playback';
+import { AudioPlayback } from './medias/audio-playback';
+import JoinRoomParameters = Backend.JoinRoomParameters;
+export type { LogFilters } from '@4players/odin-common';
+export { logger } from './config';
+type Plugin = Backend.Plugin;
 export interface DeviceParameters {
     readonly device?: Device;
     onStatusChanged?: Backend.OnStatusChanged;
 }
-export declare class WebPlugin implements Backend.Plugin {
+export declare class WebPlugin implements Plugin {
     readonly version = "1";
     private _NextRoomId;
     private _PlaybackVolume;
     private readonly _ConnectionPool;
-    private readonly _AudioController;
+    private readonly _MediaController;
     get playbackVolume(): Backend.Volume;
     static create(audioContextFactory: AudioContextFactory): Promise<WebPlugin>;
     private constructor();
-    joinRoom(parameters: Backend.JoinRoomParameters): Room;
+    joinRoom(parameters: JoinRoomParameters): Room;
     createAudioPlayback(parameters: CreateAudioPlaybackParameters): Promise<AudioPlayback>;
     createAudioCapture(parameters: CreateAudioCaptureParameters): Promise<AudioCapture>;
+    createVideoCapture(ms: MediaStream, customType?: string): Promise<VideoCapture>;
+    createVideoPlayback(parameters: Backend.CreateVideoPlaybackParameters): Promise<VideoPlayback>;
     enumerateDevices(): Promise<Device[]>;
     setOutputVolume(volume: Backend.Volume): void;
     setOutputDevice(device: DeviceParameters): Promise<void>;
@@ -32,9 +42,10 @@ export declare class Room implements Backend.Room {
     private readonly _Peers;
     private readonly _AvailableMediaIds;
     get mainConnection(): MainConnection | undefined;
-    constructor(id: number, connectionPool: ConnectionPool, parameters: Backend.JoinRoomParameters);
+    constructor(id: number, connectionPool: ConnectionPool, parameters: JoinRoomParameters);
+    get token(): string;
     request(method: string, properties: unknown): Promise<unknown>;
-    link(media: Backend.Media): void;
+    link(media: Backend.Media): Promise<void>;
     unlink(media: Backend.Media): void;
     close(): void;
     private _HandleEvent;

package/lib/plugin/index.js

@@ -7,23 +7,32 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { assert, unwrap, RoomNotificationsRpc, generateUUID, } from '@4players/odin-common';
-import { AudioCapture, AudioContextCollection, AudioController, AudioPlayback, } from './audioController';
+import { Backend, assert, unwrap, RoomNotificationsRpc, generateUUID, OdinError, } from '@4players/odin-common';
+import { AudioContextCollection, MediaController, } from './mediaController';
 import { ConnectionPool } from './connectionPool';
 import { RoomConnection } from './roomConnection';
 import { parseRpcMessage } from './rpcConnection';
 import { Token } from './token';
+import { AudioCapture } from './medias/audio-capture';
+import { enumerateDevices } from './deviceManager';
+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 class WebPlugin {
     get playbackVolume() {
         return this._PlaybackVolume;
     }
     static create(audioContextFactory) {
         return __awaiter(this, void 0, void 0, function* () {
+            logger.info(['Other'], 'Using ODIN Plugin Web!');
             // eslint-disable-next-line prefer-const
             let audioController;
             const pool = new ConnectionPool((connectionId, packet) => audioController.receivePacket(connectionId, packet));
             const audioContexts = new AudioContextCollection(audioContextFactory);
-            audioController = new AudioController(audioContexts, pool.sendDatagram.bind(pool));
+            audioController = new MediaController(audioContexts, pool.sendDatagram.bind(pool));
             return new WebPlugin(pool, audioController);
         });
     }
@@ -32,34 +41,45 @@ export class WebPlugin {
         this._NextRoomId = 0;
         this._PlaybackVolume = 1;
         this._ConnectionPool = connectionPool;
-        this._AudioController = audioController;
+        this._MediaController = audioController;
     }
     joinRoom(parameters) {
         return new Room(this._NextRoomId++, this._ConnectionPool, parameters);
     }
     createAudioPlayback(parameters) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this._AudioController.createAudioPlayback(parameters);
+            return this._MediaController.createAudioPlayback(parameters);
         });
     }
     createAudioCapture(parameters) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this._AudioController.createAudioCapture(parameters);
+            return this._MediaController.createAudioCapture(parameters);
+        });
+    }
+    createVideoCapture(ms, customType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._MediaController.createVideoCapture(ms, customType);
+        });
+    }
+    createVideoPlayback(parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new VideoPlayback(parameters.uid, parameters.customType);
         });
     }
     enumerateDevices() {
-        return this._AudioController.enumerateDevices();
+        return enumerateDevices();
     }
     setOutputVolume(volume) {
-        this._AudioController.playbackSetGlobalVolume(volume);
+        this._MediaController.playbackSetGlobalVolume(volume);
     }
     setOutputDevice(device) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this._AudioController.playbackSetDevice(device.device);
+            yield this._MediaController.playbackSetDevice(device.device);
         });
     }
     close() {
-        this._AudioController.close();
+        logger.debug(['Other', 'Plugin.close()']);
+        this._MediaController.close();
         this._ConnectionPool.close();
     }
 }
@@ -68,7 +88,7 @@ export class Room {
         return this._Connection.mainConnection;
     }
     constructor(id, connectionPool, parameters) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         this._Captures = new Map();
         this._Playbacks = new Map();
         this._Peers = new Map();
@@ -81,69 +101,126 @@ export class Room {
         assert(roomId !== undefined, 'room id required for multi-room-tokens');
         this._Id = id;
         this._OnEvent = onEvent;
-        this._Connection = new RoomConnection(connectionPool, this._HandleEvent.bind(this), gateway ? new URL(gateway) : undefined, token, roomId, userData, position);
+        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);
+    }
+    get token() {
+        return this._Connection.token.text;
     }
     request(method, properties) {
         return this._Connection.request(method, properties);
     }
     link(media) {
-        var _a;
-        if (media instanceof AudioPlayback) {
-            const entry = (_a = this._Playbacks.get(media.uid)) !== null && _a !== void 0 ? _a : {
-                media: undefined,
-                playback: undefined,
-            };
-            if (entry.playback !== undefined) {
-                this.unlink(entry.playback);
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            if (media instanceof AudioPlayback) {
+                const entry = (_a = this._Playbacks.get(media.uid)) !== null && _a !== void 0 ? _a : {
+                    media: undefined,
+                    playback: undefined,
+                };
+                if (entry.playback !== undefined) {
+                    this.unlink(entry.playback);
+                }
+                if (entry.media !== undefined) {
+                    media.start(entry.media);
+                }
+                entry.playback = media;
+                this._Playbacks.set(media.uid, entry);
             }
-            if (entry.media !== undefined) {
-                media.start(entry.media);
+            else if (media instanceof AudioCapture) {
+                let entry = this._Captures.get(media);
+                if (entry) {
+                    this.unlink(media);
+                }
+                const mediaId = this.mainConnection !== undefined && this._AvailableMediaIds.shift();
+                entry = {
+                    media: mediaId
+                        ? {
+                            connectionId: this.mainConnection.id,
+                            mediaId,
+                        }
+                        : undefined,
+                    uid: generateUUID(),
+                };
+                this._Captures.set(media, entry);
+                if (entry.media !== undefined) {
+                    media.start(this._Connection, entry.media, entry.uid);
+                }
             }
-            entry.playback = media;
-            this._Playbacks.set(media.uid, entry);
-        }
-        else if (media instanceof AudioCapture) {
-            let entry = this._Captures.get(media);
-            if (entry) {
-                this.unlink(media);
+            else if (media instanceof VideoCapture) {
+                let mediaEntry = this._Captures.get(media);
+                if (mediaEntry) {
+                    this.unlink(media);
+                }
+                if (media.mediaStream) {
+                    const mediaId = this.mainConnection !== undefined && this._AvailableMediaIds.shift();
+                    mediaEntry = {
+                        media: mediaId
+                            ? {
+                                connectionId: this.mainConnection.id,
+                                mediaId,
+                            }
+                            : undefined,
+                        uid: generateUUID(),
+                    };
+                    this._Captures.set(media, mediaEntry);
+                    if (mediaEntry.media !== undefined) {
+                        // @TODO Check if we also need to send the StartMedia rpc
+                        (_b = this.mainConnection) === null || _b === void 0 ? void 0 : _b.startLocalVideo(mediaEntry.media.mediaId, media.mediaStream.getTracks()[0]);
+                        media.start(this._Connection, mediaEntry.media, mediaEntry.uid);
+                    }
+                }
             }
-            const mediaId = this.mainConnection !== undefined && this._AvailableMediaIds.shift();
-            entry = {
-                media: mediaId
-                    ? {
-                        connectionId: this.mainConnection.id,
-                        mediaId,
+            else if (media instanceof VideoPlayback) {
+                const entry = (_c = this._Playbacks.get(media.uid)) !== null && _c !== void 0 ? _c : {
+                    media: undefined,
+                    playback: undefined,
+                };
+                if (entry.playback !== undefined) {
+                    this.unlink(entry.playback);
+                }
+                if (entry.media !== undefined) {
+                    const track = yield ((_d = this.mainConnection) === null || _d === void 0 ? void 0 : _d.startRemoteVideo(entry.media.mediaId));
+                    if (track) {
+                        media.setMediaStream(new MediaStream([track]));
                     }
-                    : undefined,
-                uid: generateUUID(),
-            };
-            this._Captures.set(media, entry);
-            if (entry.media !== undefined) {
-                media.start(this._Connection, entry.media, entry.uid);
+                }
+                entry.playback = media;
+                this._Playbacks.set(media.uid, entry);
             }
-        }
-        else {
-            throw new Error('invalid media');
-        }
+            else {
+                throw new OdinError('invalid media');
+            }
+        });
     }
     unlink(media) {
-        if (media instanceof AudioPlayback) {
+        var _a, _b;
+        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)
                 return;
             entry.playback = undefined;
             if (entry.media !== undefined) {
-                media.stop(entry.media);
+                if (media instanceof AudioPlayback) {
+                    media.stop(entry.media);
+                }
+                else {
+                    (_a = this.mainConnection) === null || _a === void 0 ? void 0 : _a.stopRemoteVideo(entry.media.mediaId);
+                    // @TODO check if the MediaStream and its tracks have to get closed manually.
+                    media.setMediaStream(undefined);
+                }
             }
             this._Playbacks.set(media.uid, entry);
         }
-        else if (media instanceof AudioCapture) {
+        else if (media instanceof AudioCapture || media instanceof VideoCapture) {
             const entry = this._Captures.get(media);
             if (entry === undefined)
                 return;
             if (entry.media !== undefined) {
                 media.stop(this._Connection, entry.media);
                 this._AvailableMediaIds.push(entry.media.mediaId);
+                if (media instanceof VideoCapture) {
+                    (_b = this.mainConnection) === null || _b === void 0 ? void 0 : _b.stopLocalVideo(entry.media.mediaId);
+                }
             }
             this._Captures.delete(media);
         }
@@ -152,6 +229,7 @@ export class Room {
         }
     }
     close() {
+        logger.debug(['Other', 'Room.close()']);
         this._Connection.close();
     }
     _HandleEvent(method, properties) {
@@ -163,7 +241,6 @@ export class Room {
             this._HandleKnownEvent(rpc);
             properties = rpc.properties;
         }
-        console.log(`handle event ${method} ${this._OnEvent !== undefined}`);
         this._OnEvent(method, properties);
     }
     _HandleKnownEvent(event) {
@@ -190,8 +267,14 @@ export class Room {
         for (const [capture, entry] of this._Captures) {
             if (entry.media === undefined)
                 continue;
-            capture.stop(this._Connection, entry.media);
-            entry.media = undefined;
+            if (capture instanceof VideoCapture) {
+                // @TODO Check if it needs implementation
+                logger.debug(['Connection', 'Video'], '_HandleConnectionLost() VideoCapture');
+            }
+            if (capture instanceof AudioCapture) {
+                capture.stop(this._Connection, entry.media);
+                entry.media = undefined;
+            }
         }
         this._AvailableMediaIds.length = 0;
     }
@@ -221,7 +304,12 @@ export class Room {
                 connectionId: this.mainConnection.id,
                 mediaId: this._AvailableMediaIds.shift(),
             };
-            capture.start(this._Connection, entry.media, entry.uid);
+            if (capture instanceof AudioCapture) {
+                capture.start(this._Connection, entry.media, entry.uid);
+            }
+            if (capture instanceof VideoCapture) {
+                // @TODO Check if it needs implementation
+            }
         }
     }
     _HandlePeerUpdate(update) {
@@ -254,10 +342,11 @@ export class Room {
         if (this.mainConnection === undefined)
             return;
         const peer = this._Peers.get(peerId);
-        if (peer === undefined || media.properties.kind !== 'audio')
+        if (peer === undefined ||
+            (media.properties.kind !== 'audio' && media.properties.kind !== 'video')) {
             return;
+        }
         const uid = String((_a = media.properties.uid) !== null && _a !== void 0 ? _a : generateUUID());
-        console.log(`uuid ${media.properties.uid} ${uid}`);
         media.properties.uid = uid; // feed the uid back, so it can be seen be seen down the chain.
         const entry = (_b = this._Playbacks.get(uid)) !== null && _b !== void 0 ? _b : {
             media: undefined,
@@ -270,10 +359,17 @@ export class Room {
             mediaId: media.id,
         };
         if (entry.playback !== undefined) {
-            entry.playback.start(entry.media);
+            if (entry.playback instanceof AudioPlayback) {
+                entry.playback.start(entry.media);
+            }
+            if (entry.playback instanceof VideoPlayback) {
+                logger.debug(['Video'], '_HandleMediaStart() VideoPlayback');
+                this.mainConnection.startRemoteVideo(entry.media.mediaId).then();
+            }
         }
     }
     _HandleMediaStopped(peerId, mediaId) {
+        var _a;
         const peer = this._Peers.get(peerId);
         if (peer === undefined)
             return;
@@ -284,7 +380,13 @@ export class Room {
         if (entry === undefined)
             return;
         if (entry.media !== undefined && entry.playback !== undefined) {
-            entry.playback.stop(entry.media);
+            if (entry.playback instanceof AudioPlayback) {
+                entry.playback.stop(entry.media);
+            }
+            if (entry.playback instanceof VideoPlayback) {
+                logger.debug(['Video', '_HandleMediaStopped() VideoPlayback']);
+                (_a = this.mainConnection) === null || _a === void 0 ? void 0 : _a.stopRemoteVideo(entry.media.mediaId);
+            }
         }
         entry.media = undefined;
         peer.mediaIds.delete(mediaId);

package/lib/plugin/mainConnection.d.ts

@@ -1,37 +1,30 @@
-import { MainCommands, MainNotifications, Result } from '@4players/odin-common';
+import { Backend, Result } from '@4players/odin-common';
 import { Token } from './token';
-import { TypedRpcConnection } from './rpcConnection';
+import { RpcConnection } from './rpcConnection';
+import Transport = Backend.Transport;
 export type DatagramHandler = (connectionId: number, datagram: Uint8Array) => void;
-export declare class MainConnection {
-    readonly id: number;
-    readonly url: URL;
-    readonly onDatagram: DatagramHandler;
-    readonly connection: TypedRpcConnection<MainCommands, MainNotifications>;
-    readonly webRtc: RTCPeerConnection;
-    static create(id: number, url: URL, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
-    private readonly _AudioChannel;
-    private readonly _PeerIdMap;
-    private _PeriodicHealthCheck;
-    private _WebRtcIceTimeout;
-    private _WebRtcTimeout;
-    private _ClosePromise;
-    get closePromise(): Promise<"closed">;
+export declare function createMainConnection(id: number, transport: Transport, address: string, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
+export declare enum ConnectionStatus {
+    Connecting = 0,
+    Connected = 1,
+    Closed = 2
+}
+export interface MainConnection {
+    get id(): number;
+    get transport(): Transport;
+    get address(): string;
+    get status(): ConnectionStatus;
+    get closePromise(): Promise<'closed'>;
     get closeSignal(): AbortSignal;
     get closed(): boolean;
-    webRtcReady(): Promise<boolean>;
-    private constructor();
+    waitForConnected(): Promise<void>;
     close(): void;
-    joinRoom(token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]): Promise<Result<WebSocket> | 'closed'>;
-    getReconnectToken(webSocket: WebSocket): Promise<Result<Token>>;
-    sendDatagram(datagram: Uint8Array): void;
+    joinRoom(token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]): Promise<Result<RpcConnection> | 'closed'>;
+    getReconnectToken(peerId: number): Promise<Result<Token>>;
     healthCheck(): Promise<boolean>;
-    private _Request;
-    private _readEvents;
-    private _SendOffer;
-    private _OnWebRtcStatusChanged;
-    private _OnWebRtcUpdate;
-    private _UpdateRemoteSdp;
-    private _AddIceCandidate;
-    private _OnIceCandidate;
-    private _CleanUp;
+    sendDatagram(datagram: Uint8Array): void;
+    startLocalVideo(mediaId: number, track: MediaStreamTrack): void;
+    stopLocalVideo(mediaId: number): void;
+    startRemoteVideo(mediaId: number): Promise<MediaStreamTrack>;
+    stopRemoteVideo(mediaId: number): void;
 }