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

package/src/main/ets/modules/reward/PLVRewardManager.d.ets

@@ -0,0 +1,48 @@
+import { IPLVEventNotify } from '@polyvharmony/live-scenes-foundation';
+import { PLVBaseModule } from '../../common/PLVBaseModule';
+import { PLVRewardSettingVO } from './model/PLVRewardSettingVO';
+/**
+ * 事件类型，可以使用{@link PLVRewardManager#eventNotify}监听对应的事件
+ */
+export type EventType = 'reward_setting';
+/**
+ * 打赏管理器
+ */
+export declare class PLVRewardManager extends PLVBaseModule {
+    /**
+     * 打赏配置数据
+     */
+    rewardSetting?: PLVRewardSettingVO;
+    /**
+     * 事件通知
+     */
+    eventNotify: IPLVEventNotify<EventType>;
+    /**
+     * 获取打赏配置
+     * @returns
+     */
+    getRewardSetting(): Promise<PLVRewardSettingVO>;
+    /**
+     * 获取剩余积分
+     * @returns
+     */
+    getRemainingRewardPoint(): Promise<number>;
+    /**
+     * 积分打赏
+     * @param goodId
+     * @param goodNum
+     * @returns
+     */
+    makePointReward(u180: number, v180: number): Promise<number>;
+    /**
+     * 道具打赏
+     * @param goodId
+     * @param goodNum
+     * @returns
+     */
+    makeGiftCashReward(n180: number, o180: number): Promise<object>;
+    /**
+     * 销毁
+     */
+    destroy(): void;
+}

package/src/main/ets/modules/reward/PLVRewardManager.js

@@ -0,0 +1,50 @@
+import { PLVEventNotify, PLVUtils } from '@polyvharmony/live-scenes-foundation';
+import { PLVBaseModule } from '../../common/PLVBaseModule';
+import { apiPlvNetApi } from '../net/PLVApiPlvNetApi';
+import { PLVRewardPointVO } from './model/PLVRewardPointVO';
+const TAG = '[PLVRewardManager]';
+export class PLVRewardManager extends PLVBaseModule {
+    constructor() {
+        super(...arguments);
+        this.eventNotify = new PLVEventNotify(this);
+    }
+    getRewardSetting() {
+        return PLVUtils.safePromise(async (j181, k181) => {
+            const l181 = await apiPlvNetApi(this.channelData).getRewardSetting(this.channelData.loginChannelId, this.channelData.appId, this.channelData.appSecret).catch((err) => {
+                return Promise.reject(err.log(TAG, 'getRewardSetting error'));
+            });
+            j181(l181.data.data);
+            this.eventNotify.emit('reward_setting', l181.data.data);
+            this.rewardSetting = l181.data.data;
+        });
+    }
+    getRemainingRewardPoint() {
+        return PLVUtils.safePromise(async (d181, e181) => {
+            const f181 = await apiPlvNetApi(this.channelData).getRewardPoint(this.channelData.loginChannelId, this.channelData.appId, this.channelData.appSecret, this.channelData.viewerId, this.channelData.viewerName).catch((err) => {
+                return Promise.reject(err.log(TAG, 'getRewardPoint error'));
+            });
+            const g181 = PLVRewardPointVO.toPoint(f181.data.data);
+            d181(g181);
+        });
+    }
+    makePointReward(u180 = 1, v180) {
+        return PLVUtils.safePromise(async (x180, y180) => {
+            const z180 = await apiPlvNetApi(this.channelData).makePointReward(this.channelData.loginChannelId, this.channelData.appId, this.channelData.appSecret, this.channelData.viewerId, this.channelData.viewerName, this.channelData.viewerAvatar, u180, v180).catch((err) => {
+                return Promise.reject(err.log(TAG, 'makePointReward error'));
+            });
+            const a181 = PLVRewardPointVO.toPoint(z180.data.data);
+            x180(a181);
+        });
+    }
+    makeGiftCashReward(n180 = 1, o180) {
+        return PLVUtils.safePromise(async (q180, r180) => {
+            const s180 = await apiPlvNetApi(this.channelData).makeGiftCashReward(this.channelData.loginChannelId, this.channelData.appId, this.channelData.appSecret, this.channelData.viewerId, this.channelData.viewerName, this.channelData.viewerAvatar, n180, o180, this.channelData.sessionId).catch((err) => {
+                return Promise.reject(err.log(TAG, 'makeGiftCashReward error'));
+            });
+            q180(s180.data);
+        });
+    }
+    destroy() {
+        this.eventNotify.clear();
+    }
+}

