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

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

@@ -0,0 +1,33 @@
+export class PLVMemberViewModel {
+    constructor(e157, f157) {
+        this.repo = e157;
+        this.useCases = f157;
+        this.repo.mediator.acceptViewerLinkMicRequest = (o157) => {
+            this.useCases.handleStateUseCase.acceptViewerLinkMicRequest(o157);
+        };
+        this.repo.mediator.inviteViewerLinkMic = (m157, n157) => {
+            this.useCases.handleStateUseCase.inviteViewerLinkMic(m157, n157);
+        };
+        this.repo.mediator.hangupViewerLinkMic = (l157) => {
+            this.useCases.handleStateUseCase.hangupViewerLinkMic(l157);
+        };
+        this.repo.mediator.updateByLinkMicStatusList = (k157) => {
+            this.useCases.updateViewerUseCase.updateByLinkMicStatusList(k157);
+        };
+    }
+    init() {
+        this.useCases.init();
+    }
+    startUpdateChannelViewersInterval() {
+        this.useCases.updateViewerUseCase.startUpdateChannelViewersInterval();
+    }
+    stopUpdateChannelViewersInterval() {
+        this.useCases.updateViewerUseCase.stopUpdateChannelViewersInterval();
+    }
+    kickViewer(d157) {
+        this.useCases.handleStateUseCase.kickViewer(d157);
+    }
+    banViewer(b157, c157) {
+        this.useCases.handleStateUseCase.banViewer(b157, c157);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { LifecycleAwareDependComponent } from '@polyvharmony/media-player-sdk';
+import { PLVMemberRepo } from '../../model/PLVMemberRepo';
+import { MemberUpdateViewerUseCase } from './MemberUpdateViewerUseCase';
+import { IMemberHandleStateUseCase } from './roles/base/IMemberHandleStateUseCase';
+export declare class MemberHandleStateUseCase implements IMemberHandleStateUseCase, LifecycleAwareDependComponent {
+    private readonly repo;
+    private readonly updateViewerUseCase;
+    private impl;
+    constructor(x157: PLVMemberRepo, y157: MemberUpdateViewerUseCase);
+    init(): void;
+    acceptViewerLinkMicRequest(v157: string): void;
+    inviteViewerLinkMic(t157: string, u157?: boolean): void;
+    hangupViewerLinkMic(s157: string): void;
+    kickViewer(r157: string): void;
+    banViewer(p157: string, q157?: boolean | undefined): void;
+    onDestroy(): void;
+}

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

@@ -0,0 +1,40 @@
+import { PLVUserType } from '../../../socket/model/PLVUserType';
+import { MemberGuestHandleStateUseCase } from './roles/guest/MemberGuestHandleStateUseCase';
+import { MemberTeacherHandleStateUseCase } from './roles/teacher/MemberTeacherHandleStateUseCase';
+export class MemberHandleStateUseCase {
+    constructor(x157, y157) {
+        this.impl = undefined;
+        this.repo = x157;
+        this.updateViewerUseCase = y157;
+    }
+    init() {
+        const w157 = this.repo.mediator.channelData?.viewerType;
+        if (w157 === PLVUserType.USERTYPE_TEACHER) {
+            this.impl = new MemberTeacherHandleStateUseCase(this.repo, this.updateViewerUseCase);
+        }
+        else if (w157 === PLVUserType.USERTYPE_GUEST) {
+            this.impl = new MemberGuestHandleStateUseCase(this.repo, this.updateViewerUseCase);
+        }
+        else {
+        }
+        this.impl?.init();
+    }
+    acceptViewerLinkMicRequest(v157) {
+        this.impl?.acceptViewerLinkMicRequest(v157);
+    }
+    inviteViewerLinkMic(t157, u157 = true) {
+        this.impl?.inviteViewerLinkMic(t157, u157);
+    }
+    hangupViewerLinkMic(s157) {
+        this.impl?.hangupViewerLinkMic(s157);
+    }
+    kickViewer(r157) {
+        this.impl?.kickViewer(r157);
+    }
+    banViewer(p157, q157) {
+        this.impl?.banViewer(p157, q157);
+    }
+    onDestroy() {
+        this.impl?.onDestroy();
+    }
+}

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

@@ -0,0 +1,24 @@
+import { PLVMemberRepo } from '../../model/PLVMemberRepo';
+import { IMemberUpdateViewerUseCase, MemberUpdateChannelViewersPayload } from './roles/base/IMemberUpdateViewerUseCase';
+import { LifecycleAwareDependComponent } from '@polyvharmony/media-player-sdk';
+import { PLVLinkMicSocketJoinAnswerRecv, PLVLinkMicSocketJoinLeaveRecv, PLVLinkMicSocketJoinRequestRecv, PLVLinkMicSocketJoinSuccessRecv } from '../../../linkmic/model/vo/PLVLinkMicSocketEvent';
+import { PLVMemberSocketLoginRecv, PLVMemberSocketLogoutRecv } from '../../model/vo/PLVMemberSocketEvent';
+import { PLVLinkMicChannelStatus } from '../../../linkmic/model/vo/PLVLinkMicChannelStatus';
+export declare class MemberUpdateViewerUseCase implements IMemberUpdateViewerUseCase, LifecycleAwareDependComponent {
+    private readonly repo;
+    private impl;
+    constructor(h158: PLVMemberRepo);
+    init(): void;
+    startUpdateChannelViewersInterval(): void;
+    stopUpdateChannelViewersInterval(): void;
+    handleChannelViewersUpdate(payload: MemberUpdateChannelViewersPayload): void;
+    sortChannelViewers(): void;
+    updateByLinkMicStatusList(f158: PLVLinkMicChannelStatus): void;
+    onSocketUserLogin(e158: PLVMemberSocketLoginRecv): void;
+    onSocketUserLogout(d158: PLVMemberSocketLogoutRecv): void;
+    onSocketJoinRequest(c158: PLVLinkMicSocketJoinRequestRecv): void;
+    onSocketJoinAnswer(b158: PLVLinkMicSocketJoinAnswerRecv): void;
+    onSocketJoinSuccess(a158: PLVLinkMicSocketJoinSuccessRecv): void;
+    onSocketJoinLeave(z157: PLVLinkMicSocketJoinLeaveRecv): void;
+    onDestroy(): void;
+}

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

@@ -0,0 +1,56 @@
+import { PLVUserType } from '../../../socket/model/PLVUserType';
+import { MemberTeacherUpdateViewerUseCase } from './roles/teacher/MemberTeacherUpdateViewerUseCase';
+import { MemberGuestUpdateViewerUseCase } from './roles/guest/MemberGuestUpdateViewerUseCase';
+export class MemberUpdateViewerUseCase {
+    constructor(h158) {
+        this.impl = undefined;
+        this.repo = h158;
+    }
+    init() {
+        const g158 = this.repo.mediator.channelData?.viewerType;
+        if (g158 === PLVUserType.USERTYPE_TEACHER) {
+            this.impl = new MemberTeacherUpdateViewerUseCase(this.repo);
+        }
+        else if (g158 === PLVUserType.USERTYPE_GUEST) {
+            this.impl = new MemberGuestUpdateViewerUseCase(this.repo);
+        }
+        else {
+        }
+    }
+    startUpdateChannelViewersInterval() {
+        this.impl?.startUpdateChannelViewersInterval();
+    }
+    stopUpdateChannelViewersInterval() {
+        this.impl?.stopUpdateChannelViewersInterval();
+    }
+    handleChannelViewersUpdate(payload) {
+        this.impl?.handleChannelViewersUpdate(payload);
+    }
+    sortChannelViewers() {
+        this.impl?.sortChannelViewers();
+    }
+    updateByLinkMicStatusList(f158) {
+        this.impl?.updateByLinkMicStatusList(f158);
+    }
+    onSocketUserLogin(e158) {
+        this.impl?.onSocketUserLogin(e158);
+    }
+    onSocketUserLogout(d158) {
+        this.impl?.onSocketUserLogout(d158);
+    }
+    onSocketJoinRequest(c158) {
+        this.impl?.onSocketJoinRequest(c158);
+    }
+    onSocketJoinAnswer(b158) {
+        this.impl?.onSocketJoinAnswer(b158);
+    }
+    onSocketJoinSuccess(a158) {
+        this.impl?.onSocketJoinSuccess(a158);
+    }
+    onSocketJoinLeave(z157) {
+        this.impl?.onSocketJoinLeave(z157);
+    }
+    onDestroy() {
+        this.stopUpdateChannelViewersInterval();
+    }
+}

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

@@ -0,0 +1,8 @@
+import { MemberHandleStateUseCase } from './MemberHandleStateUseCase';
+import { MemberUpdateViewerUseCase } from './MemberUpdateViewerUseCase';
+export declare class PLVMemberUseCases {
+    readonly handleStateUseCase: MemberHandleStateUseCase;
+    readonly updateViewerUseCase: MemberUpdateViewerUseCase;
+    constructor(i158: MemberHandleStateUseCase, j158: MemberUpdateViewerUseCase);
+    init(): void;
+}

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

@@ -0,0 +1,10 @@
+export class PLVMemberUseCases {
+    constructor(i158, j158) {
+        this.handleStateUseCase = i158;
+        this.updateViewerUseCase = j158;
+    }
+    init() {
+        this.updateViewerUseCase.init();
+        this.handleStateUseCase.init();
+    }
+}

package/src/main/ets/modules/member/viewmodel/usecase/roles/base/IMemberHandleStateUseCase.d.ets

@@ -0,0 +1,9 @@
+export interface IMemberHandleStateUseCase {
+    init(): void;
+    acceptViewerLinkMicRequest(viewerId: string): void;
+    inviteViewerLinkMic(viewerId: string, needAnswer: boolean): void;
+    hangupViewerLinkMic(viewerId: string): void;
+    kickViewer(viewerId: string): void;
+    banViewer(viewerId: string, ban?: boolean): void;
+    onDestroy(): void;
+}

package/src/main/ets/modules/member/viewmodel/usecase/roles/base/IMemberHandleStateUseCase.js

@@ -0,0 +1 @@
+export {};

package/src/main/ets/modules/member/viewmodel/usecase/roles/base/IMemberUpdateViewerUseCase.d.ets

@@ -0,0 +1,22 @@
+import { PLVLinkMicChannelStatus } from '../../../../../linkmic/model/vo/PLVLinkMicChannelStatus';
+import { PLVLinkMicSocketJoinAnswerRecv, PLVLinkMicSocketJoinLeaveRecv, PLVLinkMicSocketJoinRequestRecv, PLVLinkMicSocketJoinSuccessRecv } from '../../../../../linkmic/model/vo/PLVLinkMicSocketEvent';
+import { PLVMemberChannelViewer } from '../../../../model/vo/PLVMemberChannelViewer';
+import { PLVMemberSocketLoginRecv, PLVMemberSocketLogoutRecv } from '../../../../model/vo/PLVMemberSocketEvent';
+export interface IMemberUpdateViewerUseCase {
+    startUpdateChannelViewersInterval(): void;
+    stopUpdateChannelViewersInterval(): void;
+    handleChannelViewersUpdate(payload: MemberUpdateChannelViewersPayload): void;
+    sortChannelViewers(): void;
+    updateByLinkMicStatusList(linkmicStatus: PLVLinkMicChannelStatus): void;
+    onSocketUserLogin(login: PLVMemberSocketLoginRecv): void;
+    onSocketUserLogout(logout: PLVMemberSocketLogoutRecv): void;
+    onSocketJoinRequest(joinRequest: PLVLinkMicSocketJoinRequestRecv): void;
+    onSocketJoinAnswer(joinAnswer: PLVLinkMicSocketJoinAnswerRecv): void;
+    onSocketJoinSuccess(joinSuccess: PLVLinkMicSocketJoinSuccessRecv): void;
+    onSocketJoinLeave(joinLeave: PLVLinkMicSocketJoinLeaveRecv): void;
+}
+export declare class MemberUpdateChannelViewersPayload {
+    add?: (PLVMemberChannelViewer | undefined)[];
+    remove?: (PLVMemberChannelViewer | undefined)[];
+    setAll?: (PLVMemberChannelViewer | undefined)[];
+}

package/src/main/ets/modules/member/viewmodel/usecase/roles/base/IMemberUpdateViewerUseCase.js

@@ -0,0 +1,2 @@
+export class MemberUpdateChannelViewersPayload {
+}

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

@@ -0,0 +1,30 @@
+import { PLVMemberRepo } from '../../../../model/PLVMemberRepo';
+import { MemberUpdateViewerUseCase } from '../../MemberUpdateViewerUseCase';
+import { IMemberHandleStateUseCase } from '../base/IMemberHandleStateUseCase';
+export declare class MemberGuestHandleStateUseCase implements IMemberHandleStateUseCase {
+    private readonly repo;
+    private readonly updateViewerUseCase;
+    private disposables;
+    private observers;
+    constructor(a160: PLVMemberRepo, b160: MemberUpdateViewerUseCase);
+    init(): void;
+    acceptViewerLinkMicRequest(u159: string): void;
+    inviteViewerLinkMic(s159: string, t159?: boolean): void;
+    hangupViewerLinkMic(r159: string): void;
+    kickViewer(q159: string): Promise<void>;
+    banViewer(o159: string, p159?: 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;
+}

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

@@ -0,0 +1,139 @@
+import { PLVDisposable } from '@polyvharmony/live-scenes-foundation';
+import { decodeFromJson, isNullOrUndefined, MutableObserver, requireNotNull } from '@polyvharmony/media-player-sdk';
+import { PLVLinkMicSocketJoinAnswerRecv, PLVLinkMicSocketJoinLeaveRecv, PLVLinkMicSocketJoinRequestRecv, PLVLinkMicSocketJoinSuccessRecv, PLVLinkMicSocketSwitchJoinVoiceRecv, PLVLinkMicSocketTeacherSetPermissionRecv } from '../../../../../linkmic/model/vo/PLVLinkMicSocketEvent';
+import { PLVLinkMicState } from '../../../../../linkmic/model/vo/PLVLinkMicState';
+import { PLVSocketMessageEvent, PLVSocketOnEvent } from '../../../../../socket/model/PLVSocketEventConstants';
+import { PLVMemberSocketBanIpRecv, PLVMemberSocketLoginRecv, PLVMemberSocketLogoutRecv, PLVMemberSocketSetNickRecv, PLVMemberSocketUnShieldRecv } from '../../../../model/vo/PLVMemberSocketEvent';
+const TAG = "PLVMemberManager";
+export class MemberGuestHandleStateUseCase {
+    constructor(a160, b160) {
+        this.disposables = [];
+        this.observers = [];
+        this.repo = a160;
+        this.updateViewerUseCase = b160;
+    }
+    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(u159) {
+    }
+    inviteViewerLinkMic(s159, t159 = true) {
+    }
+    hangupViewerLinkMic(r159) {
+    }
+    async kickViewer(q159) {
+    }
+    async banViewer(o159, p159 = true) {
+    }
+    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 n159 = decodeFromJson(data, PLVMemberSocketLoginRecv);
+        this.updateViewerUseCase.onSocketUserLogin(n159);
+    }
+    onSocketUserLogout(data) {
+        const m159 = decodeFromJson(data, PLVMemberSocketLogoutRecv);
+        this.updateViewerUseCase.onSocketUserLogout(m159);
+    }
+    onSocketTeacherSetPermission(data) {
+        const j159 = decodeFromJson(data, PLVLinkMicSocketTeacherSetPermissionRecv);
+        const k159 = this.repo.mediator.findViewerByViewerId(j159.userId);
+        if (k159 === undefined) {
+            return;
+        }
+        if (j159.type === "voice") {
+            const l159 = j159.status === "1";
+            k159.linkmicState.setValue(l159 ? PLVLinkMicState.Joined : PLVLinkMicState.NoLinkMic);
+        }
+    }
+    onSocketUserSetNick(data) {
+        const g159 = decodeFromJson(data, PLVMemberSocketSetNickRecv);
+        const h159 = g159.userId;
+        const i159 = this.repo.mediator.findViewerByViewerId(h159);
+        if (i159 !== undefined) {
+            i159.viewerName.setValue(g159.nick);
+        }
+    }
+    onSocketBanIp(data) {
+        const d159 = decodeFromJson(data, PLVMemberSocketBanIpRecv);
+        const e159 = d159.data?.userId;
+        const f159 = this.repo.mediator.findViewerByViewerId(e159);
+        if (f159 !== undefined) {
+            f159.ban.setValue(true);
+        }
+    }
+    onSocketUnShield(data) {
+        const a159 = decodeFromJson(data, PLVMemberSocketUnShieldRecv);
+        const b159 = a159.data?.userId;
+        const c159 = this.repo.mediator.findViewerByViewerId(b159);
+        if (c159 !== undefined) {
+            c159.ban.setValue(false);
+        }
+    }
+    onSocketSwitchJoinVoice(data) {
+        const w158 = decodeFromJson(data, PLVLinkMicSocketSwitchJoinVoiceRecv);
+        const x158 = w158.user?.loginId;
+        const y158 = w158.user?.micId?.toString() ?? w158.user?.userId;
+        const z158 = this.repo.mediator.findViewerByViewerId(x158);
+        if (z158 !== undefined && !isNullOrUndefined(y158)) {
+            z158.linkmicId = y158;
+        }
+    }
+    onSocketJoinRequest(data) {
+        const t158 = decodeFromJson(data, PLVLinkMicSocketJoinRequestRecv);
+        this.updateViewerUseCase.onSocketJoinRequest(t158);
+        const u158 = t158.user?.loginId;
+        const v158 = this.repo.mediator.findViewerByViewerId(u158);
+        if (u158 !== undefined && v158 !== undefined && v158.linkmicState.value === PLVLinkMicState.Inviting) {
+            this.acceptViewerLinkMicRequest(u158);
+        }
+    }
+    onSocketJoinAnswer(data) {
+        const s158 = decodeFromJson(data, PLVLinkMicSocketJoinAnswerRecv);
+        this.updateViewerUseCase.onSocketJoinAnswer(s158);
+    }
+    onSocketJoinSuccess(data) {
+        const r158 = decodeFromJson(data, PLVLinkMicSocketJoinSuccessRecv);
+        this.updateViewerUseCase.onSocketJoinSuccess(r158);
+    }
+    onSocketJoinLeave(data) {
+        const q158 = decodeFromJson(data, PLVLinkMicSocketJoinLeaveRecv);
+        this.updateViewerUseCase.onSocketJoinLeave(q158);
+    }
+    onDestroy() {
+        this.disposables.forEach((p158) => {
+            p158.dispose();
+        });
+        this.disposables = [];
+        MutableObserver.disposeAll(this.observers);
+        this.observers = [];
+    }
+    observeSocketEvent(event, callback) {
+        const m158 = requireNotNull(this.repo.mediator.socketMediator);
+        m158.onData(event, callback);
+        return disposable(() => m158.offData(event, callback));
+    }
+}
+class SocketDisposable extends PLVDisposable {
+    constructor(l158) {
+        super();
+        this.onDispose = l158;
+    }
+    dispose() {
+        super.dispose();
+        this.onDispose?.();
+    }
+}
+function disposable(k158) {
+    return new SocketDisposable(k158);
+}

package/src/main/ets/modules/member/viewmodel/usecase/roles/guest/MemberGuestUpdateViewerUseCase.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 MemberGuestUpdateViewerUseCase implements IMemberUpdateViewerUseCase {
+    private readonly repo;
+    private updateChannelViewerTask;
+    constructor(t164: PLVMemberRepo);
+    startUpdateChannelViewersInterval(): void;
+    stopUpdateChannelViewersInterval(): void;
+    handleChannelViewersUpdate(payload: MemberUpdateChannelViewersPayload): void;
+    sortChannelViewers(): void;
+    updateByLinkMicStatusList(g162: PLVLinkMicChannelStatus): void;
+    onSocketUserLogin(z161: PLVMemberSocketLoginRecv): void;
+    onSocketUserLogout(v161: PLVMemberSocketLogoutRecv): void;
+    onSocketJoinRequest(q161: PLVLinkMicSocketJoinRequestRecv): void;
+    onSocketJoinAnswer(n161: PLVLinkMicSocketJoinAnswerRecv): void;
+    onSocketJoinSuccess(i161: PLVLinkMicSocketJoinSuccessRecv): void;
+    onSocketJoinLeave(f161: PLVLinkMicSocketJoinLeaveRecv): void;
+    private updateServerListViewer;
+    private getViewerSortOrder;
+}