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

package/lib/plugin/mainConnection.js

@@ -1,294 +1,23 @@
 /* eslint-disable no-dupe-class-members */
-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 { MainCommandsRpc, MainNotificationsRpc, assert, extendUrl, failure, success, } from '@4players/odin-common';
-import { Token } from './token';
-import { TypedRpcConnection } from './rpcConnection';
-import { connect } from './websocket';
-import { HealthCheckTimeout, MainConnectionPingInterval, WebRTCIceTimeout as WebRtcIceTimeout, WebRTCTimeout as WebRtcTimeout, } from './config';
-export class MainConnection {
-    static create(id, url, onDatagram, signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (signal.aborted)
-                return failure('aborted');
-            const webSocketUrl = extendUrl(url, 'main');
-            if (webSocketUrl.type !== 'Success')
-                return webSocketUrl;
-            const webSocket = yield connect(webSocketUrl.value, signal);
-            if (webSocket.type !== 'Success')
-                return webSocket;
-            const connection = new TypedRpcConnection(webSocket.value, MainCommandsRpc, MainNotificationsRpc);
-            let webRtc;
-            try {
-                webRtc = new RTCPeerConnection();
-            }
-            catch (reason) {
-                connection.close();
-                return failure(`unable to create webrtc connection; ${reason}`);
-            }
-            return success(new MainConnection(id, url, onDatagram, connection, webRtc));
-        });
-    }
-    get closePromise() {
-        return this._ClosePromise;
-    }
-    get closeSignal() {
-        return this.connection.closeSignal;
-    }
-    get closed() {
-        return this.connection.closed;
-    }
-    webRtcReady() {
-        const isReady = () => {
-            switch (this.webRtc.connectionState) {
-                case 'connected':
-                    return true;
-                case 'failed':
-                case 'closed':
-                    return false;
-                default:
-                    return undefined;
-            }
-        };
-        const result = isReady();
-        if (result !== undefined)
-            return Promise.resolve(result);
-        return new Promise((accept) => {
-            const onConnectionStateChanged = () => {
-                const result = isReady();
-                if (result !== undefined) {
-                    this.webRtc.removeEventListener('connectionstatechange', onConnectionStateChanged);
-                    accept(result);
-                }
-            };
-            this.webRtc.addEventListener('connectionstatechange', onConnectionStateChanged);
-        });
-    }
-    constructor(id, url, onDatagram, connection, webRtc) {
-        this.id = id;
-        this.url = url;
-        this.onDatagram = onDatagram;
-        this.connection = connection;
-        this.webRtc = webRtc;
-        this._PeerIdMap = new WeakMap();
-        this.closeSignal.addEventListener('abort', () => this._CleanUp(), {
-            once: true,
-        });
-        this._ClosePromise = new Promise((accept) => {
-            this.closeSignal.addEventListener('abort', () => accept('closed'), {
-                once: true,
-            });
-        });
-        this._AudioChannel = this.webRtc.createDataChannel('audio', {
-            id: 2,
-            negotiated: true,
-            ordered: false,
-            maxRetransmits: 0,
-        });
-        this._AudioChannel.binaryType = 'arraybuffer';
-        this._AudioChannel.onmessage = (event) => onDatagram(this.id, new Uint8Array(event.data));
-        this.webRtc.onicecandidate = this._OnIceCandidate.bind(this);
-        this.webRtc.onconnectionstatechange = () => this._OnWebRtcStatusChanged();
-        this._SendOffer();
-        if (MainConnectionPingInterval !== undefined) {
-            this._PeriodicHealthCheck = setInterval(() => this.healthCheck(), MainConnectionPingInterval);
-        }
-        this._readEvents();
-    }
-    close() {
-        this.connection.close();
-    }
-    joinRoom(token, roomId, userData, position) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.connection.request('JoinRoom', {
-                token: String(token),
-                room_id: roomId,
-                user_data: userData,
-                position,
-            });
-            if (response === 'closed' || response.type === 'Failure')
-                return response;
-            const responseValue = response.value;
-            if (!('token' in responseValue)) {
-                return failure('JoinRoom responded without token');
-            }
-            const url = extendUrl(this.url, `room?token=${responseValue.token}`);
-            if (url.type === 'Failure')
-                return url;
-            const webSocket = yield connect(url.value, this.closeSignal);
-            if (webSocket.type === 'Success') {
-                this._PeerIdMap.set(webSocket.value, responseValue.peer_id);
-            }
-            return webSocket;
-        });
-    }
-    getReconnectToken(webSocket) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const peerId = this._PeerIdMap.get(webSocket);
-            if (peerId === undefined) {
-                return failure('the webSocket is not part of this connection');
-            }
-            const response = yield this._Request('RequestReconnectToken', {
-                peer_id: peerId,
-            });
-            if (response.type === 'Failure')
-                return response;
-            return Token.parse(response.value);
-        });
-    }
-    sendDatagram(datagram) {
-        if (this._AudioChannel.readyState === 'open') {
-            this._AudioChannel.send(datagram);
-        }
-    }
-    healthCheck() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this._Request('Ping', {}, HealthCheckTimeout);
-            const success = response !== 'timeout' && response.type === 'Success';
-            if (!success)
-                this.close();
-            return success;
-        });
-    }
-    _Request(name, properties, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield (timeout === undefined
-                ? this.connection.request(name, properties)
-                : this.connection.request(name, properties, timeout));
-            if (result === 'closed')
-                return failure('connection lost');
-            return result;
-        });
-    }
-    _readEvents() {
-        return __awaiter(this, void 0, void 0, function* () {
-            while (true) {
-                const event = yield this.connection.recv();
-                if (event === 'closed')
-                    break;
-                console.debug(`${this.url} received ${event.name} on main`, event.properties);
-                if (event.name === 'WebRtcUpdate') {
-                    this._OnWebRtcUpdate(event.properties);
-                }
-            }
-            this.close();
-        });
-    }
-    _SendOffer() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let sdp;
-            try {
-                const offer = yield this.webRtc.createOffer();
-                assert(offer.type === 'offer' && offer.sdp, 'generated broken webrtc offer');
-                yield this.webRtc.setLocalDescription(offer);
-                sdp = (_a = offer.sdp) !== null && _a !== void 0 ? _a : '';
-            }
-            catch (_b) {
-                console.error('RTCPeerConnection failed creating an offer');
-                return;
-            }
-            yield this._Request('WebRtcUpdate', {
-                kind: 'Sdp',
-                type: 'Offer',
-                sdp,
-                media_map: [],
-            });
-        });
-    }
-    _OnWebRtcStatusChanged() {
-        console.log(`webrtc ${this.webRtc.connectionState}`);
-        switch (this.webRtc.connectionState) {
-            case 'closed':
-            case 'failed':
-                this.close();
-                break;
-            case 'connected':
-                clearTimeout(this._WebRtcIceTimeout);
-                this._WebRtcIceTimeout = undefined;
-                clearTimeout(this._WebRtcTimeout);
-                this._WebRtcTimeout = undefined;
-                break;
-            case 'disconnected':
-                this.healthCheck();
-            // falls through
-            default:
-                if (this._WebRtcIceTimeout === undefined) {
-                    this._WebRtcIceTimeout = setTimeout(() => {
-                        this.webRtc.restartIce();
-                        this._WebRtcIceTimeout = undefined;
-                    }, WebRtcIceTimeout);
-                }
-                if (this._WebRtcTimeout === undefined) {
-                    this._WebRtcTimeout = setTimeout(() => this.close(), WebRtcTimeout);
-                }
-                break;
-        }
-    }
-    _OnWebRtcUpdate(update) {
-        switch (update.kind) {
-            case 'Sdp':
-                this._UpdateRemoteSdp(update);
-                break;
-            case 'Trickle':
-                this._AddIceCandidate(update);
-                break;
-            case 'TrickleFinished':
-                this.webRtc.addIceCandidate(undefined);
-                break;
-        }
-    }
-    _UpdateRemoteSdp(update) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const type = update.type === 'Answer' ? 'answer' : 'offer';
-            yield this.webRtc.setRemoteDescription({ type, sdp: update.sdp });
-        });
-    }
-    _AddIceCandidate(candidate) {
-        var _a, _b, _c;
-        const candidateInit = {
-            candidate: candidate.candidate,
-            sdpMid: (_a = candidate.spd_mid) !== null && _a !== void 0 ? _a : undefined,
-            sdpMLineIndex: (_b = candidate.spd_mline_index) !== null && _b !== void 0 ? _b : undefined,
-            usernameFragment: (_c = candidate.username_fragment) !== null && _c !== void 0 ? _c : undefined,
-        };
-        // HACK/TODO(max): find out why the server is not sending sdpMid or sdpMLineIndex
-        if (candidateInit.sdpMid === undefined &&
-            candidateInit.sdpMLineIndex === undefined) {
-            candidateInit.sdpMid = '0';
-        }
-        this.webRtc.addIceCandidate(candidateInit);
-    }
-    _OnIceCandidate(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (event.candidate) {
-                const { candidate, sdpMid, sdpMLineIndex, usernameFragment } = event.candidate;
-                this._Request('WebRtcUpdate', {
-                    kind: 'Trickle',
-                    candidate,
-                    spd_mid: sdpMid !== null && sdpMid !== void 0 ? sdpMid : undefined,
-                    spd_mline_index: sdpMLineIndex !== null && sdpMLineIndex !== void 0 ? sdpMLineIndex : undefined,
-                    username_fragment: usernameFragment !== null && usernameFragment !== void 0 ? usernameFragment : undefined,
-                });
-            }
-            else {
-                this._Request('WebRtcUpdate', { kind: 'TrickleFinished' });
-            }
-        });
-    }
-    _CleanUp() {
-        console.debug(`${this.url} closed`);
-        this.connection.close();
-        this.webRtc.close();
-        clearInterval(this._PeriodicHealthCheck);
-        clearTimeout(this._WebRtcIceTimeout);
-        clearTimeout(this._WebRtcTimeout);
+import { Backend } from '@4players/odin-common';
+import { logger } 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) {
+        case Transport.H3:
+            return H3MainConnection.create(id, address, onDatagram, signal);
+        case Transport.WebRTC:
+            return WebRtcMainConnection.create(id, address, onDatagram, signal);
+        default:
+            throw new Error(`transport ${transport} is not supported`);
     }
 }
