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

package/src/main/ets/modules/member/viewmodel/usecase/roles/guest/MemberGuestUpdateViewerUseCase.js

@@ -0,0 +1,344 @@
+import { PLVScheduledTask, PLVTextUtils } from '@polyvharmony/live-scenes-foundation';
+import { extendArray, isLiteralTrue, isNullOrUndefined, requireNotNull, retry, RetryConditions, runCatching, seconds } from '@polyvharmony/media-player-sdk';
+import { PLVLinkMicState } from '../../../../../linkmic/model/vo/PLVLinkMicState';
+import { PLVSocketUserBean } from '../../../../../socket/model/PLVSocketUserBean';
+import { PLVUserType } from '../../../../../socket/model/PLVUserType';
+import { PLVMemberChannelViewer } from '../../../../model/vo/PLVMemberChannelViewer';
+const MEMBER_LIST_MAX_LENGTH = 500;
+export class MemberGuestUpdateViewerUseCase {
+    constructor(t164) {
+        this.updateChannelViewerTask = null;
+        this.repo = t164;
+    }
+    startUpdateChannelViewersInterval() {
+        this.stopUpdateChannelViewersInterval();
+        this.updateChannelViewerTask = new PLVScheduledTask(() => {
+            this.updateServerListViewer();
+        }, 0, seconds(20).toMillis());
+        this.updateChannelViewerTask.start();
+    }
+    stopUpdateChannelViewersInterval() {
+        this.updateChannelViewerTask?.cancel();
+        this.updateChannelViewerTask = null;
+    }
+    handleChannelViewersUpdate(payload) {
+        const s163 = this.repo.mediator.channelViewers.value ?? [];
+        const t163 = extendArray(s163)
+            .associate_ext(r164 => [r164.viewerId, r164]);
+        const u163 = [];
+        const v163 = [];
+        if (payload.setAll) {
+            const i164 = extendArray(payload.setAll).filterNotNull_ext();
+            const j164 = extendArray(i164)
+                .associate_ext(q164 => [q164.viewerId, q164]);
+            i164.forEach(o164 => {
+                if (t163.has(o164.viewerId)) {
+                    const p164 = t163.get(o164.viewerId);
+                    p164.linkmicId ??= o164.linkmicId;
+                    p164.socketId ??= o164.socketId;
+                }
+                if (!t163.has(o164.viewerId)) {
+                    u163.push(o164);
+                }
+            });
+            s163.forEach(n164 => {
+                if (!j164.has(n164.viewerId)) {
+                    v163.push(n164);
+                }
+            });
+        }
+        else {
+            if (payload.add) {
+                extendArray(payload.add)
+                    .filterNotNull_ext()
+                    .forEach(h164 => {
+                    if (!t163.has(h164.viewerId)) {
+                        u163.push(h164);
+                    }
+                });
+            }
+            if (payload.remove) {
+                extendArray(payload.remove)
+                    .filterNotNull_ext()
+                    .forEach(f164 => {
+                    if (t163.has(f164.viewerId)) {
+                        v163.push(t163.get(f164.viewerId));
+                    }
+                });
+            }
+        }
+        if (u163.length > 0 || v163.length > 0) {
+            const x163 = [];
+            s163.filter(d164 => !v163.includes(d164))
+                .forEach(c164 => x163.push(c164));
+            u163.forEach(b164 => x163.push(b164));
+            this.repo.mediator.channelViewers.setValue(x163);
+            this.sortChannelViewers();
+        }
+    }
+    sortChannelViewers() {
+        const o163 = this.repo.mediator.channelViewers.value ?? [];
+        const p163 = extendArray(o163).sortBy_ext((r163) => this.getViewerSortOrder(r163));
+        this.repo.mediator.channelViewers.setValue(p163);
+    }
+    updateByLinkMicStatusList(g162) {
+        const h162 = this.repo.mediator.channelViewers.value ?? [];
+        const i162 = extendArray(h162)
+            .associate_ext(n163 => [n163.viewerId, n163]);
+        const j162 = extendArray(g162.joinList ?? [])
+            .associate_ext(m163 => [m163.loginId ?? m163.userId, m163]);
+        const k162 = extendArray(g162.waitList ?? [])
+            .associate_ext(l163 => [l163.loginId ?? l163.userId, l163]);
+        const l162 = [];
+        const m162 = [];
+        let n162 = false;
+        i162.forEach((f163, g163) => {
+            const h163 = j162.has(g163) && j162.get(g163)?.classStatus?.voice === 1;
+            const i163 = k162.has(g163);
+            const j163 = f163.linkmicState.value ?? PLVLinkMicState.NoLinkMic;
+            if (h163) {
+                f163.linkmicState.setValue(PLVLinkMicState.Joined);
+            }
+            else if (i163) {
+                if (j163 !== PLVLinkMicState.Requesting) {
+                    f163.linkmicState.setValue(PLVLinkMicState.Requesting);
+                    m162.push(f163);
+                }
+            }
+            else {
+                const k163 = [PLVLinkMicState.Inviting, PLVLinkMicState.WaitingResponse];
+                if (!k163.includes(j163)) {
+                    f163.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+                }
+            }
+            n162 ||= j163 !== f163.linkmicState.value;
+        });
+        g162.joinList?.forEach(a163 => {
+            const b163 = a163.loginId;
+            const c163 = a163.roomId;
+            if (isNullOrUndefined(b163) || isNullOrUndefined(c163)) {
+                return;
+            }
+            if (!i162.has(b163)) {
+                const d163 = new PLVMemberChannelViewer(c163, b163);
+                const e163 = a163.classStatus?.voice === 1;
+                d163.linkmicState.setValue(e163 ? PLVLinkMicState.Joined : PLVLinkMicState.NoLinkMic);
+                d163.viewerName.setValue(a163.nick);
+                d163.viewerType = a163.userType ?? undefined;
+                d163.viewerAvatar = PLVTextUtils.fixPic(a163.pic ?? undefined);
+                d163.viewerActor = a163.actor ?? undefined;
+                d163.linkmicId = a163.userId ?? undefined;
+                d163.socketId = a163.uid ?? undefined;
+                d163.isMyself = b163 === this.repo.mediator.channelData?.viewerId;
+                l162.push(d163);
+            }
+        });
+        g162.waitList?.forEach(w162 => {
+            const x162 = w162.loginId;
+            const y162 = w162.roomId;
+            if (isNullOrUndefined(x162) || isNullOrUndefined(y162)) {
+                return;
+            }
+            if (!i162.has(x162)) {
+                const z162 = new PLVMemberChannelViewer(y162, x162);
+                z162.linkmicState.setValue(PLVLinkMicState.Requesting);
+                z162.viewerName.setValue(w162.nick);
+                z162.viewerType = w162.userType ?? undefined;
+                z162.viewerAvatar = PLVTextUtils.fixPic(w162.pic ?? undefined);
+                z162.viewerActor = w162.actor ?? undefined;
+                z162.linkmicId = w162.userId ?? undefined;
+                z162.socketId = w162.uid ?? undefined;
+                z162.isMyself = x162 === this.repo.mediator.channelData?.viewerId;
+                l162.push(z162);
+                m162.push(z162);
+            }
+        });
+        this.handleChannelViewersUpdate({
+            add: l162
+        });
+        if (n162) {
+            this.sortChannelViewers();
+        }
+        m162.forEach(v162 => {
+            this.repo.mediator.onViewerRequestLinkMic.setValue(v162);
+        });
+    }
+    onSocketUserLogin(z161) {
+        const a162 = z161.onlineUserNumber;
+        if (a162 !== undefined) {
+            this.repo.mediator.channelViewerCount.setValue(a162);
+        }
+        const b162 = z161.user?.userId;
+        if (isNullOrUndefined(b162)) {
+            return;
+        }
+        const c162 = this.repo.mediator.channelViewers.value ?? [];
+        if (c162.length < MEMBER_LIST_MAX_LENGTH) {
+            const d162 = this.repo.mediator.findViewerByViewerId(b162);
+            if (d162 === undefined) {
+                const e162 = requireNotNull(z161.user?.roomId ?? this.repo.mediator.channelData?.loginChannelId);
+                const f162 = new PLVMemberChannelViewer(e162, b162);
+                f162.viewerName.value = z161.user?.nick;
+                f162.viewerType = z161.user?.userType;
+                f162.viewerAvatar = PLVTextUtils.fixPic(z161.user?.pic);
+                f162.viewerActor = z161.user?.actor;
+                f162.socketId = z161.user?.uid;
+                f162.isMyself = b162 === this.repo.mediator.channelData?.viewerId;
+                if (PLVSocketUserBean.isSpecialType(f162.viewerType)) {
+                    f162.linkmicId = b162;
+                }
+                if (z161.user?.banned !== undefined) {
+                    f162.ban.setValue(z161.user.banned);
+                }
+                this.handleChannelViewersUpdate({
+                    add: [f162]
+                });
+            }
+        }
+    }
+    onSocketUserLogout(v161) {
+        const w161 = v161.onlineUserNumber;
+        if (w161 !== undefined) {
+            this.repo.mediator.channelViewerCount.setValue(w161);
+        }
+        const x161 = v161.userId;
+        const y161 = this.repo.mediator.findViewerByViewerId(x161);
+        if (y161 !== undefined) {
+            this.handleChannelViewersUpdate({
+                remove: [y161]
+            });
+        }
+    }
+    onSocketJoinRequest(q161) {
+        const r161 = q161.user?.loginId;
+        if (isNullOrUndefined(r161)) {
+            return;
+        }
+        const s161 = this.repo.mediator.findViewerByViewerId(r161);
+        if (s161 !== undefined) {
+            if (s161.linkmicState.value === PLVLinkMicState.NoLinkMic) {
+                s161.linkmicState.setValue(PLVLinkMicState.Requesting);
+            }
+            s161.linkmicId = q161.user?.userId;
+            this.sortChannelViewers();
+        }
+        else {
+            const t161 = requireNotNull(q161.user?.roomId ?? this.repo.mediator.channelData?.loginChannelId);
+            const u161 = new PLVMemberChannelViewer(t161, r161);
+            u161.viewerName.value = q161.user?.nick;
+            u161.viewerType = q161.user?.userType;
+            u161.viewerAvatar = PLVTextUtils.fixPic(q161.user?.pic);
+            u161.viewerActor = q161.user?.actor;
+            u161.linkmicId = q161.user?.userId;
+            u161.socketId = q161.user?.uid;
+            u161.linkmicState.setValue(PLVLinkMicState.Requesting);
+            u161.isMyself = r161 === this.repo.mediator.channelData?.viewerId;
+            this.handleChannelViewersUpdate({
+                add: [u161]
+            });
+        }
+    }
+    onSocketJoinAnswer(n161) {
+        const o161 = n161.userId;
+        if (isNullOrUndefined(o161)) {
+            return;
+        }
+        const p161 = this.repo.mediator.findViewerByViewerId(o161);
+        if (p161 !== undefined) {
+            if (!isLiteralTrue(n161.status)) {
+                p161.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+            }
+        }
+    }
+    onSocketJoinSuccess(i161) {
+        const j161 = i161.user?.loginId;
+        if (isNullOrUndefined(j161)) {
+            return;
+        }
+        const k161 = this.repo.mediator.findViewerByViewerId(j161);
+        if (k161 !== undefined) {
+            k161.linkmicState.setValue(PLVLinkMicState.Joined);
+            k161.linkmicId = i161.user?.userId;
+            this.sortChannelViewers();
+        }
+        else {
+            const l161 = requireNotNull(i161.user?.roomId ?? this.repo.mediator.channelData?.loginChannelId);
+            const m161 = new PLVMemberChannelViewer(l161, j161);
+            m161.viewerName.value = i161.user?.nick;
+            m161.viewerType = i161.user?.userType;
+            m161.viewerAvatar = PLVTextUtils.fixPic(i161.user?.pic);
+            m161.viewerActor = i161.user?.actor;
+            m161.linkmicId = i161.user?.userId;
+            m161.socketId = i161.user?.uid;
+            m161.linkmicState.setValue(PLVLinkMicState.Joined);
+            m161.isMyself = j161 === this.repo.mediator.channelData?.viewerId;
+            this.handleChannelViewersUpdate({
+                add: [m161]
+            });
+        }
+    }
+    onSocketJoinLeave(f161) {
+        const g161 = f161.user?.loginId;
+        if (isNullOrUndefined(g161)) {
+            return;
+        }
+        const h161 = this.repo.mediator.findViewerByViewerId(g161);
+        if (h161 !== undefined) {
+            h161.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+            this.sortChannelViewers();
+        }
+    }
+    async updateServerListViewer() {
+        const sessionId = this.repo.mediator.channelData?.sessionId;
+        if (sessionId === undefined) {
+            return;
+        }
+        const response = await runCatching(retry(() => this.repo.getListUsers(sessionId, 1, MEMBER_LIST_MAX_LENGTH), RetryConditions.delay(3, seconds(3))));
+        if (response.success === false) {
+            return;
+        }
+        this.repo.mediator.channelViewerCount.setValue(response.data.count ?? 0);
+        const a161 = extendArray(response.data.userlist ?? [])
+            .filterNotNull_ext()
+            .map((d161) => {
+            if (isNullOrUndefined(d161.channelId) || isNullOrUndefined(d161.userId)) {
+                return null;
+            }
+            const e161 = new PLVMemberChannelViewer(d161.channelId, d161.userId);
+            e161.viewerType = d161.userType ?? undefined;
+            e161.viewerName.value = d161.nick ?? undefined;
+            e161.viewerAvatar = d161.pic ? PLVTextUtils.fixPic(d161.pic) : undefined;
+            e161.viewerActor = d161.actor ?? undefined;
+            e161.linkmicId = d161.micId?.toString() ?? d161.userId;
+            e161.socketId = d161.uid ?? undefined;
+            e161.isMyself = d161.userId === this.repo.mediator.channelData?.viewerId;
+            e161.ban.setValue(isLiteralTrue(d161.classStatus?.banned));
+            return e161;
+        })
+            .filterNotNull_ext();
+        this.handleChannelViewersUpdate({
+            setAll: a161
+        });
+    }
+    getViewerSortOrder(c160) {
+        const d160 = [
+            (z160) => z160.isMyself,
+            (y160) => y160.viewerType === PLVUserType.USERTYPE_MANAGER,
+            (x160) => x160.viewerType === PLVUserType.USERTYPE_TEACHER,
+            (w160) => w160.viewerType === PLVUserType.USERTYPE_GUEST,
+            (v160) => v160.viewerType === PLVUserType.USERTYPE_VIEWER,
+            (u160) => u160.viewerType === PLVUserType.USERTYPE_ASSISTANT,
+            (t160) => t160.linkmicState.value === PLVLinkMicState.Requesting,
+            (s160) => s160.linkmicState.value === PLVLinkMicState.Inviting,
+            (r160) => r160.linkmicState.value === PLVLinkMicState.WaitingResponse,
+            (q160) => q160.linkmicState.value === PLVLinkMicState.Joined,
+            (p160) => p160.viewerType !== PLVUserType.USERTYPE_DUMMY,
+        ];
+        for (let order = 0; order < d160.length; order++) {
+            if (d160[order](c160)) {
+                return order;
+            }
+        }
+        return d160.length;
+    }
+}

