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

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

@@ -1,4 +1,4 @@
-import { preferences } from '@kit.ArkData';
+import preferences from "@ohos.data.preferences";
 export declare class PLVPreferencesUtils {
     private constructor();
     /**
@@ -7,7 +7,7 @@ export declare class PLVPreferencesUtils {
      * @param value
      * @param preferenceName
      */
-    static put(key: string, value: preferences.ValueType, u3?: string): Promise<void>;
+    static put(z5: string, a6: preferences.ValueType, b6?: string): Promise<void>;
     /**
      * 获取缓存值
      * @param key
@@ -15,44 +15,44 @@ export declare class PLVPreferencesUtils {
      * @param preferenceName
      * @returns
      */
-    static get(key: string, defValue: preferences.ValueType, t3?: string): Promise<preferences.ValueType>;
+    static get(w5: string, x5: preferences.ValueType, y5?: string): Promise<preferences.ValueType>;
     /**
      * 获取string类型的缓存值
      * @param key
      * @returns
      */
-    static getString(key: string, s3?: string): Promise<string>;
+    static getString(u5: string, v5?: string): Promise<string>;
     /**
      * 获取number类型的缓存值
      * @param key
      * @returns
      */
-    static getNumber(key: string, r3?: string, defaultValue?: number): Promise<number>;
+    static getNumber(r5: string, s5?: string, t5?: number): Promise<number>;
     /**
      * 获取boolean类型的缓存值
      * @param key
      * @param preferenceName
      * @returns
      */
-    static getBoolean(key: string, q3?: string): Promise<boolean>;
+    static getBoolean(p5: string, q5?: string): Promise<boolean>;
     /**
      * 检查缓存的Preferences实例中是否包含名为给定Key的存储键值对
      * @param key
      * @param preferenceName
      * @returns
      */
-    static has(key: string, p3?: string): Promise<boolean>;
+    static has(n5: string, o5?: string): Promise<boolean>;
     /**
      * 删除缓存值
      * @param key
      * @param preferenceName
      * @returns
      */
-    static delete(key: string, n3?: string): Promise<void>;
+    static delete(l5: string, m5?: string): Promise<void>;
     /**
      * 清空缓存
      * @param preferenceName
      * @returns
      */
-    static clear(m3?: string): Promise<void>;
+    static clear(k5?: 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, u3 = defaultPreferenceName) {
-        await PreferencesUtil.put(key, value, u3);
+    static async put(z5, a6, b6 = defaultPreferenceName) {
+        await PreferencesUtil.put(z5, a6, b6);
     }
-    static async get(key, defValue, t3 = defaultPreferenceName) {
-        return PreferencesUtil.get(key, defValue, t3);
+    static async get(w5, x5, y5 = defaultPreferenceName) {
+        return PreferencesUtil.get(w5, x5, y5);
     }
-    static async getString(key, s3 = defaultPreferenceName) {
-        return (await PreferencesUtil.get(key, "", s3));
+    static async getString(u5, v5 = defaultPreferenceName) {
+        return (await PreferencesUtil.get(u5, "", v5));
     }
-    static async getNumber(key, r3 = defaultPreferenceName, defaultValue = 0) {
-        return (await PreferencesUtil.get(key, defaultValue, r3));
+    static async getNumber(r5, s5 = defaultPreferenceName, t5 = 0) {
+        return (await PreferencesUtil.get(r5, t5, s5));
     }
-    static async getBoolean(key, q3 = defaultPreferenceName) {
-        return (await PreferencesUtil.get(key, false, q3));
+    static async getBoolean(p5, q5 = defaultPreferenceName) {
+        return (await PreferencesUtil.get(p5, false, q5));
     }
-    static async has(key, p3 = defaultPreferenceName) {
-        return PreferencesUtil.has(key, p3);
+    static async has(n5, o5 = defaultPreferenceName) {
+        return PreferencesUtil.has(n5, o5);
     }
-    static async delete(key, n3 = defaultPreferenceName) {
-        return PreferencesUtil.delete(key, n3);
+    static async delete(l5, m5 = defaultPreferenceName) {
+        return PreferencesUtil.delete(l5, m5);
     }
-    static async clear(m3 = defaultPreferenceName) {
-        return PreferencesUtil.clear(m3);
+    static async clear(k5 = defaultPreferenceName) {
+        return PreferencesUtil.clear(k5);
     }
 }

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

@@ -5,7 +5,7 @@ export declare class PLVScheduledTask {
     timerId?: number;
     nextExecutionTime: number;
     isRunning: boolean;
-    constructor(callback: Function, delay: number, period?: number);
+    constructor(f6: Function, g6: number, h6?: number);
     start(): void;
     scheduleNextExecution(): Promise<void>;
     cancel(): void;

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

@@ -1,10 +1,10 @@
 import PLVLogger from '../modules/log/PLVLogger';
 const TAG = '[PLVScheduledTask]';
 export class PLVScheduledTask {
-    constructor(callback, delay, period = delay) {
-        this.callback = callback;
-        this.delay = delay;
-        this.period = period;
+    constructor(f6, g6, h6 = g6) {
+        this.callback = f6;
+        this.delay = g6;
+        this.period = h6;
         this.timerId = undefined;
         this.nextExecutionTime = 0;
         this.isRunning = false;
@@ -21,18 +21,18 @@ export class PLVScheduledTask {
         if (!this.isRunning) {
             return;
         }
-        const now = Date.now();
-        const v3 = Math.max(0, this.nextExecutionTime - now);
+        const c6 = Date.now();
+        const d6 = Math.max(0, this.nextExecutionTime - c6);
         this.timerId = setTimeout(async () => {
             try {
                 await this.callback();
             }
-            catch (error) {
-                PLVLogger.printError(TAG, 'scheduleNextExecution error', error);
+            catch (e6) {
+                PLVLogger.printError(TAG, 'scheduleNextExecution error', e6);
             }
             this.nextExecutionTime = Date.now() + this.period;
             this.scheduleNextExecution();
-        }, v3);
+        }, d6);
     }
     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(y3?: number);
-    observe(callback?: PLVCallback<T[]>): void;
+    constructor(k6?: number);
+    observe(j6?: PLVCallback<T[]>): void;
     release(): void;
-    push(x3: T): void;
+    push(i6: T): void;
 }

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

@@ -1,16 +1,16 @@
-const w3 = 500;
+const SOCKET_EVENT_BUFFER_TIMESPAN = 500;
 export class PLVSimpleBuffer {
-    constructor(y3 = w3) {
+    constructor(k6 = SOCKET_EVENT_BUFFER_TIMESPAN) {
         this.buffer = [];
-        this.timespan = w3;
+        this.timespan = SOCKET_EVENT_BUFFER_TIMESPAN;
         this.isRelease = false;
-        this.timespan = y3;
+        this.timespan = k6;
     }
-    observe(callback) {
+    observe(j6) {
         if (this.intervalId == undefined) {
             this.intervalId = setInterval(() => {
                 if (this.buffer.length > 0) {
-                    callback?.(this.buffer);
+                    j6?.(this.buffer);
                     this.buffer.length = 0;
                 }
             }, this.timespan);
@@ -21,10 +21,10 @@ export class PLVSimpleBuffer {
         clearInterval(this.intervalId);
         this.buffer.length = 0;
     }
-    push(x3) {
+    push(i6) {
         if (this.isRelease) {
             return;
         }
-        this.buffer.push(x3);
+        this.buffer.push(i6);
     }
 }

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

@@ -1,10 +1,10 @@
 export declare class PLVSparseArray<V> {
     private entries;
-    set(key: number, value: V): void;
-    get(key: number): V | undefined;
-    delete(key: number): void;
+    set(y6: number, z6: V): void;
+    get(v6: number): V | undefined;
+    delete(t6: 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;
+    forEach(r6: (key: number, value: V) => void): void;
+    forEachReverse(o6: (key: number, value: V) => void): void;
+    someReverse(l6: (key: number, value: V) => boolean): boolean;
 }

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

@@ -2,40 +2,40 @@ 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;
+    set(y6, z6) {
+        const a7 = this.entries.findIndex((b7) => b7[0] >= y6);
+        if (a7 >= 0 && this.entries[a7][0] === y6) {
+            this.entries[a7][1] = z6;
         }
         else {
-            this.entries.splice(h4 >= 0 ? h4 : this.entries.length, 0, [key, value]);
+            this.entries.splice(a7 >= 0 ? a7 : this.entries.length, 0, [y6, z6]);
         }
     }
-    get(key) {
-        const f4 = this.entries.find((g4) => g4[0] === key);
-        return f4 ? f4[1] : undefined;
+    get(v6) {
+        const w6 = this.entries.find((x6) => x6[0] === v6);
+        return w6 ? w6[1] : undefined;
     }
-    delete(key) {
-        this.entries = this.entries.filter((e4) => e4[0] !== key);
+    delete(t6) {
+        this.entries = this.entries.filter((u6) => u6[0] !== t6);
     }
     size() {
         return this.entries.length;
     }
-    forEach(callback) {
-        for (const d4 of this.entries) {
-            callback(d4[0], d4[1]);
+    forEach(r6) {
+        for (const s6 of this.entries) {
+            r6(s6[0], s6[1]);
         }
     }
-    forEachReverse(callback) {
-        for (let b4 = this.entries.length - 1; b4 >= 0; b4--) {
-            const c4 = this.entries[b4];
-            callback(c4[0], c4[1]);
+    forEachReverse(o6) {
+        for (let p6 = this.entries.length - 1; p6 >= 0; p6--) {
+            const q6 = this.entries[p6];
+            o6(q6[0], q6[1]);
         }
     }
-    someReverse(callback) {
-        for (let z3 = this.entries.length - 1; z3 >= 0; z3--) {
-            const a4 = this.entries[z3];
-            if (callback(a4[0], a4[1])) {
+    someReverse(l6) {
+        for (let m6 = this.entries.length - 1; m6 >= 0; m6--) {
+            const n6 = this.entries[m6];
+            if (l6(n6[0], n6[1])) {
                 return true;
             }
         }

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

@@ -1,10 +1,10 @@
 export declare class PLVTextUtils {
-    static checkValidDataLength(...str: string[]): boolean;
-    static parseString(input?: string): string[];
-    static convertSpecialString(input?: string): string;
-    static toString(num?: number): string | undefined;
-    static toWString(data?: number): string | undefined;
-    static toKString(data?: number): string | undefined;
-    static fixPic(k4?: string): string;
-    static isNumberZero(number?: string): boolean;
+    static checkValidDataLength(...r7: string[]): boolean;
+    static parseString(j7?: string): string[];
+    static convertSpecialString(i7?: string): string;
+    static toString(h7?: number): string | undefined;
+    static toWString(g7?: number): string | undefined;
+    static toKString(f7?: number): string | undefined;
+    static fixPic(e7?: string): string;
+    static isNumberZero(c7?: string): boolean;
 }

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

@@ -1,37 +1,37 @@
 export class PLVTextUtils {
-    static checkValidDataLength(...str) {
-        for (const s of str) {
-            if (s.length == 0) {
+    static checkValidDataLength(...r7) {
+        for (const s7 of r7) {
+            if (s7.length == 0) {
                 return false;
             }
         }
         return true;
     }
-    static parseString(input) {
-        if (!(input = PLVTextUtils.convertSpecialString(input))) {
+    static parseString(j7) {
+        if (!(j7 = PLVTextUtils.convertSpecialString(j7))) {
             return undefined;
         }
-        const l4 = /\[([^\[\]]{1,5})\]/g;
-        let match;
-        let m4 = 0;
-        const result = [];
-        while ((match = l4.exec(input)) !== null) {
-            const o4 = match[0];
-            if (match.index > m4) {
-                const p4 = input.slice(m4, match.index);
-                result.push(p4);
+        const k7 = /\[([^\[\]]{1,5})\]/g;
+        let l7;
+        let m7 = 0;
+        const n7 = [];
+        while ((l7 = k7.exec(j7)) !== null) {
+            const p7 = l7[0];
+            if (l7.index > m7) {
+                const q7 = j7.slice(m7, l7.index);
+                n7.push(q7);
             }
-            result.push(o4);
-            m4 = l4.lastIndex;
+            n7.push(p7);
+            m7 = k7.lastIndex;
         }
-        if (m4 < input.length) {
-            const n4 = input.slice(m4);
-            result.push(n4);
+        if (m7 < j7.length) {
+            const o7 = j7.slice(m7);
+            n7.push(o7);
         }
-        return result;
+        return n7;
     }
-    static convertSpecialString(input) {
-        return input?.replace(/&lt;/g, "<")
+    static convertSpecialString(i7) {
+        return i7?.replace(/&lt;/g, "<")
             .replace(/&lt/g, "<")
             .replace(/&gt;/g, ">")
             .replace(/&gt/g, ">")
@@ -42,38 +42,38 @@ export class PLVTextUtils {
             .replace(/&#39;/g, "'")
             .replace(/&amp;/g, "&");
     }
-    static toString(num) {
-        return (num || num == 0) ? num + '' : undefined;
+    static toString(h7) {
+        return (h7 || h7 == 0) ? h7 + '' : undefined;
     }
-    static toWString(data) {
-        if (data && data > 10000) {
-            return (data / 10000).toFixed(1) + 'w';
+    static toWString(g7) {
+        if (g7 && g7 > 10000) {
+            return (g7 / 10000).toFixed(1) + 'w';
         }
-        return PLVTextUtils.toString(data);
+        return PLVTextUtils.toString(g7);
     }
-    static toKString(data) {
-        if (data && data > 1000) {
-            return (data / 1000).toFixed(1) + 'k';
+    static toKString(f7) {
+        if (f7 && f7 > 1000) {
+            return (f7 / 1000).toFixed(1) + 'k';
         }
-        return PLVTextUtils.toString(data);
+        return PLVTextUtils.toString(f7);
     }
-    static fixPic(k4) {
-        if (!k4) {
-            return k4 || '';
+    static fixPic(e7) {
+        if (!e7) {
+            return e7 || '';
         }
-        if (k4.startsWith('//')) {
-            return `http:${k4}`;
+        if (e7.startsWith('//')) {
+            return `http:${e7}`;
         }
-        else if (k4.startsWith('/')) {
-            return `http://livestatic.videocc.net${k4}`;
+        else if (e7.startsWith('/')) {
+            return `http://livestatic.videocc.net${e7}`;
         }
-        return k4;
+        return e7;
     }
-    static isNumberZero(number) {
-        if (!number) {
+    static isNumberZero(c7) {
+        if (!c7) {
             return true;
         }
-        const j4 = parseFloat(number);
-        return j4 === 0;
+        const d7 = parseFloat(c7);
+        return d7 === 0;
     }
 }

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

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

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

@@ -1,14 +1,14 @@
 export class PLVTimeUtils {
-    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')}`;
+    static generateTime(t7, u7) {
+        const v7 = Math.floor(t7 / 1000);
+        const w7 = v7 % 60;
+        const x7 = Math.floor((v7 / 60) % 60);
+        const y7 = Math.floor(v7 / 3600);
+        if (u7 || y7 > 0) {
+            return `${y7.toString().padStart(2, '0')}:${x7.toString().padStart(2, '0')}:${w7.toString().padStart(2, '0')}`;
         }
         else {
-            return `${u4.toString().padStart(2, '0')}:${t4.toString().padStart(2, '0')}`;
+            return `${x7.toString().padStart(2, '0')}:${w7.toString().padStart(2, '0')}`;
         }
     }
 }

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

@@ -1,7 +1,7 @@
 export declare class PLVToastUtils {
-    shortShow(message: string | Resource): void;
-    longShow(message: string | Resource): void;
+    shortShow(c8: string | Resource): void;
+    longShow(b8: string | Resource): void;
     private show;
 }
-declare const u8: PLVToastUtils;
-export default u8;
+declare const _default: PLVToastUtils;
+export default _default;

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

@@ -1,16 +1,16 @@
 import promptAction from "@ohos.promptAction";
 import PLVCommonConstants from './PLVCommonConstants';
 export class PLVToastUtils {
-    shortShow(message) {
-        this.show(message, PLVCommonConstants.LENGTH_SHORT);
+    shortShow(c8) {
+        this.show(c8, PLVCommonConstants.LENGTH_SHORT);
     }
-    longShow(message) {
-        this.show(message, PLVCommonConstants.LENGTH_LONG);
+    longShow(b8) {
+        this.show(b8, PLVCommonConstants.LENGTH_LONG);
     }
-    show(message, duration) {
+    show(z7, a8) {
         promptAction.showToast({
-            message: message,
-            duration: duration
+            message: z7,
+            duration: a8
         });
     }
 }

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

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

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

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

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

@@ -1,32 +1,33 @@
 import { PLVAvoidAreaChangeListener, PLVCallback, PLVCallback2, PLVDisposable, PLVMediaQueryListener } from './PLVCallback';
-import { common } from '@kit.AbilityKit';
-import { mediaquery, window } from '@kit.ArkUI';
+import common from "@ohos.app.ability.common";
+import mediaquery from "@ohos.mediaquery";
+import window from "@ohos.window";
 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, 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>, 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>;
-    static validCallback(callback: string): boolean;
+    static init(f11: common.UIAbilityContext, g11: window.WindowStage): void;
+    static getClassTag(c11?: string | Object, d11?: boolean): string | undefined;
+    static retryWhen<u23 = void>(y10: PLVCallback<void, u23>, z10: PLVCallback<void, u23>): Promise<Awaited<u23>>;
+    static disposablePromise<t23>(v10: Promise<t23>, w10?: PLVDisposable): Promise<t23>;
+    static safePromise<s23 = void>(p10: PLVCallback2<PLVResolve<s23>, PLVReject, void>, q10?: PLVDisposable): Promise<s23>;
+    static retryPromise<r23>(h10: number, i10: number, j10: Promise<r23>, k10?: PLVDisposable): Promise<r23>;
+    static delay(f10?: number): Promise<void>;
+    static validCallback(e10: string): boolean;
     static getPid(): string;
     static getDeviceId(): string;
-    static undefinedToValue<T>(data: T, callback: PLVCallback<T, void>, delay?: number): undefined;
-    static copyText(text: string): Promise<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, h5?: window.Window): Promise<Object[]>;
-    static setWindowSystemBarProperties(systemBarProperties?: window.SystemBarProperties): void;
-    static startScan(component?: Object): Promise<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;
+    static undefinedToValue<q23>(z9: q23, a10: PLVCallback<q23, void>, b10?: number): undefined;
+    static copyText(y9: string): Promise<void>;
+    static listenerOrientation(w9: PLVCallback<mediaquery.MediaQueryResult>): PLVMediaQueryListener;
+    static listenerAvoidAreaChange(t9: PLVCallback<window.AvoidAreaOptions>): PLVAvoidAreaChangeListener;
+    static changeOrientation(m9: boolean, n9?: Object, o9?: window.Window): void;
+    static isLandscape(k9?: Object): boolean;
+    static setWindowFullScreen(z8?: boolean, a9?: boolean, b9?: Object, c9?: window.Window): Promise<Object[]>;
+    static setWindowSystemBarProperties(y8?: window.SystemBarProperties): void;
+    static startScan(s8?: Object): Promise<string>;
+    static getVideoRectJS(q8: boolean): string;
+    static getExitFullScreenJS(o8: boolean): string;
+    static colorResourceToHex(n8: Resource): string;
+    static colorIntToHex(k8: number, l8?: boolean): string;
+    static debounce(g8: Function, h8?: number, i8?: string): void;
 }