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

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

@@ -7,7 +7,7 @@ export declare class PLVPreferencesUtils {
      * @param value
      * @param preferenceName
      */
-    static put(key: string, value: preferences.ValueType, x3?: string): Promise<void>;
+    static put(key: string, value: preferences.ValueType, u3?: string): Promise<void>;
     /**
      * 获取缓存值
      * @param key
@@ -15,44 +15,44 @@ export declare class PLVPreferencesUtils {
      * @param preferenceName
      * @returns
      */
-    static get(key: string, defValue: preferences.ValueType, w3?: string): Promise<preferences.ValueType>;
+    static get(key: string, defValue: preferences.ValueType, t3?: string): Promise<preferences.ValueType>;
     /**
      * 获取string类型的缓存值
      * @param key
      * @returns
      */
-    static getString(key: string, v3?: string): Promise<string>;
+    static getString(key: string, s3?: string): Promise<string>;
     /**
      * 获取number类型的缓存值
      * @param key
      * @returns
      */
-    static getNumber(key: string, u3?: string, defaultValue?: number): Promise<number>;
+    static getNumber(key: string, r3?: string, defaultValue?: number): Promise<number>;
     /**
      * 获取boolean类型的缓存值
      * @param key
      * @param preferenceName
      * @returns
      */
-    static getBoolean(key: string, t3?: string): Promise<boolean>;
+    static getBoolean(key: string, q3?: string): Promise<boolean>;
     /**
      * 检查缓存的Preferences实例中是否包含名为给定Key的存储键值对
      * @param key
      * @param preferenceName
      * @returns
      */
-    static has(key: string, s3?: string): Promise<boolean>;
+    static has(key: string, p3?: string): Promise<boolean>;
     /**
      * 删除缓存值
      * @param key
      * @param preferenceName
      * @returns
      */
-    static delete(key: string, r3?: string): Promise<void>;
+    static delete(key: string, n3?: string): Promise<void>;
     /**
      * 清空缓存
      * @param preferenceName
      * @returns
      */
-    static clear(q3?: string): Promise<void>;
+    static clear(m3?: string): Promise<void>;
 }

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

