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

package/src/main/ets/modules/streamer/PLVStreamerManager.d.ets

@@ -0,0 +1,84 @@
+import { DependScope, State } from '@polyvharmony/media-player-sdk';
+import { PLVPushDowngradePreference, PLVPushOrientation } from '@polyvharmony/rtc-sdk';
+import { PLVBaseModule } from '../../common/PLVBaseModule';
+import { PLVChannelData } from '../../common/PLVChannelData';
+import { PLVLinkMicBitRate } from '../linkmic/model/vo/PLVLinkMicBitRate';
+import { PLVLinkMicBitRateEncodeParam } from '../linkmic/model/vo/PLVLinkMicBitRateEncodeParam';
+import { PLVLinkMicPushResolutionRatio } from '../linkmic/model/vo/PLVLinkMicPushResolutionRatio';
+import { PLVSocketMediator } from '../socket/PLVSocketMediator';
+import { PLVStreamerMixLayoutType } from './model/vo/PLVStreamerMixLayoutType';
+import { PLVStreamerState } from './model/vo/PLVStreamerState';
+export declare class PLVStreamerManager extends PLVBaseModule {
+    private readonly dependScope;
+    private readonly mediator;
+    private readonly viewModel;
+    /**
+     * 当前频道直播推流状态
+     */
+    readonly streamerState: State<PLVStreamerState>;
+    /**
+     * 频道直播开始时刻
+     */
+    readonly liveStartTimestamp: State<number | undefined>;
+    /**
+     * 当前推流清晰度
+     */
+    readonly currentBitRate: State<PLVLinkMicBitRate>;
+    /**
+     * 当前清晰度编码参数
+     */
+    readonly currentBitRateEncodeParam: State<PLVLinkMicBitRateEncodeParam>;
+    /**
+     * 频道支持的清晰度编码参数
+     */
+    readonly channelSupportBitRateEncodeParams: State<PLVLinkMicBitRateEncodeParam[]>;
+    /**
+     * 当前推流画面比例
+     */
+    readonly pushResolutionRatio: State<PLVLinkMicPushResolutionRatio>;
+    /**
+     * 弱网降级策略
+     */
+    readonly pushDowngradePreference: State<PLVPushDowngradePreference>;
+    /**
+     * 混流布局
+     */
+    readonly mixLayoutType: State<PLVStreamerMixLayoutType>;
+    constructor(s186: DependScope, t186: PLVChannelData, u186: PLVSocketMediator);
+    private init;
+    /**
+     * [讲师] 开始直播
+     * [嘉宾] 加入直播
+     * @param recover 上一次直播未正常关闭，是否继续上一次直播
+     */
+    startStream(recover?: boolean): Promise<void>;
+    /**
+     * [讲师] 停止直播
+     * [嘉宾] 退出直播
+     */
+    finishStream(): void;
+    /**
+     * [讲师] 更新频道名称
+     */
+    updateChannelName(name: string): Promise<void>;
+    /**
+     * [讲师、嘉宾] 设置推流清晰度
+     */
+    setBitRate(bitRate: PLVLinkMicBitRate): void;
+    /**
+     * [讲师、嘉宾] 设置推流画面比例
+     */
+    setPushResolutionRatio(o186: PLVLinkMicPushResolutionRatio): void;
+    /**
+     * [讲师、嘉宾] 设置推流方向
+     */
+    setPushOrientation(n186: PLVPushOrientation): void;
+    /**
+     * [讲师、嘉宾] 设置弱网降级偏好
+     */
+    setPushDowngradePreference(m186: PLVPushDowngradePreference): void;
+    /**
+     * [讲师] 设置混流画面类型
+     */
+    setMixLayoutType(l186: PLVStreamerMixLayoutType): void;
+}

package/src/main/ets/modules/streamer/PLVStreamerManager.js

