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

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

@@ -0,0 +1,33 @@
+import buffer from "@ohos.buffer";
+import { CryptoJS } from '@ohos/crypto-js';
+export class PLVRequestSetting {
+    static createSign(map, key) {
+        const a8 = key + PLVRequestSetting.concatParams(map) + key;
+        const b8 = CryptoJS.MD5(a8).toString().toUpperCase();
+        return b8;
+    }
+    static decryptDataSync(data) {
+        const z7 = CryptoJS.AES.decrypt(buffer.from(data, '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 z7;
+    }
+    static concatParams(map) {
+        const y7 = Array.from(map.keys()).sort();
+        const builder = [];
+        for (const key of y7) {
+            if (!key || !map.get(key)) {
+                continue;
+            }
+            builder.push(key + map.get(key));
+        }
+        return builder.join('');
+    }
+}
+PLVRequestSetting.KEY_1 = 'polyv_sdk_api_innor';
+PLVRequestSetting.PLV_SWITCH_API_INNOR = 'polyv_switch_api_innor';
+PLVRequestSetting.DECRYPT_KEY_1_SRC = 'PolyvApiResponse';
+PLVRequestSetting.DECRYPT_KEY_2_SRC = 'PolyvLiveEncrypt';

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

@@ -0,0 +1,50 @@
+import { PLVCallback } from '../../common/PLVCallback';
+export declare class PLVSocketIO {
+    private client;
+    protected socketIOStatus: PLVSocketIOStatus;
+    protected onSocketIOStatusListener?: PLVCallback<PLVSocketIOStatus, void>;
+    private set_open_listener;
+    protected set_fail_listener(f9: () => void): void;
+    protected set_reconnecting_listener(e9: () => void): void;
+    private set_reconnect_listener;
+    protected set_close_listener(c9: (reason: string) => void): void;
+    protected set_socket_open_listener(b9: (nsp: string) => void): void;
+    protected set_socket_close_listener(a9: (nsp: string) => void): void;
+    protected connect(uri: string): void;
+    protected connectWithQuery(uri: string, query: string, v8: string): void;
+    connected(): boolean;
+    disconnect(u8?: boolean): void;
+    destroy(t8?: boolean): void;
+    protected clear_con_listeners(): void;
+    protected clear_socket_listeners(): void;
+    protected set_reconnect_attempts(s8: number): void;
+    protected set_reconnect_delay(r8: number): void;
+    protected set_reconnect_delay_max(q8: 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;
+    private opened;
+    protected get_sessionid(): string;
+    protected set_nsp(p8: string): void;
+    protected on(m8: string, n8: (event_json: string) => void): void;
+    protected once(k8: string, l8: (event_json: string) => void): void;
+    protected off(j8: string): void;
+    protected off_all(): void;
+    private socket_close;
+    protected on_error(i8: (message: string) => void): void;
+    protected off_error(): void;
+    protected emitSkipCheck(name: string, message: ESObject, g8?: (emit_callback_json: string) => void): void;
+    emit(name: string, message: ESObject, e8?: (emit_callback_json: string) => void): boolean;
+    private replaceJson;
+}
+export declare enum PLVSocketIOStatus {
+    IDLE = 0,
+    CONNECT = 1,
+    OPEN = 2,
+    RECONNECT = 3,
+    RECONNECT_SUCCESS = 4,
+    SOCKET_CLOSE = 5
+}

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

@@ -0,0 +1,164 @@
+import { client_socket } from 'socket';
+import PLVLogger from '../log/PLVLogger';
+const TAG = '[PLVSocketIO]';
+export class PLVSocketIO {
+    constructor() {
+        this.client = new client_socket();
+        this.socketIOStatus = PLVSocketIOStatus.IDLE;
+    }
+    set_open_listener(g9) {
+        this.client.set_open_listener(g9);
+    }
+    set_fail_listener(f9) {
+        this.client.set_fail_listener(f9);
+    }
+    set_reconnecting_listener(e9) {
+        this.client.set_reconnecting_listener(e9);
+    }
+    set_reconnect_listener(d9) {
+        this.client.set_reconnect_listener(d9);
+    }
+    set_close_listener(c9) {
+        this.client.set_close_listener(c9);
+    }
+    set_socket_open_listener(b9) {
+        this.client.set_socket_open_listener(b9);
+    }
+    set_socket_close_listener(a9) {
+        this.client.set_socket_close_listener(a9);
+    }
+    connect(uri) {
+        this.connectWithQuery(uri, '', '');
+    }
+    connectWithQuery(uri, query, v8) {
+        if (this.socketIOStatus == PLVSocketIOStatus.IDLE || this.socketIOStatus == PLVSocketIOStatus.SOCKET_CLOSE) {
+            this.socketIOStatus = PLVSocketIOStatus.CONNECT;
+            this.onSocketIOStatusListener?.(this.socketIOStatus);
+        }
+        this.set_open_listener(() => {
+            PLVLogger.info(TAG, 'call socket open');
+            this.socketIOStatus = this.socketIOStatus == PLVSocketIOStatus.RECONNECT ? PLVSocketIOStatus.RECONNECT_SUCCESS : PLVSocketIOStatus.OPEN;
+            this.onSocketIOStatusListener?.(this.socketIOStatus);
+        });
+        this.set_reconnect_listener(() => {
+            PLVLogger.info(TAG, 'call socket reconnect');
+            this.socketIOStatus = PLVSocketIOStatus.RECONNECT;
+            this.onSocketIOStatusListener?.(this.socketIOStatus);
+        });
+        this.set_socket_close_listener(() => {
+            PLVLogger.info(TAG, 'call socket close');
+            this.socketIOStatus = PLVSocketIOStatus.SOCKET_CLOSE;
+            this.onSocketIOStatusListener?.(this.socketIOStatus);
+        });
+        this.set_close_listener(() => {
+            PLVLogger.info(TAG, 'call close');
+        });
+        this.client.connectWithQuery(uri, query, v8);
+    }
+    connected() {
+        return this.opened() && this.socketIOStatus != PLVSocketIOStatus.SOCKET_CLOSE;
+    }
+    disconnect(u8) {
+        if (this.socketIOStatus != PLVSocketIOStatus.SOCKET_CLOSE && !u8) {
+            this.socket_close();
+        }
+        this.close();
+    }
+    destroy(t8) {
+        this.disconnect(t8);
+        this.clear_con_listeners();
+        this.clear_socket_listeners();
+    }
+    clear_con_listeners() {
+        this.client.clear_con_listeners();
+    }
+    clear_socket_listeners() {
+        this.client.clear_socket_listeners();
+    }
+    set_reconnect_attempts(s8) {
+        this.client.set_reconnect_attempts(s8);
+    }
+    set_reconnect_delay(r8) {
+        this.client.set_reconnect_delay(r8);
+    }
+    set_reconnect_delay_max(q8) {
+        this.client.set_reconnect_delay_max(q8);
+    }
+    set_logs_default() {
+        this.client.set_logs_default();
+    }
+    set_logs_quiet() {
+        this.client.set_logs_quiet();
+    }
+    set_logs_verbose() {
+        this.client.set_logs_verbose();
+    }
+    close() {
+        this.client.close();
+    }
+    sync_close() {
+        this.client.sync_close();
+    }
+    set_proxy_basic_auth(uri, username, password) {
+        this.client.set_proxy_basic_auth(uri, username, password);
+    }
+    opened() {
+        return this.client.opened();
+    }
+    get_sessionid() {
+        return this.client.get_sessionid();
+    }
+    set_nsp(p8) {
+        this.client.set_nsp(p8);
+    }
+    on(m8, n8) {
+        this.client.on(m8, (json) => {
+            n8(this.replaceJson(json));
+        });
+    }
+    once(k8, l8) {
+        this.client.once(k8, l8);
+    }
+    off(j8) {
+        this.client.off(j8);
+    }
+    off_all() {
+        this.client.off_all();
+    }
+    socket_close() {
+        this.client.socket_close();
+    }
+    on_error(i8) {
+        this.client.on_error(i8);
+    }
+    off_error() {
+        this.client.off_error();
+    }
+    emitSkipCheck(name, message, g8) {
+        this.client.emit(name, message, (json) => {
+            g8?.(this.replaceJson(json));
+        });
+    }
+    emit(name, message, e8) {
+        PLVLogger.info(TAG, `emit: ${message}, name: ${name}, connected: ${this.connected()}`);
+        if (this.connected()) {
+            this.client.emit(name, message, (json) => {
+                e8?.(this.replaceJson(json));
+            });
+            return true;
+        }
+        return false;
+    }
+    replaceJson(json) {
+        return json.replace(/"{/g, '{').replace(/}"/g, '}');
+    }
+}
+export var PLVSocketIOStatus;
+(function (d8) {
+    d8[d8["IDLE"] = 0] = "IDLE";
+    d8[d8["CONNECT"] = 1] = "CONNECT";
+    d8[d8["OPEN"] = 2] = "OPEN";
+    d8[d8["RECONNECT"] = 3] = "RECONNECT";
+    d8[d8["RECONNECT_SUCCESS"] = 4] = "RECONNECT_SUCCESS";
+    d8[d8["SOCKET_CLOSE"] = 5] = "SOCKET_CLOSE";
+})(PLVSocketIOStatus || (PLVSocketIOStatus = {}));

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

@@ -0,0 +1,5 @@
+@Component
+export declare struct PLVFailureLayout {
+    handleReload?: () => void;
+    build(): void;
+}

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

@@ -0,0 +1,77 @@
+if (!("finalizeConstruction" in ViewPU.prototype)) {
+    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;
+        }
+        this.handleReload = undefined;
+        this.setInitiallyProvidedValue(params);
+        this.finalizeConstruction();
+    }
+    setInitiallyProvidedValue(params) {
+        if (params.handleReload !== undefined) {
+            this.handleReload = params.handleReload;
+        }
+    }
+    updateStateVars(params) {
+    }
+    purgeVariableDependenciesOnElmtId(rmElmtId) {
+    }
+    aboutToBeDeleted() {
+        SubscriberManager.Get().delete(this.id__());
+        this.aboutToBeDeletedInternal();
+    }
+    initialRender() {
+        this.observeComponentCreation2((elmtId, isInitialRender) => {
+            Row.create();
+            Row.justifyContent(FlexAlign.Center);
+            Row.layoutWeight(1);
+        }, Row);
+        this.observeComponentCreation2((elmtId, isInitialRender) => {
+            Column.create();
+        }, Column);
+        this.observeComponentCreation2((elmtId, isInitialRender) => {
+            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) => {
+            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);
+            Text.fontSize({ "id": -1, "type": 10002, params: ["app.float.plv_web_normal_text_size1"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
+            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) => {
+            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__" });
+            Row.margin({ top: { "id": -1, "type": 10002, params: ["app.float.plv_web_sm_padding_margin"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" } });
+            Row.borderWidth(1);
+            Row.borderColor({ "id": -1, "type": 10001, params: ["app.color.plv_web_main_red_color"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
+            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) => {
+            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);
+            Text.fontSize({ "id": -1, "type": 10002, params: ["app.float.plv_web_small_text_size"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
+            Text.width(PLVCommonConstants.FULL_PERCENT);
+            Text.textAlign(TextAlign.Center);
+        }, Text);
+        Text.pop();
+        Row.pop();
+        Column.pop();
+        Row.pop();
+    }
+    rerender() {
+        this.updateDirtyElements();
+    }
+}

package/src/main/ets/modules/web/PLVLoadingLayout.d.ets

@@ -0,0 +1,4 @@
+@Component
+export declare struct PLVLoadingLayout {
+    build(): void;
+}

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

@@ -0,0 +1,46 @@
+if (!("finalizeConstruction" in ViewPU.prototype)) {
+    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => {
+    });
+}
+import PLVCommonConstants from '../../common/PLVCommonConstants';
+export class PLVLoadingLayout extends ViewPU {
+    constructor(parent, params, __localStorage, elmtId = -1, paramsLambda = undefined, extraInfo) {
+        super(parent, __localStorage, elmtId, extraInfo);
+        if (typeof paramsLambda === "function") {
+            this.paramsGenerator_ = paramsLambda;
+        }
+        this.setInitiallyProvidedValue(params);
+        this.finalizeConstruction();
+    }
+    setInitiallyProvidedValue(params) {
+    }
+    updateStateVars(params) {
+    }
+    purgeVariableDependenciesOnElmtId(rmElmtId) {
+    }
+    aboutToBeDeleted() {
+        SubscriberManager.Get().delete(this.id__());
+        this.aboutToBeDeletedInternal();
+    }
+    initialRender() {
+        this.observeComponentCreation2((elmtId, isInitialRender) => {
+            Column.create();
+            Column.height(PLVCommonConstants.FULL_PERCENT);
+            Column.width(PLVCommonConstants.FULL_PERCENT);
+        }, Column);
+        this.observeComponentCreation2((elmtId, isInitialRender) => {
+            Column.create();
+            Column.margin({ top: { "id": -1, "type": 10002, params: ["app.float.plv_web_loading_img_margin"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" } });
+            Column.width({ "id": -1, "type": 10002, params: ["app.float.plv_web_loading_img_size"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
+            Column.height({ "id": -1, "type": 10002, params: ["app.float.plv_web_loading_img_size"], "bundleName": "__harDefaultBundleName__", "moduleName": "__harDefaultModuleName__" });
+        }, Column);
+        this.observeComponentCreation2((elmtId, isInitialRender) => {
+            LoadingProgress.create();
+        }, LoadingProgress);
+        Column.pop();
+        Column.pop();
+    }
+    rerender() {
+        this.updateDirtyElements();
+    }
+}

package/src/main/ets/modules/web/PLVNewWindowLayout.d.ets

@@ -0,0 +1,8 @@
+import webview from '@ohos.web.webview';
+@CustomDialog
+export declare struct PLVNewWindowLayout {
+    controller?: CustomDialogController;
+    webviewController: webview.WebviewController;
+    aboutToAppear(): void;
+    build(): void;
+}

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

@@ -0,0 +1,62 @@
+if (!("finalizeConstruction" in ViewPU.prototype)) {
+    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => {
+    });
+}
+import webview from '@ohos.web.webview';
+import PLVLogger from '../log/PLVLogger';
+const TAG = "[PLVNewWindowLayout]";
+export class PLVNewWindowLayout extends ViewPU {
+    constructor(parent, params, __localStorage, elmtId = -1, paramsLambda = undefined, extraInfo) {
+        super(parent, __localStorage, elmtId, extraInfo);
+        if (typeof paramsLambda === "function") {
+            this.paramsGenerator_ = paramsLambda;
+        }
+        this.controller = undefined;
+        this.webviewController = new webview.WebviewController();
+        this.setInitiallyProvidedValue(params);
+        this.finalizeConstruction();
+    }
+    setInitiallyProvidedValue(params) {
+        if (params.controller !== undefined) {
+            this.controller = params.controller;
+        }
+        if (params.webviewController !== undefined) {
+            this.webviewController = params.webviewController;
+        }
+    }
+    updateStateVars(params) {
+    }
+    purgeVariableDependenciesOnElmtId(rmElmtId) {
+    }
+    aboutToBeDeleted() {
+        SubscriberManager.Get().delete(this.id__());
+        this.aboutToBeDeletedInternal();
+    }
+    setController(ctr) {
+        this.controller = ctr;
+    }
+    aboutToAppear() {
+    }
+    initialRender() {
+        this.observeComponentCreation2((elmtId, isInitialRender) => {
+            Column.create();
+        }, Column);
+        this.observeComponentCreation2((elmtId, isInitialRender) => {
+            Web.create({ src: "", controller: this.webviewController });
+            Web.javaScriptAccess(true);
+            Web.zoomAccess(true);
+            Web.domStorageAccess(true);
+            Web.multiWindowAccess(false);
+            Web.onWindowExit(() => {
+                PLVLogger.info(TAG, "onWindowExit");
+                if (this.controller) {
+                    this.controller.close();
+                }
+            });
+        }, Web);
+        Column.pop();
+    }
+    rerender() {
+        this.updateDirtyElements();
+    }
+}

package/src/main/ets/modules/web/PLVSimpleWeb.d.ets

@@ -0,0 +1,14 @@
+import { PLVWebpageStatus } from '../../common/PLVCommonEnums';
+import { PLVWebController } from './PLVWebController';
+export declare const TAG = "[PLVSimpleWeb]";
+@Component
+export declare struct PLVSimpleWeb {
+    @State
+    webStatus: PLVWebpageStatus;
+    controller: PLVWebController;
+    src?: string | Resource;
+    incognitoMode?: boolean;
+    showLoading?: boolean;
+    aboutToAppear(): void;
+    build(): void;
+}