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

package/src/main/ets/modules/chatroom/PLVChatroomManager.d.ets

@@ -0,0 +1,219 @@
+import { IPLVEventNotify, PLVCallback, PLVJSONObject, PLVStateData } from '@polyvharmony/live-scenes-foundation';
+import { PLVBaseModule } from '../../common/PLVBaseModule';
+import { PLVSocketMediator } from '../socket/PLVSocketMediator';
+import { PLVLocalSpeakEvent } from './model/PLVLocalSpeakEvent';
+import { BusinessError } from '@kit.BasicServicesKit';
+import { PLVChatQuoteDataBean } from './model/PLVChatQuoteDataBean';
+import { PLVLocalQuizEvent } from './model/PLVLocalQuizEvent';
+import { PLVHistoryQuizListVO } from './model/PLVHistroyQuizListVO';
+import { PLVEmotionImageBean, PLVEmotionImagesVO } from './model/PLVEmotionImagesVO';
+import { PLVChannelData } from '../../common/PLVChannelData';
+import { PLVToTopEvent } from './model/PLVToTopEvent';
+import { PLVEmotionEvent } from './model/PLVEmotionEvent';
+import { PLVChatImgEvent } from './model/PLVChatImgEvent';
+/**
+ * 事件类型，可以使用{@link PLVChatroomManager#eventNotify}监听对应的事件
+ */
+export type EventType = 'restrict_max_viewer' | 'close_room' | 'online_user_number' | 'focus_mode_open' | 'likes_count' | 'emotions' | 'to_top';
+/**
+ * 聊天室管理器
+ */
+export declare class PLVChatroomManager extends PLVBaseModule {
+    /**
+     * 在线人数
+     */
+    onlineUserNumber: number;
+    /**
+     * 是否打开专注模式
+     */
+    isFocusModeOpen: boolean;
+    /**
+     * 是否已经关闭房间
+     */
+    isCloseRoom: boolean;
+    /**
+     * 登录成功前是否已收到closeRoom事件
+     */
+    isReceiveCloseRoomEvent: boolean;
+    /**
+     * 是否被禁言
+     */
+    isBanIp: boolean;
+    /**
+     * 点赞数
+     */
+    likesCount: number;
+    /**
+     * 是否可以回复
+     */
+    quoteReplyEnabled: boolean;
+    /**
+     * 个性表情数据
+     */
+    emotions?: PLVEmotionImageBean[];
+    /**
+     * 评论上墙数据
+     */
+    toTopData: PLVStateData<PLVToTopEvent>;
+    private willSendLikesCount;
+    private sendLikesCountTimerId?;
+    private socketMediator;
+    /**
+     * 事件通知
+     */
+    eventNotify: IPLVEventNotify<EventType>;
+    constructor(d124: PLVChannelData, e124: PLVSocketMediator);
+    /**
+     * 监听socket通道的聊天事件
+     * @param event
+     * @param callback
+     * @param onTag
+     */
+    onData(event: string, callback: Function, c124?: string | Object): void;
+    /**
+     * 是否处于已连接状态
+     * @returns
+     */
+    connected(): boolean;
+    /**
+     * 设置专注模式值
+     * @param isFocusModeOpen
+     */
+    setupFocusMode(b124: boolean): void;
+    /**
+     * 设置关闭房间值
+     * @param isCloseRoom
+     */
+    setupCloseRoom(a124: boolean): void;
+    /**
+     * 设置在线人数值
+     * @param onlineUserNumber
+     */
+    setupOnlineUserNumber(z123: number): void;
+    /**
+     * 设置点赞数
+     * @param added
+     */
+    setupLikesCount(x123: number): void;
+    /**
+     * 设置评论上墙数据，为undefined时为下墙
+     * @param toTopEvent
+     */
+    setupToTopEvent(v123?: PLVToTopEvent): void;
+    /**
+     * 发言
+     * @param message
+     * @param reply
+     * @param source
+     * @returns
+     */
+    speak(message?: string, reply?: PLVChatQuoteDataBean, source?: string): Promise<PLVLocalSpeakEvent>;
+    /**
+     * 提问
+     * @param message
+     * @returns
+     */
+    quiz(message?: string): Promise<PLVLocalQuizEvent>;
+    sendEmotionImage(e123: PLVEmotionImageBean): Promise<PLVEmotionEvent>;
+    sendLocalImage(uri: string): Promise<PLVChatImgEvent>;
+    /**
+     * 点赞
+     * @param addedCount
+     */
+    likes(p122?: number): void;
+    /**
+     * 讲师 切换全体禁言
+     */
+    switchCloseRoom(): void;
+    /**
+     * 获取超长消息
+     * @param msgId
+     * @returns
+     */
+    getOverLengthFullMessage(h122: string): Promise<string>;
+    /**
+     * 获取提问历史记录
+     * @param page
+     * @param size
+     * @returns
+     */
+    getQuizHistoryList(b122: number, size: number): Promise<PLVHistoryQuizListVO>;
+    /**
+     * 获取聊天历史记录
+     * @param size
+     * @param timestamp
+     * @param index
+     * @returns
+     */
+    getChatHistoryList(size: number, timestamp?: number, index?: number): Promise<PLVJSONObject[]>;
+    /**
+     * 解析聊天历史记录数据
+     * @param value
+     * @param syncParsedCallback
+     */
+    parseChatHistoryData(value: PLVJSONObject, k121: PLVCallback<PLVJSONObject, void>): void;
+    /**
+     * 获取个性表情数据
+     * @param page
+     * @param size
+     * @returns
+     */
+    getEmotionImages(e121?: number, size?: number): Promise<PLVEmotionImagesVO>;
+    /**
+     * 销毁
+     */
+    destroy(): void;
+    private init;
+    private isSpecialType;
+    private emitMessage;
+    private checkDataStatus;
+    private sendLikesBySocket;
+    private sendLikesByApi;
+    private compressLocalImage;
+    private compressLocalImageOnce;
+}
+/**
+ * 聊天室错误码枚举
+ */
+export declare enum PLVChatroomErrorCode {
+    /**
+     * 发言信息为空
+     */
+    MESSAGE_IS_NULL = -1,
+    /**
+     * 房间已关闭
+     */
+    ROOM_IS_CLOSED = -2,
+    /**
+     * 未处于已连接状态
+     */
+    ROOM_NOT_CONNECTED = -3,
+    /**
+     * 用户已被禁言
+     */
+    USER_IS_BANNED = -4,
+    /**
+     * 聊天发送的图片过大
+     */
+    CHAT_IMAGE_TOO_LARGE = -101,
+    /**
+     * 聊天室上传图片失败
+     */
+    CHAT_IMAGE_UPLOAD_FAIL = -102
+}
+/**
+ * 聊天室错误码
+ */
+export declare class PLVChatroomError extends Error implements BusinessError<object | undefined> {
+    static readonly MESSAGE_IS_NULL: PLVChatroomError;
+    static readonly ROOM_IS_CLOSED: PLVChatroomError;
+    static readonly ROOM_NOT_CONNECTED: PLVChatroomError;
+    static readonly USER_IS_BANNED: PLVChatroomError;
+    static readonly CHAT_IMAGE_TOO_LARGE: PLVChatroomError;
+    static readonly CHAT_IMAGE_UPLOAD_FAIL: PLVChatroomError;
+    message: string;
+    code: number;
+    data?: object | undefined;
+    constructor(message: string, code: number);
+    bindData(data?: object): this;
+}