@@ -0,0 +1,58 @@
+import { runCatching } from '@polyvharmony/media-player-sdk';
+import { PLVBaseModule } from '../../common/PLVBaseModule';
+import { PLVStreamerMediator } from './mediator/PLVStreamerMediator';
+import { PLVStreamerErrorEvent } from './model/vo/PLVStreamerErrorEvent';
+import { PLVStreamerViewModel } from './viewmodel/PLVStreamerViewModel';
+export class PLVStreamerManager extends PLVBaseModule {
+    constructor(s186, t186, u186) {
+        super(t186);
+        this.dependScope = s186;
+        this.mediator = this.dependScope.get(PLVStreamerMediator);
+        this.viewModel = this.dependScope.get(PLVStreamerViewModel);
+        this.streamerState = this.mediator.streamerState;
+        this.liveStartTimestamp = this.mediator.liveStartTimestamp;
+        this.currentBitRate = this.mediator.linkmicMediator.currentBitRate;
+        this.currentBitRateEncodeParam = this.mediator.linkmicMediator.currentBitRateEncodeParam;
+        this.channelSupportBitRateEncodeParams = this.mediator.linkmicMediator.channelSupportBitRateEncodeParams;
+        this.pushResolutionRatio = this.mediator.linkmicMediator.currentPushResolutionRatio;
+        this.pushDowngradePreference = this.mediator.linkmicMediator.currentPushDowngradePreference;
+        this.mixLayoutType = this.mediator.mixLayoutType;
+        this.init(t186, u186);
+    }
+    async init(p186, q186) {
+        await this.channelData.initializedPromise.get();
+        await this.mediator.linkmicMediator.initFinish.promise;
+        this.mediator.channelData = p186;
+        this.mediator.socketMediator = q186;
+        const r186 = await runCatching(this.viewModel.init());
+        if (r186.success === false) {
+            this.mediator.reportError(PLVStreamerErrorEvent.STREAMER_INIT_FAILED, r186.error.message);
+        }
+        this.mediator.initFinish.resolve();
+    }
+    async startStream(recover = false) {
+        await this.mediator.initFinish.promise;
+        await this.viewModel.startStream(recover);
+    }
+    finishStream() {
+        this.viewModel.finishStream();
+    }
+    async updateChannelName(name) {
+        return this.viewModel.updateChannelName(name);
+    }
+    setBitRate(bitRate) {
+        this.viewModel.setBitRate(bitRate);
+    }
+    setPushResolutionRatio(o186) {
+        this.viewModel.setPushResolutionRatio(o186);
+    }
+    setPushOrientation(n186) {
+        this.viewModel.setPushOrientation(n186);
+    }
+    setPushDowngradePreference(m186) {
+        this.viewModel.setPushDowngradePreference(m186);
+    }
+    setMixLayoutType(l186) {
+        this.viewModel.setMixLayoutType(l186);
+    }
+}

package/src/main/ets/modules/streamer/di/PLVStreamerModule.d.ets

@@ -0,0 +1,2 @@
+import { DependModule } from '@polyvharmony/media-player-sdk';
+export declare const streamerModule: DependModule;

package/src/main/ets/modules/streamer/di/PLVStreamerModule.js

@@ -0,0 +1,19 @@
+import { DependModule } from '@polyvharmony/media-player-sdk';
+import { PLVLinkMicMediator } from '../../linkmic/mediator/PLVLinkMicMediator';
+import { PLVStreamerMediator } from '../mediator/PLVStreamerMediator';
+import { PLVStreamerLocalDataSource } from '../model/datasource/PLVStreamerLocalDataSource';
+import { PLVStreamerNetworkDataSource } from '../model/datasource/PLVStreamerNetworkDataSource';
+import { PLVStreamerRepo } from '../model/PLVStreamerRepo';
+import { PLVStreamerViewModel } from '../viewmodel/PLVStreamerViewModel';
+import { PLVStreamerUseCases } from '../viewmodel/usecase/PLVStreamerUseCases';
+import { StreamerHandleStateUseCase } from '../viewmodel/usecase/StreamerHandleStateUseCase';
+import { StreamerMixStreamUseCase } from '../viewmodel/usecase/StreamerMixStreamUseCase';
+export const streamerModule = new DependModule();
+streamerModule.provide(PLVStreamerMediator, (scope) => new PLVStreamerMediator(scope.get(PLVLinkMicMediator)));
+streamerModule.provide(PLVStreamerLocalDataSource, (scope) => new PLVStreamerLocalDataSource(scope.get(PLVStreamerMediator)));
+streamerModule.provide(PLVStreamerNetworkDataSource, (scope) => new PLVStreamerNetworkDataSource(scope.get(PLVStreamerMediator)));
+streamerModule.provide(PLVStreamerRepo, (scope) => new PLVStreamerRepo(scope.get(PLVStreamerMediator), scope.get(PLVStreamerLocalDataSource), scope.get(PLVStreamerNetworkDataSource)));
+streamerModule.provide(StreamerMixStreamUseCase, (scope) => new StreamerMixStreamUseCase(scope.get(PLVStreamerRepo)));
+streamerModule.provide(StreamerHandleStateUseCase, (scope) => new StreamerHandleStateUseCase(scope.get(PLVStreamerRepo), scope.get(StreamerMixStreamUseCase)));
+streamerModule.provide(PLVStreamerUseCases, (scope) => new PLVStreamerUseCases(scope.get(StreamerHandleStateUseCase), scope.get(StreamerMixStreamUseCase)));
+streamerModule.provide(PLVStreamerViewModel, (scope) => new PLVStreamerViewModel(scope.get(PLVStreamerRepo), scope.get(PLVStreamerUseCases)));

