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

package/src/main/ets/modules/linkmic/viewmodel/PLVLinkMicViewModel.d.ets

@@ -5,29 +5,29 @@ import { PLVLinkMicUseCases } from './usecase/PLVLinkMicUseCases';
 export declare class PLVLinkMicViewModel {
     private readonly repo;
     private readonly useCases;
-    constructor(p31: PLVLinkMicRepo, q31: PLVLinkMicUseCases);
+    constructor(d32: PLVLinkMicRepo, e32: PLVLinkMicUseCases);
     init(): Promise<void>;
     requestLinkMic(): void;
     acceptLinkMicInvitation(): void;
     refuseLinkMicInvitation(): void;
     leaveLinkMic(): void;
-    setLinkMicMode(o31: PLVLinkMicMode): Promise<boolean>;
+    setLinkMicMode(c32: PLVLinkMicMode): Promise<boolean>;
     openLinkMic(): Promise<boolean>;
     closeLinkMic(): Promise<boolean>;
-    acceptViewerLinkMicRequest(n31: string): void;
-    inviteViewerLinkMic(l31: string, m31: boolean): void;
-    hangupViewerLinkMic(k31: string): void;
+    acceptViewerLinkMicRequest(b32: string): void;
+    inviteViewerLinkMic(z31: string, a32: boolean): void;
+    hangupViewerLinkMic(y31: string): void;
     hangupAllViewersLinkMic(): void;
-    setViewerEnableCamera(i31: string, j31: boolean): void;
-    setViewerEnableMicrophone(g31: string, h31: boolean): void;
-    grantSpeaker(f31: string): void;
-    revokeSpeaker(e31: string): void;
-    setMainView(d31: string): void;
-    enableCamera(c31: boolean): void;
-    enableMicrophone(b31: boolean): void;
+    setViewerEnableCamera(w31: string, x31: boolean): void;
+    setViewerEnableMicrophone(u31: string, v31: boolean): void;
+    grantSpeaker(t31: string): void;
+    revokeSpeaker(s31: string): void;
+    setMainView(r31: string): void;
+    enableCamera(q31: boolean): void;
+    enableMicrophone(p31: boolean): void;
     enableCameraMicrophoneToLastState(): void;
     switchCamera(): void;
-    setLocalMirror(a31: boolean): void;
-    setupVideoRender(z30: PLVLinkMicVideoRenderParam): void;
-    removeVideoRender(y30: PLVLinkMicVideoRenderParam): void;
+    setLocalMirror(o31: boolean): void;
+    setupVideoRender(n31: PLVLinkMicVideoRenderParam): void;
+    removeVideoRender(m31: PLVLinkMicVideoRenderParam): void;
 }

package/src/main/ets/modules/linkmic/viewmodel/PLVLinkMicViewModel.js