package/src/main/ets/modules/member/viewmodel/usecase/roles/teacher/MemberTeacherHandleStateUseCase.d.ets

@@ -0,0 +1,32 @@
+import { PLVMemberRepo } from '../../../../model/PLVMemberRepo';
+import { MemberUpdateViewerUseCase } from '../../MemberUpdateViewerUseCase';
+import { IMemberHandleStateUseCase } from '../base/IMemberHandleStateUseCase';
+export declare class MemberTeacherHandleStateUseCase implements IMemberHandleStateUseCase {
+    private readonly repo;
+    private readonly updateViewerUseCase;
+    private disposables;
+    private observers;
+    constructor(f167: PLVMemberRepo, g167: MemberUpdateViewerUseCase);
+    init(): void;
+    acceptViewerLinkMicRequest(v166: string): void;
+    inviteViewerLinkMic(p166: string, q166?: boolean): void;
+    hangupViewerLinkMic(m166: string): void;
+    kickViewer(j166: string): Promise<void>;
+    banViewer(f166: string, g166?: boolean): Promise<void>;
+    private onSocketMessage;
+    private onSocketUserLogin;
+    private onSocketUserLogout;
+    private onSocketTeacherSetPermission;
+    private onSocketUserSetNick;
+    private onSocketBanIp;
+    private onSocketUnShield;
+    private onSocketSwitchJoinVoice;
+    private onSocketJoinRequest;
+    private onSocketJoinAnswer;
+    private onSocketJoinSuccess;
+    private onSocketJoinLeave;
+    onDestroy(): void;
+    private observeSocketEvent;
+    private createViewerSocketUser;
+    private isChannelReachLinkMicLimit;
+}