package/src/main/ets/modules/streamer/mediator/PLVStreamerMediator.d.ets

@@ -0,0 +1,24 @@
+import { LifecycleAwareDependComponent, MutableEvent, MutableState } from '@polyvharmony/media-player-sdk';
+import { PLVChannelData } from '../../../common/PLVChannelData';
+import { PLVLinkMicMediator } from '../../linkmic/mediator/PLVLinkMicMediator';
+import { PLVSocketMediator } from '../../socket/PLVSocketMediator';
+import { PLVStreamerErrorEvent } from '../model/vo/PLVStreamerErrorEvent';
+import { PLVStreamerMixLayoutType } from '../model/vo/PLVStreamerMixLayoutType';
+import { PLVStreamerState } from '../model/vo/PLVStreamerState';
+export declare class PLVStreamerMediator implements LifecycleAwareDependComponent {
+    readonly linkmicMediator: PLVLinkMicMediator;
+    channelData: PLVChannelData | null;
+    socketMediator: PLVSocketMediator | null;
+    readonly initFinish: {
+        promise: Promise<void>;
+        resolve: (value: void | PromiseLike<void>) => void;
+        reject: (reason?: any) => void;
+    };
+    readonly streamerState: MutableState<PLVStreamerState>;
+    readonly liveStartTimestamp: MutableState<number>;
+    readonly mixLayoutType: MutableState<PLVStreamerMixLayoutType>;
+    readonly errorEvent: MutableEvent<PLVStreamerErrorEvent>;
+    constructor(f184: PLVLinkMicMediator);
+    reportError(code: number, message: string): void;
+    onDestroy(): void;
+}

package/src/main/ets/modules/streamer/mediator/PLVStreamerMediator.js

@@ -0,0 +1,25 @@
+import { PLVLogger } from '@polyvharmony/live-scenes-foundation';
+import { MutableEvent, MutableSource, MutableState, Promises } from '@polyvharmony/media-player-sdk';
+import { PLVStreamerErrorEvent } from '../model/vo/PLVStreamerErrorEvent';
+import { PLVStreamerMixLayoutType } from '../model/vo/PLVStreamerMixLayoutType';
+import { PLVStreamerState } from '../model/vo/PLVStreamerState';
+const TAG = "PLVStreamerManager";
+export class PLVStreamerMediator {
+    constructor(f184) {
+        this.channelData = null;
+        this.socketMediator = null;
+        this.initFinish = Promises.withResolvers();
+        this.streamerState = new MutableState(PLVStreamerState.NOT_START);
+        this.liveStartTimestamp = new MutableState(undefined);
+        this.mixLayoutType = new MutableState(PLVStreamerMixLayoutType.TILE);
+        this.errorEvent = new MutableEvent();
+        this.linkmicMediator = f184;
+    }
+    reportError(code, message) {
+        this.errorEvent.value = new PLVStreamerErrorEvent(code, message);
+        PLVLogger.error(TAG, `Streamer module error, code:${code}, message:${message}`, true);
+    }
+    onDestroy() {
+        MutableSource.disposeAll(this);
+    }
+}

