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

package/src/main/ets/modules/interact/PLVInteractWeb.js

@@ -0,0 +1,308 @@
+if (!("finalizeConstruction" in ViewPU.prototype)) {
+    Reflect.set(ViewPU.prototype, "finalizeConstruction", () => {
+    });
+}
+import { PLVJSONUtils, PLVLogger, PLVSimpleWeb } from '@polyvharmony/live-scenes-foundation';
+import { PLVLanguage } from '../i18n/PLVLanguageManager';
+import { EVENT_TYPE_LANGUAGE } from '../web/PLVSocketWebController';
+import { toWebParams } from '../web/PLVWebParams';
+import { PLVShowLotteryEvent } from './lottery/PLVShowLotteryEvent';
+import { PLVInteractInfo, PLVLotteryDataBean } from './model/info/PLVInteractInfo';
+import { PLVWebviewUpdateAppStatusVO } from './model/PLVWebviewUpdateAppStatusVO';
+import { PLVUpdateChannelSwitchEvent } from '../socket/model/interact/PLVUpdateChannelSwitchEvent';
+import { PLVCallAppEvent } from '../socket/model/interact/PLVCallAppEvent';
+import { PLVChangeRedpackStatusEvent } from '../socket/model/interact/PLVChangeRedpackStatusEvent';
+import { PLVInteractDataBean } from './model/PLVInteractBean';
+import { PLVRedPaperReceiveType } from '../socket/model/redpack/RedPaperReceiveType';
+import { PLVProductContentBean } from '../product/model/PLVProductContentBean';
+const V2_GET_NATIVE_APP_PARAMS_INFO = "getNativeAppParamsInfo";
+const V2_INIT_WEB_VIEW = "initWebView";
+const V2_CLOSE_WEB_VIEW = "closeWebView";
+const V2_LINK_CLICK = "linkClick";
+const V2_CALL_APP_EVENT = "callAppEvent";
+const V2_SHOW_WEB_VIEW = "showWebView";
+const V2_WEB_VIEW_UPDATE_APP_STATUS = "webViewUpdateAppStatus";
+const V2_LOCK_TO_PORTRAIT = "lockToPortrait";
+const V2_GET_INTERACT_INFO = "getInteractInfo";
+const V2_CLICK_PRODUCT_BUTTON = 'clickProductButton';
+const V2_UPDATE_NATIVE_APP_PARAMS_INFO = "updateNativeAppParamsInfo";
+const V2_APP_CALL_WEB_VIEW_EVENT = "appCallWebViewEvent";
+const EVENT_OPEN_RED_PAPER = "OPEN_RED_PAPER";
+const V2_UPDATE_CHANNEL_CONFIG = "updateChannelConfig";
+const JS_HANDLER = [V2_GET_NATIVE_APP_PARAMS_INFO, V2_INIT_WEB_VIEW, V2_CLOSE_WEB_VIEW, V2_LINK_CLICK,
+    V2_CALL_APP_EVENT, V2_SHOW_WEB_VIEW, V2_WEB_VIEW_UPDATE_APP_STATUS, V2_LOCK_TO_PORTRAIT,
+    V2_GET_INTERACT_INFO, V2_CLICK_PRODUCT_BUTTON];
+const TAG = '[PLVInteractWeb]';
+const URL = 'https://websdk.videocc.net/interactions-receive-sdk-ui-webview/latest/index.html';
+const WATCH_STATUS_PLAYBACK = "1";
+const WATCH_STATUS_LIVE = "0";
+const LANG_EN = "en";
+const LANG_ZH = "zh_CN";
+export class PLVInteractWeb 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 = new SynchedPropertyObjectTwoWayPU(params.controller, this, "controller");
+        this.__interactManager = new SynchedPropertyObjectTwoWayPU(params.interactManager, this, "interactManager");
+        this.__interactCallback = new SynchedPropertyObjectTwoWayPU(params.interactCallback, this, "interactCallback");
+        this.redpackManager = undefined;
+        this.url = URL;
+        this.watchStatus = WATCH_STATUS_LIVE;
+        this.setInitiallyProvidedValue(params);
+        this.finalizeConstruction();
+    }
+    setInitiallyProvidedValue(params) {
+        if (params.redpackManager !== undefined) {
+            this.redpackManager = params.redpackManager;
+        }
+        if (params.url !== undefined) {
+            this.url = params.url;
+        }
+        if (params.watchStatus !== undefined) {
+            this.watchStatus = params.watchStatus;
+        }
+    }
+    updateStateVars(params) {
+    }
+    purgeVariableDependenciesOnElmtId(rmElmtId) {
+        this.__controller.purgeDependencyOnElmtId(rmElmtId);
+        this.__interactManager.purgeDependencyOnElmtId(rmElmtId);
+        this.__interactCallback.purgeDependencyOnElmtId(rmElmtId);
+    }
+    aboutToBeDeleted() {
+        this.__controller.aboutToBeDeleted();
+        this.__interactManager.aboutToBeDeleted();
+        this.__interactCallback.aboutToBeDeleted();
+        SubscriberManager.Get().delete(this.id__());
+        this.aboutToBeDeletedInternal();
+    }
+    get controller() {
+        return this.__controller.get();
+    }
+    set controller(newValue) {
+        this.__controller.set(newValue);
+    }
+    get interactManager() {
+        return this.__interactManager.get();
+    }
+    set interactManager(newValue) {
+        this.__interactManager.set(newValue);
+    }
+    get interactCallback() {
+        return this.__interactCallback.get();
+    }
+    set interactCallback(newValue) {
+        this.__interactCallback.set(newValue);
+    }
+    aboutToAppear() {
+        this.config();
+        this.observer();
+    }
+    aboutToDisappear() {
+        this.controller?.destroy();
+    }
+    initialRender() {
+        {
+            this.observeComponentCreation2((elmtId, isInitialRender) => {
+                if (isInitialRender) {
+                    let componentCall = new PLVSimpleWeb(this, {
+                        controller: this.controller,
+                        src: URL
+                    }, undefined, elmtId, () => {
+                    }, { page: "sdk/src/main/ets/modules/interact/PLVInteractWeb.ets", line: 77, col: 5 });
+                    ViewPU.create(componentCall);
+                    let paramsLambda = () => {
+                        return {
+                            controller: this.controller,
+                            src: URL
+                        };
+                    };
+                    componentCall.paramsGenerator_ = paramsLambda;
+                }
+                else {
+                    this.updateStateVarsOfChildByElmtId(elmtId, {});
+                }
+            }, { name: "PLVSimpleWeb" });
+        }
+    }
+    config() {
+        this.initUrl(this.controller?.channelData.language);
+        this.controller?.eventNotify?.on(EVENT_TYPE_LANGUAGE, (data) => {
+            this.initUrl(data);
+            this.controller?.loadUrlCatch(this.url);
+        }, this);
+        JS_HANDLER.forEach((event) => {
+            this.controller?.registerHandler(event, (data, callback) => {
+                PLVLogger.info(TAG, `${event} param: ${data}`);
+                this.handlerJsCall(event, data, callback);
+            });
+        });
+    }
+    initUrl(data) {
+        const lang = data == PLVLanguage.EN ? LANG_EN : LANG_ZH;
+        this.url = URL + `?livePlayBack=${WATCH_STATUS_LIVE}&lang=${lang}`;
+    }
+    handlerJsCall(event, param, callback) {
+        switch (event) {
+            case V2_GET_NATIVE_APP_PARAMS_INFO:
+                this.processGetNativeAppParamsInfo(param, callback);
+                break;
+            case V2_CLOSE_WEB_VIEW:
+                this.interactCallback?.processWebViewVisibility?.(false);
+                break;
+            case V2_SHOW_WEB_VIEW:
+                this.interactCallback?.processWebViewVisibility?.(true);
+                break;
+            case V2_WEB_VIEW_UPDATE_APP_STATUS:
+                this.processWebViewUpdateAppStatus(param);
+                break;
+            case V2_GET_INTERACT_INFO:
+                this.processGetInteractInfo(param, callback);
+                break;
+            case V2_CLICK_PRODUCT_BUTTON:
+                this.processClickProductEvent(param, callback);
+                break;
+            case V2_CALL_APP_EVENT: this.processCallAppEvent(param, callback);
+        }
+    }
+    async processGetNativeAppParamsInfo(data, callback) {
+        const param = await toWebParams(this.controller.channelData);
+        callback(param);
+    }
+    processWebViewUpdateAppStatus(data) {
+        const w125 = PLVJSONUtils.json2Bean(PLVWebviewUpdateAppStatusVO, data);
+        if (w125) {
+            this.interactManager?.interactStatusNotify.emit("interact_status", w125);
+        }
+    }
+    processGetInteractInfo(data, callback) {
+        const s125 = this.controller?.channelData.liveDetail?.lotteryGiftButtonTextCH;
+        const t125 = this.controller?.channelData.liveDetail?.lotteryGiftButtonTextEN;
+        const info = new PLVInteractInfo();
+        const u125 = new PLVLotteryDataBean();
+        u125.lotteryTextCN = s125;
+        u125.lotteryTextEN = t125;
+        info.lotteryData = u125;
+        const v125 = PLVJSONUtils.bean2Json(u125);
+        callback(v125);
+    }
+    showQuestionnaire() {
+        const data = "{\"event\" : \"SHOW_QUESTIONNAIRE\"}";
+        this.controller?.callHandle(V2_APP_CALL_WEB_VIEW_EVENT, data, (data) => {
+            PLVLogger.info(TAG, `${V2_APP_CALL_WEB_VIEW_EVENT} ${data}`);
+        });
+    }
+    showCardPush(p125) {
+        const data = PLVJSONUtils.bean2Json(p125) ?? "";
+        this.controller?.callHandle(V2_APP_CALL_WEB_VIEW_EVENT, data, (data) => {
+            PLVLogger.info(TAG, `${V2_APP_CALL_WEB_VIEW_EVENT} ${data}`);
+        });
+    }
+    showLottery() {
+        const data = PLVJSONUtils.bean2Json(new PLVShowLotteryEvent());
+        this.controller?.callHandle(V2_APP_CALL_WEB_VIEW_EVENT, data, (data) => {
+            PLVLogger.info(TAG, `${V2_APP_CALL_WEB_VIEW_EVENT} ${data}`);
+        });
+    }
+    onShowJobDetail(event) {
+        const data = PLVJSONUtils.bean2Json(event);
+        this.controller?.callHandle(V2_APP_CALL_WEB_VIEW_EVENT, data, (data) => {
+            PLVLogger.info(TAG, `${V2_APP_CALL_WEB_VIEW_EVENT} ${data}`);
+        });
+    }
+    receiveRedPaper(k125) {
+        this.redpackManager?.receiveRedPaper(k125, this.controller?.channelData.loginChannelId, this.controller?.channelData?.viewerId);
+        const map = new Map();
+        map.set("event", EVENT_OPEN_RED_PAPER);
+        map.set("data", k125);
+        const payload = PLVJSONUtils.map2jsonStr(map, (key, value) => {
+            if (key === 'id' || key === 'receiveType' || key === 'time') {
+                return undefined;
+            }
+            return value;
+        });
+        this.controller?.callHandle(V2_APP_CALL_WEB_VIEW_EVENT, payload, (data) => {
+            PLVLogger.info(TAG, `${V2_APP_CALL_WEB_VIEW_EVENT} ${data}`);
+        });
+    }
+    updateChannelSwitch(values) {
+        if (values.isEmpty()) {
+            return;
+        }
+        const h125 = new PLVUpdateChannelSwitchEvent();
+        values.forEach((value) => {
+            h125.value?.push(value);
+        });
+        const data = PLVJSONUtils.safeStringify(h125);
+        this.controller?.callHandle(V2_UPDATE_CHANNEL_CONFIG, data, (data) => {
+            PLVLogger.info(TAG, `${V2_UPDATE_CHANNEL_CONFIG} ${data}`);
+        });
+    }
+    processCallAppEvent(data, callback) {
+        const f125 = PLVJSONUtils.toFillData(PLVCallAppEvent, data);
+        if (!f125) {
+            return;
+        }
+        switch (f125?.event) {
+            case PLVChangeRedpackStatusEvent.EVENT:
+                this.processChangeRedpackStatusEvent(data);
+                return;
+        }
+        if (f125?.isOpenLinkEvent()) {
+            this.interactCallback?.processOpenLinkEvent?.(f125.isInsideOpen(), f125.isOutsideOpen(), f125.getUrl() ?? "");
+        }
+        else if (f125?.isUpdateIarEntranceEvent()) {
+            f125.getDataArray();
+        }
+        let g125 = new PLVInteractDataBean();
+        g125.callAppEvent = f125;
+        this.interactManager?.eventDataNotify.emit('interact_data', g125);
+    }
+    processChangeRedpackStatusEvent(data) {
+        const e125 = PLVJSONUtils.json2Bean(PLVChangeRedpackStatusEvent, data);
+        if (!e125 || !e125?.isValid()) {
+            return;
+        }
+        this.redpackManager?.updateRedPaperReceiveStatus(e125.value?.redpackId, PLVRedPaperReceiveType.match(e125.value?.status));
+    }
+    processClickProductEvent(data, callback) {
+        const jsonObject = PLVJSONUtils.safeParse(data);
+        if (jsonObject) {
+            const c125 = PLVJSONUtils.bean2Bean(new PLVProductContentBean(), jsonObject['data']);
+            const d125 = c125?.getLinkByType();
+            this.interactCallback?.processClickProductEvent?.(d125);
+        }
+    }
+    observer() {
+        this.controller?.channelData.eventNotify.on('switch_function', (value) => {
+            this.updateChannelSwitch(value);
+        });
+        this.interactManager?.registerInteractView({
+            showQuestionnaire: () => {
+                this.showQuestionnaire();
+            },
+            showCardPush: (b125) => {
+                this.showCardPush(b125);
+            },
+            showLottery: () => {
+                this.showLottery();
+            },
+            receiveRedPaper: (a125) => {
+                this.receiveRedPaper(a125);
+            },
+            onShowJobDetail: (event) => {
+                if (!event) {
+                    return;
+                }
+                this.onShowJobDetail(event);
+            }
+        });
+    }
+    rerender() {
+        this.updateDirtyElements();
+    }
+}
+export class PLVInteractCallback {
+}