package/src/main/ets/modules/member/viewmodel/usecase/roles/teacher/MemberTeacherHandleStateUseCase.js

@@ -0,0 +1,245 @@
+import { PLVDisposable, PLVLogger } from '@polyvharmony/live-scenes-foundation';
+import { decodeFromJson, encodeToJson, isNullOrUndefined, md5, MutableObserver, requireNotNull } from '@polyvharmony/media-player-sdk';
+import { PLVLinkMicSocketJoinAnswerRecv, PLVLinkMicSocketJoinLeaveRecv, PLVLinkMicSocketJoinRequestRecv, PLVLinkMicSocketJoinResponseSend, PLVLinkMicSocketJoinSuccessRecv, PLVLinkMicSocketOpenMicrophoneSend, PLVLinkMicSocketSwitchJoinVoiceRecv, PLVLinkMicSocketTeacherSetPermissionRecv } from '../../../../../linkmic/model/vo/PLVLinkMicSocketEvent';
+import { PLVLinkMicState } from '../../../../../linkmic/model/vo/PLVLinkMicState';
+import { PLVSocketMessageEvent, PLVSocketOnEvent } from '../../../../../socket/model/PLVSocketEventConstants';
+import { PLVSocketUserSend } from '../../../../../socket/model/PLVSocketUserBean';
+import { PLVMemberErrorEvent } from '../../../../model/vo/PLVMemberErrorEvent';
+import { PLVMemberSocketBanIpRecv, PLVMemberSocketKickSend, PLVMemberSocketLoginRecv, PLVMemberSocketLogoutRecv, PLVMemberSocketSetNickRecv, PLVMemberSocketShieldSend, PLVMemberSocketUnShieldRecv, PLVMemberSocketUnShieldSend } from '../../../../model/vo/PLVMemberSocketEvent';
+const TAG = "PLVMemberManager";
+export class MemberTeacherHandleStateUseCase {
+    constructor(f167, g167) {
+        this.disposables = [];
+        this.observers = [];
+        this.repo = f167;
+        this.updateViewerUseCase = g167;
+    }
+    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_ANSWER, (data) => this.onSocketJoinAnswer(data)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_SUCCESS, (data) => this.onSocketJoinSuccess(data)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_LEAVE, (data) => this.onSocketJoinLeave(data)));
+    }
+    acceptViewerLinkMicRequest(v166) {
+        if (this.isChannelReachLinkMicLimit()) {
+            this.repo.mediator.reportError(PLVMemberErrorEvent.REACH_LINKMIC_LIMIT, "acceptViewerLinkMicRequest channel reach linkmic limit");
+            return;
+        }
+        const w166 = this.repo.mediator.findViewerByViewerId(v166);
+        if (w166 === undefined) {
+            PLVLogger.error(TAG, `acceptViewerLinkMicRequest viewerId ${v166} not found.`);
+            return;
+        }
+        const x166 = this.createViewerSocketUser(w166);
+        const y166 = new PLVLinkMicSocketJoinResponseSend();
+        y166.user = x166;
+        y166.roomId = w166.channelId;
+        y166.value = "1";
+        y166.toEmitAll = 1;
+        y166.needAnswer = 0;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_RESPONSE, encodeToJson(y166), () => {
+            if (w166.linkmicState.value !== PLVLinkMicState.Joined) {
+                w166.linkmicState.setValue(PLVLinkMicState.WaitingResponse);
+                this.updateViewerUseCase.sortChannelViewers();
+            }
+        });
+    }
+    inviteViewerLinkMic(p166, q166 = true) {
+        if (this.isChannelReachLinkMicLimit()) {
+            this.repo.mediator.reportError(PLVMemberErrorEvent.REACH_LINKMIC_LIMIT, "inviteViewerLinkMic channel reach linkmic limit");
+            return;
+        }
+        const r166 = this.repo.mediator.findViewerByViewerId(p166);
+        if (r166 === undefined) {
+            PLVLogger.error(TAG, `acceptViewerLinkMicRequest viewerId ${p166} not found.`);
+            return;
+        }
+        if (r166.linkmicState.value === PLVLinkMicState.Requesting) {
+            return this.acceptViewerLinkMicRequest(p166);
+        }
+        const s166 = this.createViewerSocketUser(r166);
+        const t166 = new PLVLinkMicSocketJoinResponseSend();
+        t166.user = s166;
+        t166.roomId = r166.channelId;
+        t166.value = "1";
+        t166.toEmitAll = 1;
+        t166.needAnswer = q166 ? 1 : 0;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_RESPONSE, encodeToJson(t166), () => {
+            if (r166.linkmicState.value !== PLVLinkMicState.Joined) {
+                r166.linkmicState.setValue(PLVLinkMicState.Inviting);
+                this.updateViewerUseCase.sortChannelViewers();
+            }
+        });
+    }
+    hangupViewerLinkMic(m166) {
+        const n166 = this.repo.mediator.findViewerByViewerId(m166);
+        if (n166 === undefined) {
+            PLVLogger.error(TAG, `acceptViewerLinkMicRequest viewerId ${m166} not found.`);
+            return;
+        }
+        const o166 = new PLVLinkMicSocketOpenMicrophoneSend();
+        o166.roomId = n166.channelId;
+        o166.status = "close";
+        o166.userId = n166.linkmicId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(o166));
+        n166.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+        this.updateViewerUseCase.sortChannelViewers();
+    }
+    async kickViewer(j166) {
+        const k166 = await this.repo.mediator.channelData?.loginRoomIdPromise.get();
+        const l166 = new PLVMemberSocketKickSend();
+        l166.roomId = k166;
+        l166.channelId = this.repo.mediator.channelData?.loginChannelId;
+        l166.type = "userId";
+        l166.userId = j166;
+        l166.sign = md5(`polyv_room_sign${k166}`);
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(l166));
+    }
+    async banViewer(f166, g166 = true) {
+        const h166 = await this.repo.mediator.channelData?.loginRoomIdPromise.get();
+        const i166 = g166 ? new PLVMemberSocketShieldSend() : new PLVMemberSocketUnShieldSend();
+        i166.roomId = h166;
+        i166.channelId = this.repo.mediator.channelData?.loginChannelId;
+        i166.type = "userId";
+        i166.value = f166;
+        i166.sign = md5(`polyv_room_sign${h166}`);
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(i166));
+    }
+    onSocketMessage(data, event) {
+        switch (event) {
+            case PLVSocketMessageEvent.LOGIN: return this.onSocketUserLogin(data);
+            case PLVSocketMessageEvent.LOGOUT: return this.onSocketUserLogout(data);
+            case PLVSocketMessageEvent.TEACHER_SET_PERMISSION: return this.onSocketTeacherSetPermission(data);
+            case PLVSocketMessageEvent.SET_NICK: return this.onSocketUserSetNick(data);
+            case PLVSocketMessageEvent.BAN_IP: return this.onSocketBanIp(data);
+            case PLVSocketMessageEvent.UN_SHIELD: return this.onSocketUnShield(data);
+            case PLVSocketMessageEvent.SWITCH_JOIN_VOICE: return this.onSocketSwitchJoinVoice(data);
+            default:
+        }
+    }
+    onSocketUserLogin(data) {
+        const e166 = decodeFromJson(data, PLVMemberSocketLoginRecv);
+        this.updateViewerUseCase.onSocketUserLogin(e166);
+    }
+    onSocketUserLogout(data) {
+        const d166 = decodeFromJson(data, PLVMemberSocketLogoutRecv);
+        this.updateViewerUseCase.onSocketUserLogout(d166);
+    }
+    onSocketTeacherSetPermission(data) {
+        const a166 = decodeFromJson(data, PLVLinkMicSocketTeacherSetPermissionRecv);
+        const b166 = this.repo.mediator.findViewerByViewerId(a166.userId);
+        if (b166 === undefined) {
+            return;
+        }
+        if (a166.type === "voice") {
+            const c166 = a166.status === "1";
+            b166.linkmicState.setValue(c166 ? PLVLinkMicState.Joined : PLVLinkMicState.NoLinkMic);
+        }
+    }
+    onSocketUserSetNick(data) {
+        const x165 = decodeFromJson(data, PLVMemberSocketSetNickRecv);
+        const y165 = x165.userId;
+        const z165 = this.repo.mediator.findViewerByViewerId(y165);
+        if (z165 !== undefined) {
+            z165.viewerName.setValue(x165.nick);
+        }
+    }
+    onSocketBanIp(data) {
+        const u165 = decodeFromJson(data, PLVMemberSocketBanIpRecv);
+        const v165 = u165.data?.userId;
+        const w165 = this.repo.mediator.findViewerByViewerId(v165);
+        if (w165 !== undefined) {
+            w165.ban.setValue(true);
+        }
+    }
+    onSocketUnShield(data) {
+        const r165 = decodeFromJson(data, PLVMemberSocketUnShieldRecv);
+        const s165 = r165.data?.userId;
+        const t165 = this.repo.mediator.findViewerByViewerId(s165);
+        if (t165 !== undefined) {
+            t165.ban.setValue(false);
+        }
+    }
+    onSocketSwitchJoinVoice(data) {
+        const n165 = decodeFromJson(data, PLVLinkMicSocketSwitchJoinVoiceRecv);
+        const o165 = n165.user?.loginId;
+        const p165 = n165.user?.micId?.toString() ?? n165.user?.userId;
+        const q165 = this.repo.mediator.findViewerByViewerId(o165);
+        if (q165 !== undefined && !isNullOrUndefined(p165)) {
+            q165.linkmicId = p165;
+        }
+    }
+    onSocketJoinRequest(data) {
+        const k165 = decodeFromJson(data, PLVLinkMicSocketJoinRequestRecv);
+        this.updateViewerUseCase.onSocketJoinRequest(k165);
+        const l165 = k165.user?.loginId;
+        const m165 = this.repo.mediator.findViewerByViewerId(l165);
+        if (m165 !== undefined) {
+            if (l165 !== undefined && m165.linkmicState.value === PLVLinkMicState.Inviting) {
+                this.acceptViewerLinkMicRequest(l165);
+            }
+            else {
+                this.repo.mediator.onViewerRequestLinkMic.setValue(m165);
+            }
+        }
+    }
+    onSocketJoinAnswer(data) {
+        const j165 = decodeFromJson(data, PLVLinkMicSocketJoinAnswerRecv);
+        this.updateViewerUseCase.onSocketJoinAnswer(j165);
+    }
+    onSocketJoinSuccess(data) {
+        const i165 = decodeFromJson(data, PLVLinkMicSocketJoinSuccessRecv);
+        this.updateViewerUseCase.onSocketJoinSuccess(i165);
+    }
+    onSocketJoinLeave(data) {
+        const h165 = decodeFromJson(data, PLVLinkMicSocketJoinLeaveRecv);
+        this.updateViewerUseCase.onSocketJoinLeave(h165);
+    }
+    onDestroy() {
+        this.disposables.forEach((g165) => {
+            g165.dispose();
+        });
+        this.disposables = [];
+        MutableObserver.disposeAll(this.observers);
+        this.observers = [];
+    }
+    observeSocketEvent(event, callback) {
+        const d165 = requireNotNull(this.repo.mediator.socketMediator);
+        d165.onData(event, callback);
+        return disposable(() => d165.offData(event, callback));
+    }
+    createViewerSocketUser(b165) {
+        const c165 = new PLVSocketUserSend();
+        c165.nick = b165.viewerName.value;
+        c165.pic = b165.viewerAvatar;
+        c165.userType = b165.viewerType;
+        c165.userId = b165.viewerId;
+        return c165;
+    }
+    isChannelReachLinkMicLimit() {
+        const w164 = this.repo.mediator.channelData?.liveDetail?.linkMicLimit;
+        if (w164 === undefined) {
+            PLVLogger.warn(TAG, "channel linkmic limit is undefined, treat as reach limit.");
+            return true;
+        }
+        const x164 = this.repo.mediator.channelViewers.value ?? [];
+        const y164 = x164.filter(a165 => a165.linkmicState.value === PLVLinkMicState.Joined).length;
+        if (y164 >= w164) {
+            PLVLogger.warn(TAG, `channel reach linkmic limit, current join ${y164}, limit ${w164}`);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+}
+class SocketDisposable extends PLVDisposable {
+    constructor(v164) {
+        super();
+        this.onDispose = v164;
+    }
+    dispose() {
+        super.dispose();
+        this.onDispose?.();
+    }
+}
+function disposable(u164) {
+    return new SocketDisposable(u164);
+}

package/src/main/ets/modules/member/viewmodel/usecase/roles/teacher/MemberTeacherUpdateViewerUseCase.d.ets

@@ -0,0 +1,23 @@
+import { PLVLinkMicChannelStatus } from '../../../../../linkmic/model/vo/PLVLinkMicChannelStatus';
+import { PLVLinkMicSocketJoinAnswerRecv, PLVLinkMicSocketJoinLeaveRecv, PLVLinkMicSocketJoinRequestRecv, PLVLinkMicSocketJoinSuccessRecv } from '../../../../../linkmic/model/vo/PLVLinkMicSocketEvent';
+import { PLVMemberRepo } from '../../../../model/PLVMemberRepo';
+import { PLVMemberSocketLoginRecv, PLVMemberSocketLogoutRecv } from '../../../../model/vo/PLVMemberSocketEvent';
+import { IMemberUpdateViewerUseCase, MemberUpdateChannelViewersPayload } from '../base/IMemberUpdateViewerUseCase';
+export declare class MemberTeacherUpdateViewerUseCase implements IMemberUpdateViewerUseCase {
+    private readonly repo;
+    private updateChannelViewerTask;
+    constructor(y171: PLVMemberRepo);
+    startUpdateChannelViewersInterval(): void;
+    stopUpdateChannelViewersInterval(): void;
+    handleChannelViewersUpdate(payload: MemberUpdateChannelViewersPayload): void;
+    sortChannelViewers(): void;
+    updateByLinkMicStatusList(l169: PLVLinkMicChannelStatus): void;
+    onSocketUserLogin(e169: PLVMemberSocketLoginRecv): void;
+    onSocketUserLogout(a169: PLVMemberSocketLogoutRecv): void;
+    onSocketJoinRequest(v168: PLVLinkMicSocketJoinRequestRecv): void;
+    onSocketJoinAnswer(s168: PLVLinkMicSocketJoinAnswerRecv): void;
+    onSocketJoinSuccess(n168: PLVLinkMicSocketJoinSuccessRecv): void;
+    onSocketJoinLeave(k168: PLVLinkMicSocketJoinLeaveRecv): void;
+    private updateServerListViewer;
+    private getViewerSortOrder;
+}