TeaWeb/shared/js/connection/DummyVoiceConnection.ts

import {
    AbstractVoiceConnection,
    VoiceConnectionStatus, WhisperSessionInitializer
} from "tc-shared/connection/VoiceConnection";
import {RecorderProfile} from "tc-shared/voice/RecorderProfile";
import {AbstractServerConnection} from "tc-shared/connection/ConnectionBase";
import {VoiceClient} from "tc-shared/voice/VoiceClient";
import {VoicePlayerLatencySettings, VoicePlayerState} from "tc-shared/voice/VoicePlayer";
import {WhisperSession} from "tc-shared/voice/VoiceWhisper";

class DummyVoiceClient implements VoiceClient {
    private readonly clientId: number;
    private volume: number;

    constructor(clientId: number) {
        this.clientId = clientId;
        this.volume = 1;
    }

    getClientId(): number {
        return this.clientId;
    }

    getVolume(): number {
        return this.volume;
    }

    setVolume(volume: number) {
        this.volume = volume;
    }

    getState(): VoicePlayerState {
        return VoicePlayerState.STOPPED;
    }

    getLatencySettings(): Readonly<VoicePlayerLatencySettings> {
        return { maxBufferTime: 0, minBufferTime: 0 };
    }

    setLatencySettings(settings) { }

    flushBuffer() { }
    abortReplay() { }
}

export class DummyVoiceConnection extends AbstractVoiceConnection {
    private recorder: RecorderProfile;
    private voiceClients: DummyVoiceClient[] = [];

    constructor(connection: AbstractServerConnection) {
        super(connection);
    }

    async acquireVoiceRecorder(recorder: RecorderProfile | undefined): Promise<void> {
        if(this.recorder === recorder)
            return;

        if(this.recorder) {
            this.recorder.callback_unmount = undefined;
            await this.recorder.unmount();
        }

        await recorder?.unmount();
        this.recorder = recorder;

        if(this.recorder) {
            this.recorder.callback_unmount = () => {
                this.recorder = undefined;
                this.events.fire("notify_recorder_changed");
            }
        }

        this.events.fire("notify_recorder_changed", {});
    }

    availableVoiceClients(): VoiceClient[] {
        return this.voiceClients;
    }

    decodingSupported(codec: number): boolean {
        return false;
    }

    encodingSupported(codec: number): boolean {
        return false;
    }

    getConnectionState(): VoiceConnectionStatus {
        return VoiceConnectionStatus.ClientUnsupported;
    }

    getEncoderCodec(): number {
        return 0;
    }

    async registerVoiceClient(clientId: number): Promise<VoiceClient> {
        const client = new DummyVoiceClient(clientId);
        this.voiceClients.push(client);
        return client;
    }

    setEncoderCodec(codec: number) {}

    async unregisterVoiceClient(client: VoiceClient): Promise<void> {
        this.voiceClients.remove(client as any);
    }

    voiceRecorder(): RecorderProfile {
        return this.recorder;
    }

    dropWhisperSession(session: WhisperSession) { }

    getWhisperSessionInitializer(): WhisperSessionInitializer | undefined {
        return undefined;
    }

    getWhisperSessions(): WhisperSession[] {
        return [];
    }

    setWhisperSessionInitializer(initializer: WhisperSessionInitializer | undefined) { }
}