@polyvharmony/live-scenes-foundation 1.3.0-rc.3 → 1.3.1

package/src/main/ets/common/ui/PLVNodeController.js

@@ -1,40 +1,41 @@
-import { BuilderNode, NodeController } from "@ohos.arkui.node";
+import { BuilderNode as BuilderNode } from "@ohos.arkui.node";
+import { NodeController as NodeController } from "@ohos.arkui.node";
 import { PLVPromiseValue } from '../PLVCallback';
-const l6 = new Map();
+const viewNodes = new Map();
 export class PLVNodeControllerManager {
     constructor() {
         this.controllers = new Map();
     }
-    static get(id = 0) {
-        if (!PLVNodeControllerManager.controllerManagers.has(id)) {
-            PLVNodeControllerManager.controllerManagers.set(id, new PLVNodeControllerManager());
+    static get(q12 = 0) {
+        if (!PLVNodeControllerManager.controllerManagers.has(q12)) {
+            PLVNodeControllerManager.controllerManagers.set(q12, new PLVNodeControllerManager());
         }
-        return PLVNodeControllerManager.controllerManagers.get(id);
+        return PLVNodeControllerManager.controllerManagers.get(q12);
     }
-    static delete(id) {
-        PLVNodeControllerManager.get(id).destroy();
-        PLVNodeControllerManager.controllerManagers.delete(id);
+    static delete(p12) {
+        PLVNodeControllerManager.get(p12).destroy();
+        PLVNodeControllerManager.controllerManagers.delete(p12);
     }
-    getOrCreate(config) {
-        const uniqueId = typeof config === 'string' ? config : config.name;
-        if (!this.controllers.has(uniqueId)) {
-            this.controllers.set(uniqueId, new PLVNodeController(typeof config === 'string' ? { name: uniqueId } : config));
+    getOrCreate(m12) {
+        const n12 = typeof m12 === 'string' ? m12 : m12.name;
+        if (!this.controllers.has(n12)) {
+            this.controllers.set(n12, new PLVNodeController(typeof m12 === 'string' ? { name: n12 } : m12));
         }
-        const controller = this.controllers.get(uniqueId);
-        if (typeof config !== 'string' && config.wrapBuilder) {
-            controller.fill(config.wrapBuilder, config.params);
-            controller.show(config.isShow);
+        const o12 = this.controllers.get(n12);
+        if (typeof m12 !== 'string' && m12.wrapBuilder) {
+            o12.fill(m12.wrapBuilder, m12.params);
+            o12.show(m12.isShow);
         }
-        return controller;
+        return o12;
     }
-    destroy(uniqueId) {
-        if (uniqueId) {
-            this.controllers.get(uniqueId)?.destroy();
-            this.controllers.delete(uniqueId);
+    destroy(k12) {
+        if (k12) {
+            this.controllers.get(k12)?.destroy();
+            this.controllers.delete(k12);
         }
         else {
-            this.controllers.forEach((controller) => {
-                controller.destroy();
+            this.controllers.forEach((l12) => {
+                l12.destroy();
             });
             this.controllers.clear();
         }
@@ -42,7 +43,7 @@ export class PLVNodeControllerManager {
 }
 PLVNodeControllerManager.controllerManagers = new Map();
 export class PLVNodeController extends NodeController {
-    constructor(config) {
+    constructor(j12) {
         super();
         this.viewNode = undefined;
         this.wrapBuilder = undefined;
@@ -51,52 +52,52 @@ export class PLVNodeController extends NodeController {
         this.isShowPromise = new PLVPromiseValue();
         this.uiContext = undefined;
         this.environmentCallback = undefined;
-        this.uniqueId = config.name;
-        this.isShow = config.isShow;
-        this.wrapBuilder = config.wrapBuilder;
-        this.params = config.params;
+        this.uniqueId = j12.name;
+        this.isShow = j12.isShow;
+        this.wrapBuilder = j12.wrapBuilder;
+        this.params = j12.params;
         this.show(this.isShow);
     }
-    makeNode(uiContext) {
+    makeNode(i12) {
         if (!this.isShow || !this.wrapBuilder) {
             return null;
         }
-        this.uiContext = uiContext;
-        this.viewNode = l6.get(this.uniqueId) ?? new BuilderNode(uiContext);
-        l6.set(this.uniqueId, this.viewNode);
+        this.uiContext = i12;
+        this.viewNode = viewNodes.get(this.uniqueId) ?? new BuilderNode(i12);
+        viewNodes.set(this.uniqueId, this.viewNode);
         if (!this.viewNode.getFrameNode()) {
             this.viewNode.build(this.wrapBuilder, this.params);
-            this.onEnvironment(uiContext);
+            this.onEnvironment(i12);
         }
         return this.viewNode.getFrameNode();
     }
-    fill(wrapBuilder, params) {
-        this.wrapBuilder = wrapBuilder;
-        this.params = params;
+    fill(g12, h12) {
+        this.wrapBuilder = g12;
+        this.params = h12;
         return this;
     }
-    show(isShow = false) {
-        if (this.isShow === isShow || !this.wrapBuilder) {
+    show(f12 = false) {
+        if (this.isShow === f12 || !this.wrapBuilder) {
             return;
         }
-        this.isShow = isShow;
+        this.isShow = f12;
         this.rebuild();
-        this.isShowPromise.set(isShow);
+        this.isShowPromise.set(f12);
     }
     destroy() {
-        l6.get(this.uniqueId)?.dispose();
-        l6.delete(this.uniqueId);
+        viewNodes.get(this.uniqueId)?.dispose();
+        viewNodes.delete(this.uniqueId);
         if (this.environmentCallback !== undefined) {
             this.uiContext?.getHostContext()?.getApplicationContext().off('environment', this.environmentCallback);
         }
         this.uiContext = undefined;
     }
-    onEnvironment(uiContext) {
-        this.environmentCallback = uiContext.getHostContext()?.getApplicationContext().on('environment', {
-            onConfigurationUpdated: (config) => {
+    onEnvironment(c12) {
+        this.environmentCallback = c12.getHostContext()?.getApplicationContext().on('environment', {
+            onConfigurationUpdated: (e12) => {
                 this.viewNode?.updateConfiguration();
             },
-            onMemoryLevel: (level) => {
+            onMemoryLevel: (d12) => {
             }
         });
     }

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

@@ -1,20 +1,20 @@
 import { PLVPrintLogLevel } from '../../common/PLVCommonEnums';
-import { common } from '@kit.AbilityKit';
+import common from "@ohos.app.ability.common";
 export declare class PLVLogger {
     private printLogLevel;
     private tag;
     private format;
     private filePrinter?;
-    init(context: common.UIAbilityContext): void;
-    level(v6: PLVPrintLogLevel): void;
-    debug(tag: string, message: string, u6?: boolean): void;
-    info(tag: string, message: string, t6?: boolean): void;
-    warn(tag: string, message: string, s6?: boolean): void;
-    error(tag: string, message: string, r6?: boolean): void;
-    printWarn(tag: string, q6: string, err: Error): string;
-    printError(tag: string, p6: string, err: Error): string;
+    init(w13: common.UIAbilityContext): void;
+    level(v13: PLVPrintLogLevel): void;
+    debug(r13: string, s13: string, t13?: boolean): void;
+    info(n13: string, o13: string, p13?: boolean): void;
+    warn(j13: string, k13: string, l13?: boolean): void;
+    error(f13: string, g13: string, h13?: boolean): void;
+    printWarn(b13: string, c13: string, d13: Error): string;
+    printError(x12: string, y12: string, z12: Error): string;
     private generateErrorMsg;
     private intercept;
 }
-declare const u8: PLVLogger;
-export default u8;
+declare const _default: PLVLogger;
+export default _default;

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

@@ -9,59 +9,59 @@ export class PLVLogger {
         this.tag = PLVCommonConstants.TAG.substring(1, PLVCommonConstants.TAG.length - 1);
         this.format = "%s";
     }
-    init(context) {
-        const config = new LogConfiguration.Builder()
+    init(w13) {
+        const x13 = new LogConfiguration.Builder()
             .setTag(this.tag)
             .build();
-        const filesDir = context.filesDir;
-        this.filePrinter = new PLVXLogBuilder(`${filesDir}/log`, true, '../../modules/log/PLVXLogWorker.ets')
+        const y13 = w13.filesDir;
+        this.filePrinter = new PLVXLogBuilder(`${y13}/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()]);
+        XLog.init(x13, [new OhPrinter()]);
     }
-    level(v6) {
-        this.printLogLevel = v6;
+    level(v13) {
+        this.printLogLevel = v13;
     }
-    debug(tag, message, u6 = true) {
-        const msg = util.format(this.format, tag, message);
-        this.intercept(PLVPrintLogLevel.DEBUG, msg, u6) || XLog.d(msg);
+    debug(r13, s13, t13 = true) {
+        const u13 = util.format(this.format, r13, s13);
+        this.intercept(PLVPrintLogLevel.DEBUG, u13, t13) || XLog.d(u13);
     }
-    info(tag, message, t6 = true) {
-        const msg = util.format(this.format, tag, message);
-        this.intercept(PLVPrintLogLevel.INFO, msg, t6) || XLog.i(msg);
+    info(n13, o13, p13 = true) {
+        const q13 = util.format(this.format, n13, o13);
+        this.intercept(PLVPrintLogLevel.INFO, q13, p13) || XLog.i(q13);
     }
-    warn(tag, message, s6 = true) {
-        const msg = util.format(this.format, tag, message);
-        this.intercept(PLVPrintLogLevel.WARN, msg, s6) || XLog.w(msg);
+    warn(j13, k13, l13 = true) {
+        const m13 = util.format(this.format, j13, k13);
+        this.intercept(PLVPrintLogLevel.WARN, m13, l13) || XLog.w(m13);
     }
-    error(tag, message, r6 = true) {
-        const msg = util.format(this.format, tag, message);
-        this.intercept(PLVPrintLogLevel.ERROR, msg, r6) || XLog.e(msg);
+    error(f13, g13, h13 = true) {
+        const i13 = util.format(this.format, f13, g13);
+        this.intercept(PLVPrintLogLevel.ERROR, i13, h13) || XLog.e(i13);
     }
-    printWarn(tag, q6, err) {
-        const msg = this.generateErrorMsg(q6, err);
-        this.warn(tag, msg);
-        return msg;
+    printWarn(b13, c13, d13) {
+        const e13 = this.generateErrorMsg(c13, d13);
+        this.warn(b13, e13);
+        return e13;
     }
-    printError(tag, p6, err) {
-        const msg = this.generateErrorMsg(p6, err);
-        this.error(tag, msg);
-        return msg;
+    printError(x12, y12, z12) {
+        const a13 = this.generateErrorMsg(y12, z12);
+        this.error(x12, a13);
+        return a13;
     }
-    generateErrorMsg(n6, err) {
-        let o6 = '';
-        if (err && err.code) {
-            o6 = `, code=${err.code}`;
+    generateErrorMsg(u12, v12) {
+        let w12 = '';
+        if (v12 && v12.code) {
+            w12 = `, code=${v12.code}`;
         }
-        return `${n6}: name=${err.name}, message=${err.message}${o6}\n${err.stack}`;
+        return `${u12}: name=${v12.name}, message=${v12.message}${w12}\n${v12.stack}`;
     }
-    intercept(level, msg, m6 = true) {
-        if (m6) {
-            this.filePrinter?.println(level, this.tag, msg);
+    intercept(r12, s12, t12 = true) {
+        if (t12) {
+            this.filePrinter?.println(r12, this.tag, s12);
         }
-        return this.printLogLevel > level;
+        return this.printLogLevel > r12;
     }
 }
 export default new PLVLogger();

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

@@ -4,8 +4,8 @@ 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(w6: number, tag: string, msg: string): void;
+    constructor(d14: FilePrinter.Builder);
+    println(z13: number, a14: string, b14: string): void;
 }
 export declare class PLVXLogBuilder extends FilePrinter.Builder {
     build(): FilePrinter;

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

@@ -3,29 +3,31 @@ 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) {
+    constructor(d14) {
         super();
-        this.builder = builder;
+        this.builder = d14;
         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.onmessage = (h14) => {
+                    let i14 = h14.data;
+                    let j14 = i14.type;
                 };
-                this.workerInstance.onexit = (code) => {
+                this.workerInstance.onexit = (g14) => {
+                    console.info("XLog: workerInstance onexit");
                 };
-                let data = new LogInitMessage(this.builder);
-                this.workerInstance.postMessage(data);
+                let f14 = new LogInitMessage(this.builder);
+                this.workerInstance.postMessage(f14);
             }
-            catch (err) {
+            catch (e14) {
+                console.error("XLog start worker err: " + e14);
             }
         }
     }
-    println(w6, tag, msg) {
+    println(z13, a14, b14) {
         if (this.workerInstance != null) {
-            let data = new LogAddMessage(w6, tag, msg);
-            this.workerInstance.postMessage(data);
+            let c14 = new LogAddMessage(z13, a14, b14);
+            this.workerInstance.postMessage(c14);
         }
     }
 }

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

@@ -4,5 +4,5 @@ export declare class PLVHttpData<T> {
     status?: string;
     message?: string;
     data?: T;
-    static fill<T>(x6: T, data: PLVResponse<T>): void;
+    static fill<v23>(k14: v23, l14: PLVResponse<v23>): void;
 }

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

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

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

@@ -1,5 +1,5 @@
 import { AxiosError } from '@ohos/axios';
 export declare class PLVHttpError extends AxiosError {
-    constructor(z6: AxiosError);
-    log(tag: string, y6: string): this;
+    constructor(o14: AxiosError);
+    log(m14: string, n14: string): this;
 }

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

@@ -2,12 +2,12 @@ import { AxiosError } from '@ohos/axios';
 import PLVJSONUtils from '../../common/PLVJSONUtils';
 import PLVLogger from '../log/PLVLogger';
 export class PLVHttpError extends AxiosError {
-    constructor(z6) {
-        const message = (z6.response?.data && PLVJSONUtils.safeStringify(z6.response.data)) || z6.message;
-        super(message, z6.code, z6.config, z6.request, z6.response);
+    constructor(o14) {
+        const p14 = (o14.response?.data && PLVJSONUtils.safeStringify(o14.response.data)) || o14.message;
+        super(p14, o14.code, o14.config, o14.request, o14.response);
     }
-    log(tag, y6) {
-        PLVLogger.printError(tag, y6, this);
+    log(m14, n14) {
+        PLVLogger.printError(m14, n14, this);
         return this;
     }
 }

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

@@ -1,5 +1,5 @@
 import { AxiosRequestConfig, AxiosResponse } from '@ohos/axios';
-import { HashMap } from '@kit.ArkTS';
+import HashMap from "@ohos.util.HashMap";
 export declare class PLVHttpRequest {
     static readonly CACHE_TIMEOUT: number;
     static readonly CACHE_DATA_MAP: HashMap<string, AxiosResponse>;
@@ -7,19 +7,20 @@ export declare class PLVHttpRequest {
     baseURL?: string;
     userAgent?: string;
     private method?;
-    constructor(g7?: string);
-    ua(f7?: string): this;
-    create<z8 = Object>(config?: PLVAxiosRequestConfig<z8>): import("@ohos/axios").AxiosInstance;
-    request<T = Object, R = AxiosResponse<T>>(p: Promise<AxiosResponse<T>>): Promise<R>;
-    get<T = Object, R = AxiosResponse<T>, y8 = Object>(config?: PLVAxiosRequestConfig<y8>): Promise<R>;
-    post<T = Object, R = AxiosResponse<T>, x8 = Object>(config?: PLVAxiosRequestConfig<x8>): Promise<R>;
-    checkCache<T = Object, R = AxiosResponse<T>, w8 = Object>(config?: PLVAxiosRequestConfig<w8>): Promise<R> | undefined;
-    generateCacheKey(config?: AxiosRequestConfig): string;
+    constructor(w15?: string);
+    ua(v15?: string): this;
+    create<m24 = Object>(i15?: PLVAxiosRequestConfig<m24>): import("@ohos/axios").AxiosInstance;
+    request<k24 = Object, l24 = AxiosResponse<k24>>(b15: Promise<AxiosResponse<k24>>): Promise<l24>;
+    get<h24 = Object, i24 = AxiosResponse<h24>, j24 = Object>(a15?: PLVAxiosRequestConfig<j24>): Promise<i24>;
+    post<e24 = Object, f24 = AxiosResponse<e24>, g24 = Object>(z14?: PLVAxiosRequestConfig<g24>): Promise<f24>;
+    checkCache<b24 = Object, c24 = AxiosResponse<b24>, d24 = Object>(x14?: PLVAxiosRequestConfig<d24>): Promise<c24> | undefined;
+    generateCacheKey(q14?: AxiosRequestConfig): string;
 }
 export interface PLVAxiosRequestConfig<D = Object> extends AxiosRequestConfig<D> {
     formUrlEncoded?: boolean;
     aesDecrypted?: boolean;
     useCache?: boolean;
+    cacheTime?: number;
     fillData?: Object;
     signKey?: string;
 }