package/src/main/ets/modules/streamer/model/PLVStreamerRepo.d.ets

@@ -0,0 +1,21 @@
+import { PLVStreamerMediator } from '../mediator/PLVStreamerMediator';
+import { PLVStreamerLocalDataSource } from './datasource/PLVStreamerLocalDataSource';
+import { PLVStreamerNetworkDataSource } from './datasource/PLVStreamerNetworkDataSource';
+import { PLVStreamerLiveStatusResponseVO } from './vo/PLVStreamerLiveStatusResponseVO';
+import { PLVStreamerMixActionVO } from './vo/PLVStreamerMixActionVO';
+import { PLVStreamerMixLayoutType } from './vo/PLVStreamerMixLayoutType';
+export declare class PLVStreamerRepo {
+    readonly mediator: PLVStreamerMediator;
+    readonly localDataSource: PLVStreamerLocalDataSource;
+    readonly networkDataSource: PLVStreamerNetworkDataSource;
+    constructor(w185: PLVStreamerMediator, x185: PLVStreamerLocalDataSource, y185: PLVStreamerNetworkDataSource);
+    init(): Promise<void>;
+    private initMixLayoutType;
+    notifyStreamStart(stream: string, recover: boolean, videoWidth: number, videoHeight: number): Promise<string>;
+    notifyStreamEnd(stream: string): Promise<void>;
+    setMixLayoutType(p185: PLVStreamerMixLayoutType): Promise<void>;
+    sendMixAction(o185: PLVStreamerMixActionVO): Promise<void>;
+    getStreamerSessionId(stream: string): Promise<string>;
+    updateChannelName(name: string): Promise<void>;
+    getLiveStatusSessionId(stream: string): Promise<PLVStreamerLiveStatusResponseVO>;
+}

package/src/main/ets/modules/streamer/model/PLVStreamerRepo.js

@@ -0,0 +1,58 @@
+import { requireNotNull } from '@polyvharmony/media-player-sdk';
+import { PLVStreamerMixLayoutType } from './vo/PLVStreamerMixLayoutType';
+export class PLVStreamerRepo {
+    constructor(w185, x185, y185) {
+        this.mediator = w185;
+        this.localDataSource = x185;
+        this.networkDataSource = y185;
+    }
+    async init() {
+        await this.initMixLayoutType();
+    }
+    async initMixLayoutType() {
+        const u185 = await this.localDataSource.getMixLayoutType();
+        if (u185 !== undefined) {
+            return this.mediator.mixLayoutType.setValue(u185);
+        }
+        const v185 = this.mediator.channelData?.liveDetail?.mobileAlonePushMixMode;
+        if (v185 === 'flatten') {
+            return this.setMixLayoutType(PLVStreamerMixLayoutType.TILE);
+        }
+        else if (v185 === 'lecture') {
+            return this.setMixLayoutType(PLVStreamerMixLayoutType.SPEAKER);
+        }
+        return this.setMixLayoutType(PLVStreamerMixLayoutType.TILE);
+    }
+    async notifyStreamStart(stream, recover, videoWidth, videoHeight) {
+        const s185 = requireNotNull(this.mediator.channelData);
+        const t185 = requireNotNull(s185.loginChannelId);
+        return this.networkDataSource.notifyStreamStart(t185, stream, recover, videoWidth, videoHeight);
+    }
+    async notifyStreamEnd(stream) {
+        const q185 = requireNotNull(this.mediator.channelData);
+        const r185 = requireNotNull(q185.loginChannelId);
+        return this.networkDataSource.notifyStreamEnd(r185, stream);
+    }
+    async setMixLayoutType(p185) {
+        this.mediator.mixLayoutType.setValue(p185);
+        this.localDataSource.saveMixLayoutType(p185);
+    }
+    async sendMixAction(o185) {
+        await this.networkDataSource.sendMixAction(o185);
+    }
+    async getStreamerSessionId(stream) {
+        const m185 = requireNotNull(this.mediator.channelData);
+        const n185 = requireNotNull(m185.loginChannelId);
+        return this.networkDataSource.getStreamerSessionId(n185, stream);
+    }
+    async updateChannelName(name) {
+        const k185 = requireNotNull(this.mediator.channelData);
+        const l185 = requireNotNull(k185.loginChannelId);
+        return this.networkDataSource.updateChannelName(l185, name);
+    }
+    async getLiveStatusSessionId(stream) {
+        const i185 = requireNotNull(this.mediator.channelData);
+        const j185 = requireNotNull(i185.loginChannelId);
+        return this.networkDataSource.getLiveStatusSessionId(j185, stream);
+    }
+}

