@4players/odin-plugin-web 1.0.0-alpha.2 → 1.0.0-alpha.20

package/{backend/lib → lib/plugin}/index.d.ts

@@ -1,27 +1,43 @@
-import { ConnectionPool } from './connectionPool';
 import { Backend } from '@4players/odin-common';
-import { AudioCapture, AudioContextFactory, AudioPlayback, CreateAudioCaptureParameters, CreateAudioPlaybackParameters, Device, Volume } from './audioController';
+import { AudioContextFactory, CreateAudioCaptureParameters, CreateAudioPlaybackParameters, Device } from './mediaController';
+import { ConnectionPool } from './connectionPool';
 import { MainConnection } from './mainConnection';
-export type Media = Backend.Media;
-export type JoinRoomParameters = Backend.JoinRoomParameters;
+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 {
-    readonly version = "1";
+export declare enum Transport {
+    H3 = "h3",
+    WebRTC = "webrtc"
+}
+export interface WebPluginOptions {
+    transport: Transport;
+}
+export declare class WebPlugin implements Plugin {
+    readonly options: WebPluginOptions;
+    readonly version = "2";
     private _NextRoomId;
     private _PlaybackVolume;
     private readonly _ConnectionPool;
-    private readonly _AudioController;
+    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>;
     createAudioCapture(parameters: CreateAudioCaptureParameters): Promise<AudioCapture>;
+    createVideoCapture(ms: MediaStream, customType?: string): Promise<VideoCapture>;
+    createVideoPlayback(parameters: Backend.CreateVideoPlaybackParameters): Promise<VideoPlayback>;
     enumerateDevices(): Promise<Device[]>;
-    setOutputVolume(volume: Volume): void;
+    setOutputVolume(volume: Backend.Volume): void;
     setOutputDevice(device: DeviceParameters): Promise<void>;
     close(): void;
 }
@@ -34,10 +50,12 @@ 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;
+    get cipher(): Backend.Cipher | undefined;
     request(method: string, properties: unknown): Promise<unknown>;
-    link(media: Media): void;
-    unlink(media: Media): void;
+    link(media: Backend.Media): Promise<void>;
+    unlink(media: Backend.Media): void;
     close(): void;
     private _HandleEvent;
     private _HandleKnownEvent;
@@ -50,4 +68,3 @@ export declare class Room implements Backend.Room {
     private _HandleMediaStart;
     private _HandleMediaStopped;
 }
-//# sourceMappingURL=index.d.ts.map

package/lib/plugin/index.js

@@ -0,0 +1,404 @@
+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 { assert, generateUUID, OdinError, RoomNotificationsRpc, unwrap, } 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';
+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, options) {
+        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 MediaController(audioContexts, pool.sendDatagram.bind(pool));
+            return new WebPlugin(pool, audioController, options);
+        });
+    }
+    constructor(connectionPool, audioController, options = { transport: Transport.H3 }) {
+        this.options = options;
+        this.version = '2';
+        this._NextRoomId = 0;
+        this._PlaybackVolume = 1;
+        this._ConnectionPool = connectionPool;
+        this._MediaController = audioController;
+    }
+    joinRoom(parameters) {
+        return new Room(this._NextRoomId++, this._ConnectionPool, parameters, this.options);
+    }
+    createAudioPlayback(parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._MediaController.createAudioPlayback(parameters);
+        });
+    }
+    createAudioCapture(parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 enumerateDevices();
+    }
+    setOutputVolume(volume) {
+        this._MediaController.playbackSetGlobalVolume(volume);
+    }
+    setOutputDevice(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._MediaController.playbackSetDevice(device.device);
+        });
+    }
+    close() {
+        logger.debug(['Other', 'Plugin.close()']);
+        this._MediaController.close();
+        this._ConnectionPool.close();
+    }
+}
+export class Room {
+    get mainConnection() {
+        return this._Connection.mainConnection;
+    }
+    constructor(id, connectionPool, parameters, options) {
+        var _a, _b, _c;
+        this._Captures = new Map();
+        this._Playbacks = new Map();
+        this._Peers = new Map();
+        this._AvailableMediaIds = [];
+        const { gateway, onEvent } = parameters;
+        const token = unwrap(Token.parse(parameters.token));
+        const roomId = (_a = parameters.roomId) !== null && _a !== void 0 ? _a : token.defaultRoomId;
+        const userData = (_b = parameters.userData) !== null && _b !== void 0 ? _b : new Uint8Array(0);
+        const position = (_c = parameters.position) !== null && _c !== void 0 ? _c : [0, 0, 0];
+        assert(roomId !== undefined, 'room id required for multi-room-tokens');
+        this._Id = id;
+        this._OnEvent = onEvent;
+        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;
+    }
+    get cipher() {
+        return undefined; // not implemented
+    }
+    request(method, properties) {
+        return this._Connection.request(method, properties);
+    }
+    link(media) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            logger.debug(['Audio'], 'Room.link() media', media);
+            if (media instanceof AudioPlayback) {
+                const entry = (_a = this._Playbacks.get(media.uid)) !== null && _a !== void 0 ? _a : {
+                    media: undefined,
+                    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);
+            }
+            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);
+                }
+            }
+            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);
+                    }
+                }
+            }
+            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]));
+                    }
+                }
+                entry.playback = media;
+                this._Playbacks.set(media.uid, entry);
+            }
+            else {
+                throw new OdinError('invalid media');
+            }
+        });
+    }
+    unlink(media) {
+        var _a, _b;
+        logger.debug(['Audio'], 'Room.unlink() media', media);
+        if (media instanceof AudioPlayback || media instanceof VideoPlayback) {
+            const entry = this._Playbacks.get(media.uid);
+            if ((entry === null || entry === void 0 ? void 0 : entry.playback) !== media)
+                return;
+            entry.playback = undefined;
+            if (entry.media !== undefined) {
+                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 || 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);
+        }
+        else {
+            throw new Error('invalid media');
+        }
+    }
+    close() {
+        logger.debug(['Other', 'Room.close()']);
+        this._Connection.close();
+    }
+    _HandleEvent(method, properties) {
+        const rpc = parseRpcMessage(RoomNotificationsRpc, {
+            name: method,
+            properties,
+        });
+        if (rpc !== undefined) {
+            this._HandleKnownEvent(rpc);
+            properties = rpc.properties;
+        }
+        this._OnEvent(method, properties);
+    }
+    _HandleKnownEvent(event) {
+        switch (event.name) {
+            case 'RoomStatusChanged':
+                if (event.properties.status !== 'Joined') {
+                    this._HandleConnectionLost();
+                }
+                break;
+            case 'RoomUpdated':
+                for (const update of event.properties.updates) {
+                    this._HandleRoomUpdate(update);
+                }
+                break;
+            case 'PeerUpdated':
+                this._HandlePeerUpdate(event.properties);
+                break;
+        }
+    }
+    _HandleConnectionLost() {
+        for (const peerId of this._Peers.keys()) {
+            this._HandlePeerLeft(peerId);
+        }
+        for (const [capture, entry] of this._Captures) {
+            if (entry.media === undefined)
+                continue;
+            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;
+    }
+    _HandleRoomUpdate(update) {
+        if (update.kind === 'Joined') {
+            assert(this._AvailableMediaIds.length === 0, 'left over media ids');
+            this._AvailableMediaIds.push(...update.media_ids);
+            this._HandleRoomJoined();
+            for (const peer of update.room.peers) {
+                this._HandlePeerJoined(peer);
+            }
+        }
+        else if (update.kind === 'PeerJoined') {
+            this._HandlePeerJoined(update.peer);
+        }
+        else if (update.kind === 'PeerLeft') {
+            this._HandlePeerLeft(update.peer_id);
+        }
+    }
+    _HandleRoomJoined() {
+        for (const [capture, entry] of this._Captures) {
+            if (this._AvailableMediaIds.length === 0 ||
+                this.mainConnection === undefined) {
+                continue;
+            }
+            entry.media = {
+                connectionId: this.mainConnection.id,
+                mediaId: this._AvailableMediaIds.shift(),
+            };
+            if (capture instanceof AudioCapture) {
+                capture.start(this._Connection, entry.media, entry.uid);
+            }
+            if (capture instanceof VideoCapture) {
+                // @TODO Check if it needs implementation
+            }
+        }
+    }
+    _HandlePeerUpdate(update) {
+        if (update.kind === 'MediaStarted') {
+            this._HandleMediaStart(update.peer_id, update.media);
+        }
+        else if (update.kind === 'MediaStopped') {
+            this._HandleMediaStopped(update.peer_id, update.media_id);
+        }
+    }
+    _HandlePeerJoined(peer) {
+        if (!this._Peers.has(peer.id)) {
+            this._Peers.set(peer.id, { mediaIds: new Map() });
+        }
+        for (const media of peer.medias) {
+            this._HandleMediaStart(peer.id, media);
+        }
+    }
+    _HandlePeerLeft(peerId) {
+        const entry = this._Peers.get(peerId);
+        if (entry === undefined)
+            return;
+        for (const mediaId of entry.mediaIds.keys()) {
+            this._HandleMediaStopped(peerId, mediaId);
+        }
+        this._Peers.delete(peerId);
+    }
+    _HandleMediaStart(peerId, media) {
+        var _a, _b;
+        if (this.mainConnection === undefined)
+            return;
+        const peer = this._Peers.get(peerId);
+        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());
+        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,
+            playback: undefined,
+        };
+        this._Playbacks.set(uid, entry);
+        peer.mediaIds.set(media.id, uid);
+        entry.media = {
+            connectionId: this.mainConnection.id,
+            mediaId: media.id,
+        };
+        if (entry.playback !== undefined) {
+            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;
+        const uid = peer === null || peer === void 0 ? void 0 : peer.mediaIds.get(mediaId);
+        if (uid === undefined)
+            return;
+        const entry = this._Playbacks.get(uid);
+        if (entry === undefined)
+            return;
+        if (entry.media !== undefined && entry.playback !== undefined) {
+            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

@@ -0,0 +1,30 @@
+import { Result } from '@4players/odin-common';
+import { Token } from './token';
+import { Transport } from './index';
+import { RpcConnection } from './rpcConnection';
+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 {
+    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;
+    waitForConnected(): Promise<void>;
+    close(): 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>;
+    sendDatagram(datagram: Uint8Array): void;
+    startLocalVideo(mediaId: number, track: MediaStreamTrack): void;
+    stopLocalVideo(mediaId: number): void;
+    startRemoteVideo(mediaId: number): Promise<MediaStreamTrack>;
+    stopRemoteVideo(mediaId: number): void;
+}

package/lib/plugin/mainConnection.js

@@ -0,0 +1,21 @@
+/* eslint-disable no-dupe-class-members */
+import { logger, Transport } from './index';
+import { WebRtcMainConnection } from './webrtc/mainConnection';
+import { H3MainConnection } from './h3/mainConnection';
+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/{backend/lib/audioController.d.ts → lib/plugin/mediaController.d.ts}

@@ -1,9 +1,8 @@
 import { Backend, Strand } from '@4players/odin-common';
-import { DeviceParameters } from '.';
-import { CaptureSink, PlaybackId, PlaybackWorker } from '@4players/odin-plugin-web-worker';
-import { RoomConnection } from './roomConnection';
-export type Volume = Backend.Volume;
-export type Activity = Backend.Activity;
+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;
@@ -31,30 +30,30 @@ 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;
     globalVolume: number;
     playbacks: Map<string, {
         id: GlobalMediaId | undefined;
-        volume: Volume;
+        volume: Backend.Volume;
         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[]>;
-    playbackSetDevice(device: Device | undefined): Promise<void>;
+    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): Activity;
-    playbackSetVolume(uid: string, volume: Volume): void;
-    playbackGetVolume(uid: string): Volume;
+    playbackGetActivity(uid: string): Backend.Activity;
+    playbackSetVolume(uid: string, volume: Backend.Volume): void;
+    playbackGetVolume(uid: string): Backend.Volume;
     closePlayback(uid: string): void;
     close(): void;
 }
@@ -65,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("@4players/odin-plugin-web-worker").Activity;
-    get speechProbability(): number;
-    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>;
-}
-//# sourceMappingURL=audioController.d.ts.map