+export var ConnectionStatus;
+(function (ConnectionStatus) {
+    ConnectionStatus[ConnectionStatus["Connecting"] = 0] = "Connecting";
+    ConnectionStatus[ConnectionStatus["Connected"] = 1] = "Connected";
+    ConnectionStatus[ConnectionStatus["Closed"] = 2] = "Closed";
+})(ConnectionStatus || (ConnectionStatus = {}));

package/lib/plugin/{audioController.d.ts → mediaController.d.ts}

@@ -1,7 +1,8 @@
 import { Backend, Strand } from '@4players/odin-common';
-import { DeviceParameters } from './index';
-import { RoomConnection } from './roomConnection';
 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;
@@ -29,7 +30,7 @@ export declare class AudioContextCollection {
     release(audioContext: BaseAudioContext): Promise<void>;
     close(): void;
 }
-export declare class AudioController {
+export declare class MediaController {
     readonly audioContexts: AudioContextCollection;
     readonly sink: CaptureSink;
     playbackWorker: PlaybackWorker | undefined;
@@ -40,18 +41,12 @@ export declare class AudioController {
         playback: AudioPlayback;
     }>;
     setPlaybackStrand: Strand;
-    create(audioContexts: AudioContextCollection, sink: CaptureSink): Promise<AudioController>;
+    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>;
-    enumerateDevices(): Promise<Device[]>;
-    /**
-     * Requests audio and video browser permissions. Optionally, requests either audio or video permissions.
-     * @private
-     * @throws
-     */
-    private _requestMediaPermissions;
+    createVideoCapture(ms: MediaStream, customType?: string): Promise<VideoCapture>;
     playbackSetDevice(device?: Device): Promise<void>;
     playbackSetGlobalVolume(value: Backend.Volume): void;
     playbackStart(uid: string, id: GlobalMediaId): void;
@@ -69,38 +64,3 @@ export declare class Device implements Backend.Device {
     get type(): "AudioPlayback" | "AudioCapture";
     get name(): string;
 }
-export declare class AudioPlayback implements Backend.AudioPlayback {
-    readonly controller: AudioController;
-    readonly uid: Backend.UID;
-    get volume(): Backend.Volume;
-    get activity(): Backend.Activity;
-    constructor(controller: AudioController, uid: Backend.UID);
-    start(id: GlobalMediaId): void;
-    stop(id: GlobalMediaId): void;
-    setVolume(value: Backend.Volume): void;
-    close(): void;
-}
-export declare class AudioCapture implements Backend.AudioCapture {
-    readonly controller: AudioController;
-    private _Capture;
-    private readonly _Medias;
-    private _Vad;
-    private _Apm;
-    private _Volume;
-    private _deviceParameters?;
-    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: AudioController, 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<import("@4players/odin-common").Success<void> | undefined>;
-    setVolume(value: Backend.Volume): void;
-    close(): void;
-    _UpdateMedias(): Promise<void>;
-}

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,29 @@
+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 _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<import("@4players/odin-common").Success<void> | undefined>;
+    setVolume(value: Backend.Volume): void;
+    close(): void;
+    _UpdateMedias(): Promise<void>;
+}