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

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

@@ -0,0 +1,38 @@
+import { PLVUserType } from '../../../socket/model/PLVUserType';
+import { LinkMicViewerEncodeParamUseCase } from './roles/viewer/LinkMicViewerEncodeParamUseCase';
+import { LinkMicTeacherEncodeParamUseCase } from './roles/teacher/LinkMicTeacherEncodeParamUseCase';
+import { LinkMicGuestEncodeParamUseCase } from './roles/guest/LinkMicGuestEncodeParamUseCase';
+export class LinkMicEncodeParamUseCase {
+    constructor(y132) {
+        this.impl = undefined;
+        this.repo = y132;
+    }
+    init() {
+        const x132 = this.repo.mediator.channelData?.viewerType;
+        if (x132 === PLVUserType.USERTYPE_TEACHER) {
+            this.impl = new LinkMicTeacherEncodeParamUseCase(this.repo);
+        }
+        else if (x132 === PLVUserType.USERTYPE_GUEST) {
+            this.impl = new LinkMicGuestEncodeParamUseCase(this.repo);
+        }
+        else {
+            this.impl = new LinkMicViewerEncodeParamUseCase(this.repo);
+        }
+        this.impl?.init();
+    }
+    setBitRate(bitRate) {
+        this.impl?.setBitRate(bitRate);
+    }
+    setPushResolutionRatio(w132) {
+        this.impl?.setPushResolutionRatio(w132);
+    }
+    setPushOrientation(v132) {
+        this.impl?.setPushOrientation(v132);
+    }
+    setPushMirror(u132) {
+        this.impl?.setPushMirror(u132);
+    }
+    setPushDowngradePreference(t132) {
+        this.impl?.setPushDowngradePreference(t132);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { PLVLinkMicRepo } from '../../model/PLVLinkMicRepo';
+import { PLVLinkMicSocketJoinLeaveRecv, PLVLinkMicSocketJoinRequestRecv, PLVLinkMicSocketJoinSuccessRecv } from '../../model/vo/PLVLinkMicSocketEvent';
+export declare class LinkMicHandleQueueOrderUseCase {
+    private readonly repo;
+    constructor(l133: PLVLinkMicRepo);
+    onEventJoinRequest(i133: PLVLinkMicSocketJoinRequestRecv): void;
+    onEventJoinSuccess(e133: PLVLinkMicSocketJoinSuccessRecv): void;
+    onEventJoinLeave(z132: PLVLinkMicSocketJoinLeaveRecv): void;
+}

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

@@ -0,0 +1,47 @@
+import { isNullOrUndefined } from '@polyvharmony/media-player-sdk';
+export class LinkMicHandleQueueOrderUseCase {
+    constructor(l133) {
+        this.repo = l133;
+    }
+    onEventJoinRequest(i133) {
+        const j133 = i133.user?.userId;
+        const k133 = i133.requestIndex;
+        if (isNullOrUndefined(j133) || isNullOrUndefined(k133)) {
+            return;
+        }
+        if (this.repo.mediator.isMySocketLinkMicId(j133)) {
+            this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(k133);
+        }
+    }
+    onEventJoinSuccess(e133) {
+        const f133 = e133.user?.userId;
+        const g133 = e133.requestIndex;
+        if (isNullOrUndefined(f133) || isNullOrUndefined(g133)) {
+            return;
+        }
+        if (this.repo.mediator.isMySocketLinkMicId(f133)) {
+            this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(-1);
+            return;
+        }
+        const h133 = this.repo.mediator.joinLinkMicWaitingQueueOrder.value ?? -1;
+        if (g133 >= 0 && h133 > 0 && h133 > g133) {
+            this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(h133 - 1);
+        }
+    }
+    onEventJoinLeave(z132) {
+        const a133 = z132.user?.userId;
+        const b133 = z132.isLeaveMic;
+        const c133 = z132.requestIndex;
+        if (isNullOrUndefined(a133) || isNullOrUndefined(b133) || isNullOrUndefined(c133) || b133 === 1) {
+            return;
+        }
+        if (this.repo.mediator.isMySocketLinkMicId(a133)) {
+            this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(-1);
+            return;
+        }
+        const d133 = this.repo.mediator.joinLinkMicWaitingQueueOrder.value ?? -1;
+        if (c133 >= 0 && d133 > 0 && d133 > c133) {
+            this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(d133 - 1);
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+import { LifecycleAwareDependComponent } from '@polyvharmony/media-player-sdk';
+import { PLVRTCClientRole } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicRepo } from '../../model/PLVLinkMicRepo';
+import { PLVLinkMicVideoRenderParam } from '../../model/vo/PLVLinkMicVideoRenderParam';
+import { ILinkMicHandleRTCUseCase } from './roles/base/ILinkMicHandleRTCUseCase';
+export declare class LinkMicHandleRTCUseCase implements ILinkMicHandleRTCUseCase, LifecycleAwareDependComponent {
+    private readonly repo;
+    private observers;
+    private impl;
+    constructor(s133: PLVLinkMicRepo);
+    init(): void;
+    joinChannel(): void;
+    leaveChannel(): void;
+    switchRole(role: PLVRTCClientRole): void;
+    enableCamera(enable: boolean): void;
+    enableMicrophone(enable: boolean): void;
+    enableCameraMicrophoneToLastState(): void;
+    switchCamera(): void;
+    setLocalRenderMirror(o133: boolean): void;
+    setupVideoRender(n133: PLVLinkMicVideoRenderParam): void;
+    removeVideoRender(m133: PLVLinkMicVideoRenderParam): void;
+    onDestroy(): void;
+    private renewToken;
+}

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

@@ -0,0 +1,70 @@
+import { MutableObserver } from '@polyvharmony/media-player-sdk';
+import { PLVUserType } from '../../../socket/model/PLVUserType';
+import { PLVLinkMicRTCTokenExpired } from '../../model/vo/PLVLinkMicRTCEvent';
+import { LinkMicGuestHandleRTCUseCase } from './roles/guest/LinkMicGuestHandleRTCUseCase';
+import { LinkMicTeacherHandleRTCUseCase } from './roles/teacher/LinkMicTeacherHandleRTCUseCase';
+import { LinkMicViewerHandleRTCUseCase } from './roles/viewer/LinkMicViewerHandleRTCUseCase';
+export class LinkMicHandleRTCUseCase {
+    constructor(s133) {
+        this.observers = [];
+        this.impl = undefined;
+        this.repo = s133;
+    }
+    init() {
+        this.repo.mediator.rtcEvent.observe((r133) => {
+            if (r133 instanceof PLVLinkMicRTCTokenExpired) {
+                this.renewToken();
+            }
+        })
+            .pushTo(this.observers);
+        const p133 = this.repo.mediator.channelData?.viewerType;
+        if (p133 === PLVUserType.USERTYPE_TEACHER) {
+            this.impl = new LinkMicTeacherHandleRTCUseCase(this.repo);
+        }
+        else if (p133 === PLVUserType.USERTYPE_GUEST) {
+            this.impl = new LinkMicGuestHandleRTCUseCase(this.repo);
+        }
+        else {
+            this.impl = new LinkMicViewerHandleRTCUseCase(this.repo);
+        }
+        this.impl?.init();
+    }
+    joinChannel() {
+        this.impl?.joinChannel();
+    }
+    leaveChannel() {
+        this.impl?.leaveChannel();
+    }
+    switchRole(role) {
+        this.impl?.switchRole(role);
+    }
+    enableCamera(enable) {
+        this.impl?.enableCamera(enable);
+    }
+    enableMicrophone(enable) {
+        this.impl?.enableMicrophone(enable);
+    }
+    enableCameraMicrophoneToLastState() {
+        this.impl?.enableCameraMicrophoneToLastState();
+    }
+    switchCamera() {
+        this.impl?.switchCamera();
+    }
+    setLocalRenderMirror(o133) {
+        this.impl?.setLocalRenderMirror(o133);
+    }
+    setupVideoRender(n133) {
+        this.impl?.setupVideoRender(n133);
+    }
+    removeVideoRender(m133) {
+        this.impl?.removeVideoRender(m133);
+    }
+    onDestroy() {
+        this.impl?.onDestroy();
+        MutableObserver.disposeAll(this.observers);
+        this.observers = [];
+    }
+    renewToken() {
+        this.repo.renewToken();
+    }
+}

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

@@ -0,0 +1,38 @@
+import { LifecycleAwareDependComponent } from '@polyvharmony/media-player-sdk';
+import { PLVLinkMicRepo } from '../../model/PLVLinkMicRepo';
+import { ILinkMicHandleStateUseCase } from './roles/base/ILinkMicHandleStateUseCase';
+import { LinkMicHandleQueueOrderUseCase } from './LinkMicHandleQueueOrderUseCase';
+import { LinkMicHandleRTCUseCase } from './LinkMicHandleRTCUseCase';
+import { LinkMicUpdateChannelViewerUseCase } from './LinkMicUpdateChannelViewerUseCase';
+import { PLVLinkMicMode } from '../../model/vo/PLVLinkMicMode';
+export declare class LinkMicHandleStateUseCase implements ILinkMicHandleStateUseCase, LifecycleAwareDependComponent {
+    private readonly repo;
+    private readonly handleQueueOrderUseCase;
+    private readonly handleRTCUseCase;
+    private readonly updateChannelViewerUseCase;
+    private impl;
+    constructor(e134: PLVLinkMicRepo, f134: LinkMicHandleQueueOrderUseCase, g134: LinkMicHandleRTCUseCase, h134: LinkMicUpdateChannelViewerUseCase);
+    init(): void;
+    requestJoinLinkMic(): Promise<void>;
+    acceptInvitation(): Promise<void>;
+    refuseInvitation(): void;
+    leaveLinkMic(): void;
+    onStreamerStart(): void;
+    onLiveStreamStart(): void;
+    setLinkMicMode(c134: PLVLinkMicMode): Promise<boolean>;
+    openLinkMic(): Promise<boolean>;
+    closeLinkMic(): Promise<boolean>;
+    acceptViewerLinkMicRequest(b134: string): void;
+    inviteViewerLinkMic(z133: string, a134: boolean): void;
+    hangupViewerLinkMic(y133: string): void;
+    hangupAllViewersLinkMic(): void;
+    setViewerEnableCamera(x133: string, enable: boolean): void;
+    setViewerEnableMicrophone(w133: string, enable: boolean): void;
+    grantSpeaker(v133: string): void;
+    revokeSpeaker(u133: string): void;
+    setMainView(t133: string): void;
+    onLiveStreamStop(): void;
+    onStreamerStop(): void;
+    updateInvitationExpireTime(): void;
+    onDestroy(): void;
+}

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

@@ -0,0 +1,92 @@
+import { PLVUserType } from '../../../socket/model/PLVUserType';
+import { LinkMicViewerHandleStateUseCase } from './roles/viewer/LinkMicViewerHandleStateUseCase';
+import { LinkMicTeacherHandleStateUseCase } from './roles/teacher/LinkMicTeacherHandleStateUseCase';
+import { LinkMicGuestHandleStateUseCase } from './roles/guest/LinkMicGuestHandleStateUseCase';
+export class LinkMicHandleStateUseCase {
+    constructor(e134, f134, g134, h134) {
+        this.impl = undefined;
+        this.repo = e134;
+        this.handleQueueOrderUseCase = f134;
+        this.handleRTCUseCase = g134;
+        this.updateChannelViewerUseCase = h134;
+    }
+    init() {
+        const d134 = this.repo.mediator.channelData?.viewerType;
+        if (d134 === PLVUserType.USERTYPE_TEACHER) {
+            this.impl = new LinkMicTeacherHandleStateUseCase(this.repo, this.handleQueueOrderUseCase, this.handleRTCUseCase, this.updateChannelViewerUseCase);
+        }
+        else if (d134 === PLVUserType.USERTYPE_GUEST) {
+            this.impl = new LinkMicGuestHandleStateUseCase(this.repo, this.handleQueueOrderUseCase, this.handleRTCUseCase, this.updateChannelViewerUseCase);
+        }
+        else {
+            this.impl = new LinkMicViewerHandleStateUseCase(this.repo, this.handleQueueOrderUseCase, this.handleRTCUseCase, this.updateChannelViewerUseCase);
+        }
+        this.impl?.init();
+    }
+    async requestJoinLinkMic() {
+        await this.impl?.requestJoinLinkMic();
+    }
+    async acceptInvitation() {
+        await this.impl?.acceptInvitation();
+    }
+    refuseInvitation() {
+        this.impl?.refuseInvitation();
+    }
+    leaveLinkMic() {
+        this.impl?.leaveLinkMic();
+    }
+    onStreamerStart() {
+        this.impl?.onStreamerStart();
+    }
+    onLiveStreamStart() {
+        this.impl?.onLiveStreamStart();
+    }
+    async setLinkMicMode(c134) {
+        return this.impl?.setLinkMicMode(c134) ?? false;
+    }
+    async openLinkMic() {
+        return this.impl?.openLinkMic() ?? false;
+    }
+    async closeLinkMic() {
+        return this.impl?.closeLinkMic() ?? false;
+    }
+    acceptViewerLinkMicRequest(b134) {
+        this.impl?.acceptViewerLinkMicRequest(b134);
+    }
+    inviteViewerLinkMic(z133, a134) {
+        this.impl?.inviteViewerLinkMic(z133, a134);
+    }
+    hangupViewerLinkMic(y133) {
+        this.impl?.hangupViewerLinkMic(y133);
+    }
+    hangupAllViewersLinkMic() {
+        this.impl?.hangupAllViewersLinkMic();
+    }
+    setViewerEnableCamera(x133, enable) {
+        this.impl?.setViewerEnableCamera(x133, enable);
+    }
+    setViewerEnableMicrophone(w133, enable) {
+        this.impl?.setViewerEnableMicrophone(w133, enable);
+    }
+    grantSpeaker(v133) {
+        this.impl?.grantSpeaker(v133);
+    }
+    revokeSpeaker(u133) {
+        this.impl?.revokeSpeaker(u133);
+    }
+    setMainView(t133) {
+        this.impl?.setMainView(t133);
+    }
+    onLiveStreamStop() {
+        this.impl?.onLiveStreamStop();
+    }
+    onStreamerStop() {
+        this.impl?.onStreamerStop();
+    }
+    updateInvitationExpireTime() {
+        this.impl?.updateInvitationExpireTime();
+    }
+    onDestroy() {
+        this.impl?.onDestroy();
+    }
+}

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

@@ -0,0 +1,27 @@
+import { LifecycleAwareDependComponent } from '@polyvharmony/media-player-sdk';
+import { PLVLinkMicRepo } from '../../model/PLVLinkMicRepo';
+import { PLVLinkMicSocketJoinLeaveRecv, PLVLinkMicSocketJoinSuccessRecv, PLVLinkMicSocketSwitchViewRecv, PLVLinkMicSocketTeacherSetPermissionRecv } from '../../model/vo/PLVLinkMicSocketEvent';
+import { PLVLinkMicViewer } from '../../model/vo/PLVLinkMicViewer';
+export declare class LinkMicUpdateChannelViewerUseCase implements LifecycleAwareDependComponent {
+    private readonly repo;
+    private taskUpdateChannelLinkMicViewers;
+    private observers;
+    constructor(k137: PLVLinkMicRepo);
+    init(): void;
+    handleChannelLinkMicViewersUpdate(param: UpdateChannelLinkMicViewerPayload): void;
+    sortChannelLinkMicViewers(): void;
+    onEventJoinSuccess(c136: PLVLinkMicSocketJoinSuccessRecv): void;
+    onEventJoinLeave(y135: PLVLinkMicSocketJoinLeaveRecv): void;
+    onEventTeacherSetPermission(t135: PLVLinkMicSocketTeacherSetPermissionRecv): void;
+    onEventSwitchView(s135: PLVLinkMicSocketSwitchViewRecv): void;
+    startUpdateChannelLinkMicViewersInterval(): void;
+    stopUpdateChannelLinkMicViewersInterval(): void;
+    private updateByChannelLinkMicStatus;
+    onDestroy(): void;
+    private getViewerSortOrder;
+}
+export declare class UpdateChannelLinkMicViewerPayload {
+    add?: (PLVLinkMicViewer | undefined)[];
+    remove?: (PLVLinkMicViewer | undefined)[];
+    setAll?: (PLVLinkMicViewer | undefined)[];
+}

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

@@ -0,0 +1,247 @@
+import { PLVScheduledTask, PLVTextUtils } from '@polyvharmony/live-scenes-foundation';
+import { extendArray, isTextEmpty, MutableObserver, requireNotNull, seconds } from '@polyvharmony/media-player-sdk';
+import { PLVUserType } from '../../../socket/model/PLVUserType';
+import { PLVLinkMicViewer } from '../../model/vo/PLVLinkMicViewer';
+export class LinkMicUpdateChannelViewerUseCase {
+    constructor(k137) {
+        this.taskUpdateChannelLinkMicViewers = undefined;
+        this.observers = [];
+        this.repo = k137;
+    }
+    init() {
+    }
+    handleChannelLinkMicViewersUpdate(param) {
+        const l136 = this.repo.mediator.channelLinkMicViewers.value ?? [];
+        const m136 = extendArray(l136)
+            .associate_ext(j137 => [j137.linkmicId, j137]);
+        const n136 = [];
+        const o136 = [];
+        if (param.setAll) {
+            const b137 = extendArray(param.setAll).filterNotNull_ext();
+            const c137 = extendArray(b137)
+                .associate_ext(i137 => [i137.linkmicId, i137]);
+            b137.forEach(h137 => {
+                if (!m136.has(h137.linkmicId)) {
+                    n136.push(h137);
+                }
+            });
+            l136.forEach(g137 => {
+                if (!c137.has(g137.linkmicId)) {
+                    o136.push(g137);
+                }
+            });
+        }
+        else {
+            if (param.add) {
+                extendArray(param.add)
+                    .filterNotNull_ext()
+                    .forEach(a137 => {
+                    if (!m136.has(a137.linkmicId)) {
+                        n136.push(a137);
+                    }
+                });
+            }
+            if (param.remove) {
+                extendArray(param.remove)
+                    .filterNotNull_ext()
+                    .forEach(y136 => {
+                    if (m136.has(y136.linkmicId)) {
+                        o136.push(m136.get(y136.linkmicId));
+                    }
+                });
+            }
+        }
+        if (n136.length > 0 || o136.length > 0) {
+            const q136 = [];
+            l136.filter(w136 => !o136.includes(w136))
+                .forEach(v136 => q136.push(v136));
+            n136.forEach(u136 => q136.push(u136));
+            this.repo.mediator.channelLinkMicViewers.setValue(q136);
+            this.sortChannelLinkMicViewers();
+        }
+        if (n136.length > 0) {
+            this.repo.mediator.viewerJoinLinkMicEvent.setValue(n136);
+        }
+        if (o136.length > 0) {
+            this.repo.mediator.viewerLeaveLinkMicEvent.setValue(o136);
+        }
+    }
+    sortChannelLinkMicViewers() {
+        const h136 = this.repo.mediator.channelLinkMicViewers.value ?? [];
+        const i136 = extendArray(h136).sortBy_ext((k136) => this.getViewerSortOrder(k136));
+        this.repo.mediator.channelLinkMicViewers.setValue(i136);
+    }
+    onEventJoinSuccess(c136) {
+        if (this.repo.mediator.isMySocketLinkMicId(c136.user?.userId)) {
+            this.handleChannelLinkMicViewersUpdate({
+                add: [this.repo.mediator.localLinkMicViewer.value]
+            });
+        }
+        else if (c136.user?.userId) {
+            const d136 = requireNotNull(this.repo.mediator.channelData?.loginChannelId);
+            const e136 = this.repo.createRenderViewParam(c136.user.userId);
+            if (!e136) {
+                return;
+            }
+            const f136 = this.repo.getRemoteViewerMediaState(e136.linkmicId);
+            const g136 = new PLVLinkMicViewer(d136, e136.linkmicId, e136.componentId, e136.componentLibraryName);
+            g136.viewerName.value = c136.user.nick;
+            g136.viewerId = c136.user.loginId;
+            g136.viewerAvatar = PLVTextUtils.fixPic(c136.user.pic);
+            g136.viewerActor = c136.user.actor;
+            g136.viewerType = c136.user.userType;
+            g136.isMyself = false;
+            if (f136 !== undefined) {
+                g136.isAudioEnable.setValue(f136.audioEnable);
+                g136.isVideoEnable.setValue(f136.videoEnable);
+                g136.audioVolume.setValue(f136.audioVolume);
+            }
+            this.handleChannelLinkMicViewersUpdate({
+                add: [g136]
+            });
+        }
+    }
+    onEventJoinLeave(y135) {
+        if (this.repo.mediator.isMySocketLinkMicId(y135.user?.userId)) {
+            this.handleChannelLinkMicViewersUpdate({
+                remove: [this.repo.mediator.localLinkMicViewer.value]
+            });
+        }
+        else if (y135.user?.userId) {
+            const z135 = this.repo.mediator.channelLinkMicViewers.value?.find(b136 => b136.linkmicId === y135.user?.userId);
+            this.handleChannelLinkMicViewersUpdate({
+                remove: [z135]
+            });
+        }
+    }
+    onEventTeacherSetPermission(t135) {
+        if (t135.type === "voice" && t135.status === "1") {
+            const u135 = this.repo.mediator.memberMediator?.findViewerByViewerId(t135.userId);
+            if (u135 === undefined || u135.linkmicId === undefined) {
+                return;
+            }
+            const v135 = this.repo.mediator.findViewerByLinkMicId(u135.linkmicId);
+            if (v135 !== undefined) {
+                return;
+            }
+            const w135 = this.repo.createRenderViewParam(u135.linkmicId);
+            if (w135 === undefined) {
+                return;
+            }
+            if (this.repo.mediator.isMySocketLinkMicId(u135.linkmicId)) {
+                this.handleChannelLinkMicViewersUpdate({
+                    add: [this.repo.mediator.localLinkMicViewer.value]
+                });
+            }
+            else {
+                const x135 = new PLVLinkMicViewer(u135.channelId, u135.linkmicId, w135.componentId, w135.componentLibraryName);
+                x135.viewerName.value = u135.viewerName.value;
+                x135.viewerId = u135.viewerId;
+                x135.viewerAvatar = u135.viewerAvatar;
+                x135.viewerActor = u135.viewerActor;
+                x135.viewerType = u135.viewerType;
+                x135.isMyself = false;
+                this.handleChannelLinkMicViewersUpdate({
+                    add: [x135]
+                });
+            }
+        }
+    }
+    onEventSwitchView(s135) {
+        this.sortChannelLinkMicViewers();
+    }
+    startUpdateChannelLinkMicViewersInterval() {
+        this.stopUpdateChannelLinkMicViewersInterval();
+        this.taskUpdateChannelLinkMicViewers = new PLVScheduledTask(() => this.updateByChannelLinkMicStatus(), 0, seconds(20).toMillis());
+        this.taskUpdateChannelLinkMicViewers.start();
+    }
+    stopUpdateChannelLinkMicViewersInterval() {
+        this.taskUpdateChannelLinkMicViewers?.cancel();
+        this.taskUpdateChannelLinkMicViewers = undefined;
+    }
+    async updateByChannelLinkMicStatus() {
+        const b135 = requireNotNull(this.repo.mediator.channelData?.loginChannelId);
+        const c135 = await this.repo.getChannelLinkMicStatus();
+        const d135 = [PLVUserType.USERTYPE_GUEST];
+        this.repo.mediator.memberMediator?.updateByLinkMicStatusList?.(c135);
+        const e135 = c135.joinList
+            ?.filter(p135 => {
+            const userType = p135.userType;
+            const q135 = p135.userId;
+            if (!userType || !q135) {
+                return false;
+            }
+            if (d135.includes(userType)) {
+                return p135.classStatus?.voice === 1;
+            }
+            return true;
+        })
+            .map((k135) => {
+            const l135 = this.repo.createRenderViewParam(k135.userId);
+            if (!l135) {
+                return undefined;
+            }
+            const m135 = this.repo.mediator.isMySocketLinkMicId(l135.linkmicId);
+            if (m135) {
+                return this.repo.mediator.localLinkMicViewer.value;
+            }
+            else {
+                const n135 = this.repo.getRemoteViewerMediaState(l135.linkmicId);
+                const o135 = new PLVLinkMicViewer(b135, l135.linkmicId, l135.componentId, l135.componentLibraryName);
+                o135.viewerName.value = k135.nick ?? undefined;
+                o135.viewerId = k135.loginId ?? undefined;
+                o135.viewerAvatar = PLVTextUtils.fixPic(k135.pic ?? undefined);
+                o135.viewerActor = k135.actor ?? undefined;
+                o135.viewerType = k135.userType ?? undefined;
+                o135.isMyself = false;
+                if (n135 !== undefined) {
+                    o135.isAudioEnable.setValue(n135.audioEnable);
+                    o135.isVideoEnable.setValue(n135.videoEnable);
+                    o135.audioVolume.setValue(n135.audioVolume);
+                }
+                return o135;
+            }
+        })
+            ?? [];
+        this.handleChannelLinkMicViewersUpdate({
+            setAll: e135
+        });
+        let f135 = c135.master;
+        if (isTextEmpty(f135)) {
+            f135 = e135.find(j135 => j135?.viewerType === PLVUserType.USERTYPE_TEACHER)?.linkmicId;
+        }
+        if (isTextEmpty(f135)) {
+            f135 = e135[0]?.linkmicId;
+        }
+        if (f135 !== this.repo.mediator.channelMainViewLinkMicId.value) {
+            this.repo.mediator.channelMainViewLinkMicId.setValue(f135);
+            this.sortChannelLinkMicViewers();
+        }
+    }
+    onDestroy() {
+        this.stopUpdateChannelLinkMicViewersInterval();
+        MutableObserver.disposeAll(this.observers);
+        this.observers = [];
+    }
+    getViewerSortOrder(i134) {
+        const j134 = this.repo.mediator.channelMainViewLinkMicId.value;
+        const k134 = [
+            (a135) => a135.linkmicId === j134,
+            (z134) => z134.viewerType === PLVUserType.USERTYPE_TEACHER,
+            (y134) => y134.isMyself,
+            (x134) => x134.viewerType === PLVUserType.USERTYPE_GUEST,
+            (w134) => w134.viewerType === PLVUserType.USERTYPE_MANAGER,
+            (v134) => v134.viewerType === PLVUserType.USERTYPE_VIEWER,
+            (u134) => u134.viewerType === PLVUserType.USERTYPE_ASSISTANT,
+            (t134) => t134.viewerType !== PLVUserType.USERTYPE_DUMMY,
+        ];
+        for (let order = 0; order < k134.length; order++) {
+            if (k134[order](i134)) {
+                return order;
+            }
+        }
+        return k134.length;
+    }
+}
+export class UpdateChannelLinkMicViewerPayload {
+}

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

@@ -0,0 +1,17 @@
+import { LifecycleAwareDependComponent } from '@polyvharmony/media-player-sdk';
+import { PLVLinkMicRepo } from '../../model/PLVLinkMicRepo';
+export declare class LinkMicViewLogUseCase implements LifecycleAwareDependComponent {
+    private readonly repo;
+    private viewLogTask;
+    private playId;
+    private stayDuration;
+    private playDuration;
+    private observers;
+    constructor(r137: PLVLinkMicRepo);
+    init(): void;
+    private startViewLogTask;
+    private stopViewLogTask;
+    private onViewLogTaskInterval;
+    private sendViewLog;
+    onDestroy(): void;
+}