@4players/odin-plugin-web 1.0.0-alpha.21 → 1.0.0-alpha.22

package/lib/plugin/mediaController.d.ts

@@ -0,0 +1,66 @@
+import { Backend, Strand } from '@4players/odin-common';
+import { CaptureSink, PlaybackId, PlaybackWorker } from '../worker/common';
+import { AudioCapture } from './medias/audio-capture';
+import { VideoCapture } from './medias/video-capture';
+import { AudioPlayback } from './medias/audio-playback';
+export type CreateAudioPlaybackParameters = Backend.CreateAudioPlaybackParameters;
+export type CreateAudioCaptureParameters = Backend.CreateAudioCaptureParameters & {
+    readonly device?: Device;
+};
+export type AudioContextFactory = (sampleRate: number | undefined) => Promise<AudioContext>;
+export interface GlobalMediaId extends PlaybackId {
+}
+declare global {
+    interface AudioSinkOptions {
+        type: 'none';
+    }
+    interface AudioContext {
+        setSinkId?: (sinkId: string | undefined | AudioSinkOptions) => Promise<undefined>;
+    }
+}
+export declare class AudioContextCollection {
+    readonly audioContextFactory: AudioContextFactory;
+    readonly entries: Array<{
+        sampleRate: undefined | number;
+        audioContext: AudioContext;
+        references: number;
+    }>;
+    constructor(audioContextFactory: AudioContextFactory);
+    acquire(sampleRate: number | undefined): Promise<AudioContext>;
+    release(audioContext: BaseAudioContext): Promise<void>;
+    close(): void;
+}
+export declare class MediaController {
+    readonly audioContexts: AudioContextCollection;
+    readonly sink: CaptureSink;
+    playbackWorker: PlaybackWorker | undefined;
+    globalVolume: number;
+    playbacks: Map<string, {
+        id: GlobalMediaId | undefined;
+        volume: Backend.Volume;
+        playback: AudioPlayback;
+    }>;
+    setPlaybackStrand: Strand;
+    create(audioContexts: AudioContextCollection, sink: CaptureSink): Promise<MediaController>;
+    constructor(audioContexts: AudioContextCollection, sink: CaptureSink);
+    receivePacket(connectionId: number, packet: Uint8Array): void;
+    createAudioPlayback(parameters: CreateAudioPlaybackParameters): Promise<AudioPlayback>;
+    createAudioCapture(parameters: CreateAudioCaptureParameters): Promise<AudioCapture>;
+    createVideoCapture(ms: MediaStream, customType?: string): Promise<VideoCapture>;
+    playbackSetDevice(device?: Device): Promise<void>;
+    playbackSetGlobalVolume(value: Backend.Volume): void;
+    playbackStart(uid: string, id: GlobalMediaId): void;
+    playbackStop(uid: string, id: GlobalMediaId): void;
+    playbackGetActivity(uid: string): Backend.Activity;
+    playbackSetVolume(uid: string, volume: Backend.Volume): void;
+    playbackGetVolume(uid: string): Backend.Volume;
+    closePlayback(uid: string): void;
+    close(): void;
+}
+export declare class Device implements Backend.Device {
+    readonly device: MediaDeviceInfo;
+    readonly isDefault: boolean;
+    constructor(device: MediaDeviceInfo, isDefault?: boolean);
+    get type(): "AudioPlayback" | "AudioCapture";
+    get name(): string;
+}

package/lib/plugin/mediaController.js