package/src/main/ets/modules/streamer/model/datasource/PLVStreamerLocalDataSource.d.ets

@@ -0,0 +1,8 @@
+import { PLVStreamerMediator } from "../../mediator/PLVStreamerMediator";
+import { PLVStreamerMixLayoutType } from "../vo/PLVStreamerMixLayoutType";
+export declare class PLVStreamerLocalDataSource {
+    private readonly mediator;
+    constructor(j184: PLVStreamerMediator);
+    getMixLayoutType(): Promise<PLVStreamerMixLayoutType | undefined>;
+    saveMixLayoutType(g184: PLVStreamerMixLayoutType): Promise<void>;
+}

package/src/main/ets/modules/streamer/model/datasource/PLVStreamerLocalDataSource.js

@@ -0,0 +1,17 @@
+import { PLVKVStore, requireNotNull } from "@polyvharmony/media-player-sdk";
+export class PLVStreamerLocalDataSource {
+    constructor(j184) {
+        this.mediator = j184;
+    }
+    async getMixLayoutType() {
+        const i184 = requireNotNull(this.mediator.channelData?.loginChannelId);
+        const kvStore = new PLVKVStore(`plv_streamer_channel_mix_layout_type_${i184}`, Number);
+        const value = await kvStore.get();
+        return value?.valueOf();
+    }
+    async saveMixLayoutType(g184) {
+        const h184 = requireNotNull(this.mediator.channelData?.loginChannelId);
+        const kvStore = new PLVKVStore(`plv_streamer_channel_mix_layout_type_${h184}`, Number);
+        await kvStore.set(g184);
+    }
+}

package/src/main/ets/modules/streamer/model/datasource/PLVStreamerNetworkDataSource.d.ets

@@ -0,0 +1,14 @@
+import { PLVStreamerMediator } from '../../mediator/PLVStreamerMediator';
+import { PLVStreamerLiveStatusResponseVO } from '../vo/PLVStreamerLiveStatusResponseVO';
+import { PLVStreamerMixActionVO } from '../vo/PLVStreamerMixActionVO';
+export declare class PLVStreamerNetworkDataSource {
+    private readonly mediator;
+    constructor(h185: PLVStreamerMediator);
+    notifyStreamStart(d185: string, stream: string, recover: boolean, videoWidth: number, videoHeight: number): Promise<string>;
+    notifyStreamEnd(z184: string, stream: string): Promise<void>;
+    sendMixAction(w184: PLVStreamerMixActionVO): Promise<void>;
+    getStreamerSessionId(r184: string, stream: string): Promise<string>;
+    updateChannelName(m184: string, name: string): Promise<void>;
+    getLiveStatusSessionId(k184: string, stream: string): Promise<PLVStreamerLiveStatusResponseVO>;
+    private get api_polyv_net();
+}

package/src/main/ets/modules/streamer/model/datasource/PLVStreamerNetworkDataSource.js