package/src/main/ets/modules/reward/model/PLVRewardPointVO.d.ets

@@ -0,0 +1,3 @@
+export declare class PLVRewardPointVO {
+    static toPoint(obj?: PLVRewardPointVO): number;
+}

package/src/main/ets/modules/reward/model/PLVRewardPointVO.js

@@ -0,0 +1,8 @@
+export class PLVRewardPointVO {
+    static toPoint(obj) {
+        if (!obj) {
+            return 0;
+        }
+        return parseInt(obj.toString());
+    }
+}

package/src/main/ets/modules/reward/model/PLVRewardSettingVO.d.ets

@@ -0,0 +1,39 @@
+@Observed
+export declare class PLVRewardSettingVO {
+    donateCashEnabled?: string;
+    donateGiftEnabled?: string;
+    cashDonate?: CashDonateDataBean;
+    giftDonate?: GiftDonateDataBean;
+    fill(): void;
+    getDonateCashEnabled(): boolean;
+    getDonateGiftEnabled(): boolean;
+}
+export interface CashDonateDataBean {
+    cashs?: string[];
+    cashMin?: string;
+}
+@Observed
+export declare class GiftDonateDataBean {
+    payWay?: string;
+    cashUnit?: string;
+    private pointUnit?;
+    cashPays?: GiftDetailDataBean[];
+    pointPays?: GiftDetailDataBean[];
+    enabledCashPays?: GiftDetailDataBean[];
+    enabledPointPays?: GiftDetailDataBean[];
+    getPointUnit(): string | Resource | undefined;
+}
+@Observed
+export declare class GiftDetailDataBean {
+    private name?;
+    private img?;
+    price?: string;
+    sequence?: number;
+    enabled?: string;
+    goodId?: number;
+    pointUnit?: string | Resource | undefined;
+    cashUnit?: string;
+    getName(): string | Resource | undefined;
+    getImg(): string;
+    isFree(): boolean;
+}

package/src/main/ets/modules/reward/model/PLVRewardSettingVO.js

