@polyvharmony/live-scenes-sdk 1.2.0 → 1.3.0-rc.1

package/src/main/ets/modules/net/vo/PLVNetworkQuality.js

@@ -1,10 +1,10 @@
 export var PLVNetworkQuality;
-(function (z175) {
-    z175[z175["EXCELLENT"] = 0] = "EXCELLENT";
-    z175[z175["GOOD"] = 1] = "GOOD";
-    z175[z175["POOR"] = 2] = "POOR";
-    z175[z175["BAD"] = 3] = "BAD";
-    z175[z175["VERY_BAD"] = 4] = "VERY_BAD";
-    z175[z175["DISCONNECT"] = 5] = "DISCONNECT";
-    z175[z175["UNKNOWN"] = 6] = "UNKNOWN";
+(function (z146) {
+    z146[z146["EXCELLENT"] = 0] = "EXCELLENT";
+    z146[z146["GOOD"] = 1] = "GOOD";
+    z146[z146["POOR"] = 2] = "POOR";
+    z146[z146["BAD"] = 3] = "BAD";
+    z146[z146["VERY_BAD"] = 4] = "VERY_BAD";
+    z146[z146["DISCONNECT"] = 5] = "DISCONNECT";
+    z146[z146["UNKNOWN"] = 6] = "UNKNOWN";
 })(PLVNetworkQuality || (PLVNetworkQuality = {}));

package/src/main/ets/modules/player/PLVPlayerManager.d.ets

@@ -3,10 +3,12 @@ import { PLVBaseModule } from '../../common/PLVBaseModule';
 import { PLVChannelData } from '../../common/PLVChannelData';
 export declare class PLVPlayerManager extends PLVBaseModule {
     private readonly _mainMediaPlayer;
-    constructor(c176: PLVChannelData);
+    constructor(x147: PLVChannelData);
     get mainMediaPlayer(): PLVMediaPlayer;
     startMainMediaPlayerWithComponent(component: object): void;
+    changePlaybackVid(w147?: string): void;
     private setMainMediaPlayerResource;
+    private setMediaResourceToPlayback;
     release(): void;
     destroy(): void;
 }

package/src/main/ets/modules/player/PLVPlayerManager.js

@@ -2,8 +2,8 @@ import { lazy, PLVMediaPlayer, PLVPlaybackListType, requireNotNull } from '@poly
 import { PLVBaseModule } from '../../common/PLVBaseModule';
 import { PLVLoginType } from '../login/model/PLVLoginType';
 export class PLVPlayerManager extends PLVBaseModule {
-    constructor(c176) {
-        super(c176);
+    constructor(x147) {
+        super(x147);
         this._mainMediaPlayer = lazy(() => new PLVMediaPlayer());
     }
     get mainMediaPlayer() {
@@ -13,6 +13,9 @@ export class PLVPlayerManager extends PLVBaseModule {
         this.mainMediaPlayer.setXComponent(component);
         this.setMainMediaPlayerResource();
     }
+    changePlaybackVid(w147) {
+        this.setMediaResourceToPlayback(w147);
+    }
     setMainMediaPlayerResource() {
         if (this.channelData.loginType === PLVLoginType.LIVE) {
             this.mainMediaPlayer.setMediaResource({
@@ -33,26 +36,29 @@ export class PLVPlayerManager extends PLVBaseModule {
             });
         }
         else if (this.channelData.loginType === PLVLoginType.PLAYBACK) {
-            this.mainMediaPlayer.setMediaResource({
-                channelId: requireNotNull(this.channelData.loginChannelId),
-                authentication: {
-                    userId: requireNotNull(this.channelData.userId),
-                    appId: requireNotNull(this.channelData.appId),
-                    appSecret: requireNotNull(this.channelData.appSecret),
-                },
-                viewerParam: {
-                    viewerId: requireNotNull(this.channelData.viewerId),
-                    viewerName: requireNotNull(this.channelData.viewerName),
-                    viewerAvatar: this.channelData.viewerAvatar,
-                    viewLogParam4: this.channelData.param4,
-                    viewLogParam5: this.channelData.param5,
-                },
-                videoId: this.channelData.playbackVid,
-                playbackListType: PLVPlaybackListType.parseType(this.channelData.playbackListType),
-                scene: 'playback'
-            });
+            this.setMediaResourceToPlayback(this.channelData.playbackVid);
         }
     }
+    setMediaResourceToPlayback(v147) {
+        this.mainMediaPlayer.setMediaResource({
+            channelId: requireNotNull(this.channelData.loginChannelId),
+            authentication: {
+                userId: requireNotNull(this.channelData.userId),
+                appId: requireNotNull(this.channelData.appId),
+                appSecret: requireNotNull(this.channelData.appSecret),
+            },
+            viewerParam: {
+                viewerId: requireNotNull(this.channelData.viewerId),
+                viewerName: requireNotNull(this.channelData.viewerName),
+                viewerAvatar: this.channelData.viewerAvatar,
+                viewLogParam4: this.channelData.param4,
+                viewLogParam5: this.channelData.param5,
+            },
+            videoId: v147,
+            playbackListType: PLVPlaybackListType.parseType(this.channelData.playbackListType),
+            scene: 'playback'
+        });
+    }
     release() {
         if (this._mainMediaPlayer.isInit) {
             this.mainMediaPlayer.release();

package/src/main/ets/modules/player/PLVPlayerMediator.d.ets

@@ -1,6 +1,13 @@
 import { PLVPlayerManager } from "./PLVPlayerManager";
 export declare class PLVPlayerMediator {
     private readonly playerManager;
-    constructor(e176: PLVPlayerManager);
+    constructor(a148: PLVPlayerManager);
     get viewLogReportFrequency(): number;
+    get videoCurrentPosition(): number;
+    get pptPlayType(): string;
+    get pptPlayId(): string;
+    get playbackVideoData(): import("@polyvharmony/media-player-sdk").MutableState<import("@polyvharmony/media-player-sdk").PLVPlaybackVideoData>;
+    get seekStartEvent(): import("@polyvharmony/media-player-sdk").MutableEvent<import("@polyvharmony/media-player-sdk").PLVMediaPlayerOnSeekStartEvent>;
+    get playerState(): import("@polyvharmony/media-player-sdk").MutableState<import("@polyvharmony/media-player-sdk").PLVMediaPlayerState>;
+    get progressState(): import("@polyvharmony/media-player-sdk").MutableState<number>;
 }

package/src/main/ets/modules/player/PLVPlayerMediator.js

@@ -1,8 +1,38 @@
+import { PLVPlaybackListType } from "@polyvharmony/media-player-sdk";
 export class PLVPlayerMediator {
-    constructor(e176) {
-        this.playerManager = e176;
+    constructor(a148) {
+        this.playerManager = a148;
     }
     get viewLogReportFrequency() {
         return this.playerManager.mainMediaPlayer.getBusinessListenerRegistry().liveChannelJson.value?.reportFreq ?? 10;
     }
+    get videoCurrentPosition() {
+        return this.playerManager.mainMediaPlayer.getCurrentPosition();
+    }
+    get pptPlayType() {
+        const z147 = this.playerManager.mainMediaPlayer.getBusinessListenerRegistry().playbackVideoData.value;
+        if (PLVPlaybackListType.TEMP_STORE === z147?.playbackListType) {
+            return PLVPlaybackListType.TEMP_STORE.origin;
+        }
+        return PLVPlaybackListType.PLAYBACK.origin;
+    }
+    get pptPlayId() {
+        const y147 = this.playerManager.mainMediaPlayer.getBusinessListenerRegistry().playbackVideoData.value;
+        if (PLVPlaybackListType.TEMP_STORE === y147?.playbackListType) {
+            return y147.fileId ?? '';
+        }
+        return y147?.videoId ?? '';
+    }
+    get playbackVideoData() {
+        return this.playerManager.mainMediaPlayer.getBusinessListenerRegistry().playbackVideoData;
+    }
+    get seekStartEvent() {
+        return this.playerManager.mainMediaPlayer.getEventListenerRegistry().onSeekStartEvent;
+    }
+    get playerState() {
+        return this.playerManager.mainMediaPlayer.getStateListenerRegistry().playerState;
+    }
+    get progressState() {
+        return this.playerManager.mainMediaPlayer.getStateListenerRegistry().progressState;
+    }
 }

package/src/main/ets/modules/player/playback/PLVChapterDataVO.d.ets

@@ -0,0 +1,10 @@
+export declare class PLVChapterDataVO {
+    autoId?: number;
+    docType?: number;
+    event?: string;
+    id?: string;
+    image?: string;
+    pageId?: number;
+    timeStamp?: number;
+    title?: string;
+}

package/src/main/ets/modules/player/playback/PLVChapterDataVO.js

@@ -0,0 +1,2 @@
+export class PLVChapterDataVO {
+}

package/src/main/ets/modules/player/playback/PLVPlaybackListType.js

@@ -1,6 +1,6 @@
 export var PLVPlaybackListType;
-(function (b176) {
-    b176["TEMP_STORE"] = "1";
-    b176["PLAYBACK"] = "2";
-    b176["VOD"] = "3";
+(function (a147) {
+    a147["TEMP_STORE"] = "1";
+    a147["PLAYBACK"] = "2";
+    a147["VOD"] = "3";
 })(PLVPlaybackListType || (PLVPlaybackListType = {}));

package/src/main/ets/modules/player/playback/PLVPreviousListVO.d.ets

@@ -0,0 +1,48 @@
+export declare class PLVPreviousListVO {
+    pageSize?: number;
+    pageNumber?: number;
+    totalItems?: number;
+    totalPages?: number;
+    endRow?: number;
+    nextPageNumber?: number;
+    lastPage?: boolean;
+    prePageNumber?: number;
+    startRow?: number;
+    firstPage?: boolean;
+    limit?: number;
+    offset?: number;
+    contents?: PLVPreviousContent[];
+    fill(): void;
+    private formatDateUtil;
+}
+export declare class PLVPreviousContent {
+    videoId?: string;
+    videoPoolId?: string;
+    userId?: string;
+    channelId?: string;
+    title?: string;
+    firstImage?: string;
+    duration?: string;
+    myBr?: string;
+    qid?: object;
+    seed?: number;
+    ordertime?: number;
+    createdTime?: number;
+    lastModified?: number;
+    rank?: number;
+    asDefault?: string;
+    url?: string;
+    channelSessionId?: string;
+    status?: string;
+    fileUrl?: string;
+    fileId?: string;
+    startTime?: string;
+    liveType?: string;
+    width?: object;
+    height?: object;
+    origin?: object;
+    callbackUrl?: object;
+    errorCount?: object;
+    mergeinfo?: object;
+    watchUrl?: string;
+}

package/src/main/ets/modules/player/playback/PLVPreviousListVO.js

@@ -0,0 +1,21 @@
+import { PLVTextUtils } from "@polyvharmony/live-scenes-foundation";
+export class PLVPreviousListVO {
+    fill() {
+        if (this.contents) {
+            this.contents.forEach(item => {
+                item.firstImage = PLVTextUtils.fixPic(item.firstImage);
+                if (item.startTime) {
+                    item.startTime = this.formatDateUtil(item.startTime);
+                }
+            });
+        }
+    }
+    formatDateUtil(startTime) {
+        if (startTime.length >= 12) {
+            return `${startTime.slice(0, 4)}-${startTime.slice(4, 6)}-${startTime.slice(6, 8)} ${startTime.slice(8, 10)}:${startTime.slice(10, 12)}`;
+        }
+        return startTime;
+    }
+}
+export class PLVPreviousContent {
+}

package/src/main/ets/modules/player/playback/PLVPreviousManager.d.ets

@@ -0,0 +1,73 @@
+import { PLVPromiseValue, PLVStatefulData } from '@polyvharmony/live-scenes-foundation';
+import { PLVBaseModule } from '../../../common/PLVBaseModule';
+import { PLVChannelData } from '../../../common/PLVChannelData';
+import { PLVPlayerMediator } from '../PLVPlayerMediator';
+import { PLVChapterDataVO } from './PLVChapterDataVO';
+import { PLVPreviousContent, PLVPreviousListVO } from './PLVPreviousListVO';
+/**
+ * 往期管理器
+ */
+export declare class PLVPreviousManager extends PLVBaseModule {
+    private playerMediator;
+    /**
+     * 每页数量
+     */
+    pageSize: number;
+    /**
+     * 是否没有更多数据
+     */
+    isNoMoreData: boolean;
+    private currentPage;
+    private previousList;
+    /**
+     * 获取选中的往期数据的promise
+     */
+    selPreviousDataPromise: PLVPromiseValue<PLVSelPreviousData>;
+    /**
+     * 获取选中的章节数据的promise
+     */
+    selChapterDataPromise: PLVPromiseValue<PLVSelChapterData>;
+    /**
+     * 获取往期列表的promise
+     */
+    previousListPromise: PLVPromiseValue<PLVStatefulData<PLVPreviousContent[]>>;
+    /**
+     * 获取章节列表的promise
+     */
+    chapterListPromise: PLVPromiseValue<PLVStatefulData<PLVChapterDataVO[]>>;
+    private lastRequestChapterId;
+    private observes;
+    constructor(t147: PLVChannelData, u147: PLVPlayerMediator);
+    /**
+     * 改变选中的往期数据索引
+     */
+    changeSelPreviousIndex(index: number): void;
+    /**
+     * 改变选中的章节数据索引
+     * @param isPostChanged 是否要改变播放进度
+     */
+    changeSelChapterIndex(index: number, s147?: boolean): void;
+    /**
+     * 请求往期列表
+     * @returns
+     */
+    requestPreviousList(): Promise<PLVPreviousListVO>;
+    /**
+     * 销毁
+     */
+    destroy(): void;
+    private init;
+    private updateChapterListByPlayback;
+    private updateChapterListByRecord;
+}
+export declare class PLVSelPreviousData {
+    index: number;
+    videoPoolId?: string;
+    constructor(index: number, d147?: string);
+}
+export declare class PLVSelChapterData {
+    index: number;
+    timeMillisecond?: number;
+    isPostChanged?: boolean;
+    constructor(index: number, b147?: number, c147?: boolean);
+}

package/src/main/ets/modules/player/playback/PLVPreviousManager.js

@@ -0,0 +1,164 @@
+import { PLVLogger, PLVPromiseValue, PLVStatefulData, PLVUtils } from '@polyvharmony/live-scenes-foundation';
+import { MutableObserver, PLVPlaybackListType as PlayerPLVPlaybackListType, PLVMediaPlayerState } from '@polyvharmony/media-player-sdk';
+import { PLVBaseModule } from '../../../common/PLVBaseModule';
+import { apiChatPlvNetApi } from '../../net/PLVApiChatPlvNetApi';
+import { apiPlvNetApi } from '../../net/PLVApiPlvNetApi';
+import { PLVPlaybackListType } from './PLVPlaybackListType';
+const TAG = '[PLVPreviousManager]';
+export class PLVPreviousManager extends PLVBaseModule {
+    constructor(t147, u147) {
+        super(t147);
+        this.pageSize = 50;
+        this.isNoMoreData = false;
+        this.currentPage = 0;
+        this.previousList = [];
+        this.selPreviousDataPromise = new PLVPromiseValue();
+        this.selChapterDataPromise = new PLVPromiseValue();
+        this.previousListPromise = new PLVPromiseValue();
+        this.chapterListPromise = new PLVPromiseValue();
+        this.observes = [];
+        this.playerMediator = u147;
+        this.init();
+    }
+    changeSelPreviousIndex(index) {
+        this.selPreviousDataPromise.set(new PLVSelPreviousData(index, this.previousList[index]?.videoPoolId));
+    }
+    changeSelChapterIndex(index, s147 = true) {
+        this.selChapterDataPromise.set(new PLVSelChapterData(index, this.chapterListPromise.value?.data?.[index]?.timeStamp, s147));
+    }
+    requestPreviousList() {
+        return PLVUtils.safePromise(async (p147, reject) => {
+            const q147 = PLVPlaybackListType.VOD == this.channelData.playbackListType ? 'vod' : 'playback';
+            this.currentPage++;
+            const r147 = await apiPlvNetApi(this.channelData)
+                .getPreviousList(this.channelData.loginChannelId, this.channelData.appId, this.channelData.appSecret, this.currentPage, this.pageSize, q147)
+                .catch((err) => {
+                this.currentPage--;
+                this.previousListPromise.set(PLVStatefulData.error(err));
+                return Promise.reject(err.log(TAG, 'requestPreviousList error'));
+            });
+            p147(r147.data.data);
+            const contents = r147.data.data.contents;
+            this.isNoMoreData = (contents?.length ?? 0) < this.pageSize;
+            if ((contents?.length ?? 0) > 0) {
+                if (this.previousList.length === 0) {
+                    this.selPreviousDataPromise.set(new PLVSelPreviousData(0, contents[0].videoPoolId));
+                }
+                this.previousList.push(...contents);
+                this.previousListPromise.set(PLVStatefulData.success(this.previousList));
+            }
+            else {
+                PLVLogger.info(TAG, 'requestPreviousList no more data');
+            }
+        });
+    }
+    destroy() {
+        MutableObserver.disposeAll(this.observes);
+    }
+    async init() {
+        await this.channelData.initializedPromise.get();
+        if (this.channelData.hasChapterMenu()) {
+            this.playerMediator.playbackVideoData.observe((o147) => {
+                if (!o147) {
+                    return;
+                }
+                if (PlayerPLVPlaybackListType.TEMP_STORE === o147.playbackListType) {
+                    this.updateChapterListByRecord(o147.fileId);
+                }
+                else if (o147.fileUrl) {
+                    this.updateChapterListByPlayback(o147.videoId);
+                }
+            }).pushTo(this.observes);
+            this.playerMediator.progressState.observe((progress) => {
+                if ((this.chapterListPromise.value?.data?.length ?? 0) <= 0) {
+                    return;
+                }
+                const dataList = this.chapterListPromise.value.data;
+                let m147 = -1;
+                for (let n147 = 0; n147 < dataList.length; n147++) {
+                    const data = dataList[n147];
+                    if (progress >= (data.timeStamp !== undefined ? data.timeStamp * 1000 : 0)) {
+                        m147 = n147;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (m147 !== -1 && m147 !== this.selChapterDataPromise.value?.index) {
+                    this.changeSelChapterIndex(m147, false);
+                }
+            }).pushTo(this.observes);
+        }
+        if (this.channelData.hasPreviousMenu()) {
+            this.playerMediator.playerState.observe((k147) => {
+                if (PLVMediaPlayerState.STATE_COMPLETED === k147) {
+                    if (this.selPreviousDataPromise.value != null) {
+                        const l147 = this.previousList.length - 1 === this.selPreviousDataPromise.value.index;
+                        const index = l147 ? 0 : this.selPreviousDataPromise.value.index + 1;
+                        this.changeSelPreviousIndex(index);
+                    }
+                }
+            }).pushTo(this.observes);
+        }
+    }
+    updateChapterListByPlayback(h147) {
+        if (!h147 || this.lastRequestChapterId === h147) {
+            return;
+        }
+        this.lastRequestChapterId = h147;
+        return PLVUtils.safePromise(async (i147, reject) => {
+            const j147 = await apiChatPlvNetApi(this.channelData)
+                .getPlaybackChapterList(this.channelData.loginChannelId, h147)
+                .catch((err) => {
+                this.chapterListPromise.set(PLVStatefulData.error(err));
+                return Promise.reject(err.log(TAG, 'updateChapterListByPlayback error'));
+            });
+            if (j147.data.length > 0) {
+                this.chapterListPromise.set(PLVStatefulData.success(j147.data));
+                this.changeSelChapterIndex(0, false);
+            }
+            else {
+                PLVLogger.info(TAG, 'updateChapterListByPlayback no data');
+            }
+        });
+    }
+    updateChapterListByRecord(e147) {
+        if (!e147 || this.lastRequestChapterId === e147) {
+            return;
+        }
+        this.lastRequestChapterId = e147;
+        return PLVUtils.safePromise(async (f147, reject) => {
+            const g147 = await apiChatPlvNetApi(this.channelData)
+                .getRecordChapterList(this.channelData.loginChannelId, e147)
+                .catch((err) => {
+                this.chapterListPromise.set(PLVStatefulData.error(err));
+                return Promise.reject(err.log(TAG, 'updateChapterListByRecord error'));
+            });
+            if (g147.data.length > 0) {
+                this.chapterListPromise.set(PLVStatefulData.success(g147.data));
+                this.changeSelChapterIndex(0, false);
+            }
+            else {
+                PLVLogger.info(TAG, 'updateChapterListByRecord no data');
+            }
+        });
+    }
+}
+export class PLVSelPreviousData {
+    constructor(index, d147) {
+        this.index = 0;
+        this.videoPoolId = '';
+        this.index = index;
+        this.videoPoolId = d147;
+    }
+}
+export class PLVSelChapterData {
+    constructor(index, b147, c147) {
+        this.index = 0;
+        this.timeMillisecond = 0;
+        this.isPostChanged = false;
+        this.index = index;
+        this.timeMillisecond = b147 !== undefined ? b147 * 1000 : undefined;
+        this.isPostChanged = c147;
+    }
+}

package/src/main/ets/modules/ppt/PLVPPTWeb.d.ets

@@ -0,0 +1,15 @@
+import { PLVPPTWebController } from './PLVPPTWebController';
+@Component
+export declare struct PLVPPTWeb {
+    controller: PLVPPTWebController;
+    customUrl: string;
+    private url;
+    pptBackgroundImg: string;
+    pptBackgroundImgWidth: string;
+    pptBackgroundColor: string;
+    aboutToAppear(): void;
+    aboutToDisappear(): void;
+    build(): void;
+    config(): void;
+    initUrl(): void;
+}

package/src/main/ets/modules/ppt/PLVPPTWeb.js

@@ -0,0 +1,97 @@
+if (!("finalizeConstruction" in ViewPU.prototype)) {
+    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => {
+    });
+}
+import { PLVNetUtils, PLVSimpleWeb } from '@polyvharmony/live-scenes-foundation';
+import { lateInit } from '@polyvharmony/media-player-sdk';
+const TAG = '[PLVPPTWeb]';
+const URL = 'https://player.polyv.net/resp/ppt-h5/latest/page/pptForMobile.html';
+export class PLVPPTWeb 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 = lateInit();
+        this.customUrl = URL;
+        this.url = URL;
+        this.pptBackgroundImg = '';
+        this.pptBackgroundImgWidth = '';
+        this.pptBackgroundColor = '';
+        this.setInitiallyProvidedValue(params);
+        this.finalizeConstruction();
+    }
+    setInitiallyProvidedValue(params) {
+        if (params.controller !== undefined) {
+            this.controller = params.controller;
+        }
+        if (params.customUrl !== undefined) {
+            this.customUrl = params.customUrl;
+        }
+        if (params.url !== undefined) {
+            this.url = params.url;
+        }
+        if (params.pptBackgroundImg !== undefined) {
+            this.pptBackgroundImg = params.pptBackgroundImg;
+        }
+        if (params.pptBackgroundImgWidth !== undefined) {
+            this.pptBackgroundImgWidth = params.pptBackgroundImgWidth;
+        }
+        if (params.pptBackgroundColor !== undefined) {
+            this.pptBackgroundColor = params.pptBackgroundColor;
+        }
+    }
+    updateStateVars(params) {
+    }
+    purgeVariableDependenciesOnElmtId(rmElmtId) {
+    }
+    aboutToBeDeleted() {
+        SubscriberManager.Get().delete(this.id__());
+        this.aboutToBeDeletedInternal();
+    }
+    aboutToAppear() {
+        this.config();
+    }
+    aboutToDisappear() {
+        this.controller?.destroy();
+    }
+    initialRender() {
+        {
+            this.observeComponentCreation2((elmtId, isInitialRender) => {
+                if (isInitialRender) {
+                    let componentCall = new PLVSimpleWeb(this, {
+                        controller: this.controller,
+                        src: this.url
+                    }, undefined, elmtId, () => {
+                    }, { page: "sdk/src/main/ets/modules/ppt/PLVPPTWeb.ets", line: 28, col: 5 });
+                    ViewPU.create(componentCall);
+                    let paramsLambda = () => {
+                        return {
+                            controller: this.controller,
+                            src: this.url
+                        };
+                    };
+                    componentCall.paramsGenerator_ = paramsLambda;
+                }
+                else {
+                    this.updateStateVarsOfChildByElmtId(elmtId, {});
+                }
+            }, { name: "PLVSimpleWeb" });
+        }
+    }
+    config() {
+        this.initUrl();
+    }
+    initUrl() {
+        this.url = PLVNetUtils.appendParams(this.customUrl, {
+            "useVisibleControl": "true",
+            "domainName": this.controller.channelData.chatDomain?.getChatApiDomainHost() ?? '',
+            "pptBackgroundImg": this.pptBackgroundImg,
+            "pptBackgroundImgWidth": this.pptBackgroundImgWidth,
+            "pptBackgroundColor": this.pptBackgroundColor
+        });
+    }
+    rerender() {
+        this.updateDirtyElements();
+    }
+}

package/src/main/ets/modules/ppt/PLVPPTWebController.d.ets

@@ -0,0 +1,29 @@
+import { PLVEventNotify, PLVWebController } from '@polyvharmony/live-scenes-foundation';
+import { PLVChannelData } from '../../common/PLVChannelData';
+import { PLVSocketMediator } from '../socket/PLVSocketMediator';
+import { PLVPlayerMediator } from '../player/PLVPlayerMediator';
+export type EventType = 'switchPPTLocation' | 'onPPTStatusChange';
+export type ChangePPTType = 'gotoPreviousStep' | 'gotoNextStep' | 'pptBtnBack';
+export declare class PLVPPTWebController extends PLVWebController {
+    private delayTime;
+    private socketMediator;
+    channelData: PLVChannelData;
+    private playerMediator;
+    private callbacks;
+    eventNotify: PLVEventNotify<EventType>;
+    private observers;
+    constructor(r148: PLVChannelData, s148: PLVSocketMediator, t148: PLVPlayerMediator, webTag?: string);
+    updateDelayTime(q148: boolean): void;
+    setSEIData(p148: number): void;
+    changePPTPage(type: ChangePPTType): void;
+    videoStart(n148?: string, o148?: string): void;
+    pptPlay(): void;
+    pptPause(): void;
+    pptSeek(m148: number): void;
+    destroy(): void;
+    private init;
+    private onPlayerData;
+    private onSocketDataAfterAttached;
+    private registerLiveHandlerIfNeed;
+    private registerPlaybackHandlerIfNeed;
+}