package/src/main/ets/modules/interact/invitePoster/PLVInteractInvitePoster.d.ets

@@ -0,0 +1,9 @@
+import { PLVChannelData } from "../../../common/PLVChannelData";
+export declare class PLVInteractInvitePoster {
+    private readonly channelData;
+    private invitePosterSetting;
+    constructor(t124: PLVChannelData);
+    getInvitePosterUrl(): Promise<string>;
+    getLiveWatchUrl(): Promise<string>;
+    private getInvitePosterSetting;
+}

package/src/main/ets/modules/interact/invitePoster/PLVInteractInvitePoster.js

@@ -0,0 +1,55 @@
+import { extendString, formatDate, isLiteralTrue, requireNotNull, runCatching } from "@polyvharmony/media-player-sdk";
+import { apiPlvNetApi } from "../../net/PLVApiPlvNetApi";
+export class PLVInteractInvitePoster {
+    constructor(t124) {
+        this.invitePosterSetting = undefined;
+        this.channelData = t124;
+    }
+    async getInvitePosterUrl() {
+        const setting = await this.getInvitePosterSetting();
+        const o124 = requireNotNull(this.channelData.loginChannelId);
+        const p124 = requireNotNull(this.channelData.viewerId);
+        const q124 = requireNotNull(this.channelData.viewerName);
+        const r124 = this.channelData.viewerAvatar;
+        let type = setting.invitePosterTheme;
+        let s124 = setting.inviteCoverImage;
+        if (type == -1 || !isLiteralTrue(setting.invitePosterEnabled)) {
+            type = 3;
+            s124 = "//s1.videocc.net/default-img/channel/default-splash.png";
+        }
+        return extendString("https://live.polyv.cn/invite-poster/poster.html")
+            .setUrlQueryParam_ext({
+            type: type?.toString(),
+            avatar: r124,
+            nickname: q124,
+            name: setting.name,
+            inviteCoverImage: s124,
+            time: Date.now().toString(),
+            publisher: setting.publisher,
+            invitePosterId: p124,
+            watchDomain: setting.watchDomain,
+            channelId: o124,
+            watchUrl: setting.watchUrl,
+            customUserType: setting.customUserType,
+            footerText: setting.footerSetting?.footerText
+        }) + `&startTime=${(setting.startTime ?? 0) === 0 ? "" : formatDate(new Date(setting.startTime), "yyyy-MM-dd HH:mm")}`;
+    }
+    async getLiveWatchUrl() {
+        const setting = await this.getInvitePosterSetting();
+        return requireNotNull(setting.watchUrl, () => "getLiveShareUrl watchUrl is null");
+    }
+    async getInvitePosterSetting() {
+        if (this.invitePosterSetting !== undefined) {
+            return this.invitePosterSetting;
+        }
+        const k124 = requireNotNull(this.channelData.loginChannelId);
+        const appId = requireNotNull(this.channelData.appId);
+        const l124 = requireNotNull(this.channelData.appSecret);
+        const result = await runCatching(apiPlvNetApi(this.channelData).getInvitePosterSetting(k124, appId, l124));
+        if (result.success === false) {
+            throw result.error;
+        }
+        this.invitePosterSetting = requireNotNull(result.data.data.data, () => "getInvitePosterSetting Response null");
+        return this.invitePosterSetting;
+    }
+}

