@polyvharmony/live-scenes-sdk 1.2.0-rc.1

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/teacher/LinkMicTeacherHandleStateUseCase.d.ets

@@ -0,0 +1,49 @@
+import { PLVLinkMicRepo } from '../../../../model/PLVLinkMicRepo';
+import { PLVLinkMicMode } from '../../../../model/vo/PLVLinkMicMode';
+import { ILinkMicHandleStateUseCase } from '../base/ILinkMicHandleStateUseCase';
+import { LinkMicHandleQueueOrderUseCase } from '../../LinkMicHandleQueueOrderUseCase';
+import { LinkMicHandleRTCUseCase } from '../../LinkMicHandleRTCUseCase';
+import { LinkMicUpdateChannelViewerUseCase } from '../../LinkMicUpdateChannelViewerUseCase';
+export declare class LinkMicTeacherHandleStateUseCase implements ILinkMicHandleStateUseCase {
+    private readonly repo;
+    private readonly handleQueueOrderUseCase;
+    private readonly handleRTCUseCase;
+    private readonly updateChannelViewerUseCase;
+    private lastEmitLinkMicStatusModeUpdatePromise;
+    private disposables;
+    private observers;
+    constructor(j148: PLVLinkMicRepo, k148: LinkMicHandleQueueOrderUseCase, l148: LinkMicHandleRTCUseCase, m148: LinkMicUpdateChannelViewerUseCase);
+    init(): void;
+    requestJoinLinkMic(): Promise<void>;
+    acceptInvitation(): Promise<void>;
+    refuseInvitation(): void;
+    leaveLinkMic(): void;
+    onStreamerStart(): void;
+    onLiveStreamStart(): void;
+    setLinkMicMode(c148: PLVLinkMicMode): Promise<boolean>;
+    openLinkMic(): Promise<boolean>;
+    closeLinkMic(): Promise<boolean>;
+    private emitLinkMicStatusModeUpdate;
+    acceptViewerLinkMicRequest(w147: string): void;
+    inviteViewerLinkMic(u147: string, v147: boolean): void;
+    hangupViewerLinkMic(r147: string): void;
+    hangupAllViewersLinkMic(): void;
+    setViewerEnableCamera(o147: string, enable: boolean): void;
+    setViewerEnableMicrophone(m147: string, enable: boolean): void;
+    grantSpeaker(l147: string): void;
+    revokeSpeaker(j147: string): void;
+    setMainView(g147: string): void;
+    private moveSpeaker;
+    onLiveStreamStop(): void;
+    onStreamerStop(): void;
+    updateInvitationExpireTime(): void;
+    private onSocketMessage;
+    private onSocketTeacherSetPermission;
+    private onSocketUserSetNick;
+    private onSocketJoinAnswer;
+    private onSocketJoinSuccess;
+    private onSocketJoinLeave;
+    private onSocketSwitchView;
+    onDestroy(): void;
+    private observeSocketEvent;
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/teacher/LinkMicTeacherHandleStateUseCase.js

@@ -0,0 +1,254 @@
+import { PLVDisposable, PLVLogger, PLVRequestSetting } from '@polyvharmony/live-scenes-foundation';
+import { decodeFromJson, delay, encodeToJson, isLiteralTrue, isNullOrUndefined, MutableObserver, Promises, requireNotNull, runCatching } from '@polyvharmony/media-player-sdk';
+import { PLVSocketMessageEvent, PLVSocketOnEvent } from '../../../../../socket/model/PLVSocketEventConstants';
+import { PLVLinkMicMode } from '../../../../model/vo/PLVLinkMicMode';
+import { PLVLinkMicSocketJoinAnswerRecv, PLVLinkMicSocketJoinLeaveRecv, PLVLinkMicSocketJoinSuccessRecv, PLVLinkMicSocketMuteUserMediaSend, PLVLinkMicSocketOpenMicrophoneSend, PLVLinkMicSocketSwitchViewRecv, PLVLinkMicSocketSwitchViewSend, PLVLinkMicSocketTeacherSetPermissionRecv, PLVLinkMicSocketTeacherSetPermissionSend } from '../../../../model/vo/PLVLinkMicSocketEvent';
+import { PLVLinkMicState } from '../../../../model/vo/PLVLinkMicState';
+import { PLVMemberSocketSetNickRecv } from '../../../../../member/model/vo/PLVMemberSocketEvent';
+import { PLVLinkMicAnswerInvitationEvent } from '../../../../model/vo/PLVLinkMicInteractEvent';
+const TAG = "PLVLinkMicManager";
+export class LinkMicTeacherHandleStateUseCase {
+    constructor(j148, k148, l148, m148) {
+        this.lastEmitLinkMicStatusModeUpdatePromise = null;
+        this.disposables = [];
+        this.observers = [];
+        this.repo = j148;
+        this.handleQueueOrderUseCase = k148;
+        this.handleRTCUseCase = l148;
+        this.updateChannelViewerUseCase = m148;
+    }
+    init() {
+        this.disposables.push(this.observeSocketEvent(PLVSocketOnEvent.MESSAGE, (data, event) => this.onSocketMessage(data, event)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_ANSWER, (data) => this.onSocketJoinAnswer(data)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_SUCCESS, (data) => this.onSocketJoinSuccess(data)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_LEAVE, (data) => this.onSocketJoinLeave(data)), this.observeSocketEvent(PLVSocketOnEvent.SWITCH_VIEW, (data) => this.onSocketSwitchView(data)));
+    }
+    async requestJoinLinkMic() {
+    }
+    async acceptInvitation() {
+    }
+    refuseInvitation() {
+    }
+    leaveLinkMic() {
+    }
+    onStreamerStart() {
+        this.repo.mediator.linkmicState.setValue(PLVLinkMicState.Joined);
+        this.handleRTCUseCase.joinChannel();
+        this.updateChannelViewerUseCase.startUpdateChannelLinkMicViewersInterval();
+        this.updateChannelViewerUseCase.handleChannelLinkMicViewersUpdate({
+            add: [this.repo.mediator.localLinkMicViewer.value]
+        });
+    }
+    onLiveStreamStart() {
+    }
+    async setLinkMicMode(c148) {
+        const d148 = this.repo.mediator.channelAllowRequestHandsUpLinkMic.value ?? false;
+        this.repo.mediator.channelLinkMicMode.setValue(c148);
+        if (this.repo.mediator.isLinkMicStrategyV2.value === true) {
+            if (!d148) {
+                return await this.closeLinkMic();
+            }
+            else {
+                this.hangupAllViewersLinkMic();
+                return await this.openLinkMic();
+            }
+        }
+        else {
+            return true;
+        }
+    }
+    async openLinkMic() {
+        this.repo.mediator.channelAllowLinkMic.setValue(true);
+        this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(true);
+        return await this.emitLinkMicStatusModeUpdate();
+    }
+    async closeLinkMic() {
+        if (this.repo.mediator.isLinkMicStrategyV2.value === true) {
+            this.repo.mediator.channelAllowLinkMic.setValue(true);
+            this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(false);
+        }
+        else {
+            this.repo.mediator.channelAllowLinkMic.setValue(false);
+            this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(false);
+        }
+        return await this.emitLinkMicStatusModeUpdate();
+    }
+    async emitLinkMicStatusModeUpdate() {
+        await this.lastEmitLinkMicStatusModeUpdatePromise;
+        const result = Promises.withResolvers();
+        this.lastEmitLinkMicStatusModeUpdatePromise = result.promise;
+        const x147 = this.repo.mediator.channelAllowRequestHandsUpLinkMic.value ?? false;
+        const y147 = this.repo.mediator.channelLinkMicMode.value ?? PLVLinkMicMode.VIDEO;
+        const z147 = new PLVLinkMicSocketOpenMicrophoneSend();
+        z147.roomId = this.repo.mediator.channelData?.loginChannelId;
+        z147.status = x147 ? "open" : "close";
+        z147.teacherId = this.repo.mediator.channelData?.viewerId;
+        z147.type = y147;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(z147), () => {
+            result.resolve(true);
+        });
+        runCatching(async () => {
+            await delay(1000);
+            result.resolve(false);
+        });
+        return result.promise;
+    }
+    acceptViewerLinkMicRequest(w147) {
+        this.repo.mediator.memberMediator?.acceptViewerLinkMicRequest?.(w147);
+    }
+    inviteViewerLinkMic(u147, v147) {
+        this.repo.mediator.memberMediator?.inviteViewerLinkMic?.(u147, v147);
+    }
+    hangupViewerLinkMic(r147) {
+        const s147 = this.repo.mediator.findViewerByViewerId(r147);
+        const t147 = this.repo.mediator.channelMainViewLinkMicId.value;
+        if (!isNullOrUndefined(t147) && s147?.linkmicId === t147) {
+            this.revokeSpeaker("");
+        }
+        this.repo.mediator.memberMediator?.hangupViewerLinkMic?.(r147);
+    }
+    hangupAllViewersLinkMic() {
+        const q147 = new PLVLinkMicSocketOpenMicrophoneSend();
+        q147.status = "removeAll";
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(q147));
+    }
+    setViewerEnableCamera(o147, enable) {
+        const p147 = new PLVLinkMicSocketMuteUserMediaSend();
+        p147.sessionId = this.repo.mediator.channelData?.sessionId;
+        p147.mute = !enable;
+        p147.teacherId = this.repo.mediator.channelData?.viewerId;
+        p147.userId = o147;
+        p147.type = "video";
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(p147));
+    }
+    setViewerEnableMicrophone(m147, enable) {
+        const n147 = new PLVLinkMicSocketMuteUserMediaSend();
+        n147.sessionId = this.repo.mediator.channelData?.sessionId;
+        n147.mute = !enable;
+        n147.teacherId = this.repo.mediator.channelData?.viewerId;
+        n147.userId = m147;
+        n147.type = "audio";
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(n147));
+    }
+    grantSpeaker(l147) {
+        this.moveSpeaker(l147);
+        this.setMainView(l147);
+    }
+    revokeSpeaker(j147) {
+        const k147 = requireNotNull(this.repo.mediator.channelData?.viewerId);
+        this.moveSpeaker(k147);
+        this.setMainView(k147);
+    }
+    setMainView(g147) {
+        const h147 = this.repo.mediator.memberMediator?.findViewerByViewerId(g147);
+        if (h147 === undefined) {
+            PLVLogger.error(TAG, `setMainView fail, viewerId ${g147} not found.`);
+            return;
+        }
+        const i147 = new PLVLinkMicSocketSwitchViewSend();
+        i147.emitMode = 0;
+        i147.roomId = this.repo.mediator.channelData?.loginChannelId;
+        i147.userId = h147.linkmicId;
+        i147.socketId = h147.socketId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.SWITCH_VIEW, encodeToJson(i147));
+    }
+    moveSpeaker(e147) {
+        const f147 = new PLVLinkMicSocketTeacherSetPermissionSend();
+        f147.emitMode = 0;
+        f147.roomId = this.repo.mediator.channelData?.loginChannelId;
+        f147.sessionId = this.repo.mediator.channelData?.sessionId;
+        f147.type = "speaker";
+        f147.status = "1";
+        f147.userId = e147;
+        f147.sign = PLVRequestSetting.createSign(new Map(Object.entries(f147)), "polyvChatSign")
+            .toUpperCase();
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(f147));
+    }
+    onLiveStreamStop() {
+    }
+    onStreamerStop() {
+        this.closeLinkMic();
+        this.updateChannelViewerUseCase.stopUpdateChannelLinkMicViewersInterval();
+        this.updateChannelViewerUseCase.handleChannelLinkMicViewersUpdate({
+            remove: [this.repo.mediator.localLinkMicViewer.value]
+        });
+        this.repo.mediator.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+        this.handleRTCUseCase.leaveChannel();
+    }
+    updateInvitationExpireTime() {
+    }
+    onSocketMessage(data, event) {
+        switch (event) {
+            case PLVSocketMessageEvent.TEACHER_SET_PERMISSION: return this.onSocketTeacherSetPermission(data);
+            case PLVSocketMessageEvent.SET_NICK: return this.onSocketUserSetNick(data);
+            default:
+        }
+    }
+    onSocketTeacherSetPermission(data) {
+        const d147 = decodeFromJson(data, PLVLinkMicSocketTeacherSetPermissionRecv);
+        this.updateChannelViewerUseCase.onEventTeacherSetPermission(d147);
+    }
+    onSocketUserSetNick(data) {
+        const a147 = decodeFromJson(data, PLVMemberSocketSetNickRecv);
+        const b147 = a147.userId;
+        const c147 = this.repo.mediator.findViewerByViewerId(b147);
+        if (c147 !== undefined) {
+            c147.viewerName.setValue(a147.nick);
+        }
+    }
+    onSocketJoinAnswer(data) {
+        const w146 = decodeFromJson(data, PLVLinkMicSocketJoinAnswerRecv);
+        const x146 = w146.userId;
+        if (isNullOrUndefined(x146)) {
+            return;
+        }
+        const y146 = this.repo.mediator.memberMediator?.findViewerByViewerId(x146);
+        if (y146 !== undefined) {
+            const z146 = isLiteralTrue(w146.status);
+            this.repo.mediator.viewerAnswerInvitationEvent.setValue(new PLVLinkMicAnswerInvitationEvent(y146, z146));
+        }
+    }
+    onSocketJoinSuccess(data) {
+        const v146 = decodeFromJson(data, PLVLinkMicSocketJoinSuccessRecv);
+        this.updateChannelViewerUseCase.onEventJoinSuccess(v146);
+    }
+    onSocketJoinLeave(data) {
+        const t146 = decodeFromJson(data, PLVLinkMicSocketJoinLeaveRecv);
+        this.updateChannelViewerUseCase.onEventJoinLeave(t146);
+        const u146 = this.repo.mediator.channelMainViewLinkMicId.value;
+        if (!isNullOrUndefined(u146) && t146.user?.userId === u146) {
+            this.revokeSpeaker("");
+        }
+    }
+    onSocketSwitchView(data) {
+        const s146 = decodeFromJson(data, PLVLinkMicSocketSwitchViewRecv);
+        if (isNullOrUndefined(s146.userId)) {
+            return;
+        }
+        this.repo.mediator.channelMainViewLinkMicId.setValue(s146.userId);
+        this.updateChannelViewerUseCase.onEventSwitchView(s146);
+    }
+    onDestroy() {
+        this.disposables.forEach((r146) => {
+            r146.dispose();
+        });
+        this.disposables = [];
+        MutableObserver.disposeAll(this.observers);
+        this.observers = [];
+    }
+    observeSocketEvent(event, callback) {
+        const o146 = requireNotNull(this.repo.mediator.socketMediator);
+        o146.onData(event, callback);
+        return disposable(() => o146.offData(event, callback));
+    }
+}
+class SocketDisposable extends PLVDisposable {
+    constructor(n146) {
+        super();
+        this.onDispose = n146;
+    }
+    dispose() {
+        super.dispose();
+        this.onDispose?.();
+    }
+}
+function disposable(m146) {
+    return new SocketDisposable(m146);
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/viewer/LinkMicViewerEncodeParamUseCase.d.ets

@@ -0,0 +1,15 @@
+import { PLVLinkMicRepo } from '../../../../model/PLVLinkMicRepo';
+import { PLVPushDowngradePreference, PLVPushOrientation } from '@polyvharmony/rtc-sdk';
+import { ILinkMicEncodeParamUseCase } from '../base/ILinkMicEncodeParamUseCase';
+import { PLVLinkMicBitRate } from '../../../../model/vo/PLVLinkMicBitRate';
+import { PLVLinkMicPushResolutionRatio } from '../../../../model/vo/PLVLinkMicPushResolutionRatio';
+export declare class LinkMicViewerEncodeParamUseCase implements ILinkMicEncodeParamUseCase {
+    private readonly repo;
+    constructor(s148: PLVLinkMicRepo);
+    init(): void;
+    setBitRate(bitRate: PLVLinkMicBitRate): void;
+    setPushResolutionRatio(q148: PLVLinkMicPushResolutionRatio): void;
+    setPushOrientation(p148: PLVPushOrientation): void;
+    setPushMirror(o148: boolean): void;
+    setPushDowngradePreference(n148: PLVPushDowngradePreference): void;
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/viewer/LinkMicViewerEncodeParamUseCase.js

@@ -0,0 +1,24 @@
+import { PLVRTCVideoEncodeParam } from '@polyvharmony/rtc-sdk';
+export class LinkMicViewerEncodeParamUseCase {
+    constructor(s148) {
+        this.repo = s148;
+    }
+    init() {
+        const r148 = new PLVRTCVideoEncodeParam();
+        r148.width = 320;
+        r148.height = 180;
+        r148.frameRate = 15;
+        r148.targetBitRate = 400;
+        this.repo.setLocalVideoEncodeParam(r148);
+    }
+    setBitRate(bitRate) {
+    }
+    setPushResolutionRatio(q148) {
+    }
+    setPushOrientation(p148) {
+    }
+    setPushMirror(o148) {
+    }
+    setPushDowngradePreference(n148) {
+    }
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/viewer/LinkMicViewerHandleRTCUseCase.d.ets

@@ -0,0 +1,26 @@
+import { PLVRTCClientRole } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicRepo } from '../../../../model/PLVLinkMicRepo';
+import { PLVLinkMicVideoRenderParam } from '../../../../model/vo/PLVLinkMicVideoRenderParam';
+import { ILinkMicHandleRTCUseCase } from '../base/ILinkMicHandleRTCUseCase';
+export declare class LinkMicViewerHandleRTCUseCase implements ILinkMicHandleRTCUseCase {
+    private readonly repo;
+    private observers;
+    private lastEnableCamera;
+    private lastEnableMicrophone;
+    constructor(f149: PLVLinkMicRepo);
+    init(): void;
+    joinChannel(): void;
+    leaveChannel(): void;
+    switchRole(role: PLVRTCClientRole): void;
+    enableCamera(enable: boolean): void;
+    enableMicrophone(enable: boolean): void;
+    enableCameraMicrophoneToLastState(): void;
+    switchCamera(): void;
+    setLocalRenderMirror(b149: boolean): void;
+    setupVideoRender(z148: PLVLinkMicVideoRenderParam): void;
+    removeVideoRender(x148: PLVLinkMicVideoRenderParam): void;
+    onDestroy(): void;
+    private updateLastEnableCamera;
+    private updateLastEnableMicrophone;
+    private getVideoRenderParam;
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/viewer/LinkMicViewerHandleRTCUseCase.js

@@ -0,0 +1,106 @@
+import { MutableObserver } from '@polyvharmony/media-player-sdk';
+import { PLVRTCClientRole, PLVRTCVideoRenderParam, PLVVideoRenderFitMode } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicCameraFacing } from '../../../../model/vo/PLVLinkMicCameraFacing';
+import { PLVLinkMicMode } from '../../../../model/vo/PLVLinkMicMode';
+import { PLVLinkMicState } from '../../../../model/vo/PLVLinkMicState';
+import { PLVLinkMicVideoRenderParam } from '../../../../model/vo/PLVLinkMicVideoRenderParam';
+export class LinkMicViewerHandleRTCUseCase {
+    constructor(f149) {
+        this.observers = [];
+        this.lastEnableCamera = false;
+        this.lastEnableMicrophone = false;
+        this.repo = f149;
+    }
+    init() {
+    }
+    joinChannel() {
+        this.repo.joinRTCChannel();
+        this.switchRole(PLVRTCClientRole.BROADCASTER);
+        this.enableCameraMicrophoneToLastState();
+    }
+    leaveChannel() {
+        this.enableCamera(false);
+        this.enableMicrophone(false);
+        this.repo.leaveRTCChannel();
+    }
+    switchRole(role) {
+        this.repo.switchRTCRole(role);
+    }
+    enableCamera(enable) {
+        this.repo.enableLocalVideo(enable);
+        this.repo.mediator.localLinkMicViewer.value?.isVideoEnable?.setValue(enable);
+        this.updateLastEnableCamera(enable);
+    }
+    enableMicrophone(enable) {
+        this.repo.enableLocalAudio(enable);
+        this.repo.mediator.localLinkMicViewer.value?.isAudioEnable?.setValue(enable);
+        this.updateLastEnableMicrophone(enable);
+    }
+    enableCameraMicrophoneToLastState() {
+        const e149 = this.lastEnableCamera && this.repo.mediator.channelLinkMicMode.value === PLVLinkMicMode.VIDEO;
+        this.enableCamera(e149);
+        this.enableMicrophone(this.lastEnableMicrophone);
+    }
+    switchCamera() {
+        this.repo.mediator.cameraFacing.value = (this.repo.mediator.cameraFacing.value ?? PLVLinkMicCameraFacing.FRONT).switchNext();
+        this.repo.switchCamera();
+    }
+    setLocalRenderMirror(b149) {
+        const c149 = this.repo.mediator.linkmicId;
+        if (c149 === undefined) {
+            return;
+        }
+        this.repo.mediator.localRenderMirror.setValue(b149);
+        const d149 = this.getVideoRenderParam(c149);
+        this.setupVideoRender(new PLVLinkMicVideoRenderParam(c149, d149.viewId));
+    }
+    setupVideoRender(z148) {
+        const a149 = this.getVideoRenderParam(z148.linkmicId);
+        a149.viewId = z148.xcomponentId;
+        if (this.repo.mediator.isMySocketLinkMicId(z148.linkmicId)) {
+            a149.renderMirror = this.repo.mediator.localRenderMirror.value ?? false;
+        }
+        this.repo.setVideoRender(a149);
+    }
+    removeVideoRender(x148) {
+        const y148 = this.getVideoRenderParam(x148.linkmicId);
+        if (x148.xcomponentId === null || y148.viewId === x148.xcomponentId) {
+            y148.viewId = null;
+            this.repo.setVideoRender(y148);
+        }
+    }
+    onDestroy() {
+        MutableObserver.disposeAll(this.observers);
+        this.observers = [];
+    }
+    updateLastEnableCamera(enable) {
+        const w148 = this.repo.mediator.linkmicState.value;
+        if (w148 === PLVLinkMicState.Inviting || w148 === PLVLinkMicState.Joined) {
+            this.lastEnableCamera = enable;
+        }
+    }
+    updateLastEnableMicrophone(enable) {
+        const v148 = this.repo.mediator.linkmicState.value;
+        if (v148 === PLVLinkMicState.Inviting || v148 === PLVLinkMicState.Joined) {
+            this.lastEnableMicrophone = enable;
+        }
+    }
+    getVideoRenderParam(t148) {
+        let param = this.repo.getVideoRenderParam(t148);
+        if (param !== null) {
+            return param;
+        }
+        const u148 = t148 === this.repo.mediator.channelData?.loginChannelId;
+        param = new PLVRTCVideoRenderParam();
+        param.linkmicId = t148;
+        param.viewId = null;
+        if (u148) {
+            param.renderFitMode = PLVVideoRenderFitMode.FIT;
+        }
+        else {
+            param.renderFitMode = PLVVideoRenderFitMode.HIDDEN;
+        }
+        param.renderMirror = false;
+        return param;
+    }
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/viewer/LinkMicViewerHandleStateUseCase.d.ets

@@ -0,0 +1,57 @@
+import { PLVLinkMicRepo } from '../../../../model/PLVLinkMicRepo';
+import { PLVLinkMicMode } from '../../../../model/vo/PLVLinkMicMode';
+import { ILinkMicHandleStateUseCase } from '../base/ILinkMicHandleStateUseCase';
+import { LinkMicHandleQueueOrderUseCase } from '../../LinkMicHandleQueueOrderUseCase';
+import { LinkMicHandleRTCUseCase } from '../../LinkMicHandleRTCUseCase';
+import { LinkMicUpdateChannelViewerUseCase } from '../../LinkMicUpdateChannelViewerUseCase';
+export declare class LinkMicViewerHandleStateUseCase implements ILinkMicHandleStateUseCase {
+    private readonly repo;
+    private readonly handleQueueOrderUseCase;
+    private readonly handleRTCUseCase;
+    private readonly updateChannelViewerUseCase;
+    private taskUpdateMicSetting;
+    private disposables;
+    private observers;
+    constructor(t151: PLVLinkMicRepo, u151: LinkMicHandleQueueOrderUseCase, v151: LinkMicHandleRTCUseCase, w151: LinkMicUpdateChannelViewerUseCase);
+    init(): void;
+    requestJoinLinkMic(): Promise<void>;
+    acceptInvitation(): Promise<void>;
+    refuseInvitation(): void;
+    leaveLinkMic(): void;
+    onStreamerStart(): void;
+    onLiveStreamStart(): void;
+    setLinkMicMode(d151: PLVLinkMicMode): Promise<boolean>;
+    openLinkMic(): Promise<boolean>;
+    closeLinkMic(): Promise<boolean>;
+    acceptViewerLinkMicRequest(c151: string): void;
+    inviteViewerLinkMic(a151: string, b151: boolean): void;
+    hangupViewerLinkMic(z150: string): void;
+    hangupAllViewersLinkMic(): void;
+    setViewerEnableCamera(y150: string, enable: boolean): void;
+    setViewerEnableMicrophone(x150: string, enable: boolean): void;
+    grantSpeaker(w150: string): void;
+    revokeSpeaker(v150: string): void;
+    setMainView(u150: string): void;
+    onLiveStreamStop(): void;
+    onStreamerStop(): void;
+    updateInvitationExpireTime(): void;
+    private onSocketMessage;
+    private onSocketOpenMicrophone;
+    private onSocketMuteUserMicro;
+    private onSocketUserSetNick;
+    private onSocketJoinRequest;
+    private onSocketJoinResponse;
+    private onSocketJoinSuccess;
+    private onSocketJoinLeave;
+    private onSocketSwitchView;
+    private updateMicSetting;
+    private onRTCEvent;
+    private onRTCJoinSuccess;
+    private onRTCKickOut;
+    private onViewerLeaveLinkMic;
+    onDestroy(): void;
+    private observeSocketEvent;
+    private createSocketUser;
+    private updateLinkMicMode;
+    private isChannelReachLinkMicLimit;
+}