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

package/lib/plugin/h3/mainConnection.js

@@ -1,195 +0,0 @@
-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 { ConnectionStatus, } from '../mainConnection';
-import { MainCommandsRpc, MainNotificationsRpc, RoomCommandsRpc, RoomNotificationsRpc, failure, success, } from '@4players/odin-common';
-import { logger, Transport } from '..';
-import { Token } from '../token';
-import { RpcConnection, TypedRpcConnection } from '../rpcConnection';
-import { HealthCheckTimeout } from '../config';
-import * as pkg from '../../../package.json';
-export class H3MainConnection {
-    get closeSignal() {
-        return this.closeController.signal;
-    }
-    get transport() {
-        return Transport.H3;
-    }
-    get closed() {
-        return this.closeSignal.aborted;
-    }
-    static create(id, address, onDatagram, signal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const url = new URL(`https://${address}?version=${pkg.version}`);
-                const closeController = new AbortController();
-                signal.addEventListener('abort', () => closeController.abort(), {
-                    once: true,
-                });
-                const connection = new WebTransport(url);
-                closeController.signal.addEventListener('abort', () => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        yield connection.close();
-                    }
-                    catch (_a) {
-                        /* drop silently */
-                    }
-                }), { once: true });
-                yield connection.ready;
-                const stream = yield connection.createBidirectionalStream();
-                const rpc = new TypedRpcConnection(new RpcConnection(stream), MainCommandsRpc, MainNotificationsRpc);
-                closeController.signal.addEventListener('abort', () => rpc.close(), {
-                    once: true,
-                });
-                rpc.notify('Hello', { stream: 'main' });
-                return success(new H3MainConnection(id, address, onDatagram, connection, rpc, closeController));
-            }
-            catch (error) {
-                return failure(`connecting to ${address} failed with ${error}`);
-            }
-        });
-    }
-    constructor(id, address, onDatagram, connection, rpc, closeController) {
-        this.id = id;
-        this.address = address;
-        this.connection = connection;
-        this.rpc = rpc;
-        this.closeController = closeController;
-        this.status = ConnectionStatus.Connecting;
-        logger.info(['Connection', 'H3'], 'H3MainConnection.constructor()');
-        this.closePromise = (() => __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.connection.closed;
-            }
-            catch (_a) {
-                /* drop silently */
-            }
-            return 'closed';
-        }))();
-        this.datagramWriter = connection.datagrams.writable.getWriter();
-        this.connection.closed
-            .then(() => {
-            this.status = ConnectionStatus.Closed;
-        })
-            .catch(() => {
-            /* drop silently */
-        });
-        this.connection.ready
-            .then(() => {
-            this.status = ConnectionStatus.Connected;
-        })
-            .catch(() => {
-            /* drop silently */
-        });
-        readDatagrams(this.connection, this.id, onDatagram);
-    }
-    waitForConnected() {
-        return Promise.race([
-            this.connection.ready,
-            this.connection.closed.then(() => {
-                throw new Error('connection closed');
-            }),
-        ]);
-    }
-    close() {
-        this.closeController.abort('request');
-    }
-    joinRoom(token, roomId, userData, position) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (this.closed)
-                    return 'closed';
-                const stream = yield this.connection
-                    .createBidirectionalStream()
-                    .catch(() => 'closed');
-                if (stream === 'closed')
-                    return 'closed';
-                const rpc = new TypedRpcConnection(new RpcConnection(stream), RoomCommandsRpc, RoomNotificationsRpc);
-                const response = yield rpc.request('Hello', {
-                    stream: 'room',
-                    token: String(token),
-                    room_id: roomId,
-                    user_data: userData,
-                    position,
-                });
-                if (response === 'closed' || response.type === 'Failure')
-                    return response;
-                return success(rpc.rpcConnection);
-            }
-            catch (error) {
-                return failure(`JoinRoom failed; ${error}`);
-            }
-        });
-    }
-    getReconnectToken(peerId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this._Request('RequestReconnectToken', {
-                peer_id: peerId,
-            });
-            if (response.type === 'Failure')
-                return response;
-            return Token.parse(response.value);
-        });
-    }
-    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;
-        });
-    }
-    sendDatagram(datagram) {
-        try {
-            this.datagramWriter.write(datagram);
-        }
-        catch (_a) {
-            /* drop silently */
-        }
-    }
-    startLocalVideo(mediaId, track) {
-        throw new Error('not supported.');
-    }
-    stopLocalVideo(mediaId) {
-        throw new Error('not supported.');
-    }
-    startRemoteVideo(mediaId) {
-        throw new Error('not supported.');
-    }
-    stopRemoteVideo(mediaId) {
-        throw new Error('not supported.');
-    }
-    _Request(name, properties, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield (timeout === undefined
-                ? this.rpc.request(name, properties)
-                : this.rpc.request(name, properties, timeout));
-            if (result === 'closed')
-                return failure('connection lost');
-            return result;
-        });
-    }
-}
-function readDatagrams(connection, connectionId, onDatagram) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const reader = connection.datagrams.readable.getReader();
-            for (;;) {
-                const read = yield reader.read();
-                if (read.done)
-                    break;
-                onDatagram(connectionId, read.value);
-            }
-        }
-        catch (_a) {
-            /* drop silently */
-        }
-    });
-}

package/lib/plugin/mainConnection.d.ts

@@ -1,30 +0,0 @@
-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

@@ -1,21 +0,0 @@
-/* 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/lib/plugin/mediaController.d.ts

@@ -1,66 +0,0 @@
-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

@@ -1,215 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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>;
-}