package/src/main/ets/modules/interact/invitePoster/model/PLVInvitePosterSettingVO.d.ets

@@ -0,0 +1,40 @@
+export declare class PLVInvitePosterSettingVO {
+    channelId?: number | null;
+    followEnabled?: string | null;
+    followAutoShow?: string | null;
+    followImage?: string | null;
+    followEntrance?: string | null;
+    followTips?: string | null;
+    invitePosterEnabled?: Object | null;
+    inviteListEnabled?: Object | null;
+    inviteCoverImage?: string | null;
+    invitePosterTheme?: number | null;
+    name?: string | null;
+    publisher?: string | null;
+    startTime?: number | null;
+    footerSetting?: FooterSetting | null;
+    invitePosterCustomEnabled?: string | null;
+    invitePosterNickNameEnabled?: string | null;
+    invitePosterAvatarEnabled?: string | null;
+    invitePosterImageUrl?: Object | null;
+    qrCodePositionX?: Object | null;
+    qrCodePositionY?: Object | null;
+    qrCodeSize?: Object | null;
+    nickNameSize?: Object | null;
+    nickNamePositionX?: Object | null;
+    nickNamePositionY?: Object | null;
+    nickNameColor?: Object | null;
+    avatarPositionX?: Object | null;
+    avatarPositionY?: Object | null;
+    avatarSize?: Object | null;
+    customUserType?: string | null;
+    watchUrl?: string | null;
+    watchDomain?: string | null;
+}
+export declare class FooterSetting {
+    userId?: string | null;
+    showFooterEnabled?: string | null;
+    footerText?: string | null;
+    footTextLinkProtocol?: string | null;
+    footTextLinkUrl?: string | null;
+}