@@ -0,0 +1,65 @@
+import { PLVJSONUtils } from '@polyvharmony/live-scenes-foundation';
+import { isNullOrUndefined, require, requireNotNull } from '@polyvharmony/media-player-sdk';
+import BuildProfile from '../../../../../../../BuildProfile';
+import { PLVLiveChannelSettingUpdateBasicSetting, PLVLiveChannelSettingUpdateRequestVO } from '../../../business/model/PLVLiveChannelSettingUpdateRequestVO';
+import { apiPlvNetApi } from '../../../net/PLVApiPlvNetApi';
+export class PLVStreamerNetworkDataSource {
+    constructor(h185) {
+        this.mediator = h185;
+    }
+    async notifyStreamStart(d185, stream, recover, videoWidth, videoHeight) {
+        const e185 = requireNotNull(this.mediator.channelData);
+        const appId = requireNotNull(e185.appId);
+        const f185 = requireNotNull(e185.appSecret);
+        const response = await this.api_polyv_net.notifyStreamStart(d185, appId, f185, stream, recover ? "Y" : "N", videoWidth, videoHeight);
+        require(response.status === 200
+            && response.data.code === 200
+            && response.data.data !== undefined, () => `notifyStreamStart failed: ${PLVJSONUtils.safeStringify(response)}`);
+        return response.data.data;
+    }
+    async notifyStreamEnd(z184, stream) {
+        const a185 = requireNotNull(this.mediator.channelData);
+        const appId = requireNotNull(a185.appId);
+        const b185 = requireNotNull(a185.appSecret);
+        const version = BuildProfile.HAR_VERSION;
+        const response = await this.api_polyv_net.notifyStreamEnd(z184, appId, b185, stream, version);
+        require(response.status === 200
+            && response.data.code === 200, () => `notifyStreamEnd failed: ${PLVJSONUtils.safeStringify(response)}`);
+    }
+    async sendMixAction(w184) {
+        const x184 = requireNotNull(this.mediator.channelData);
+        const appId = requireNotNull(x184.appId);
+        const y184 = requireNotNull(x184.appSecret);
+        await this.api_polyv_net.mixAction(appId, y184, w184);
+    }
+    async getStreamerSessionId(r184, stream) {
+        const s184 = requireNotNull(this.mediator.channelData);
+        const appId = requireNotNull(s184.appId);
+        const t184 = requireNotNull(s184.appSecret);
+        const response = await this.api_polyv_net.getStreamerSessionId(r184, appId, t184, stream);
+        require(response.status === 200
+            && response.data.code === 200
+            && response.data.data !== undefined, () => `getStreamerSessionId failed: ${PLVJSONUtils.safeStringify(response)}`);
+        return requireNotNull(response.data.data?.sessionId, () => "getStreamerSessionId response null sessionId");
+    }
+    async updateChannelName(m184, name) {
+        const n184 = requireNotNull(this.mediator.channelData);
+        const appId = requireNotNull(n184.appId);
+        const o184 = requireNotNull(n184.appSecret);
+        const p184 = new PLVLiveChannelSettingUpdateRequestVO();
+        p184.basicSetting = new PLVLiveChannelSettingUpdateBasicSetting();
+        p184.basicSetting.name = name;
+        const response = await this.api_polyv_net.updateChannelBasic(m184, appId, o184, p184);
+        require(response.status === 200
+            && response.data.code === 200, () => `updateChannelName failed: ${PLVJSONUtils.safeStringify(response)}`);
+    }
+    async getLiveStatusSessionId(k184, stream) {
+        const response = await this.api_polyv_net.getLiveStatusSessionId(k184, stream);
+        require(response.status === 200
+            && !isNullOrUndefined(response.data), () => `getLiveStatusSessionId failed: ${PLVJSONUtils.safeStringify(response)}`);
+        return response.data;
+    }
+    get api_polyv_net() {
+        return apiPlvNetApi(requireNotNull(this.mediator.channelData));
+    }
+}

package/src/main/ets/modules/streamer/model/vo/PLVStreamerErrorEvent.d.ets

@@ -0,0 +1,21 @@
+export declare class PLVStreamerErrorEvent {
+    /**
+     * 推流模块初始化失败
+     */
+    static readonly STREAMER_INIT_FAILED = 1;
+    /**
+     * 开始推流调用失败
+     */
+    static readonly STREAMER_START_FAIL = 2;
+    /**
+     * 推流获取sessionId失败
+     */
+    static readonly GET_SESSION_ID_FAIL = 3;
+    /**
+     * 更新频道名称失败
+     */
+    static readonly UPDATE_CHANNEL_NAME_FAIL = 4;
+    readonly code: number;
+    readonly message: string;
+    constructor(code: number, message: string);
+}

package/src/main/ets/modules/streamer/model/vo/PLVStreamerErrorEvent.js