package/src/main/ets/modules/chatroom/PLVChatroomManager.js

@@ -0,0 +1,480 @@
+import { PLVEventNotify, PLVJSONUtils, PLVLogger, PLVStateData, PLVTextUtils, PLVUtils } from '@polyvharmony/live-scenes-foundation';
+import { PLVBaseModule } from '../../common/PLVBaseModule';
+import { PLVSocketMessageEvent, PLVSocketOnEvent, PLVSocketSpeakEvent, SOCKET_ON_EVENT_ALL } from '../socket/model/PLVSocketEventConstants';
+import { PLVChatroomDataHandlerFactory } from './handler/PLVChatroomDataHandlerFactory';
+import { PLVLocalSpeakEvent } from './model/PLVLocalSpeakEvent';
+import { PLVSocketUserBean } from '../socket/model/PLVSocketUserBean';
+import { PLVLocalQuizEvent } from './model/PLVLocalQuizEvent';
+import { PLVUserType } from '../socket/model/PLVUserType';
+import { PLVHistoryChatImgEvent } from './model/PLVHistoryChatImgEvent';
+import { PLVRewardEvent } from './model/PLVRewardEvent';
+import { PLVHistoryFileShareEvent } from './model/PLVHistoryFileShareEvent';
+import { PLVHistorySpeakEvent } from './model/PLVHistorySpeakEvent';
+import { PLVHistoryRedPaperEvent } from '../interact/redpack/model/PLVHistoryRedPaperEvent';
+import { apiChatPlvNetApi } from '../net/PLVApiChatPlvNetApi';
+import { apiPlvNetApi } from '../net/PLVApiPlvNetApi';
+import { PLVGetFullMessageAckBean } from './model/PLVGetFullMessageAckBean';
+import { bytes, encodeToJson, extendNumber, extendString, Files, md5, megaBytes, Promises, random, requireNotNull } from '@polyvharmony/media-player-sdk';
+import { PLVEmotionEvent } from './model/PLVEmotionEvent';
+import fs from "@ohos.file.fs";
+import image from "@ohos.multimedia.image";
+import { apiPlvLiveImagesApi } from '../net/PLVLiveImagesVideoNetApi';
+import { PLVChatImgEvent } from './model/PLVChatImgEvent';
+import { PLVChatImgContentBean, PLVSizeBean } from './model/PLVChatImgContentBean';
+const TAG = '[PLVChatroomManager]';
+const CHAT_ROOM_IMAGE_MAX_ALLOW_SIZE = megaBytes(2).toBytes();
+export class PLVChatroomManager extends PLVBaseModule {
+    constructor(d124, e124) {
+        super(d124);
+        this.onlineUserNumber = 0;
+        this.isFocusModeOpen = false;
+        this.isCloseRoom = false;
+        this.isReceiveCloseRoomEvent = false;
+        this.isBanIp = false;
+        this.likesCount = 0;
+        this.quoteReplyEnabled = false;
+        this.toTopData = new PLVStateData();
+        this.willSendLikesCount = 0;
+        this.eventNotify = new PLVEventNotify(this);
+        this.socketMediator = e124;
+        this.init();
+    }
+    onData(event, callback, c124) {
+        this.socketMediator.onData(event, callback, c124 || this);
+    }
+    connected() {
+        return this.socketMediator.connected();
+    }
+    setupFocusMode(b124) {
+        this.eventNotify.emit('focus_mode_open', b124);
+        this.isFocusModeOpen = b124;
+    }
+    setupCloseRoom(a124) {
+        this.eventNotify.emit('close_room', a124);
+        this.isCloseRoom = a124;
+    }
+    setupOnlineUserNumber(z123) {
+        this.eventNotify.emit('online_user_number', z123);
+        this.onlineUserNumber = z123;
+    }
+    setupLikesCount(x123) {
+        const y123 = this.likesCount + x123;
+        this.eventNotify.emit('likes_count', y123);
+        this.likesCount = y123;
+    }
+    setupToTopEvent(v123) {
+        const w123 = this.toTopData.copyValue(v123);
+        this.eventNotify.emit('to_top', w123);
+        this.toTopData = w123;
+    }
+    speak(message, reply, source) {
+        return PLVUtils.safePromise(async (p123, q123) => {
+            const r123 = new PLVLocalSpeakEvent();
+            r123.speakMessage = message;
+            r123.parsedData = PLVTextUtils.parseString(message);
+            r123.quote = reply;
+            r123.source = source;
+            r123.userId = this.channelData.viewerId;
+            r123.nick = this.channelData.viewerName;
+            r123.time = Date.now();
+            if (this.checkDataStatus(q123, message, r123, true)) {
+                const data = PLVJSONUtils.safeStringify({
+                    'EVENT': PLVSocketMessageEvent.SPEAK,
+                    'values': [message],
+                    'accountId': this.channelData.userId,
+                    'sessionId': this.channelData.sessionId,
+                    'roomId': await this.channelData.loginRoomIdPromise.get(),
+                    'needIdCallback': true,
+                    'quoteId': reply?.messageId,
+                    'source': source
+                });
+                this.emitMessage(PLVSocketOnEvent.MESSAGE, data, (callback) => {
+                    const t123 = PLVJSONUtils.safeParse(callback);
+                    r123.id = t123?.message?.[0];
+                    if (t123?.message?.[1]) {
+                        const u123 = t123?.message?.[1];
+                        if (u123 && u123['content']) {
+                            r123.speakMessage = u123['content'];
+                            r123.parsedData = PLVTextUtils.parseString(r123.speakMessage);
+                        }
+                    }
+                    p123(r123);
+                    PLVLogger.info(TAG, 'speak success');
+                });
+            }
+        });
+    }
+    quiz(message) {
+        return PLVUtils.safePromise(async (k123, l123) => {
+            if (this.checkDataStatus(l123, message, false, false)) {
+                const data = PLVJSONUtils.safeStringify({
+                    'EVENT': PLVSocketMessageEvent.S_QUESTION,
+                    'content': message,
+                    'user': {
+                        'actor': PLVUserType.USERTYPE_STUDENT,
+                        'nick': this.channelData.viewerName,
+                        'pic': this.channelData.viewerAvatar,
+                        'userId': this.channelData.viewerId,
+                        'userType': this.channelData.viewerType
+                    },
+                    'roomId': await this.channelData.loginRoomIdPromise.get()
+                });
+                this.emitMessage(PLVSocketOnEvent.MESSAGE, data, () => {
+                    const n123 = new PLVLocalQuizEvent();
+                    n123.quizMessage = message;
+                    n123.parsedData = PLVTextUtils.parseString(message);
+                    n123.time = Date.now();
+                    k123(n123);
+                    PLVLogger.info(TAG, 'quiz success');
+                });
+            }
+        });
+    }
+    async sendEmotionImage(e123) {
+        const result = Promises.withResolvers();
+        const event = new PLVEmotionEvent();
+        event.id = e123.id;
+        const f123 = new PLVSocketUserBean();
+        f123.setActor(this.channelData.viewerActor);
+        f123.channelId = this.channelData.loginChannelId;
+        f123.nick = this.channelData.viewerName;
+        f123.setPic(this.channelData.viewerAvatar);
+        f123.roomId = await this.channelData.loginRoomIdPromise.get();
+        f123.userId = this.channelData.viewerId;
+        f123.userType = this.channelData.viewerType;
+        event.user = f123;
+        event.time = Date.now();
+        if (this.checkDataStatus(result.reject, e123.url, event, true)) {
+            const g123 = new Object({
+                id: e123.id
+            });
+            this.emitMessage(PLVSocketOnEvent.EMOTION, PLVJSONUtils.safeStringify(g123), (callback) => {
+                const i123 = PLVJSONUtils.safeParse(callback);
+                event.messageId = i123?.message?.[0];
+                result.resolve(event);
+            });
+        }
+        return result.promise;
+    }
+    async sendLocalImage(uri) {
+        const result = Promises.withResolvers();
+        const r122 = await this.compressLocalImage(uri);
+        if (await Files.bytesLength(r122) > CHAT_ROOM_IMAGE_MAX_ALLOW_SIZE) {
+            throw PLVChatroomError.CHAT_IMAGE_TOO_LARGE;
+        }
+        const fileName = Files.fileName(r122);
+        const s122 = extendString(fileName).substringBeforeLast_ext(".");
+        const t122 = (await apiPlvNetApi(this.channelData).getImageUploadToken(requireNotNull(this.channelData.loginChannelId), requireNotNull(this.channelData.appId), requireNotNull(this.channelData.appSecret))).data.data;
+        requireNotNull(t122, () => PLVChatroomError.CHAT_IMAGE_UPLOAD_FAIL);
+        const u122 = image.createImageSource(r122);
+        const imageSize = (await u122.getImageInfo()).size;
+        const v122 = await fs.open(r122, fs.OpenMode.CREATE | fs.OpenMode.READ_WRITE);
+        const w122 = (await fs.stat(v122.fd)).size;
+        const x122 = new ArrayBuffer(w122);
+        await fs.read(v122.fd, x122);
+        await fs.close(v122);
+        const y122 = await apiPlvLiveImagesApi(this.channelData).uploadLiveImages(fileName, `${t122?.dir}${fileName}`, requireNotNull(t122?.policy), requireNotNull(t122?.accessid), requireNotNull(t122?.signature), requireNotNull(t122?.encodedCallback), x122);
+        const event = new PLVChatImgEvent();
+        const z122 = new PLVSocketUserBean();
+        z122.setActor(this.channelData.viewerActor);
+        z122.channelId = this.channelData.loginChannelId;
+        z122.nick = this.channelData.viewerName;
+        z122.setPic(this.channelData.viewerAvatar);
+        z122.roomId = await this.channelData.loginRoomIdPromise.get();
+        z122.userId = this.channelData.viewerId;
+        z122.userType = this.channelData.viewerType;
+        event.user = z122;
+        event.time = Date.now();
+        const value = new PLVChatImgContentBean();
+        value.id = s122;
+        const size = new PLVSizeBean();
+        size.width = imageSize.width;
+        size.height = imageSize.height;
+        value.size = size;
+        value.status = "upLoadingSuccess";
+        value.type = "chatImg";
+        value.uploadImgUrl = y122;
+        event.values = [value];
+        if (this.checkDataStatus(result.reject, y122, event, true)) {
+            const b123 = new Object({
+                EVENT: PLVChatImgEvent.EVENT,
+                accountId: this.channelData.userId,
+                roomId: await this.channelData.loginRoomIdPromise.get(),
+                sessionId: this.channelData.sessionId,
+                values: [value]
+            });
+            this.emitMessage(PLVSocketOnEvent.MESSAGE, PLVJSONUtils.safeStringify(b123), (callback) => {
+                const d123 = PLVJSONUtils.safeParse(callback);
+                event.id = d123?.message?.[0];
+                result.resolve(event);
+            });
+        }
+        return result.promise;
+    }
+    likes(p122 = 1) {
+        this.setupLikesCount(p122);
+        if (this.willSendLikesCount == 0) {
+            this.willSendLikesCount = Math.min(200, this.willSendLikesCount + p122);
+            this.sendLikesCountTimerId = setTimeout(async () => {
+                this.sendLikesBySocket(this.willSendLikesCount);
+                this.sendLikesByApi(this.willSendLikesCount);
+                this.willSendLikesCount = 0;
+            }, 5000);
+        }
+        else {
+            this.willSendLikesCount = Math.min(200, this.willSendLikesCount + p122);
+        }
+    }
+    switchCloseRoom() {
+        if (this.channelData.viewerType !== PLVUserType.USERTYPE_TEACHER) {
+            return;
+        }
+        const o122 = this.channelData.loginChannelId ?? "";
+        const data = encodeToJson({
+            EVENT: PLVSocketMessageEvent.CLOSE_ROOM,
+            roomId: o122,
+            sign: md5(`polyv_room_sign${o122}`)
+        });
+        this.emitMessage(PLVSocketOnEvent.MESSAGE, data);
+    }
+    getOverLengthFullMessage(h122) {
+        return PLVUtils.safePromise((j122, k122) => {
+            const data = PLVJSONUtils.safeStringify({
+                'EVENT': PLVSocketSpeakEvent.GET_FULL_MESSAGE,
+                "id": h122
+            });
+            this.emitMessage(PLVSocketOnEvent.SPEAK, data, (callback) => {
+                const m122 = PLVJSONUtils.safeParse(callback);
+                if (m122?.message?.[0]) {
+                    const n122 = PLVJSONUtils.bean2Bean(new PLVGetFullMessageAckBean(), m122.message[0]);
+                    if (n122?.isValid()) {
+                        j122(n122.data.content);
+                        PLVLogger.info(TAG, `getOverLengthFullMessage success`);
+                    }
+                    else {
+                        PLVLogger.info(TAG, `getOverLengthFullMessage error: ${h122}, ${PLVJSONUtils.safeStringify(n122)}`);
+                    }
+                }
+            });
+        });
+    }
+    getQuizHistoryList(b122, size) {
+        return PLVUtils.safePromise(async (d122, e122) => {
+            const f122 = await apiChatPlvNetApi(this.channelData)
+                .getQuizHistoryList(this.channelData.appId, this.channelData.appSecret, this.channelData.viewerId, this.channelData.viewerType, await this.channelData.loginRoomIdPromise.get(), b122, size)
+                .catch((err) => {
+                return Promise.reject(err.log(TAG, 'getQuizHistoryList error'));
+            });
+            d122(f122.data.data);
+        });
+    }
+    getChatHistoryList(size, timestamp, index) {
+        return PLVUtils.safePromise(async (x121, y121) => {
+            const z121 = await apiChatPlvNetApi(this.channelData)
+                .getChatHistoryList(this.channelData.appId, this.channelData.appSecret, this.channelData.viewerId, this.channelData.viewerType, await this.channelData.loginRoomIdPromise.get(), timestamp, index, size)
+                .catch((err) => {
+                return Promise.reject(err.log(TAG, 'getChatHistoryList error'));
+            });
+            const data = z121.data['data'];
+            x121(data['list']);
+        });
+    }
+    parseChatHistoryData(value, k121) {
+        const l121 = {};
+        const m121 = value;
+        const n121 = m121['msgType'];
+        if (n121) {
+            return;
+        }
+        const o121 = m121['time'];
+        l121['time'] = o121;
+        const p121 = m121['msgSource'];
+        const q121 = m121['user'];
+        const content = m121['content'];
+        if (p121) {
+            if ('chatImg' == p121) {
+                const v121 = PLVJSONUtils.toFillData(new PLVHistoryChatImgEvent(), m121);
+                l121['data'] = v121;
+            }
+            else if ('reward' == p121) {
+                const u121 = PLVJSONUtils.toFillData(new PLVRewardEvent(), m121);
+                l121['data'] = u121;
+            }
+            else if ('file' == p121) {
+                const t121 = PLVJSONUtils.toFillData(new PLVHistoryFileShareEvent(), m121);
+                l121['data'] = t121;
+            }
+            else if ('redpaper' == p121) {
+                const s121 = PLVJSONUtils.toFillData(new PLVHistoryRedPaperEvent(), m121);
+                if (s121 && s121.isSupportType()) {
+                    l121['data'] = s121;
+                }
+            }
+        }
+        else if (q121) {
+            const uid = q121['uid'];
+            if ('2' == uid || typeof content === 'object') {
+                return;
+            }
+            const r121 = PLVJSONUtils.toFillData(new PLVHistorySpeakEvent(), m121);
+            l121['data'] = r121;
+        }
+        k121(l121);
+    }
+    getEmotionImages(e121 = 1, size = 100) {
+        return PLVUtils.safePromise(async (g121, h121) => {
+            const i121 = await apiChatPlvNetApi(this.channelData)
+                .getEmotionImages(this.channelData.loginChannelId, this.channelData.userId, e121, size)
+                .catch((err) => {
+                return Promise.reject(err.log(TAG, 'getEmotionImages error'));
+            });
+            g121(i121.data.data);
+            this.eventNotify.emit('emotions', ...i121.data.data?.list);
+            this.emotions = i121.data.data?.list;
+        });
+    }
+    destroy() {
+        this.eventNotify.clear();
+        clearTimeout(this.sendLikesCountTimerId);
+    }
+    async init() {
+        this.likesCount = (await this.channelData.initializedPromise.get()).liveDetail?.likes || 0;
+        this.quoteReplyEnabled = (await this.channelData.initializedPromise.get()).liveDetail?.quoteReplyEnabled === 'Y' || PLVSocketUserBean.isSpecialType(this.channelData.viewerType);
+        SOCKET_ON_EVENT_ALL.forEach((value) => {
+            this.onData(value, (data, event) => {
+                const d121 = PLVChatroomDataHandlerFactory.getMessageHandler(this, value, event);
+                d121?.handle(data);
+            }, this);
+        });
+    }
+    isSpecialType() {
+        return PLVSocketUserBean.isSpecialType(this.channelData.viewerType);
+    }
+    emitMessage(name, message, a121) {
+        return this.socketMediator.emit(name, message, a121);
+    }
+    checkDataStatus(x120, message, y120, z120) {
+        if (!this.connected()) {
+            x120(PLVChatroomError.ROOM_NOT_CONNECTED);
+            return false;
+        }
+        if (z120 && this.isCloseRoom && !this.isSpecialType()) {
+            x120(PLVChatroomError.ROOM_IS_CLOSED);
+            return false;
+        }
+        if (y120 && this.isBanIp) {
+            x120(PLVChatroomError.USER_IS_BANNED.bindData(y120));
+            return false;
+        }
+        if (!message) {
+            x120(PLVChatroomError.MESSAGE_IS_NULL);
+            return false;
+        }
+        return true;
+    }
+    async sendLikesBySocket(v120) {
+        const data = PLVJSONUtils.safeStringify({
+            'EVENT': PLVSocketMessageEvent.LIKES,
+            'nick': this.channelData.viewerName,
+            'count': v120,
+            'roomId': await this.channelData.loginRoomIdPromise.get(),
+            'userId': this.channelData.viewerId,
+            'sessionId': this.channelData.sessionId
+        });
+        this.emitMessage(PLVSocketOnEvent.MESSAGE, data, () => {
+            PLVLogger.info(TAG, 'sendLikesBySocket success');
+        });
+    }
+    sendLikesByApi(p120) {
+        return PLVUtils.safePromise(async (r120, s120) => {
+            const t120 = await apiPlvNetApi(this.channelData).sendLikes(this.channelData.loginChannelId, this.channelData.appId, this.channelData.appSecret, this.channelData.viewerId, p120).catch((err) => {
+                return Promise.reject(err.log(TAG, 'sendLikesByApi error'));
+            });
+            r120(t120.data);
+            PLVLogger.info(TAG, `sendLikesByApi success`);
+        });
+    }
+    async compressLocalImage(source) {
+        const j120 = await fs.open(source);
+        const k120 = `${getContext().cacheDir}/chatImage/chat_img_Harmony_${Date.now()}_${random(0, 1e7)}.jpg`;
+        await Files.deleteRecursively(k120);
+        await Files.mkdirs(Files.parentFile(k120));
+        await fs.copyFile(j120.fd, k120);
+        await fs.close(j120);
+        let l120 = k120;
+        let m120 = await Files.bytesLength(l120);
+        let n120 = 100;
+        if (m120 < CHAT_ROOM_IMAGE_MAX_ALLOW_SIZE) {
+            const fileName = Files.fileName(l120);
+            if (fileName.toLowerCase().endsWith("jpg") || fileName.toLowerCase().endsWith("jpeg")) {
+                return l120;
+            }
+        }
+        l120 = await this.compressLocalImageOnce(k120, n120);
+        m120 = await Files.bytesLength(l120);
+        if (m120 < CHAT_ROOM_IMAGE_MAX_ALLOW_SIZE) {
+            return l120;
+        }
+        const o120 = bytes(m120).toKBs();
+        if (o120 >= 19000) {
+            n120 = 20;
+        }
+        else {
+            n120 = extendNumber(106.847 - (6.188 * o120) / (1800 - 0.091 * o120))
+                .coerceIn_ext(20, 100);
+        }
+        await Files.deleteRecursively(l120);
+        l120 = await this.compressLocalImageOnce(k120, n120);
+        m120 = await Files.bytesLength(l120);
+        if (m120 < CHAT_ROOM_IMAGE_MAX_ALLOW_SIZE) {
+            return l120;
+        }
+        if (n120 <= 20) {
+            return l120;
+        }
+        n120 = 20;
+        await Files.deleteRecursively(l120);
+        l120 = await this.compressLocalImageOnce(k120, n120);
+        return l120;
+    }
+    async compressLocalImageOnce(source, quality) {
+        const g120 = image.createImageSource(source);
+        const h120 = `${getContext().cacheDir}/chatImage/Htemp_${Date.now()}_${random(0, 1e7)}.jpg`;
+        await Files.deleteRecursively(h120);
+        const outFile = await fs.open(h120, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+        const i120 = image.createImagePacker();
+        await i120.packToFile(g120, outFile.fd, {
+            format: "image/jpeg",
+            quality: quality
+        });
+        await i120.release();
+        await fs.close(outFile);
+        return h120;
+    }
+}
+export var PLVChatroomErrorCode;
+(function (f120) {
+    f120[f120["MESSAGE_IS_NULL"] = -1] = "MESSAGE_IS_NULL";
+    f120[f120["ROOM_IS_CLOSED"] = -2] = "ROOM_IS_CLOSED";
+    f120[f120["ROOM_NOT_CONNECTED"] = -3] = "ROOM_NOT_CONNECTED";
+    f120[f120["USER_IS_BANNED"] = -4] = "USER_IS_BANNED";
+    f120[f120["CHAT_IMAGE_TOO_LARGE"] = -101] = "CHAT_IMAGE_TOO_LARGE";
+    f120[f120["CHAT_IMAGE_UPLOAD_FAIL"] = -102] = "CHAT_IMAGE_UPLOAD_FAIL";
+})(PLVChatroomErrorCode || (PLVChatroomErrorCode = {}));
+export class PLVChatroomError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.message = message;
+        this.code = code;
+    }
+    bindData(data) {
+        this.data = data;
+        return this;
+    }
+}
+PLVChatroomError.MESSAGE_IS_NULL = new PLVChatroomError('message is null', PLVChatroomErrorCode.MESSAGE_IS_NULL);
+PLVChatroomError.ROOM_IS_CLOSED = new PLVChatroomError('room is closed', PLVChatroomErrorCode.ROOM_IS_CLOSED);
+PLVChatroomError.ROOM_NOT_CONNECTED = new PLVChatroomError('room not connected', PLVChatroomErrorCode.ROOM_NOT_CONNECTED);
+PLVChatroomError.USER_IS_BANNED = new PLVChatroomError('user is banned', PLVChatroomErrorCode.USER_IS_BANNED);
+PLVChatroomError.CHAT_IMAGE_TOO_LARGE = new PLVChatroomError('chat image is too large', PLVChatroomErrorCode.CHAT_IMAGE_TOO_LARGE);
+PLVChatroomError.CHAT_IMAGE_UPLOAD_FAIL = new PLVChatroomError('chat image upload fail', PLVChatroomErrorCode.CHAT_IMAGE_UPLOAD_FAIL);