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

package/src/main/ets/common/PLVUtils.js

@@ -0,0 +1,197 @@
+import PLVLogger from '../modules/log/PLVLogger';
+import PLVCommonConstants from './PLVCommonConstants';
+import { AppUtil, DeviceUtil, PasteboardUtil } from '@pura/harmony-utils';
+import ConfigurationConstant from "@ohos.app.ability.ConfigurationConstant";
+import window from "@ohos.window";
+import scanBarcode from "@hms.core.scan.scanBarcode";
+import scanCore from "@hms.core.scan.scanCore";
+const TAG = '[PLVUtils]';
+export default class PLVUtils {
+    constructor() {
+    }
+    static init(context, windowStage) {
+        AppUtil.init(context, windowStage);
+    }
+    static getClassTag(tag, f6 = true) {
+        let key = f6 ? '[Anonymous]' : undefined;
+        if (typeof tag == 'string') {
+            key = tag;
+        }
+        else {
+            if (tag && tag.constructor) {
+                key = `[${tag.constructor.name}]`;
+            }
+        }
+        return key;
+    }
+    static retryWhen(when, retry) {
+        try {
+            return Promise.resolve(when());
+        }
+        catch (err) {
+            PLVLogger.printWarn(TAG, 'retryWhen catch error', err);
+            try {
+                return Promise.resolve(retry());
+            }
+            catch (err) {
+                PLVLogger.printWarn(TAG, 'retryWhen catch error while retry', err);
+                return Promise.reject(err);
+            }
+        }
+    }
+    static async disposablePromise(promise, e6) {
+        try {
+            await promise;
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        if (e6?.isDispose()) {
+            return Promise.reject(new Error('error'));
+        }
+        return promise;
+    }
+    static safePromise(callback, a6) {
+        const promise = new Promise(async (c6, d6) => {
+            try {
+                await callback(c6, d6);
+            }
+            catch (err) {
+                PLVLogger.printWarn(TAG, 'safePromise catch error', err);
+                d6(err);
+            }
+        });
+        return PLVUtils.disposablePromise(promise, a6);
+    }
+    static async retryPromise(w5, x5, promise, y5) {
+        let z5 = 0;
+        let error = new Error('error');
+        while (z5 <= w5) {
+            try {
+                const result = await promise;
+                if (!y5?.isDispose()) {
+                    return result;
+                }
+            }
+            catch (err) {
+                error = err;
+                PLVLogger.printWarn(TAG, `retryPromise retryCount=${z5} catch error`, err);
+            }
+            if (++z5 > w5) {
+                break;
+            }
+            if (y5?.isDispose()) {
+                return Promise.reject(error);
+            }
+            await PLVUtils.delay(x5);
+        }
+        return Promise.reject(error);
+    }
+    static async delay(delay) {
+        return PLVUtils.safePromise((v5) => {
+            setTimeout(v5, delay);
+        });
+    }
+    static validCallback(callback) {
+        return '/' != callback;
+    }
+    static getPid() {
+        const current = Date.now();
+        const random = Math.floor(Math.random() * 1000000) + 1000000;
+        return current + "X" + random;
+    }
+    static getDeviceId() {
+        return DeviceUtil.getDeviceId();
+    }
+    static undefinedToValue(data, callback, delay) {
+        setTimeout(() => {
+            callback(data);
+        }, delay ? delay : PLVCommonConstants.DELAY_TIME_S);
+        return undefined;
+    }
+    static copyText(text) {
+        return PasteboardUtil.setDataText(text);
+    }
+    static changeOrientation(m5, component, n5) {
+        let context = getContext(component);
+        let o5 = (s5) => {
+            s5.setPreferredOrientation(m5 ? window.Orientation.LANDSCAPE : window.Orientation.PORTRAIT);
+        };
+        n5 ? o5(n5) :
+            window.getLastWindow(context).then((r5) => {
+                o5(r5);
+            });
+    }
+    static isLandscape(component) {
+        let context = getContext(component);
+        return context.config.direction === ConfigurationConstant.Direction.DIRECTION_HORIZONTAL;
+    }
+    static setWindowFullScreen(isLayoutFullScreen = false, isFullScreen = false, component, c5) {
+        return new Promise((e5) => {
+            let context = getContext(component);
+            let f5 = (j5) => {
+                let k5 = j5.getWindowProperties().isLayoutFullScreen;
+                let l5 = j5.getWindowProperties().isFullScreen;
+                j5.setWindowLayoutFullScreen(isLayoutFullScreen);
+                if (canIUse("SystemCapability.Window.SessionManager")) {
+                    j5.setSpecificSystemBarEnabled('status', !isFullScreen);
+                    e5([k5, l5]);
+                }
+            };
+            c5 ? f5(c5) :
+                window.getLastWindow(context).then((i5) => {
+                    f5(i5);
+                });
+        });
+    }
+    static startScan(component) {
+        return new Promise((z4) => {
+            if (canIUse('SystemCapability.Multimedia.Scan.Core') && canIUse('SystemCapability.Multimedia.Scan.ScanBarcode')) {
+                let options = {
+                    scanTypes: [scanCore.ScanType.ALL],
+                    enableMultiMode: true,
+                    enableAlbum: true
+                };
+                try {
+                    scanBarcode.startScanForResult(getContext(component), options).then((result) => {
+                        PLVLogger.info(TAG, 'Promise scan result: ' + JSON.stringify(result));
+                        z4(result.originalValue);
+                    }).catch((error) => {
+                        PLVLogger.error(TAG, 'Promise error: ' + JSON.stringify(error));
+                    });
+                }
+                catch (error) {
+                    PLVLogger.error(TAG, 'failReason: ' + JSON.stringify(error));
+                }
+            }
+        });
+    }
+    static getVideoRectJS(w4) {
+        let x4 = "function getVideoRect() {";
+        {
+            x4 += "let tags = document.getElementsByTagName('video');";
+            x4 += "if (tags.length > 0) {";
+            {
+                x4 += "let video = tags[0];";
+                x4 += "return {";
+                {
+                    x4 += "'width': video.videoWidth,";
+                    x4 += "'height': video.videoHeight";
+                }
+                x4 += "};";
+            }
+            x4 += "}";
+            x4 += "return {};";
+        }
+        x4 += "}";
+        x4 += "getVideoRect();";
+        return w4 ? PLVCommonConstants.JS_PRE + x4 : x4;
+    }
+    static getExitFullScreenJS(u4) {
+        let v4 = "function exitFullScreen() {";
+        v4 += "document.getElementsByTagName('video')[0].webkitExitFullScreen()";
+        v4 += "}";
+        v4 += "exitFullScreen();";
+        return u4 ? PLVCommonConstants.JS_PRE + v4 : v4;
+    }
+}

package/src/main/ets/common/PLVWebUtils.d.ets

@@ -0,0 +1,6 @@
+export declare class PLVWebUtils {
+    static toWebViewContent(content?: string, color?: string): string;
+    static toRGBA(l6: string): string;
+    static cleanHTML(input: string): string;
+    static openWebLink(url?: string, component?: object): void;
+}

package/src/main/ets/common/PLVWebUtils.js

@@ -0,0 +1,79 @@
+import { PLVTextUtils } from './PLVTextUtils';
+import PLVLogger from '../modules/log/PLVLogger';
+const TAG = '[PLVWebUtils]';
+export class PLVWebUtils {
+    static toWebViewContent(content, color) {
+        if (!content) {
+            return content;
+        }
+        if (!color) {
+            color = "rgba(0, 0, 0, 1)";
+        }
+        const style = "style=\" width:100%;\"";
+        const m6 = "word-break:break-all;";
+        const n6 = "color: " + color + ";";
+        content = content.replace(/src=\"\/\//g, "src=\"https://");
+        content = content.replace(/<img /g, "<img " + style + " ");
+        content = content.replace(/<li>/g, "<li style=\"" + n6 + "\">");
+        content = content.replace(/<p>/g, "<p style=\"" + m6 + n6 + "\">");
+        content = content.replace(/<div>/g, "<div style=\"" + m6 + n6 + "\">");
+        content = content.replace(/<table>/g, "<table border='1' rules=all style=\"" + n6 + "\">");
+        content = content.replace(/<td>/g, "<td width=\"36\">");
+        content = content.replace(/color: (#([0-9a-fA-F]{6}|[0-9a-fA-F]{8}));/g, (p6, q6) => {
+            return `color: ${PLVWebUtils.toRGBA(q6)};`;
+        });
+        content = "<!DOCTYPE html>\n" +
+            "<html lang=\"en\">\n" +
+            "<head>\n" +
+            "        <meta charset=\"UTF-8\">\n" +
+            "        <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n" +
+            "        <meta http-equiv=\"X-UA-Compatible\" content=\"ie=edge\">\n" +
+            "        <title>Document</title>\n" +
+            "</head>\n" +
+            "<body style=\" color: " + color + ";margin:0;padding:0\">" +
+            content + "</body>\n" +
+            "</html>";
+        return content;
+    }
+    static toRGBA(l6) {
+        let alpha = 1;
+        if (l6.length > 7) {
+            alpha = parseInt(l6.substring(1, 3), 16) / 255;
+            l6 = `#${l6.substring(3)}`;
+        }
+        const red = parseInt(l6.substring(1, 3), 16);
+        const green = parseInt(l6.substring(3, 5), 16);
+        const blue = parseInt(l6.substring(5, 7), 16);
+        return `rgba(${red}, ${green}, ${blue}, ${alpha})`;
+    }
+    static cleanHTML(input) {
+        let i6 = input.replace(/<p>((?:<img[^>]*>)+)<\/p>/g, (match, k6) => {
+            return k6.replace(/<img[^>]*>/g, '[图片]');
+        });
+        i6 = i6.replace(/<p><a[^>]*>(.*?)<\/a><\/p>/g, '$1');
+        i6 = i6.replace(/<p>(.*?)<\/p>/g, '$1');
+        i6 = i6.replace(/\n/g, ' ');
+        i6 = PLVTextUtils.convertSpecialString(i6);
+        return i6;
+    }
+    static openWebLink(url, component) {
+        let want = {
+            action: 'ohos.want.action.viewData',
+            entities: ['entity.system.browsable'],
+            uri: url
+        };
+        const context = getContext(component);
+        if (context) {
+            context.startAbility(want)
+                .then(() => {
+                PLVLogger.info(TAG, `openWebLink success, url: ${url}`);
+            })
+                .catch((err) => {
+                PLVLogger.error(TAG, `openWebLink error, url: ${url}, code: ${err.code}, message: ${err.message}`);
+            });
+        }
+        else {
+            PLVLogger.error(TAG, `openWebLink error, context: undefined`);
+        }
+    }
+}

package/src/main/ets/modules/log/PLVLogger.d.ets

@@ -0,0 +1,20 @@
+import { PLVPrintLogLevel } from '../../common/PLVCommonEnums';
+import { common } from '@kit.AbilityKit';
+export declare class PLVLogger {
+    private printLogLevel;
+    private tag;
+    private format;
+    private filePrinter?;
+    init(context: common.UIAbilityContext): void;
+    level(a7: PLVPrintLogLevel): void;
+    debug(tag: string, message: string, z6?: boolean): void;
+    info(tag: string, message: string, y6?: boolean): void;
+    warn(tag: string, message: string, x6?: boolean): void;
+    error(tag: string, message: string, w6?: boolean): void;
+    printWarn(tag: string, v6: string, err: Error): string;
+    printError(tag: string, u6: string, err: Error): string;
+    private generateErrorMsg;
+    private intercept;
+}
+declare const x11: PLVLogger;
+export default x11;

package/src/main/ets/modules/log/PLVLogger.js

@@ -0,0 +1,67 @@
+import PLVCommonConstants from '../../common/PLVCommonConstants';
+import { PLVPrintLogLevel } from '../../common/PLVCommonEnums';
+import { DateFileNameGenerator, FileLastModifiedCleanStrategy, FileSizeBackupStrategy, LogConfiguration, OhPrinter, XLog } from '@ohos-port/xlog';
+import util from "@ohos.util";
+import { PLVXLogBuilder } from './PLVXLogFilePrinter';
+export class PLVLogger {
+    constructor() {
+        this.printLogLevel = PLVPrintLogLevel.ALL;
+        this.tag = PLVCommonConstants.TAG.substring(1, PLVCommonConstants.TAG.length - 1);
+        this.format = "%s";
+    }
+    init(context) {
+        const config = new LogConfiguration.Builder()
+            .setTag(this.tag)
+            .build();
+        const filesDir = context.filesDir;
+        this.filePrinter = new PLVXLogBuilder(`${filesDir}/log`, true, '../../modules/log/PLVXLogWorker.ets')
+            .setCleanStrategy(new FileLastModifiedCleanStrategy(5 * 24 * 60 * 60 * 1000))
+            .setFileNameGenerator(new DateFileNameGenerator())
+            .setBackupStrategy(new FileSizeBackupStrategy(10 * 1024 * 1024))
+            .build();
+        XLog.init(config, [new OhPrinter()]);
+    }
+    level(a7) {
+        this.printLogLevel = a7;
+    }
+    debug(tag, message, z6 = true) {
+        const msg = util.format(this.format, tag, message);
+        this.intercept(PLVPrintLogLevel.DEBUG, msg, z6) || XLog.d(msg);
+    }
+    info(tag, message, y6 = true) {
+        const msg = util.format(this.format, tag, message);
+        this.intercept(PLVPrintLogLevel.INFO, msg, y6) || XLog.i(msg);
+    }
+    warn(tag, message, x6 = true) {
+        const msg = util.format(this.format, tag, message);
+        this.intercept(PLVPrintLogLevel.WARN, msg, x6) || XLog.w(msg);
+    }
+    error(tag, message, w6 = true) {
+        const msg = util.format(this.format, tag, message);
+        this.intercept(PLVPrintLogLevel.ERROR, msg, w6) || XLog.e(msg);
+    }
+    printWarn(tag, v6, err) {
+        const msg = this.generateErrorMsg(v6, err);
+        this.warn(tag, msg);
+        return msg;
+    }
+    printError(tag, u6, err) {
+        const msg = this.generateErrorMsg(u6, err);
+        this.error(tag, msg);
+        return msg;
+    }
+    generateErrorMsg(s6, err) {
+        let t6 = '';
+        if (err && err.code) {
+            t6 = `, code=${err.code}`;
+        }
+        return `${s6}: name=${err.name}, message=${err.message}${t6}\n${err.stack}`;
+    }
+    intercept(level, msg, r6 = true) {
+        if (r6) {
+            this.filePrinter?.println(level, this.tag, msg);
+        }
+        return this.printLogLevel > level;
+    }
+}
+export default new PLVLogger();

package/src/main/ets/modules/log/PLVXLogFilePrinter.d.ets

@@ -0,0 +1,12 @@
+import worker from '@ohos.worker';
+import { FilePrinter } from '@ohos-port/xlog';
+import { Printer } from '@ohos-port/xlog/src/main/ets/printer/Printer';
+export declare class PLVXLogFilePrinter extends Printer {
+    builder: FilePrinter.Builder;
+    workerInstance?: worker.ThreadWorker;
+    constructor(builder: FilePrinter.Builder);
+    println(b7: number, tag: string, msg: string): void;
+}
+export declare class PLVXLogBuilder extends FilePrinter.Builder {
+    build(): FilePrinter;
+}

package/src/main/ets/modules/log/PLVXLogFilePrinter.js

@@ -0,0 +1,37 @@
+import worker from '@ohos.worker';
+import { FilePrinter } from '@ohos-port/xlog';
+import { LogAddMessage, LogInitMessage } from '@ohos-port/xlog/src/main/ets/printer/file/MessageType';
+import { Printer } from '@ohos-port/xlog/src/main/ets/printer/Printer';
+export class PLVXLogFilePrinter extends Printer {
+    constructor(builder) {
+        super();
+        this.builder = builder;
+        if (this.builder.useWorker) {
+            try {
+                this.workerInstance = new worker.ThreadWorker(this.builder.workerPath);
+                this.workerInstance.onmessage = (e) => {
+                    let data = e.data;
+                    let type = data.type;
+                };
+                this.workerInstance.onexit = (code) => {
+                };
+                let data = new LogInitMessage(this.builder);
+                this.workerInstance.postMessage(data);
+            }
+            catch (err) {
+            }
+        }
+    }
+    println(b7, tag, msg) {
+        if (this.workerInstance != null) {
+            let data = new LogAddMessage(b7, tag, msg);
+            this.workerInstance.postMessage(data);
+        }
+    }
+}
+export class PLVXLogBuilder extends FilePrinter.Builder {
+    build() {
+        super.build();
+        return new PLVXLogFilePrinter(this);
+    }
+}

package/src/main/ets/modules/log/PLVXLogWorker.d.ets

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

package/src/main/ets/modules/log/PLVXLogWorker.js

@@ -0,0 +1,4 @@
+import worker from '@ohos.worker';
+import { logErrorHandler, logHandler } from '@ohos-port/xlog/XLogBaseWorker';
+worker.workerPort.onmessage = logHandler;
+worker.workerPort.onerror = logErrorHandler;

package/src/main/ets/modules/net/PLVApiConstants.d.ets

@@ -0,0 +1,7 @@
+export declare class PLVApiConstants {
+    static readonly API_PLV_NET = "https://api.polyv.net";
+    static readonly ELOG_PLV_NET = "https://elog.polyv.net";
+    static readonly HTTPS_LIVEIMAGES_VIDEOCC_NET = "https://liveimages.videocc.net";
+    static readonly RTAS_VIDEOCC_NET = "https://rtas.videocc.net";
+    static readonly NGB_PUSH_URL = "https://sdkoptedge.chinanetcenter.com";
+}

package/src/main/ets/modules/net/PLVApiConstants.js

@@ -0,0 +1,7 @@
+export class PLVApiConstants {
+}
+PLVApiConstants.API_PLV_NET = 'https://api.polyv.net';
+PLVApiConstants.ELOG_PLV_NET = 'https://elog.polyv.net';
+PLVApiConstants.HTTPS_LIVEIMAGES_VIDEOCC_NET = 'https://liveimages.videocc.net';
+PLVApiConstants.RTAS_VIDEOCC_NET = 'https://rtas.videocc.net';
+PLVApiConstants.NGB_PUSH_URL = 'https://sdkoptedge.chinanetcenter.com';

package/src/main/ets/modules/net/PLVHttpData.d.ets

@@ -0,0 +1,8 @@
+import { PLVResponse } from '../../common/PLVType';
+export declare class PLVHttpData<T> {
+    code?: number;
+    status?: string;
+    message?: string;
+    data?: T;
+    static fill<T>(e7: T, data: PLVResponse<T>): void;
+}

package/src/main/ets/modules/net/PLVHttpData.js

@@ -0,0 +1,8 @@
+import PLVJSONUtils from '../../common/PLVJSONUtils';
+export class PLVHttpData {
+    static fill(e7, data) {
+        if (data) {
+            PLVJSONUtils.httpData2Bean(e7, data.data);
+        }
+    }
+}

package/src/main/ets/modules/net/PLVHttpError.d.ets

@@ -0,0 +1,5 @@
+import { AxiosError } from '@ohos/axios';
+export declare class PLVHttpError extends AxiosError {
+    constructor(g7: AxiosError);
+    log(tag: string, f7: string): this;
+}

package/src/main/ets/modules/net/PLVHttpError.js

@@ -0,0 +1,13 @@
+import { AxiosError } from '@ohos/axios';
+import PLVJSONUtils from '../../common/PLVJSONUtils';
+import PLVLogger from '../log/PLVLogger';
+export class PLVHttpError extends AxiosError {
+    constructor(g7) {
+        const message = (g7.response?.data && PLVJSONUtils.safeStringify(g7.response.data)) || g7.message;
+        super(message, g7.code, g7.config, g7.request, g7.response);
+    }
+    log(tag, f7) {
+        PLVLogger.printError(tag, f7, this);
+        return this;
+    }
+}

package/src/main/ets/modules/net/PLVHttpRequest.d.ets

@@ -0,0 +1,25 @@
+import { AxiosRequestConfig, AxiosResponse } from '@ohos/axios';
+import { HashMap } from '@kit.ArkTS';
+export declare class PLVHttpRequest {
+    static readonly CACHE_TIMEOUT: number;
+    static readonly CACHE_DATA_MAP: HashMap<string, AxiosResponse>;
+    static token?: string;
+    baseURL?: string;
+    userAgent?: string;
+    private method?;
+    constructor(x7?: string);
+    ua(w7?: string): this;
+    create<g12 = Object>(config?: PLVAxiosRequestConfig<g12>): import("@ohos/axios").AxiosInstance;
+    request<T = Object, f12 = AxiosResponse<T>>(p: Promise<AxiosResponse<T>>): Promise<f12>;
+    get<T = Object, d12 = AxiosResponse<T>, e12 = Object>(config?: PLVAxiosRequestConfig<e12>): Promise<d12>;
+    post<T = Object, b12 = AxiosResponse<T>, c12 = Object>(config?: PLVAxiosRequestConfig<c12>): Promise<b12>;
+    checkCache<T = Object, z11 = AxiosResponse<T>, a12 = Object>(config?: PLVAxiosRequestConfig<a12>): Promise<z11> | undefined;
+    generateCacheKey(config?: AxiosRequestConfig): string;
+}
+export interface PLVAxiosRequestConfig<D = Object> extends AxiosRequestConfig<D> {
+    formUrlEncoded?: boolean;
+    aesDecrypted?: boolean;
+    useCache?: boolean;
+    fillData?: Object;
+    signKey?: string;
+}

package/src/main/ets/modules/net/PLVHttpRequest.js

@@ -0,0 +1,147 @@
+import axios, { AxiosError } from '@ohos/axios';
+import HashMap from "@ohos.util.HashMap";
+import PLVJSONUtils from '../../common/PLVJSONUtils';
+import { PLVHttpError } from './PLVHttpError';
+import PLVLogger from '../log/PLVLogger';
+import { PLVRequestSetting } from './PLVRequestSetting';
+import { PLVHttpData } from './PLVHttpData';
+import PLVUtils from '../../common/PLVUtils';
+import { PLVNetUtils } from '../../common/PLVNetUtils';
+const TAG = '[PLVHttpRequest]';
+export class PLVHttpRequest {
+    constructor(x7) {
+        this.baseURL = x7;
+    }
+    ua(w7) {
+        this.userAgent = w7;
+        return this;
+    }
+    create(config) {
+        const o7 = axios.create();
+        o7.defaults.timeout = 10000;
+        o7.defaults.readTimeout = 10000;
+        o7.defaults.connectTimeout = 10000;
+        o7.defaults.baseURL = this.baseURL;
+        o7.defaults.headers.common["w1"] = this.userAgent;
+        if (config?.formUrlEncoded) {
+            o7.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded';
+        }
+        let cacheKey = '';
+        o7.interceptors.request.use((v7) => {
+            if (config?.signKey) {
+                const data = v7.params ? v7.params : v7.data;
+                const map = PLVJSONUtils.object2Map(data);
+                map.delete('log');
+                data['sign'] = PLVRequestSetting.createSign(map, config.signKey);
+            }
+            if (PLVHttpRequest.token) {
+                const params = v7.params;
+                const data = v7.data;
+                if (params && Object.keys(params).includes('appId')) {
+                    params['token'] = PLVHttpRequest.token;
+                    params["z1"] = PLVHttpRequest.token;
+                }
+                if (data && Object.keys(data).includes('appId')) {
+                    data['token'] = PLVHttpRequest.token;
+                    data["z1"] = PLVHttpRequest.token;
+                }
+            }
+            if (config?.useCache) {
+                cacheKey = this.generateCacheKey(v7);
+            }
+            PLVLogger.info(TAG, `--> ${this.method} ${this.baseURL}${config?.url}${PLVNetUtils.formatParams(v7?.params)}`);
+            PLVLogger.info(TAG, `--> ${PLVNetUtils.formatParams(v7?.data)}`);
+            return v7;
+        }, (error) => {
+            return Promise.reject(error);
+        });
+        o7.interceptors.response.use((response) => {
+            PLVLogger.info(TAG, `<-- ${response.status} ${this.method} ${this.baseURL}${response.config.url}${PLVNetUtils.formatParams(config?.params)} (${response.performanceTiming?.totalTiming}ms)`);
+            PLVLogger.info(TAG, `Header: ${PLVJSONUtils.safeStringify(response.headers)}`);
+            PLVLogger.info(TAG, `Result: ${PLVJSONUtils.safeStringify(response.data)}`);
+            if (config?.aesDecrypted) {
+                const u7 = response.data;
+                if (u7) {
+                    u7['data'] = PLVJSONUtils.safeParse(PLVRequestSetting.decryptDataSync(u7['data']));
+                }
+                else {
+                    PLVLogger.printError(TAG, 'response error', new Error('jsonData undefined'));
+                }
+            }
+            if (config?.fillData) {
+                PLVHttpData.fill(config.fillData, response);
+            }
+            if (cacheKey) {
+                PLVHttpRequest.CACHE_DATA_MAP.set(cacheKey, response);
+                setTimeout(() => {
+                    PLVHttpRequest.CACHE_DATA_MAP.remove(cacheKey);
+                }, PLVHttpRequest.CACHE_TIMEOUT);
+            }
+            return response;
+        }, (error) => {
+            return Promise.reject(error);
+        });
+        return o7;
+    }
+    request(p) {
+        return PLVUtils.safePromise((k7, l7) => {
+            p.then((r) => {
+                const data = r.data;
+                if (data) {
+                    for (const key of Object.keys(data)) {
+                        if (key == 'code' && data[key] != 200 + '') {
+                            l7(new PLVHttpError(new AxiosError(PLVJSONUtils.safeStringify(r.data || ''), data[key], undefined, undefined, r)));
+                            return;
+                        }
+                    }
+                }
+                k7(r);
+            }).catch((err) => {
+                l7(new PLVHttpError(err));
+            });
+        });
+    }
+    get(config) {
+        this.method = 'GET';
+        return this.checkCache(config) || this.request(this.create(config).get(config?.url, config));
+    }
+    post(config) {
+        this.method = 'POST';
+        return this.checkCache(config) || this.request(this.create(config).post(config?.url, config?.data, config));
+    }
+    checkCache(config) {
+        if (config?.useCache) {
+            const cacheKey = this.generateCacheKey(config);
+            if (PLVHttpRequest.CACHE_DATA_MAP.hasKey(cacheKey)) {
+                PLVLogger.info(TAG, `--> ${this.method} ${this.baseURL}${config?.url} use cache`);
+                return Promise.resolve(PLVHttpRequest.CACHE_DATA_MAP.get(cacheKey));
+            }
+        }
+        return undefined;
+    }
+    generateCacheKey(config) {
+        let cacheKey = this.baseURL + '' + config?.url;
+        const params = config?.params;
+        const data = config?.data;
+        const h7 = (record) => {
+            if (record) {
+                for (const key of Object.keys(record)) {
+                    if (key == 'timestamp' || key == 'sign' || key == 'token' || key == 'viewerToken') {
+                        continue;
+                    }
+                    if (key == 'appId' && PLVHttpRequest.token) {
+                        cacheKey += PLVHttpRequest.token;
+                    }
+                    else {
+                        cacheKey += record[key];
+                    }
+                }
+            }
+        };
+        h7(params);
+        h7(data);
+        return cacheKey;
+    }
+}
+PLVHttpRequest.CACHE_TIMEOUT = 1000 * 60 * 5;
+PLVHttpRequest.CACHE_DATA_MAP = new HashMap();

package/src/main/ets/modules/net/PLVRequestSetting.d.ets

@@ -0,0 +1,9 @@
+export declare class PLVRequestSetting {
+    static readonly KEY_1 = "polyv_sdk_api_innor";
+    static readonly PLV_SWITCH_API_INNOR = "polyv_switch_api_innor";
+    static readonly DECRYPT_KEY_1_SRC = "PolyvApiResponse";
+    static readonly DECRYPT_KEY_2_SRC = "PolyvLiveEncrypt";
+    static createSign(map: Map<string, Object | undefined>, key?: string): string;
+    static decryptDataSync(data: string): string;
+    static concatParams(map: Map<string, Object | undefined>): string;
+}