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

package/src/main/ets/modules/linkmic/viewmodel/usecase/roles/viewer/LinkMicViewerHandleStateUseCase.js

@@ -0,0 +1,373 @@
+import { PLVDisposable, PLVLogger, PLVScheduledTask } from '@polyvharmony/live-scenes-foundation';
+import { decodeFromJson, encodeToJson, isNullOrUndefined, MutableObserver, requireNotNull, runCatching, seconds } from '@polyvharmony/media-player-sdk';
+import { PLVSocketMessageEvent, PLVSocketOnEvent } from '../../../../../socket/model/PLVSocketEventConstants';
+import { PLVUserType } from '../../../../../socket/model/PLVUserType';
+import { PLVLinkMicErrorEvent } from '../../../../model/vo/PLVLinkMicErrorEvent';
+import { PLVLinkMicMode } from '../../../../model/vo/PLVLinkMicMode';
+import { PLVLinkMicRTCJoinSuccess, PLVLinkMicRTCKickOut } from '../../../../model/vo/PLVLinkMicRTCEvent';
+import { PLVLinkMicSocketJoinAnswerSend, PLVLinkMicSocketJoinAnswerTTLAck, PLVLinkMicSocketJoinAnswerTTLSend, PLVLinkMicSocketJoinLeaveRecv, PLVLinkMicSocketJoinLeaveSend, PLVLinkMicSocketJoinRequestRecv, PLVLinkMicSocketJoinRequestSend, PLVLinkMicSocketJoinResponseRecv, PLVLinkMicSocketJoinSuccessRecv, PLVLinkMicSocketJoinSuccessSend, PLVLinkMicSocketMicSettingAck, PLVLinkMicSocketMicSettingSend, PLVLinkMicSocketMuteUserMicroRecv, PLVLinkMicSocketOpenMicrophoneRecv, PLVLinkMicSocketSwitchViewRecv } from '../../../../model/vo/PLVLinkMicSocketEvent';
+import { PLVLinkMicState } from '../../../../model/vo/PLVLinkMicState';
+import { PLVSocketUserSend } from '../../../../../socket/model/PLVSocketUserBean';
+import { PLVMemberSocketSetNickRecv } from '../../../../../member/model/vo/PLVMemberSocketEvent';
+const TAG = "PLVLinkMicManager";
+export class LinkMicViewerHandleStateUseCase {
+    constructor(t151, u151, v151, w151) {
+        this.taskUpdateMicSetting = undefined;
+        this.disposables = [];
+        this.observers = [];
+        this.repo = t151;
+        this.handleQueueOrderUseCase = u151;
+        this.handleRTCUseCase = v151;
+        this.updateChannelViewerUseCase = w151;
+    }
+    init() {
+        this.disposables.push(this.observeSocketEvent(PLVSocketOnEvent.MESSAGE, (data, event) => this.onSocketMessage(data, event)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_REQUEST, (data) => this.onSocketJoinRequest(data)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_RESPONSE, (data) => this.onSocketJoinResponse(data)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_SUCCESS, (data) => this.onSocketJoinSuccess(data)), this.observeSocketEvent(PLVSocketOnEvent.JOIN_LEAVE, (data) => this.onSocketJoinLeave(data)), this.observeSocketEvent(PLVSocketOnEvent.SWITCH_VIEW, (data) => this.onSocketSwitchView(data)));
+        this.repo.mediator.rtcEvent.observe((event) => this.onRTCEvent(event))
+            .pushTo(this.observers);
+        this.repo.mediator.viewerLeaveLinkMicEvent.observe(s151 => this.onViewerLeaveLinkMic(s151))
+            .pushTo(this.observers);
+        this.taskUpdateMicSetting = new PLVScheduledTask(() => this.updateMicSetting(), seconds(1).toMillis(), seconds(10).toMillis());
+        this.taskUpdateMicSetting.start();
+    }
+    async requestJoinLinkMic() {
+        const h151 = this.repo.mediator.linkmicState.value;
+        if (h151 === PLVLinkMicState.Inviting) {
+            this.acceptInvitation();
+            return;
+        }
+        if (await this.isChannelReachLinkMicLimit()) {
+            this.repo.mediator.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+            this.repo.mediator.reportError(PLVLinkMicErrorEvent.REACH_LINKMIC_LIMIT, "requestJoinLinkMic channel reach linkmic limit");
+            return;
+        }
+        const event = new PLVLinkMicSocketJoinRequestSend();
+        event.user = this.createSocketUser();
+        event.roomId = this.repo.mediator.channelData?.loginChannelId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_REQUEST, encodeToJson(event), () => {
+            this.repo.mediator.linkmicState.setValue(PLVLinkMicState.Requesting);
+        });
+    }
+    async acceptInvitation() {
+        if (await this.isChannelReachLinkMicLimit()) {
+            this.repo.mediator.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+            this.repo.mediator.reportError(PLVLinkMicErrorEvent.REACH_LINKMIC_LIMIT, "acceptInvitation channel reach linkmic limit");
+            return;
+        }
+        const event = new PLVLinkMicSocketJoinAnswerSend();
+        event.user = this.createSocketUser();
+        event.roomId = this.repo.mediator.channelData?.loginChannelId;
+        event.status = 1;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_ANSWER, encodeToJson(event), () => {
+            const g151 = this.repo.mediator.linkmicState.value;
+            if (g151 === PLVLinkMicState.Inviting) {
+                this.repo.mediator.linkmicState.setValue(PLVLinkMicState.WaitingResponse);
+            }
+        });
+    }
+    refuseInvitation() {
+        const event = new PLVLinkMicSocketJoinAnswerSend();
+        event.user = this.createSocketUser();
+        event.roomId = this.repo.mediator.channelData?.loginChannelId;
+        event.status = 0;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_ANSWER, encodeToJson(event));
+        this.repo.mediator.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+        this.handleRTCUseCase.leaveChannel();
+    }
+    leaveLinkMic() {
+        const e151 = this.repo.mediator.linkmicState.value;
+        if (e151 === undefined || ![PLVLinkMicState.Requesting, PLVLinkMicState.Joined].includes(e151)) {
+            return;
+        }
+        const event = new PLVLinkMicSocketJoinLeaveSend();
+        event.user = this.createSocketUser();
+        event.roomId = this.repo.mediator.channelData?.loginChannelId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_LEAVE, encodeToJson(event));
+        this.repo.mediator.linkmicState.setValue(PLVLinkMicState.NoLinkMic);
+        this.repo.mediator.channelLinkMicViewers.setValue([]);
+        this.repo.mediator.channelMainViewLinkMicId.setValue(undefined);
+        this.handleRTCUseCase.leaveChannel();
+    }
+    onStreamerStart() {
+    }
+    onLiveStreamStart() {
+    }
+    async setLinkMicMode(d151) {
+        return false;
+    }
+    async openLinkMic() {
+        return false;
+    }
+    async closeLinkMic() {
+        return false;
+    }
+    acceptViewerLinkMicRequest(c151) {
+    }
+    inviteViewerLinkMic(a151, b151) {
+    }
+    hangupViewerLinkMic(z150) {
+    }
+    hangupAllViewersLinkMic() {
+    }
+    setViewerEnableCamera(y150, enable) {
+    }
+    setViewerEnableMicrophone(x150, enable) {
+    }
+    grantSpeaker(w150) {
+    }
+    revokeSpeaker(v150) {
+    }
+    setMainView(u150) {
+    }
+    onLiveStreamStop() {
+    }
+    onStreamerStop() {
+    }
+    updateInvitationExpireTime() {
+        const event = new PLVLinkMicSocketJoinAnswerTTLSend();
+        event.userId = this.repo.mediator.channelData?.viewerId;
+        event.roomId = this.repo.mediator.channelData?.loginChannelId;
+        event.sessionId = this.repo.mediator.channelData?.sessionId;
+        const p150 = Date.now();
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_ANSWER_TTL, encodeToJson(event), (data) => {
+            const ttl = decodeFromJson(data, PLVLinkMicSocketJoinAnswerTTLAck).message?.[0] ?? 0;
+            const expire = p150 + seconds(ttl).toMillis();
+            this.repo.mediator.invitationExpireTimestamp.setValue(expire);
+            const r150 = expire - Date.now();
+            setTimeout(() => {
+                const expire = this.repo.mediator.invitationExpireTimestamp.value ?? 0;
+                const t150 = this.repo.mediator.linkmicState.value;
+                if (t150 === PLVLinkMicState.Inviting && Date.now() >= expire) {
+                    this.refuseInvitation();
+                }
+            }, r150);
+        });
+    }
+    onSocketMessage(data, event) {
+        switch (event) {
+            case PLVSocketMessageEvent.OPEN_MICROPHONE: return this.onSocketOpenMicrophone(data);
+            case PLVSocketMessageEvent.MUTE_USER_MICRO: return this.onSocketMuteUserMicro(data);
+            case PLVSocketMessageEvent.SET_NICK: return this.onSocketUserSetNick(data);
+            default:
+        }
+    }
+    onSocketOpenMicrophone(data) {
+        const m150 = decodeFromJson(data, PLVLinkMicSocketOpenMicrophoneRecv);
+        const n150 = m150.userId !== undefined;
+        if (m150.status === 'open') {
+            if (!n150) {
+                this.repo.mediator.channelAllowLinkMic.setValue(true);
+                this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(true);
+                this.updateLinkMicMode(m150.type);
+            }
+        }
+        else if (m150.status === 'close') {
+            if (!n150) {
+                if (this.repo.mediator.isLinkMicStrategyV2.value === true) {
+                    this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(false);
+                    const o150 = this.repo.mediator.linkmicState.value === PLVLinkMicState.Requesting;
+                    if (o150) {
+                        this.leaveLinkMic();
+                    }
+                }
+                else {
+                    this.repo.mediator.channelAllowLinkMic.setValue(false);
+                    this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(false);
+                    this.leaveLinkMic();
+                }
+            }
+            if (n150 && this.repo.mediator.isMySocketLinkMicId(m150.userId)) {
+                this.repo.mediator.teacherHangUpLinkMicEvent.setValue(Date.now());
+                this.leaveLinkMic();
+            }
+        }
+    }
+    onSocketMuteUserMicro(data) {
+        const l150 = decodeFromJson(data, PLVLinkMicSocketMuteUserMicroRecv);
+        if (l150.type === 'audio') {
+            if (l150.mute === true) {
+                this.handleRTCUseCase.enableMicrophone(false);
+            }
+            if (l150.mute === false) {
+                this.handleRTCUseCase.enableMicrophone(true);
+            }
+        }
+        if (l150.type === 'video') {
+            if (l150.mute === true) {
+                this.handleRTCUseCase.enableCamera(false);
+            }
+            if (l150.mute === false) {
+                this.handleRTCUseCase.enableCamera(true);
+            }
+        }
+    }
+    onSocketUserSetNick(data) {
+        const i150 = decodeFromJson(data, PLVMemberSocketSetNickRecv);
+        const j150 = i150.userId;
+        const k150 = this.repo.mediator.findViewerByViewerId(j150);
+        if (k150 !== undefined) {
+            k150.viewerName.setValue(i150.nick);
+        }
+    }
+    onSocketJoinRequest(data) {
+        const h150 = decodeFromJson(data, PLVLinkMicSocketJoinRequestRecv);
+        this.handleQueueOrderUseCase.onEventJoinRequest(h150);
+    }
+    onSocketJoinResponse(data) {
+        const f150 = decodeFromJson(data, PLVLinkMicSocketJoinResponseRecv);
+        if (!this.repo.mediator.isMySocketLinkMicId(f150.user?.userId)) {
+            return;
+        }
+        this.updateLinkMicMode(f150.type);
+        const g150 = this.repo.mediator.linkmicState.value;
+        if (f150.isNeedAnswer()) {
+            if (g150 === PLVLinkMicState.Requesting) {
+                this.acceptInvitation();
+            }
+            else if (g150 === PLVLinkMicState.NoLinkMic) {
+                this.repo.mediator.invitationExpireTimestamp.setValue(Date.now() + seconds(30).toMillis());
+                this.repo.mediator.linkmicState.setValue(PLVLinkMicState.Inviting);
+                this.updateInvitationExpireTime();
+            }
+        }
+        else {
+            this.repo.mediator.linkmicState.setValue(PLVLinkMicState.Joined);
+            this.handleRTCUseCase.joinChannel();
+        }
+    }
+    onSocketJoinSuccess(data) {
+        const e150 = decodeFromJson(data, PLVLinkMicSocketJoinSuccessRecv);
+        this.handleQueueOrderUseCase.onEventJoinSuccess(e150);
+        this.updateChannelViewerUseCase.onEventJoinSuccess(e150);
+        if (this.repo.mediator.isMySocketLinkMicId(e150.user?.userId)) {
+            this.updateChannelViewerUseCase.startUpdateChannelLinkMicViewersInterval();
+        }
+    }
+    onSocketJoinLeave(data) {
+        const d150 = decodeFromJson(data, PLVLinkMicSocketJoinLeaveRecv);
+        this.handleQueueOrderUseCase.onEventJoinLeave(d150);
+        this.updateChannelViewerUseCase.onEventJoinLeave(d150);
+        if (this.repo.mediator.isMySocketLinkMicId(d150.user?.userId)) {
+            this.updateChannelViewerUseCase.stopUpdateChannelLinkMicViewersInterval();
+        }
+    }
+    onSocketSwitchView(data) {
+        const c150 = decodeFromJson(data, PLVLinkMicSocketSwitchViewRecv);
+        if (isNullOrUndefined(c150.userId)) {
+            return;
+        }
+        this.repo.mediator.channelMainViewLinkMicId.setValue(c150.userId);
+        this.updateChannelViewerUseCase.onEventSwitchView(c150);
+    }
+    updateMicSetting() {
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MIC, encodeToJson(new PLVLinkMicSocketMicSettingSend()), (data) => {
+            const b150 = decodeFromJson(data, PLVLinkMicSocketMicSettingAck).message?.[0];
+            const status = b150?.data?.status;
+            const type = b150?.data?.type;
+            if (status === 'open') {
+                this.repo.mediator.channelAllowLinkMic.setValue(true);
+                this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(true);
+            }
+            else if (status === 'close') {
+                if (this.repo.mediator.isLinkMicStrategyV2.value === true) {
+                    this.repo.mediator.channelAllowLinkMic.setValue(true);
+                    this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(false);
+                }
+                else {
+                    this.repo.mediator.channelAllowLinkMic.setValue(false);
+                    this.repo.mediator.channelAllowRequestHandsUpLinkMic.setValue(false);
+                }
+            }
+            this.updateLinkMicMode(type);
+        });
+    }
+    onRTCEvent(event) {
+        if (event instanceof PLVLinkMicRTCJoinSuccess) {
+            this.onRTCJoinSuccess(event);
+        }
+        else if (event instanceof PLVLinkMicRTCKickOut) {
+            this.onRTCKickOut(event);
+        }
+    }
+    onRTCJoinSuccess(y149) {
+        this.repo.sendLinkMicIdRelation();
+        const z149 = new PLVLinkMicSocketJoinSuccessSend();
+        z149.user = this.createSocketUser();
+        z149.roomId = this.repo.mediator.channelData?.loginChannelId;
+        z149.sessionId = this.repo.mediator.channelData?.sessionId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.JOIN_SUCCESS, encodeToJson(z149));
+    }
+    onRTCKickOut(x149) {
+        this.leaveLinkMic();
+        this.repo.mediator.teacherHangUpLinkMicEvent.setValue(Date.now());
+    }
+    onViewerLeaveLinkMic(s149) {
+        const t149 = s149.find(w149 => w149.linkmicId === this.repo.mediator.linkmicId) !== undefined;
+        const u149 = this.repo.mediator.linkmicState.value === PLVLinkMicState.Joined;
+        if (t149 && u149) {
+            this.leaveLinkMic();
+        }
+    }
+    onDestroy() {
+        this.taskUpdateMicSetting?.cancel();
+        this.taskUpdateMicSetting = undefined;
+        this.disposables.forEach((r149) => {
+            r149.dispose();
+        });
+        this.disposables = [];
+        MutableObserver.disposeAll(this.observers);
+        this.observers = [];
+    }
+    observeSocketEvent(event, callback) {
+        const o149 = requireNotNull(this.repo.mediator.socketMediator);
+        o149.onData(event, callback);
+        return disposable(() => o149.offData(event, callback));
+    }
+    createSocketUser() {
+        const n149 = new PLVSocketUserSend();
+        n149.nick = this.repo.mediator.channelData?.viewerName;
+        n149.pic = this.repo.mediator.channelData?.viewerAvatar;
+        n149.userType = this.repo.mediator.channelData?.viewerType;
+        n149.userId = this.repo.mediator.linkmicId;
+        return n149;
+    }
+    updateLinkMicMode(mode) {
+        if (mode === PLVLinkMicMode.AUDIO || mode === PLVLinkMicMode.VIDEO) {
+            this.repo.mediator.channelLinkMicMode.setValue(mode);
+        }
+    }
+    async isChannelReachLinkMicLimit() {
+        const i149 = this.repo.mediator.channelData?.liveDetail?.linkMicLimit;
+        if (i149 === undefined) {
+            PLVLogger.warn(TAG, "channel linkmic limit is undefined, treat as reach limit.");
+            return true;
+        }
+        const j149 = await runCatching(this.repo.getChannelLinkMicStatus());
+        if (j149.success === false) {
+            PLVLogger.warn(TAG, `channel linkmic status response fail: ${j149.error.message}`);
+            return true;
+        }
+        const k149 = j149.data.joinList?.filter(m149 => {
+            m149.userType === PLVUserType.USERTYPE_TEACHER || m149.classStatus?.voice === 1;
+        })?.length ?? 0;
+        if (k149 >= i149 + 1) {
+            PLVLogger.warn(TAG, `channel reach linkmic limit, current join ${k149}, limit ${i149}`);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+}
+class SocketDisposable extends PLVDisposable {
+    constructor(h149) {
+        super();
+        this.onDispose = h149;
+    }
+    dispose() {
+        super.dispose();
+        this.onDispose?.();
+    }
+}
+function disposable(g149) {
+    return new SocketDisposable(g149);
+}

package/src/main/ets/modules/log/elog/PLVELogSender.d.ets

@@ -0,0 +1,12 @@
+import { PLVBaseModule } from '../../../common/PLVBaseModule';
+import { PLVChannelData } from '../../../common/PLVChannelData';
+import { PLVELogDataBean, PLVELogPartData } from './model/PLVELogDataBean';
+export declare function eLogSender(m152: PLVChannelData): PLVELogSender;
+export declare class PLVELogSender extends PLVBaseModule {
+    static readonly LOG_ARR: PLVELogDataBean[];
+    static batchIntervalId?: number;
+    constructor(k152: PLVChannelData);
+    once(j152: PLVELogPartData): void;
+    batch(i152: PLVELogPartData): void;
+    private reportLiveELog;
+}

package/src/main/ets/modules/log/elog/PLVELogSender.js

@@ -0,0 +1,47 @@
+import { PLVJSONUtils, PLVLogger, PLVUtils } from '@polyvharmony/live-scenes-foundation';
+import { PLVBaseModule } from '../../../common/PLVBaseModule';
+import { eLogPlvNetApi } from '../../net/PLVELogPlvNetApi';
+import { toELogData } from './model/PLVELogDataBean';
+const TAG = '[PLVELogSender]';
+const BATCH_INTERVAL = 1000 * 60;
+const BATCH_LENGTH = 20;
+export function eLogSender(m152) {
+    return new PLVELogSender(m152);
+}
+export class PLVELogSender extends PLVBaseModule {
+    constructor(k152) {
+        super(k152);
+        if (PLVELogSender.batchIntervalId == undefined) {
+            PLVELogSender.batchIntervalId = setInterval(() => {
+                if (PLVELogSender.LOG_ARR.length > 0) {
+                    this.reportLiveELog(PLVELogSender.LOG_ARR);
+                    PLVELogSender.LOG_ARR.length = 0;
+                }
+            }, BATCH_INTERVAL);
+        }
+    }
+    once(j152) {
+        this.reportLiveELog([toELogData(this.channelData, j152)]);
+    }
+    batch(i152) {
+        const log = toELogData(this.channelData, i152);
+        PLVELogSender.LOG_ARR.push(log);
+        PLVLogger.info(TAG, `batch log: ${PLVJSONUtils.safeStringify(log)}`);
+        if (PLVELogSender.LOG_ARR.length >= BATCH_LENGTH) {
+            this.reportLiveELog(PLVELogSender.LOG_ARR);
+            PLVELogSender.LOG_ARR.length = 0;
+        }
+    }
+    reportLiveELog(d152) {
+        return PLVUtils.safePromise(async (f152, g152) => {
+            const log = PLVJSONUtils.safeStringify(d152);
+            PLVLogger.info(TAG, `reportLiveELog: ${log}`);
+            await eLogPlvNetApi(this.channelData).reportLiveELog(this.channelData.loginChannelId, log)
+                .catch((err) => {
+                return Promise.reject(err.log(TAG, 'reportLiveELog error'));
+            });
+            PLVLogger.info(TAG, 'reportLiveELog success');
+        });
+    }
+}
+PLVELogSender.LOG_ARR = [];

package/src/main/ets/modules/log/elog/model/PLVELogDataBean.d.ets

@@ -0,0 +1,31 @@
+import { PLVChannelData } from '../../../../common/PLVChannelData';
+export declare class PLVELogDataBean {
+    appId?: string;
+    channelId2?: string;
+    deviceType?: string;
+    errorCode?: number;
+    framework?: string;
+    level?: number;
+    logFile?: PLVLogFileBean;
+    logVersion?: string;
+    platform2?: string;
+    project?: string;
+    userId2?: string;
+    version2?: string;
+    viewerId?: string;
+    event?: string;
+    module?: string;
+    time?: string;
+}
+export declare class PLVLogFileBean {
+    systemLog?: string;
+    information?: string;
+    exception?: string;
+}
+export declare class PLVELogPartData {
+    errorCode?: number;
+    event: string;
+    module: string;
+    information?: string;
+}
+export declare function toELogData(x151: PLVChannelData, y151: PLVELogPartData): PLVELogDataBean;

package/src/main/ets/modules/log/elog/model/PLVELogDataBean.js

@@ -0,0 +1,40 @@
+import deviceInfo from '@ohos.deviceInfo';
+import { SDK_NAME_VERSION } from '../../../../common/PLVLiveSceneSDK';
+export class PLVELogDataBean {
+    constructor() {
+        this.deviceType = 'phone';
+        this.errorCode = 0;
+        this.framework = 'origin';
+        this.level = 0;
+        this.logVersion = '1.0.0';
+        this.platform2 = deviceInfo.productModel + '/' + deviceInfo.sdkApiVersion;
+        this.project = 'liveScene';
+        this.version2 = SDK_NAME_VERSION;
+        this.event = 'default_event';
+        this.module = 'default_module';
+        this.time = Date.now() + '';
+    }
+}
+export class PLVLogFileBean {
+}
+export class PLVELogPartData {
+    constructor() {
+        this.errorCode = 0;
+        this.event = 'default_event';
+        this.module = 'default_module';
+    }
+}
+export function toELogData(x151, y151) {
+    const data = new PLVELogDataBean();
+    data.errorCode = y151.errorCode || 0;
+    data.event = y151.event || 'default_event';
+    data.module = y151.module || 'default_module';
+    data.logFile = {
+        information: y151.information
+    };
+    data.appId = x151.appId;
+    data.channelId2 = x151.loginChannelId;
+    data.userId2 = x151.userId;
+    data.viewerId = x151.viewerId;
+    return data;
+}

package/src/main/ets/modules/log/elog/model/PLVELogModuleConstants.d.ets

@@ -0,0 +1,10 @@
+export declare enum PLVELogModuleName {
+    SOCKET = "socket"
+}
+export declare enum PLVELogSocketBatchEvent {
+    LOGGING = "logging",
+    LOGIN_SUCCESS = "loginSuccess",
+    RECONNECTING = "reconnecting",
+    RECONNECT_SUCCESS = "reconnectSuccess",
+    LOGIN_FAIL = "loginFail"
+}

package/src/main/ets/modules/log/elog/model/PLVELogModuleConstants.js

@@ -0,0 +1,12 @@
+export var PLVELogModuleName;
+(function (c152) {
+    c152["SOCKET"] = "socket";
+})(PLVELogModuleName || (PLVELogModuleName = {}));
+export var PLVELogSocketBatchEvent;
+(function (b152) {
+    b152["LOGGING"] = "logging";
+    b152["LOGIN_SUCCESS"] = "loginSuccess";
+    b152["RECONNECTING"] = "reconnecting";
+    b152["RECONNECT_SUCCESS"] = "reconnectSuccess";
+    b152["LOGIN_FAIL"] = "loginFail";
+})(PLVELogSocketBatchEvent || (PLVELogSocketBatchEvent = {}));

package/src/main/ets/modules/login/PLVSceneLoginManager.d.ets

@@ -0,0 +1,37 @@
+import { PLVBaseModule } from '../../common/PLVBaseModule';
+import { PLVChannelData } from '../../common/PLVChannelData';
+/**
+ * 登录管理器
+ */
+export declare class PLVSceneLoginManager extends PLVBaseModule {
+    /**
+     * 登录直播
+     * @param userId 账号userId
+     * @param channelId 频道Id
+     * @param appId 账号appId
+     * @param appSecret 账号appSecret
+     * @returns
+     */
+    loginLive(userId?: string, e155?: string, appId?: string, f155?: string): Promise<PLVChannelData>;
+    /**
+     * 登录回放
+     * @param userId 账号userId
+     * @param channelId 频道Id
+     * @param appId 账号appId
+     * @param appSecret 账号appSecret
+     * @param videoId 视频Id
+     * @returns
+     */
+    loginPlayback(userId?: string, s154?: string, appId?: string, t154?: string, u154?: string): Promise<PLVChannelData>;
+    /**
+     * 登录手机开播
+     * @param channel 频道号
+     * @param password 频道密码
+     * @param nickname 用户昵称
+     * @returns true 登录成功，失败时通过 promise 异常返回
+     */
+    loginStreamer(channel: string, password: string, nickname?: string | undefined): Promise<boolean>;
+    private loginThrottling;
+    private streamerGetPushStreamUrl;
+    private setupChannelData;
+}