@polyvharmony/live-scenes-sdk 1.3.1 → 1.3.2-rc.1

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

@@ -11,27 +11,27 @@ import { PLVSocketUserSend } from '../../../../../socket/model/PLVSocketUserBean
 import { PLVMemberSocketSetNickRecv } from '../../../../../member/model/vo/PLVMemberSocketEvent';
 const TAG = "PLVLinkMicManager";
 export class LinkMicViewerHandleStateUseCase {
-    constructor(p51, q51, r51, s51) {
+    constructor(d52, e52, f52, g52) {
         this.taskUpdateMicSetting = undefined;
         this.disposables = [];
         this.observers = [];
-        this.repo = p51;
-        this.handleQueueOrderUseCase = q51;
-        this.handleRTCUseCase = r51;
-        this.updateChannelViewerUseCase = s51;
+        this.repo = d52;
+        this.handleQueueOrderUseCase = e52;
+        this.handleRTCUseCase = f52;
+        this.updateChannelViewerUseCase = g52;
     }
     init() {
-        this.disposables.push(this.observeSocketEvent(PLVSocketOnEvent.MESSAGE, (n51, o51) => this.onSocketMessage(n51, o51)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_REQUEST, (m51) => this.onSocketJoinRequest(m51)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_RESPONSE, (l51) => this.onSocketJoinResponse(l51)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_SUCCESS, (k51) => this.onSocketJoinSuccess(k51)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_LEAVE, (j51) => this.onSocketJoinLeave(j51)), this.observeSocketEvent(PLVSocketOnEvent.SWITCH_VIEW, (i51) => this.onSocketSwitchView(i51)));
-        this.repo.mediator.rtcEvent.observe((h51) => this.onRTCEvent(h51))
+        this.disposables.push(this.observeSocketEvent(PLVSocketOnEvent.MESSAGE, (b52, c52) => this.onSocketMessage(b52, c52)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_REQUEST, (a52) => this.onSocketJoinRequest(a52)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_RESPONSE, (z51) => this.onSocketJoinResponse(z51)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_SUCCESS, (y51) => this.onSocketJoinSuccess(y51)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_LEAVE, (x51) => this.onSocketJoinLeave(x51)), this.observeSocketEvent(PLVSocketOnEvent.SWITCH_VIEW, (w51) => this.onSocketSwitchView(w51)));
+        this.repo.mediator.rtcEvent.observe((v51) => this.onRTCEvent(v51))
             .pushTo(this.observers);
-        this.repo.mediator.viewerLeaveLinkMicEvent.observe(g51 => this.onViewerLeaveLinkMic(g51))
+        this.repo.mediator.viewerLeaveLinkMicEvent.observe(u51 => this.onViewerLeaveLinkMic(u51))
             .pushTo(this.observers);
         this.taskUpdateMicSetting = new PLVScheduledTask(() => this.updateMicSetting(), seconds(1).toMillis(), seconds(10).toMillis());
         this.taskUpdateMicSetting.start();
     }
     async requestJoinLinkMic() {
-        const e51 = this.repo.mediator.linkmicState.value;
-        if (e51 === PLVLinkMicState.Inviting) {
+        const s51 = this.repo.mediator.linkmicState.value;
+        if (s51 === PLVLinkMicState.Inviting) {
             this.acceptInvitation();
             return;
         }
@@ -40,10 +40,10 @@ export class LinkMicViewerHandleStateUseCase {
             this.repo.mediator.reportError(PLVLinkMicErrorEvent.REACH_LINKMIC_LIMIT, "requestJoinLinkMic channel reach linkmic limit");
             return;
         }
-        const f51 = new PLVLinkMicSocketJoinRequestSend();
-        f51.user = this.createSocketUser();
-        f51.roomId = this.repo.mediator.channelData?.loginChannelId;
-        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_REQUEST, encodeToJson(f51), () => {
+        const t51 = new PLVLinkMicSocketJoinRequestSend();
+        t51.user = this.createSocketUser();
+        t51.roomId = this.repo.mediator.channelData?.loginChannelId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_REQUEST, encodeToJson(t51), () => {
             this.repo.mediator.linkmicState.setValue(PLVLinkMicState.Requesting);
         });
     }
@@ -53,35 +53,35 @@ export class LinkMicViewerHandleStateUseCase {
             this.repo.mediator.reportError(PLVLinkMicErrorEvent.REACH_LINKMIC_LIMIT, "acceptInvitation channel reach linkmic limit");
             return;
         }
-        const c51 = new PLVLinkMicSocketJoinAnswerSend();
-        c51.user = this.createSocketUser();
-        c51.roomId = this.repo.mediator.channelData?.loginChannelId;
-        c51.status = 1;
-        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_ANSWER, encodeToJson(c51), () => {
-            const d51 = this.repo.mediator.linkmicState.value;
-            if (d51 === PLVLinkMicState.Inviting) {
+        const q51 = new PLVLinkMicSocketJoinAnswerSend();
+        q51.user = this.createSocketUser();
+        q51.roomId = this.repo.mediator.channelData?.loginChannelId;
+        q51.status = 1;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_ANSWER, encodeToJson(q51), () => {
+            const r51 = this.repo.mediator.linkmicState.value;
+            if (r51 === PLVLinkMicState.Inviting) {
                 this.repo.mediator.linkmicState.setValue(PLVLinkMicState.WaitingResponse);
             }
         });
     }
     refuseInvitation() {
-        const b51 = new PLVLinkMicSocketJoinAnswerSend();
-        b51.user = this.createSocketUser();
-        b51.roomId = this.repo.mediator.channelData?.loginChannelId;
-        b51.status = 0;
-        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_ANSWER, encodeToJson(b51));
+        const p51 = new PLVLinkMicSocketJoinAnswerSend();
+        p51.user = this.createSocketUser();
+        p51.roomId = this.repo.mediator.channelData?.loginChannelId;
+        p51.status = 0;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_ANSWER, encodeToJson(p51));
         this.repo.mediator.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
         this.handleRTCUseCase.leaveChannel();
     }
     leaveLinkMic() {
-        const z50 = this.repo.mediator.linkmicState.value;
-        if (z50 === undefined || ![PLVLinkMicState.Requesting, PLVLinkMicState.Joined].includes(z50)) {
+        const n51 = this.repo.mediator.linkmicState.value;
+        if (n51 === undefined || ![PLVLinkMicState.Requesting, PLVLinkMicState.Joined].includes(n51)) {
             return;
         }
-        const a51 = new PLVLinkMicSocketJoinLeaveSend();
-        a51.user = this.createSocketUser();
-        a51.roomId = this.repo.mediator.channelData?.loginChannelId;
-        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_LEAVE, encodeToJson(a51));
+        const o51 = new PLVLinkMicSocketJoinLeaveSend();
+        o51.user = this.createSocketUser();
+        o51.roomId = this.repo.mediator.channelData?.loginChannelId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_LEAVE, encodeToJson(o51));
         this.repo.mediator.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
         this.repo.mediator.channelLinkMicViewers.setValue([]);
         this.repo.mediator.channelMainViewLinkMicId.setValue(undefined);
@@ -91,7 +91,7 @@ export class LinkMicViewerHandleStateUseCase {
     }
     onLiveStreamStart() {
     }
-    async setLinkMicMode(y50) {
+    async setLinkMicMode(m51) {
         return false;
     }
     async openLinkMic() {
@@ -100,75 +100,75 @@ export class LinkMicViewerHandleStateUseCase {
     async closeLinkMic() {
         return false;
     }
-    acceptViewerLinkMicRequest(x50) {
+    acceptViewerLinkMicRequest(l51) {
     }
-    inviteViewerLinkMic(v50, w50) {
+    inviteViewerLinkMic(j51, k51) {
     }
-    hangupViewerLinkMic(u50) {
+    hangupViewerLinkMic(i51) {
     }
     hangupAllViewersLinkMic() {
     }
-    setViewerEnableCamera(s50, t50) {
+    setViewerEnableCamera(g51, h51) {
     }
-    setViewerEnableMicrophone(q50, r50) {
+    setViewerEnableMicrophone(e51, f51) {
     }
-    grantSpeaker(p50) {
+    grantSpeaker(d51) {
     }
-    revokeSpeaker(o50) {
+    revokeSpeaker(c51) {
     }
-    setMainView(n50) {
+    setMainView(b51) {
     }
     onLiveStreamStop() {
     }
     onStreamerStop() {
     }
     updateInvitationExpireTime() {
-        const f50 = new PLVLinkMicSocketJoinAnswerTTLSend();
-        f50.userId = this.repo.mediator.channelData?.viewerId;
-        f50.roomId = this.repo.mediator.channelData?.loginChannelId;
-        f50.sessionId = this.repo.mediator.channelData?.sessionId;
-        const g50 = Date.now();
-        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_ANSWER_TTL, encodeToJson(f50), (h50) => {
-            const i50 = decodeFromJson(h50, PLVLinkMicSocketJoinAnswerTTLAck).message?.[0] ?? 0;
-            const j50 = g50 + seconds(i50).toMillis();
-            this.repo.mediator.invitationExpireTimestamp.setValue(j50);
-            const k50 = j50 - Date.now();
+        const t50 = new PLVLinkMicSocketJoinAnswerTTLSend();
+        t50.userId = this.repo.mediator.channelData?.viewerId;
+        t50.roomId = this.repo.mediator.channelData?.loginChannelId;
+        t50.sessionId = this.repo.mediator.channelData?.sessionId;
+        const u50 = Date.now();
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_ANSWER_TTL, encodeToJson(t50), (v50) => {
+            const w50 = decodeFromJson(v50, PLVLinkMicSocketJoinAnswerTTLAck).message?.[0] ?? 0;
+            const x50 = u50 + seconds(w50).toMillis();
+            this.repo.mediator.invitationExpireTimestamp.setValue(x50);
+            const y50 = x50 - Date.now();
             setTimeout(() => {
-                const l50 = this.repo.mediator.invitationExpireTimestamp.value ?? 0;
-                const m50 = this.repo.mediator.linkmicState.value;
-                if (m50 === PLVLinkMicState.Inviting && Date.now() >= l50) {
+                const z50 = this.repo.mediator.invitationExpireTimestamp.value ?? 0;
+                const a51 = this.repo.mediator.linkmicState.value;
+                if (a51 === PLVLinkMicState.Inviting && Date.now() >= z50) {
                     this.refuseInvitation();
                 }
-            }, k50);
+            }, y50);
         });
     }
-    onSocketMessage(d50, e50) {
-        switch (e50) {
+    onSocketMessage(r50, s50) {
+        switch (s50) {
             case PLVSocketMessageEvent.OPEN_MICROPHONE:
-                return this.onSocketOpenMicrophone(d50);
+                return this.onSocketOpenMicrophone(r50);
             case PLVSocketMessageEvent.MUTE_USER_MICRO:
-                return this.onSocketMuteUserMicro(d50);
+                return this.onSocketMuteUserMicro(r50);
             case PLVSocketMessageEvent.SET_NICK:
-                return this.onSocketUserSetNick(d50);
+                return this.onSocketUserSetNick(r50);
             default:
         }
     }
-    onSocketOpenMicrophone(z49) {
-        const a50 = decodeFromJson(z49, PLVLinkMicSocketOpenMicrophoneRecv);
-        const b50 = a50.userId !== undefined;
-        if (a50.status === 'open') {
-            if (!b50) {
+    onSocketOpenMicrophone(n50) {
+        const o50 = decodeFromJson(n50, PLVLinkMicSocketOpenMicrophoneRecv);
+        const p50 = o50.userId !== undefined;
+        if (o50.status === 'open') {
+            if (!p50) {
                 this.repo.mediator.channelAllowLinkMic.setValue(true);
                 this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(true);
-                this.updateLinkMicMode(a50.type);
+                this.updateLinkMicMode(o50.type);
             }
         }
-        else if (a50.status === 'close') {
-            if (!b50) {
+        else if (o50.status === 'close') {
+            if (!p50) {
                 if (this.repo.mediator.isLinkMicStrategyV2.value === true) {
                     this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(false);
-                    const c50 = this.repo.mediator.linkmicState.value === PLVLinkMicState.Requesting;
-                    if (c50) {
+                    const q50 = this.repo.mediator.linkmicState.value === PLVLinkMicState.Requesting;
+                    if (q50) {
                         this.leaveLinkMic();
                     }
                 }
@@ -178,55 +178,55 @@ export class LinkMicViewerHandleStateUseCase {
                     this.leaveLinkMic();
                 }
             }
-            if (b50 && this.repo.mediator.isMySocketLinkMicId(a50.userId)) {
+            if (p50 && this.repo.mediator.isMySocketLinkMicId(o50.userId)) {
                 this.repo.mediator.teacherHangUpLinkMicEvent.setValue(Date.now());
                 this.leaveLinkMic();
             }
         }
     }
-    onSocketMuteUserMicro(x49) {
-        const y49 = decodeFromJson(x49, PLVLinkMicSocketMuteUserMicroRecv);
-        if (y49.type === 'audio') {
-            if (y49.mute === true) {
+    onSocketMuteUserMicro(l50) {
+        const m50 = decodeFromJson(l50, PLVLinkMicSocketMuteUserMicroRecv);
+        if (m50.type === 'audio') {
+            if (m50.mute === true) {
                 this.handleRTCUseCase.enableMicrophone(false);
             }
-            if (y49.mute === false) {
+            if (m50.mute === false) {
                 this.handleRTCUseCase.enableMicrophone(true);
             }
         }
-        if (y49.type === 'video') {
-            if (y49.mute === true) {
+        if (m50.type === 'video') {
+            if (m50.mute === true) {
                 this.handleRTCUseCase.enableCamera(false);
             }
-            if (y49.mute === false) {
+            if (m50.mute === false) {
                 this.handleRTCUseCase.enableCamera(true);
             }
         }
     }
-    onSocketUserSetNick(t49) {
-        const u49 = decodeFromJson(t49, PLVMemberSocketSetNickRecv);
-        const v49 = u49.userId;
-        const w49 = this.repo.mediator.findViewerByViewerId(v49);
-        if (w49 !== undefined) {
-            w49.viewerName.setValue(u49.nick);
+    onSocketUserSetNick(h50) {
+        const i50 = decodeFromJson(h50, PLVMemberSocketSetNickRecv);
+        const j50 = i50.userId;
+        const k50 = this.repo.mediator.findViewerByViewerId(j50);
+        if (k50 !== undefined) {
+            k50.viewerName.setValue(i50.nick);
         }
     }
-    onSocketJoinRequest(r49) {
-        const s49 = decodeFromJson(r49, PLVLinkMicSocketJoinRequestRecv);
-        this.handleQueueOrderUseCase.onEventJoinRequest(s49);
+    onSocketJoinRequest(f50) {
+        const g50 = decodeFromJson(f50, PLVLinkMicSocketJoinRequestRecv);
+        this.handleQueueOrderUseCase.onEventJoinRequest(g50);
     }
-    onSocketJoinResponse(o49) {
-        const p49 = decodeFromJson(o49, PLVLinkMicSocketJoinResponseRecv);
-        if (!this.repo.mediator.isMySocketLinkMicId(p49.user?.userId)) {
+    onSocketJoinResponse(c50) {
+        const d50 = decodeFromJson(c50, PLVLinkMicSocketJoinResponseRecv);
+        if (!this.repo.mediator.isMySocketLinkMicId(d50.user?.userId)) {
             return;
         }
-        this.updateLinkMicMode(p49.type);
-        const q49 = this.repo.mediator.linkmicState.value;
-        if (p49.isNeedAnswer()) {
-            if (q49 === PLVLinkMicState.Requesting) {
+        this.updateLinkMicMode(d50.type);
+        const e50 = this.repo.mediator.linkmicState.value;
+        if (d50.isNeedAnswer()) {
+            if (e50 === PLVLinkMicState.Requesting) {
                 this.acceptInvitation();
             }
-            else if (q49 === PLVLinkMicState.NoLinkMic) {
+            else if (e50 === PLVLinkMicState.NoLinkMic) {
                 this.repo.mediator.invitationExpireTimestamp.setValue(Date.now() + seconds(30).toMillis());
                 this.repo.mediator.linkmicState.setValue(PLVLinkMicState.Inviting);
                 this.updateInvitationExpireTime();
@@ -237,40 +237,40 @@ export class LinkMicViewerHandleStateUseCase {
             this.handleRTCUseCase.joinChannel();
         }
     }
-    onSocketJoinSuccess(m49) {
-        const n49 = decodeFromJson(m49, PLVLinkMicSocketJoinSuccessRecv);
-        this.handleQueueOrderUseCase.onEventJoinSuccess(n49);
-        this.updateChannelViewerUseCase.onEventJoinSuccess(n49);
-        if (this.repo.mediator.isMySocketLinkMicId(n49.user?.userId)) {
+    onSocketJoinSuccess(a50) {
+        const b50 = decodeFromJson(a50, PLVLinkMicSocketJoinSuccessRecv);
+        this.handleQueueOrderUseCase.onEventJoinSuccess(b50);
+        this.updateChannelViewerUseCase.onEventJoinSuccess(b50);
+        if (this.repo.mediator.isMySocketLinkMicId(b50.user?.userId)) {
             this.updateChannelViewerUseCase.startUpdateChannelLinkMicViewersInterval();
         }
     }
-    onSocketJoinLeave(k49) {
-        const l49 = decodeFromJson(k49, PLVLinkMicSocketJoinLeaveRecv);
-        this.handleQueueOrderUseCase.onEventJoinLeave(l49);
-        this.updateChannelViewerUseCase.onEventJoinLeave(l49);
-        if (this.repo.mediator.isMySocketLinkMicId(l49.user?.userId)) {
+    onSocketJoinLeave(y49) {
+        const z49 = decodeFromJson(y49, PLVLinkMicSocketJoinLeaveRecv);
+        this.handleQueueOrderUseCase.onEventJoinLeave(z49);
+        this.updateChannelViewerUseCase.onEventJoinLeave(z49);
+        if (this.repo.mediator.isMySocketLinkMicId(z49.user?.userId)) {
             this.updateChannelViewerUseCase.stopUpdateChannelLinkMicViewersInterval();
         }
     }
-    onSocketSwitchView(i49) {
-        const j49 = decodeFromJson(i49, PLVLinkMicSocketSwitchViewRecv);
-        if (isNullOrUndefined(j49.userId)) {
+    onSocketSwitchView(w49) {
+        const x49 = decodeFromJson(w49, PLVLinkMicSocketSwitchViewRecv);
+        if (isNullOrUndefined(x49.userId)) {
             return;
         }
-        this.repo.mediator.channelMainViewLinkMicId.setValue(j49.userId);
-        this.updateChannelViewerUseCase.onEventSwitchView(j49);
+        this.repo.mediator.channelMainViewLinkMicId.setValue(x49.userId);
+        this.updateChannelViewerUseCase.onEventSwitchView(x49);
     }
     updateMicSetting() {
-        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MIC, encodeToJson(new PLVLinkMicSocketMicSettingSend()), (e49) => {
-            const f49 = decodeFromJson(e49, PLVLinkMicSocketMicSettingAck).message?.[0];
-            const g49 = f49?.data?.status;
-            const h49 = f49?.data?.type;
-            if (g49 === 'open') {
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MIC, encodeToJson(new PLVLinkMicSocketMicSettingSend()), (s49) => {
+            const t49 = decodeFromJson(s49, PLVLinkMicSocketMicSettingAck).message?.[0];
+            const u49 = t49?.data?.status;
+            const v49 = t49?.data?.type;
+            if (u49 === 'open') {
                 this.repo.mediator.channelAllowLinkMic.setValue(true);
                 this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(true);
             }
-            else if (g49 === 'close') {
+            else if (u49 === 'close') {
                 if (this.repo.mediator.isLinkMicStrategyV2.value === true) {
                     this.repo.mediator.channelAllowLinkMic.setValue(true);
                     this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(false);
@@ -280,80 +280,80 @@ export class LinkMicViewerHandleStateUseCase {
                     this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(false);
                 }
             }
-            this.updateLinkMicMode(h49);
+            this.updateLinkMicMode(v49);
         });
     }
-    onRTCEvent(d49) {
-        if (d49 instanceof PLVLinkMicRTCJoinSuccess) {
-            this.onRTCJoinSuccess(d49);
+    onRTCEvent(r49) {
+        if (r49 instanceof PLVLinkMicRTCJoinSuccess) {
+            this.onRTCJoinSuccess(r49);
         }
-        else if (d49 instanceof PLVLinkMicRTCKickOut) {
-            this.onRTCKickOut(d49);
+        else if (r49 instanceof PLVLinkMicRTCKickOut) {
+            this.onRTCKickOut(r49);
         }
     }
-    onRTCJoinSuccess(b49) {
+    onRTCJoinSuccess(p49) {
         this.repo.sendLinkMicIdRelation();
-        const c49 = new PLVLinkMicSocketJoinSuccessSend();
-        c49.user = this.createSocketUser();
-        c49.roomId = this.repo.mediator.channelData?.loginChannelId;
-        c49.sessionId = this.repo.mediator.channelData?.sessionId;
-        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_SUCCESS, encodeToJson(c49));
+        const q49 = new PLVLinkMicSocketJoinSuccessSend();
+        q49.user = this.createSocketUser();
+        q49.roomId = this.repo.mediator.channelData?.loginChannelId;
+        q49.sessionId = this.repo.mediator.channelData?.sessionId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_SUCCESS, encodeToJson(q49));
     }
-    onRTCKickOut(a49) {
+    onRTCKickOut(o49) {
         this.leaveLinkMic();
         this.repo.mediator.teacherHangUpLinkMicEvent.setValue(Date.now());
     }
-    onViewerLeaveLinkMic(w48) {
-        const x48 = w48.find(z48 => z48.linkmicId === this.repo.mediator.linkmicId) !== undefined;
-        const y48 = this.repo.mediator.linkmicState.value === PLVLinkMicState.Joined;
-        if (x48 && y48) {
+    onViewerLeaveLinkMic(k49) {
+        const l49 = k49.find(n49 => n49.linkmicId === this.repo.mediator.linkmicId) !== undefined;
+        const m49 = this.repo.mediator.linkmicState.value === PLVLinkMicState.Joined;
+        if (l49 && m49) {
             this.leaveLinkMic();
         }
     }
     onDestroy() {
         this.taskUpdateMicSetting?.cancel();
         this.taskUpdateMicSetting = undefined;
-        this.disposables.forEach((v48) => {
-            v48.dispose();
+        this.disposables.forEach((j49) => {
+            j49.dispose();
         });
         this.disposables = [];
         MutableObserver.disposeAll(this.observers);
         this.observers = [];
     }
-    observeSocketEvent(s48, t48) {
-        const u48 = requireNotNull(this.repo.mediator.socketMediator);
-        u48.onData(s48, t48);
-        return disposable(() => u48.offData(s48, t48));
+    observeSocketEvent(g49, h49) {
+        const i49 = requireNotNull(this.repo.mediator.socketMediator);
+        i49.onData(g49, h49);
+        return disposable(() => i49.offData(g49, h49));
     }
     createSocketUser() {
-        const r48 = new PLVSocketUserSend();
-        r48.nick = this.repo.mediator.channelData?.viewerName;
-        r48.pic = this.repo.mediator.channelData?.viewerAvatar;
-        r48.userType = this.repo.mediator.channelData?.viewerType;
-        r48.userId = this.repo.mediator.linkmicId;
-        return r48;
-    }
-    updateLinkMicMode(q48) {
-        if (q48 === PLVLinkMicMode.AUDIO || q48 === PLVLinkMicMode.VIDEO) {
-            this.repo.mediator.channelLinkMicMode.setValue(q48);
+        const f49 = new PLVSocketUserSend();
+        f49.nick = this.repo.mediator.channelData?.viewerName;
+        f49.pic = this.repo.mediator.channelData?.viewerAvatar;
+        f49.userType = this.repo.mediator.channelData?.viewerType;
+        f49.userId = this.repo.mediator.linkmicId;
+        return f49;
+    }
+    updateLinkMicMode(e49) {
+        if (e49 === PLVLinkMicMode.AUDIO || e49 === PLVLinkMicMode.VIDEO) {
+            this.repo.mediator.channelLinkMicMode.setValue(e49);
         }
     }
     async isChannelReachLinkMicLimit() {
-        const m48 = this.repo.mediator.channelData?.liveDetail?.linkMicLimit;
-        if (m48 === undefined) {
+        const a49 = this.repo.mediator.channelData?.liveDetail?.linkMicLimit;
+        if (a49 === undefined) {
             PLVLogger.warn(TAG, "channel linkmic limit is undefined, treat as reach limit.");
             return true;
         }
-        const n48 = await runCatching(this.repo.getChannelLinkMicStatus());
-        if (n48.success === false) {
-            PLVLogger.warn(TAG, `channel linkmic status response fail: ${n48.error.message}`);
+        const b49 = await runCatching(this.repo.getChannelLinkMicStatus());
+        if (b49.success === false) {
+            PLVLogger.warn(TAG, `channel linkmic status response fail: ${b49.error.message}`);
             return true;
         }
-        const o48 = n48.data.joinList?.filter(p48 => {
-            p48.userType === PLVUserType.USERTYPE_TEACHER || p48.classStatus?.voice === 1;
+        const c49 = b49.data.joinList?.filter(d49 => {
+            d49.userType === PLVUserType.USERTYPE_TEACHER || d49.classStatus?.voice === 1;
         })?.length ?? 0;
-        if (o48 >= m48 + 1) {
-            PLVLogger.warn(TAG, `channel reach linkmic limit, current join ${o48}, limit ${m48}`);
+        if (c49 >= a49 + 1) {
+            PLVLogger.warn(TAG, `channel reach linkmic limit, current join ${c49}, limit ${a49}`);
             return true;
         }
         else {
@@ -362,15 +362,15 @@ export class LinkMicViewerHandleStateUseCase {
     }
 }
 class SocketDisposable extends PLVDisposable {
-    constructor(l48) {
+    constructor(z48) {
         super();
-        this.onDispose = l48;
+        this.onDispose = z48;
     }
     dispose() {
         super.dispose();
         this.onDispose?.();
     }
 }
-function disposable(k48) {
-    return new SocketDisposable(k48);
+function disposable(y48) {
+    return new SocketDisposable(y48);
 }

package/src/main/ets/modules/log/elog/PLVELogSender.d.ets

@@ -1,12 +1,12 @@
 import { PLVBaseModule } from '../../../common/PLVBaseModule';
 import { PLVChannelData } from '../../../common/PLVChannelData';
 import { PLVELogDataBean, PLVELogPartData } from './model/PLVELogDataBean';
-export declare function eLogSender(h52: PLVChannelData): PLVELogSender;
+export declare function eLogSender(v52: PLVChannelData): PLVELogSender;
 export declare class PLVELogSender extends PLVBaseModule {
     static readonly LOG_ARR: PLVELogDataBean[];
     static batchIntervalId?: number;
-    constructor(g52: PLVChannelData);
-    once(f52: PLVELogPartData): void;
-    batch(d52: PLVELogPartData): void;
+    constructor(u52: PLVChannelData);
+    once(t52: PLVELogPartData): void;
+    batch(r52: PLVELogPartData): void;
     private reportLiveELog;
 }

package/src/main/ets/modules/log/elog/PLVELogSender.js

@@ -5,12 +5,12 @@ import { toELogData } from './model/PLVELogDataBean';
 const TAG = '[PLVELogSender]';
 const BATCH_INTERVAL = 1000 * 60;
 const BATCH_LENGTH = 20;
-export function eLogSender(h52) {
-    return new PLVELogSender(h52);
+export function eLogSender(v52) {
+    return new PLVELogSender(v52);
 }
 export class PLVELogSender extends PLVBaseModule {
-    constructor(g52) {
-        super(g52);
+    constructor(u52) {
+        super(u52);
         if (PLVELogSender.batchIntervalId == undefined) {
             PLVELogSender.batchIntervalId = setInterval(() => {
                 if (PLVELogSender.LOG_ARR.length > 0) {
@@ -20,25 +20,25 @@ export class PLVELogSender extends PLVBaseModule {
             }, BATCH_INTERVAL);
         }
     }
-    once(f52) {
-        this.reportLiveELog([toELogData(this.channelData, f52)]);
+    once(t52) {
+        this.reportLiveELog([toELogData(this.channelData, t52)]);
     }
-    batch(d52) {
-        const e52 = toELogData(this.channelData, d52);
-        PLVELogSender.LOG_ARR.push(e52);
-        PLVLogger.info(TAG, `batch log: ${PLVJSONUtils.safeStringify(e52)}`);
+    batch(r52) {
+        const s52 = toELogData(this.channelData, r52);
+        PLVELogSender.LOG_ARR.push(s52);
+        PLVLogger.info(TAG, `batch log: ${PLVJSONUtils.safeStringify(s52)}`);
         if (PLVELogSender.LOG_ARR.length >= BATCH_LENGTH) {
             this.reportLiveELog(PLVELogSender.LOG_ARR);
             PLVELogSender.LOG_ARR.length = 0;
         }
     }
-    reportLiveELog(y51) {
-        return PLVUtils.safePromise(async (z51, a52) => {
-            const b52 = PLVJSONUtils.safeStringify(y51);
-            PLVLogger.info(TAG, `reportLiveELog: ${b52}`);
-            await eLogPlvNetApi(this.channelData).reportLiveELog(this.channelData.loginChannelId, b52)
-                .catch((c52) => {
-                return Promise.reject(c52.log(TAG, 'reportLiveELog error'));
+    reportLiveELog(m52) {
+        return PLVUtils.safePromise(async (n52, o52) => {
+            const p52 = PLVJSONUtils.safeStringify(m52);
+            PLVLogger.info(TAG, `reportLiveELog: ${p52}`);
+            await eLogPlvNetApi(this.channelData).reportLiveELog(this.channelData.loginChannelId, p52)
+                .catch((q52) => {
+                return Promise.reject(q52.log(TAG, 'reportLiveELog error'));
             });
             PLVLogger.info(TAG, 'reportLiveELog success');
         });

package/src/main/ets/modules/log/elog/model/PLVELogDataBean.d.ets

@@ -28,4 +28,4 @@ export declare class PLVELogPartData {
     module: string;
     information?: string;
 }
-export declare function toELogData(t51: PLVChannelData, u51: PLVELogPartData): PLVELogDataBean;
+export declare function toELogData(h52: PLVChannelData, i52: PLVELogPartData): PLVELogDataBean;

package/src/main/ets/modules/log/elog/model/PLVELogDataBean.js

@@ -24,17 +24,17 @@ export class PLVELogPartData {
         this.module = 'default_module';
     }
 }
-export function toELogData(t51, u51) {
-    const v51 = new PLVELogDataBean();
-    v51.errorCode = u51.errorCode || 0;
-    v51.event = u51.event || 'default_event';
-    v51.module = u51.module || 'default_module';
-    v51.logFile = {
-        information: u51.information
+export function toELogData(h52, i52) {
+    const j52 = new PLVELogDataBean();
+    j52.errorCode = i52.errorCode || 0;
+    j52.event = i52.event || 'default_event';
+    j52.module = i52.module || 'default_module';
+    j52.logFile = {
+        information: i52.information
     };
-    v51.appId = t51.appId;
-    v51.channelId2 = t51.loginChannelId;
-    v51.userId2 = t51.userId;
-    v51.viewerId = t51.viewerId;
-    return v51;
+    j52.appId = h52.appId;
+    j52.channelId2 = h52.loginChannelId;
+    j52.userId2 = h52.userId;
+    j52.viewerId = h52.viewerId;
+    return j52;
 }