@@ -0,0 +1,10 @@
+export class PLVStreamerErrorEvent {
+    constructor(code, message) {
+        this.code = code;
+        this.message = message;
+    }
+}
+PLVStreamerErrorEvent.STREAMER_INIT_FAILED = 1;
+PLVStreamerErrorEvent.STREAMER_START_FAIL = 2;
+PLVStreamerErrorEvent.GET_SESSION_ID_FAIL = 3;
+PLVStreamerErrorEvent.UPDATE_CHANNEL_NAME_FAIL = 4;

package/src/main/ets/modules/streamer/model/vo/PLVStreamerLiveStatusResponseVO.d.ts

@@ -0,0 +1,4 @@
+export declare class PLVStreamerLiveStatusResponseVO {
+    status?: string | null;
+    sessionId?: string | null;
+}

package/src/main/ets/modules/streamer/model/vo/PLVStreamerLiveStatusResponseVO.js

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

package/src/main/ets/modules/streamer/model/vo/PLVStreamerMixActionResponse.d.ets

@@ -0,0 +1,3 @@
+export declare class PLVStreamerMixActionResponse {
+    res?: boolean;
+}

package/src/main/ets/modules/streamer/model/vo/PLVStreamerMixActionResponse.js

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

package/src/main/ets/modules/streamer/model/vo/PLVStreamerMixActionVO.d.ets

@@ -0,0 +1,55 @@
+import { PLVStreamerMixLayoutType } from './PLVStreamerMixLayoutType';
+export declare class PLVStreamerMixActionVO {
+    action?: MixAction;
+    roomId?: string;
+    outputParam?: MixOutputParam;
+    encodeParam?: MixEncodeParam;
+    userList?: MixUser[];
+    mixLayoutType?: PLVStreamerMixLayoutType;
+    publishCdnParam?: MixPublishCdnParam;
+}
+export declare class MixOutputParam {
+    streamId?: string;
+    pureAudioStream?: number;
+}
+export declare class MixEncodeParam {
+    audioSampleRate?: number;
+    audioBitrate?: number;
+    audioChannels?: number;
+    videoWidth?: number;
+    videoHeight?: number;
+    videoBitrate?: number;
+    videoFramerate?: number;
+    videoGop?: number;
+    backgroundColor: number;
+    audioCodec: number;
+}
+export declare class MixUser {
+    streamType?: MixStreamType;
+    userId?: string;
+    renderMode?: MixRenderMode;
+    mixInputType?: MixInputType;
+    hidden: boolean;
+}
+export declare enum MixAction {
+    START = "start",
+    UPDATE = "update",
+    END = "end"
+}
+export declare enum MixStreamType {
+    CAMERA = 0,
+    SCREEN = 1
+}
+export declare enum MixRenderMode {
+    FILL = 0,
+    FIT = 1,
+    FIT_BLACK_BACKGROUND = 2
+}
+export declare enum MixInputType {
+    VIDEO_AUDIO = 0,
+    VIDEO_ONLY = 1,
+    AUDIO_ONLY = 2
+}
+export declare class MixPublishCdnParam {
+    cdnUrl?: string;
+}

package/src/main/ets/modules/streamer/model/vo/PLVStreamerMixActionVO.js

@@ -0,0 +1,40 @@
+export class PLVStreamerMixActionVO {
+}
+export class MixOutputParam {
+}
+export class MixEncodeParam {
+    constructor() {
+        this.backgroundColor = 0;
+        this.audioCodec = 0;
+    }
+}
+export class MixUser {
+    constructor() {
+        this.hidden = false;
+    }
+}
+export var MixAction;
+(function (g186) {
+    g186["START"] = "start";
+    g186["UPDATE"] = "update";
+    g186["END"] = "end";
+})(MixAction || (MixAction = {}));
+export var MixStreamType;
+(function (f186) {
+    f186[f186["CAMERA"] = 0] = "CAMERA";
+    f186[f186["SCREEN"] = 1] = "SCREEN";
+})(MixStreamType || (MixStreamType = {}));
+export var MixRenderMode;
+(function (e186) {
+    e186[e186["FILL"] = 0] = "FILL";
+    e186[e186["FIT"] = 1] = "FIT";
+    e186[e186["FIT_BLACK_BACKGROUND"] = 2] = "FIT_BLACK_BACKGROUND";
+})(MixRenderMode || (MixRenderMode = {}));
+export var MixInputType;
+(function (d186) {
+    d186[d186["VIDEO_AUDIO"] = 0] = "VIDEO_AUDIO";
+    d186[d186["VIDEO_ONLY"] = 1] = "VIDEO_ONLY";
+    d186[d186["AUDIO_ONLY"] = 2] = "AUDIO_ONLY";
+})(MixInputType || (MixInputType = {}));
+export class MixPublishCdnParam {
+}

