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

package/src/main/ets/modules/login/model/PLVLoginType.js

@@ -1,32 +1,32 @@
 import { PLVLiveChannelType } from "./PLVLiveChannelType";
 export var PLVLoginType;
-(function (h53) {
-    h53[h53["LIVE"] = 0] = "LIVE";
-    h53[h53["PLAYBACK"] = 1] = "PLAYBACK";
+(function (v53) {
+    v53[v53["LIVE"] = 0] = "LIVE";
+    v53[v53["PLAYBACK"] = 1] = "PLAYBACK";
 })(PLVLoginType || (PLVLoginType = {}));
 export var PLVLiveScene;
-(function (g53) {
-    g53["CLOUD_CLASS"] = "0";
-    g53["LIVE_ECOMMERCE"] = "1";
-    g53["LAND_TEMPLATE"] = "2";
-    g53["PORTRAIT_TEMPLATE"] = "3";
+(function (u53) {
+    u53["CLOUD_CLASS"] = "0";
+    u53["LIVE_ECOMMERCE"] = "1";
+    u53["LAND_TEMPLATE"] = "2";
+    u53["PORTRAIT_TEMPLATE"] = "3";
 })(PLVLiveScene || (PLVLiveScene = {}));
-export function isSupportChannelType(e53, f53) {
-    switch (e53) {
+export function isSupportChannelType(s53, t53) {
+    switch (s53) {
         case PLVLiveScene.CLOUD_CLASS:
-            return f53 === PLVLiveChannelType.PPT || f53 === PLVLiveChannelType.ALONE;
+            return t53 === PLVLiveChannelType.PPT || t53 === PLVLiveChannelType.ALONE;
         case PLVLiveScene.LIVE_ECOMMERCE:
-            return f53 === PLVLiveChannelType.ALONE;
+            return t53 === PLVLiveChannelType.ALONE;
         case PLVLiveScene.LAND_TEMPLATE:
-            return f53 === PLVLiveChannelType.PPT || f53 === PLVLiveChannelType.ALONE;
+            return t53 === PLVLiveChannelType.PPT || t53 === PLVLiveChannelType.ALONE;
         case PLVLiveScene.PORTRAIT_TEMPLATE:
-            return f53 === PLVLiveChannelType.PPT || f53 === PLVLiveChannelType.ALONE;
+            return t53 === PLVLiveChannelType.PPT || t53 === PLVLiveChannelType.ALONE;
         default:
             return false;
     }
 }
-export function getBusinessValue(d53) {
-    switch (d53) {
+export function getBusinessValue(r53) {
+    switch (r53) {
         case PLVLiveScene.CLOUD_CLASS:
             return '0';
         case PLVLiveScene.LIVE_ECOMMERCE:

package/src/main/ets/modules/member/PLVMemberManager.d.ets

@@ -24,7 +24,7 @@ export declare class PLVMemberManager extends PLVBaseModule {
      * 成员模块错误事件
      */
     readonly errorEvent: MutableEvent<PLVMemberErrorEvent>;
-    constructor(m57: DependScope, n57: PLVChannelData, o57: PLVSocketMediator);
+    constructor(a58: DependScope, b58: PLVChannelData, c58: PLVSocketMediator);
     private init;
     /**
      * 开始轮询更新频道观众列表
@@ -37,10 +37,10 @@ export declare class PLVMemberManager extends PLVBaseModule {
     /**
      * 踢出指定观众
      */
-    kickViewer(k57: string): void;
+    kickViewer(y57: string): void;
     /**
      * 禁言指定观众
      * @param ban 禁言/取消禁言
      */
-    banViewer(i57: string, j57?: boolean): void;
+    banViewer(w57: string, x57?: boolean): void;
 }

package/src/main/ets/modules/member/PLVMemberManager.js

@@ -2,21 +2,21 @@ import { PLVBaseModule } from '../../common/PLVBaseModule';
 import { PLVMemberMediator } from './mediator/PLVMemberMediator';
 import { PLVMemberViewModel } from './viewmodel/PLVMemberViewModel';
 export class PLVMemberManager extends PLVBaseModule {
-    constructor(m57, n57, o57) {
-        super(n57);
-        this.dependScope = m57;
+    constructor(a58, b58, c58) {
+        super(b58);
+        this.dependScope = a58;
         this.mediator = this.dependScope.get(PLVMemberMediator);
         this.viewModel = this.dependScope.get(PLVMemberViewModel);
         this.channelViewerCount = this.mediator.channelViewerCount;
         this.channelViewers = this.mediator.channelViewers;
         this.onViewerRequestLinkMic = this.mediator.onViewerRequestLinkMic;
         this.errorEvent = this.mediator.errorEvent;
-        this.init(o57);
+        this.init(c58);
     }
-    async init(l57) {
+    async init(z57) {
         await this.channelData.initializedPromise.get();
         this.mediator.channelData = this.channelData;
-        this.mediator.socketMediator = l57;
+        this.mediator.socketMediator = z57;
         this.viewModel.init();
     }
     startUpdateChannelViewersInterval() {
@@ -25,10 +25,10 @@ export class PLVMemberManager extends PLVBaseModule {
     stopUpdateChannelViewersInterval() {
         this.viewModel.stopUpdateChannelViewersInterval();
     }
-    kickViewer(k57) {
-        this.viewModel.kickViewer(k57);
+    kickViewer(y57) {
+        this.viewModel.kickViewer(y57);
     }
-    banViewer(i57, j57 = true) {
-        this.viewModel.banViewer(i57, j57);
+    banViewer(w57, x57 = true) {
+        this.viewModel.banViewer(w57, x57);
     }
 }

package/src/main/ets/modules/member/di/PLVMemberModule.js

@@ -8,12 +8,12 @@ import { MemberUpdateViewerUseCase } from '../viewmodel/usecase/MemberUpdateView
 import { PLVMemberUseCases } from '../viewmodel/usecase/PLVMemberUseCases';
 export const memberModule = new DependModule();
 memberModule.provide(PLVMemberMediator, () => new PLVMemberMediator());
-memberModule.provide(PLVMemberNetworkDataSource, (f56) => new PLVMemberNetworkDataSource(f56.get(PLVMemberMediator)));
-memberModule.provide(PLVMemberRepo, (e56) => new PLVMemberRepo(e56.get(PLVMemberMediator), e56.get(PLVMemberNetworkDataSource)));
-memberModule.provide(MemberUpdateViewerUseCase, (d56) => new MemberUpdateViewerUseCase(d56.get(PLVMemberRepo)));
-memberModule.provide(MemberHandleStateUseCase, (c56) => new MemberHandleStateUseCase(c56.get(PLVMemberRepo), c56.get(MemberUpdateViewerUseCase)));
-memberModule.provide(PLVMemberUseCases, (b56) => new PLVMemberUseCases(b56.get(MemberHandleStateUseCase), b56.get(MemberUpdateViewerUseCase)));
-memberModule.provide(PLVMemberViewModel, (a56) => new PLVMemberViewModel(a56.get(PLVMemberRepo), a56.get(PLVMemberUseCases)));
-memberModule.afterCreate(PLVMemberMediator, (z55) => runCatching(() => {
-    z55.get(PLVMemberViewModel);
+memberModule.provide(PLVMemberNetworkDataSource, (t56) => new PLVMemberNetworkDataSource(t56.get(PLVMemberMediator)));
+memberModule.provide(PLVMemberRepo, (s56) => new PLVMemberRepo(s56.get(PLVMemberMediator), s56.get(PLVMemberNetworkDataSource)));
+memberModule.provide(MemberUpdateViewerUseCase, (r56) => new MemberUpdateViewerUseCase(r56.get(PLVMemberRepo)));
+memberModule.provide(MemberHandleStateUseCase, (q56) => new MemberHandleStateUseCase(q56.get(PLVMemberRepo), q56.get(MemberUpdateViewerUseCase)));
+memberModule.provide(PLVMemberUseCases, (p56) => new PLVMemberUseCases(p56.get(MemberHandleStateUseCase), p56.get(MemberUpdateViewerUseCase)));
+memberModule.provide(PLVMemberViewModel, (o56) => new PLVMemberViewModel(o56.get(PLVMemberRepo), o56.get(PLVMemberUseCases)));
+memberModule.afterCreate(PLVMemberMediator, (n56) => runCatching(() => {
+    n56.get(PLVMemberViewModel);
 }));

package/src/main/ets/modules/member/mediator/PLVMemberMediator.d.ets

@@ -15,8 +15,8 @@ export declare class PLVMemberMediator implements LifecycleAwareDependComponent
     inviteViewerLinkMic: ((viewerId: string, needAnswer: boolean) => void) | null;
     hangupViewerLinkMic: ((viewerId: string) => void) | null;
     updateByLinkMicStatusList: ((linkmicStatus: PLVLinkMicChannelStatus) => void) | null;
-    findViewerByViewerId(k56: string | undefined | null): PLVMemberChannelViewer | undefined;
-    findViewerByLinkmicId(i56: string | undefined): PLVMemberChannelViewer | undefined;
-    reportError(g56: number, h56: string): void;
+    findViewerByViewerId(y56: string | undefined | null): PLVMemberChannelViewer | undefined;
+    findViewerByLinkmicId(w56: string | undefined): PLVMemberChannelViewer | undefined;
+    reportError(u56: number, v56: string): void;
     onDestroy(): void;
 }

package/src/main/ets/modules/member/mediator/PLVMemberMediator.js

@@ -15,21 +15,21 @@ export class PLVMemberMediator {
         this.hangupViewerLinkMic = null;
         this.updateByLinkMicStatusList = null;
     }
-    findViewerByViewerId(k56) {
-        if (isNullOrUndefined(k56)) {
+    findViewerByViewerId(y56) {
+        if (isNullOrUndefined(y56)) {
             return undefined;
         }
-        return (this.channelViewers.value ?? []).find(l56 => l56.viewerId === k56);
+        return (this.channelViewers.value ?? []).find(z56 => z56.viewerId === y56);
     }
-    findViewerByLinkmicId(i56) {
-        if (isNullOrUndefined(i56)) {
+    findViewerByLinkmicId(w56) {
+        if (isNullOrUndefined(w56)) {
             return undefined;
         }
-        return (this.channelViewers.value ?? []).find(j56 => j56.linkmicId === i56);
+        return (this.channelViewers.value ?? []).find(x56 => x56.linkmicId === w56);
     }
-    reportError(g56, h56) {
-        this.errorEvent.value = new PLVMemberErrorEvent(g56, h56);
-        PLVLogger.error(TAG, `Linkmic module error, code:${g56}, message:${h56}`, true);
+    reportError(u56, v56) {
+        this.errorEvent.value = new PLVMemberErrorEvent(u56, v56);
+        PLVLogger.error(TAG, `Linkmic module error, code:${u56}, message:${v56}`, true);
     }
     onDestroy() {
         MutableSource.disposeAll(this);

package/src/main/ets/modules/member/model/PLVMemberRepo.d.ets

@@ -5,6 +5,6 @@ import { PLVMemberListResponseData } from './vo/PLVMemberListResponseData';
 export declare class PLVMemberRepo {
     readonly mediator: PLVMemberMediator;
     private readonly networkDataSource;
-    constructor(c57: PLVMemberMediator, d57: PLVMemberNetworkDataSource);
-    getListUsers(x56: string, y56: number, z56: number): Promise<RecursiveNullable<PLVMemberListResponseData>>;
+    constructor(q57: PLVMemberMediator, r57: PLVMemberNetworkDataSource);
+    getListUsers(l57: string, m57: number, n57: number): Promise<RecursiveNullable<PLVMemberListResponseData>>;
 }

package/src/main/ets/modules/member/model/PLVMemberRepo.js

@@ -1,12 +1,12 @@
 import { requireNotNull } from '@polyvharmony/media-player-sdk';
 export class PLVMemberRepo {
-    constructor(c57, d57) {
-        this.mediator = c57;
-        this.networkDataSource = d57;
+    constructor(q57, r57) {
+        this.mediator = q57;
+        this.networkDataSource = r57;
     }
-    async getListUsers(x56, y56, z56) {
-        const a57 = requireNotNull(this.mediator.channelData);
-        const b57 = requireNotNull(a57.loginChannelId);
-        return this.networkDataSource.getListUsers(b57, x56, y56, z56, 1, true);
+    async getListUsers(l57, m57, n57) {
+        const o57 = requireNotNull(this.mediator.channelData);
+        const p57 = requireNotNull(o57.loginChannelId);
+        return this.networkDataSource.getListUsers(p57, l57, m57, n57, 1, true);
     }
 }

package/src/main/ets/modules/member/model/datasource/PLVMemberNetworkDataSource.d.ets

@@ -3,7 +3,7 @@ import { PLVMemberMediator } from '../../mediator/PLVMemberMediator';
 import { PLVMemberListResponseData } from '../vo/PLVMemberListResponseData';
 export declare class PLVMemberNetworkDataSource {
     private readonly mediator;
-    constructor(w56: PLVMemberMediator);
-    getListUsers(m56: string, n56: string, o56: number, p56: number, q56: number, r56: boolean): Promise<RecursiveNullable<PLVMemberListResponseData>>;
+    constructor(k57: PLVMemberMediator);
+    getListUsers(a57: string, b57: string, c57: number, d57: number, e57: number, f57: boolean): Promise<RecursiveNullable<PLVMemberListResponseData>>;
     private get api_polyv_net();
 }

package/src/main/ets/modules/member/model/datasource/PLVMemberNetworkDataSource.js

@@ -2,18 +2,18 @@ import { PLVJSONUtils } from '@polyvharmony/live-scenes-foundation';
 import { require, requireNotNull } from '@polyvharmony/media-player-sdk';
 import { apiPlvNetApi } from '../../../net/PLVApiPlvNetApi';
 export class PLVMemberNetworkDataSource {
-    constructor(w56) {
-        this.mediator = w56;
+    constructor(k57) {
+        this.mediator = k57;
     }
-    async getListUsers(m56, n56, o56, p56, q56, r56) {
-        const s56 = requireNotNull(this.mediator.channelData);
-        const t56 = requireNotNull(s56.appId);
-        const u56 = requireNotNull(s56.appSecret);
-        const v56 = await this.api_polyv_net.getListUsers(m56, t56, u56, n56, o56, p56, q56, r56);
-        require(v56.status === 200
-            && v56.data.code === 200
-            && v56.data.data !== undefined, () => `getListUsers failed: ${PLVJSONUtils.safeStringify(v56)}`);
-        return v56.data.data;
+    async getListUsers(a57, b57, c57, d57, e57, f57) {
+        const g57 = requireNotNull(this.mediator.channelData);
+        const h57 = requireNotNull(g57.appId);
+        const i57 = requireNotNull(g57.appSecret);
+        const j57 = await this.api_polyv_net.getListUsers(a57, h57, i57, b57, c57, d57, e57, f57);
+        require(j57.status === 200
+            && j57.data.code === 200
+            && j57.data.data !== undefined, () => `getListUsers failed: ${PLVJSONUtils.safeStringify(j57)}`);
+        return j57.data.data;
     }
     get api_polyv_net() {
         return apiPlvNetApi(requireNotNull(this.mediator.channelData));

package/src/main/ets/modules/member/model/vo/PLVMemberChannelViewer.d.ets

@@ -12,5 +12,5 @@ export declare class PLVMemberChannelViewer {
     linkmicId?: string;
     socketId?: string;
     isMyself: boolean;
-    constructor(e57: string, f57: string);
+    constructor(s57: string, t57: string);
 }

package/src/main/ets/modules/member/model/vo/PLVMemberChannelViewer.js

@@ -1,12 +1,12 @@
 import { MutableState } from '@polyvharmony/media-player-sdk';
 import { PLVLinkMicState } from '../../../linkmic/model/vo/PLVLinkMicState';
 export class PLVMemberChannelViewer {
-    constructor(e57, f57) {
+    constructor(s57, t57) {
         this.linkmicState = new MutableState(PLVLinkMicState.NoLinkMic);
         this.viewerName = new MutableState();
         this.ban = new MutableState(false);
         this.isMyself = false;
-        this.channelId = e57;
-        this.viewerId = f57;
+        this.channelId = s57;
+        this.viewerId = t57;
     }
 }

package/src/main/ets/modules/member/model/vo/PLVMemberErrorEvent.d.ets

@@ -9,5 +9,5 @@ export declare class PLVMemberErrorEvent {
     static readonly REACH_LINKMIC_LIMIT = 2;
     readonly code: number;
     readonly message: string;
-    constructor(g57: number, h57: string);
+    constructor(u57: number, v57: string);
 }

package/src/main/ets/modules/member/model/vo/PLVMemberErrorEvent.js

@@ -1,7 +1,7 @@
 export class PLVMemberErrorEvent {
-    constructor(g57, h57) {
-        this.code = g57;
-        this.message = h57;
+    constructor(u57, v57) {
+        this.code = u57;
+        this.message = v57;
     }
 }
 PLVMemberErrorEvent.MEMBER_INIT_FAILED = 1;

package/src/main/ets/modules/member/viewmodel/PLVMemberViewModel.d.ets

@@ -3,10 +3,10 @@ import { PLVMemberUseCases } from './usecase/PLVMemberUseCases';
 export declare class PLVMemberViewModel {
     private readonly repo;
     private readonly useCases;
-    constructor(s57: PLVMemberRepo, t57: PLVMemberUseCases);
+    constructor(g58: PLVMemberRepo, h58: PLVMemberUseCases);
     init(): void;
     startUpdateChannelViewersInterval(): void;
     stopUpdateChannelViewersInterval(): void;
-    kickViewer(r57: string): void;
-    banViewer(p57: string, q57?: boolean | undefined): void;
+    kickViewer(f58: string): void;
+    banViewer(d58: string, e58?: boolean | undefined): void;
 }

package/src/main/ets/modules/member/viewmodel/PLVMemberViewModel.js

@@ -1,18 +1,18 @@
 export class PLVMemberViewModel {
-    constructor(s57, t57) {
-        this.repo = s57;
-        this.useCases = t57;
-        this.repo.mediator.acceptViewerLinkMicRequest = (y57) => {
-            this.useCases.handleStateUseCase.acceptViewerLinkMicRequest(y57);
+    constructor(g58, h58) {
+        this.repo = g58;
+        this.useCases = h58;
+        this.repo.mediator.acceptViewerLinkMicRequest = (m58) => {
+            this.useCases.handleStateUseCase.acceptViewerLinkMicRequest(m58);
         };
-        this.repo.mediator.inviteViewerLinkMic = (w57, x57) => {
-            this.useCases.handleStateUseCase.inviteViewerLinkMic(w57, x57);
+        this.repo.mediator.inviteViewerLinkMic = (k58, l58) => {
+            this.useCases.handleStateUseCase.inviteViewerLinkMic(k58, l58);
         };
-        this.repo.mediator.hangupViewerLinkMic = (v57) => {
-            this.useCases.handleStateUseCase.hangupViewerLinkMic(v57);
+        this.repo.mediator.hangupViewerLinkMic = (j58) => {
+            this.useCases.handleStateUseCase.hangupViewerLinkMic(j58);
         };
-        this.repo.mediator.updateByLinkMicStatusList = (u57) => {
-            this.useCases.updateViewerUseCase.updateByLinkMicStatusList(u57);
+        this.repo.mediator.updateByLinkMicStatusList = (i58) => {
+            this.useCases.updateViewerUseCase.updateByLinkMicStatusList(i58);
         };
     }
     init() {
@@ -24,10 +24,10 @@ export class PLVMemberViewModel {
     stopUpdateChannelViewersInterval() {
         this.useCases.updateViewerUseCase.stopUpdateChannelViewersInterval();
     }
-    kickViewer(r57) {
-        this.useCases.handleStateUseCase.kickViewer(r57);
+    kickViewer(f58) {
+        this.useCases.handleStateUseCase.kickViewer(f58);
     }
-    banViewer(p57, q57) {
-        this.useCases.handleStateUseCase.banViewer(p57, q57);
+    banViewer(d58, e58) {
+        this.useCases.handleStateUseCase.banViewer(d58, e58);
     }
 }

package/src/main/ets/modules/member/viewmodel/usecase/MemberHandleStateUseCase.d.ets

@@ -6,12 +6,12 @@ export declare class MemberHandleStateUseCase implements IMemberHandleStateUseCa
     private readonly repo;
     private readonly updateViewerUseCase;
     private impl;
-    constructor(h58: PLVMemberRepo, i58: MemberUpdateViewerUseCase);
+    constructor(v58: PLVMemberRepo, w58: MemberUpdateViewerUseCase);
     init(): void;
-    acceptViewerLinkMicRequest(f58: string): void;
-    inviteViewerLinkMic(d58: string, e58?: boolean): void;
-    hangupViewerLinkMic(c58: string): void;
-    kickViewer(b58: string): void;
-    banViewer(z57: string, a58?: boolean | undefined): void;
+    acceptViewerLinkMicRequest(t58: string): void;
+    inviteViewerLinkMic(r58: string, s58?: boolean): void;
+    hangupViewerLinkMic(q58: string): void;
+    kickViewer(p58: string): void;
+    banViewer(n58: string, o58?: boolean | undefined): void;
     onDestroy(): void;
 }

package/src/main/ets/modules/member/viewmodel/usecase/MemberHandleStateUseCase.js

@@ -2,37 +2,37 @@ import { PLVUserType } from '../../../socket/model/PLVUserType';
 import { MemberGuestHandleStateUseCase } from './roles/guest/MemberGuestHandleStateUseCase';
 import { MemberTeacherHandleStateUseCase } from './roles/teacher/MemberTeacherHandleStateUseCase';
 export class MemberHandleStateUseCase {
-    constructor(h58, i58) {
+    constructor(v58, w58) {
         this.impl = undefined;
-        this.repo = h58;
-        this.updateViewerUseCase = i58;
+        this.repo = v58;
+        this.updateViewerUseCase = w58;
     }
     init() {
-        const g58 = this.repo.mediator.channelData?.viewerType;
-        if (g58 === PLVUserType.USERTYPE_TEACHER) {
+        const u58 = this.repo.mediator.channelData?.viewerType;
+        if (u58 === PLVUserType.USERTYPE_TEACHER) {
             this.impl = new MemberTeacherHandleStateUseCase(this.repo, this.updateViewerUseCase);
         }
-        else if (g58 === PLVUserType.USERTYPE_GUEST) {
+        else if (u58 === PLVUserType.USERTYPE_GUEST) {
             this.impl = new MemberGuestHandleStateUseCase(this.repo, this.updateViewerUseCase);
         }
         else {
         }
         this.impl?.init();
     }
-    acceptViewerLinkMicRequest(f58) {
-        this.impl?.acceptViewerLinkMicRequest(f58);
+    acceptViewerLinkMicRequest(t58) {
+        this.impl?.acceptViewerLinkMicRequest(t58);
     }
-    inviteViewerLinkMic(d58, e58 = true) {
-        this.impl?.inviteViewerLinkMic(d58, e58);
+    inviteViewerLinkMic(r58, s58 = true) {
+        this.impl?.inviteViewerLinkMic(r58, s58);
     }
-    hangupViewerLinkMic(c58) {
-        this.impl?.hangupViewerLinkMic(c58);
+    hangupViewerLinkMic(q58) {
+        this.impl?.hangupViewerLinkMic(q58);
     }
-    kickViewer(b58) {
-        this.impl?.kickViewer(b58);
+    kickViewer(p58) {
+        this.impl?.kickViewer(p58);
     }
-    banViewer(z57, a58) {
-        this.impl?.banViewer(z57, a58);
+    banViewer(n58, o58) {
+        this.impl?.banViewer(n58, o58);
     }
     onDestroy() {
         this.impl?.onDestroy();

package/src/main/ets/modules/member/viewmodel/usecase/MemberUpdateViewerUseCase.d.ets

@@ -7,18 +7,18 @@ import { PLVLinkMicChannelStatus } from '../../../linkmic/model/vo/PLVLinkMicCha
 export declare class MemberUpdateViewerUseCase implements IMemberUpdateViewerUseCase, LifecycleAwareDependComponent {
     private readonly repo;
     private impl;
-    constructor(s58: PLVMemberRepo);
+    constructor(g59: PLVMemberRepo);
     init(): void;
     startUpdateChannelViewersInterval(): void;
     stopUpdateChannelViewersInterval(): void;
-    handleChannelViewersUpdate(q58: MemberUpdateChannelViewersPayload): void;
+    handleChannelViewersUpdate(e59: MemberUpdateChannelViewersPayload): void;
     sortChannelViewers(): void;
-    updateByLinkMicStatusList(p58: PLVLinkMicChannelStatus): void;
-    onSocketUserLogin(o58: PLVMemberSocketLoginRecv): void;
-    onSocketUserLogout(n58: PLVMemberSocketLogoutRecv): void;
-    onSocketJoinRequest(m58: PLVLinkMicSocketJoinRequestRecv): void;
-    onSocketJoinAnswer(l58: PLVLinkMicSocketJoinAnswerRecv): void;
-    onSocketJoinSuccess(k58: PLVLinkMicSocketJoinSuccessRecv): void;
-    onSocketJoinLeave(j58: PLVLinkMicSocketJoinLeaveRecv): void;
+    updateByLinkMicStatusList(d59: PLVLinkMicChannelStatus): void;
+    onSocketUserLogin(c59: PLVMemberSocketLoginRecv): void;
+    onSocketUserLogout(b59: PLVMemberSocketLogoutRecv): void;
+    onSocketJoinRequest(a59: PLVLinkMicSocketJoinRequestRecv): void;
+    onSocketJoinAnswer(z58: PLVLinkMicSocketJoinAnswerRecv): void;
+    onSocketJoinSuccess(y58: PLVLinkMicSocketJoinSuccessRecv): void;
+    onSocketJoinLeave(x58: PLVLinkMicSocketJoinLeaveRecv): void;
     onDestroy(): void;
 }

package/src/main/ets/modules/member/viewmodel/usecase/MemberUpdateViewerUseCase.js

@@ -2,16 +2,16 @@ import { PLVUserType } from '../../../socket/model/PLVUserType';
 import { MemberTeacherUpdateViewerUseCase } from './roles/teacher/MemberTeacherUpdateViewerUseCase';
 import { MemberGuestUpdateViewerUseCase } from './roles/guest/MemberGuestUpdateViewerUseCase';
 export class MemberUpdateViewerUseCase {
-    constructor(s58) {
+    constructor(g59) {
         this.impl = undefined;
-        this.repo = s58;
+        this.repo = g59;
     }
     init() {
-        const r58 = this.repo.mediator.channelData?.viewerType;
-        if (r58 === PLVUserType.USERTYPE_TEACHER) {
+        const f59 = this.repo.mediator.channelData?.viewerType;
+        if (f59 === PLVUserType.USERTYPE_TEACHER) {
             this.impl = new MemberTeacherUpdateViewerUseCase(this.repo);
         }
-        else if (r58 === PLVUserType.USERTYPE_GUEST) {
+        else if (f59 === PLVUserType.USERTYPE_GUEST) {
             this.impl = new MemberGuestUpdateViewerUseCase(this.repo);
         }
         else {
@@ -23,32 +23,32 @@ export class MemberUpdateViewerUseCase {
     stopUpdateChannelViewersInterval() {
         this.impl?.stopUpdateChannelViewersInterval();
     }
-    handleChannelViewersUpdate(q58) {
-        this.impl?.handleChannelViewersUpdate(q58);
+    handleChannelViewersUpdate(e59) {
+        this.impl?.handleChannelViewersUpdate(e59);
     }
     sortChannelViewers() {
         this.impl?.sortChannelViewers();
     }
-    updateByLinkMicStatusList(p58) {
-        this.impl?.updateByLinkMicStatusList(p58);
+    updateByLinkMicStatusList(d59) {
+        this.impl?.updateByLinkMicStatusList(d59);
     }
-    onSocketUserLogin(o58) {
-        this.impl?.onSocketUserLogin(o58);
+    onSocketUserLogin(c59) {
+        this.impl?.onSocketUserLogin(c59);
     }
-    onSocketUserLogout(n58) {
-        this.impl?.onSocketUserLogout(n58);
+    onSocketUserLogout(b59) {
+        this.impl?.onSocketUserLogout(b59);
     }
-    onSocketJoinRequest(m58) {
-        this.impl?.onSocketJoinRequest(m58);
+    onSocketJoinRequest(a59) {
+        this.impl?.onSocketJoinRequest(a59);
     }
-    onSocketJoinAnswer(l58) {
-        this.impl?.onSocketJoinAnswer(l58);
+    onSocketJoinAnswer(z58) {
+        this.impl?.onSocketJoinAnswer(z58);
     }
-    onSocketJoinSuccess(k58) {
-        this.impl?.onSocketJoinSuccess(k58);
+    onSocketJoinSuccess(y58) {
+        this.impl?.onSocketJoinSuccess(y58);
     }
-    onSocketJoinLeave(j58) {
-        this.impl?.onSocketJoinLeave(j58);
+    onSocketJoinLeave(x58) {
+        this.impl?.onSocketJoinLeave(x58);
     }
     onDestroy() {
         this.stopUpdateChannelViewersInterval();

package/src/main/ets/modules/member/viewmodel/usecase/PLVMemberUseCases.d.ets

@@ -3,6 +3,6 @@ import { MemberUpdateViewerUseCase } from './MemberUpdateViewerUseCase';
 export declare class PLVMemberUseCases {
     readonly handleStateUseCase: MemberHandleStateUseCase;
     readonly updateViewerUseCase: MemberUpdateViewerUseCase;
-    constructor(t58: MemberHandleStateUseCase, u58: MemberUpdateViewerUseCase);
+    constructor(h59: MemberHandleStateUseCase, i59: MemberUpdateViewerUseCase);
     init(): void;
 }

package/src/main/ets/modules/member/viewmodel/usecase/PLVMemberUseCases.js

@@ -1,7 +1,7 @@
 export class PLVMemberUseCases {
-    constructor(t58, u58) {
-        this.handleStateUseCase = t58;
-        this.updateViewerUseCase = u58;
+    constructor(h59, i59) {
+        this.handleStateUseCase = h59;
+        this.updateViewerUseCase = i59;
     }
     init() {
         this.updateViewerUseCase.init();

package/src/main/ets/modules/member/viewmodel/usecase/roles/guest/MemberGuestHandleStateUseCase.d.ets

@@ -6,13 +6,13 @@ export declare class MemberGuestHandleStateUseCase implements IMemberHandleState
     private readonly updateViewerUseCase;
     private disposables;
     private observers;
-    constructor(z60: PLVMemberRepo, a61: MemberUpdateViewerUseCase);
+    constructor(n61: PLVMemberRepo, o61: MemberUpdateViewerUseCase);
     init(): void;
-    acceptViewerLinkMicRequest(s60: string): void;
-    inviteViewerLinkMic(q60: string, r60?: boolean): void;
-    hangupViewerLinkMic(p60: string): void;
-    kickViewer(o60: string): Promise<void>;
-    banViewer(m60: string, n60?: boolean): Promise<void>;
+    acceptViewerLinkMicRequest(g61: string): void;
+    inviteViewerLinkMic(e61: string, f61?: boolean): void;
+    hangupViewerLinkMic(d61: string): void;
+    kickViewer(c61: string): Promise<void>;
+    banViewer(a61: string, b61?: boolean): Promise<void>;
     private onSocketMessage;
     private onSocketUserLogin;
     private onSocketUserLogout;