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

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

@@ -9,138 +9,139 @@ import PLVUtils from '../../common/PLVUtils';
 import { PLVNetUtils } from '../../common/PLVNetUtils';
 const TAG = '[PLVHttpRequest]';
 export class PLVHttpRequest {
-    constructor(g7) {
-        this.baseURL = g7;
+    constructor(w15) {
+        this.baseURL = w15;
     }
-    ua(f7) {
-        this.userAgent = f7;
+    ua(v15) {
+        this.userAgent = v15;
         return this;
     }
-    create(config) {
-        const c7 = axios.create();
-        c7.defaults.timeout = 10000;
-        c7.defaults.readTimeout = 10000;
-        c7.defaults.connectTimeout = 10000;
-        c7.defaults.baseURL = this.baseURL;
-        c7.defaults.headers.common["w1"] = this.userAgent;
-        if (config?.formUrlEncoded) {
-            c7.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded';
+    create(i15) {
+        const j15 = axios.create();
+        j15.defaults.timeout = 10000;
+        j15.defaults.readTimeout = 10000;
+        j15.defaults.connectTimeout = 10000;
+        j15.defaults.baseURL = this.baseURL;
+        j15.defaults.headers.common['User-Agent'] = this.userAgent;
+        const k15 = (i15?.cacheTime === 0 ? PLVHttpRequest.CACHE_TIMEOUT : i15?.cacheTime) ?? PLVHttpRequest.CACHE_TIMEOUT;
+        if (i15?.formUrlEncoded) {
+            j15.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded';
         }
-        let cacheKey = '';
-        c7.interceptors.request.use((e7) => {
-            if (config?.signKey) {
-                const data = e7.params ? e7.params : e7.data;
-                const map = PLVJSONUtils.object2Map(data);
-                map.delete('log');
-                data['sign'] = PLVRequestSetting.createSign(map, config.signKey);
+        let l15 = '';
+        j15.interceptors.request.use((q15) => {
+            if (i15?.signKey) {
+                const t15 = q15.params ? q15.params : q15.data;
+                const u15 = PLVJSONUtils.object2Map(t15);
+                u15.delete('log');
+                t15['sign'] = PLVRequestSetting.createSign(u15, i15.signKey);
             }
             if (PLVHttpRequest.token) {
-                const params = e7.params;
-                const data = e7.data;
-                if (params && Object.keys(params).includes('appId')) {
-                    params['token'] = PLVHttpRequest.token;
-                    params["z1"] = PLVHttpRequest.token;
+                const r15 = q15.params;
+                const s15 = q15.data;
+                if (r15 && Object.keys(r15).includes('appId')) {
+                    r15['token'] = PLVHttpRequest.token;
+                    r15['viewerToken'] = PLVHttpRequest.token;
                 }
-                if (data && Object.keys(data).includes('appId')) {
-                    data['token'] = PLVHttpRequest.token;
-                    data["z1"] = PLVHttpRequest.token;
+                if (s15 && Object.keys(s15).includes('appId')) {
+                    s15['token'] = PLVHttpRequest.token;
+                    s15['viewerToken'] = PLVHttpRequest.token;
                 }
             }
-            if (config?.useCache) {
-                cacheKey = this.generateCacheKey(e7);
+            if (i15?.useCache) {
+                l15 = this.generateCacheKey(q15);
             }
-            PLVLogger.info(TAG, `--> ${this.method} ${this.baseURL}${config?.url}${PLVNetUtils.formatParams(e7?.params)}`);
-            PLVLogger.info(TAG, `--> ${PLVNetUtils.formatParams(e7?.data)}`);
-            return e7;
-        }, (error) => {
-            return Promise.reject(error);
+            PLVLogger.info(TAG, `--> ${this.method} ${this.baseURL}${i15?.url}${PLVNetUtils.formatParams(q15?.params)}`);
+            PLVLogger.info(TAG, `--> ${PLVNetUtils.formatParams(q15?.data)}`);
+            return q15;
+        }, (p15) => {
+            return Promise.reject(p15);
         });
-        c7.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 d7 = response.data;
-                if (d7) {
-                    d7['data'] = PLVJSONUtils.safeParse(PLVRequestSetting.decryptDataSync(d7['data']));
+        j15.interceptors.response.use((n15) => {
+            PLVLogger.info(TAG, `<-- ${n15.status} ${this.method} ${this.baseURL}${n15.config.url}${PLVNetUtils.formatParams(i15?.params)} (${n15.performanceTiming?.totalTiming}ms)`);
+            PLVLogger.info(TAG, `Header: ${PLVJSONUtils.safeStringify(n15.headers)}`);
+            PLVLogger.info(TAG, `Result: ${PLVJSONUtils.safeStringify(n15.data)}`);
+            if (i15?.aesDecrypted) {
+                const o15 = n15.data;
+                if (o15) {
+                    o15['data'] = PLVJSONUtils.safeParse(PLVRequestSetting.decryptDataSync(o15['data']));
                 }
                 else {
                     PLVLogger.printError(TAG, 'response error', new Error('jsonData undefined'));
                 }
             }
-            if (config?.fillData) {
-                PLVHttpData.fill(config.fillData, response);
+            if (i15?.fillData) {
+                PLVHttpData.fill(i15.fillData, n15);
             }
-            if (cacheKey) {
-                PLVHttpRequest.CACHE_DATA_MAP.set(cacheKey, response);
+            if (l15) {
+                PLVHttpRequest.CACHE_DATA_MAP.set(l15, n15);
                 setTimeout(() => {
-                    PLVHttpRequest.CACHE_DATA_MAP.remove(cacheKey);
-                }, PLVHttpRequest.CACHE_TIMEOUT);
+                    PLVHttpRequest.CACHE_DATA_MAP.remove(l15);
+                }, k15);
             }
-            return response;
-        }, (error) => {
-            return Promise.reject(error);
+            return n15;
+        }, (m15) => {
+            return Promise.reject(m15);
         });
-        return c7;
+        return j15;
     }
-    request(p) {
-        return PLVUtils.safePromise((b7, reject) => {
-            p.then((r) => {
-                const data = r.data;
-                if (data) {
-                    for (const key of Object.keys(data)) {
-                        if (key == 'code' && data[key] != 200 + '') {
-                            reject(new PLVHttpError(new AxiosError(PLVJSONUtils.safeStringify(r.data || ''), data[key], undefined, undefined, r)));
+    request(b15) {
+        return PLVUtils.safePromise((c15, d15) => {
+            b15.then((f15) => {
+                const g15 = f15.data;
+                if (g15) {
+                    for (const h15 of Object.keys(g15)) {
+                        if (h15 == 'code' && g15[h15] != 200 + '') {
+                            d15(new PLVHttpError(new AxiosError(PLVJSONUtils.safeStringify(f15.data || ''), g15[h15], undefined, undefined, f15)));
                             return;
                         }
                     }
                 }
-                b7(r);
-            }).catch((err) => {
-                reject(new PLVHttpError(err));
+                c15(f15);
+            }).catch((e15) => {
+                d15(new PLVHttpError(e15));
             });
         });
     }
-    get(config) {
+    get(a15) {
         this.method = 'GET';
-        return this.checkCache(config) || this.request(this.create(config).get(config?.url, config));
+        return this.checkCache(a15) || this.request(this.create(a15).get(a15?.url, a15));
     }
-    post(config) {
+    post(z14) {
         this.method = 'POST';
-        return this.checkCache(config) || this.request(this.create(config).post(config?.url, config?.data, config));
+        return this.checkCache(z14) || this.request(this.create(z14).post(z14?.url, z14?.data, z14));
     }
-    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));
+    checkCache(x14) {
+        if (x14?.useCache) {
+            const y14 = this.generateCacheKey(x14);
+            if (PLVHttpRequest.CACHE_DATA_MAP.hasKey(y14)) {
+                PLVLogger.info(TAG, `--> ${this.method} ${this.baseURL}${x14?.url} use cache`);
+                return Promise.resolve(PLVHttpRequest.CACHE_DATA_MAP.get(y14));
             }
         }
         return undefined;
     }
-    generateCacheKey(config) {
-        let cacheKey = this.baseURL + '' + config?.url;
-        const params = config?.params;
-        const data = config?.data;
-        const a7 = (record) => {
-            if (record) {
-                for (const key of Object.keys(record)) {
-                    if (key == 'timestamp' || key == 'sign' || key == 'token' || key == 'viewerToken') {
+    generateCacheKey(q14) {
+        let r14 = this.baseURL + '' + q14?.url;
+        const s14 = q14?.params;
+        const t14 = q14?.data;
+        const u14 = (v14) => {
+            if (v14) {
+                for (const w14 of Object.keys(v14)) {
+                    if (w14 == 'timestamp' || w14 == 'sign' || w14 == 'token' || w14 == 'viewerToken') {
                         continue;
                     }
-                    if (key == 'appId' && PLVHttpRequest.token) {
-                        cacheKey += PLVHttpRequest.token;
+                    if (w14 == 'appId' && PLVHttpRequest.token) {
+                        r14 += PLVHttpRequest.token;
                     }
                     else {
-                        cacheKey += record[key];
+                        r14 += v14[w14];
                     }
                 }
             }
         };
-        a7(params);
-        a7(data);
-        return cacheKey;
+        u14(s14);
+        u14(t14);
+        return r14;
     }
 }
 PLVHttpRequest.CACHE_TIMEOUT = 1000 * 60 * 5;

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

@@ -3,7 +3,7 @@ export declare class PLVRequestSetting {
     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;
+    static createSign(d16: Map<string, Object | undefined>, e16?: string): string;
+    static decryptDataSync(b16: string): string;
+    static concatParams(x15: Map<string, Object | undefined>): string;
 }

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

@@ -1,30 +1,30 @@
 import buffer from "@ohos.buffer";
 import { CryptoJS } from '@ohos/crypto-js';
 export class PLVRequestSetting {
-    static createSign(map, key) {
-        const j7 = key + PLVRequestSetting.concatParams(map) + key;
-        const k7 = CryptoJS.MD5(j7).toString().toUpperCase();
-        return k7;
+    static createSign(d16, e16) {
+        const f16 = e16 + PLVRequestSetting.concatParams(d16) + e16;
+        const g16 = CryptoJS.MD5(f16).toString().toUpperCase();
+        return g16;
     }
-    static decryptDataSync(data) {
-        const i7 = CryptoJS.AES.decrypt(buffer.from(data, 'base64').toString('hex'), CryptoJS.enc.Utf8.parse(PLVRequestSetting.DECRYPT_KEY_1_SRC), {
+    static decryptDataSync(b16) {
+        const c16 = CryptoJS.AES.decrypt(buffer.from(b16, 'base64').toString('hex'), CryptoJS.enc.Utf8.parse(PLVRequestSetting.DECRYPT_KEY_1_SRC), {
             format: CryptoJS.format.Hex,
             iv: CryptoJS.enc.Utf8.parse(PLVRequestSetting.DECRYPT_KEY_2_SRC),
             mode: CryptoJS.mode.CBC,
             padding: CryptoJS.pad.Pkcs7
         }).toString(CryptoJS.enc.Utf8);
-        return i7;
+        return c16;
     }
-    static concatParams(map) {
-        const h7 = Array.from(map.keys()).sort();
-        const builder = [];
-        for (const key of h7) {
-            if (!key || !map.get(key)) {
+    static concatParams(x15) {
+        const y15 = Array.from(x15.keys()).sort();
+        const z15 = [];
+        for (const a16 of y15) {
+            if (!a16 || !x15.get(a16)) {
                 continue;
             }
-            builder.push(key + map.get(key));
+            z15.push(a16 + x15.get(a16));
         }
-        return builder.join('');
+        return z15.join('');
     }
 }
 PLVRequestSetting.KEY_1 = 'polyv_sdk_api_innor';

package/src/main/ets/modules/socket/PLVSocketIO.d.ets

@@ -5,40 +5,40 @@ export declare class PLVSocketIO {
     protected onSocketIOStatusListener?: PLVCallback<PLVSocketIOStatus, void>;
     protected isTokenExpired: boolean;
     private set_open_listener;
-    protected set_fail_listener(h8: () => void): void;
-    protected set_reconnecting_listener(g8: () => void): void;
+    protected set_fail_listener(r17: () => void): void;
+    protected set_reconnecting_listener(q17: () => void): void;
     private set_reconnect_listener;
-    protected set_close_listener(e8: (reason: string) => void): void;
-    protected set_socket_open_listener(d8: (nsp: string) => void): void;
-    protected set_socket_close_listener(c8: (nsp: string) => void): void;
-    protected connect(uri: string): void;
-    protected connectWithQuery(uri: string, query: string, b8: string): void;
+    protected set_close_listener(o17: (reason: string) => void): void;
+    protected set_socket_open_listener(n17: (nsp: string) => void): void;
+    protected set_socket_close_listener(m17: (nsp: string) => void): void;
+    protected connect(l17: string): void;
+    protected connectWithQuery(i17: string, j17: string, k17: string): void;
     connected(): boolean;
-    disconnect(a8?: boolean): void;
-    destroy(z7?: boolean): void;
+    disconnect(h17?: boolean): void;
+    destroy(g17?: boolean): void;
     protected clear_con_listeners(): void;
     protected clear_socket_listeners(): void;
-    protected set_reconnect_attempts(y7: number): void;
-    protected set_reconnect_delay(x7: number): void;
-    protected set_reconnect_delay_max(w7: number): void;
+    protected set_reconnect_attempts(f17: number): void;
+    protected set_reconnect_delay(e17: number): void;
+    protected set_reconnect_delay_max(d17: number): void;
     protected set_logs_default(): void;
     protected set_logs_quiet(): void;
     protected set_logs_verbose(): void;
     private close;
     private sync_close;
-    protected set_proxy_basic_auth(uri: string, username: string, password: string): void;
+    protected set_proxy_basic_auth(a17: string, b17: string, c17: string): void;
     private opened;
     protected get_sessionid(): string;
-    protected set_nsp(v7: string): void;
-    protected on(t7: string, u7: (event_json: string) => void): void;
-    protected once(r7: string, s7: (event_json: string) => void): void;
-    protected off(q7: string): void;
+    protected set_nsp(z16: string): void;
+    protected on(w16: string, x16: (event_json: string) => void): void;
+    protected once(u16: string, v16: (event_json: string) => void): void;
+    protected off(t16: string): void;
     protected off_all(): void;
     private socket_close;
-    protected on_error(p7: (message: string) => void): void;
+    protected on_error(s16: (message: string) => void): void;
     protected off_error(): void;
-    protected emitSkipCheck(name: string, message: ESObject, o7?: (emit_callback_json: string) => void): void;
-    emit(name: string, message: ESObject, n7?: (emit_callback_json: string) => void): boolean;
+    protected emitSkipCheck(o16: string, p16: ESObject, q16?: (emit_callback_json: string) => void): void;
+    emit(k16: string, l16: ESObject, m16?: (emit_callback_json: string) => void): boolean;
     private replaceJson;
 }
 export declare enum PLVSocketIOStatus {

package/src/main/ets/modules/socket/PLVSocketIO.js

@@ -8,31 +8,31 @@ export class PLVSocketIO {
         this.socketIOStatus = PLVSocketIOStatus.IDLE;
         this.isTokenExpired = false;
     }
-    set_open_listener(i8) {
-        this.client.set_open_listener(i8);
+    set_open_listener(s17) {
+        this.client.set_open_listener(s17);
     }
-    set_fail_listener(h8) {
-        this.client.set_fail_listener(h8);
+    set_fail_listener(r17) {
+        this.client.set_fail_listener(r17);
     }
-    set_reconnecting_listener(g8) {
-        this.client.set_reconnecting_listener(g8);
+    set_reconnecting_listener(q17) {
+        this.client.set_reconnecting_listener(q17);
     }
-    set_reconnect_listener(f8) {
-        this.client.set_reconnect_listener(f8);
+    set_reconnect_listener(p17) {
+        this.client.set_reconnect_listener(p17);
     }
-    set_close_listener(e8) {
-        this.client.set_close_listener(e8);
+    set_close_listener(o17) {
+        this.client.set_close_listener(o17);
     }
-    set_socket_open_listener(d8) {
-        this.client.set_socket_open_listener(d8);
+    set_socket_open_listener(n17) {
+        this.client.set_socket_open_listener(n17);
     }
-    set_socket_close_listener(c8) {
-        this.client.set_socket_close_listener(c8);
+    set_socket_close_listener(m17) {
+        this.client.set_socket_close_listener(m17);
     }
-    connect(uri) {
-        this.connectWithQuery(uri, '', '');
+    connect(l17) {
+        this.connectWithQuery(l17, '', '');
     }
-    connectWithQuery(uri, query, b8) {
+    connectWithQuery(i17, j17, k17) {
         this.isTokenExpired = false;
         if (this.socketIOStatus == PLVSocketIOStatus.IDLE || this.socketIOStatus == PLVSocketIOStatus.SOCKET_CLOSE) {
             this.socketIOStatus = PLVSocketIOStatus.CONNECT;
@@ -65,19 +65,19 @@ export class PLVSocketIO {
         this.set_close_listener(() => {
             PLVLogger.info(TAG, 'call close');
         });
-        this.client.connectWithQuery(uri, query, b8);
+        this.client.connectWithQuery(i17, j17, k17);
     }
     connected() {
         return this.opened() && this.socketIOStatus != PLVSocketIOStatus.SOCKET_CLOSE;
     }
-    disconnect(a8) {
-        if (this.socketIOStatus != PLVSocketIOStatus.SOCKET_CLOSE && !a8) {
+    disconnect(h17) {
+        if (this.socketIOStatus != PLVSocketIOStatus.SOCKET_CLOSE && !h17) {
             this.socket_close();
         }
         this.close();
     }
-    destroy(z7) {
-        this.disconnect(z7);
+    destroy(g17) {
+        this.disconnect(g17);
         this.clear_con_listeners();
         this.clear_socket_listeners();
     }
@@ -87,14 +87,14 @@ export class PLVSocketIO {
     clear_socket_listeners() {
         this.client.clear_socket_listeners();
     }
-    set_reconnect_attempts(y7) {
-        this.client.set_reconnect_attempts(y7);
+    set_reconnect_attempts(f17) {
+        this.client.set_reconnect_attempts(f17);
     }
-    set_reconnect_delay(x7) {
-        this.client.set_reconnect_delay(x7);
+    set_reconnect_delay(e17) {
+        this.client.set_reconnect_delay(e17);
     }
-    set_reconnect_delay_max(w7) {
-        this.client.set_reconnect_delay_max(w7);
+    set_reconnect_delay_max(d17) {
+        this.client.set_reconnect_delay_max(d17);
     }
     set_logs_default() {
         this.client.set_logs_default();
@@ -111,8 +111,8 @@ export class PLVSocketIO {
     sync_close() {
         this.client.sync_close();
     }
-    set_proxy_basic_auth(uri, username, password) {
-        this.client.set_proxy_basic_auth(uri, username, password);
+    set_proxy_basic_auth(a17, b17, c17) {
+        this.client.set_proxy_basic_auth(a17, b17, c17);
     }
     opened() {
         return this.client.opened();
@@ -120,19 +120,19 @@ export class PLVSocketIO {
     get_sessionid() {
         return this.client.get_sessionid();
     }
-    set_nsp(v7) {
-        this.client.set_nsp(v7);
+    set_nsp(z16) {
+        this.client.set_nsp(z16);
     }
-    on(t7, u7) {
-        this.client.on(t7, (json) => {
-            u7(this.replaceJson(json));
+    on(w16, x16) {
+        this.client.on(w16, (y16) => {
+            x16(this.replaceJson(y16));
         });
     }
-    once(r7, s7) {
-        this.client.once(r7, s7);
+    once(u16, v16) {
+        this.client.once(u16, v16);
     }
-    off(q7) {
-        this.client.off(q7);
+    off(t16) {
+        this.client.off(t16);
     }
     off_all() {
         this.client.off_all();
@@ -140,42 +140,42 @@ export class PLVSocketIO {
     socket_close() {
         this.client.socket_close();
     }
-    on_error(p7) {
-        this.client.on_error(p7);
+    on_error(s16) {
+        this.client.on_error(s16);
     }
     off_error() {
         this.client.off_error();
     }
-    emitSkipCheck(name, message, o7) {
-        this.client.emit(name, message, (json) => {
-            o7?.(this.replaceJson(json));
+    emitSkipCheck(o16, p16, q16) {
+        this.client.emit(o16, p16, (r16) => {
+            q16?.(this.replaceJson(r16));
         });
     }
-    emit(name, message, n7) {
-        PLVLogger.info(TAG, `emit: ${message}, name: ${name}, connected: ${this.connected()}`);
+    emit(k16, l16, m16) {
+        PLVLogger.info(TAG, `emit: ${l16}, name: ${k16}, connected: ${this.connected()}`);
         if (this.connected()) {
-            this.client.emit(name, message, (json) => {
-                n7?.(this.replaceJson(json));
+            this.client.emit(k16, l16, (n16) => {
+                m16?.(this.replaceJson(n16));
             });
             return true;
         }
         return false;
     }
-    replaceJson(json) {
-        json = json.replace(/^"{/, '{').replace(/}"$/, '}').replace(/"{/, '{');
-        const m7 = json.lastIndexOf('}"');
-        if (m7 !== -1) {
-            json = json.substring(0, m7) + '}' + json.substring(m7 + 2);
+    replaceJson(i16) {
+        i16 = i16.replace(/^"{/, '{').replace(/}"$/, '}').replace(/"{/, '{');
+        const j16 = i16.lastIndexOf('}"');
+        if (j16 !== -1) {
+            i16 = i16.substring(0, j16) + '}' + i16.substring(j16 + 2);
         }
-        return json;
+        return i16;
     }
 }
 export var PLVSocketIOStatus;
-(function (l7) {
-    l7[l7["IDLE"] = 0] = "IDLE";
-    l7[l7["CONNECT"] = 1] = "CONNECT";
-    l7[l7["OPEN"] = 2] = "OPEN";
-    l7[l7["RECONNECT"] = 3] = "RECONNECT";
-    l7[l7["RECONNECT_SUCCESS"] = 4] = "RECONNECT_SUCCESS";
-    l7[l7["SOCKET_CLOSE"] = 5] = "SOCKET_CLOSE";
+(function (h16) {
+    h16[h16["IDLE"] = 0] = "IDLE";
+    h16[h16["CONNECT"] = 1] = "CONNECT";
+    h16[h16["OPEN"] = 2] = "OPEN";
+    h16[h16["RECONNECT"] = 3] = "RECONNECT";
+    h16[h16["RECONNECT_SUCCESS"] = 4] = "RECONNECT_SUCCESS";
+    h16[h16["SOCKET_CLOSE"] = 5] = "SOCKET_CLOSE";
 })(PLVSocketIOStatus || (PLVSocketIOStatus = {}));

package/src/main/ets/modules/web/PLVFailureLayout.js

@@ -1,46 +1,45 @@
 if (!("finalizeConstruction" in ViewPU.prototype)) {
-    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => {
-    });
+    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => { });
 }
 import PLVCommonConstants from '../../common/PLVCommonConstants';
 export class PLVFailureLayout extends ViewPU {
-    constructor(parent, params, __localStorage, elmtId = -1, paramsLambda = undefined, extraInfo) {
-        super(parent, __localStorage, elmtId, extraInfo);
-        if (typeof paramsLambda === "function") {
-            this.paramsGenerator_ = paramsLambda;
+    constructor(i18, j18, k18, l18 = -1, m18 = undefined, n18) {
+        super(i18, k18, l18, n18);
+        if (typeof m18 === "function") {
+            this.paramsGenerator_ = m18;
         }
         this.handleReload = undefined;
-        this.setInitiallyProvidedValue(params);
+        this.setInitiallyProvidedValue(j18);
         this.finalizeConstruction();
     }
-    setInitiallyProvidedValue(params) {
-        if (params.handleReload !== undefined) {
-            this.handleReload = params.handleReload;
+    setInitiallyProvidedValue(h18) {
+        if (h18.handleReload !== undefined) {
+            this.handleReload = h18.handleReload;
         }
     }
-    updateStateVars(params) {
+    updateStateVars(g18) {
     }
-    purgeVariableDependenciesOnElmtId(rmElmtId) {
+    purgeVariableDependenciesOnElmtId(f18) {
     }
     aboutToBeDeleted() {
         SubscriberManager.Get().delete(this.id__());
         this.aboutToBeDeletedInternal();
     }
     initialRender() {
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((d18, e18) => {
             Row.create();
             Row.justifyContent(FlexAlign.Center);
             Row.layoutWeight(1);
         }, Row);
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((b18, c18) => {
             Column.create();
         }, Column);
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((z17, a18) => {
             Image.create({ "id": -1, "type": 20000, params: ["app.media.plv_web_ic_failure"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
             Image.width({ "id": -1, "type": 10002, params: ["app.float.plv_web_failure_img_size"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
             Image.height({ "id": -1, "type": 10002, params: ["app.float.plv_web_failure_img_size"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
         }, Image);
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((x17, y17) => {
             Text.create({ "id": -1, "type": 10003, params: ["app.string.plv_web_load_failed"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
             Text.fontColor({ "id": -1, "type": 10001, params: ["app.color.plv_web_reload_title_color"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
             Text.fontFamily(PLVCommonConstants.HARMONY_HEI_TI_FONT_FAMILY);
@@ -48,7 +47,7 @@ export class PLVFailureLayout extends ViewPU {
             Text.margin({ top: { "id": -1, "type": 10002, params: ["app.float.plv_web_sm_padding_margin"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" } });
         }, Text);
         Text.pop();
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((v17, w17) => {
             Row.create();
             Row.height({ "id": -1, "type": 10002, params: ["app.float.plv_web_reload_btn_height"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
             Row.width({ "id": -1, "type": 10002, params: ["app.float.plv_web_reload_btn_width"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
@@ -58,7 +57,7 @@ export class PLVFailureLayout extends ViewPU {
             Row.borderRadius({ "id": -1, "type": 10002, params: ["app.float.plv_web_large_border_radius"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
             Row.onClick(() => this.handleReload?.());
         }, Row);
-        this.observeComponentCreation2((elmtId, isInitialRender) => {
+        this.observeComponentCreation2((t17, u17) => {
             Text.create({ "id": -1, "type": 10003, params: ["app.string.plv_web_reload"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
             Text.fontColor({ "id": -1, "type": 10001, params: ["app.color.plv_web_main_red_color"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
             Text.fontFamily(PLVCommonConstants.HARMONY_HEI_TI_FONT_FAMILY);