@@ -0,0 +1,215 @@
+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 { Strand, assert } from '@4players/odin-common';
+import { createPlaybackWorker } from '../worker';
+import { Silence, } from '../worker/common';
+import { AudioCapture } from './medias/audio-capture';
+import { VideoCapture } from './medias/video-capture';
+import { AudioPlayback } from './medias/audio-playback';
+export class AudioContextCollection {
+    constructor(audioContextFactory) {
+        this.audioContextFactory = audioContextFactory;
+        this.entries = [];
+    }
+    acquire(sampleRate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const entry of this.entries) {
+                if (entry.sampleRate === sampleRate) {
+                    entry.references += 1;
+                    return entry.audioContext;
+                }
+                else if (entry.sampleRate === undefined) {
+                    const audioContext = entry.audioContext;
+                    if (audioContext.sampleRate === sampleRate) {
+                        entry.references += 1;
+                        return entry.audioContext;
+                    }
+                }
+            }
+            const entry = {
+                sampleRate,
+                audioContext: yield this.audioContextFactory(sampleRate),
+                references: 1,
+            };
+            this.entries.push(entry);
+            return entry.audioContext;
+        });
+    }
+    release(audioContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const index = this.entries.findIndex((entry) => entry.audioContext === audioContext);
+            if (index < 0)
+                return;
+            this.entries[index].references -= 1;
+            if (this.entries[index].references <= 0) {
+                const context = this.entries[index].audioContext;
+                this.entries.splice(index, 1);
+                yield context.close();
+            }
+        });
+    }
+    close() {
+        for (const entry of this.entries) {
+            entry.audioContext.close();
+        }
+    }
+}
+export class MediaController {
+    create(audioContexts, sink) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new MediaController(audioContexts, sink);
+        });
+    }
+    constructor(audioContexts, sink) {
+        this.audioContexts = audioContexts;
+        this.sink = sink;
+        this.globalVolume = 1;
+        this.playbacks = new Map();
+        this.setPlaybackStrand = new Strand();
+    }
+    receivePacket(connectionId, packet) {
+        var _a;
+        (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.receivePacket(connectionId, packet);
+    }
+    createAudioPlayback(parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let entry = this.playbacks.get(parameters.uid);
+            let volume = parameters.volume;
+            if (entry === undefined) {
+                volume = volume !== null && volume !== void 0 ? volume : 1;
+                const playback = new AudioPlayback(this, parameters.uid);
+                entry = { id: undefined, volume, playback };
+                this.playbacks.set(parameters.uid, entry);
+            }
+            if (volume !== undefined) {
+                entry.playback.setVolume(volume);
+            }
+            return entry.playback;
+        });
+    }
+    createAudioCapture(parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const capture = new AudioCapture(this, parameters);
+            yield capture.setDevice(parameters);
+            return capture;
+        });
+    }
+    createVideoCapture(ms, customType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const videoCapture = new VideoCapture(this, customType);
+            yield videoCapture.setDevice(ms);
+            return videoCapture;
+        });
+    }
+    playbackSetDevice(device) {
+        return this.setPlaybackStrand.enqueue(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let deviceId = (_a = device === null || device === void 0 ? void 0 : device.device.deviceId) !== null && _a !== void 0 ? _a : '';
+            if (deviceId === 'default') {
+                deviceId = '';
+            }
+            let audioContext;
+            if (this.playbackWorker === undefined) {
+                audioContext = yield this.audioContexts.acquire(48000);
+                this.playbackWorker = yield createPlaybackWorker(audioContext);
+                this.playbackWorker.setGlobalVolume(this.globalVolume);
+            }
+            else {
+                audioContext = this.playbackWorker.audioContext;
+            }
+            if ((audioContext === null || audioContext === void 0 ? void 0 : audioContext.setSinkId) !== undefined &&
+                device &&
+                (audioContext === null || audioContext === void 0 ? void 0 : audioContext.state) === 'running') {
+                yield audioContext.setSinkId(deviceId);
+            }
+        }));
+    }
+    playbackSetGlobalVolume(value) {
+        var _a;
+        this.globalVolume = value === 'muted' ? 0 : value;
+        (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.setGlobalVolume(this.globalVolume);
+    }
+    playbackStart(uid, id) {
+        var _a;
+        const entry = this.playbacks.get(uid);
+        if (entry === undefined)
+            return;
+        if (entry.id !== undefined) {
+            this.playbackStop(uid, entry.id);
+        }
+        entry.id = id;
+        (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.addMedias(id.connectionId, [id.mediaId]);
+        this.playbackSetVolume(uid, entry.volume);
+    }
+    playbackStop(uid, id) {
+        var _a;
+        const entry = this.playbacks.get(uid);
+        if (entry === undefined)
+            return;
+        if (entry.id !== id)
+            console.error('playback mediaId out of sync!');
+        entry.id = undefined;
+        (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.removeMedias(id.connectionId, [id.mediaId]);
+    }
+    playbackGetActivity(uid) {
+        var _a, _b;
+        const entry = this.playbacks.get(uid);
+        if ((entry === null || entry === void 0 ? void 0 : entry.id) === undefined)
+            return Silence;
+        return (_b = (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.getActivity(entry.id)) !== null && _b !== void 0 ? _b : Silence;
+    }
+    playbackSetVolume(uid, volume) {
+        var _a;
+        const entry = this.playbacks.get(uid);
+        if (entry === undefined)
+            return;
+        entry.volume = volume === 'muted' ? 0 : volume;
+        if (entry.id !== undefined) {
+            (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.setVolume(entry.id, entry.volume);
+        }
+    }
+    playbackGetVolume(uid) {
+        var _a;
+        const entry = this.playbacks.get(uid);
+        return (_a = entry === null || entry === void 0 ? void 0 : entry.volume) !== null && _a !== void 0 ? _a : 1;
+    }
+    closePlayback(uid) {
+        const entry = this.playbacks.get(uid);
+        if (entry === undefined)
+            return;
+        if (entry.id !== undefined)
+            this.playbackStop(uid, entry.id);
+        this.playbacks.delete(uid);
+    }
+    close() {
+        var _a;
+        (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.close();
+        this.audioContexts.close();
+    }
+}
+export class Device {
+    constructor(device, isDefault = false) {
+        this.device = device;
+        this.isDefault = isDefault;
+    }
+    get type() {
+        switch (this.device.kind) {
+            case 'audioinput':
+                return 'AudioCapture';
+            case 'audiooutput':
+                return 'AudioPlayback';
+            default:
+                assert(false, 'not supported device');
+        }
+    }
+    get name() {
+        return this.device.label;
+    }
+}

package/lib/plugin/medias/audio-capture.d.ts

@@ -0,0 +1,30 @@
+import { Backend } from '@4players/odin-common';
+import { DeviceParameters } from '../index';
+import { RoomConnection } from '../roomConnection';
+import { MediaController, CreateAudioCaptureParameters, GlobalMediaId } from '../mediaController';
+export declare class AudioCapture implements Backend.AudioCapture {
+    readonly controller: MediaController;
+    private _Capture;
+    private readonly _Medias;
+    private _Vad;
+    private _Apm;
+    private _Volume;
+    private _DeviceParameters?;
+    private _ProcessingSetDevice;
+    private _DeviceCb;
+    get vad(): Backend.VadConfig;
+    get apm(): Backend.ApmConfig;
+    get volume(): Backend.Volume;
+    get activity(): import("../../worker/common").Activity;
+    get speechProbability(): number;
+    get deviceId(): string | undefined;
+    constructor(controller: MediaController, parameters: CreateAudioCaptureParameters);
+    start(room: RoomConnection, media: GlobalMediaId, uid: Backend.UID): void;
+    stop(room: RoomConnection, media: GlobalMediaId): void;
+    setVad(value: Backend.VadConfig): void;
+    setApm(config: Backend.ApmConfig): Promise<void>;
+    setDevice(parameters: DeviceParameters): Promise<void>;
+    setVolume(value: Backend.Volume): Promise<void>;
+    close(): Promise<void>;
+    _UpdateMedias(): Promise<void>;
+}

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

@@ -0,0 +1,224 @@
+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 { Silence } from '../../worker/common';
+import { logger } from '../index';
+import { createCaptureWorker } from '../../worker';
+import { openCaptureDevice, stopMediaStream, enumerateDevices, } from '../deviceManager';
+const defaultVad = {
+    voiceActivity: {
+        attackThreshold: 0.9,
+        releaseThreshold: 0.8,
+    },
+    volumeGate: {
+        attackThreshold: -30,
+        releaseThreshold: -40,
+    },
+};
+const defaultApm = {
+    echoCanceller: false,
+    highPassFilter: false,
+    preAmplifier: false,
+    captureLevelAdjustment: false,
+    noiseSuppression: 'None',
+    transientSuppressor: false,
+    gainController: false,
+};
+export class AudioCapture {
+    get vad() {
+        return this._Vad;
+    }
+    get apm() {
+        return this._Apm;
+    }
+    get volume() {
+        return this._Volume;
+    }
+    get activity() {
+        var _a, _b;
+        return (_b = (_a = this._Capture) === null || _a === void 0 ? void 0 : _a.worker.activity) !== null && _b !== void 0 ? _b : Silence;
+    }
+    get speechProbability() {
+        var _a, _b;
+        return (_b = (_a = this._Capture) === null || _a === void 0 ? void 0 : _a.worker.speechProbability) !== null && _b !== void 0 ? _b : 0;
+    }
+    get deviceId() {
+        var _a, _b;
+        return (_b = (_a = this._DeviceParameters) === null || _a === void 0 ? void 0 : _a.device) === null || _b === void 0 ? void 0 : _b.device.deviceId;
+    }
+    constructor(controller, parameters) {
+        this.controller = controller;
+        this._Medias = new Map();
+        this._Vad = defaultVad;
+        this._Apm = defaultApm;
+        this._Volume = 1;
+        this._ProcessingSetDevice = false;
+        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;
+                return (device.device.deviceId ===
+                    ((_b = (_a = this._DeviceParameters) === null || _a === void 0 ? void 0 : _a.device) === null || _b === void 0 ? void 0 : _b.device.deviceId));
+            });
+            if (!isListed) {
+                (_b = (_a = this._DeviceParameters) === null || _a === void 0 ? void 0 : _a.onStatusChanged) === null || _b === void 0 ? void 0 : _b.call(_a, 'stopped');
+                navigator.mediaDevices.removeEventListener('devicechange', this._DeviceCb);
+            }
+        });
+        if (parameters.apm) {
+            this.setApm(parameters.apm);
+        }
+        if (parameters.vad) {
+            this.setVad(parameters.vad);
+        }
+        if (parameters.volume) {
+            this.setVolume(parameters.volume);
+        }
+    }
+    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()));
+        }
+        if (entry.has(media.mediaId))
+            return;
+        entry.add(media.mediaId);
+        if (((_a = room.mainConnection) === null || _a === void 0 ? void 0 : _a.id) === media.connectionId) {
+            room
+                .typedRequest('StartMedia', {
+                media_id: media.mediaId,
+                properties: { kind: 'audio', uid },
+            })
+                .catch((reason) => console.error(`StartMedia got rejected; ${reason}`));
+        }
+        this._UpdateMedias();
+    }
+    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;
+        if (((_a = room.mainConnection) === null || _a === void 0 ? void 0 : _a.id) === media.connectionId) {
+            room
+                .typedRequest('StopMedia', { media_id: media.mediaId })
+                .catch((reason) => console.error(`StopMedia got rejected; ${reason}`));
+        }
+        this._UpdateMedias();
+    }
+    setVad(value) {
+        logger.debug(['Audio'], 'AudioCapture.setVad() config', value);
+        this._Vad = value;
+        if (this._Capture) {
+            this._Capture.worker.setVad(value);
+        }
+    }
+    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);
+            }
+        });
+    }
+    setDevice(parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger.debug(['Device'], 'AudioCapture.setDevice() parameters: ', parameters);
+            const rollbackParams = this._DeviceParameters;
+            this._DeviceParameters = parameters;
+            if (this._Volume === 'muted') {
+                return;
+            }
+            const device = yield openCaptureDevice(this.controller, parameters, this._Apm);
+            if (device.type !== 'Success') {
+                logger.error([
+                    'Device',
+                    `AudioCapture.setDevice() Unable to open capture device; ${device.reason}`,
+                ]);
+                this._DeviceParameters = rollbackParams;
+                return;
+            }
+            if (this._DeviceParameters.onStatusChanged) {
+                navigator.mediaDevices.addEventListener('devicechange', this._DeviceCb);
+            }
+            if (this._Capture !== undefined) {
+                stopMediaStream(this._Capture.source.mediaStream);
+                this._Capture.source.disconnect(this._Capture.worker.worklet);
+            }
+            if (this._Capture === undefined ||
+                this._Capture.worker.worklet.context !== device.value.context) {
+                (_a = this._Capture) === null || _a === void 0 ? void 0 : _a.worker.close();
+                this._Capture = {
+                    worker: yield createCaptureWorker(device.value.context, this.controller.sink),
+                    source: device.value,
+                };
+                yield this._UpdateMedias();
+                yield this.setVolume(this._Volume);
+                this.setVad(this.vad);
+            }
+            else {
+                this._Capture.source = device.value;
+            }
+            this._Capture.source.connect(this._Capture.worker.worklet);
+        });
+    }
+    setVolume(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger.debug(['Audio'], 'AudioCapture.setVolume()', value);
+            this._Volume = value;
+            if (this._ProcessingSetDevice)
+                return;
+            this._ProcessingSetDevice = true;
+            if (value === 'muted') {
+                yield this.close();
+            }
+            else {
+                if (!this._Capture && this._DeviceParameters) {
+                    yield this.setDevice(this._DeviceParameters);
+                }
+                (_a = this._Capture) === null || _a === void 0 ? void 0 : _a.worker.setVolume(value);
+            }
+            this._ProcessingSetDevice = false;
+            if (value !== this._Volume) {
+                yield this.setVolume(this._Volume);
+            }
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug(['Audio'], 'AudioCapture.close()');
+            if (this._Capture !== undefined) {
+                this._Capture.worker.close();
+                stopMediaStream(this._Capture.source.mediaStream);
+                this._Capture.source.disconnect(this._Capture.worker.worklet);
+                yield this.controller.audioContexts.release(this._Capture.source.context);
+            }
+            navigator.mediaDevices.removeEventListener('devicechange', this._DeviceCb);
+            this._Capture = undefined;
+        });
+    }
+    _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) };
+                });
+                this._Capture.worker.setMedias(connections);
+            }
+        });
+    }
+}