package/src/main/ets/modules/interact/invitePoster/model/PLVInvitePosterSettingVO.js

@@ -0,0 +1,4 @@
+export class PLVInvitePosterSettingVO {
+}
+export class FooterSetting {
+}

package/src/main/ets/modules/interact/lottery/PLVShowLotteryEvent.d.ets

@@ -0,0 +1,3 @@
+export declare class PLVShowLotteryEvent {
+    event?: string;
+}

package/src/main/ets/modules/interact/lottery/PLVShowLotteryEvent.js

@@ -0,0 +1,5 @@
+export class PLVShowLotteryEvent {
+    constructor() {
+        this.event = "CLICK_LOTTERY_PENDANT";
+    }
+}

package/src/main/ets/modules/interact/model/PLVFunctionSwitchBean.d.ets

@@ -0,0 +1,9 @@
+export declare class PLVFunctionSwitchBean {
+    type?: string;
+    imageResource?: Resource;
+    name?: string | Resource;
+    isShow?: boolean;
+    isSelected?: boolean;
+    icon?: string;
+    constructor(type?: string, u124?: Resource, name?: string | Resource, isShow?: boolean, icon?: string);
+}

package/src/main/ets/modules/interact/model/PLVFunctionSwitchBean.js

@@ -0,0 +1,9 @@
+export class PLVFunctionSwitchBean {
+    constructor(type, u124, name, isShow, icon) {
+        this.type = type;
+        this.imageResource = u124;
+        this.isShow = isShow;
+        this.name = name;
+        this.icon = icon;
+    }
+}

