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

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

@@ -0,0 +1,21 @@
+import { PLVSocketMessageEvent } from '../../../socket/model/PLVSocketEventConstants';
+export class PLVStreamerSocketOnSliceStartRecv {
+}
+export class PLVStreamerSocketOnSliceStartEventData {
+}
+export class PLVStreamerSocketOnSliceIDRecv {
+}
+export class PLVStreamerSocketOnSliceIDEventData {
+}
+export class PLVStreamerSocketOnSliceStartSend {
+    constructor() {
+        this.EVENT = PLVSocketMessageEvent.ON_SLICE_START;
+    }
+}
+export class PLVStreamerSocketOnSliceStartData {
+}
+export class PLVStreamerSocketFinishClassSend {
+    constructor() {
+        this.EVENT = PLVSocketMessageEvent.FINISH_CLASS;
+    }
+}

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

@@ -0,0 +1,14 @@
+export declare enum PLVStreamerState {
+    /**
+     * 直播未开始
+     */
+    NOT_START = 0,
+    /**
+     * 直播中
+     */
+    START = 1,
+    /**
+     * 直播结束
+     */
+    FINISH = 2
+}

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

@@ -0,0 +1,6 @@
+export var PLVStreamerState;
+(function (k186) {
+    k186[k186["NOT_START"] = 0] = "NOT_START";
+    k186[k186["START"] = 1] = "START";
+    k186[k186["FINISH"] = 2] = "FINISH";
+})(PLVStreamerState || (PLVStreamerState = {}));

package/src/main/ets/modules/streamer/viewmodel/PLVStreamerViewModel.d.ets

@@ -0,0 +1,20 @@
+import { PLVPushDowngradePreference, PLVPushOrientation } from '@polyvharmony/rtc-sdk';
+import { PLVLinkMicBitRate } from '../../linkmic/model/vo/PLVLinkMicBitRate';
+import { PLVLinkMicPushResolutionRatio } from '../../linkmic/model/vo/PLVLinkMicPushResolutionRatio';
+import { PLVStreamerRepo } from '../model/PLVStreamerRepo';
+import { PLVStreamerMixLayoutType } from '../model/vo/PLVStreamerMixLayoutType';
+import { PLVStreamerUseCases } from './usecase/PLVStreamerUseCases';
+export declare class PLVStreamerViewModel {
+    private readonly repo;
+    private readonly useCases;
+    constructor(a187: PLVStreamerRepo, b187: PLVStreamerUseCases);
+    init(): Promise<void>;
+    startStream(recover: boolean): Promise<void>;
+    finishStream(): void;
+    updateChannelName(name: string): Promise<void>;
+    setBitRate(bitRate: PLVLinkMicBitRate): void;
+    setPushResolutionRatio(y186: PLVLinkMicPushResolutionRatio): void;
+    setPushOrientation(x186: PLVPushOrientation): void;
+    setPushDowngradePreference(w186: PLVPushDowngradePreference): void;
+    setMixLayoutType(v186: PLVStreamerMixLayoutType): void;
+}

package/src/main/ets/modules/streamer/viewmodel/PLVStreamerViewModel.js