@@ -1,7 +1,7 @@
 export class PLVLinkMicViewModel {
-    constructor(p31, q31) {
-        this.repo = p31;
-        this.useCases = q31;
+    constructor(d32, e32) {
+        this.repo = d32;
+        this.useCases = e32;
         this.repo.mediator.onStreamerStart = () => {
             this.useCases.handleStateUseCase.onStreamerStart();
         };
@@ -14,17 +14,17 @@ export class PLVLinkMicViewModel {
         this.repo.mediator.onStreamerStop = () => {
             this.useCases.handleStateUseCase.onStreamerStop();
         };
-        this.repo.mediator.setBitRate = (u31) => {
-            this.useCases.encodeParamUseCase.setBitRate(u31);
+        this.repo.mediator.setBitRate = (i32) => {
+            this.useCases.encodeParamUseCase.setBitRate(i32);
         };
-        this.repo.mediator.setPushResolutionRatio = (t31) => {
-            this.useCases.encodeParamUseCase.setPushResolutionRatio(t31);
+        this.repo.mediator.setPushResolutionRatio = (h32) => {
+            this.useCases.encodeParamUseCase.setPushResolutionRatio(h32);
         };
-        this.repo.mediator.setPushOrientation = (s31) => {
-            this.useCases.encodeParamUseCase.setPushOrientation(s31);
+        this.repo.mediator.setPushOrientation = (g32) => {
+            this.useCases.encodeParamUseCase.setPushOrientation(g32);
         };
-        this.repo.mediator.setPushDowngradePreference = (r31) => {
-            this.useCases.encodeParamUseCase.setPushDowngradePreference(r31);
+        this.repo.mediator.setPushDowngradePreference = (f32) => {
+            this.useCases.encodeParamUseCase.setPushDowngradePreference(f32);
         };
     }
     async init() {
@@ -43,8 +43,8 @@ export class PLVLinkMicViewModel {
     leaveLinkMic() {
         this.useCases.handleStateUseCase.leaveLinkMic();
     }
-    async setLinkMicMode(o31) {
-        return this.useCases.handleStateUseCase.setLinkMicMode(o31);
+    async setLinkMicMode(c32) {
+        return this.useCases.handleStateUseCase.setLinkMicMode(c32);
     }
     async openLinkMic() {
         return this.useCases.handleStateUseCase.openLinkMic();
@@ -52,38 +52,38 @@ export class PLVLinkMicViewModel {
     async closeLinkMic() {
         return this.useCases.handleStateUseCase.closeLinkMic();
     }
-    acceptViewerLinkMicRequest(n31) {
-        this.useCases.handleStateUseCase.acceptViewerLinkMicRequest(n31);
+    acceptViewerLinkMicRequest(b32) {
+        this.useCases.handleStateUseCase.acceptViewerLinkMicRequest(b32);
     }
-    inviteViewerLinkMic(l31, m31) {
-        this.useCases.handleStateUseCase.inviteViewerLinkMic(l31, m31);
+    inviteViewerLinkMic(z31, a32) {
+        this.useCases.handleStateUseCase.inviteViewerLinkMic(z31, a32);
     }
-    hangupViewerLinkMic(k31) {
-        this.useCases.handleStateUseCase.hangupViewerLinkMic(k31);
+    hangupViewerLinkMic(y31) {
+        this.useCases.handleStateUseCase.hangupViewerLinkMic(y31);
     }
     hangupAllViewersLinkMic() {
         this.useCases.handleStateUseCase.hangupAllViewersLinkMic();
     }
-    setViewerEnableCamera(i31, j31) {
-        this.useCases.handleStateUseCase.setViewerEnableCamera(i31, j31);
+    setViewerEnableCamera(w31, x31) {
+        this.useCases.handleStateUseCase.setViewerEnableCamera(w31, x31);
     }
-    setViewerEnableMicrophone(g31, h31) {
-        this.useCases.handleStateUseCase.setViewerEnableMicrophone(g31, h31);
+    setViewerEnableMicrophone(u31, v31) {
+        this.useCases.handleStateUseCase.setViewerEnableMicrophone(u31, v31);
     }
-    grantSpeaker(f31) {
-        this.useCases.handleStateUseCase.grantSpeaker(f31);
+    grantSpeaker(t31) {
+        this.useCases.handleStateUseCase.grantSpeaker(t31);
     }
-    revokeSpeaker(e31) {
-        this.useCases.handleStateUseCase.revokeSpeaker(e31);
+    revokeSpeaker(s31) {
+        this.useCases.handleStateUseCase.revokeSpeaker(s31);
     }
-    setMainView(d31) {
-        this.useCases.handleStateUseCase.setMainView(d31);
+    setMainView(r31) {
+        this.useCases.handleStateUseCase.setMainView(r31);
     }
-    enableCamera(c31) {
-        this.useCases.handleRTCUseCase.enableCamera(c31);
+    enableCamera(q31) {
+        this.useCases.handleRTCUseCase.enableCamera(q31);
     }
-    enableMicrophone(b31) {
-        this.useCases.handleRTCUseCase.enableMicrophone(b31);
+    enableMicrophone(p31) {
+        this.useCases.handleRTCUseCase.enableMicrophone(p31);
     }
     enableCameraMicrophoneToLastState() {
         this.useCases.handleRTCUseCase.enableCameraMicrophoneToLastState();
@@ -91,14 +91,14 @@ export class PLVLinkMicViewModel {
     switchCamera() {
         this.useCases.handleRTCUseCase.switchCamera();
     }
-    setLocalMirror(a31) {
-        this.useCases.handleRTCUseCase.setLocalRenderMirror(a31);
-        this.useCases.encodeParamUseCase.setPushMirror(a31);
+    setLocalMirror(o31) {
+        this.useCases.handleRTCUseCase.setLocalRenderMirror(o31);
+        this.useCases.encodeParamUseCase.setPushMirror(o31);
     }
-    setupVideoRender(z30) {
-        this.useCases.handleRTCUseCase.setupVideoRender(z30);
+    setupVideoRender(n31) {
+        this.useCases.handleRTCUseCase.setupVideoRender(n31);
     }
-    removeVideoRender(y30) {
-        this.useCases.handleRTCUseCase.removeVideoRender(y30);
+    removeVideoRender(m31) {
+        this.useCases.handleRTCUseCase.removeVideoRender(m31);
     }
 }

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

@@ -6,11 +6,11 @@ import { PLVPushDowngradePreference, PLVPushOrientation } from '@polyvharmony/rt
 export declare class LinkMicEncodeParamUseCase implements ILinkMicEncodeParamUseCase {
     private readonly repo;
     private impl;
-    constructor(b32: PLVLinkMicRepo);
+    constructor(p32: PLVLinkMicRepo);
     init(): void;
-    setBitRate(z31: PLVLinkMicBitRate): void;
-    setPushResolutionRatio(y31: PLVLinkMicPushResolutionRatio): void;
-    setPushOrientation(x31: PLVPushOrientation): void;
-    setPushMirror(w31: boolean): void;
-    setPushDowngradePreference(v31: PLVPushDowngradePreference): void;
+    setBitRate(n32: PLVLinkMicBitRate): void;
+    setPushResolutionRatio(m32: PLVLinkMicPushResolutionRatio): void;
+    setPushOrientation(l32: PLVPushOrientation): void;
+    setPushMirror(k32: boolean): void;
+    setPushDowngradePreference(j32: PLVPushDowngradePreference): void;
 }

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

@@ -3,16 +3,16 @@ import { LinkMicViewerEncodeParamUseCase } from './roles/viewer/LinkMicViewerEnc
 import { LinkMicTeacherEncodeParamUseCase } from './roles/teacher/LinkMicTeacherEncodeParamUseCase';
 import { LinkMicGuestEncodeParamUseCase } from './roles/guest/LinkMicGuestEncodeParamUseCase';
 export class LinkMicEncodeParamUseCase {
-    constructor(b32) {
+    constructor(p32) {
         this.impl = undefined;
-        this.repo = b32;
+        this.repo = p32;
     }
     init() {
-        const a32 = this.repo.mediator.channelData?.viewerType;
-        if (a32 === PLVUserType.USERTYPE_TEACHER) {
+        const o32 = this.repo.mediator.channelData?.viewerType;
+        if (o32 === PLVUserType.USERTYPE_TEACHER) {
             this.impl = new LinkMicTeacherEncodeParamUseCase(this.repo);
         }
-        else if (a32 === PLVUserType.USERTYPE_GUEST) {
+        else if (o32 === PLVUserType.USERTYPE_GUEST) {
             this.impl = new LinkMicGuestEncodeParamUseCase(this.repo);
         }
         else {
@@ -20,19 +20,19 @@ export class LinkMicEncodeParamUseCase {
         }
         this.impl?.init();
     }
-    setBitRate(z31) {
-        this.impl?.setBitRate(z31);
+    setBitRate(n32) {
+        this.impl?.setBitRate(n32);
     }
-    setPushResolutionRatio(y31) {
-        this.impl?.setPushResolutionRatio(y31);
+    setPushResolutionRatio(m32) {
+        this.impl?.setPushResolutionRatio(m32);
     }
-    setPushOrientation(x31) {
-        this.impl?.setPushOrientation(x31);
+    setPushOrientation(l32) {
+        this.impl?.setPushOrientation(l32);
     }
-    setPushMirror(w31) {
-        this.impl?.setPushMirror(w31);
+    setPushMirror(k32) {
+        this.impl?.setPushMirror(k32);
     }
-    setPushDowngradePreference(v31) {
-        this.impl?.setPushDowngradePreference(v31);
+    setPushDowngradePreference(j32) {
+        this.impl?.setPushDowngradePreference(j32);
     }
 }

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

@@ -2,8 +2,8 @@ import { PLVLinkMicRepo } from '../../model/PLVLinkMicRepo';
 import { PLVLinkMicSocketJoinLeaveRecv, PLVLinkMicSocketJoinRequestRecv, PLVLinkMicSocketJoinSuccessRecv } from '../../model/vo/PLVLinkMicSocketEvent';
 export declare class LinkMicHandleQueueOrderUseCase {
     private readonly repo;
-    constructor(o32: PLVLinkMicRepo);
-    onEventJoinRequest(l32: PLVLinkMicSocketJoinRequestRecv): void;
-    onEventJoinSuccess(h32: PLVLinkMicSocketJoinSuccessRecv): void;
-    onEventJoinLeave(c32: PLVLinkMicSocketJoinLeaveRecv): void;
+    constructor(c33: PLVLinkMicRepo);
+    onEventJoinRequest(z32: PLVLinkMicSocketJoinRequestRecv): void;
+    onEventJoinSuccess(v32: PLVLinkMicSocketJoinSuccessRecv): void;
+    onEventJoinLeave(q32: PLVLinkMicSocketJoinLeaveRecv): void;
 }

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

@@ -1,47 +1,47 @@
 import { isNullOrUndefined } from '@polyvharmony/media-player-sdk';
 export class LinkMicHandleQueueOrderUseCase {
-    constructor(o32) {
-        this.repo = o32;
+    constructor(c33) {
+        this.repo = c33;
     }
-    onEventJoinRequest(l32) {
-        const m32 = l32.user?.userId;
-        const n32 = l32.requestIndex;
-        if (isNullOrUndefined(m32) || isNullOrUndefined(n32)) {
+    onEventJoinRequest(z32) {
+        const a33 = z32.user?.userId;
+        const b33 = z32.requestIndex;
+        if (isNullOrUndefined(a33) || isNullOrUndefined(b33)) {
             return;
         }
-        if (this.repo.mediator.isMySocketLinkMicId(m32)) {
-            this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(n32);
+        if (this.repo.mediator.isMySocketLinkMicId(a33)) {
+            this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(b33);
         }
     }
-    onEventJoinSuccess(h32) {
-        const i32 = h32.user?.userId;
-        const j32 = h32.requestIndex;
-        if (isNullOrUndefined(i32) || isNullOrUndefined(j32)) {
+    onEventJoinSuccess(v32) {
+        const w32 = v32.user?.userId;
+        const x32 = v32.requestIndex;
+        if (isNullOrUndefined(w32) || isNullOrUndefined(x32)) {
             return;
         }
-        if (this.repo.mediator.isMySocketLinkMicId(i32)) {
+        if (this.repo.mediator.isMySocketLinkMicId(w32)) {
             this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(-1);
             return;
         }
-        const k32 = this.repo.mediator.joinLinkMicWaitingQueueOrder.value ?? -1;
-        if (j32 >= 0 && k32 > 0 && k32 > j32) {
-            this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(k32 - 1);
+        const y32 = this.repo.mediator.joinLinkMicWaitingQueueOrder.value ?? -1;
+        if (x32 >= 0 && y32 > 0 && y32 > x32) {
+            this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(y32 - 1);
         }
     }
-    onEventJoinLeave(c32) {
-        const d32 = c32.user?.userId;
-        const e32 = c32.isLeaveMic;
-        const f32 = c32.requestIndex;
-        if (isNullOrUndefined(d32) || isNullOrUndefined(e32) || isNullOrUndefined(f32) || e32 === 1) {
+    onEventJoinLeave(q32) {
+        const r32 = q32.user?.userId;
+        const s32 = q32.isLeaveMic;
+        const t32 = q32.requestIndex;
+        if (isNullOrUndefined(r32) || isNullOrUndefined(s32) || isNullOrUndefined(t32) || s32 === 1) {
             return;
         }
-        if (this.repo.mediator.isMySocketLinkMicId(d32)) {
+        if (this.repo.mediator.isMySocketLinkMicId(r32)) {
             this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(-1);
             return;
         }
-        const g32 = this.repo.mediator.joinLinkMicWaitingQueueOrder.value ?? -1;
-        if (f32 >= 0 && g32 > 0 && g32 > f32) {
-            this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(g32 - 1);
+        const u32 = this.repo.mediator.joinLinkMicWaitingQueueOrder.value ?? -1;
+        if (t32 >= 0 && u32 > 0 && u32 > t32) {
+            this.repo.mediator.joinLinkMicWaitingQueueOrder.setValue(u32 - 1);
         }
     }
 }

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

@@ -7,18 +7,18 @@ export declare class LinkMicHandleRTCUseCase implements ILinkMicHandleRTCUseCase
     private readonly repo;
     private observers;
     private impl;
-    constructor(x32: PLVLinkMicRepo);
+    constructor(l33: PLVLinkMicRepo);
     init(): void;
     joinChannel(): void;
     leaveChannel(): void;
-    switchRole(u32: PLVRTCClientRole): void;
-    enableCamera(t32: boolean): void;
-    enableMicrophone(s32: boolean): void;
+    switchRole(i33: PLVRTCClientRole): void;
+    enableCamera(h33: boolean): void;
+    enableMicrophone(g33: boolean): void;
     enableCameraMicrophoneToLastState(): void;
     switchCamera(): void;
-    setLocalRenderMirror(r32: boolean): void;
-    setupVideoRender(q32: PLVLinkMicVideoRenderParam): void;
-    removeVideoRender(p32: PLVLinkMicVideoRenderParam): void;
+    setLocalRenderMirror(f33: boolean): void;
+    setupVideoRender(e33: PLVLinkMicVideoRenderParam): void;
+    removeVideoRender(d33: PLVLinkMicVideoRenderParam): void;
     onDestroy(): void;
     private renewToken;
 }

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

@@ -5,23 +5,23 @@ import { LinkMicGuestHandleRTCUseCase } from './roles/guest/LinkMicGuestHandleRT
 import { LinkMicTeacherHandleRTCUseCase } from './roles/teacher/LinkMicTeacherHandleRTCUseCase';
 import { LinkMicViewerHandleRTCUseCase } from './roles/viewer/LinkMicViewerHandleRTCUseCase';
 export class LinkMicHandleRTCUseCase {
-    constructor(x32) {
+    constructor(l33) {
         this.observers = [];
         this.impl = undefined;
-        this.repo = x32;
+        this.repo = l33;
     }
     init() {
-        this.repo.mediator.rtcEvent.observe((w32) => {
-            if (w32 instanceof PLVLinkMicRTCTokenExpired) {
+        this.repo.mediator.rtcEvent.observe((k33) => {
+            if (k33 instanceof PLVLinkMicRTCTokenExpired) {
                 this.renewToken();
             }
         })
             .pushTo(this.observers);
-        const v32 = this.repo.mediator.channelData?.viewerType;
-        if (v32 === PLVUserType.USERTYPE_TEACHER) {
+        const j33 = this.repo.mediator.channelData?.viewerType;
+        if (j33 === PLVUserType.USERTYPE_TEACHER) {
             this.impl = new LinkMicTeacherHandleRTCUseCase(this.repo);
         }
-        else if (v32 === PLVUserType.USERTYPE_GUEST) {
+        else if (j33 === PLVUserType.USERTYPE_GUEST) {
             this.impl = new LinkMicGuestHandleRTCUseCase(this.repo);
         }
         else {
@@ -35,14 +35,14 @@ export class LinkMicHandleRTCUseCase {
     leaveChannel() {
         this.impl?.leaveChannel();
     }
-    switchRole(u32) {
-        this.impl?.switchRole(u32);
+    switchRole(i33) {
+        this.impl?.switchRole(i33);
     }
-    enableCamera(t32) {
-        this.impl?.enableCamera(t32);
+    enableCamera(h33) {
+        this.impl?.enableCamera(h33);
     }
-    enableMicrophone(s32) {
-        this.impl?.enableMicrophone(s32);
+    enableMicrophone(g33) {
+        this.impl?.enableMicrophone(g33);
     }
     enableCameraMicrophoneToLastState() {
         this.impl?.enableCameraMicrophoneToLastState();
@@ -50,14 +50,14 @@ export class LinkMicHandleRTCUseCase {
     switchCamera() {
         this.impl?.switchCamera();
     }
-    setLocalRenderMirror(r32) {
-        this.impl?.setLocalRenderMirror(r32);
+    setLocalRenderMirror(f33) {
+        this.impl?.setLocalRenderMirror(f33);
     }
-    setupVideoRender(q32) {
-        this.impl?.setupVideoRender(q32);
+    setupVideoRender(e33) {
+        this.impl?.setupVideoRender(e33);
     }
-    removeVideoRender(p32) {
-        this.impl?.removeVideoRender(p32);
+    removeVideoRender(d33) {
+        this.impl?.removeVideoRender(d33);
     }
     onDestroy() {
         this.impl?.onDestroy();

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

@@ -11,7 +11,7 @@ export declare class LinkMicHandleStateUseCase implements ILinkMicHandleStateUse
     private readonly handleRTCUseCase;
     private readonly updateChannelViewerUseCase;
     private impl;
-    constructor(l33: PLVLinkMicRepo, m33: LinkMicHandleQueueOrderUseCase, n33: LinkMicHandleRTCUseCase, o33: LinkMicUpdateChannelViewerUseCase);
+    constructor(z33: PLVLinkMicRepo, a34: LinkMicHandleQueueOrderUseCase, b34: LinkMicHandleRTCUseCase, c34: LinkMicUpdateChannelViewerUseCase);
     init(): void;
     requestJoinLinkMic(): Promise<void>;
     acceptInvitation(): Promise<void>;
@@ -19,18 +19,18 @@ export declare class LinkMicHandleStateUseCase implements ILinkMicHandleStateUse
     leaveLinkMic(): void;
     onStreamerStart(): void;
     onLiveStreamStart(): void;
-    setLinkMicMode(j33: PLVLinkMicMode): Promise<boolean>;
+    setLinkMicMode(x33: PLVLinkMicMode): Promise<boolean>;
     openLinkMic(): Promise<boolean>;
     closeLinkMic(): Promise<boolean>;
-    acceptViewerLinkMicRequest(i33: string): void;
-    inviteViewerLinkMic(g33: string, h33: boolean): void;
-    hangupViewerLinkMic(f33: string): void;
+    acceptViewerLinkMicRequest(w33: string): void;
+    inviteViewerLinkMic(u33: string, v33: boolean): void;
+    hangupViewerLinkMic(t33: string): void;
     hangupAllViewersLinkMic(): void;
-    setViewerEnableCamera(d33: string, e33: boolean): void;
-    setViewerEnableMicrophone(b33: string, c33: boolean): void;
-    grantSpeaker(a33: string): void;
-    revokeSpeaker(z32: string): void;
-    setMainView(y32: string): void;
+    setViewerEnableCamera(r33: string, s33: boolean): void;
+    setViewerEnableMicrophone(p33: string, q33: boolean): void;
+    grantSpeaker(o33: string): void;
+    revokeSpeaker(n33: string): void;
+    setMainView(m33: string): void;
     onLiveStreamStop(): void;
     onStreamerStop(): void;
     updateInvitationExpireTime(): void;

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

@@ -3,19 +3,19 @@ import { LinkMicViewerHandleStateUseCase } from './roles/viewer/LinkMicViewerHan
 import { LinkMicTeacherHandleStateUseCase } from './roles/teacher/LinkMicTeacherHandleStateUseCase';
 import { LinkMicGuestHandleStateUseCase } from './roles/guest/LinkMicGuestHandleStateUseCase';
 export class LinkMicHandleStateUseCase {
-    constructor(l33, m33, n33, o33) {
+    constructor(z33, a34, b34, c34) {
         this.impl = undefined;
-        this.repo = l33;
-        this.handleQueueOrderUseCase = m33;
-        this.handleRTCUseCase = n33;
-        this.updateChannelViewerUseCase = o33;
+        this.repo = z33;
+        this.handleQueueOrderUseCase = a34;
+        this.handleRTCUseCase = b34;
+        this.updateChannelViewerUseCase = c34;
     }
     init() {
-        const k33 = this.repo.mediator.channelData?.viewerType;
-        if (k33 === PLVUserType.USERTYPE_TEACHER) {
+        const y33 = this.repo.mediator.channelData?.viewerType;
+        if (y33 === PLVUserType.USERTYPE_TEACHER) {
             this.impl = new LinkMicTeacherHandleStateUseCase(this.repo, this.handleQueueOrderUseCase, this.handleRTCUseCase, this.updateChannelViewerUseCase);
         }
-        else if (k33 === PLVUserType.USERTYPE_GUEST) {
+        else if (y33 === PLVUserType.USERTYPE_GUEST) {
             this.impl = new LinkMicGuestHandleStateUseCase(this.repo, this.handleQueueOrderUseCase, this.handleRTCUseCase, this.updateChannelViewerUseCase);
         }
         else {
@@ -41,8 +41,8 @@ export class LinkMicHandleStateUseCase {
     onLiveStreamStart() {
         this.impl?.onLiveStreamStart();
     }
-    async setLinkMicMode(j33) {
-        return this.impl?.setLinkMicMode(j33) ?? false;
+    async setLinkMicMode(x33) {
+        return this.impl?.setLinkMicMode(x33) ?? false;
     }
     async openLinkMic() {
         return this.impl?.openLinkMic() ?? false;
@@ -50,32 +50,32 @@ export class LinkMicHandleStateUseCase {
     async closeLinkMic() {
         return this.impl?.closeLinkMic() ?? false;
     }
-    acceptViewerLinkMicRequest(i33) {
-        this.impl?.acceptViewerLinkMicRequest(i33);
+    acceptViewerLinkMicRequest(w33) {
+        this.impl?.acceptViewerLinkMicRequest(w33);
     }
-    inviteViewerLinkMic(g33, h33) {
-        this.impl?.inviteViewerLinkMic(g33, h33);
+    inviteViewerLinkMic(u33, v33) {
+        this.impl?.inviteViewerLinkMic(u33, v33);
     }
-    hangupViewerLinkMic(f33) {
-        this.impl?.hangupViewerLinkMic(f33);
+    hangupViewerLinkMic(t33) {
+        this.impl?.hangupViewerLinkMic(t33);
     }
     hangupAllViewersLinkMic() {
         this.impl?.hangupAllViewersLinkMic();
     }
-    setViewerEnableCamera(d33, e33) {
-        this.impl?.setViewerEnableCamera(d33, e33);
+    setViewerEnableCamera(r33, s33) {
+        this.impl?.setViewerEnableCamera(r33, s33);
     }
-    setViewerEnableMicrophone(b33, c33) {
-        this.impl?.setViewerEnableMicrophone(b33, c33);
+    setViewerEnableMicrophone(p33, q33) {
+        this.impl?.setViewerEnableMicrophone(p33, q33);
     }
-    grantSpeaker(a33) {
-        this.impl?.grantSpeaker(a33);
+    grantSpeaker(o33) {
+        this.impl?.grantSpeaker(o33);
     }
-    revokeSpeaker(z32) {
-        this.impl?.revokeSpeaker(z32);
+    revokeSpeaker(n33) {
+        this.impl?.revokeSpeaker(n33);
     }
-    setMainView(y32) {
-        this.impl?.setMainView(y32);
+    setMainView(m33) {
+        this.impl?.setMainView(m33);
     }
     onLiveStreamStop() {
         this.impl?.onLiveStreamStop();

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

@@ -6,14 +6,14 @@ export declare class LinkMicUpdateChannelViewerUseCase implements LifecycleAware
     private readonly repo;
     private taskUpdateChannelLinkMicViewers;
     private observers;
-    constructor(x35: PLVLinkMicRepo);
+    constructor(l36: PLVLinkMicRepo);
     init(): void;
-    handleChannelLinkMicViewersUpdate(g35: UpdateChannelLinkMicViewerPayload): void;
+    handleChannelLinkMicViewersUpdate(u35: UpdateChannelLinkMicViewerPayload): void;
     sortChannelLinkMicViewers(): void;
-    onEventJoinSuccess(y34: PLVLinkMicSocketJoinSuccessRecv): void;
-    onEventJoinLeave(v34: PLVLinkMicSocketJoinLeaveRecv): void;
-    onEventTeacherSetPermission(q34: PLVLinkMicSocketTeacherSetPermissionRecv): void;
-    onEventSwitchView(p34: PLVLinkMicSocketSwitchViewRecv): void;
+    onEventJoinSuccess(m35: PLVLinkMicSocketJoinSuccessRecv): void;
+    onEventJoinLeave(j35: PLVLinkMicSocketJoinLeaveRecv): void;
+    onEventTeacherSetPermission(e35: PLVLinkMicSocketTeacherSetPermissionRecv): void;
+    onEventSwitchView(d35: PLVLinkMicSocketSwitchViewRecv): void;
     startUpdateChannelLinkMicViewersInterval(): void;
     stopUpdateChannelLinkMicViewersInterval(): void;
     private updateByChannelLinkMicStatus;