package/src/main/ets/modules/interact/model/PLVInteractBean.d.ets

@@ -0,0 +1,17 @@
+import { PLVCallAppEvent } from '../../../modules/socket/model/interact/PLVCallAppEvent';
+import { PLVRedPaperEvent } from '../../../modules/interact/redpack/model/PLVRedPaperEvent';
+import { PLVShowPushCardEvent } from '../../../modules/interact/pushcard/model/PLVShowPushCardEvent';
+import { PLVShowJobDetailEvent } from '../../socket/model/interact/PLVShowJobDetailEvent';
+export declare class PLVInteractBean {
+    data: PLVInteractDataBean;
+}
+export declare class PLVInteractDataBean {
+    callAppEvent?: PLVCallAppEvent;
+}
+export declare class IPLVInteractView {
+    showQuestionnaire?: () => void;
+    showCardPush?: (showPushCardEvent: PLVShowPushCardEvent | undefined) => void;
+    showLottery?: () => void;
+    receiveRedPaper?: (redPaperEvent: PLVRedPaperEvent) => void;
+    onShowJobDetail?: (event: PLVShowJobDetailEvent | undefined) => void;
+}

package/src/main/ets/modules/interact/model/PLVInteractBean.js

@@ -0,0 +1,9 @@
+export class PLVInteractBean {
+    constructor() {
+        this.data = new PLVInteractDataBean();
+    }
+}
+export class PLVInteractDataBean {
+}
+export class IPLVInteractView {
+}