@@ -0,0 +1,53 @@
+import { PLVLogger } from '@polyvharmony/live-scenes-foundation';
+import { runCatching } from '@polyvharmony/media-player-sdk';
+import { PLVUserType } from '../../socket/model/PLVUserType';
+import { PLVStreamerErrorEvent } from '../model/vo/PLVStreamerErrorEvent';
+const TAG = 'PLVStreamerManager';
+export class PLVStreamerViewModel {
+    constructor(a187, b187) {
+        this.repo = a187;
+        this.useCases = b187;
+    }
+    async init() {
+        const role = this.repo.mediator.channelData?.viewerType;
+        if (role === undefined || ![PLVUserType.USERTYPE_TEACHER, PLVUserType.USERTYPE_GUEST].includes(role)) {
+            PLVLogger.info(TAG, `viewerType ${role} not match StreamerManager, stop init.`);
+            return;
+        }
+        await this.repo.init();
+        this.useCases.init();
+    }
+    async startStream(recover) {
+        await this.useCases.handleStateUseCase.startStream(recover);
+    }
+    finishStream() {
+        this.useCases.handleStateUseCase.finishStream();
+    }
+    async updateChannelName(name) {
+        const response = await runCatching(this.repo.updateChannelName(name));
+        if (response.success === true) {
+            const z186 = this.repo.mediator.channelData?.streamerData;
+            if (z186 !== undefined) {
+                z186.channelName = name;
+            }
+        }
+        else {
+            this.repo.mediator.reportError(PLVStreamerErrorEvent.UPDATE_CHANNEL_NAME_FAIL, response.error.message);
+        }
+    }
+    setBitRate(bitRate) {
+        this.repo.mediator.linkmicMediator.setBitRate?.(bitRate);
+    }
+    setPushResolutionRatio(y186) {
+        this.repo.mediator.linkmicMediator.setPushResolutionRatio?.(y186);
+    }
+    setPushOrientation(x186) {
+        this.repo.mediator.linkmicMediator.setPushOrientation?.(x186);
+    }
+    setPushDowngradePreference(w186) {
+        this.repo.mediator.linkmicMediator.setPushDowngradePreference?.(w186);
+    }
+    setMixLayoutType(v186) {
+        this.useCases.mixStreamUseCase.setMixLayoutType(v186);
+    }
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/PLVStreamerUseCases.d.ets

@@ -0,0 +1,8 @@
+import { StreamerHandleStateUseCase } from './StreamerHandleStateUseCase';
+import { StreamerMixStreamUseCase } from './StreamerMixStreamUseCase';
+export declare class PLVStreamerUseCases {
+    readonly handleStateUseCase: StreamerHandleStateUseCase;
+    readonly mixStreamUseCase: StreamerMixStreamUseCase;
+    constructor(c187: StreamerHandleStateUseCase, d187: StreamerMixStreamUseCase);
+    init(): void;
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/PLVStreamerUseCases.js

@@ -0,0 +1,10 @@
+export class PLVStreamerUseCases {
+    constructor(c187, d187) {
+        this.handleStateUseCase = c187;
+        this.mixStreamUseCase = d187;
+    }
+    init() {
+        this.handleStateUseCase.init();
+        this.mixStreamUseCase.init();
+    }
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/StreamerHandleStateUseCase.d.ets

@@ -0,0 +1,14 @@
+import { LifecycleAwareDependComponent } from '@polyvharmony/media-player-sdk';
+import { PLVStreamerRepo } from '../../model/PLVStreamerRepo';
+import { IStreamerHandleStateUseCase } from './roles/base/IStreamerHandleStateUseCase';
+import { StreamerMixStreamUseCase } from './StreamerMixStreamUseCase';
+export declare class StreamerHandleStateUseCase implements IStreamerHandleStateUseCase, LifecycleAwareDependComponent {
+    private readonly repo;
+    private readonly mixStreamUseCase;
+    private impl;
+    constructor(a189: PLVStreamerRepo, b189: StreamerMixStreamUseCase);
+    init(): void;
+    startStream(recover: boolean): Promise<void>;
+    finishStream(): void;
+    onDestroy(): void;
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/StreamerHandleStateUseCase.js

@@ -0,0 +1,31 @@
+import { PLVUserType } from '../../../socket/model/PLVUserType';
+import { StreamerGuestHandleStateUseCase } from './roles/guest/StreamerGuestHandleStateUseCase';
+import { StreamerTeacherHandleStateUseCase } from './roles/teacher/StreamerTeacherHandleStateUseCase';
+export class StreamerHandleStateUseCase {
+    constructor(a189, b189) {
+        this.impl = undefined;
+        this.repo = a189;
+        this.mixStreamUseCase = b189;
+    }
+    init() {
+        const z188 = this.repo.mediator.channelData?.viewerType;
+        if (z188 === PLVUserType.USERTYPE_TEACHER) {
+            this.impl = new StreamerTeacherHandleStateUseCase(this.repo, this.mixStreamUseCase);
+        }
+        else if (z188 === PLVUserType.USERTYPE_GUEST) {
+            this.impl = new StreamerGuestHandleStateUseCase(this.repo, this.mixStreamUseCase);
+        }
+        else {
+        }
+        this.impl?.init();
+    }
+    async startStream(recover) {
+        return this.impl?.startStream(recover);
+    }
+    finishStream() {
+        return this.impl?.finishStream();
+    }
+    onDestroy() {
+        this.impl?.onDestroy();
+    }
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/StreamerMixStreamUseCase.d.ets

@@ -0,0 +1,12 @@
+import { PLVStreamerRepo } from '../../model/PLVStreamerRepo';
+import { PLVStreamerMixLayoutType } from '../../model/vo/PLVStreamerMixLayoutType';
+import { IStreamerMixStreamUseCase } from './roles/base/IStreamerMixStreamUseCase';
+export declare class StreamerMixStreamUseCase implements IStreamerMixStreamUseCase {
+    private readonly repo;
+    private impl;
+    constructor(e189: PLVStreamerRepo);
+    init(): void;
+    startMix(): void;
+    stopMix(): void;
+    setMixLayoutType(c189: PLVStreamerMixLayoutType): void;
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/StreamerMixStreamUseCase.js

@@ -0,0 +1,30 @@
+import { StreamerTeacherMixStreamUseCase } from './roles/teacher/StreamerTeacherMixStreamUseCase';
+import { PLVUserType } from '../../../socket/model/PLVUserType';
+import { StreamerGuestMixStreamUseCase } from './roles/guest/StreamerGuestMixStreamUseCase';
+export class StreamerMixStreamUseCase {
+    constructor(e189) {
+        this.impl = undefined;
+        this.repo = e189;
+    }
+    init() {
+        const d189 = this.repo.mediator.channelData?.viewerType;
+        if (d189 === PLVUserType.USERTYPE_TEACHER) {
+            this.impl = new StreamerTeacherMixStreamUseCase(this.repo);
+        }
+        else if (d189 === PLVUserType.USERTYPE_GUEST) {
+            this.impl = new StreamerGuestMixStreamUseCase(this.repo);
+        }
+        else {
+        }
+        this.impl?.init();
+    }
+    startMix() {
+        this.impl?.startMix();
+    }
+    stopMix() {
+        this.impl?.stopMix();
+    }
+    setMixLayoutType(c189) {
+        this.impl?.setMixLayoutType(c189);
+    }
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/roles/base/IStreamerHandleStateUseCase.d.ets

@@ -0,0 +1,6 @@
+export interface IStreamerHandleStateUseCase {
+    init(): void;
+    startStream(recover: boolean): void;
+    finishStream(): void;
+    onDestroy(): void;
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/roles/base/IStreamerHandleStateUseCase.js

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

package/src/main/ets/modules/streamer/viewmodel/usecase/roles/base/IStreamerMixStreamUseCase.d.ets

@@ -0,0 +1,7 @@
+import { PLVStreamerMixLayoutType } from '../../../../model/vo/PLVStreamerMixLayoutType';
+export interface IStreamerMixStreamUseCase {
+    init(): void;
+    startMix(): void;
+    stopMix(): void;
+    setMixLayoutType(mixLayoutType: PLVStreamerMixLayoutType): void;
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/roles/base/IStreamerMixStreamUseCase.js

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

package/src/main/ets/modules/streamer/viewmodel/usecase/roles/guest/StreamerGuestHandleStateUseCase.d.ets

@@ -0,0 +1,23 @@
+import { PLVStreamerRepo } from '../../../../model/PLVStreamerRepo';
+import { IStreamerHandleStateUseCase } from '../base/IStreamerHandleStateUseCase';
+import { StreamerMixStreamUseCase } from '../../StreamerMixStreamUseCase';
+export declare class StreamerGuestHandleStateUseCase implements IStreamerHandleStateUseCase {
+    private readonly repo;
+    private readonly mixStreamUseCase;
+    private updateLiveStreamStatusIntervalTask;
+    private disposables;
+    constructor(t187: PLVStreamerRepo, u187: StreamerMixStreamUseCase);
+    init(): void;
+    startStream(recover: boolean): Promise<void>;
+    finishStream(): void;
+    private onSocketMessage;
+    private onSocketOnSliceStart;
+    private onSocketOnSliceID;
+    private onSocketFinishClass;
+    private startUpdateLiveStreamStatusIntervalTask;
+    private updateLiveStreamStatus;
+    private stopUpdateLiveStreamStatusIntervalTask;
+    onDestroy(): void;
+    private onChangeLiveStreamStatus;
+    private observeSocketEvent;
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/roles/guest/StreamerGuestHandleStateUseCase.js

@@ -0,0 +1,109 @@
+import { PLVStreamerState } from '../../../../model/vo/PLVStreamerState';
+import { PLVSocketMessageEvent, PLVSocketOnEvent } from '../../../../../socket/model/PLVSocketEventConstants';
+import { PLVDisposable, PLVScheduledTask } from '@polyvharmony/live-scenes-foundation';
+import { decodeFromJson, isNullOrUndefined, requireNotNull, runCatching, seconds } from '@polyvharmony/media-player-sdk';
+import { PLVStreamerSocketOnSliceIDRecv, PLVStreamerSocketOnSliceStartRecv } from '../../../../model/vo/PLVStreamerSocketEvent';
+export class StreamerGuestHandleStateUseCase {
+    constructor(t187, u187) {
+        this.updateLiveStreamStatusIntervalTask = null;
+        this.disposables = [];
+        this.repo = t187;
+        this.mixStreamUseCase = u187;
+    }
+    init() {
+        this.disposables.push(this.observeSocketEvent(PLVSocketOnEvent.MESSAGE, (data, event) => this.onSocketMessage(data, event)));
+    }
+    async startStream(recover) {
+        this.repo.mediator.linkmicMediator.onStreamerStart?.();
+        this.startUpdateLiveStreamStatusIntervalTask();
+    }
+    finishStream() {
+        this.stopUpdateLiveStreamStatusIntervalTask();
+        this.repo.mediator.linkmicMediator.onStreamerStop?.();
+    }
+    onSocketMessage(data, event) {
+        switch (event) {
+            case PLVSocketMessageEvent.ON_SLICE_START: return this.onSocketOnSliceStart(data);
+            case PLVSocketMessageEvent.ON_SLICE_ID: return this.onSocketOnSliceID(data);
+            case PLVSocketMessageEvent.FINISH_CLASS: return this.onSocketFinishClass(data);
+            default:
+        }
+    }
+    onSocketOnSliceStart(data) {
+        const r187 = decodeFromJson(data, PLVStreamerSocketOnSliceStartRecv);
+        const startTime = r187.pushtime ?? Date.now();
+        this.repo.mediator.liveStartTimestamp.setValue(startTime);
+        this.onChangeLiveStreamStatus(PLVStreamerState.START);
+    }
+    onSocketOnSliceID(data) {
+        const q187 = decodeFromJson(data, PLVStreamerSocketOnSliceIDRecv);
+        const startTime = q187.data?.pushtime ?? Date.now();
+        this.repo.mediator.liveStartTimestamp.setValue(startTime);
+    }
+    onSocketFinishClass(data) {
+        this.onChangeLiveStreamStatus(PLVStreamerState.NOT_START);
+    }
+    startUpdateLiveStreamStatusIntervalTask() {
+        this.stopUpdateLiveStreamStatusIntervalTask();
+        this.updateLiveStreamStatusIntervalTask = new PLVScheduledTask(() => {
+            this.updateLiveStreamStatus();
+        }, 0, seconds(10).toMillis());
+        this.updateLiveStreamStatusIntervalTask.start();
+    }
+    async updateLiveStreamStatus() {
+        const stream = this.repo.mediator.channelData?.streamerData?.currentStream;
+        if (isNullOrUndefined(stream)) {
+            return;
+        }
+        const n187 = await runCatching(this.repo.getLiveStatusSessionId(stream));
+        if (n187.success === false) {
+            return;
+        }
+        const o187 = n187.data.status === "live";
+        this.onChangeLiveStreamStatus(o187 ? PLVStreamerState.START : PLVStreamerState.NOT_START);
+    }
+    stopUpdateLiveStreamStatusIntervalTask() {
+        this.updateLiveStreamStatusIntervalTask?.cancel();
+        this.updateLiveStreamStatusIntervalTask = null;
+    }
+    onDestroy() {
+        this.stopUpdateLiveStreamStatusIntervalTask();
+        this.disposables.forEach((m187) => {
+            m187.dispose();
+        });
+        this.disposables = [];
+    }
+    onChangeLiveStreamStatus(i187) {
+        const j187 = this.repo.mediator.streamerState.value === PLVStreamerState.START;
+        const k187 = i187 === PLVStreamerState.START;
+        if (this.repo.mediator.streamerState.value !== i187) {
+            this.repo.mediator.streamerState.setValue(i187);
+        }
+        if (j187 !== k187) {
+            if (k187) {
+                this.repo.mediator.linkmicMediator.onLiveStreamStart?.();
+            }
+            else {
+                this.repo.mediator.linkmicMediator.onLiveStreamStop?.();
+            }
+        }
+    }
+    observeSocketEvent(event, callback) {
+        const g187 = requireNotNull(this.repo.mediator.socketMediator);
+        g187.onData(event, callback);
+        return disposable(() => g187.offData(event, callback));
+    }
+}
+class SocketDisposable extends PLVDisposable {
+    constructor(f187) {
+        super();
+        this.onDispose = f187;
+    }
+    dispose() {
+        super.dispose();
+        this.onDispose?.();
+    }
+}
+function disposable(e187) {
+    return new SocketDisposable(e187);
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/roles/guest/StreamerGuestMixStreamUseCase.d.ets

@@ -0,0 +1,11 @@
+import { PLVStreamerRepo } from '../../../../model/PLVStreamerRepo';
+import { PLVStreamerMixLayoutType } from '../../../../model/vo/PLVStreamerMixLayoutType';
+import { IStreamerMixStreamUseCase } from '../base/IStreamerMixStreamUseCase';
+export declare class StreamerGuestMixStreamUseCase implements IStreamerMixStreamUseCase {
+    private readonly repo;
+    constructor(w187: PLVStreamerRepo);
+    init(): void;
+    startMix(): void;
+    stopMix(): void;
+    setMixLayoutType(v187: PLVStreamerMixLayoutType): void;
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/roles/guest/StreamerGuestMixStreamUseCase.js

@@ -0,0 +1,13 @@
+export class StreamerGuestMixStreamUseCase {
+    constructor(w187) {
+        this.repo = w187;
+    }
+    init() {
+    }
+    startMix() {
+    }
+    stopMix() {
+    }
+    setMixLayoutType(v187) {
+    }
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/roles/teacher/StreamerTeacherHandleStateUseCase.d.ets

@@ -0,0 +1,14 @@
+import { PLVStreamerRepo } from '../../../../model/PLVStreamerRepo';
+import { IStreamerHandleStateUseCase } from '../base/IStreamerHandleStateUseCase';
+import { StreamerMixStreamUseCase } from '../../StreamerMixStreamUseCase';
+export declare class StreamerTeacherHandleStateUseCase implements IStreamerHandleStateUseCase {
+    private readonly repo;
+    private readonly mixStreamUseCase;
+    constructor(e188: PLVStreamerRepo, f188: StreamerMixStreamUseCase);
+    init(): void;
+    startStream(recover: boolean): Promise<void>;
+    finishStream(): void;
+    private emitSocketOnSliceStart;
+    private emitSocketFinishClass;
+    onDestroy(): void;
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/roles/teacher/StreamerTeacherHandleStateUseCase.js

@@ -0,0 +1,75 @@
+import { encodeToJson, requireNotNull, runCatching } from '@polyvharmony/media-player-sdk';
+import { PLVPushOrientation } from '@polyvharmony/rtc-sdk';
+import { PLVStreamerErrorEvent } from '../../../../model/vo/PLVStreamerErrorEvent';
+import { PLVStreamerState } from '../../../../model/vo/PLVStreamerState';
+import { PLVStreamerSocketFinishClassSend, PLVStreamerSocketOnSliceStartData, PLVStreamerSocketOnSliceStartSend } from '../../../../model/vo/PLVStreamerSocketEvent';
+import { PLVSocketOnEvent } from '../../../../../socket/model/PLVSocketEventConstants';
+export class StreamerTeacherHandleStateUseCase {
+    constructor(e188, f188) {
+        this.repo = e188;
+        this.mixStreamUseCase = f188;
+    }
+    init() {
+    }
+    async startStream(recover) {
+        const stream = requireNotNull(this.repo.mediator.channelData?.streamerData?.stream);
+        const a188 = requireNotNull(this.repo.mediator.linkmicMediator.currentBitRateEncodeParam.value);
+        const b188 = this.repo.mediator.linkmicMediator.currentPushOrientation.value !== PLVPushOrientation.LANDSCAPE;
+        const width = b188 ? a188.videoHeight : a188.videoWidth;
+        const height = b188 ? a188.videoWidth : a188.videoHeight;
+        this.repo.mediator.linkmicMediator.onStreamerStart?.();
+        const c188 = await runCatching(this.repo.notifyStreamStart(stream, recover, width, height));
+        if (c188.success === false) {
+            this.repo.mediator.reportError(PLVStreamerErrorEvent.STREAMER_START_FAIL, c188.error.message);
+            return;
+        }
+        this.mixStreamUseCase.startMix();
+        const d188 = await runCatching(this.repo.getStreamerSessionId(stream));
+        if (d188.success === false) {
+            this.repo.mediator.reportError(PLVStreamerErrorEvent.GET_SESSION_ID_FAIL, d188.error.message);
+            return;
+        }
+        this.emitSocketOnSliceStart();
+        requireNotNull(this.repo.mediator.channelData).sessionId = d188.data;
+        this.repo.mediator.streamerState.setValue(PLVStreamerState.START);
+        this.repo.mediator.liveStartTimestamp.setValue(Date.now());
+    }
+    finishStream() {
+        const stream = requireNotNull(this.repo.mediator.channelData?.streamerData?.stream);
+        runCatching(this.repo.notifyStreamEnd(stream));
+        runCatching(() => this.repo.mediator.linkmicMediator.onStreamerStop?.());
+        runCatching(() => this.emitSocketFinishClass());
+        runCatching(() => this.mixStreamUseCase.stopMix());
+        this.repo.mediator.streamerState.setValue(PLVStreamerState.FINISH);
+    }
+    emitSocketOnSliceStart() {
+        const event = new PLVStreamerSocketOnSliceStartSend();
+        event.classInterval = 0;
+        const data = new PLVStreamerSocketOnSliceStartData();
+        data.autoId = 0;
+        data.isCamClosed = 0;
+        data.pageId = 0;
+        data.step = 0;
+        event.data = data;
+        event.docType = 1;
+        event.emitMode = 0;
+        event.isNoCount = 0;
+        event.keepClass = false;
+        event.pushtime = Date.now();
+        event.roomId = this.repo.mediator.channelData?.loginChannelId;
+        event.sessionId = this.repo.mediator.channelData?.sessionId;
+        event.streamName = this.repo.mediator.channelData?.streamerData?.stream;
+        event.timeStamp = 0;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(event));
+    }
+    emitSocketFinishClass() {
+        const event = new PLVStreamerSocketFinishClassSend();
+        event.channelId = this.repo.mediator.channelData?.loginChannelId;
+        event.clearPermission = 0;
+        event.roomId = this.repo.mediator.channelData?.loginChannelId;
+        event.userId = this.repo.mediator.channelData?.viewerId;
+        this.repo.mediator.socketMediator?.emit(PLVSocketOnEvent.MESSAGE, encodeToJson(event));
+    }
+    onDestroy() {
+    }
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/roles/teacher/StreamerTeacherMixStreamUseCase.d.ets

@@ -0,0 +1,20 @@
+import { PLVStreamerRepo } from '../../../../model/PLVStreamerRepo';
+import { PLVStreamerMixLayoutType } from '../../../../model/vo/PLVStreamerMixLayoutType';
+import { IStreamerMixStreamUseCase } from '../base/IStreamerMixStreamUseCase';
+export declare class StreamerTeacherMixStreamUseCase implements IStreamerMixStreamUseCase {
+    private readonly repo;
+    constructor(y188: PLVStreamerRepo);
+    private readonly mixActionDebounce;
+    private readonly mixAction;
+    private updateMixObserver;
+    init(): void;
+    startMix(): void;
+    private observeUpdateMix;
+    stopMix(): void;
+    setMixLayoutType(s188: PLVStreamerMixLayoutType): void;
+    private readMixEncodeParam;
+    private readMixLayoutType;
+    private readMixUserList;
+    private isPortrait;
+    private sendMixAction;
+}

package/src/main/ets/modules/streamer/viewmodel/usecase/roles/teacher/StreamerTeacherMixStreamUseCase.js

@@ -0,0 +1,133 @@
+import { copyPartial, delay, DerivedState, encodeToJson, requireNotNull, retry, runCatching, seconds } from '@polyvharmony/media-player-sdk';
+import { MixAction, MixEncodeParam, MixInputType, MixOutputParam, MixPublishCdnParam, MixRenderMode, MixStreamType, MixUser, PLVStreamerMixActionVO } from '../../../../model/vo/PLVStreamerMixActionVO';
+import { PLVStreamerMixLayoutType } from '../../../../model/vo/PLVStreamerMixLayoutType';
+import display from "@ohos.display";
+import { PLVPushOrientation } from '@polyvharmony/rtc-sdk';
+export class StreamerTeacherMixStreamUseCase {
+    constructor(y188) {
+        this.mixActionDebounce = new AwaitDebounce();
+        this.mixAction = new PLVStreamerMixActionVO();
+        this.updateMixObserver = null;
+        this.repo = y188;
+    }
+    init() {
+        const w188 = new MixOutputParam();
+        w188.streamId = this.repo.mediator.channelData?.streamerData?.stream;
+        w188.pureAudioStream = 0;
+        this.mixAction.outputParam = w188;
+        const x188 = new MixPublishCdnParam();
+        x188.cdnUrl = this.repo.mediator.channelData?.pushStreamUrl;
+        this.mixAction.publishCdnParam = x188;
+    }
+    startMix() {
+        this.mixAction.action = MixAction.START;
+        this.mixAction.roomId = this.repo.mediator.channelData?.loginChannelId;
+        this.mixAction.encodeParam = this.readMixEncodeParam();
+        this.mixAction.mixLayoutType = this.readMixLayoutType();
+        const v188 = new MixUser();
+        v188.userId = this.repo.mediator.channelData?.viewerId;
+        v188.streamType = MixStreamType.CAMERA;
+        v188.mixInputType = MixInputType.VIDEO_AUDIO;
+        v188.renderMode = MixRenderMode.FILL;
+        this.mixAction.userList = [v188];
+        this.sendMixAction();
+        this.observeUpdateMix();
+    }
+    observeUpdateMix() {
+        this.updateMixObserver?.dispose();
+        this.updateMixObserver = new DerivedState(() => {
+            if (this.mixAction.action === MixAction.START) {
+                this.mixAction.action = MixAction.UPDATE;
+            }
+            if (this.mixAction.action !== MixAction.UPDATE) {
+                return null;
+            }
+            this.mixAction.encodeParam = this.readMixEncodeParam();
+            this.mixAction.userList = this.readMixUserList();
+            this.mixAction.mixLayoutType = this.readMixLayoutType();
+            return encodeToJson(this.mixAction);
+        }).observe(value => {
+            if (value !== null) {
+                this.sendMixAction();
+            }
+        });
+    }
+    stopMix() {
+        this.updateMixObserver?.dispose();
+        this.updateMixObserver = null;
+        this.mixAction.action = MixAction.END;
+        this.mixAction.userList = [];
+        this.sendMixAction();
+    }
+    setMixLayoutType(s188) {
+        if (this.repo.mediator.mixLayoutType.value === s188) {
+            return;
+        }
+        this.repo.setMixLayoutType(s188);
+    }
+    readMixEncodeParam() {
+        const o188 = new MixEncodeParam();
+        const p188 = requireNotNull(this.repo.mediator.linkmicMediator.currentBitRateEncodeParam.value);
+        const q188 = this.repo.mediator.linkmicMediator.currentPushOrientation.value;
+        const r188 = (q188 === PLVPushOrientation.AUTO && this.isPortrait()) || q188 === PLVPushOrientation.PORTRAIT;
+        o188.audioSampleRate = 48000;
+        o188.audioBitrate = 64;
+        o188.audioChannels = 2;
+        o188.videoWidth = !r188 ? p188.videoWidth : p188.videoHeight;
+        o188.videoHeight = !r188 ? p188.videoHeight : p188.videoWidth;
+        o188.videoBitrate = p188.videoBitrate;
+        o188.videoFramerate = p188.videoFps;
+        o188.videoGop = p188.videoGop;
+        return o188;
+    }
+    readMixLayoutType() {
+        return this.repo.mediator.mixLayoutType.value ?? PLVStreamerMixLayoutType.TILE;
+    }
+    readMixUserList() {
+        const k188 = this.repo.mediator.linkmicMediator.channelLinkMicViewers.value ?? [];
+        return k188.map(m188 => {
+            const n188 = new MixUser();
+            n188.userId = m188.linkmicId;
+            n188.streamType = MixStreamType.CAMERA;
+            n188.renderMode = MixRenderMode.FILL;
+            n188.mixInputType = MixInputType.VIDEO_AUDIO;
+            return n188;
+        });
+    }
+    isPortrait() {
+        const orientation = display.getDefaultDisplaySync().orientation;
+        return orientation === display.Orientation.PORTRAIT || orientation === display.Orientation.PORTRAIT_INVERTED;
+    }
+    sendMixAction() {
+        const action = copyPartial(this.mixAction, {});
+        this.mixActionDebounce.run(async () => {
+            await runCatching(retry(() => this.repo.sendMixAction(action), async (e, j188) => {
+                if (j188 >= 3) {
+                    return false;
+                }
+                await delay(seconds(3).toMillis());
+                return true;
+            }));
+        });
+    }
+}
+class AwaitDebounce {
+    constructor() {
+        this.taskRunning = null;
+        this.taskPending = null;
+    }
+    async run(task) {
+        if (this.taskRunning !== null) {
+            this.taskPending = task;
+            return;
+        }
+        this.taskRunning = task;
+        await this.taskRunning();
+        this.taskRunning = null;
+        if (this.taskPending !== null) {
+            const pending = this.taskPending;
+            this.taskPending = null;
+            this.run(pending);
+        }
+    }
+}