@@ -3,28 +3,28 @@ const defaultPreferenceName = "PLV_SP_HARMONY_UTILS_PREFERENCES";
 export class PLVPreferencesUtils {
     constructor() {
     }
-    static async put(key, value, x3 = defaultPreferenceName) {
-        await PreferencesUtil.put(key, value, x3);
+    static async put(key, value, u3 = defaultPreferenceName) {
+        await PreferencesUtil.put(key, value, u3);
     }
-    static async get(key, defValue, w3 = defaultPreferenceName) {
-        return PreferencesUtil.get(key, defValue, w3);
+    static async get(key, defValue, t3 = defaultPreferenceName) {
+        return PreferencesUtil.get(key, defValue, t3);
     }
-    static async getString(key, v3 = defaultPreferenceName) {
-        return (await PreferencesUtil.get(key, "", v3));
+    static async getString(key, s3 = defaultPreferenceName) {
+        return (await PreferencesUtil.get(key, "", s3));
     }
-    static async getNumber(key, u3 = defaultPreferenceName, defaultValue = 0) {
-        return (await PreferencesUtil.get(key, defaultValue, u3));
+    static async getNumber(key, r3 = defaultPreferenceName, defaultValue = 0) {
+        return (await PreferencesUtil.get(key, defaultValue, r3));
     }
-    static async getBoolean(key, t3 = defaultPreferenceName) {
-        return (await PreferencesUtil.get(key, false, t3));
+    static async getBoolean(key, q3 = defaultPreferenceName) {
+        return (await PreferencesUtil.get(key, false, q3));
     }
-    static async has(key, s3 = defaultPreferenceName) {
-        return PreferencesUtil.has(key, s3);
+    static async has(key, p3 = defaultPreferenceName) {
+        return PreferencesUtil.has(key, p3);
     }
-    static async delete(key, r3 = defaultPreferenceName) {
-        return PreferencesUtil.delete(key, r3);
+    static async delete(key, n3 = defaultPreferenceName) {
+        return PreferencesUtil.delete(key, n3);
     }
-    static async clear(q3 = defaultPreferenceName) {
-        return PreferencesUtil.clear(q3);
+    static async clear(m3 = defaultPreferenceName) {
+        return PreferencesUtil.clear(m3);
     }
 }

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

@@ -22,7 +22,7 @@ export class PLVScheduledTask {
             return;
         }
         const now = Date.now();
-        const y3 = Math.max(0, this.nextExecutionTime - now);
+        const v3 = Math.max(0, this.nextExecutionTime - now);
         this.timerId = setTimeout(async () => {
             try {
                 await this.callback();
@@ -32,7 +32,7 @@ export class PLVScheduledTask {
             }
             this.nextExecutionTime = Date.now() + this.period;
             this.scheduleNextExecution();
-        }, y3);
+        }, v3);
     }
     cancel() {
         if (!this.isRunning) {

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

@@ -4,8 +4,8 @@ export declare class PLVSimpleBuffer<T> {
     private intervalId?;
     private timespan;
     private isRelease;
-    constructor(d4?: number);
+    constructor(y3?: number);
     observe(callback?: PLVCallback<T[]>): void;
     release(): void;
-    push(b4: T): void;
+    push(x3: T): void;
 }

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

@@ -1,10 +1,10 @@
-const a4 = 500;
+const w3 = 500;
 export class PLVSimpleBuffer {
-    constructor(d4 = a4) {
+    constructor(y3 = w3) {
         this.buffer = [];
-        this.timespan = a4;
+        this.timespan = w3;
         this.isRelease = false;
-        this.timespan = d4;
+        this.timespan = y3;
     }
     observe(callback) {
         if (this.intervalId == undefined) {
@@ -21,10 +21,10 @@ export class PLVSimpleBuffer {
         clearInterval(this.intervalId);
         this.buffer.length = 0;
     }
-    push(b4) {
+    push(x3) {
         if (this.isRelease) {
             return;
         }
-        this.buffer.push(b4);
+        this.buffer.push(x3);
     }
 }

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

@@ -0,0 +1,10 @@
+export declare class PLVSparseArray<V> {
+    private entries;
+    set(key: number, value: V): void;
+    get(key: number): V | undefined;
+    delete(key: number): void;
+    size(): number;
+    forEach(callback: (key: number, value: V) => void): void;
+    forEachReverse(callback: (key: number, value: V) => void): void;
+    someReverse(callback: (key: number, value: V) => boolean): boolean;
+}

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

@@ -0,0 +1,44 @@
+export class PLVSparseArray {
+    constructor() {
+        this.entries = [];
+    }
+    set(key, value) {
+        const h4 = this.entries.findIndex((i4) => i4[0] >= key);
+        if (h4 >= 0 && this.entries[h4][0] === key) {
+            this.entries[h4][1] = value;
+        }
+        else {
+            this.entries.splice(h4 >= 0 ? h4 : this.entries.length, 0, [key, value]);
+        }
+    }
+    get(key) {
+        const f4 = this.entries.find((g4) => g4[0] === key);
+        return f4 ? f4[1] : undefined;
+    }
+    delete(key) {
+        this.entries = this.entries.filter((e4) => e4[0] !== key);
+    }
+    size() {
+        return this.entries.length;
+    }
+    forEach(callback) {
+        for (const d4 of this.entries) {
+            callback(d4[0], d4[1]);
+        }
+    }
+    forEachReverse(callback) {
+        for (let b4 = this.entries.length - 1; b4 >= 0; b4--) {
+            const c4 = this.entries[b4];
+            callback(c4[0], c4[1]);
+        }
+    }
+    someReverse(callback) {
+        for (let z3 = this.entries.length - 1; z3 >= 0; z3--) {
+            const a4 = this.entries[z3];
+            if (callback(a4[0], a4[1])) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

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

@@ -4,6 +4,7 @@ export declare class PLVTextUtils {
     static convertSpecialString(input?: string): string;
     static toString(num?: number): string | undefined;
     static toWString(data?: number): string | undefined;
-    static fixPic(f4?: string): string;
+    static toKString(data?: number): string | undefined;
+    static fixPic(k4?: string): string;
     static isNumberZero(number?: string): boolean;
 }

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

@@ -11,22 +11,22 @@ export class PLVTextUtils {
         if (!(input = PLVTextUtils.convertSpecialString(input))) {
             return undefined;
         }
-        const g4 = /\[([^\[\]]{1,5})\]/g;
+        const l4 = /\[([^\[\]]{1,5})\]/g;
         let match;
-        let h4 = 0;
+        let m4 = 0;
         const result = [];
-        while ((match = g4.exec(input)) !== null) {
-            const j4 = match[0];
-            if (match.index > h4) {
-                const k4 = input.slice(h4, match.index);
-                result.push(k4);
+        while ((match = l4.exec(input)) !== null) {
+            const o4 = match[0];
+            if (match.index > m4) {
+                const p4 = input.slice(m4, match.index);
+                result.push(p4);
             }
-            result.push(j4);
-            h4 = g4.lastIndex;
+            result.push(o4);
+            m4 = l4.lastIndex;
         }
-        if (h4 < input.length) {
-            const i4 = input.slice(h4);
-            result.push(i4);
+        if (m4 < input.length) {
+            const n4 = input.slice(m4);
+            result.push(n4);
         }
         return result;
     }
@@ -51,23 +51,29 @@ export class PLVTextUtils {
         }
         return PLVTextUtils.toString(data);
     }
-    static fixPic(f4) {
-        if (!f4) {
-            return f4 || '';
+    static toKString(data) {
+        if (data && data > 1000) {
+            return (data / 1000).toFixed(1) + 'k';
         }
-        if (f4.startsWith('//')) {
-            return `http:${f4}`;
+        return PLVTextUtils.toString(data);
+    }
+    static fixPic(k4) {
+        if (!k4) {
+            return k4 || '';
+        }
+        if (k4.startsWith('//')) {
+            return `http:${k4}`;
         }
-        else if (f4.startsWith('/')) {
-            return `http://livestatic.videocc.net${f4}`;
+        else if (k4.startsWith('/')) {
+            return `http://livestatic.videocc.net${k4}`;
         }
-        return f4;
+        return k4;
     }
     static isNumberZero(number) {
         if (!number) {
             return true;
         }
-        const e4 = parseFloat(number);
-        return e4 === 0;
+        const j4 = parseFloat(number);
+        return j4 === 0;
     }
 }

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

@@ -4,5 +4,5 @@ export declare class PLVTimeUtils {
      * @param millisecond
      * @param fit 小时是否适配"00"
      */
-    static generateTime(l4: number, m4: boolean): string;
+    static generateTime(q4: number, r4: boolean): string;
 }

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

@@ -1,14 +1,14 @@
 export class PLVTimeUtils {
-    static generateTime(l4, m4) {
-        const n4 = Math.floor(l4 / 1000);
-        const o4 = n4 % 60;
-        const p4 = Math.floor((n4 / 60) % 60);
-        const q4 = Math.floor(n4 / 3600);
-        if (m4 || q4 > 0) {
-            return `${q4.toString().padStart(2, '0')}:${p4.toString().padStart(2, '0')}:${o4.toString().padStart(2, '0')}`;
+    static generateTime(q4, r4) {
+        const s4 = Math.floor(q4 / 1000);
+        const t4 = s4 % 60;
+        const u4 = Math.floor((s4 / 60) % 60);
+        const v4 = Math.floor(s4 / 3600);
+        if (r4 || v4 > 0) {
+            return `${v4.toString().padStart(2, '0')}:${u4.toString().padStart(2, '0')}:${t4.toString().padStart(2, '0')}`;
         }
         else {
-            return `${p4.toString().padStart(2, '0')}:${o4.toString().padStart(2, '0')}`;
+            return `${u4.toString().padStart(2, '0')}:${t4.toString().padStart(2, '0')}`;
         }
     }
 }

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

@@ -3,5 +3,5 @@ export declare class PLVToastUtils {
     longShow(message: string | Resource): void;
     private show;
 }
-declare const x11: PLVToastUtils;
-export default x11;
+declare const u8: PLVToastUtils;
+export default u8;

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

@@ -1,6 +1,7 @@
 import { AxiosResponse } from '@ohos/axios';
 import { PLVHttpData } from '../modules/net/PLVHttpData';
 export type PLVResponseObject = AxiosResponse<object>;
+export type PLVResponseType<T> = AxiosResponse<T>;
 export type PLVResponseData<T> = AxiosResponse<PLVHttpData<T>>;
 export type PLVResponse<T> = PLVResponseData<T> | void;
 export type PLVJSONObject = Record<string, Object | undefined>;

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

@@ -1,3 +1,3 @@
 export declare class PLVUACreator {
-    static createUA(r4: string, s4?: string): string;
+    static createUA(w4: string, x4?: string): string;
 }

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

@@ -1,11 +1,11 @@
 import deviceInfo from '@ohos.deviceInfo';
 export class PLVUACreator {
-    static createUA(r4, s4) {
-        let t4 = r4;
-        if (s4) {
-            t4 += `(${s4})`;
+    static createUA(w4, x4) {
+        let y4 = w4;
+        if (x4) {
+            y4 += `(${x4})`;
         }
-        t4 += ` ohos/${deviceInfo.osFullName} (HarmonyOS ${deviceInfo.osFullName}; ${deviceInfo.brand} ${deviceInfo.productModel};)`;
-        return t4;
+        y4 += ` ohos/${deviceInfo.osFullName} (HarmonyOS ${deviceInfo.osFullName}; ${deviceInfo.brand} ${deviceInfo.productModel};)`;
+        return y4;
     }
 }

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

@@ -1,13 +1,14 @@
-import { PLVCallback, PLVCallback2, PLVDisposable } from './PLVCallback';
+import { PLVAvoidAreaChangeListener, PLVCallback, PLVCallback2, PLVDisposable, PLVMediaQueryListener } from './PLVCallback';
 import { common } from '@kit.AbilityKit';
-import { window } from '@kit.ArkUI';
+import { mediaquery, window } from '@kit.ArkUI';
 import { PLVReject, PLVResolve } from './PLVType';
 export default class PLVUtils {
+    private static readonly TIMES;
     private constructor();
     static init(context: common.UIAbilityContext, windowStage: window.WindowStage): void;
-    static getClassTag(tag?: string | Object, f6?: boolean): string | undefined;
+    static getClassTag(tag?: string | Object, d6?: boolean): string | undefined;
     static retryWhen<T = void>(when: PLVCallback<void, T>, retry: PLVCallback<void, T>): Promise<Awaited<T>>;
-    static disposablePromise<T>(promise: Promise<T>, e6?: PLVDisposable): Promise<T>;
+    static disposablePromise<T>(promise: Promise<T>, c6?: PLVDisposable): Promise<T>;
     static safePromise<T = void>(callback: PLVCallback2<PLVResolve<T>, PLVReject, void>, a6?: PLVDisposable): Promise<T>;
     static retryPromise<T>(w5: number, x5: number, promise: Promise<T>, y5?: PLVDisposable): Promise<T>;
     static delay(delay?: number): Promise<void>;
@@ -16,10 +17,16 @@ export default class PLVUtils {
     static getDeviceId(): string;
     static undefinedToValue<T>(data: T, callback: PLVCallback<T, void>, delay?: number): undefined;
     static copyText(text: string): Promise<void>;
-    static changeOrientation(m5: boolean, component?: Object, n5?: window.Window): void;
+    static listenerOrientation(callback: PLVCallback<mediaquery.MediaQueryResult>): PLVMediaQueryListener;
+    static listenerAvoidAreaChange(callback: PLVCallback<window.AvoidAreaOptions>): PLVAvoidAreaChangeListener;
+    static changeOrientation(o5: boolean, component?: Object, p5?: window.Window): void;
     static isLandscape(component?: Object): boolean;
-    static setWindowFullScreen(isLayoutFullScreen?: boolean, isFullScreen?: boolean, component?: Object, c5?: window.Window): Promise<Object[]>;
+    static setWindowFullScreen(isLayoutFullScreen?: boolean, isFullScreen?: boolean, component?: Object, h5?: window.Window): Promise<Object[]>;
+    static setWindowSystemBarProperties(systemBarProperties?: window.SystemBarProperties): void;
     static startScan(component?: Object): Promise<string>;
-    static getVideoRectJS(w4: boolean): string;
-    static getExitFullScreenJS(u4: boolean): string;
+    static getVideoRectJS(e5: boolean): string;
+    static getExitFullScreenJS(c5: boolean): string;
+    static colorResourceToHex(resource: Resource): string;
+    static colorIntToHex(z4: number, a5?: boolean): string;
+    static debounce(func: Function, delay?: number, key?: string): void;
 }

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

@@ -1,10 +1,13 @@
+import { PLVAvoidAreaChangeListener, PLVMediaQueryListener } from './PLVCallback';
 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 mediaquery from "@ohos.mediaquery";
 import window from "@ohos.window";
 import scanBarcode from "@hms.core.scan.scanBarcode";
 import scanCore from "@hms.core.scan.scanCore";
+import { PLVDeviceUtils } from './PLVDeviceUtils';
 const TAG = '[PLVUtils]';
 export default class PLVUtils {
     constructor() {
@@ -12,8 +15,8 @@ export default class PLVUtils {
     static init(context, windowStage) {
         AppUtil.init(context, windowStage);
     }
-    static getClassTag(tag, f6 = true) {
-        let key = f6 ? '[Anonymous]' : undefined;
+    static getClassTag(tag, d6 = true) {
+        let key = d6 ? '[Anonymous]' : undefined;
         if (typeof tag == 'string') {
             key = tag;
         }
@@ -39,26 +42,26 @@ export default class PLVUtils {
             }
         }
     }
-    static async disposablePromise(promise, e6) {
+    static async disposablePromise(promise, c6) {
         try {
             await promise;
         }
         catch (error) {
             return Promise.reject(error);
         }
-        if (e6?.isDispose()) {
+        if (c6?.isDispose()) {
             return Promise.reject(new Error('error'));
         }
         return promise;
     }
     static safePromise(callback, a6) {
-        const promise = new Promise(async (c6, d6) => {
+        const promise = new Promise(async (b6, reject) => {
             try {
-                await callback(c6, d6);
+                await callback(b6, reject);
             }
             catch (err) {
                 PLVLogger.printWarn(TAG, 'safePromise catch error', err);
-                d6(err);
+                reject(err);
             }
         });
         return PLVUtils.disposablePromise(promise, a6);
@@ -112,40 +115,58 @@ export default class PLVUtils {
     static copyText(text) {
         return PasteboardUtil.setDataText(text);
     }
-    static changeOrientation(m5, component, n5) {
+    static listenerOrientation(callback) {
+        const listener = mediaquery.matchMediaSync('(orientation: landscape)');
+        listener.on('change', callback);
+        return new PLVMediaQueryListener(listener, callback);
+    }
+    static listenerAvoidAreaChange(callback) {
+        const t5 = AppUtil.getMainWindow();
+        try {
+            t5.on('avoidAreaChange', callback);
+        }
+        catch (u5) {
+            PLVLogger.error(TAG, `Failed to enable the listener for system avoid area changes. Cause code: ${u5.code}, message: ${u5.message}`);
+        }
+        return new PLVAvoidAreaChangeListener(t5, callback);
+    }
+    static changeOrientation(o5, component, p5) {
         let context = getContext(component);
-        let o5 = (s5) => {
-            s5.setPreferredOrientation(m5 ? window.Orientation.LANDSCAPE : window.Orientation.PORTRAIT);
+        let q5 = (s5) => {
+            s5.setPreferredOrientation(o5 ? window.Orientation.LANDSCAPE : window.Orientation.PORTRAIT);
         };
-        n5 ? o5(n5) :
+        p5 ? q5(p5) :
             window.getLastWindow(context).then((r5) => {
-                o5(r5);
+                q5(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) => {
+    static setWindowFullScreen(isLayoutFullScreen = false, isFullScreen = false, component, h5) {
+        return new Promise((i5) => {
             let context = getContext(component);
-            let f5 = (j5) => {
-                let k5 = j5.getWindowProperties().isLayoutFullScreen;
-                let l5 = j5.getWindowProperties().isFullScreen;
-                j5.setWindowLayoutFullScreen(isLayoutFullScreen);
+            let j5 = (l5) => {
+                let m5 = l5.getWindowProperties().isLayoutFullScreen;
+                let n5 = l5.getWindowProperties().isFullScreen;
+                l5.setWindowLayoutFullScreen(isLayoutFullScreen);
                 if (canIUse("SystemCapability.Window.SessionManager")) {
-                    j5.setSpecificSystemBarEnabled('status', !isFullScreen);
-                    e5([k5, l5]);
+                    l5.setSpecificSystemBarEnabled('status', !isFullScreen);
+                    i5([m5, n5]);
                 }
             };
-            c5 ? f5(c5) :
-                window.getLastWindow(context).then((i5) => {
-                    f5(i5);
+            h5 ? j5(h5) :
+                window.getLastWindow(context).then((k5) => {
+                    j5(k5);
                 });
         });
     }
+    static setWindowSystemBarProperties(systemBarProperties) {
+        PLVDeviceUtils.setWindowSystemBarProperties(systemBarProperties);
+    }
     static startScan(component) {
-        return new Promise((z4) => {
+        return new Promise((g5) => {
             if (canIUse('SystemCapability.Multimedia.Scan.Core') && canIUse('SystemCapability.Multimedia.Scan.ScanBarcode')) {
                 let options = {
                     scanTypes: [scanCore.ScanType.ALL],
@@ -155,7 +176,7 @@ export default class PLVUtils {
                 try {
                     scanBarcode.startScanForResult(getContext(component), options).then((result) => {
                         PLVLogger.info(TAG, 'Promise scan result: ' + JSON.stringify(result));
-                        z4(result.originalValue);
+                        g5(result.originalValue);
                     }).catch((error) => {
                         PLVLogger.error(TAG, 'Promise error: ' + JSON.stringify(error));
                     });
@@ -166,32 +187,55 @@ export default class PLVUtils {
             }
         });
     }
-    static getVideoRectJS(w4) {
-        let x4 = "function getVideoRect() {";
+    static getVideoRectJS(e5) {
+        let f5 = "function getVideoRect() {";
         {
-            x4 += "let tags = document.getElementsByTagName('video');";
-            x4 += "if (tags.length > 0) {";
+            f5 += "let tags = document.getElementsByTagName('video');";
+            f5 += "if (tags.length > 0) {";
             {
-                x4 += "let video = tags[0];";
-                x4 += "return {";
+                f5 += "let video = tags[0];";
+                f5 += "return {";
                 {
-                    x4 += "'width': video.videoWidth,";
-                    x4 += "'height': video.videoHeight";
+                    f5 += "'width': video.videoWidth,";
+                    f5 += "'height': video.videoHeight";
                 }
-                x4 += "};";
+                f5 += "};";
             }
-            x4 += "}";
-            x4 += "return {};";
+            f5 += "}";
+            f5 += "return {};";
+        }
+        f5 += "}";
+        f5 += "getVideoRect();";
+        return e5 ? PLVCommonConstants.JS_PRE + f5 : f5;
+    }
+    static getExitFullScreenJS(c5) {
+        let d5 = "function exitFullScreen() {";
+        d5 += "document.getElementsByTagName('video')[0].webkitExitFullScreen()";
+        d5 += "}";
+        d5 += "exitFullScreen();";
+        return c5 ? PLVCommonConstants.JS_PRE + d5 : d5;
+    }
+    static colorResourceToHex(resource) {
+        return PLVUtils.colorIntToHex(getContext().resourceManager.getColorSync(resource));
+    }
+    static colorIntToHex(z4, a5 = false) {
+        const b5 = z4.toString(16).padStart(8, '0');
+        if (a5) {
+            return `#${b5.toUpperCase()}`;
+        }
+        else {
+            return `#${b5.substring(2).toUpperCase()}`;
         }
-        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;
+    static debounce(func, delay = 500, key = 'default') {
+        if (PLVUtils.TIMES.has(key)) {
+            clearTimeout(PLVUtils.TIMES.get(key));
+        }
+        const timer = setTimeout(() => {
+            func();
+            PLVUtils.TIMES.delete(key);
+        }, delay);
+        PLVUtils.TIMES.set(key, timer);
     }
 }
+PLVUtils.TIMES = new Map();

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

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