package/src/main/ets/modules/interact/model/PLVWebviewUpdateAppStatusVO.d.ets

@@ -0,0 +1,16 @@
+export declare class PLVWebviewUpdateAppStatusVO {
+    event?: string;
+    value?: ValueBean;
+}
+export declare class ValueBean {
+    dataArray?: FunctionBean[];
+}
+export declare class FunctionBean {
+    event?: string;
+    icon?: string;
+    title?: string;
+    isShow?: boolean;
+    status?: string;
+    delayTime?: number;
+    iconUrl?: string;
+}

package/src/main/ets/modules/interact/model/PLVWebviewUpdateAppStatusVO.js

@@ -0,0 +1,6 @@
+export class PLVWebviewUpdateAppStatusVO {
+}
+export class ValueBean {
+}
+export class FunctionBean {
+}

package/src/main/ets/modules/interact/model/info/PLVInteractInfo.d.ets

@@ -0,0 +1,7 @@
+export declare class PLVInteractInfo {
+    lotteryData?: PLVLotteryDataBean;
+}
+export declare class PLVLotteryDataBean {
+    lotteryTextCN?: string;
+    lotteryTextEN?: string;
+}

package/src/main/ets/modules/interact/model/info/PLVInteractInfo.js

@@ -0,0 +1,4 @@
+export class PLVInteractInfo {
+}
+export class PLVLotteryDataBean {
+}

package/src/main/ets/modules/interact/pushcard/PLVPushCardManager.d.ets

@@ -0,0 +1,28 @@
+import { IPLVEventNotify } from '@polyvharmony/live-scenes-foundation/';
+import { PLVBaseModule } from '../../../common/PLVBaseModule';
+import { PLVChannelData } from '../../../common/PLVChannelData';
+import { PLVSocketMediator } from '../../socket/PLVSocketMediator';
+import { PLVCardPushVO } from './model/PLVCardPushVO';
+/**
+ * 事件类型，可以使用{@link PLVPushCardManager#eventNotify}监听对应的事件
+ */
+export type EventType = 'pushcard_data';
+/**
+ * 卡片推送管理器
+ */
+export declare class PLVPushCardManager extends PLVBaseModule {
+    private socketMediator;
+    private getCardPushInfoDisposable;
+    eventNotify: IPLVEventNotify<EventType>;
+    constructor(o126: PLVChannelData, p126: PLVSocketMediator);
+    private init;
+    private notifyPushStart;
+    private notifyPushCancel;
+    /**
+     * 获取推送卡片的信息
+     * @param cardId
+     * @returns
+     */
+    getCardPushInfo(e126?: string): Promise<PLVCardPushVO>;
+    disposable(): void;
+}

package/src/main/ets/modules/interact/pushcard/PLVPushCardManager.js

