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

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

@@ -0,0 +1,260 @@
+if (!("finalizeConstruction" in ViewPU.prototype)) {
+    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => {
+    });
+}
+import PLVCommonConstants from '../../common/PLVCommonConstants';
+import { PLVFullScreenStatus, PLVWebpageStatus } from '../../common/PLVCommonEnums';
+import PLVLogger from '../log/PLVLogger';
+import { PLVFailureLayout } from './PLVFailureLayout';
+import { PLVLoadingLayout } from './PLVLoadingLayout';
+import { PLVNewWindowLayout } from './PLVNewWindowLayout';
+import { PLVWebController } from './PLVWebController';
+export const TAG = "[PLVSimpleWeb]";
+export class PLVSimpleWeb extends ViewPU {
+    constructor(parent, params, __localStorage, elmtId = -1, paramsLambda = undefined, extraInfo) {
+        super(parent, __localStorage, elmtId, extraInfo);
+        if (typeof paramsLambda === "function") {
+            this.paramsGenerator_ = paramsLambda;
+        }
+        this.a2 = new ObservedPropertySimplePU(PLVWebpageStatus.INIT, this, "webStatus");
+        this.controller = new PLVWebController();
+        this.src = undefined;
+        this.incognitoMode = undefined;
+        this.showLoading = undefined;
+        this.setInitiallyProvidedValue(params);
+        this.finalizeConstruction();
+    }
+    setInitiallyProvidedValue(params) {
+        if (params.webStatus !== undefined) {
+            this.webStatus = params.webStatus;
+        }
+        if (params.controller !== undefined) {
+            this.controller = params.controller;
+        }
+        if (params.src !== undefined) {
+            this.src = params.src;
+        }
+        if (params.incognitoMode !== undefined) {
+            this.incognitoMode = params.incognitoMode;
+        }
+        if (params.showLoading !== undefined) {
+            this.showLoading = params.showLoading;
+        }
+    }
+    updateStateVars(params) {
+    }
+    purgeVariableDependenciesOnElmtId(rmElmtId) {
+        this.a2.purgeDependencyOnElmtId(rmElmtId);
+    }
+    aboutToBeDeleted() {
+        this.a2.aboutToBeDeleted();
+        SubscriberManager.Get().delete(this.id__());
+        this.aboutToBeDeletedInternal();
+    }
+    get webStatus() {
+        return this.a2.get();
+    }
+    set webStatus(newValue) {
+        this.a2.set(newValue);
+    }
+    aboutToAppear() {
+        PLVLogger.info(TAG, `load url: ${this.src}`);
+    }
+    initialRender() {
+        this.observeComponentCreation2((elmtId, isInitialRender) => {
+            Stack.create();
+            Stack.width(PLVCommonConstants.FULL_PERCENT);
+            Stack.height(PLVCommonConstants.FULL_PERCENT);
+        }, Stack);
+        this.observeComponentCreation2((elmtId, isInitialRender) => {
+            Web.create({
+                controller: this.controller,
+                src: this.src,
+                incognitoMode: this.incognitoMode
+            });
+            Web.darkMode(this.controller._darkMode);
+            Web.forceDarkAccess(this.controller._forceDarkAccess);
+            Web.domStorageAccess(this.controller._domStorageAccess);
+            Web.zoomAccess(this.controller._zoomAccess);
+            Web.fileAccess(this.controller._fileAccess);
+            Web.multiWindowAccess(this.controller._multiWindowAccess);
+            Web.allowWindowOpenMethod(this.controller._allowWindowOpenMethod);
+            Web.javaScriptAccess(this.controller._javaScriptAccess);
+            Web.mixedMode(this.controller._mixedMode);
+            Web.cacheMode(this.controller._cacheMode);
+            Web.backgroundColor(this.controller._backgroundColor);
+            Web.verticalScrollBarAccess(this.controller._verticalScrollBarAccess);
+            Web.nestedScroll(this.controller._nestedScrollOptions);
+            Web.overScrollMode(this.controller._overScrollMode);
+            Web.onControllerAttached(() => {
+                PLVLogger.info(TAG, "onControllerAttached: " + this.src);
+                this.controller.handleControllerAttached();
+                this.controller._onControllerAttached?.();
+            });
+            Web.onInterceptRequest((event) => {
+                if (this.controller._onInterceptRequest) {
+                    return this.controller._onInterceptRequest?.(event.request);
+                }
+                return null;
+            });
+            Web.onLoadIntercept((event) => {
+                let result = false;
+                if (this.controller._onLoadIntercept) {
+                    result = this.controller._onLoadIntercept?.(event.data);
+                }
+                result = result || this.controller.handleIsLoadIntercept(event.data);
+                return result;
+            });
+            Web.onWindowNew((event) => {
+                if (this.controller._onWindowNew?.(event)) {
+                    return;
+                }
+                this.controller.handleWindowNew(event, (z10) => {
+                    return new CustomDialogController({
+                        builder: () => {
+                            let jsDialog = new PLVNewWindowLayout(this, { webviewController: z10 }, undefined, -1, () => {
+                            }, { page: "foundation/src/main/ets/modules/web/PLVSimpleWeb.ets", line: 72, b2: 24 });
+                            jsDialog.setController();
+                            ViewPU.create(jsDialog);
+                            let paramsLambda = () => {
+                                return {
+                                    webviewController: z10
+                                };
+                            };
+                            jsDialog.paramsGenerator_ = paramsLambda;
+                        },
+                        cornerRadius: 0
+                    }, this);
+                });
+            });
+            Web.onShowFileSelector((event) => {
+                if (this.controller._onShowFileSelector) {
+                    return this.controller._onShowFileSelector?.(event);
+                }
+                return true;
+            });
+            Web.onFullScreenExit(() => {
+                PLVLogger.info(TAG, 'onFullScreenExit');
+                this.controller._fullScreenStatus = PLVFullScreenStatus.EXIT;
+                if (this.controller._onFullScreenExit?.()) {
+                    return;
+                }
+                this.controller.handleFullScreenExit();
+            });
+            Web.onFullScreenEnter(() => {
+                PLVLogger.info(TAG, 'onFullScreenEnter');
+                this.controller._fullScreenStatus = PLVFullScreenStatus.ENTER;
+                if (this.controller._onFullScreenEnter?.()) {
+                    return;
+                }
+                this.controller.handleFullScreenEnter();
+            });
+            Web.onProgressChange((event) => {
+                PLVLogger.info(TAG, 'onProgressChange:' + event?.newProgress);
+                this.controller._onProgressChange?.(event);
+            });
+            Web.onPageBegin((event) => {
+                PLVLogger.info(TAG, 'onPageBegin');
+                this.controller._onPageBegin?.(event);
+            });
+            Web.onErrorReceive((event) => {
+                PLVLogger.info(TAG, "onErrorReceive:" + `{info:${event?.error.getErrorInfo()},code:${event?.error.getErrorCode()}}`);
+                this.controller.handleErrorReceive();
+                this.webStatus = PLVWebpageStatus.FINISHED;
+                this.controller._onErrorReceive?.(event);
+            });
+            Web.onPageEnd((event) => {
+                PLVLogger.info(TAG, 'onPageEnd');
+                this.controller.handlePageEnd(event);
+                if (this.webStatus != PLVWebpageStatus.ERROR) {
+                    this.webStatus = PLVWebpageStatus.FINISHED;
+                    this.controller._onPageEnd?.(event);
+                }
+            });
+        }, Web);
+        this.observeComponentCreation2((elmtId, isInitialRender) => {
+            If.create();
+            if (this.webStatus === PLVWebpageStatus.INIT && this.showLoading) {
+                this.ifElseBranchUpdateFunction(0, () => {
+                    this.observeComponentCreation2((elmtId, isInitialRender) => {
+                        Column.create();
+                        Column.backgroundColor(Color.White);
+                    }, Column);
+                    {
+                        this.observeComponentCreation2((elmtId, isInitialRender) => {
+                            if (isInitialRender) {
+                                let componentCall = new PLVLoadingLayout(this, {}, undefined, elmtId, () => {
+                                }, { page: "foundation/src/main/ets/modules/web/PLVSimpleWeb.ets", line: 124, b2: 11 });
+                                ViewPU.create(componentCall);
+                                let paramsLambda = () => {
+                                    return {};
+                                };
+                                componentCall.paramsGenerator_ = paramsLambda;
+                            }
+                            else {
+                                this.updateStateVarsOfChildByElmtId(elmtId, {});
+                            }
+                        }, { name: "PLVLoadingLayout" });
+                    }
+                    Column.pop();
+                });
+            }
+            else {
+                this.ifElseBranchUpdateFunction(1, () => {
+                });
+            }
+        }, If);
+        If.pop();
+        this.observeComponentCreation2((elmtId, isInitialRender) => {
+            If.create();
+            if (this.webStatus === PLVWebpageStatus.ERROR && this.showLoading) {
+                this.ifElseBranchUpdateFunction(0, () => {
+                    this.observeComponentCreation2((elmtId, isInitialRender) => {
+                        Column.create();
+                        Column.justifyContent(FlexAlign.Center);
+                        Column.alignItems(HorizontalAlign.Center);
+                        Column.backgroundColor(Color.White);
+                        Column.width(PLVCommonConstants.FULL_PERCENT);
+                        Column.height(PLVCommonConstants.FULL_PERCENT);
+                    }, Column);
+                    {
+                        this.observeComponentCreation2((elmtId, isInitialRender) => {
+                            if (isInitialRender) {
+                                let componentCall = new PLVFailureLayout(this, {
+                                    handleReload: () => {
+                                        this.webStatus = PLVWebpageStatus.INIT;
+                                        this.controller?.refresh();
+                                    }
+                                }, undefined, elmtId, () => {
+                                }, { page: "foundation/src/main/ets/modules/web/PLVSimpleWeb.ets", line: 131, b2: 11 });
+                                ViewPU.create(componentCall);
+                                let paramsLambda = () => {
+                                    return {
+                                        handleReload: () => {
+                                            this.webStatus = PLVWebpageStatus.INIT;
+                                            this.controller?.refresh();
+                                        }
+                                    };
+                                };
+                                componentCall.paramsGenerator_ = paramsLambda;
+                            }
+                            else {
+                                this.updateStateVarsOfChildByElmtId(elmtId, {});
+                            }
+                        }, { name: "PLVFailureLayout" });
+                    }
+                    Column.pop();
+                });
+            }
+            else {
+                this.ifElseBranchUpdateFunction(1, () => {
+                });
+            }
+        }, If);
+        If.pop();
+        Stack.pop();
+    }
+    rerender() {
+        this.updateDirtyElements();
+    }
+}

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