package/lib/plugin/medias/audio-playback.d.ts

@@ -0,0 +1,13 @@
+import { Backend } from '@4players/odin-common';
+import { GlobalMediaId, MediaController } from '../mediaController';
+export declare class AudioPlayback implements Backend.AudioPlayback {
+    readonly controller: MediaController;
+    readonly uid: Backend.UID;
+    get volume(): Backend.Volume;
+    get activity(): Backend.Activity;
+    constructor(controller: MediaController, uid: Backend.UID);
+    start(id: GlobalMediaId): void;
+    stop(id: GlobalMediaId): void;
+    setVolume(value: Backend.Volume): Promise<void>;
+    close(): void;
+}

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

@@ -0,0 +1,40 @@
+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 { logger } from '../config';
+export class AudioPlayback {
+    get volume() {
+        return this.controller.playbackGetVolume(this.uid);
+    }
+    get activity() {
+        return this.controller.playbackGetActivity(this.uid);
+    }
+    constructor(controller, uid) {
+        this.controller = controller;
+        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) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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/medias/video-capture.d.ts

@@ -0,0 +1,15 @@
+import { GlobalMediaId, MediaController } from '../mediaController';
+import { Backend } from '@4players/odin-common';
+import { RoomConnection } from '../roomConnection';
+export declare class VideoCapture implements Backend.VideoCapture {
+    readonly controller: MediaController;
+    readonly customType?: string | undefined;
+    private _mediaStream?;
+    private readonly _Medias;
+    constructor(controller: MediaController, customType?: string | undefined);
+    get mediaStream(): MediaStream | undefined;
+    setDevice(ms: MediaStream): Promise<void>;
+    start(room: RoomConnection, media: GlobalMediaId, uid: Backend.UID): void;
+    stop(room: RoomConnection, media: GlobalMediaId): void;
+    close(): void;
+}

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

@@ -0,0 +1,69 @@
+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 { stopMediaStream } from '../deviceManager';
+export class VideoCapture {
+    constructor(controller, customType) {
+        this.controller = controller;
+        this.customType = customType;
+        this._Medias = new Map();
+    }
+    get mediaStream() {
+        return this._mediaStream;
+    }
+    setDevice(ms) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // @TODO: Stop old ms before
+            this._mediaStream = ms;
+        });
+    }
+    start(room, media, uid) {
+        var _a;
+        let entry = this._Medias.get(media.connectionId);
+        if (entry === undefined) {
+            this._Medias.set(media.connectionId, (entry = new Set()));
+        }
+        if (entry.has(media.mediaId))
+            return;
+        entry.add(media.mediaId);
+        if (((_a = room.mainConnection) === null || _a === void 0 ? void 0 : _a.id) === media.connectionId) {
+            const properties = {
+                kind: 'video',
+                codec: 'VP8',
+                uid,
+            };
+            if (this.customType) {
+                properties.customType = this.customType;
+            }
+            room
+                .typedRequest('StartMedia', {
+                media_id: media.mediaId,
+                properties,
+            })
+                .catch((reason) => console.error(`StartMedia got rejected; ${reason}`));
+        }
+    }
+    stop(room, media) {
+        var _a;
+        if (this._mediaStream) {
+            stopMediaStream(this._mediaStream);
+        }
+        const entry = this._Medias.get(media.connectionId);
+        if (!(entry === null || entry === void 0 ? void 0 : entry.delete(media.mediaId)))
+            return;
+        if (((_a = room.mainConnection) === null || _a === void 0 ? void 0 : _a.id) === media.connectionId) {
+            room
+                .typedRequest('StopMedia', { media_id: media.mediaId })
+                .catch((reason) => console.error(`StopMedia got rejected; ${reason}`));
+        }
+    }
+    close() {
+        throw new Error('Method not implemented.');
+    }
+}