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

package/src/main/ets/modules/linkmic/viewmodel/usecase/LinkMicViewLogUseCase.js

@@ -0,0 +1,79 @@
+import { PLVScheduledTask } from '@polyvharmony/live-scenes-foundation';
+import { encodeToBase64, md5, MutableObserver, random, seconds } from '@polyvharmony/media-player-sdk';
+import BuildProfile from '../../../../../../../BuildProfile';
+import { PLVLiveViewLogVO } from '../../../business/model/PLVLiveViewLogVO';
+import { PLVSocketUserBean } from '../../../socket/model/PLVSocketUserBean';
+import { PLVLinkMicState } from '../../model/vo/PLVLinkMicState';
+export class LinkMicViewLogUseCase {
+    constructor(r137) {
+        this.viewLogTask = undefined;
+        this.playId = undefined;
+        this.stayDuration = 0;
+        this.playDuration = 0;
+        this.observers = [];
+        this.repo = r137;
+    }
+    init() {
+        const o137 = !PLVSocketUserBean.isSpecialType(this.repo.mediator.channelData?.viewerType);
+        if (!o137) {
+            return;
+        }
+        this.repo.mediator.linkmicState.observe((q137) => {
+            if (q137 === PLVLinkMicState.Joined) {
+                this.startViewLogTask();
+            }
+            else {
+                this.stopViewLogTask();
+            }
+        })
+            .pushTo(this.observers);
+    }
+    startViewLogTask() {
+        if (this.viewLogTask !== undefined) {
+            return;
+        }
+        this.playId = `${Date.now()}X${random(1000000, 2000000)}`;
+        this.stayDuration = 0;
+        this.playDuration = 0;
+        this.viewLogTask = new PLVScheduledTask(() => this.onViewLogTaskInterval(), 0, seconds(1).toMillis());
+        this.viewLogTask.start();
+    }
+    stopViewLogTask() {
+        this.viewLogTask?.cancel();
+        this.viewLogTask = undefined;
+    }
+    onViewLogTaskInterval() {
+        this.stayDuration++;
+        this.playDuration++;
+        const m137 = this.repo.mediator.playerMediator?.viewLogReportFrequency ?? 10;
+        if (this.stayDuration % m137 === 0) {
+            this.sendViewLog();
+        }
+    }
+    async sendViewLog() {
+        const l137 = new PLVLiveViewLogVO();
+        l137.pid = this.playId;
+        l137.uid = this.repo.mediator.channelData?.userId;
+        l137.cid = this.repo.mediator.channelData?.loginChannelId;
+        l137.flow = 0;
+        l137.pd = this.playDuration;
+        l137.sd = this.stayDuration;
+        l137.session_id = encodeToBase64(this.repo.mediator.channelData?.sessionId);
+        l137.pn = 'polyv-harmony-live-sdk';
+        l137.pv = BuildProfile.HAR_VERSION;
+        l137.ptype = PLVLiveViewLogVO.PTYPE_PRTC;
+        l137.param1 = encodeToBase64(this.repo.mediator.channelData?.viewerId);
+        l137.param2 = encodeToBase64(this.repo.mediator.channelData?.viewerName);
+        l137.param3 = encodeToBase64('live');
+        l137.param4 = encodeToBase64(this.repo.mediator.channelData?.param4);
+        l137.param5 = encodeToBase64(this.repo.mediator.channelData?.param5);
+        l137.ts = Date.now();
+        l137.sign = md5(`rtas.net${l137.pid}${l137.cid}${l137.flow}${l137.pd}`);
+        await this.repo.sendLiveViewLog(l137);
+    }
+    onDestroy() {
+        MutableObserver.disposeAll(this.observers);
+        this.observers = [];
+        this.stopViewLogTask();
+    }
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/PLVLinkMicUseCases.d.ets

@@ -0,0 +1,16 @@
+import { LinkMicEncodeParamUseCase } from './LinkMicEncodeParamUseCase';
+import { LinkMicHandleQueueOrderUseCase } from './LinkMicHandleQueueOrderUseCase';
+import { LinkMicHandleRTCUseCase } from './LinkMicHandleRTCUseCase';
+import { LinkMicHandleStateUseCase } from './LinkMicHandleStateUseCase';
+import { LinkMicUpdateChannelViewerUseCase } from './LinkMicUpdateChannelViewerUseCase';
+import { LinkMicViewLogUseCase } from './LinkMicViewLogUseCase';
+export declare class PLVLinkMicUseCases {
+    readonly handleQueueOrderUseCase: LinkMicHandleQueueOrderUseCase;
+    readonly handleRTCUseCase: LinkMicHandleRTCUseCase;
+    readonly handleStateUseCase: LinkMicHandleStateUseCase;
+    readonly updateChannelViewerUseCase: LinkMicUpdateChannelViewerUseCase;
+    readonly viewLogUseCase: LinkMicViewLogUseCase;
+    readonly encodeParamUseCase: LinkMicEncodeParamUseCase;
+    constructor(s137: LinkMicHandleQueueOrderUseCase, t137: LinkMicHandleRTCUseCase, u137: LinkMicHandleStateUseCase, v137: LinkMicUpdateChannelViewerUseCase, w137: LinkMicViewLogUseCase, x137: LinkMicEncodeParamUseCase);
+    init(): void;
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/PLVLinkMicUseCases.js

@@ -0,0 +1,17 @@
+export class PLVLinkMicUseCases {
+    constructor(s137, t137, u137, v137, w137, x137) {
+        this.handleQueueOrderUseCase = s137;
+        this.handleRTCUseCase = t137;
+        this.handleStateUseCase = u137;
+        this.updateChannelViewerUseCase = v137;
+        this.viewLogUseCase = w137;
+        this.encodeParamUseCase = x137;
+    }
+    init() {
+        this.handleStateUseCase.init();
+        this.handleRTCUseCase.init();
+        this.updateChannelViewerUseCase.init();
+        this.viewLogUseCase.init();
+        this.encodeParamUseCase.init();
+    }
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/base/ILinkMicEncodeParamUseCase.d.ets

@@ -0,0 +1,11 @@
+import { PLVPushDowngradePreference, PLVPushOrientation } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicBitRate } from '../../../../model/vo/PLVLinkMicBitRate';
+import { PLVLinkMicPushResolutionRatio } from '../../../../model/vo/PLVLinkMicPushResolutionRatio';
+export interface ILinkMicEncodeParamUseCase {
+    init(): void;
+    setBitRate(bitRate: PLVLinkMicBitRate): void;
+    setPushResolutionRatio(pushResolutionRatio: PLVLinkMicPushResolutionRatio): void;
+    setPushOrientation(pushOrientation: PLVPushOrientation): void;
+    setPushMirror(isMirror: boolean): void;
+    setPushDowngradePreference(preference: PLVPushDowngradePreference): void;
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/base/ILinkMicEncodeParamUseCase.js

@@ -0,0 +1 @@
+export {};

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/base/ILinkMicHandleRTCUseCase.d.ets

@@ -0,0 +1,16 @@
+import { PLVRTCClientRole } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicVideoRenderParam } from '../../../../model/vo/PLVLinkMicVideoRenderParam';
+export interface ILinkMicHandleRTCUseCase {
+    init(): void;
+    joinChannel(): void;
+    leaveChannel(): void;
+    switchRole(role: PLVRTCClientRole): void;
+    enableCamera(enable: boolean): void;
+    enableMicrophone(enable: boolean): void;
+    enableCameraMicrophoneToLastState(): void;
+    switchCamera(): void;
+    setLocalRenderMirror(isMirror: boolean): void;
+    setupVideoRender(renderParam: PLVLinkMicVideoRenderParam): void;
+    removeVideoRender(renderParam: PLVLinkMicVideoRenderParam): void;
+    onDestroy(): void;
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/base/ILinkMicHandleRTCUseCase.js

@@ -0,0 +1 @@
+export {};

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/base/ILinkMicHandleStateUseCase.d.ets

@@ -0,0 +1,26 @@
+import { PLVLinkMicMode } from '../../../../model/vo/PLVLinkMicMode';
+export interface ILinkMicHandleStateUseCase {
+    init(): void;
+    requestJoinLinkMic(): Promise<void>;
+    acceptInvitation(): Promise<void>;
+    refuseInvitation(): void;
+    leaveLinkMic(): void;
+    onStreamerStart(): void;
+    onLiveStreamStart(): void;
+    setLinkMicMode(linkmicMode: PLVLinkMicMode): Promise<boolean>;
+    openLinkMic(): Promise<boolean>;
+    closeLinkMic(): Promise<boolean>;
+    acceptViewerLinkMicRequest(viewerId: string): void;
+    inviteViewerLinkMic(viewerId: string, needAnswer: boolean): void;
+    hangupViewerLinkMic(viewerId: string): void;
+    hangupAllViewersLinkMic(): void;
+    setViewerEnableCamera(viewerId: string, enable: boolean): void;
+    setViewerEnableMicrophone(viewerId: string, enable: boolean): void;
+    grantSpeaker(viewerId: string): void;
+    revokeSpeaker(viewerId: string): void;
+    setMainView(viewerId: string): void;
+    onLiveStreamStop(): void;
+    onStreamerStop(): void;
+    updateInvitationExpireTime(): void;
+    onDestroy(): void;
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/base/ILinkMicHandleStateUseCase.js

@@ -0,0 +1 @@
+export {};

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/guest/LinkMicGuestEncodeParamUseCase.d.ets

@@ -0,0 +1,22 @@
+import { PLVPushDowngradePreference, PLVPushOrientation } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicRepo } from '../../../../model/PLVLinkMicRepo';
+import { PLVLinkMicBitRate } from '../../../../model/vo/PLVLinkMicBitRate';
+import { PLVLinkMicPushResolutionRatio } from '../../../../model/vo/PLVLinkMicPushResolutionRatio';
+import { ILinkMicEncodeParamUseCase } from '../base/ILinkMicEncodeParamUseCase';
+export declare class LinkMicGuestEncodeParamUseCase implements ILinkMicEncodeParamUseCase {
+    private readonly repo;
+    constructor(j140: PLVLinkMicRepo);
+    init(): void;
+    setBitRate(bitRate: PLVLinkMicBitRate): void;
+    setPushResolutionRatio(i140: PLVLinkMicPushResolutionRatio): void;
+    setPushOrientation(h140: PLVPushOrientation): void;
+    setPushMirror(g140: boolean): void;
+    setPushDowngradePreference(f140: PLVPushDowngradePreference): void;
+    private updateEncodeParam;
+    private parseChannelBitRateSetting;
+    private parsePushStreamTemplate;
+    private parseBuiltinBitRateSetting;
+    private reduceEncodeParams;
+    private setupDefaultBitRate;
+    private isChannelUsePushStreamTemplate;
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/guest/LinkMicGuestEncodeParamUseCase.js

@@ -0,0 +1,153 @@
+import { extendArray, isLiteralTrue, requireNotNull, runCatching } from '@polyvharmony/media-player-sdk';
+import { PLVPushDowngradePreference, PLVPushOrientation, PLVRTCVideoEncodeParam } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicBitRate } from '../../../../model/vo/PLVLinkMicBitRate';
+import { DEFAULT_BITRATE_ENCODE_PARAM_TABLE, PLVLinkMicBitRateEncodeParam } from '../../../../model/vo/PLVLinkMicBitRateEncodeParam';
+import { PLVLinkMicPushResolutionRatio } from '../../../../model/vo/PLVLinkMicPushResolutionRatio';
+export class LinkMicGuestEncodeParamUseCase {
+    constructor(j140) {
+        this.repo = j140;
+    }
+    init() {
+        this.parseChannelBitRateSetting();
+        this.setupDefaultBitRate();
+    }
+    setBitRate(bitRate) {
+        this.repo.mediator.currentBitRate.setValue(bitRate);
+        this.updateEncodeParam();
+    }
+    setPushResolutionRatio(i140) {
+        this.repo.mediator.currentPushResolutionRatio.setValue(i140);
+        if (!this.isChannelUsePushStreamTemplate()) {
+            this.parseChannelBitRateSetting();
+        }
+        this.updateEncodeParam();
+    }
+    setPushOrientation(h140) {
+        this.repo.mediator.currentPushOrientation.setValue(h140);
+        this.updateEncodeParam();
+    }
+    setPushMirror(g140) {
+        this.repo.mediator.currentPushMirror.setValue(g140);
+        this.updateEncodeParam();
+    }
+    setPushDowngradePreference(f140) {
+        this.repo.mediator.currentPushDowngradePreference.setValue(f140);
+        this.updateEncodeParam();
+    }
+    updateEncodeParam() {
+        const y139 = this.repo.mediator.currentBitRate.value;
+        const z139 = this.repo.mediator.channelSupportBitRates.value ?? [PLVLinkMicBitRate.STANDARD];
+        let a140 = y139;
+        if (a140 === undefined || !z139.includes(a140)) {
+            a140 = z139[0];
+        }
+        if (y139 !== a140) {
+            this.setBitRate(a140);
+            return;
+        }
+        const b140 = this.repo.mediator.channelSupportBitRateEncodeParams.value?.find(e140 => e140.bitRate === a140);
+        if (b140 === undefined) {
+            return;
+        }
+        this.repo.mediator.currentBitRateEncodeParam.setValue(b140);
+        const c140 = new PLVRTCVideoEncodeParam();
+        c140.width = b140.videoWidth;
+        c140.height = b140.videoHeight;
+        c140.frameRate = b140.videoFps;
+        c140.targetBitRate = b140.videoBitrate;
+        c140.pushOrientation = this.repo.mediator.currentPushOrientation.value ?? PLVPushOrientation.AUTO;
+        c140.pushMirror = this.repo.mediator.currentPushMirror.value ?? false;
+        c140.pushDowngradePreference = this.repo.mediator.currentPushDowngradePreference.value ?? PLVPushDowngradePreference.PREFER_BETTER_QUALITY;
+        this.repo.setLocalVideoEncodeParam(c140);
+    }
+    parseChannelBitRateSetting() {
+        if (this.isChannelUsePushStreamTemplate()) {
+            this.parsePushStreamTemplate();
+        }
+        else {
+            this.parseBuiltinBitRateSetting();
+        }
+    }
+    parsePushStreamTemplate() {
+        const p139 = requireNotNull(this.repo.mediator.channelData?.streamerData?.pushStreamTemplateJson);
+        const q139 = extendArray(p139.VideoParams ?? [])
+            .map((v139, index) => {
+            const w139 = runCatching(() => {
+                const bitRate = new PLVLinkMicBitRate(index, requireNotNull(v139.QualityName));
+                return new PLVLinkMicBitRateEncodeParam(bitRate, requireNotNull(v139.VideoFps), requireNotNull(v139.VideoGop), requireNotNull(v139.VideoWidth), requireNotNull(v139.VideoHeight), requireNotNull(v139.VideoBitrate), requireNotNull(v139.ScreenFps), requireNotNull(v139.ScreenGop), requireNotNull(v139.ScreenWidth), requireNotNull(v139.ScreenHeight), requireNotNull(v139.ScreenBitrate));
+            });
+            return w139.success ? w139.data : null;
+        })
+            .filterNotNull_ext();
+        this.repo.mediator.channelSupportBitRateEncodeParams.setValue(q139);
+        const r139 = q139.map(u139 => u139.bitRate);
+        this.repo.mediator.channelSupportBitRates.setValue(r139);
+    }
+    parseBuiltinBitRateSetting() {
+        const x138 = requireNotNull(this.repo.mediator.channelData?.streamerData);
+        const maxResolution = x138.rtcMaxResolution ?? 0;
+        let y138;
+        if (isLiteralTrue(x138.appPushResolution1080Enabled) || maxResolution >= 1080) {
+            y138 = [PLVLinkMicBitRate.STANDARD, PLVLinkMicBitRate.HIGH, PLVLinkMicBitRate.SUPER, PLVLinkMicBitRate.SUPER_HIGH];
+        }
+        else if (maxResolution >= 720) {
+            y138 = [PLVLinkMicBitRate.STANDARD, PLVLinkMicBitRate.HIGH, PLVLinkMicBitRate.SUPER];
+        }
+        else if (maxResolution >= 360) {
+            y138 = [PLVLinkMicBitRate.STANDARD, PLVLinkMicBitRate.HIGH];
+        }
+        else {
+            y138 = [PLVLinkMicBitRate.STANDARD];
+        }
+        const z138 = x138.clientParams?.fps ?? 15;
+        const a139 = this.repo.mediator.currentPushResolutionRatio.value ?? PLVLinkMicPushResolutionRatio.RATIO_16_9;
+        const b139 = extendArray(DEFAULT_BITRATE_ENCODE_PARAM_TABLE)
+            .filter(o139 => y138.includes(o139.bitRate))
+            .groupBy_ext(n139 => n139.bitRate)
+            .filter_ext(m139 => m139[1].length > 0)
+            .mapValues_ext(l139 => this.reduceEncodeParams(l139[1], z138, a139))
+            .toArray_ext(k139 => k139[1]);
+        this.repo.mediator.channelSupportBitRateEncodeParams.setValue(b139);
+        const c139 = b139.map(j139 => j139.bitRate);
+        this.repo.mediator.channelSupportBitRates.setValue(c139);
+    }
+    reduceEncodeParams(h138, i138, ratio) {
+        const j138 = (a, b) => Math.abs(a - b) < 1e-6;
+        const k138 = h138.filter(w138 => w138.videoFps >= i138 && j138(w138.videoWidth / w138.videoHeight, ratio.ratio));
+        if (k138.length > 0) {
+            if (k138.length === 1) {
+                return k138[0];
+            }
+            else {
+                return k138.reduce((u138, v138) => u138.videoFps > v138.videoFps ? v138 : u138);
+            }
+        }
+        const l138 = h138.filter(s138 => j138(s138.videoWidth / s138.videoHeight, ratio.ratio));
+        if (l138.length > 0) {
+            if (l138.length === 1) {
+                return l138[0];
+            }
+            else {
+                return k138.reduce((q138, r138) => q138.videoFps > r138.videoFps ? r138 : q138);
+            }
+        }
+        return h138[0];
+    }
+    setupDefaultBitRate() {
+        if (this.isChannelUsePushStreamTemplate()) {
+            const a138 = requireNotNull(this.repo.mediator.channelData?.streamerData?.pushStreamTemplateJson);
+            const b138 = a138.VideoParams?.findIndex(g138 => g138.QualityLevel === a138.teacherDefaultQualityLevel);
+            const c138 = (this.repo.mediator.channelSupportBitRates.value ?? []).find(f138 => f138.index === b138) ?? PLVLinkMicBitRate.STANDARD;
+            this.setBitRate(c138);
+        }
+        else {
+            const z137 = extendArray(this.repo.mediator.channelSupportBitRates.value ?? [])
+                .lastOrNull_ext() ?? PLVLinkMicBitRate.STANDARD;
+            this.setBitRate(z137);
+        }
+    }
+    isChannelUsePushStreamTemplate() {
+        const y137 = this.repo.mediator.channelData?.streamerData;
+        return isLiteralTrue(y137?.clientPushStreamTemplateEnabled) && y137?.pushStreamTemplateJson !== undefined;
+    }
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/guest/LinkMicGuestHandleRTCUseCase.d.ets

@@ -0,0 +1,22 @@
+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 LinkMicGuestHandleRTCUseCase implements ILinkMicHandleRTCUseCase {
+    private readonly repo;
+    private observers;
+    constructor(v140: PLVLinkMicRepo);
+    init(): void;
+    joinChannel(): void;
+    leaveChannel(): void;
+    switchRole(role: PLVRTCClientRole): void;
+    enableCamera(enable: boolean): void;
+    enableMicrophone(enable: boolean): void;
+    enableCameraMicrophoneToLastState(): void;
+    switchCamera(): void;
+    setLocalRenderMirror(q140: boolean): void;
+    setupVideoRender(o140: PLVLinkMicVideoRenderParam): void;
+    removeVideoRender(m140: PLVLinkMicVideoRenderParam): void;
+    onDestroy(): void;
+    private getVideoRenderParam;
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/guest/LinkMicGuestHandleRTCUseCase.js

@@ -0,0 +1,91 @@
+import { MutableObserver } from '@polyvharmony/media-player-sdk';
+import { PLVRTCClientRole, PLVRTCVideoRenderParam, PLVVideoRenderFitMode } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicCameraFacing } from '../../../../model/vo/PLVLinkMicCameraFacing';
+import { PLVLinkMicState } from '../../../../model/vo/PLVLinkMicState';
+import { PLVLinkMicVideoRenderParam } from '../../../../model/vo/PLVLinkMicVideoRenderParam';
+export class LinkMicGuestHandleRTCUseCase {
+    constructor(v140) {
+        this.observers = [];
+        this.repo = v140;
+    }
+    init() {
+        this.repo.mediator.linkmicState.observe(u140 => {
+            if (u140 === PLVLinkMicState.Joined) {
+                this.switchRole(PLVRTCClientRole.BROADCASTER);
+            }
+            else {
+                this.switchRole(PLVRTCClientRole.AUDIENCE);
+            }
+        })
+            .pushTo(this.observers);
+    }
+    joinChannel() {
+        this.repo.joinRTCChannel();
+    }
+    leaveChannel() {
+        this.repo.leaveRTCChannel();
+    }
+    switchRole(role) {
+        this.repo.switchRTCRole(role);
+    }
+    enableCamera(enable) {
+        this.repo.enableLocalVideo(enable);
+        this.repo.mediator.localLinkMicViewer.value?.isVideoEnable?.setValue(enable);
+    }
+    enableMicrophone(enable) {
+        this.repo.enableLocalAudio(enable);
+        this.repo.mediator.localLinkMicViewer.value?.isAudioEnable?.setValue(enable);
+    }
+    enableCameraMicrophoneToLastState() {
+    }
+    switchCamera() {
+        this.repo.mediator.cameraFacing.value = (this.repo.mediator.cameraFacing.value ?? PLVLinkMicCameraFacing.FRONT).switchNext();
+        this.repo.switchCamera();
+    }
+    setLocalRenderMirror(q140) {
+        const r140 = this.repo.mediator.linkmicId;
+        if (r140 === undefined) {
+            return;
+        }
+        this.repo.mediator.localRenderMirror.setValue(q140);
+        const s140 = this.getVideoRenderParam(r140);
+        this.setupVideoRender(new PLVLinkMicVideoRenderParam(r140, s140.viewId));
+    }
+    setupVideoRender(o140) {
+        const p140 = this.getVideoRenderParam(o140.linkmicId);
+        p140.viewId = o140.xcomponentId;
+        if (this.repo.mediator.isMySocketLinkMicId(o140.linkmicId)) {
+            p140.renderMirror = this.repo.mediator.localRenderMirror.value ?? false;
+        }
+        this.repo.setVideoRender(p140);
+    }
+    removeVideoRender(m140) {
+        const n140 = this.getVideoRenderParam(m140.linkmicId);
+        if (m140.xcomponentId === null || n140.viewId === m140.xcomponentId) {
+            n140.viewId = null;
+            this.repo.setVideoRender(n140);
+        }
+    }
+    onDestroy() {
+        MutableObserver.disposeAll(this.observers);
+        this.observers = [];
+    }
+    getVideoRenderParam(k140) {
+        let param = this.repo.getVideoRenderParam(k140);
+        if (param !== null) {
+            return param;
+        }
+        const l140 = k140 === this.repo.mediator.channelData?.loginChannelId;
+        param = new PLVRTCVideoRenderParam();
+        param.linkmicId = k140;
+        param.viewId = null;
+        if (l140) {
+            param.renderFitMode = PLVVideoRenderFitMode.FIT;
+        }
+        else {
+            param.renderFitMode = PLVVideoRenderFitMode.HIDDEN;
+        }
+        param.renderMirror = false;
+        return param;
+    }
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/guest/LinkMicGuestHandleStateUseCase.d.ets

@@ -0,0 +1,55 @@
+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 LinkMicGuestHandleStateUseCase implements ILinkMicHandleStateUseCase {
+    private readonly repo;
+    private readonly handleQueueOrderUseCase;
+    private readonly handleRTCUseCase;
+    private readonly updateChannelViewerUseCase;
+    private disposables;
+    private observers;
+    constructor(n143: PLVLinkMicRepo, o143: LinkMicHandleQueueOrderUseCase, p143: LinkMicHandleRTCUseCase, q143: LinkMicUpdateChannelViewerUseCase);
+    init(): void;
+    requestJoinLinkMic(): Promise<void>;
+    acceptInvitation(): Promise<void>;
+    refuseInvitation(): void;
+    leaveLinkMic(): void;
+    onStreamerStart(): void;
+    onLiveStreamStart(): void;
+    setLinkMicMode(b143: PLVLinkMicMode): Promise<boolean>;
+    openLinkMic(): Promise<boolean>;
+    closeLinkMic(): Promise<boolean>;
+    acceptViewerLinkMicRequest(a143: string): void;
+    inviteViewerLinkMic(y142: string, z142: boolean): void;
+    hangupViewerLinkMic(x142: string): void;
+    hangupAllViewersLinkMic(): void;
+    setViewerEnableCamera(w142: string, enable: boolean): void;
+    setViewerEnableMicrophone(v142: string, enable: boolean): void;
+    grantSpeaker(u142: string): void;
+    revokeSpeaker(s142: string): void;
+    setMainView(p142: string): void;
+    private isMyselfSpeaker;
+    private moveSpeaker;
+    onLiveStreamStop(): void;
+    onStreamerStop(): void;
+    updateInvitationExpireTime(): void;
+    private onSocketMessage;
+    private onSocketOpenMicrophone;
+    private onSocketMuteUserMicro;
+    private onSocketTeacherSetPermission;
+    private onSocketUserSetNick;
+    private onSocketJoinRequest;
+    private onSocketJoinResponse;
+    private onSocketJoinSuccess;
+    private onSocketJoinLeave;
+    private onSocketSwitchView;
+    private tryAutoJoinLinkMic;
+    onDestroy(): void;
+    private observeSocketEvent;
+    private createSocketUser;
+    private updateLinkMicMode;
+    private isChannelReachLinkMicLimit;
+}