@@ -0,0 +1,50 @@
+import { PLVDisposable, PLVEventNotify, PLVJSONUtils, PLVUtils } from '@polyvharmony/live-scenes-foundation/';
+import { apiPlvLiveImagesApi } from '../../net/PLVLiveImagesVideoNetApi';
+import { PLVBaseModule } from '../../../common/PLVBaseModule';
+import { PLVSocketOnEvent, PLVSocketPushCardEvent } from '../../socket/model/PLVSocketEventConstants';
+import { PLVNewsPushEvent } from './model/PLVNewsPushEvent';
+const TAG = '[PLVNewsPushStartEvent]';
+export class PLVPushCardManager extends PLVBaseModule {
+    constructor(o126, p126) {
+        super(o126);
+        this.getCardPushInfoDisposable = new PLVDisposable();
+        this.eventNotify = new PLVEventNotify(this);
+        this.socketMediator = p126;
+        this.init();
+    }
+    async init() {
+        this.socketMediator.onData(PLVSocketOnEvent.NEWS_PUSH, (data, event) => {
+            if (PLVSocketPushCardEvent.NEWS_PUSH_START === event) {
+                const n126 = PLVJSONUtils.json2Bean(PLVNewsPushEvent, data);
+                if (n126) {
+                    this.notifyPushStart(n126);
+                }
+            }
+            else if (PLVSocketPushCardEvent.NEWS_PUSH_CANCEL === event) {
+                this.notifyPushCancel();
+            }
+        });
+    }
+    notifyPushStart(l126) {
+        this.eventNotify.emit("pushcard_data", l126);
+    }
+    notifyPushCancel() {
+        const k126 = new PLVNewsPushEvent();
+        k126.EVENT = PLVSocketPushCardEvent.NEWS_PUSH_CANCEL;
+        this.eventNotify.emit("pushcard_data", k126);
+    }
+    getCardPushInfo(e126) {
+        this.getCardPushInfoDisposable = new PLVDisposable();
+        return PLVUtils.safePromise(async (g126, h126) => {
+            const i126 = await PLVUtils.disposablePromise(apiPlvLiveImagesApi(this.channelData)
+                .getCardPushInfo(this.channelData.loginChannelId, e126)
+                .catch((err) => {
+                return Promise.reject(err.log(TAG, 'getCardPushInfo error'));
+            }), this.getCardPushInfoDisposable);
+            g126(i126.data.data);
+        });
+    }
+    disposable() {
+        this.getCardPushInfoDisposable.dispose();
+    }
+}

package/src/main/ets/modules/interact/pushcard/model/PLVCardPushVO.d.ets

@@ -0,0 +1,16 @@
+export declare class PLVCardPushVO {
+    cardImage?: string;
+    conditionValue?: number;
+    countdownMsg?: string;
+    duration?: number;
+    enterEnabled?: string;
+    enterImage?: string;
+    imageType?: string;
+    link?: string;
+    redirectType?: string;
+    showCondition?: string;
+    title?: string;
+    isGiftboxType(): boolean;
+    isRedpackType(): boolean;
+    isCustomType(): boolean;
+}

package/src/main/ets/modules/interact/pushcard/model/PLVCardPushVO.js

@@ -0,0 +1,11 @@
+export class PLVCardPushVO {
+    isGiftboxType() {
+        return "giftbox" === this.imageType;
+    }
+    isRedpackType() {
+        return "redpack" === this.imageType;
+    }
+    isCustomType() {
+        return "custom" === this.imageType;
+    }
+}

package/src/main/ets/modules/interact/pushcard/model/PLVNewsPushEvent.d.ets

@@ -0,0 +1,10 @@
+export declare class PLVNewsPushEvent {
+    EVENT?: string;
+    roomId?: string;
+    id?: string;
+    time?: number;
+    total?: number;
+    entrance?: string;
+    lookTime?: number;
+    isEntrance(): boolean;
+}

package/src/main/ets/modules/interact/pushcard/model/PLVNewsPushEvent.js

@@ -0,0 +1,5 @@
+export class PLVNewsPushEvent {
+    isEntrance() {
+        return "Y" === this.entrance;
+    }
+}

package/src/main/ets/modules/interact/pushcard/model/PLVShowPushCardEvent.d.ets

@@ -0,0 +1,6 @@
+import { PLVNewsPushEvent } from './PLVNewsPushEvent';
+export declare class PLVShowPushCardEvent {
+    event?: string;
+    data?: PLVNewsPushEvent;
+    setData(data: PLVNewsPushEvent | undefined): this;
+}

package/src/main/ets/modules/interact/pushcard/model/PLVShowPushCardEvent.js

@@ -0,0 +1,9 @@
+export class PLVShowPushCardEvent {
+    constructor() {
+        this.event = "SHOW_PUSH_CARD";
+    }
+    setData(data) {
+        this.data = data;
+        return this;
+    }
+}