@@ -0,0 +1,83 @@
+var __decorate = (this && this.__decorate) || function (l180, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(l180, target, key, desc);
+    else
+        for (var m180 = l180.length - 1; m180 >= 0; m180--)
+            if (d = l180[m180])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { PLVJSONUtils, PLVTextUtils } from '@polyvharmony/live-scenes-foundation';
+import { PLVI18NDataMapper } from '../../i18n/PLVI18NDataMapper';
+let PLVRewardSettingVO = class PLVRewardSettingVO {
+    fill() {
+        this.giftDonate = PLVJSONUtils.bean2Bean(new GiftDonateDataBean(), this.giftDonate);
+        if (this.giftDonate?.cashPays) {
+            let j180 = 1;
+            this.giftDonate.cashPays.forEach((value, index) => {
+                const data = this.giftDonate.cashPays[index] = PLVJSONUtils.bean2Bean(new GiftDetailDataBean(), value);
+                data.pointUnit = this.giftDonate?.getPointUnit();
+                data.cashUnit = this.giftDonate?.cashUnit;
+                if ('Y' === data.enabled) {
+                    data.goodId = j180++;
+                    if (data.isFree()) {
+                        if (!this.giftDonate.enabledCashPays) {
+                            this.giftDonate.enabledCashPays = [];
+                        }
+                        this.giftDonate?.enabledCashPays?.push(data);
+                    }
+                }
+            });
+        }
+        if (this.giftDonate?.pointPays) {
+            let h180 = 1;
+            this.giftDonate.pointPays.forEach((value, index) => {
+                const data = this.giftDonate.pointPays[index] = PLVJSONUtils.bean2Bean(new GiftDetailDataBean(), value);
+                data.pointUnit = this.giftDonate?.getPointUnit();
+                data.cashUnit = this.giftDonate?.cashUnit;
+                if ('Y' === data.enabled) {
+                    data.goodId = h180++;
+                    if (!this.giftDonate.enabledPointPays) {
+                        this.giftDonate.enabledPointPays = [];
+                    }
+                    this.giftDonate?.enabledPointPays?.push(data);
+                }
+            });
+        }
+    }
+    getDonateCashEnabled() {
+        return 'Y' === this.donateCashEnabled;
+    }
+    getDonateGiftEnabled() {
+        return 'Y' === this.donateGiftEnabled;
+    }
+};
+PLVRewardSettingVO = __decorate([
+    Observed
+], PLVRewardSettingVO);
+export { PLVRewardSettingVO };
+let GiftDonateDataBean = class GiftDonateDataBean {
+    getPointUnit() {
+        return PLVI18NDataMapper.getUnit(this.pointUnit);
+    }
+};
+GiftDonateDataBean = __decorate([
+    Observed
+], GiftDonateDataBean);
+export { GiftDonateDataBean };
+let GiftDetailDataBean = class GiftDetailDataBean {
+    getName() {
+        return PLVI18NDataMapper.getRewardName(this.name);
+    }
+    getImg() {
+        return PLVTextUtils.fixPic(this.img);
+    }
+    isFree() {
+        return parseFloat(this.price || '0') <= 0;
+    }
+};
+GiftDetailDataBean = __decorate([
+    Observed
+], GiftDetailDataBean);
+export { GiftDetailDataBean };

package/src/main/ets/modules/socket/PLVSocketManager.d.ets

@@ -0,0 +1,132 @@
+import { IPLVEventNotify, PLVSocketIO } from '@polyvharmony/live-scenes-foundation';
+import { IPLVBaseModule } from '../../common/PLVBaseModule';
+import { PLVChannelData } from '../../common/PLVChannelData';
+/**
+ * 事件类型，可以使用{@link PLVSocketManager#eventNotify_socketStatus}监听对应的事件
+ */
+export type EventType_SocketStatus = 'socket_status';
+/**
+ * socket管理器
+ */
+export declare class PLVSocketManager extends PLVSocketIO implements IPLVBaseModule {
+    /**
+     * 频道数据
+     */
+    channelData: PLVChannelData;
+    /**
+     * 是否允许子房间
+     */
+    allowChildRoom: boolean;
+    /**
+     * 是否已获取到子房间的状态
+     */
+    childRoomEnabledStatus?: PLVChildRoomEnabledStatus;
+    private loginRoomId?;
+    private tokenExpiredRetryCount;
+    private socketStatus;
+    /**
+     * 状态事件通知
+     */
+    eventNotify_socketStatus: IPLVEventNotify<EventType_SocketStatus>;
+    /**
+     * 数据事件通知
+     */
+    eventNotify_socketData: IPLVEventNotify;
+    private getTokenDisposable;
+    constructor(r183: PLVChannelData);
+    /**
+     * 登录socket
+     */
+    login(): Promise<void>;
+    /**
+     * 监听socket连接状态
+     * @param callback
+     * @param onTag
+     */
+    onStatus(callback: Function, q183?: string | Object): void;
+    /**
+     * 添加所需监听的socket事件
+     * @param onEvents
+     */
+    addOnEvent(n183: string[]): void;
+    /**
+     * 是否处于已连接状态
+     * @returns
+     */
+    connected(): boolean;
+    /**
+     * 断开
+     * @param noCallSocketClose
+     */
+    disconnect(m183?: boolean | undefined): void;
+    /**
+     * 销毁
+     * @param noCallSocketClose
+     */
+    destroy(l183?: boolean): void;
+    private loginRoom;
+    private onSocketIOStatus;
+    private attachListeners;
+    private onSocketIOData;
+    private processSocketData;
+    private getChatTokenConnect;
+    private connectSocket;
+    private callError;
+    private patchELog;
+}
+/**
+ * 子房间可用状态
+ */
+export declare class PLVChildRoomEnabledStatus {
+    childRoomEnabled?: boolean;
+    constructor(l182?: boolean);
+}
+/**
+ * socket连接状态
+ */
+export declare class PLVSocketStatusSup {
+    socketStatus: PLVSocketStatus;
+    error?: Error;
+    constructor(k182: PLVSocketStatus, error?: Error);
+}
+/**
+ * socket连接状态枚举
+ */
+export declare enum PLVSocketStatus {
+    /**
+     * 闲置
+     */
+    IDLE = 0,
+    /**
+     * 登录中
+     */
+    LOGGING = 1,
+    /**
+     * 登录成功
+     */
+    LOGIN_SUCCESS = 2,
+    /**
+     * 重连中
+     */
+    RECONNECTING = 3,
+    /**
+     * 重连成功
+     */
+    RECONNECT_SUCCESS = 4,
+    /**
+     * 登录失败
+     */
+    LOGIN_FAIL = 5,
+    /**
+     * 被踢出
+     */
+    BE_KICKED_OUT = 6,
+    /**
+     * 被拒
+     */
+    LOGIN_REFUSE = 7,
+    /**
+     * 已在其他地方登录
+     */
+    LOGIN_ELSEWHERE = 8
+}

package/src/main/ets/modules/socket/PLVSocketManager.js

@@ -0,0 +1,224 @@
+import { PLVCommonConstants, PLVDisposable, PLVEventNotify, PLVJSONUtils, PLVLogger, PLVSocketIO, PLVSocketIOStatus, PLVUtils } from '@polyvharmony/live-scenes-foundation';
+import { PLVLocalLoginEvent } from './model/PLVLocalLoginEvent';
+import { PLVSocketMessageEvent, PLVSocketOnEvent, SOCKET_ON_EVENT_ALL } from './model/PLVSocketEventConstants';
+import { apiPlvNetApi } from '../net/PLVApiPlvNetApi';
+import { eLogSender } from '../log/elog/PLVELogSender';
+import { PLVELogModuleName, PLVELogSocketBatchEvent } from '../log/elog/model/PLVELogModuleConstants';
+const TAG = '[PLVSocketManager]';
+const TOKEN_EXPIRED_RETRY_MAX_COUNT = 3;
+export class PLVSocketManager extends PLVSocketIO {
+    constructor(r183) {
+        super();
+        this.allowChildRoom = false;
+        this.tokenExpiredRetryCount = 0;
+        this.socketStatus = PLVSocketStatus.IDLE;
+        this.eventNotify_socketStatus = new PLVEventNotify(this);
+        this.eventNotify_socketData = new PLVEventNotify(this, false);
+        this.getTokenDisposable = new PLVDisposable();
+        this.channelData = r183;
+    }
+    async login() {
+        this.patchELog(PLVELogSocketBatchEvent.LOGGING, `allowChildRoom: ${this.allowChildRoom}`);
+        this.disconnect();
+        this.socketStatus = PLVSocketStatus.LOGGING;
+        this.eventNotify_socketStatus.emit('socket_status', new PLVSocketStatusSup(this.socketStatus));
+        this.childRoomEnabledStatus = undefined;
+        this.loginRoomId = this.channelData.loginChannelId;
+        if (!this.allowChildRoom) {
+            this.channelData.setupLoginRoomId(this.loginRoomId || '');
+        }
+        this.onSocketIOStatus();
+        await this.getChatTokenConnect();
+    }
+    onStatus(callback, q183) {
+        this.eventNotify_socketStatus.on('socket_status', callback, q183);
+    }
+    addOnEvent(n183) {
+        n183.forEach((value) => {
+            if (!SOCKET_ON_EVENT_ALL.includes(value)) {
+                SOCKET_ON_EVENT_ALL.push(value);
+                this.on(value, () => {
+                });
+                PLVLogger.info(TAG, `addOnEvent: ${value}`);
+            }
+        });
+        this.onSocketIOData();
+    }
+    connected() {
+        return super.connected() && (this.socketStatus == PLVSocketStatus.LOGIN_SUCCESS || this.socketStatus == PLVSocketStatus.RECONNECT_SUCCESS);
+    }
+    disconnect(m183) {
+        super.disconnect(m183);
+        this.getTokenDisposable.dispose();
+    }
+    destroy(l183) {
+        super.destroy(l183);
+        this.eventNotify_socketData.clear();
+        this.eventNotify_socketStatus.clear();
+        this.getTokenDisposable.dispose();
+    }
+    loginRoom(b183) {
+        const c183 = new PLVLocalLoginEvent();
+        c183.values = [this.channelData.viewerName || '', this.channelData.viewerAvatar || '', this.channelData.viewerId || ''];
+        c183.roomId = this.loginRoomId;
+        c183.channelId = this.channelData.loginChannelId;
+        if (this.channelData.linkmicId !== this.channelData.viewerId) {
+            c183.micId = this.channelData.linkmicId;
+        }
+        c183.type = this.channelData.viewerType;
+        c183.actor = this.channelData.viewerActor;
+        c183.param4 = this.channelData.param4;
+        c183.param5 = this.channelData.param5;
+        const data = PLVJSONUtils.safeStringify(c183);
+        PLVLogger.info(TAG, 'loginRoom data: ' + data);
+        this.emitSkipCheck(PLVSocketOnEvent.MESSAGE, data, (callback) => {
+            PLVLogger.info(TAG, 'loginRoom callback: ' + callback);
+            if (PLVUtils.validCallback(callback)) {
+                const e183 = PLVJSONUtils.safeParse(callback);
+                const f183 = PLVJSONUtils.safeStringify(e183?.message?.[0]);
+                const g183 = parseInt(f183.substring(0, 1));
+                const h183 = parseInt(f183.substring(1, 2));
+                const i183 = parseInt(f183.substring(2, 3));
+                const j183 = parseInt(f183.substring(3, 4));
+                const k183 = 2;
+                if (g183 == k183) {
+                    this.tokenExpiredRetryCount = 0;
+                    this.socketStatus = b183 == PLVSocketIOStatus.OPEN ? PLVSocketStatus.LOGIN_SUCCESS : PLVSocketStatus.RECONNECT_SUCCESS;
+                    this.eventNotify_socketStatus.emit('socket_status', new PLVSocketStatusSup(this.socketStatus));
+                    this.patchELog(this.socketStatus == PLVSocketStatus.LOGIN_SUCCESS ? PLVELogSocketBatchEvent.LOGIN_SUCCESS : PLVELogSocketBatchEvent.RECONNECT_SUCCESS);
+                }
+                else {
+                    const errorMsg = h183 == 0 ? `the room is illegal: ${callback}` :
+                        i183 == 0 ? `avatar/nickname is illegal: ${callback}` :
+                            j183 == 0 ? `has been kicked out of the room: ${callback}` :
+                                `param is illegal: ${callback}`;
+                    this.callError(new Error(errorMsg));
+                }
+            }
+            else {
+                this.callError(new Error('invalidCallback'));
+            }
+        });
+    }
+    onSocketIOStatus() {
+        this.onSocketIOStatusListener = (a183) => {
+            switch (a183) {
+                case PLVSocketIOStatus.OPEN:
+                case PLVSocketIOStatus.RECONNECT_SUCCESS:
+                    this.loginRoom(a183);
+                    break;
+                case PLVSocketIOStatus.RECONNECT:
+                    this.socketStatus = PLVSocketStatus.RECONNECTING;
+                    this.eventNotify_socketStatus.emit('socket_status', new PLVSocketStatusSup(this.socketStatus));
+                    this.patchELog(PLVELogSocketBatchEvent.RECONNECTING);
+                    break;
+                default: break;
+            }
+        };
+    }
+    attachListeners(w182) {
+        SOCKET_ON_EVENT_ALL.forEach((onEvent) => {
+            this.on(onEvent, () => {
+            });
+        });
+        w182();
+    }
+    onSocketIOData() {
+        this.on('any', (event) => {
+            const data = PLVJSONUtils.safeParse(event);
+            if (data?.eventName) {
+                const v182 = data?.message?.EVENT || '';
+                this.eventNotify_socketData.emit(data.eventName, PLVJSONUtils.safeStringify(data?.message), v182);
+                this.processSocketData(data.message, data.eventName, v182);
+            }
+        });
+    }
+    processSocketData(data, eventName, q182) {
+        if (PLVSocketOnEvent.MESSAGE === eventName) {
+            if (PLVSocketMessageEvent.TOKEN_EXPIRED === q182) {
+                setTimeout(() => {
+                    if (this.tokenExpiredRetryCount < TOKEN_EXPIRED_RETRY_MAX_COUNT) {
+                        this.disconnect();
+                        this.getChatTokenConnect();
+                        this.tokenExpiredRetryCount++;
+                    }
+                    else {
+                        this.callError(new Error('token expired'));
+                    }
+                }, PLVCommonConstants.DELAY_TIME_S);
+            }
+            else if (PLVSocketMessageEvent.KICK === q182) {
+                const r182 = data;
+                const s182 = r182['user'];
+                if (this.channelData.viewerId === s182?.userId) {
+                    this.socketStatus = PLVSocketStatus.BE_KICKED_OUT;
+                    this.eventNotify_socketStatus.emit('socket_status', new PLVSocketStatusSup(this.socketStatus));
+                }
+            }
+            else if (PLVSocketMessageEvent.LOGIN_REFUSE === q182) {
+                this.socketStatus = PLVSocketStatus.LOGIN_REFUSE;
+                this.eventNotify_socketStatus.emit('socket_status', new PLVSocketStatusSup(this.socketStatus));
+            }
+            else if (PLVSocketMessageEvent.RE_LOGIN === q182) {
+                this.socketStatus = PLVSocketStatus.LOGIN_ELSEWHERE;
+                this.eventNotify_socketStatus.emit('socket_status', new PLVSocketStatusSup(this.socketStatus));
+            }
+        }
+    }
+    async getChatTokenConnect() {
+        const n182 = await PLVUtils.retryPromise(Infinity, 3000, apiPlvNetApi(this.channelData).getChatToken(this.channelData.loginChannelId, this.channelData.appId, this.channelData.appSecret, this.channelData.viewerId, this.channelData.viewerType), this.getTokenDisposable = new PLVDisposable()).catch((err) => {
+            this.callError(err);
+            return Promise.reject(err);
+        });
+        const o182 = n182.data.data?.isChildRoomEnabled();
+        this.childRoomEnabledStatus = new PLVChildRoomEnabledStatus(o182);
+        this.loginRoomId = this.allowChildRoom && o182 && n182.data.data?.roomId ? n182.data.data?.roomId : this.loginRoomId;
+        this.channelData.setupLoginRoomId(this.loginRoomId || '');
+        this.connectSocket(n182.data.data?.token);
+    }
+    connectSocket(token) {
+        const uri = this.channelData.chatDomain?.getHttpChatDomain();
+        const query = `&version=2.0&token=${token}`;
+        this.attachListeners(() => {
+            this.onSocketIOData();
+        });
+        this.connectWithQuery(uri || '', query, this.channelData.ua());
+    }
+    callError(error) {
+        const errMsg = PLVLogger.printError(TAG, 'login error', error);
+        this.patchELog(PLVELogSocketBatchEvent.LOGIN_FAIL, `error: ${errMsg}, data: ${this.channelData.string()}`);
+        this.socketStatus = PLVSocketStatus.LOGIN_FAIL;
+        this.eventNotify_socketStatus.emit('socket_status', new PLVSocketStatusSup(this.socketStatus, error));
+    }
+    patchELog(event, info) {
+        eLogSender(this.channelData)
+            .batch({
+            module: PLVELogModuleName.SOCKET,
+            event: event,
+            information: info
+        });
+    }
+}
+export class PLVChildRoomEnabledStatus {
+    constructor(l182) {
+        this.childRoomEnabled = l182;
+    }
+}
+export class PLVSocketStatusSup {
+    constructor(k182, error) {
+        this.socketStatus = k182;
+        this.error = error;
+    }
+}
+export var PLVSocketStatus;
+(function (j182) {
+    j182[j182["IDLE"] = 0] = "IDLE";
+    j182[j182["LOGGING"] = 1] = "LOGGING";
+    j182[j182["LOGIN_SUCCESS"] = 2] = "LOGIN_SUCCESS";
+    j182[j182["RECONNECTING"] = 3] = "RECONNECTING";
+    j182[j182["RECONNECT_SUCCESS"] = 4] = "RECONNECT_SUCCESS";
+    j182[j182["LOGIN_FAIL"] = 5] = "LOGIN_FAIL";
+    j182[j182["BE_KICKED_OUT"] = 6] = "BE_KICKED_OUT";
+    j182[j182["LOGIN_REFUSE"] = 7] = "LOGIN_REFUSE";
+    j182[j182["LOGIN_ELSEWHERE"] = 8] = "LOGIN_ELSEWHERE";
+})(PLVSocketStatus || (PLVSocketStatus = {}));

package/src/main/ets/modules/socket/PLVSocketMediator.d.ets

@@ -0,0 +1,10 @@
+import { PLVSocketManager } from './PLVSocketManager';
+export declare class PLVSocketMediator {
+    private socketManager;
+    constructor(w183: PLVSocketManager);
+    onData(event: string, callback: Function, v183?: string | Object): void;
+    offData(event: string, callback: Function, u183?: string | Object): void;
+    emit(name: string, message: ESObject, t183?: (emit_callback_json: string) => void): boolean;
+    addOnEvent(s183: string[]): void;
+    connected(): boolean;
+}

package/src/main/ets/modules/socket/PLVSocketMediator.js

@@ -0,0 +1,20 @@
+export class PLVSocketMediator {
+    constructor(w183) {
+        this.socketManager = w183;
+    }
+    onData(event, callback, v183) {
+        this.socketManager.eventNotify_socketData.on(event, callback, v183);
+    }
+    offData(event, callback, u183) {
+        this.socketManager.eventNotify_socketData.off(event, callback, u183);
+    }
+    emit(name, message, t183) {
+        return this.socketManager.emit(name, message, t183);
+    }
+    addOnEvent(s183) {
+        this.socketManager.addOnEvent(s183);
+    }
+    connected() {
+        return this.socketManager.connected();
+    }
+}

package/src/main/ets/modules/socket/model/PLVChatTokenVO.d.ets

@@ -0,0 +1,7 @@
+export declare class PLVChatTokenVO {
+    mediaChannelKey?: string;
+    token?: string;
+    childRoomEnabled?: string;
+    roomId?: string;
+    isChildRoomEnabled(): boolean;
+}

package/src/main/ets/modules/socket/model/PLVChatTokenVO.js

@@ -0,0 +1,5 @@
+export class PLVChatTokenVO {
+    isChildRoomEnabled() {
+        return "Y" === this.childRoomEnabled;
+    }
+}

package/src/main/ets/modules/socket/model/PLVKickEvent.d.ets

@@ -0,0 +1,6 @@
+import { PLVSocketUserBean } from './PLVSocketUserBean';
+export declare class PLVKickEvent {
+    static readonly EVENT = "KICK";
+    channelId?: string;
+    user?: PLVSocketUserBean;
+}

package/src/main/ets/modules/socket/model/PLVKickEvent.js

@@ -0,0 +1,4 @@
+import { PLVSocketMessageEvent } from './PLVSocketEventConstants';
+export class PLVKickEvent {
+}
+PLVKickEvent.EVENT = PLVSocketMessageEvent.KICK;

package/src/main/ets/modules/socket/model/PLVLocalLoginEvent.d.ets

@@ -0,0 +1,12 @@
+export declare class PLVLocalLoginEvent {
+    EVENT: string;
+    values?: string[];
+    micId?: string;
+    roomId?: string;
+    channelId?: string;
+    type?: string;
+    actor?: string;
+    getCup: number;
+    param4?: string;
+    param5?: string;
+}

package/src/main/ets/modules/socket/model/PLVLocalLoginEvent.js

@@ -0,0 +1,7 @@
+import { PLVSocketMessageEvent } from './PLVSocketEventConstants';
+export class PLVLocalLoginEvent {
+    constructor() {
+        this.EVENT = PLVSocketMessageEvent.LOGIN;
+        this.getCup = 1;
+    }
+}