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

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

@@ -0,0 +1,103 @@
+import { instanceToPlain, plainToClass, plainToClassFromExist } from 'class-transformer';
+export default class PLVJSONUtils {
+    static safeStringify(value, replacer) {
+        try {
+            return JSON.stringify(value || new Object(), replacer);
+        }
+        catch (e) {
+            return '';
+        }
+    }
+    static safeParse(text) {
+        try {
+            return JSON.parse(text || '');
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    static json2Bean(f3, g3) {
+        try {
+            return plainToClass(f3, JSON.parse(g3), {
+                enableImplicitConversion: false, exposeDefaultValues: true
+            });
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    static bean2Json(data) {
+        try {
+            if (data == null || data == undefined) {
+                return '';
+            }
+            return JSON.stringify(instanceToPlain(data));
+        }
+        catch (e) {
+            return "";
+        }
+    }
+    static bean2Bean(e3, plain) {
+        try {
+            return plainToClassFromExist(e3, plain, {
+                enableImplicitConversion: false, exposeDefaultValues: true
+            });
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    static httpData2Bean(d3, plain) {
+        try {
+            plain.data = plainToClassFromExist(d3, plain.data, {
+                enableImplicitConversion: false, exposeDefaultValues: true
+            });
+            try {
+                plain.data.fill();
+            }
+            catch (err) {
+            }
+            return plain.data;
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    static json2Map(c3) {
+        return new Map(Object.entries(JSON.parse(c3)));
+    }
+    static object2Map(object) {
+        return new Map(Object.entries(object));
+    }
+    static map2json(map) {
+        const obj = {};
+        map.forEach((value, key) => {
+            if (key && value) {
+                obj[key] = value;
+            }
+        });
+        return obj;
+    }
+    static map2jsonStr(map, replacer) {
+        return PLVJSONUtils.safeStringify(PLVJSONUtils.map2json(map), replacer);
+    }
+    static toUnescapedData(a3) {
+        if (!a3.includes('\\')) {
+            return a3;
+        }
+        return a3.substring(1, a3.length - 1)
+            .replace(/\\"/g, '"')
+            .replace(/\\\\/g, '\\');
+    }
+    static toFillData(v2, w2) {
+        let z2 = undefined;
+        if (typeof w2 === 'string') {
+            z2 = PLVJSONUtils.json2Bean(v2, w2);
+        }
+        else if (typeof w2 === 'object') {
+            z2 = PLVJSONUtils.bean2Bean(v2, w2);
+        }
+        z2?.fill();
+        return z2;
+    }
+}

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

@@ -0,0 +1,5 @@
+export declare class PLVNetUtils {
+    static replaceUrl(k3: string, l3: Map<string, string | undefined>): string;
+    static formatUrl(j3: string, record: Record<string, string | undefined>): string;
+    static formatParams(params?: Record<string, string>): string;
+}

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

@@ -0,0 +1,29 @@
+export class PLVNetUtils {
+    static replaceUrl(k3, l3) {
+        const m3 = /{(\w+?)}/g;
+        let match;
+        let n3 = k3;
+        while ((match = m3.exec(k3)) !== null) {
+            const key = match[1];
+            const p3 = l3.get(key);
+            if (p3 !== undefined) {
+                n3 = n3.replace(match[0], p3);
+            }
+        }
+        return n3;
+    }
+    static formatUrl(j3, record) {
+        return PLVNetUtils.replaceUrl(j3, new Map(Object.entries(record)));
+    }
+    static formatParams(params) {
+        let h3 = '';
+        if (params) {
+            Object.entries(params).forEach((value, index) => {
+                if (value?.[0] && value?.[1]) {
+                    h3 += (index == 0 ? '?' : '&') + value?.[0] + '=' + value?.[1];
+                }
+            });
+        }
+        return h3;
+    }
+}

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

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

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

@@ -0,0 +1,30 @@
+import { PreferencesUtil } from '@pura/harmony-utils';
+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 get(key, defValue, w3 = defaultPreferenceName) {
+        return PreferencesUtil.get(key, defValue, w3);
+    }
+    static async getString(key, v3 = defaultPreferenceName) {
+        return (await PreferencesUtil.get(key, "", v3));
+    }
+    static async getNumber(key, u3 = defaultPreferenceName, defaultValue = 0) {
+        return (await PreferencesUtil.get(key, defaultValue, u3));
+    }
+    static async getBoolean(key, t3 = defaultPreferenceName) {
+        return (await PreferencesUtil.get(key, false, t3));
+    }
+    static async has(key, s3 = defaultPreferenceName) {
+        return PreferencesUtil.has(key, s3);
+    }
+    static async delete(key, r3 = defaultPreferenceName) {
+        return PreferencesUtil.delete(key, r3);
+    }
+    static async clear(q3 = defaultPreferenceName) {
+        return PreferencesUtil.clear(q3);
+    }
+}

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

@@ -0,0 +1,12 @@
+export declare class PLVScheduledTask {
+    callback: Function;
+    delay: number;
+    period: number;
+    timerId?: number;
+    nextExecutionTime: number;
+    isRunning: boolean;
+    constructor(callback: Function, delay: number, period?: number);
+    start(): void;
+    scheduleNextExecution(): Promise<void>;
+    cancel(): void;
+}

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

@@ -0,0 +1,44 @@
+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;
+        this.timerId = undefined;
+        this.nextExecutionTime = 0;
+        this.isRunning = false;
+    }
+    start() {
+        if (this.isRunning) {
+            return;
+        }
+        this.isRunning = true;
+        this.nextExecutionTime = Date.now() + this.delay;
+        this.scheduleNextExecution();
+    }
+    async scheduleNextExecution() {
+        if (!this.isRunning) {
+            return;
+        }
+        const now = Date.now();
+        const y3 = Math.max(0, this.nextExecutionTime - now);
+        this.timerId = setTimeout(async () => {
+            try {
+                await this.callback();
+            }
+            catch (error) {
+                PLVLogger.printError(TAG, 'scheduleNextExecution error', error);
+            }
+            this.nextExecutionTime = Date.now() + this.period;
+            this.scheduleNextExecution();
+        }, y3);
+    }
+    cancel() {
+        if (!this.isRunning) {
+            return;
+        }
+        clearTimeout(this.timerId);
+        this.isRunning = false;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { PLVCallback } from './PLVCallback';
+export declare class PLVSimpleBuffer<T> {
+    private buffer;
+    private intervalId?;
+    private timespan;
+    private isRelease;
+    constructor(d4?: number);
+    observe(callback?: PLVCallback<T[]>): void;
+    release(): void;
+    push(b4: T): void;
+}

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

@@ -0,0 +1,30 @@
+const a4 = 500;
+export class PLVSimpleBuffer {
+    constructor(d4 = a4) {
+        this.buffer = [];
+        this.timespan = a4;
+        this.isRelease = false;
+        this.timespan = d4;
+    }
+    observe(callback) {
+        if (this.intervalId == undefined) {
+            this.intervalId = setInterval(() => {
+                if (this.buffer.length > 0) {
+                    callback?.(this.buffer);
+                    this.buffer.length = 0;
+                }
+            }, this.timespan);
+        }
+    }
+    release() {
+        this.isRelease = true;
+        clearInterval(this.intervalId);
+        this.buffer.length = 0;
+    }
+    push(b4) {
+        if (this.isRelease) {
+            return;
+        }
+        this.buffer.push(b4);
+    }
+}

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

@@ -0,0 +1,9 @@
+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 fixPic(f4?: string): string;
+    static isNumberZero(number?: string): boolean;
+}

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

@@ -0,0 +1,73 @@
+export class PLVTextUtils {
+    static checkValidDataLength(...str) {
+        for (const s of str) {
+            if (s.length == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static parseString(input) {
+        if (!(input = PLVTextUtils.convertSpecialString(input))) {
+            return undefined;
+        }
+        const g4 = /\[([^\[\]]{1,5})\]/g;
+        let match;
+        let h4 = 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);
+            }
+            result.push(j4);
+            h4 = g4.lastIndex;
+        }
+        if (h4 < input.length) {
+            const i4 = input.slice(h4);
+            result.push(i4);
+        }
+        return result;
+    }
+    static convertSpecialString(input) {
+        return input?.replace(/&lt;/g, "<")
+            .replace(/&lt/g, "<")
+            .replace(/&gt;/g, ">")
+            .replace(/&gt/g, ">")
+            .replace(/&yen;/g, "¥")
+            .replace(/&yen/g, "¥")
+            .replace(/&quot;/g, "\"")
+            .replace(/&nbsp;/g, " ")
+            .replace(/&#39;/g, "'")
+            .replace(/&amp;/g, "&");
+    }
+    static toString(num) {
+        return (num || num == 0) ? num + '' : undefined;
+    }
+    static toWString(data) {
+        if (data && data > 10000) {
+            return (data / 10000).toFixed(1) + 'w';
+        }
+        return PLVTextUtils.toString(data);
+    }
+    static fixPic(f4) {
+        if (!f4) {
+            return f4 || '';
+        }
+        if (f4.startsWith('//')) {
+            return `http:${f4}`;
+        }
+        else if (f4.startsWith('/')) {
+            return `http://livestatic.videocc.net${f4}`;
+        }
+        return f4;
+    }
+    static isNumberZero(number) {
+        if (!number) {
+            return true;
+        }
+        const e4 = parseFloat(number);
+        return e4 === 0;
+    }
+}

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

@@ -0,0 +1,8 @@
+export declare class PLVTimeUtils {
+    /**
+     * 以友好的方式显示视频时间
+     * @param millisecond
+     * @param fit 小时是否适配"00"
+     */
+    static generateTime(l4: number, m4: boolean): string;
+}

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

@@ -0,0 +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')}`;
+        }
+        else {
+            return `${p4.toString().padStart(2, '0')}:${o4.toString().padStart(2, '0')}`;
+        }
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+import promptAction from "@ohos.promptAction";
+import PLVCommonConstants from './PLVCommonConstants';
+export class PLVToastUtils {
+    shortShow(message) {
+        this.show(message, PLVCommonConstants.LENGTH_SHORT);
+    }
+    longShow(message) {
+        this.show(message, PLVCommonConstants.LENGTH_LONG);
+    }
+    show(message, duration) {
+        promptAction.showToast({
+            message: message,
+            duration: duration
+        });
+    }
+}
+export default new PLVToastUtils();

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

@@ -0,0 +1,8 @@
+import { AxiosResponse } from '@ohos/axios';
+import { PLVHttpData } from '../modules/net/PLVHttpData';
+export type PLVResponseObject = AxiosResponse<object>;
+export type PLVResponseData<T> = AxiosResponse<PLVHttpData<T>>;
+export type PLVResponse<T> = PLVResponseData<T> | void;
+export type PLVJSONObject = Record<string, Object | undefined>;
+export type PLVResolve<T> = (value: T | PromiseLike<T>) => void;
+export type PLVReject = (reason?: object) => void;

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

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

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

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

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

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

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

@@ -0,0 +1,25 @@
+import { PLVCallback, PLVCallback2, PLVDisposable } from './PLVCallback';
+import { common } from '@kit.AbilityKit';
+import { window } from '@kit.ArkUI';
+import { PLVReject, PLVResolve } from './PLVType';
+export default class PLVUtils {
+    private constructor();
+    static init(context: common.UIAbilityContext, windowStage: window.WindowStage): void;
+    static getClassTag(tag?: string | Object, f6?: 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 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 getPid(): string;
+    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 isLandscape(component?: Object): boolean;
+    static setWindowFullScreen(isLayoutFullScreen?: boolean, isFullScreen?: boolean, component?: Object, c5?: window.Window): Promise<Object[]>;
+    static startScan(component?: Object): Promise<string>;
+    static getVideoRectJS(w4: boolean): string;
+    static getExitFullScreenJS(u4: boolean): string;
+}