@@ -0,0 +1,86 @@
+import { webview } from '@kit.ArkWeb';
+import { PLVCallback, PLVCallback2 } from '../../common/PLVCallback';
+import { PLVFullScreenStatus, PLVWebpageStatus } from '../../common/PLVCommonEnums';
+import { common } from '@kit.AbilityKit';
+export declare class PLVWebController extends webview.WebviewController {
+    static importSDKModuleContext: common.UIAbilityContext;
+    _webStatus: PLVWebpageStatus;
+    _fullScreenStatus: PLVFullScreenStatus;
+    _originalIsLayoutFullScreen: boolean;
+    _originalIsFullScreen: boolean;
+    _accessBackward?: PLVCallback<void, boolean>;
+    _backward?: PLVCallback<void, boolean>;
+    _userAgent?: string;
+    _addOnReloaded: PLVCallback<void, void>[];
+    _darkMode: WebDarkMode;
+    _forceDarkAccess: boolean;
+    _domStorageAccess: boolean;
+    _zoomAccess: boolean;
+    _fileAccess: boolean;
+    _multiWindowAccess: boolean;
+    _allowWindowOpenMethod: boolean;
+    _javaScriptAccess: boolean;
+    _mixedMode: MixedMode;
+    _cacheMode: CacheMode;
+    _onControllerAttached?: PLVCallback<void, void>;
+    _addOnControllerAttached: PLVCallback<void, void>[];
+    _onInterceptRequest?: PLVCallback<WebResourceRequest, WebResourceResponse>;
+    _onLoadIntercept?: PLVCallback<WebResourceRequest, boolean>;
+    _onWindowNew?: PLVCallback<OnWindowNewEvent, boolean>;
+    _onShowFileSelector?: PLVCallback<OnShowFileSelectorEvent, boolean>;
+    _onFullScreenEnter?: PLVCallback<void, boolean>;
+    _onFullScreenExit?: PLVCallback<void, boolean>;
+    _onProgressChange?: PLVCallback<OnProgressChangeEvent, void>;
+    _onPageBegin?: PLVCallback<OnPageBeginEvent, void>;
+    _onPageEnd?: PLVCallback<OnPageEndEvent, void>;
+    _addOnPageEnd: PLVCallback<OnPageEndEvent, void>[];
+    _onErrorReceive?: PLVCallback<OnErrorReceiveEvent, void>;
+    _backgroundColor?: ResourceColor;
+    _verticalScrollBarAccess?: boolean;
+    _nestedScrollOptions: NestedScrollOptions;
+    _overScrollMode: OverScrollMode;
+    private dialogController;
+    private jsBridge;
+    constructor(webTag?: string);
+    accessBackward(): boolean;
+    backward(): void;
+    darkMode(darkMode: WebDarkMode): PLVWebController;
+    forceDarkAccess(forceDarkAccess: boolean): PLVWebController;
+    domStorageAccess(domStorageAccess: boolean): PLVWebController;
+    zoomAccess(zoomAccess: boolean): PLVWebController;
+    fileAccess(fileAccess: boolean): PLVWebController;
+    multiWindowAccess(multiWindowAccess: boolean): PLVWebController;
+    allowWindowOpenMethod(allowWindowOpenMethod: boolean): PLVWebController;
+    javaScriptAccess(javaScriptAccess: boolean): PLVWebController;
+    onControllerAttached(callback: PLVCallback<void, void>): PLVWebController;
+    addOnControllerAttached(callback: PLVCallback<void, void>): PLVWebController;
+    onInterceptRequest(callback: PLVCallback<WebResourceRequest, WebResourceResponse>): PLVWebController;
+    onLoadIntercept(callback: PLVCallback<WebResourceRequest, boolean>): PLVWebController;
+    onWindowNew(callback: PLVCallback<OnWindowNewEvent, boolean>): PLVWebController;
+    onShowFileSelector(callback: PLVCallback<OnShowFileSelectorEvent, boolean>): PLVWebController;
+    onFullScreenEnter(callback: PLVCallback<void, boolean>): PLVWebController;
+    onFullScreenExit(callback: PLVCallback<void, boolean>): PLVWebController;
+    onProgressChange(callback: PLVCallback<OnProgressChangeEvent, void>): PLVWebController;
+    onPageBegin(callback: PLVCallback<OnPageBeginEvent, void>): PLVWebController;
+    onPageEnd(callback: PLVCallback<OnPageEndEvent, void>): PLVWebController;
+    addOnPageEnd(callback: PLVCallback<OnPageEndEvent, void>): PLVWebController;
+    onErrorReceive(callback: PLVCallback<OnErrorReceiveEvent, void>): PLVWebController;
+    backgroundColor(backgroundColor: ResourceColor): this;
+    verticalScrollBarAccess(verticalScrollBarAccess: boolean): this;
+    nestedScrollOptions(w11: NestedScrollOptions): this;
+    overScrollMode(overScrollMode: OverScrollMode): void;
+    userAgent(userAgent?: string): this;
+    addOnReloaded(callback: PLVCallback): this;
+    registerHandler(v11: string, handle: PLVCallback2<string, PLVCallback<string>>): this;
+    callHandle(t11: string, data: string, u11: PLVCallback<string>): this;
+    loadHtmlData(data?: string): this;
+    loadUrlCatch(url: string | Resource): void;
+    handleControllerAttached(): void;
+    handleFullScreenExit(): void;
+    handleFullScreenEnter(): void;
+    handleWindowNew(event: OnWindowNewEvent, builder: (webviewController: WebviewController) => CustomDialogController): void;
+    handleIsLoadIntercept(intercept: WebResourceRequest | undefined): boolean;
+    handlePageEnd(event: OnPageEndEvent): void;
+    handleErrorReceive(): void;
+    private getVideoWHEnterFullScreen;
+}

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