package/src/main/ets/modules/streamer/model/vo/PLVStreamerMixLayoutType.d.ets

@@ -0,0 +1,14 @@
+export declare enum PLVStreamerMixLayoutType {
+    /**
+     * 单人
+     */
+    SINGLE = 1,
+    /**
+     * 平铺
+     */
+    TILE = 2,
+    /**
+     * 主讲
+     */
+    SPEAKER = 3
+}

package/src/main/ets/modules/streamer/model/vo/PLVStreamerMixLayoutType.js

@@ -0,0 +1,6 @@
+export var PLVStreamerMixLayoutType;
+(function (i186) {
+    i186[i186["SINGLE"] = 1] = "SINGLE";
+    i186[i186["TILE"] = 2] = "TILE";
+    i186[i186["SPEAKER"] = 3] = "SPEAKER";
+})(PLVStreamerMixLayoutType || (PLVStreamerMixLayoutType = {}));

package/src/main/ets/modules/streamer/model/vo/PLVStreamerSessionIdQueryResponse.d.ets

@@ -0,0 +1,4 @@
+export declare class PLVStreamerSessionIdQueryResponse {
+    createTime?: number;
+    sessionId?: string;
+}

package/src/main/ets/modules/streamer/model/vo/PLVStreamerSessionIdQueryResponse.js

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

package/src/main/ets/modules/streamer/model/vo/PLVStreamerSocketEvent.d.ets

@@ -0,0 +1,64 @@
+export declare class PLVStreamerSocketOnSliceStartRecv {
+    data?: PLVStreamerSocketOnSliceStartEventData | null;
+    pushtime?: number | null;
+    roomId?: string | null;
+    sessionId?: string | null;
+    timeStamp?: number | null;
+    videoAndPPTPosition?: string | null;
+}
+export declare class PLVStreamerSocketOnSliceStartEventData {
+    autoId?: number | null;
+    docType?: number | null;
+    isCamClosed?: number | null;
+}
+export declare class PLVStreamerSocketOnSliceIDRecv {
+    data?: PLVStreamerSocketOnSliceIDEventData | null;
+    inClass?: boolean | null;
+    inSignIn?: boolean | null;
+    pptAndVedioPosition?: number | null;
+    token?: string | null;
+}
+export declare class PLVStreamerSocketOnSliceIDEventData {
+    autoId?: number | null;
+    courseType?: string | null;
+    docType?: string | null;
+    duration?: number | null;
+    isCamClosed?: number | null;
+    onlineUserNumber?: number | null;
+    pageId?: number | null;
+    pptAndVedioPosition?: number | null;
+    pushtime?: number | null;
+    recordTime?: number | null;
+    roomId?: string | null;
+    sessionId?: string | null;
+    step?: string | null;
+    timeStamp?: number | null;
+    userId?: string | null;
+}
+export declare class PLVStreamerSocketOnSliceStartSend {
+    EVENT: string;
+    classInterval?: number | null;
+    data?: PLVStreamerSocketOnSliceStartData | null;
+    docType?: number | null;
+    emitMode?: number | null;
+    isNoCount?: number | null;
+    keepClass?: boolean | null;
+    pushtime?: number | null;
+    roomId?: string | null;
+    sessionId?: string | null;
+    streamName?: string | null;
+    timeStamp?: number | null;
+}
+export declare class PLVStreamerSocketOnSliceStartData {
+    autoId?: number | null;
+    isCamClosed?: number | null;
+    pageId?: number | null;
+    step?: number | null;
+}
+export declare class PLVStreamerSocketFinishClassSend {
+    EVENT: string;
+    channelId?: string | null;
+    clearPermission?: number | null;
+    roomId?: string | null;
+    userId?: string | null;
+}