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

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

@@ -0,0 +1,388 @@
+import { PLVDisposable, PLVLogger, PLVRequestSetting } from '@polyvharmony/live-scenes-foundation';
+import { decodeFromJson, encodeToJson, isNullOrUndefined, MutableObserver, Promises, requireNotNull, retry, RetryConditions, runCatching, seconds, withTimeout } from '@polyvharmony/media-player-sdk';
+import { PLVSocketMessageEvent, PLVSocketOnEvent } from '../../../../../socket/model/PLVSocketEventConstants';
+import { PLVUserType } from '../../../../../socket/model/PLVUserType';
+import { PLVLinkMicErrorEvent } from '../../../../model/vo/PLVLinkMicErrorEvent';
+import { PLVLinkMicMode } from '../../../../model/vo/PLVLinkMicMode';
+import { PLVLinkMicSocketJoinAnswerSend, PLVLinkMicSocketJoinAnswerTTLAck, PLVLinkMicSocketJoinAnswerTTLSend, PLVLinkMicSocketJoinLeaveRecv, PLVLinkMicSocketJoinLeaveSend, PLVLinkMicSocketJoinRequestRecv, PLVLinkMicSocketJoinRequestSend, PLVLinkMicSocketJoinResponseRecv, PLVLinkMicSocketJoinResponseSend, PLVLinkMicSocketJoinSuccessRecv, PLVLinkMicSocketMuteUserMicroRecv, PLVLinkMicSocketOpenMicrophoneRecv, PLVLinkMicSocketSwitchViewRecv, PLVLinkMicSocketSwitchViewSend, PLVLinkMicSocketTeacherSetPermissionRecv, PLVLinkMicSocketTeacherSetPermissionSend } from '../../../../model/vo/PLVLinkMicSocketEvent';
+import { PLVLinkMicState } from '../../../../model/vo/PLVLinkMicState';
+import { PLVSocketUserSend } from '../../../../../socket/model/PLVSocketUserBean';
+import { PLVMemberSocketSetNickRecv } from '../../../../../member/model/vo/PLVMemberSocketEvent';
+const TAG = "PLVLinkMicManager";
+export class LinkMicGuestHandleStateUseCase {
+    constructor(n143, o143, p143, q143) {
+        this.disposables = [];
+        this.observers = [];
+        this.repo = n143;
+        this.handleQueueOrderUseCase = o143;
+        this.handleRTCUseCase = p143;
+        this.updateChannelViewerUseCase = q143;
+    }
+    init() {
+        this.disposables.push(this.observeSocketEvent(PLVSocketOnEvent.MESSAGE, (data, event) => this.onSocketMessage(data, event)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_REQUEST, (data) => this.onSocketJoinRequest(data)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_RESPONSE, (data) => this.onSocketJoinResponse(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() {
+        const f143 = this.repo.mediator.linkmicState.value;
+        if (f143 === PLVLinkMicState.Inviting) {
+            this.acceptInvitation();
+            return;
+        }
+        if (await this.isChannelReachLinkMicLimit()) {
+            this.repo.mediator.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+            this.repo.mediator.reportError(PLVLinkMicErrorEvent.REACH_LINKMIC_LIMIT, "requestJoinLinkMic channel reach linkmic limit");
+            return;
+        }
+        const event = new PLVLinkMicSocketJoinRequestSend();
+        event.user = this.createSocketUser();
+        event.roomId = this.repo.mediator.channelData?.loginChannelId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_REQUEST, encodeToJson(event), () => {
+            this.repo.mediator.linkmicState.setValue(PLVLinkMicState.Requesting);
+        });
+    }
+    async acceptInvitation() {
+        if (await this.isChannelReachLinkMicLimit()) {
+            this.repo.mediator.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+            this.repo.mediator.reportError(PLVLinkMicErrorEvent.REACH_LINKMIC_LIMIT, "acceptInvitation channel reach linkmic limit");
+            return;
+        }
+        const event = new PLVLinkMicSocketJoinAnswerSend();
+        event.user = this.createSocketUser();
+        event.roomId = this.repo.mediator.channelData?.loginChannelId;
+        event.status = 1;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_ANSWER, encodeToJson(event), () => {
+            const e143 = this.repo.mediator.linkmicState.value;
+            if (e143 === PLVLinkMicState.Inviting) {
+                this.repo.mediator.linkmicState.setValue(PLVLinkMicState.WaitingResponse);
+            }
+        });
+    }
+    refuseInvitation() {
+        const event = new PLVLinkMicSocketJoinAnswerSend();
+        event.user = this.createSocketUser();
+        event.roomId = this.repo.mediator.channelData?.loginChannelId;
+        event.status = 0;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_ANSWER, encodeToJson(event));
+        this.repo.mediator.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+    }
+    leaveLinkMic() {
+        const c143 = this.repo.mediator.linkmicState.value;
+        if (c143 === undefined || ![PLVLinkMicState.Requesting, PLVLinkMicState.Joined].includes(c143)) {
+            return;
+        }
+        const event = new PLVLinkMicSocketJoinLeaveSend();
+        event.user = this.createSocketUser();
+        event.roomId = this.repo.mediator.channelData?.loginChannelId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_LEAVE, encodeToJson(event));
+        this.revokeSpeaker("");
+        this.repo.mediator.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+    }
+    onStreamerStart() {
+        this.handleRTCUseCase.joinChannel();
+    }
+    onLiveStreamStart() {
+        this.tryAutoJoinLinkMic();
+        this.updateChannelViewerUseCase.startUpdateChannelLinkMicViewersInterval();
+    }
+    async setLinkMicMode(b143) {
+        return false;
+    }
+    async openLinkMic() {
+        return false;
+    }
+    async closeLinkMic() {
+        return false;
+    }
+    acceptViewerLinkMicRequest(a143) {
+    }
+    inviteViewerLinkMic(y142, z142) {
+    }
+    hangupViewerLinkMic(x142) {
+    }
+    hangupAllViewersLinkMic() {
+    }
+    setViewerEnableCamera(w142, enable) {
+    }
+    setViewerEnableMicrophone(v142, enable) {
+    }
+    grantSpeaker(u142) {
+        if (!this.isMyselfSpeaker()) {
+            return;
+        }
+        this.moveSpeaker(u142);
+        this.setMainView(u142);
+    }
+    revokeSpeaker(s142) {
+        if (!this.isMyselfSpeaker()) {
+            return;
+        }
+        const t142 = requireNotNull(this.repo.mediator.channelData?.loginChannelId);
+        this.moveSpeaker(t142);
+        this.setMainView(t142);
+    }
+    setMainView(p142) {
+        if (!this.isMyselfSpeaker()) {
+            return;
+        }
+        const q142 = this.repo.mediator.memberMediator?.findViewerByViewerId(p142);
+        if (q142 === undefined) {
+            PLVLogger.error(TAG, `setMainView fail, viewerId ${p142} not found.`);
+            return;
+        }
+        const r142 = new PLVLinkMicSocketSwitchViewSend();
+        r142.emitMode = 0;
+        r142.roomId = this.repo.mediator.channelData?.loginChannelId;
+        r142.userId = q142.linkmicId;
+        r142.socketId = q142.socketId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.SWITCH_VIEW, encodeToJson(r142));
+    }
+    isMyselfSpeaker() {
+        const o142 = this.repo.mediator.channelMainViewLinkMicId.value;
+        return !isNullOrUndefined(o142) && this.repo.mediator.isMySocketLinkMicId(o142);
+    }
+    moveSpeaker(m142) {
+        const n142 = new PLVLinkMicSocketTeacherSetPermissionSend();
+        n142.emitMode = 0;
+        n142.roomId = this.repo.mediator.channelData?.loginChannelId;
+        n142.sessionId = this.repo.mediator.channelData?.sessionId;
+        n142.type = "speaker";
+        n142.status = "1";
+        n142.userId = m142;
+        n142.sign = PLVRequestSetting.createSign(new Map(Object.entries(n142)), "polyvChatSign")
+            .toUpperCase();
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(n142));
+    }
+    onLiveStreamStop() {
+        this.leaveLinkMic();
+        this.updateChannelViewerUseCase.stopUpdateChannelLinkMicViewersInterval();
+    }
+    onStreamerStop() {
+        this.leaveLinkMic();
+        this.handleRTCUseCase.leaveChannel();
+    }
+    updateInvitationExpireTime() {
+        const event = new PLVLinkMicSocketJoinAnswerTTLSend();
+        event.userId = this.repo.mediator.channelData?.viewerId;
+        event.roomId = this.repo.mediator.channelData?.loginChannelId;
+        event.sessionId = this.repo.mediator.channelData?.sessionId;
+        const h142 = Date.now();
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_ANSWER_TTL, encodeToJson(event), (data) => {
+            const ttl = decodeFromJson(data, PLVLinkMicSocketJoinAnswerTTLAck).message?.[0] ?? 0;
+            const expire = h142 + seconds(ttl).toMillis();
+            this.repo.mediator.invitationExpireTimestamp.setValue(expire);
+            const j142 = expire - Date.now();
+            setTimeout(() => {
+                const expire = this.repo.mediator.invitationExpireTimestamp.value ?? 0;
+                const l142 = this.repo.mediator.linkmicState.value;
+                if (l142 === PLVLinkMicState.Inviting && Date.now() >= expire) {
+                    this.refuseInvitation();
+                }
+            }, j142);
+        });
+    }
+    onSocketMessage(data, event) {
+        switch (event) {
+            case PLVSocketMessageEvent.OPEN_MICROPHONE: return this.onSocketOpenMicrophone(data);
+            case PLVSocketMessageEvent.MUTE_USER_MICRO: return this.onSocketMuteUserMicro(data);
+            case PLVSocketMessageEvent.TEACHER_SET_PERMISSION: return this.onSocketTeacherSetPermission(data);
+            case PLVSocketMessageEvent.SET_NICK: return this.onSocketUserSetNick(data);
+            default:
+        }
+    }
+    onSocketOpenMicrophone(data) {
+        const f142 = decodeFromJson(data, PLVLinkMicSocketOpenMicrophoneRecv);
+        const g142 = f142.userId !== undefined;
+        if (f142.status === 'open') {
+            if (!g142) {
+                this.repo.mediator.channelAllowLinkMic.setValue(true);
+                this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(true);
+                this.updateLinkMicMode(f142.type);
+            }
+        }
+        else if (f142.status === 'close') {
+            if (!g142) {
+                if (this.repo.mediator.isLinkMicStrategyV2.value === true) {
+                    this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(false);
+                }
+                else {
+                    this.repo.mediator.channelAllowLinkMic.setValue(false);
+                    this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(false);
+                }
+            }
+            if (g142 && this.repo.mediator.isMySocketLinkMicId(f142.userId)) {
+                this.repo.mediator.teacherHangUpLinkMicEvent.setValue(Date.now());
+                this.leaveLinkMic();
+            }
+        }
+    }
+    onSocketMuteUserMicro(data) {
+        const e142 = decodeFromJson(data, PLVLinkMicSocketMuteUserMicroRecv);
+        if (e142.type === 'audio') {
+            if (e142.mute === true) {
+                this.handleRTCUseCase.enableMicrophone(false);
+            }
+            if (e142.mute === false) {
+                this.handleRTCUseCase.enableMicrophone(true);
+            }
+        }
+        if (e142.type === 'video') {
+            if (e142.mute === true) {
+                this.handleRTCUseCase.enableCamera(false);
+            }
+            if (e142.mute === false) {
+                this.handleRTCUseCase.enableCamera(true);
+            }
+        }
+    }
+    onSocketTeacherSetPermission(data) {
+        const b142 = decodeFromJson(data, PLVLinkMicSocketTeacherSetPermissionRecv);
+        this.updateChannelViewerUseCase.onEventTeacherSetPermission(b142);
+        if (b142.type === "voice") {
+            const c142 = b142.status === "1";
+            const d142 = !isNullOrUndefined(b142.userId) && b142.userId === this.repo.mediator.channelData?.viewerId;
+            if (d142) {
+                this.repo.mediator.linkmicState.setValue(c142 ? PLVLinkMicState.Joined : PLVLinkMicState.NoLinkMic);
+            }
+        }
+    }
+    onSocketUserSetNick(data) {
+        const y141 = decodeFromJson(data, PLVMemberSocketSetNickRecv);
+        const z141 = y141.userId;
+        const a142 = this.repo.mediator.findViewerByViewerId(z141);
+        if (a142 !== undefined) {
+            a142.viewerName.setValue(y141.nick);
+        }
+    }
+    onSocketJoinRequest(data) {
+        const x141 = decodeFromJson(data, PLVLinkMicSocketJoinRequestRecv);
+        this.handleQueueOrderUseCase.onEventJoinRequest(x141);
+    }
+    onSocketJoinResponse(data) {
+        const v141 = decodeFromJson(data, PLVLinkMicSocketJoinResponseRecv);
+        if (!this.repo.mediator.isMySocketLinkMicId(v141.user?.userId)) {
+            return;
+        }
+        this.updateLinkMicMode(v141.type);
+        const w141 = this.repo.mediator.linkmicState.value;
+        if (v141.isNeedAnswer()) {
+            if (w141 === PLVLinkMicState.Requesting) {
+                this.acceptInvitation();
+            }
+            else if (w141 === PLVLinkMicState.NoLinkMic) {
+                this.repo.mediator.invitationExpireTimestamp.setValue(Date.now() + seconds(30).toMillis());
+                this.repo.mediator.linkmicState.setValue(PLVLinkMicState.Inviting);
+                this.updateInvitationExpireTime();
+            }
+        }
+        else {
+            this.repo.mediator.linkmicState.setValue(PLVLinkMicState.Joined);
+        }
+    }
+    onSocketJoinSuccess(data) {
+        const u141 = decodeFromJson(data, PLVLinkMicSocketJoinSuccessRecv);
+        this.handleQueueOrderUseCase.onEventJoinSuccess(u141);
+        this.updateChannelViewerUseCase.onEventJoinSuccess(u141);
+    }
+    onSocketJoinLeave(data) {
+        const t141 = decodeFromJson(data, PLVLinkMicSocketJoinLeaveRecv);
+        this.handleQueueOrderUseCase.onEventJoinLeave(t141);
+        this.updateChannelViewerUseCase.onEventJoinLeave(t141);
+    }
+    onSocketSwitchView(data) {
+        const s141 = decodeFromJson(data, PLVLinkMicSocketSwitchViewRecv);
+        if (isNullOrUndefined(s141.userId)) {
+            return;
+        }
+        this.repo.mediator.channelMainViewLinkMicId.setValue(s141.userId);
+        this.updateChannelViewerUseCase.onEventSwitchView(s141);
+    }
+    async tryAutoJoinLinkMic() {
+        const i141 = this.repo.mediator.channelData?.streamerData?.colinMicType === "auto";
+        if (!i141) {
+            return;
+        }
+        const j141 = Promises.withResolvers();
+        const k141 = this.repo.mediator.linkmicState.observe((r141) => {
+            if (r141 === PLVLinkMicState.Joined) {
+                j141.resolve();
+                k141.dispose();
+            }
+        });
+        this.observers.push(k141);
+        const l141 = async () => {
+            const q141 = new PLVLinkMicSocketJoinResponseSend();
+            q141.roomId = await this.repo.mediator.channelData?.loginRoomIdPromise.get();
+            q141.value = "1";
+            q141.toEmitAll = 1;
+            q141.user = this.createSocketUser();
+            this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_RESPONSE, encodeToJson(q141));
+        };
+        await runCatching(retry(async () => {
+            await withTimeout(seconds(8), async () => {
+                await l141();
+                await j141.promise;
+            });
+        }, RetryConditions.delay(3, seconds(1))));
+        k141.dispose();
+    }
+    onDestroy() {
+        this.disposables.forEach((h141) => {
+            h141.dispose();
+        });
+        this.disposables = [];
+        MutableObserver.disposeAll(this.observers);
+        this.observers = [];
+    }
+    observeSocketEvent(event, callback) {
+        const e141 = requireNotNull(this.repo.mediator.socketMediator);
+        e141.onData(event, callback);
+        return disposable(() => e141.offData(event, callback));
+    }
+    createSocketUser() {
+        const d141 = new PLVSocketUserSend();
+        d141.nick = this.repo.mediator.channelData?.viewerName;
+        d141.pic = this.repo.mediator.channelData?.viewerAvatar;
+        d141.userType = this.repo.mediator.channelData?.viewerType;
+        d141.userId = this.repo.mediator.linkmicId;
+        return d141;
+    }
+    updateLinkMicMode(mode) {
+        if (mode === PLVLinkMicMode.AUDIO || mode === PLVLinkMicMode.VIDEO) {
+            this.repo.mediator.channelLinkMicMode.setValue(mode);
+        }
+    }
+    async isChannelReachLinkMicLimit() {
+        const y140 = this.repo.mediator.channelData?.liveDetail?.linkMicLimit;
+        if (y140 === undefined) {
+            PLVLogger.warn(TAG, "channel linkmic limit is undefined, treat as reach limit.");
+            return true;
+        }
+        const z140 = await runCatching(this.repo.getChannelLinkMicStatus());
+        if (z140.success === false) {
+            PLVLogger.warn(TAG, `channel linkmic status response fail: ${z140.error.message}`);
+            return true;
+        }
+        const a141 = z140.data.joinList?.filter(c141 => {
+            c141.userType === PLVUserType.USERTYPE_TEACHER || c141.classStatus?.voice === 1;
+        })?.length ?? 0;
+        if (a141 >= y140 + 1) {
+            PLVLogger.warn(TAG, `channel reach linkmic limit, current join ${a141}, limit ${y140}`);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+}
+class SocketDisposable extends PLVDisposable {
+    constructor(x140) {
+        super();
+        this.onDispose = x140;
+    }
+    dispose() {
+        super.dispose();
+        this.onDispose?.();
+    }
+}
+function disposable(w140) {
+    return new SocketDisposable(w140);
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/teacher/LinkMicTeacherEncodeParamUseCase.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 LinkMicTeacherEncodeParamUseCase implements ILinkMicEncodeParamUseCase {
+    private readonly repo;
+    constructor(c146: PLVLinkMicRepo);
+    init(): void;
+    setBitRate(bitRate: PLVLinkMicBitRate): void;
+    setPushResolutionRatio(b146: PLVLinkMicPushResolutionRatio): void;
+    setPushOrientation(a146: PLVPushOrientation): void;
+    setPushMirror(z145: boolean): void;
+    setPushDowngradePreference(y145: 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/teacher/LinkMicTeacherEncodeParamUseCase.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 LinkMicTeacherEncodeParamUseCase {
+    constructor(c146) {
+        this.repo = c146;
+    }
+    init() {
+        this.parseChannelBitRateSetting();
+        this.setupDefaultBitRate();
+    }
+    setBitRate(bitRate) {
+        this.repo.mediator.currentBitRate.setValue(bitRate);
+        this.updateEncodeParam();
+    }
+    setPushResolutionRatio(b146) {
+        this.repo.mediator.currentPushResolutionRatio.setValue(b146);
+        if (!this.isChannelUsePushStreamTemplate()) {
+            this.parseChannelBitRateSetting();
+        }
+        this.updateEncodeParam();
+    }
+    setPushOrientation(a146) {
+        this.repo.mediator.currentPushOrientation.setValue(a146);
+        this.updateEncodeParam();
+    }
+    setPushMirror(z145) {
+        this.repo.mediator.currentPushMirror.setValue(z145);
+        this.updateEncodeParam();
+    }
+    setPushDowngradePreference(y145) {
+        this.repo.mediator.currentPushDowngradePreference.setValue(y145);
+        this.updateEncodeParam();
+    }
+    updateEncodeParam() {
+        const r145 = this.repo.mediator.currentBitRate.value;
+        const s145 = this.repo.mediator.channelSupportBitRates.value ?? [PLVLinkMicBitRate.STANDARD];
+        let t145 = r145;
+        if (t145 === undefined || !s145.includes(t145)) {
+            t145 = s145[0];
+        }
+        if (r145 !== t145) {
+            this.setBitRate(t145);
+            return;
+        }
+        const u145 = this.repo.mediator.channelSupportBitRateEncodeParams.value?.find(x145 => x145.bitRate === t145);
+        if (u145 === undefined) {
+            return;
+        }
+        this.repo.mediator.currentBitRateEncodeParam.setValue(u145);
+        const v145 = new PLVRTCVideoEncodeParam();
+        v145.width = u145.videoWidth;
+        v145.height = u145.videoHeight;
+        v145.frameRate = u145.videoFps;
+        v145.targetBitRate = u145.videoBitrate;
+        v145.pushOrientation = this.repo.mediator.currentPushOrientation.value ?? PLVPushOrientation.AUTO;
+        v145.pushMirror = this.repo.mediator.currentPushMirror.value ?? false;
+        v145.pushDowngradePreference = this.repo.mediator.currentPushDowngradePreference.value ?? PLVPushDowngradePreference.PREFER_BETTER_QUALITY;
+        this.repo.setLocalVideoEncodeParam(v145);
+    }
+    parseChannelBitRateSetting() {
+        if (this.isChannelUsePushStreamTemplate()) {
+            this.parsePushStreamTemplate();
+        }
+        else {
+            this.parseBuiltinBitRateSetting();
+        }
+    }
+    parsePushStreamTemplate() {
+        const i145 = requireNotNull(this.repo.mediator.channelData?.streamerData?.pushStreamTemplateJson);
+        const j145 = extendArray(i145.VideoParams ?? [])
+            .map((o145, index) => {
+            const p145 = runCatching(() => {
+                const bitRate = new PLVLinkMicBitRate(index, requireNotNull(o145.QualityName));
+                return new PLVLinkMicBitRateEncodeParam(bitRate, requireNotNull(o145.VideoFps), requireNotNull(o145.VideoGop), requireNotNull(o145.VideoWidth), requireNotNull(o145.VideoHeight), requireNotNull(o145.VideoBitrate), requireNotNull(o145.ScreenFps), requireNotNull(o145.ScreenGop), requireNotNull(o145.ScreenWidth), requireNotNull(o145.ScreenHeight), requireNotNull(o145.ScreenBitrate));
+            });
+            return p145.success ? p145.data : null;
+        })
+            .filterNotNull_ext();
+        this.repo.mediator.channelSupportBitRateEncodeParams.setValue(j145);
+        const k145 = j145.map(n145 => n145.bitRate);
+        this.repo.mediator.channelSupportBitRates.setValue(k145);
+    }
+    parseBuiltinBitRateSetting() {
+        const q144 = requireNotNull(this.repo.mediator.channelData?.streamerData);
+        const maxResolution = q144.rtcMaxResolution ?? 0;
+        let r144;
+        if (isLiteralTrue(q144.appPushResolution1080Enabled) || maxResolution >= 1080) {
+            r144 = [PLVLinkMicBitRate.STANDARD, PLVLinkMicBitRate.HIGH, PLVLinkMicBitRate.SUPER, PLVLinkMicBitRate.SUPER_HIGH];
+        }
+        else if (maxResolution >= 720) {
+            r144 = [PLVLinkMicBitRate.STANDARD, PLVLinkMicBitRate.HIGH, PLVLinkMicBitRate.SUPER];
+        }
+        else if (maxResolution >= 360) {
+            r144 = [PLVLinkMicBitRate.STANDARD, PLVLinkMicBitRate.HIGH];
+        }
+        else {
+            r144 = [PLVLinkMicBitRate.STANDARD];
+        }
+        const s144 = q144.clientParams?.fps ?? 15;
+        const t144 = this.repo.mediator.currentPushResolutionRatio.value ?? PLVLinkMicPushResolutionRatio.RATIO_16_9;
+        const u144 = extendArray(DEFAULT_BITRATE_ENCODE_PARAM_TABLE)
+            .filter(h145 => r144.includes(h145.bitRate))
+            .groupBy_ext(g145 => g145.bitRate)
+            .filter_ext(f145 => f145[1].length > 0)
+            .mapValues_ext(e145 => this.reduceEncodeParams(e145[1], s144, t144))
+            .toArray_ext(d145 => d145[1]);
+        this.repo.mediator.channelSupportBitRateEncodeParams.setValue(u144);
+        const v144 = u144.map(c145 => c145.bitRate);
+        this.repo.mediator.channelSupportBitRates.setValue(v144);
+    }
+    reduceEncodeParams(a144, b144, ratio) {
+        const c144 = (a, b) => Math.abs(a - b) < 1e-6;
+        const d144 = a144.filter(p144 => p144.videoFps >= b144 && c144(p144.videoWidth / p144.videoHeight, ratio.ratio));
+        if (d144.length > 0) {
+            if (d144.length === 1) {
+                return d144[0];
+            }
+            else {
+                return d144.reduce((n144, o144) => n144.videoFps > o144.videoFps ? o144 : n144);
+            }
+        }
+        const e144 = a144.filter(l144 => c144(l144.videoWidth / l144.videoHeight, ratio.ratio));
+        if (e144.length > 0) {
+            if (e144.length === 1) {
+                return e144[0];
+            }
+            else {
+                return d144.reduce((j144, k144) => j144.videoFps > k144.videoFps ? k144 : j144);
+            }
+        }
+        return a144[0];
+    }
+    setupDefaultBitRate() {
+        if (this.isChannelUsePushStreamTemplate()) {
+            const t143 = requireNotNull(this.repo.mediator.channelData?.streamerData?.pushStreamTemplateJson);
+            const u143 = t143.VideoParams?.findIndex(z143 => z143.QualityLevel === t143.teacherDefaultQualityLevel);
+            const v143 = (this.repo.mediator.channelSupportBitRates.value ?? []).find(y143 => y143.index === u143) ?? PLVLinkMicBitRate.STANDARD;
+            this.setBitRate(v143);
+        }
+        else {
+            const s143 = extendArray(this.repo.mediator.channelSupportBitRates.value ?? [])
+                .lastOrNull_ext() ?? PLVLinkMicBitRate.STANDARD;
+            this.setBitRate(s143);
+        }
+    }
+    isChannelUsePushStreamTemplate() {
+        const r143 = this.repo.mediator.channelData?.streamerData;
+        return isLiteralTrue(r143?.clientPushStreamTemplateEnabled) && r143?.pushStreamTemplateJson !== undefined;
+    }
+}

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/teacher/LinkMicTeacherHandleRTCUseCase.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 LinkMicTeacherHandleRTCUseCase implements ILinkMicHandleRTCUseCase {
+    private readonly repo;
+    private observers;
+    constructor(l146: PLVLinkMicRepo);
+    init(): void;
+    joinChannel(): void;
+    leaveChannel(): void;
+    switchRole(role: PLVRTCClientRole): void;
+    enableCamera(enable: boolean): void;
+    enableMicrophone(enable: boolean): void;
+    enableCameraMicrophoneToLastState(): void;
+    switchCamera(): void;
+    setLocalRenderMirror(i146: boolean): void;
+    setupVideoRender(g146: PLVLinkMicVideoRenderParam): void;
+    removeVideoRender(e146: PLVLinkMicVideoRenderParam): void;
+    onDestroy(): void;
+    private getVideoRenderParam;
+}

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

@@ -0,0 +1,76 @@
+import { MutableObserver } from '@polyvharmony/media-player-sdk';
+import { PLVRTCClientRole, PLVRTCVideoRenderParam, PLVVideoRenderFitMode } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicCameraFacing } from '../../../../model/vo/PLVLinkMicCameraFacing';
+import { PLVLinkMicVideoRenderParam } from '../../../../model/vo/PLVLinkMicVideoRenderParam';
+export class LinkMicTeacherHandleRTCUseCase {
+    constructor(l146) {
+        this.observers = [];
+        this.repo = l146;
+    }
+    init() {
+    }
+    joinChannel() {
+        this.repo.joinRTCChannel();
+        this.switchRole(PLVRTCClientRole.BROADCASTER);
+    }
+    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(i146) {
+        const j146 = this.repo.mediator.linkmicId;
+        if (j146 === undefined) {
+            return;
+        }
+        this.repo.mediator.localRenderMirror.setValue(i146);
+        const k146 = this.getVideoRenderParam(j146);
+        this.setupVideoRender(new PLVLinkMicVideoRenderParam(j146, k146.viewId));
+    }
+    setupVideoRender(g146) {
+        const h146 = this.getVideoRenderParam(g146.linkmicId);
+        h146.viewId = g146.xcomponentId;
+        if (this.repo.mediator.isMySocketLinkMicId(g146.linkmicId)) {
+            h146.renderMirror = this.repo.mediator.localRenderMirror.value ?? false;
+        }
+        this.repo.setVideoRender(h146);
+    }
+    removeVideoRender(e146) {
+        const f146 = this.getVideoRenderParam(e146.linkmicId);
+        if (e146.xcomponentId === null || f146.viewId === e146.xcomponentId) {
+            f146.viewId = null;
+            this.repo.setVideoRender(f146);
+        }
+    }
+    onDestroy() {
+        MutableObserver.disposeAll(this.observers);
+        this.observers = [];
+    }
+    getVideoRenderParam(d146) {
+        let param = this.repo.getVideoRenderParam(d146);
+        if (param !== null) {
+            return param;
+        }
+        param = new PLVRTCVideoRenderParam();
+        param.linkmicId = d146;
+        param.viewId = null;
+        param.renderFitMode = PLVVideoRenderFitMode.HIDDEN;
+        param.renderMirror = false;
+        return param;
+    }
+}