@@ -0,0 +1,275 @@
+import webview from "@ohos.web.webview";
+import { PLVJsBridge } from 'jsbridge';
+import { PLVFullScreenStatus, PLVWebpageStatus } from '../../common/PLVCommonEnums';
+import PLVUtils from '../../common/PLVUtils';
+import PLVLogger from '../log/PLVLogger';
+const d11 = 100;
+const TAG = "[PLVWebController]";
+export class PLVWebController extends webview.WebviewController {
+    constructor(webTag) {
+        super(webTag || 'PLVWeb');
+        this._webStatus = PLVWebpageStatus.INIT;
+        this._fullScreenStatus = PLVFullScreenStatus.IDLE;
+        this._originalIsLayoutFullScreen = false;
+        this._originalIsFullScreen = false;
+        this._addOnReloaded = [];
+        this._darkMode = WebDarkMode.Auto;
+        this._forceDarkAccess = false;
+        this._domStorageAccess = true;
+        this._zoomAccess = true;
+        this._fileAccess = true;
+        this._multiWindowAccess = true;
+        this._allowWindowOpenMethod = true;
+        this._javaScriptAccess = true;
+        this._mixedMode = MixedMode.All;
+        this._cacheMode = CacheMode.None;
+        this._addOnControllerAttached = [];
+        this._addOnPageEnd = [];
+        this._backgroundColor = Color.Transparent;
+        this._verticalScrollBarAccess = false;
+        this._nestedScrollOptions = { scrollForward: NestedScrollMode.SELF_FIRST, scrollBackward: NestedScrollMode.SELF_FIRST };
+        this._overScrollMode = OverScrollMode.NEVER;
+        this.dialogController = null;
+        this.jsBridge = new PLVJsBridge(this);
+    }
+    accessBackward() {
+        if (this._accessBackward?.()) {
+            return true;
+        }
+        else if (this._fullScreenStatus === PLVFullScreenStatus.ENTER) {
+            return true;
+        }
+        try {
+            return super.accessBackward();
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    backward() {
+        if (this._backward?.()) {
+            return;
+        }
+        if (this._fullScreenStatus === PLVFullScreenStatus.ENTER) {
+            this._fullScreenStatus = PLVFullScreenStatus.EXIT;
+            this.runJavaScript(PLVUtils.getExitFullScreenJS(true));
+        }
+        else {
+            super.backward();
+        }
+    }
+    darkMode(darkMode) {
+        this._darkMode = darkMode;
+        return this;
+    }
+    forceDarkAccess(forceDarkAccess) {
+        this._forceDarkAccess = forceDarkAccess;
+        return this;
+    }
+    domStorageAccess(domStorageAccess) {
+        this._domStorageAccess = domStorageAccess;
+        return this;
+    }
+    zoomAccess(zoomAccess) {
+        this._zoomAccess = zoomAccess;
+        return this;
+    }
+    fileAccess(fileAccess) {
+        this._fileAccess = fileAccess;
+        return this;
+    }
+    multiWindowAccess(multiWindowAccess) {
+        this._multiWindowAccess = multiWindowAccess;
+        return this;
+    }
+    allowWindowOpenMethod(allowWindowOpenMethod) {
+        this._allowWindowOpenMethod = allowWindowOpenMethod;
+        return this;
+    }
+    javaScriptAccess(javaScriptAccess) {
+        this._javaScriptAccess = javaScriptAccess;
+        return this;
+    }
+    onControllerAttached(callback) {
+        this._onControllerAttached = callback;
+        return this;
+    }
+    addOnControllerAttached(callback) {
+        this._addOnControllerAttached.push(callback);
+        return this;
+    }
+    onInterceptRequest(callback) {
+        this._onInterceptRequest = callback;
+        return this;
+    }
+    onLoadIntercept(callback) {
+        this._onLoadIntercept = callback;
+        return this;
+    }
+    onWindowNew(callback) {
+        this._onWindowNew = callback;
+        return this;
+    }
+    onShowFileSelector(callback) {
+        this._onShowFileSelector = callback;
+        return this;
+    }
+    onFullScreenEnter(callback) {
+        this._onFullScreenEnter = callback;
+        return this;
+    }
+    onFullScreenExit(callback) {
+        this._onFullScreenExit = callback;
+        return this;
+    }
+    onProgressChange(callback) {
+        this._onProgressChange = callback;
+        return this;
+    }
+    onPageBegin(callback) {
+        this._onPageBegin = callback;
+        return this;
+    }
+    onPageEnd(callback) {
+        this._onPageEnd = callback;
+        return this;
+    }
+    addOnPageEnd(callback) {
+        this._addOnPageEnd.push(callback);
+        return this;
+    }
+    onErrorReceive(callback) {
+        this._onErrorReceive = callback;
+        return this;
+    }
+    backgroundColor(backgroundColor) {
+        this._backgroundColor = backgroundColor;
+        return this;
+    }
+    verticalScrollBarAccess(verticalScrollBarAccess) {
+        this._verticalScrollBarAccess = verticalScrollBarAccess;
+        return this;
+    }
+    nestedScrollOptions(w11) {
+        this._nestedScrollOptions = w11;
+        return this;
+    }
+    overScrollMode(overScrollMode) {
+        this._overScrollMode = overScrollMode;
+    }
+    userAgent(userAgent) {
+        this._userAgent = userAgent;
+        return this;
+    }
+    addOnReloaded(callback) {
+        this._addOnReloaded.push(callback);
+        return this;
+    }
+    registerHandler(v11, handle) {
+        this.jsBridge.registerHandler(v11, handle);
+        return this;
+    }
+    callHandle(t11, data, u11) {
+        this.jsBridge.callHandle(t11, data, u11);
+        return this;
+    }
+    loadHtmlData(data) {
+        PLVLogger.info(TAG, `loadHtmlData: ${data}`);
+        try {
+            super.loadData(data, "text/html", "UTF-8", ' ', ' ');
+        }
+        catch (err) {
+            const e = err;
+            PLVLogger.printError(TAG, `webController loadHtmlData err ${e.code}`, e);
+        }
+        return this;
+    }
+    loadUrlCatch(url) {
+        PLVLogger.info(TAG, `loadUrlCatch: ${url}`);
+        try {
+            super.loadUrl(url);
+            this._addOnReloaded.forEach((value) => {
+                value();
+            });
+        }
+        catch (err) {
+            const e = err;
+            PLVLogger.printError(TAG, `webController loadUrlCatch err ${e.code}`, e);
+        }
+    }
+    handleControllerAttached() {
+        this._addOnControllerAttached.forEach((value) => {
+            value();
+        });
+        if (this._userAgent) {
+            this.setCustomUserAgent(this._userAgent);
+        }
+    }
+    handleFullScreenExit() {
+        if (PLVUtils.isLandscape()) {
+            PLVUtils.changeOrientation(false);
+            PLVUtils.setWindowFullScreen(this._originalIsLayoutFullScreen, this._originalIsFullScreen);
+        }
+    }
+    handleFullScreenEnter() {
+        this.getVideoWHEnterFullScreen(d11, d11, d11 * 10);
+    }
+    handleWindowNew(event, builder) {
+        if (this.dialogController) {
+            this.dialogController.close();
+        }
+        let q11 = new webview.WebviewController();
+        this.dialogController = builder(q11);
+        this.dialogController.open();
+        event.handler.setWebController(q11);
+    }
+    handleIsLoadIntercept(intercept) {
+        try {
+            return this.jsBridge.isInterceptRequest(intercept);
+        }
+        catch (e) {
+            PLVLogger.info(TAG, 'IsLoadIntercept catch');
+            return false;
+        }
+    }
+    handlePageEnd(event) {
+        this._addOnPageEnd.forEach((value) => {
+            value(event);
+        });
+        this._webStatus = PLVWebpageStatus.FINISHED;
+        PLVUtils.retryWhen(() => {
+            this.jsBridge.loadLocalJs(PLVWebController.importSDKModuleContext);
+        }, () => {
+            this.jsBridge.loadLocalJs(getContext(this));
+        })
+            .then(() => {
+            PLVLogger.info(TAG, 'LoadLocalJs success');
+        })
+            .catch((err) => {
+            PLVLogger.info(TAG, `LoadLocalJs catch\n${err.stack}`);
+        });
+    }
+    handleErrorReceive() {
+        this._webStatus = PLVWebpageStatus.FINISHED;
+    }
+    getVideoWHEnterFullScreen(delayTime, e11, f11) {
+        if (delayTime > f11) {
+            return;
+        }
+        setTimeout(() => {
+            this.runJavaScript(PLVUtils.getVideoRectJS(true)).then((value) => {
+                let i11 = JSON.parse(value);
+                if (i11.width === 0 && i11.height === 0) {
+                    this.getVideoWHEnterFullScreen(delayTime + e11, e11, f11);
+                }
+                else if (i11.width > i11.height) {
+                    PLVUtils.changeOrientation(true);
+                    PLVUtils.setWindowFullScreen(true, true).then((k11) => {
+                        this._originalIsLayoutFullScreen = k11[0];
+                        this._originalIsFullScreen = k11[1];
+                    });
+                }
+            });
+        }, delayTime);
+    }
+}

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

@@ -0,0 +1,30 @@
+export interface PLVVideoWH {
+    width: number;
+    height: number;
+}
+export interface PLVProgressEvent {
+    newProgress: number;
+}
+export interface PLVPageEvent {
+    url: string;
+}
+export interface PLVErrorReceiveEvent {
+    request: WebResourceRequest;
+    error: WebResourceError;
+}
+export interface PLVInterceptRequestEvent {
+    request: WebResourceRequest;
+}
+export interface PLVLoadInterceptEvent {
+    data: WebResourceRequest;
+}
+export interface PLVWindowNewEvent {
+    isAlert: boolean;
+    isUserTrigger: boolean;
+    targetUrl: string;
+    handler: ControllerHandler;
+}
+export interface PLVShowFileSelectorEvent {
+    result: FileSelectorResult;
+    fileSelector: FileSelectorParam;
+}

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

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

package/src/main/module.json

@@ -0,0 +1,28 @@
+{
+	"app": {
+		"bundleName": "net.plv.livescenes.demo",
+		"versionCode": 1020000,
+		"versionName": "1.2.0",
+		"minAPIVersion": 50000012,
+		"targetAPIVersion": 50000012,
+		"apiReleaseType": "Release",
+		"compileSdkVersion": "5.0.0.71",
+		"compileSdkType": "HarmonyOS",
+		"appEnvironments": [],
+		"bundleType": "app"
+	},
+	"module": {
+		"name": "foundation",
+		"type": "har",
+		"deviceTypes": [
+			"default",
+			"tablet",
+			"2in1"
+		],
+		"packageName": "@polyvharmony/live-scenes-foundation",
+		"installationFree": false,
+		"virtualMachine": "ark12.0.2.0",
+		"compileMode": "esmodule",
+		"dependencies": []
+	}
+}